doc/regexprops-generic.texi

   1 @c Copyright (C) 1994, 1996, 1998, 2000-2001, 2003-2007, 2009-2018 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, no Front-Cover Texts, and 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 supported; for example @samp{[[:digit:]]} will match a single decimal 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.
  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 invalid.  Within square brackets, @samp{\} is taken literally.  Character classes are supported; for example @samp{[[:digit:]]} will match a single decimal digit.
  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{()}.  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{(}.
 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 Intervals are specified by @samp{@{} and @samp{@}}.  Invalid intervals are treated as literals, for example @samp{a@{1} is treated as @samp{a\@{1}
 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 Intervals are specified by @samp{@{} and @samp{@}}.  Invalid intervals are treated as literals, for example @samp{a@{1} is treated as @samp{a\@{1}
 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.
 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 invalid.  Within square brackets, @samp{\} is taken literally.  Character classes are supported; for example @samp{[[:digit:]]} will match a single decimal digit.
 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 are treated as literals, for example @samp{a@{1} is treated as @samp{a\@{1}
 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 This is a synonym for egrep.
 527 @node posix-extended regular expression syntax
 528 @subsection @samp{posix-extended} regular expression syntax
 529
 530
 531 The character @samp{.} matches any single character except the null character.
 532
 533
 534 @table @samp
 535
 536 @item +
 537 indicates that the regular expression should match one or more occurrences of the previous atom or regexp.
 538 @item ?
 539 indicates that the regular expression should match zero or one occurrence of the previous atom or regexp.
 540 @item \+
 541 matches a @samp{+}
 542 @item \?
 543 matches a @samp{?}.
 544 @end table
 545
 546
 547 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.
 548
 549 GNU extensions are supported:
 550 @enumerate
 551
 552 @item @samp{\w} matches a character within a word
 553
 554 @item @samp{\W} matches a character which is not within a word
 555
 556 @item @samp{\<} matches the beginning of a word
 557
 558 @item @samp{\>} matches the end of a word
 559
 560 @item @samp{\b} matches a word boundary
 561
 562 @item @samp{\B} matches characters which are not a word boundary
 563
 564 @item @samp{\`} matches the beginning of the whole input
 565
 566 @item @samp{\'} matches the end of the whole input
 567
 568 @end enumerate
 569
 570
 571 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{(}.
 572
 573 The alternation operator is @samp{|}.
 574
 575 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.
 576
 577 @samp{*}, @samp{+} and @samp{?} are special at any point in a regular expression except the following places, where they are not allowed:
 578 @enumerate
 579
 580 @item At the beginning of a regular expression
 581
 582 @item After an open-group, signified by
 583 @samp{(}
 584 @item After the alternation operator @samp{|}
 585
 586 @end enumerate
 587
 588
 589 Intervals are specified by @samp{@{} and @samp{@}}.  Invalid intervals such as @samp{a@{1z} are not accepted.
 590
 591 The longest possible match is returned; this applies to the regular expression as a whole and (subject to this constraint) to subexpressions within groups.
 592
 593
 594 @node posix-minimal-basic regular expression syntax
 595 @subsection @samp{posix-minimal-basic} regular expression syntax
 596
 597
 598 The character @samp{.} matches any single character except the null character.
 599
 600
 601
 602 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.
 603
 604 GNU extensions are supported:
 605 @enumerate
 606
 607 @item @samp{\w} matches a character within a word
 608
 609 @item @samp{\W} matches a character which is not within a word
 610
 611 @item @samp{\<} matches the beginning of a word
 612
 613 @item @samp{\>} matches the end of a word
 614
 615 @item @samp{\b} matches a word boundary
 616
 617 @item @samp{\B} matches characters which are not a word boundary
 618
 619 @item @samp{\`} matches the beginning of the whole input
 620
 621 @item @samp{\'} matches the end of the whole input
 622
 623 @end enumerate
 624
 625
 626 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{\(}.
 627
 628
 629
 630 The character @samp{^} only represents the beginning of a string when it appears:
 631 @enumerate
 632
 633 @item
 634 At the beginning of a regular expression
 635
 636 @item After an open-group, signified by
 637 @samp{\(}
 638
 639 @end enumerate
 640
 641
 642 The character @samp{$} only represents the end of a string when it appears:
 643 @enumerate
 644
 645 @item At the end of a regular expression
 646
 647 @item Before a close-group, signified by
 648 @samp{\)}
 649 @end enumerate
 650
 651
 652
 653
 654 Intervals are specified by @samp{\@{} and @samp{\@}}.  Invalid intervals such as @samp{a\@{1z} are not accepted.
 655
 656 The longest possible match is returned; this applies to the regular expression as a whole and (subject to this constraint) to subexpressions within groups.
 657
 658
 659 @node sed regular expression syntax
 660 @subsection @samp{sed} regular expression syntax
 661 This is a synonym for ed.