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
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953
1954
1955
1956
1957
1958
1959
1960
1961
1962
1963
1964
1965
1966
1967
1968
1969
1970
1971
1972
1973
1974
1975
1976
1977
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054
2055
2056
2057
2058
2059
2060
2061
2062
2063
2064
2065
2066
2067
2068
2069
2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086
2087
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100
2101
2102
2103
2104
2105
2106
2107
2108
2109
2110
2111
2112
2113
2114
2115
2116
2117
2118
2119
2120
2121
2122
2123
2124
2125
2126
2127
2128
2129
2130
2131
2132
2133
2134
2135
2136
2137
2138
2139
2140
2141
2142
2143
2144
2145
2146
2147
2148
2149
2150
2151
2152
2153
2154
2155
2156
2157
2158
2159
2160
2161
2162
2163
2164
2165
2166
2167
2168
2169
2170
2171
2172
2173
2174
2175
2176
2177
2178
2179
2180
2181
2182
2183
2184
2185
2186
2187
2188
2189
2190
2191
2192
2193
2194
2195
2196
2197
2198
2199
2200
2201
2202
2203
2204
2205
2206
2207
2208
2209
2210
2211
2212
2213
2214
2215
2216
2217
2218
2219
2220
2221
2222
2223
2224
2225
2226
2227
2228
2229
2230
2231
2232
2233
2234
2235
2236
2237
2238
2239
2240
2241
2242
2243
2244
2245
2246
2247
2248
2249
2250
2251
2252
2253
2254
2255
2256
2257
2258
2259
2260
2261
2262
2263
2264
2265
2266
2267
2268
2269
2270
2271
2272
2273
2274
2275
2276
2277
2278
2279
2280
2281
2282
2283
2284
2285
2286
2287
2288
2289
2290
2291
2292
2293
2294
2295
2296
2297
2298
2299
2300
2301
2302
2303
2304
2305
2306
2307
2308
2309
2310
2311
2312
2313
2314
2315
2316
2317
2318
2319
2320
2321
2322
2323
2324
2325
2326
2327
2328
2329
2330
2331
2332
2333
2334
2335
2336
2337
2338
2339
2340
2341
2342
2343
2344
2345
2346
2347
2348
2349
2350
2351
2352
2353
2354
2355
2356
2357
2358
2359
2360
2361
2362
2363
2364
2365
2366
2367
2368
2369
2370
2371
2372
2373
2374
2375
2376
2377
2378
2379
2380
2381
2382
2383
2384
2385
2386
2387
2388
2389
2390
2391
2392
2393
2394
2395
2396
2397
2398
2399
2400
2401
2402
2403
2404
2405
2406
2407
2408
2409
2410
2411
2412
2413
2414
2415
2416
2417
2418
2419
2420
2421
2422
2423
2424
2425
2426
2427
2428
2429
2430
2431
2432
2433
2434
2435
2436
2437
2438
2439
2440
2441
2442
2443
2444
2445
2446
2447
2448
2449
2450
2451
2452
2453
2454
2455
2456
2457
2458
2459
2460
2461
2462
2463
2464
2465
2466
2467
2468
2469
2470
2471
2472
2473
2474
2475
2476
2477
2478
2479
2480
2481
2482
2483
2484
2485
2486
2487
2488
2489
2490
2491
2492
2493
2494
2495
2496
2497
2498
2499
2500
2501
2502
2503
2504
2505
2506
2507
2508
2509
2510
2511
2512
2513
2514
2515
2516
2517
2518
2519
2520
2521
2522
2523
2524
2525
2526
2527
2528
2529
2530
2531
2532
2533
2534
2535
2536
2537
2538
2539
2540
2541
2542
2543
2544
2545
2546
2547
2548
2549
2550
2551
2552
2553
2554
2555
2556
2557
2558
2559
2560
2561
2562
2563
2564
2565
2566
2567
2568
2569
2570
2571
2572
2573
2574
2575
2576
2577
2578
2579
2580
2581
2582
2583
2584
2585
2586
2587
2588
2589
2590
2591
2592
2593
2594
2595
2596
2597
2598
2599
2600
2601
2602
2603
| | @c -*-texinfo-*-
@c This is part of the GNU Emacs Lisp Reference Manual.
@c Copyright (C) 1990-1995, 1998-1999, 2001-2019 Free Software
@c Foundation, Inc.
@c See the file elisp.texi for copying conditions.
@node Searching and Matching
@chapter Searching and Matching
@cindex searching
GNU Emacs provides two ways to search through a buffer for specified
text: exact string searches and regular expression searches. After a
regular expression search, you can examine the @dfn{match data} to
determine which text matched the whole regular expression or various
portions of it.
@menu
* String Search:: Search for an exact match.
* Searching and Case:: Case-independent or case-significant searching.
* Regular Expressions:: Describing classes of strings.
* Regexp Search:: Searching for a match for a regexp.
* POSIX Regexps:: Searching POSIX-style for the longest match.
* Match Data:: Finding out which part of the text matched,
after a string or regexp search.
* Search and Replace:: Commands that loop, searching and replacing.
* Standard Regexps:: Useful regexps for finding sentences, pages,...
@end menu
The @samp{skip-chars@dots{}} functions also perform a kind of searching.
@xref{Skipping Characters}. To search for changes in character
properties, see @ref{Property Search}.
@node String Search
@section Searching for Strings
@cindex string search
These are the primitive functions for searching through the text in a
buffer. They are meant for use in programs, but you may call them
interactively. If you do so, they prompt for the search string; the
arguments @var{limit} and @var{noerror} are @code{nil}, and @var{repeat}
is 1. For more details on interactive searching, @pxref{Search,,
Searching and Replacement, emacs, The GNU Emacs Manual}.
These search functions convert the search string to multibyte if the
buffer is multibyte; they convert the search string to unibyte if the
buffer is unibyte. @xref{Text Representations}.
@deffn Command search-forward string &optional limit noerror count
This function searches forward from point for an exact match for
@var{string}. If successful, it sets point to the end of the occurrence
found, and returns the new value of point. If no match is found, the
value and side effects depend on @var{noerror} (see below).
In the following example, point is initially at the beginning of the
line. Then @code{(search-forward "fox")} moves point after the last
letter of @samp{fox}:
@example
@group
---------- Buffer: foo ----------
@point{}The quick brown fox jumped over the lazy dog.
---------- Buffer: foo ----------
@end group
@group
(search-forward "fox")
@result{} 20
---------- Buffer: foo ----------
The quick brown fox@point{} jumped over the lazy dog.
---------- Buffer: foo ----------
@end group
@end example
The argument @var{limit} specifies the bound to the search, and should
be a position in the current buffer. No match extending after
that position is accepted. If @var{limit} is omitted or @code{nil}, it
defaults to the end of the accessible portion of the buffer.
@kindex search-failed
What happens when the search fails depends on the value of
@var{noerror}. If @var{noerror} is @code{nil}, a @code{search-failed}
error is signaled. If @var{noerror} is @code{t}, @code{search-forward}
returns @code{nil} and does nothing. If @var{noerror} is neither
@code{nil} nor @code{t}, then @code{search-forward} moves point to the
upper bound and returns @code{nil}.
@c I see no prospect of this ever changing, and frankly the current
@c behavior seems better, so there seems no need to mention this.
@ignore
(It would be more consistent now to return the new position of point
in that case, but some existing programs may depend on a value of
@code{nil}.)
@end ignore
The argument @var{noerror} only affects valid searches which fail to
find a match. Invalid arguments cause errors regardless of
@var{noerror}.
If @var{count} is a positive number @var{n}, the search is done
@var{n} times; each successive search starts at the end of the
previous match. If all these successive searches succeed, the
function call succeeds, moving point and returning its new value.
Otherwise the function call fails, with results depending on the value
of @var{noerror}, as described above. If @var{count} is a negative
number @minus{}@var{n}, the search is done @var{n} times in the opposite
(backward) direction.
@end deffn
@deffn Command search-backward string &optional limit noerror count
This function searches backward from point for @var{string}. It is
like @code{search-forward}, except that it searches backwards rather
than forwards. Backward searches leave point at the beginning of the
match.
@end deffn
@deffn Command word-search-forward string &optional limit noerror count
This function searches forward from point for a word match for
@var{string}. If it finds a match, it sets point to the end of the
match found, and returns the new value of point.
Word matching regards @var{string} as a sequence of words, disregarding
punctuation that separates them. It searches the buffer for the same
sequence of words. Each word must be distinct in the buffer (searching
for the word @samp{ball} does not match the word @samp{balls}), but the
details of punctuation and spacing are ignored (searching for @samp{ball
boy} does match @samp{ball. Boy!}).
In this example, point is initially at the beginning of the buffer; the
search leaves it between the @samp{y} and the @samp{!}.
@example
@group
---------- Buffer: foo ----------
@point{}He said "Please! Find
the ball boy!"
---------- Buffer: foo ----------
@end group
@group
(word-search-forward "Please find the ball, boy.")
@result{} 39
---------- Buffer: foo ----------
He said "Please! Find
the ball boy@point{}!"
---------- Buffer: foo ----------
@end group
@end example
If @var{limit} is non-@code{nil}, it must be a position in the current
buffer; it specifies the upper bound to the search. The match found
must not extend after that position.
If @var{noerror} is @code{nil}, then @code{word-search-forward} signals
an error if the search fails. If @var{noerror} is @code{t}, then it
returns @code{nil} instead of signaling an error. If @var{noerror} is
neither @code{nil} nor @code{t}, it moves point to @var{limit} (or the
end of the accessible portion of the buffer) and returns @code{nil}.
If @var{count} is a positive number, it specifies how many successive
occurrences to search for. Point is positioned at the end of the last
match. If @var{count} is a negative number, the search is backward
and point is positioned at the beginning of the last match.
@findex word-search-regexp
Internally, @code{word-search-forward} and related functions use the
function @code{word-search-regexp} to convert @var{string} to a
regular expression that ignores punctuation.
@end deffn
@deffn Command word-search-forward-lax string &optional limit noerror count
This command is identical to @code{word-search-forward}, except that
the beginning or the end of @var{string} need not match a word
boundary, unless @var{string} begins or ends in whitespace.
For instance, searching for @samp{ball boy} matches @samp{ball boyee},
but does not match @samp{balls boy}.
@end deffn
@deffn Command word-search-backward string &optional limit noerror count
This function searches backward from point for a word match to
@var{string}. This function is just like @code{word-search-forward}
except that it searches backward and normally leaves point at the
beginning of the match.
@end deffn
@deffn Command word-search-backward-lax string &optional limit noerror count
This command is identical to @code{word-search-backward}, except that
the beginning or the end of @var{string} need not match a word
boundary, unless @var{string} begins or ends in whitespace.
@end deffn
@node Searching and Case
@section Searching and Case
@cindex searching and case
By default, searches in Emacs ignore the case of the text they are
searching through; if you specify searching for @samp{FOO}, then
@samp{Foo} or @samp{foo} is also considered a match. This applies to
regular expressions, too; thus, @samp{[aB]} would match @samp{a} or
@samp{A} or @samp{b} or @samp{B}.
If you do not want this feature, set the variable
@code{case-fold-search} to @code{nil}. Then all letters must match
exactly, including case. This is a buffer-local variable; altering the
variable affects only the current buffer. (@xref{Intro to
Buffer-Local}.) Alternatively, you may change the default value.
In Lisp code, you will more typically use @code{let} to bind
@code{case-fold-search} to the desired value.
Note that the user-level incremental search feature handles case
distinctions differently. When the search string contains only lower
case letters, the search ignores case, but when the search string
contains one or more upper case letters, the search becomes
case-sensitive. But this has nothing to do with the searching
functions used in Lisp code. @xref{Incremental Search,,, emacs,
The GNU Emacs Manual}.
@defopt case-fold-search
This buffer-local variable determines whether searches should ignore
case. If the variable is @code{nil} they do not ignore case; otherwise
(and by default) they do ignore case.
@end defopt
@defopt case-replace
This variable determines whether the higher-level replacement
functions should preserve case. If the variable is @code{nil}, that
means to use the replacement text verbatim. A non-@code{nil} value
means to convert the case of the replacement text according to the
text being replaced.
This variable is used by passing it as an argument to the function
@code{replace-match}. @xref{Replacing Match}.
@end defopt
@node Regular Expressions
@section Regular Expressions
@cindex regular expression
@cindex regexp
A @dfn{regular expression}, or @dfn{regexp} for short, is a pattern that
denotes a (possibly infinite) set of strings. Searching for matches for
a regexp is a very powerful operation. This section explains how to write
regexps; the following section says how to search for them.
@findex re-builder
@cindex regular expressions, developing
For interactive development of regular expressions, you
can use the @kbd{M-x re-builder} command. It provides a convenient
interface for creating regular expressions, by giving immediate visual
feedback in a separate buffer. As you edit the regexp, all its
matches in the target buffer are highlighted. Each parenthesized
sub-expression of the regexp is shown in a distinct face, which makes
it easier to verify even very complex regexps.
@menu
* Syntax of Regexps:: Rules for writing regular expressions.
* Regexp Example:: Illustrates regular expression syntax.
* Rx Notation:: An alternative, structured regexp notation.
* Regexp Functions:: Functions for operating on regular expressions.
@end menu
@node Syntax of Regexps
@subsection Syntax of Regular Expressions
@cindex regexp syntax
@cindex syntax of regular expressions
Regular expressions have a syntax in which a few characters are
special constructs and the rest are @dfn{ordinary}. An ordinary
character is a simple regular expression that matches that character
and nothing else. The special characters are @samp{.}, @samp{*},
@samp{+}, @samp{?}, @samp{[}, @samp{^}, @samp{$}, and @samp{\}; no new
special characters will be defined in the future. The character
@samp{]} is special if it ends a character alternative (see later).
The character @samp{-} is special inside a character alternative. A
@samp{[:} and balancing @samp{:]} enclose a character class inside a
character alternative. Any other character appearing in a regular
expression is ordinary, unless a @samp{\} precedes it.
For example, @samp{f} is not a special character, so it is ordinary, and
therefore @samp{f} is a regular expression that matches the string
@samp{f} and no other string. (It does @emph{not} match the string
@samp{fg}, but it does match a @emph{part} of that string.) Likewise,
@samp{o} is a regular expression that matches only @samp{o}.
Any two regular expressions @var{a} and @var{b} can be concatenated. The
result is a regular expression that matches a string if @var{a} matches
some amount of the beginning of that string and @var{b} matches the rest of
the string.
As a simple example, we can concatenate the regular expressions @samp{f}
and @samp{o} to get the regular expression @samp{fo}, which matches only
the string @samp{fo}. Still trivial. To do something more powerful, you
need to use one of the special regular expression constructs.
@menu
* Regexp Special:: Special characters in regular expressions.
* Char Classes:: Character classes used in regular expressions.
* Regexp Backslash:: Backslash-sequences in regular expressions.
@end menu
@node Regexp Special
@subsubsection Special Characters in Regular Expressions
@cindex regexp, special characters in
Here is a list of the characters that are special in a regular
expression.
@need 800
@table @asis
@item @samp{.}@: @r{(Period)}
@cindex @samp{.} in regexp
is a special character that matches any single character except a newline.
Using concatenation, we can make regular expressions like @samp{a.b}, which
matches any three-character string that begins with @samp{a} and ends with
@samp{b}.
@item @samp{*}
@cindex @samp{*} in regexp
is not a construct by itself; it is a postfix operator that means to
match the preceding regular expression repetitively as many times as
possible. Thus, @samp{o*} matches any number of @samp{o}s (including no
@samp{o}s).
@samp{*} always applies to the @emph{smallest} possible preceding
expression. Thus, @samp{fo*} has a repeating @samp{o}, not a repeating
@samp{fo}. It matches @samp{f}, @samp{fo}, @samp{foo}, and so on.
@cindex backtracking and regular expressions
The matcher processes a @samp{*} construct by matching, immediately, as
many repetitions as can be found. Then it continues with the rest of
the pattern. If that fails, backtracking occurs, discarding some of the
matches of the @samp{*}-modified construct in the hope that this will
make it possible to match the rest of the pattern. For example, in
matching @samp{ca*ar} against the string @samp{caaar}, the @samp{a*}
first tries to match all three @samp{a}s; but the rest of the pattern is
@samp{ar} and there is only @samp{r} left to match, so this try fails.
The next alternative is for @samp{a*} to match only two @samp{a}s. With
this choice, the rest of the regexp matches successfully.
@strong{Warning:} Nested repetition operators can run for an
indefinitely long time, if they lead to ambiguous matching. For
example, trying to match the regular expression @samp{\(x+y*\)*a}
against the string @samp{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxz} could
take hours before it ultimately fails. Emacs must try each way of
grouping the @samp{x}s before concluding that none of them can work.
Even worse, @samp{\(x*\)*} can match the null string in infinitely
many ways, so it causes an infinite loop. To avoid these problems,
check nested repetitions carefully, to make sure that they do not
cause combinatorial explosions in backtracking.
@item @samp{+}
@cindex @samp{+} in regexp
is a postfix operator, similar to @samp{*} except that it must match
the preceding expression at least once. So, for example, @samp{ca+r}
matches the strings @samp{car} and @samp{caaaar} but not the string
@samp{cr}, whereas @samp{ca*r} matches all three strings.
@item @samp{?}
@cindex @samp{?} in regexp
is a postfix operator, similar to @samp{*} except that it must match the
preceding expression either once or not at all. For example,
@samp{ca?r} matches @samp{car} or @samp{cr}; nothing else.
@anchor{Non-greedy repetition}
@item @samp{*?}, @samp{+?}, @samp{??}
@cindex non-greedy repetition characters in regexp
These are @dfn{non-greedy} variants of the operators @samp{*}, @samp{+}
and @samp{?}. Where those operators match the largest possible
substring (consistent with matching the entire containing expression),
the non-greedy variants match the smallest possible substring
(consistent with matching the entire containing expression).
For example, the regular expression @samp{c[ad]*a} when applied to the
string @samp{cdaaada} matches the whole string; but the regular
expression @samp{c[ad]*?a}, applied to that same string, matches just
@samp{cda}. (The smallest possible match here for @samp{[ad]*?} that
permits the whole expression to match is @samp{d}.)
@item @samp{[ @dots{} ]}
@cindex character alternative (in regexp)
@cindex @samp{[} in regexp
@cindex @samp{]} in regexp
is a @dfn{character alternative}, which begins with @samp{[} and is
terminated by @samp{]}. In the simplest case, the characters between
the two brackets are what this character alternative can match.
Thus, @samp{[ad]} matches either one @samp{a} or one @samp{d}, and
@samp{[ad]*} matches any string composed of just @samp{a}s and @samp{d}s
(including the empty string). It follows that @samp{c[ad]*r}
matches @samp{cr}, @samp{car}, @samp{cdr}, @samp{caddaar}, etc.
You can also include character ranges in a character alternative, by
writing the starting and ending characters with a @samp{-} between them.
Thus, @samp{[a-z]} matches any lower-case @acronym{ASCII} letter.
Ranges may be intermixed freely with individual characters, as in
@samp{[a-z$%.]}, which matches any lower case @acronym{ASCII} letter
or @samp{$}, @samp{%} or period. However, the ending character of one
range should not be the starting point of another one; for example,
@samp{[a-m-z]} should be avoided.
A character alternative can also specify named character classes
(@pxref{Char Classes}). This is a POSIX feature. For example,
@samp{[[:ascii:]]} matches any @acronym{ASCII} character.
Using a character class is equivalent to mentioning each of the
characters in that class; but the latter is not feasible in practice,
since some classes include thousands of different characters.
A character class should not appear as the lower or upper bound
of a range.
The usual regexp special characters are not special inside a
character alternative. A completely different set of characters is
special: @samp{]}, @samp{-} and @samp{^}.
To include @samp{]} in a character alternative, put it at the
beginning. To include @samp{^}, put it anywhere but at the beginning.
To include @samp{-}, put it at the end. Thus, @samp{[]^-]} matches
all three of these special characters. You cannot use @samp{\} to
escape these three characters, since @samp{\} is not special here.
The following aspects of ranges are specific to Emacs, in that POSIX
allows but does not require this behavior and programs other than
Emacs may behave differently:
@enumerate
@item
If @code{case-fold-search} is non-@code{nil}, @samp{[a-z]} also
matches upper-case letters.
@item
A range is not affected by the locale's collation sequence: it always
represents the set of characters with codepoints ranging between those
of its bounds, so that @samp{[a-z]} matches only ASCII letters, even
outside the C or POSIX locale.
@item
If the lower bound of a range is greater than its upper bound, the
range is empty and represents no characters. Thus, @samp{[z-a]}
always fails to match, and @samp{[^z-a]} matches any character,
including newline. However, a reversed range should always be from
the letter @samp{z} to the letter @samp{a} to make it clear that it is
not a typo; for example, @samp{[+-*/]} should be avoided, because it
matches only @samp{/} rather than the likely-intended four characters.
@end enumerate
Some kinds of character alternatives are not the best style even
though they have a well-defined meaning in Emacs. They include:
@enumerate
@item
Although a range's bound can be almost any character, it is better
style to stay within natural sequences of ASCII letters and digits
because most people have not memorized character code tables.
For example, @samp{[.-9]} is less clear than @samp{[./0-9]},
and @samp{[`-~]} is less clear than @samp{[`a-z@{|@}~]}.
Unicode character escapes can help here; for example, for most programmers
@samp{[ก-ฺ฿-๛]} is less clear than @samp{[\u0E01-\u0E3A\u0E3F-\u0E5B]}.
@item
Although a character alternative can include duplicates, it is better
style to avoid them. For example, @samp{[XYa-yYb-zX]} is less clear
than @samp{[XYa-z]}.
@item
Although a range can denote just one, two, or three characters, it
is simpler to list the characters. For example,
@samp{[a-a0]} is less clear than @samp{[a0]}, @samp{[i-j]} is less clear
than @samp{[ij]}, and @samp{[i-k]} is less clear than @samp{[ijk]}.
@item
Although a @samp{-} can appear at the beginning of a character
alternative or as the upper bound of a range, it is better style to
put @samp{-} by itself at the end of a character alternative. For
example, although @samp{[-a-z]} is valid, @samp{[a-z-]} is better
style; and although @samp{[*--]} is valid, @samp{[*+,-]} is clearer.
@end enumerate
@item @samp{[^ @dots{} ]}
@cindex @samp{^} in regexp
@samp{[^} begins a @dfn{complemented character alternative}. This
matches any character except the ones specified. Thus,
@samp{[^a-z0-9A-Z]} matches all characters @emph{except} ASCII letters and
digits.
@samp{^} is not special in a character alternative unless it is the first
character. The character following the @samp{^} is treated as if it
were first (in other words, @samp{-} and @samp{]} are not special there).
A complemented character alternative can match a newline, unless newline is
mentioned as one of the characters not to match. This is in contrast to
the handling of regexps in programs such as @code{grep}.
You can specify named character classes, just like in character
alternatives. For instance, @samp{[^[:ascii:]]} matches any
non-@acronym{ASCII} character. @xref{Char Classes}.
@item @samp{^}
@cindex beginning of line in regexp
When matching a buffer, @samp{^} matches the empty string, but only at the
beginning of a line in the text being matched (or the beginning of the
accessible portion of the buffer). Otherwise it fails to match
anything. Thus, @samp{^foo} matches a @samp{foo} that occurs at the
beginning of a line.
When matching a string instead of a buffer, @samp{^} matches at the
beginning of the string or after a newline character.
For historical compatibility reasons, @samp{^} can be used only at the
beginning of the regular expression, or after @samp{\(}, @samp{\(?:}
or @samp{\|}.
@item @samp{$}
@cindex @samp{$} in regexp
@cindex end of line in regexp
is similar to @samp{^} but matches only at the end of a line (or the
end of the accessible portion of the buffer). Thus, @samp{x+$}
matches a string of one @samp{x} or more at the end of a line.
When matching a string instead of a buffer, @samp{$} matches at the end
of the string or before a newline character.
For historical compatibility reasons, @samp{$} can be used only at the
end of the regular expression, or before @samp{\)} or @samp{\|}.
@item @samp{\}
@cindex @samp{\} in regexp
has two functions: it quotes the special characters (including
@samp{\}), and it introduces additional special constructs.
Because @samp{\} quotes special characters, @samp{\$} is a regular
expression that matches only @samp{$}, and @samp{\[} is a regular
expression that matches only @samp{[}, and so on.
Note that @samp{\} also has special meaning in the read syntax of Lisp
strings (@pxref{String Type}), and must be quoted with @samp{\}. For
example, the regular expression that matches the @samp{\} character is
@samp{\\}. To write a Lisp string that contains the characters
@samp{\\}, Lisp syntax requires you to quote each @samp{\} with another
@samp{\}. Therefore, the read syntax for a regular expression matching
@samp{\} is @code{"\\\\"}.
@end table
@strong{Please note:} For historical compatibility, special characters
are treated as ordinary ones if they are in contexts where their special
meanings make no sense. For example, @samp{*foo} treats @samp{*} as
ordinary since there is no preceding expression on which the @samp{*}
can act. It is poor practice to depend on this behavior; quote the
special character anyway, regardless of where it appears.
As a @samp{\} is not special inside a character alternative, it can
never remove the special meaning of @samp{-} or @samp{]}. So you
should not quote these characters when they have no special meaning
either. This would not clarify anything, since backslashes can
legitimately precede these characters where they @emph{have} special
meaning, as in @samp{[^\]} (@code{"[^\\]"} for Lisp string syntax),
which matches any single character except a backslash.
In practice, most @samp{]} that occur in regular expressions close a
character alternative and hence are special. However, occasionally a
regular expression may try to match a complex pattern of literal
@samp{[} and @samp{]}. In such situations, it sometimes may be
necessary to carefully parse the regexp from the start to determine
which square brackets enclose a character alternative. For example,
@samp{[^][]]} consists of the complemented character alternative
@samp{[^][]} (which matches any single character that is not a square
bracket), followed by a literal @samp{]}.
The exact rules are that at the beginning of a regexp, @samp{[} is
special and @samp{]} not. This lasts until the first unquoted
@samp{[}, after which we are in a character alternative; @samp{[} is
no longer special (except when it starts a character class) but @samp{]}
is special, unless it immediately follows the special @samp{[} or that
@samp{[} followed by a @samp{^}. This lasts until the next special
@samp{]} that does not end a character class. This ends the character
alternative and restores the ordinary syntax of regular expressions;
an unquoted @samp{[} is special again and a @samp{]} not.
@node Char Classes
@subsubsection Character Classes
@cindex character classes in regexp
Here is a table of the classes you can use in a character alternative,
and what they mean:
@table @samp
@item [:ascii:]
This matches any @acronym{ASCII} character (codes 0--127).
@item [:alnum:]
This matches any letter or digit. For multibyte characters, it
matches characters whose Unicode @samp{general-category} property
(@pxref{Character Properties}) indicates they are alphabetic or
decimal number characters.
@item [:alpha:]
This matches any letter. For multibyte characters, it matches
characters whose Unicode @samp{general-category} property
(@pxref{Character Properties}) indicates they are alphabetic
characters.
@item [:blank:]
This matches horizontal whitespace, as defined by Annex C of the
Unicode Technical Standard #18. In particular, it matches spaces,
tabs, and other characters whose Unicode @samp{general-category}
property (@pxref{Character Properties}) indicates they are spacing
separators.
@item [:cntrl:]
This matches any character whose code is in the range 0--31.
@item [:digit:]
This matches @samp{0} through @samp{9}. Thus, @samp{[-+[:digit:]]}
matches any digit, as well as @samp{+} and @samp{-}.
@item [:graph:]
This matches graphic characters---everything except whitespace,
@acronym{ASCII} and non-@acronym{ASCII} control characters,
surrogates, and codepoints unassigned by Unicode, as indicated by the
Unicode @samp{general-category} property (@pxref{Character
Properties}).
@item [:lower:]
This matches any lower-case letter, as determined by the current case
table (@pxref{Case Tables}). If @code{case-fold-search} is
non-@code{nil}, this also matches any upper-case letter.
@item [:multibyte:]
This matches any multibyte character (@pxref{Text Representations}).
@item [:nonascii:]
This matches any non-@acronym{ASCII} character.
@item [:print:]
This matches any printing character---either whitespace, or a graphic
character matched by @samp{[:graph:]}.
@item [:punct:]
This matches any punctuation character. (At present, for multibyte
characters, it matches anything that has non-word syntax.)
@item [:space:]
This matches any character that has whitespace syntax
(@pxref{Syntax Class Table}).
@item [:unibyte:]
This matches any unibyte character (@pxref{Text Representations}).
@item [:upper:]
This matches any upper-case letter, as determined by the current case
table (@pxref{Case Tables}). If @code{case-fold-search} is
non-@code{nil}, this also matches any lower-case letter.
@item [:word:]
This matches any character that has word syntax (@pxref{Syntax Class
Table}).
@item [:xdigit:]
This matches the hexadecimal digits: @samp{0} through @samp{9}, @samp{a}
through @samp{f} and @samp{A} through @samp{F}.
@end table
@node Regexp Backslash
@subsubsection Backslash Constructs in Regular Expressions
@cindex backslash in regular expressions
For the most part, @samp{\} followed by any character matches only
that character. However, there are several exceptions: certain
sequences starting with @samp{\} that have special meanings. Here is
a table of the special @samp{\} constructs.
@table @samp
@item \|
@cindex @samp{|} in regexp
@cindex regexp alternative
specifies an alternative.
Two regular expressions @var{a} and @var{b} with @samp{\|} in
between form an expression that matches anything that either @var{a} or
@var{b} matches.
Thus, @samp{foo\|bar} matches either @samp{foo} or @samp{bar}
but no other string.
@samp{\|} applies to the largest possible surrounding expressions. Only a
surrounding @samp{\( @dots{} \)} grouping can limit the grouping power of
@samp{\|}.
If you need full backtracking capability to handle multiple uses of
@samp{\|}, use the POSIX regular expression functions (@pxref{POSIX
Regexps}).
@item \@{@var{m}\@}
is a postfix operator that repeats the previous pattern exactly @var{m}
times. Thus, @samp{x\@{5\@}} matches the string @samp{xxxxx}
and nothing else. @samp{c[ad]\@{3\@}r} matches string such as
@samp{caaar}, @samp{cdddr}, @samp{cadar}, and so on.
@item \@{@var{m},@var{n}\@}
is a more general postfix operator that specifies repetition with a
minimum of @var{m} repeats and a maximum of @var{n} repeats. If @var{m}
is omitted, the minimum is 0; if @var{n} is omitted, there is no
maximum. For both forms, @var{m} and @var{n}, if specified, may be no
larger than
@ifnottex
2**16 @minus{} 1
@end ifnottex
@tex
@math{2^{16}-1}
@end tex
.
For example, @samp{c[ad]\@{1,2\@}r} matches the strings @samp{car},
@samp{cdr}, @samp{caar}, @samp{cadr}, @samp{cdar}, and @samp{cddr}, and
nothing else.@*
@samp{\@{0,1\@}} or @samp{\@{,1\@}} is equivalent to @samp{?}.@*
@samp{\@{0,\@}} or @samp{\@{,\@}} is equivalent to @samp{*}.@*
@samp{\@{1,\@}} is equivalent to @samp{+}.
@item \( @dots{} \)
@cindex @samp{(} in regexp
@cindex @samp{)} in regexp
@cindex regexp grouping
is a grouping construct that serves three purposes:
@enumerate
@item
To enclose a set of @samp{\|} alternatives for other operations. Thus,
the regular expression @samp{\(foo\|bar\)x} matches either @samp{foox}
or @samp{barx}.
@item
To enclose a complicated expression for the postfix operators @samp{*},
@samp{+} and @samp{?} to operate on. Thus, @samp{ba\(na\)*} matches
@samp{ba}, @samp{bana}, @samp{banana}, @samp{bananana}, etc., with any
number (zero or more) of @samp{na} strings.
@item
To record a matched substring for future reference with
@samp{\@var{digit}} (see below).
@end enumerate
This last application is not a consequence of the idea of a
parenthetical grouping; it is a separate feature that was assigned as a
second meaning to the same @samp{\( @dots{} \)} construct because, in
practice, there was usually no conflict between the two meanings. But
occasionally there is a conflict, and that led to the introduction of
shy groups.
@item \(?: @dots{} \)
@cindex shy groups
@cindex non-capturing group
@cindex unnumbered group
@cindex @samp{(?:} in regexp
is the @dfn{shy group} construct. A shy group serves the first two
purposes of an ordinary group (controlling the nesting of other
operators), but it does not get a number, so you cannot refer back to
its value with @samp{\@var{digit}}. Shy groups are particularly
useful for mechanically-constructed regular expressions, because they
can be added automatically without altering the numbering of ordinary,
non-shy groups.
Shy groups are also called @dfn{non-capturing} or @dfn{unnumbered
groups}.
@item \(?@var{num}: @dots{} \)
is the @dfn{explicitly numbered group} construct. Normal groups get
their number implicitly, based on their position, which can be
inconvenient. This construct allows you to force a particular group
number. There is no particular restriction on the numbering,
e.g., you can have several groups with the same number in which case
the last one to match (i.e., the rightmost match) will win.
Implicitly numbered groups always get the smallest integer larger than
the one of any previous group.
@item \@var{digit}
matches the same text that matched the @var{digit}th occurrence of a
grouping (@samp{\( @dots{} \)}) construct.
In other words, after the end of a group, the matcher remembers the
beginning and end of the text matched by that group. Later on in the
regular expression you can use @samp{\} followed by @var{digit} to
match that same text, whatever it may have been.
The strings matching the first nine grouping constructs appearing in
the entire regular expression passed to a search or matching function
are assigned numbers 1 through 9 in the order that the open
parentheses appear in the regular expression. So you can use
@samp{\1} through @samp{\9} to refer to the text matched by the
corresponding grouping constructs.
For example, @samp{\(.*\)\1} matches any newline-free string that is
composed of two identical halves. The @samp{\(.*\)} matches the first
half, which may be anything, but the @samp{\1} that follows must match
the same exact text.
If a @samp{\( @dots{} \)} construct matches more than once (which can
happen, for instance, if it is followed by @samp{*}), only the last
match is recorded.
If a particular grouping construct in the regular expression was never
matched---for instance, if it appears inside of an alternative that
wasn't used, or inside of a repetition that repeated zero times---then
the corresponding @samp{\@var{digit}} construct never matches
anything. To use an artificial example, @samp{\(foo\(b*\)\|lose\)\2}
cannot match @samp{lose}: the second alternative inside the larger
group matches it, but then @samp{\2} is undefined and can't match
anything. But it can match @samp{foobb}, because the first
alternative matches @samp{foob} and @samp{\2} matches @samp{b}.
@item \w
@cindex @samp{\w} in regexp
matches any word-constituent character. The editor syntax table
determines which characters these are. @xref{Syntax Tables}.
@item \W
@cindex @samp{\W} in regexp
matches any character that is not a word constituent.
@item \s@var{code}
@cindex @samp{\s} in regexp
matches any character whose syntax is @var{code}. Here @var{code} is a
character that represents a syntax code: thus, @samp{w} for word
constituent, @samp{-} for whitespace, @samp{(} for open parenthesis,
etc. To represent whitespace syntax, use either @samp{-} or a space
character. @xref{Syntax Class Table}, for a list of syntax codes and
the characters that stand for them.
@item \S@var{code}
@cindex @samp{\S} in regexp
matches any character whose syntax is not @var{code}.
@cindex category, regexp search for
@item \c@var{c}
matches any character whose category is @var{c}. Here @var{c} is a
character that represents a category: thus, @samp{c} for Chinese
characters or @samp{g} for Greek characters in the standard category
table. You can see the list of all the currently defined categories
with @kbd{M-x describe-categories @key{RET}}. You can also define
your own categories in addition to the standard ones using the
@code{define-category} function (@pxref{Categories}).
@item \C@var{c}
matches any character whose category is not @var{c}.
@end table
The following regular expression constructs match the empty string---that is,
they don't use up any characters---but whether they match depends on the
context. For all, the beginning and end of the accessible portion of
the buffer are treated as if they were the actual beginning and end of
the buffer.
@table @samp
@item \`
@cindex @samp{\`} in regexp
matches the empty string, but only at the beginning
of the buffer or string being matched against.
@item \'
@cindex @samp{\'} in regexp
matches the empty string, but only at the end of
the buffer or string being matched against.
@item \=
@cindex @samp{\=} in regexp
matches the empty string, but only at point.
(This construct is not defined when matching against a string.)
@item \b
@cindex @samp{\b} in regexp
matches the empty string, but only at the beginning or
end of a word. Thus, @samp{\bfoo\b} matches any occurrence of
@samp{foo} as a separate word. @samp{\bballs?\b} matches
@samp{ball} or @samp{balls} as a separate word.
@samp{\b} matches at the beginning or end of the buffer (or string)
regardless of what text appears next to it.
@item \B
@cindex @samp{\B} in regexp
matches the empty string, but @emph{not} at the beginning or
end of a word, nor at the beginning or end of the buffer (or string).
@item \<
@cindex @samp{\<} in regexp
matches the empty string, but only at the beginning of a word.
@samp{\<} matches at the beginning of the buffer (or string) only if a
word-constituent character follows.
@item \>
@cindex @samp{\>} in regexp
matches the empty string, but only at the end of a word. @samp{\>}
matches at the end of the buffer (or string) only if the contents end
with a word-constituent character.
@item \_<
@cindex @samp{\_<} in regexp
matches the empty string, but only at the beginning of a symbol. A
symbol is a sequence of one or more word or symbol constituent
characters. @samp{\_<} matches at the beginning of the buffer (or
string) only if a symbol-constituent character follows.
@item \_>
@cindex @samp{\_>} in regexp
matches the empty string, but only at the end of a symbol. @samp{\_>}
matches at the end of the buffer (or string) only if the contents end
with a symbol-constituent character.
@end table
@kindex invalid-regexp
Not every string is a valid regular expression. For example, a string
that ends inside a character alternative without a terminating @samp{]}
is invalid, and so is a string that ends with a single @samp{\}. If
an invalid regular expression is passed to any of the search functions,
an @code{invalid-regexp} error is signaled.
@node Regexp Example
@subsection Complex Regexp Example
Here is a complicated regexp which was formerly used by Emacs to
recognize the end of a sentence together with any whitespace that
follows. (Nowadays Emacs uses a similar but more complex default
regexp constructed by the function @code{sentence-end}.
@xref{Standard Regexps}.)
Below, we show first the regexp as a string in Lisp syntax (to
distinguish spaces from tab characters), and then the result of
evaluating it. The string constant begins and ends with a
double-quote. @samp{\"} stands for a double-quote as part of the
string, @samp{\\} for a backslash as part of the string, @samp{\t} for a
tab and @samp{\n} for a newline.
@example
@group
"[.?!][]\"')@}]*\\($\\| $\\|\t\\|@ @ \\)[ \t\n]*"
@result{} "[.?!][]\"')@}]*\\($\\| $\\| \\|@ @ \\)[
]*"
@end group
@end example
@noindent
In the output, tab and newline appear as themselves.
This regular expression contains four parts in succession and can be
deciphered as follows:
@table @code
@item [.?!]
The first part of the pattern is a character alternative that matches
any one of three characters: period, question mark, and exclamation
mark. The match must begin with one of these three characters. (This
is one point where the new default regexp used by Emacs differs from
the old. The new value also allows some non-@acronym{ASCII}
characters that end a sentence without any following whitespace.)
@item []\"')@}]*
The second part of the pattern matches any closing braces and quotation
marks, zero or more of them, that may follow the period, question mark
or exclamation mark. The @code{\"} is Lisp syntax for a double-quote in
a string. The @samp{*} at the end indicates that the immediately
preceding regular expression (a character alternative, in this case) may be
repeated zero or more times.
@item \\($\\|@ $\\|\t\\|@ @ \\)
The third part of the pattern matches the whitespace that follows the
end of a sentence: the end of a line (optionally with a space), or a
tab, or two spaces. The double backslashes mark the parentheses and
vertical bars as regular expression syntax; the parentheses delimit a
group and the vertical bars separate alternatives. The dollar sign is
used to match the end of a line.
@item [ \t\n]*
Finally, the last part of the pattern matches any additional whitespace
beyond the minimum needed to end a sentence.
@end table
In the @code{rx} notation (@pxref{Rx Notation}), the regexp could be written
@example
@group
(rx (any ".?!") ; Punctuation ending sentence.
(zero-or-more (any "\"')]@}")) ; Closing quotes or brackets.
(or line-end
(seq " " line-end)
"\t"
" ") ; Two spaces.
(zero-or-more (any "\t\n "))) ; Optional extra whitespace.
@end group
@end example
Since @code{rx} regexps are just S-expressions, they can be formatted
and commented as such.
@node Rx Notation
@subsection The @code{rx} Structured Regexp Notation
@cindex rx
@cindex regexp syntax
As an alternative to the string-based syntax, Emacs provides the
structured @code{rx} notation based on Lisp S-expressions. This
notation is usually easier to read, write and maintain than regexp
strings, and can be indented and commented freely. It requires a
conversion into string form since that is what regexp functions
expect, but that conversion typically takes place during
byte-compilation rather than when the Lisp code using the regexp is
run.
Here is an @code{rx} regexp@footnote{It could be written much
simpler with non-greedy operators (how?), but that would make the
example less interesting.} that matches a block comment in the C
programming language:
@example
@group
(rx "/*" ; Initial /*
(zero-or-more
(or (not (any "*")) ; Either non-*,
(seq "*" ; or * followed by
(not (any "/"))))) ; non-/
(one-or-more "*") ; At least one star,
"/") ; and the final /
@end group
@end example
@noindent
or, using shorter synonyms and written more compactly,
@example
@group
(rx "/*"
(* (| (not (any "*"))
(: "*" (not (any "/")))))
(+ "*") "/")
@end group
@end example
@noindent
In conventional string syntax, it would be written
@example
"/\\*\\(?:[^*]\\|\\*[^/]\\)*\\*+/"
@end example
The @code{rx} notation is mainly useful in Lisp code; it cannot be
used in most interactive situations where a regexp is requested, such
as when running @code{query-replace-regexp} or in variable
customisation.
@menu
* Rx Constructs:: Constructs valid in rx forms.
* Rx Functions:: Functions and macros that use rx forms.
@end menu
@node Rx Constructs
@subsubsection Constructs in @code{rx} regexps
The various forms in @code{rx} regexps are described below. The
shorthand @var{rx} represents any @code{rx} form, and @var{rx}@dots{}
means one or more @code{rx} forms. Where the corresponding string
regexp syntax is given, @var{A}, @var{B}, @dots{} are string regexp
subexpressions.
@c With the new implementation of rx, this can be changed from
@c 'one or more' to 'zero or more'.
@subsubheading Literals
@table @asis
@item @code{"some-string"}
Match the string @samp{some-string} literally. There are no
characters with special meaning, unlike in string regexps.
@item @code{?C}
Match the character @samp{C} literally.
@end table
@subsubheading Fundamental structure
@table @asis
@item @code{(seq @var{rx}@dots{})}
@cindex @code{seq} in rx
@itemx @code{(sequence @var{rx}@dots{})}
@cindex @code{sequence} in rx
@itemx @code{(: @var{rx}@dots{})}
@cindex @code{:} in rx
@itemx @code{(and @var{rx}@dots{})}
@cindex @code{and} in rx
Match the @var{rx}s in sequence. Without arguments, the expression
matches the empty string.@*
Corresponding string regexp: @samp{@var{A}@var{B}@dots{}}
(subexpressions in sequence).
@item @code{(or @var{rx}@dots{})}
@cindex @code{or} in rx
@itemx @code{(| @var{rx}@dots{})}
@cindex @code{|} in rx
Match exactly one of the @var{rx}s, trying from left to right.
Without arguments, the expression will not match anything at all.@*
Corresponding string regexp: @samp{@var{A}\|@var{B}\|@dots{}}.
@end table
@subsubheading Repetition
@table @code
@item (zero-or-more @var{rx}@dots{})
@cindex @code{zero-or-more} in rx
@itemx (0+ @var{rx}@dots{})
@cindex @code{0+} in rx
@itemx (* @var{rx}@dots{})
@cindex @code{*} in rx
Match the @var{rx}s zero or more times.@*
Corresponding string regexp: @samp{@var{A}*}
@item (one-or-more @var{rx}@dots{})
@cindex @code{one-or-more} in rx
@itemx (1+ @var{rx}@dots{})
@cindex @code{1+} in rx
@itemx (+ @var{rx}@dots{})
@cindex @code{+} in rx
Match the @var{rx}s one or more times.@*
Corresponding string regexp: @samp{@var{A}+}
@item (zero-or-one @var{rx}@dots{})
@cindex @code{zero-or-one} in rx
@itemx (optional @var{rx}@dots{})
@cindex @code{optional} in rx
@itemx (opt @var{rx}@dots{})
@cindex @code{opt} in rx
@itemx (? @var{rx}@dots{})
@cindex @code{?} in rx
Match the @var{rx}s once or an empty string.@*
Corresponding string regexp: @samp{@var{A}?}
@item (= @var{n} @var{rx}@dots{})
@cindex @code{=} in rx
@itemx (repeat @var{n} @var{rx})
Match the @var{rx}s exactly @var{n} times.@*
Corresponding string regexp: @samp{@var{A}\@{@var{n}\@}}
@item (>= @var{n} @var{rx}@dots{})
@cindex @code{>=} in rx
Match the @var{rx}s @var{n} or more times.@*
Corresponding string regexp: @samp{@var{A}\@{@var{n},\@}}
@item (** @var{n} @var{m} @var{rx}@dots{})
@cindex @code{**} in rx
@itemx (repeat @var{n} @var{m} @var{rx}@dots{})
@cindex @code{repeat} in rx
Match the @var{rx}s at least @var{n} but no more than @var{m} times.@*
Corresponding string regexp: @samp{@var{A}\@{@var{n},@var{m}\@}}
@end table
@subsubheading Non-greedy repetition
Normally, repetition forms are greedy, in that they attempt to match
as many times as possible. The following three forms are non-greedy; they
try to match as few times as possible (@pxref{Non-greedy repetition}).
@table @code
@item (*? @var{rx}@dots{})
@cindex @code{*?} in rx
Match the @var{rx}s zero or more times, non-greedily.@*
Corresponding string regexp: @samp{@var{A}*?}
@item (+? @var{rx}@dots{})
@cindex @code{+?} in rx
Match the @var{rx}s one or more times, non-greedily.@*
Corresponding string regexp: @samp{@var{A}+?}
@item (?? @var{rx}@dots{})
@cindex @code{??} in rx
Match the @var{rx}s or an empty string, non-greedily.@*
Corresponding string regexp: @samp{@var{A}??}
@end table
The greediness of some repetition forms can be controlled using the
following constructs. However, it is usually better to use the
explicit non-greedy forms above instead.
@table @code
@item (minimal-match @var{rx})
@cindex @code{minimal-match} in rx
Match @var{rx}, with @code{zero-or-more}, @code{0+},
@code{one-or-more}, @code{1+}, @code{zero-or-one}, @code{opt} and
@code{option} using non-greedy matching.
@item (maximal-match @var{rx})
@cindex @code{maximal-match} in rx
Match @var{rx}, with @code{zero-or-more}, @code{0+},
@code{one-or-more}, @code{1+}, @code{zero-or-one}, @code{opt} and
@code{option} using non-greedy matching. This is the default.
@end table
@subsubheading Matching single characters
@table @asis
@item @code{(any @var{set}@dots{})}
@cindex @code{any} in rx
@itemx @code{(char @var{set}@dots{})}
@cindex @code{char} in rx
@itemx @code{(in @var{set}@dots{})}
@cindex @code{in} in rx
@cindex character class in rx
Match a single character from one of the @var{set}s. Each @var{set}
is a character, a string representing the set of its characters, a
range or a character class (see below). A range is either a
hyphen-separated string like @code{"A-Z"}, or a cons of characters
like @code{(?A . ?Z)}.
Note that hyphen (@code{-}) is special in strings in this construct,
since it acts as a range separator. To include a hyphen, add it as a
separate character or single-character string.@*
Corresponding string regexp: @samp{[@dots{}]}
@item @code{(not @var{charspec})}
@cindex @code{not} in rx
Match a character not included in @var{charspec}. @var{charspec} can
be an @code{any}, @code{syntax} or @code{category} form, or a
character class.@*
Corresponding string regexp: @samp{[^@dots{}]}, @samp{\S@var{code}},
@samp{\C@var{code}}
@item @code{not-newline}, @code{nonl}
@cindex @code{not-newline} in rx
@cindex @code{nonl} in rx
Match any character except a newline.@*
Corresponding string regexp: @samp{.} (dot)
@item @code{anything}
@cindex @code{anything} in rx
Match any character.@*
Corresponding string regexp: @samp{.\|\n} (for example)
@item character class
@cindex character class in rx
Match a character from a named character class:
@table @asis
@item @code{alpha}, @code{alphabetic}, @code{letter}
Match alphabetic characters. More precisely, match characters whose
Unicode @samp{general-category} property indicates that they are
alphabetic.
@item @code{alnum}, @code{alphanumeric}
Match alphabetic characters and digits. More precisely, match
characters whose Unicode @samp{general-category} property indicates
that they are alphabetic or decimal digits.
@item @code{digit}, @code{numeric}, @code{num}
Match the digits @samp{0}--@samp{9}.
@item @code{xdigit}, @code{hex-digit}, @code{hex}
Match the hexadecimal digits @samp{0}--@samp{9}, @samp{A}--@samp{F}
and @samp{a}--@samp{f}.
@item @code{cntrl}, @code{control}
Match any character whose code is in the range 0--31.
@item @code{blank}
Match horizontal whitespace. More precisely, match characters whose
Unicode @samp{general-category} property indicates that they are
spacing separators.
@item @code{space}, @code{whitespace}, @code{white}
Match any character that has whitespace syntax
(@pxref{Syntax Class Table}).
@item @code{lower}, @code{lower-case}
Match anything lower-case, as determined by the current case table.
If @code{case-fold-search} is non-nil, this also matches any
upper-case letter.
@item @code{upper}, @code{upper-case}
Match anything upper-case, as determined by the current case table.
If @code{case-fold-search} is non-nil, this also matches any
lower-case letter.
@item @code{graph}, @code{graphic}
Match any character except whitespace, @acronym{ASCII} and
non-@acronym{ASCII} control characters, surrogates, and codepoints
unassigned by Unicode, as indicated by the Unicode
@samp{general-category} property.
@item @code{print}, @code{printing}
Match whitespace or a character matched by @code{graph}.
@item @code{punct}, @code{punctuation}
Match any punctuation character. (At present, for multibyte
characters, anything that has non-word syntax.)
@item @code{word}, @code{wordchar}
Match any character that has word syntax (@pxref{Syntax Class Table}).
@item @code{ascii}
Match any @acronym{ASCII} character (codes 0--127).
@item @code{nonascii}
Match any non-@acronym{ASCII} character (but not raw bytes).
@end table
Corresponding string regexp: @samp{[[:@var{class}:]]}
@item @code{(syntax @var{syntax})}
@cindex @code{syntax} in rx
Match a character with syntax @var{syntax}, being one of the following
names:
@multitable {@code{close-parenthesis}} {Syntax character}
@headitem Syntax name @tab Syntax character
@item @code{whitespace} @tab @code{-}
@item @code{punctuation} @tab @code{.}
@item @code{word} @tab @code{w}
@item @code{symbol} @tab @code{_}
@item @code{open-parenthesis} @tab @code{(}
@item @code{close-parenthesis} @tab @code{)}
@item @code{expression-prefix} @tab @code{'}
@item @code{string-quote} @tab @code{"}
@item @code{paired-delimiter} @tab @code{$}
@item @code{escape} @tab @code{\}
@item @code{character-quote} @tab @code{/}
@item @code{comment-start} @tab @code{<}
@item @code{comment-end} @tab @code{>}
@item @code{string-delimiter} @tab @code{|}
@item @code{comment-delimiter} @tab @code{!}
@end multitable
For details, @pxref{Syntax Class Table}. Please note that
@code{(syntax punctuation)} is @emph{not} equivalent to the character class
@code{punctuation}.@*
Corresponding string regexp: @samp{\s@var{code}}
@item @code {(category @var{category})}
@cindex @code{category} in rx
Match a character in category @var{category}, which is either one of
the names below or its category character.
@multitable {@code{vowel-modifying-diacritical-mark}} {Category character}
@headitem Category name @tab Category character
@item @code{space-for-indent} @tab space
@item @code{base} @tab @code{.}
@item @code{consonant} @tab @code{0}
@item @code{base-vowel} @tab @code{1}
@item @code{upper-diacritical-mark} @tab @code{2}
@item @code{lower-diacritical-mark} @tab @code{3}
@item @code{tone-mark} @tab @code{4}
@item @code{symbol} @tab @code{5}
@item @code{digit} @tab @code{6}
@item @code{vowel-modifying-diacritical-mark} @tab @code{7}
@item @code{vowel-sign} @tab @code{8}
@item @code{semivowel-lower} @tab @code{9}
@item @code{not-at-end-of-line} @tab @code{<}
@item @code{not-at-beginning-of-line} @tab @code{>}
@item @code{alpha-numeric-two-byte} @tab @code{A}
@item @code{chinese-two-byte} @tab @code{C}
@item @code{greek-two-byte} @tab @code{G}
@item @code{japanese-hiragana-two-byte} @tab @code{H}
@item @code{indian-two-byte} @tab @code{I}
@item @code{japanese-katakana-two-byte} @tab @code{K}
@item @code{strong-left-to-right} @tab @code{L}
@item @code{korean-hangul-two-byte} @tab @code{N}
@item @code{strong-right-to-left} @tab @code{R}
@item @code{cyrillic-two-byte} @tab @code{Y}
@item @code{combining-diacritic} @tab @code{^}
@item @code{ascii} @tab @code{a}
@item @code{arabic} @tab @code{b}
@item @code{chinese} @tab @code{c}
@item @code{ethiopic} @tab @code{e}
@item @code{greek} @tab @code{g}
@item @code{korean} @tab @code{h}
@item @code{indian} @tab @code{i}
@item @code{japanese} @tab @code{j}
@item @code{japanese-katakana} @tab @code{k}
@item @code{latin} @tab @code{l}
@item @code{lao} @tab @code{o}
@item @code{tibetan} @tab @code{q}
@item @code{japanese-roman} @tab @code{r}
@item @code{thai} @tab @code{t}
@item @code{vietnamese} @tab @code{v}
@item @code{hebrew} @tab @code{w}
@item @code{cyrillic} @tab @code{y}
@item @code{can-break} @tab @code{|}
@end multitable
For more information about currently defined categories, run the
command @kbd{M-x describe-categories @key{RET}}. For how to define
new categories, @pxref{Categories}.@*
Corresponding string regexp: @samp{\c@var{code}}
@end table
@subsubheading Zero-width assertions
These all match the empty string, but only in specific places.
@table @asis
@item @code{line-start}, @code{bol}
@cindex @code{line-start} in rx
@cindex @code{bol} in rx
Match at the beginning of a line.@*
Corresponding string regexp: @samp{^}
@item @code{line-end}, @code{eol}
@cindex @code{line-end} in rx
@cindex @code{eol} in rx
Match at the end of a line.@*
Corresponding string regexp: @samp{$}
@item @code{string-start}, @code{bos}, @code{buffer-start}, @code{bot}
@cindex @code{string-start} in rx
@cindex @code{bos} in rx
@cindex @code{buffer-start} in rx
@cindex @code{bot} in rx
Match at the start of the string or buffer being matched against.@*
Corresponding string regexp: @samp{\`}
@item @code{string-end}, @code{eos}, @code{buffer-end}, @code{eot}
@cindex @code{string-end} in rx
@cindex @code{eos} in rx
@cindex @code{buffer-end} in rx
@cindex @code{eot} in rx
Match at the end of the string or buffer being matched against.@*
Corresponding string regexp: @samp{\'}
@item @code{point}
@cindex @code{point} in rx
Match at point.@*
Corresponding string regexp: @samp{\=}
@item @code{word-start}
@cindex @code{word-start} in rx
Match at the beginning of a word.@*
Corresponding string regexp: @samp{\<}
@item @code{word-end}
@cindex @code{word-end} in rx
Match at the end of a word.@*
Corresponding string regexp: @samp{\>}
@item @code{word-boundary}
@cindex @code{word-boundary} in rx
Match at the beginning or end of a word.@*
Corresponding string regexp: @samp{\b}
@item @code{not-word-boundary}
@cindex @code{not-word-boundary} in rx
Match anywhere but at the beginning or end of a word.@*
Corresponding string regexp: @samp{\B}
@item @code{symbol-start}
@cindex @code{symbol-start} in rx
Match at the beginning of a symbol.@*
Corresponding string regexp: @samp{\_<}
@item @code{symbol-end}
@cindex @code{symbol-end} in rx
Match at the end of a symbol.@*
Corresponding string regexp: @samp{\_>}
@end table
@subsubheading Capture groups
@table @code
@item (group @var{rx}@dots{})
@cindex @code{group} in rx
@itemx (submatch @var{rx}@dots{})
@cindex @code{submatch} in rx
Match the @var{rx}s, making the matched text and position accessible
in the match data. The first group in a regexp is numbered 1;
subsequent groups will be numbered one higher than the previous
group.@*
Corresponding string regexp: @samp{\(@dots{}\)}
@item (group-n @var{n} @var{rx}@dots{})
@cindex @code{group-n} in rx
@itemx (submatch-n @var{n} @var{rx}@dots{})
@cindex @code{submatch-n} in rx
Like @code{group}, but explicitly assign the group number @var{n}.
@var{n} must be positive.@*
Corresponding string regexp: @samp{\(?@var{n}:@dots{}\)}
@item (backref @var{n})
@cindex @code{backref} in rx
Match the text previously matched by group number @var{n}.
@var{n} must be in the range 1--9.@*
Corresponding string regexp: @samp{\@var{n}}
@end table
@subsubheading Dynamic inclusion
@table @code
@item (literal @var{expr})
@cindex @code{literal} in rx
Match the literal string that is the result from evaluating the Lisp
expression @var{expr}. The evaluation takes place at call time, in
the current lexical environment.
@item (regexp @var{expr})
@cindex @code{regexp} in rx
@itemx (regex @var{expr})
@cindex @code{regex} in rx
Match the string regexp that is the result from evaluating the Lisp
expression @var{expr}. The evaluation takes place at call time, in
the current lexical environment.
@item (eval @var{expr})
@cindex @code{eval} in rx
Match the rx form that is the result from evaluating the Lisp
expression @var{expr}. The evaluation takes place at macro-expansion
time for @code{rx}, at call time for @code{rx-to-string},
in the current global environment.
@end table
@node Rx Functions
@subsubsection Functions and macros using @code{rx} regexps
@defmac rx rx-expr@dots{}
Translate the @var{rx-expr}s to a string regexp, as if they were the
body of a @code{(seq @dots{})} form. The @code{rx} macro expands to a
string constant, or, if @code{literal} or @code{regexp} forms are
used, a Lisp expression that evaluates to a string.
@end defmac
@defun rx-to-string rx-expr &optional no-group
Translate @var{rx-expr} to a string regexp which is returned.
If @var{no-group} is absent or nil, bracket the result in a
non-capturing group, @samp{\(?:@dots{}\)}, if necessary to ensure that
a postfix operator appended to it will apply to the whole expression.
Arguments to @code{literal} and @code{regexp} forms in @var{rx-expr}
must be string literals.
@end defun
The @code{pcase} macro can use @code{rx} expressions as patterns
directly; @pxref{rx in pcase}.
@node Regexp Functions
@subsection Regular Expression Functions
These functions operate on regular expressions.
@cindex quote special characters in regexp
@defun regexp-quote string
This function returns a regular expression whose only exact match is
@var{string}. Using this regular expression in @code{looking-at} will
succeed only if the next characters in the buffer are @var{string};
using it in a search function will succeed if the text being searched
contains @var{string}. @xref{Regexp Search}.
This allows you to request an exact string match or search when calling
a function that wants a regular expression.
@example
@group
(regexp-quote "^The cat$")
@result{} "\\^The cat\\$"
@end group
@end example
One use of @code{regexp-quote} is to combine an exact string match with
context described as a regular expression. For example, this searches
for the string that is the value of @var{string}, surrounded by
whitespace:
@example
@group
(re-search-forward
(concat "\\s-" (regexp-quote string) "\\s-"))
@end group
@end example
@end defun
@cindex optimize regexp
@defun regexp-opt strings &optional paren keep-order
This function returns an efficient regular expression that will match
any of the strings in the list @var{strings}. This is useful when you
need to make matching or searching as fast as possible---for example,
for Font Lock mode@footnote{Note that @code{regexp-opt} does not
guarantee that its result is absolutely the most efficient form
possible. A hand-tuned regular expression can sometimes be slightly
more efficient, but is almost never worth the effort.}.
@c E.g., see https://debbugs.gnu.org/2816
If @var{strings} is the empty list, the return value is a regexp that
never matches anything.
The optional argument @var{paren} can be any of the following:
@table @asis
@item a string
The resulting regexp is preceded by @var{paren} and followed by
@samp{\)}, e.g. use @samp{"\\(?1:"} to produce an explicitly
numbered group.
@item @code{words}
The resulting regexp is surrounded by @samp{\<\(} and @samp{\)\>}.
@item @code{symbols}
The resulting regexp is surrounded by @samp{\_<\(} and @samp{\)\_>}
(this is often appropriate when matching programming-language
keywords and the like).
@item non-@code{nil}
The resulting regexp is surrounded by @samp{\(} and @samp{\)}.
@item @code{nil}
The resulting regexp is surrounded by @samp{\(?:} and @samp{\)},
if it is necessary to ensure that a postfix operator appended to
it will apply to the whole expression.
@end table
The optional argument @var{keep-order}, if @code{nil} or omitted,
allows the returned regexp to match the strings in any order. If
non-@code{nil}, the match is guaranteed to be performed in the order
given, as if the strings were made into a regexp by joining them with
the @samp{\|} operator.
Up to reordering, the resulting regexp of @code{regexp-opt} is
equivalent to but usually more efficient than that of a simplified
version:
@example
(defun simplified-regexp-opt (strings &optional paren)
(let ((parens
(cond
((stringp paren) (cons paren "\\)"))
((eq paren 'words) '("\\<\\(" . "\\)\\>"))
((eq paren 'symbols) '("\\_<\\(" . "\\)\\_>"))
((null paren) '("\\(?:" . "\\)"))
(t '("\\(" . "\\)")))))
(concat (car parens)
(mapconcat 'regexp-quote strings "\\|")
(cdr parens))))
@end example
@end defun
@defun regexp-opt-depth regexp
This function returns the total number of grouping constructs
(parenthesized expressions) in @var{regexp}. This does not include
shy groups (@pxref{Regexp Backslash}).
@end defun
@c Supposedly an internal regexp-opt function, but table.el uses it at least.
@defun regexp-opt-charset chars
This function returns a regular expression matching a character in the
list of characters @var{chars}.
@example
(regexp-opt-charset '(?a ?b ?c ?d ?e))
@result{} "[a-e]"
@end example
@end defun
@c Internal functions: regexp-opt-group
@defvar regexp-unmatchable
This variable contains a regexp that is guaranteed not to match any
string at all. It is particularly useful as default value for
variables that may be set to a pattern that actually matches
something.
@end defvar
@node Regexp Search
@section Regular Expression Searching
@cindex regular expression searching
@cindex regexp searching
@cindex searching for regexp
In GNU Emacs, you can search for the next match for a regular
expression (@pxref{Syntax of Regexps}) either incrementally or not.
For incremental search commands, see @ref{Regexp Search, , Regular
Expression Search, emacs, The GNU Emacs Manual}. Here we describe
only the search functions useful in programs. The principal one is
@code{re-search-forward}.
These search functions convert the regular expression to multibyte if
the buffer is multibyte; they convert the regular expression to unibyte
if the buffer is unibyte. @xref{Text Representations}.
@deffn Command re-search-forward regexp &optional limit noerror count
This function searches forward in the current buffer for a string of
text that is matched by the regular expression @var{regexp}. The
function skips over any amount of text that is not matched by
@var{regexp}, and leaves point at the end of the first match found.
It returns the new value of point.
If @var{limit} is non-@code{nil}, it must be a position in the current
buffer. It specifies the upper bound to the search. No match
extending after that position is accepted. If @var{limit} is omitted
or @code{nil}, it defaults to the end of the accessible portion of the
buffer.
What @code{re-search-forward} does when the search fails depends on
the value of @var{noerror}:
@table @asis
@item @code{nil}
Signal a @code{search-failed} error.
@item @code{t}
Do nothing and return @code{nil}.
@item anything else
Move point to @var{limit} (or the end of the accessible portion of the
buffer) and return @code{nil}.
@end table
The argument @var{noerror} only affects valid searches which fail to
find a match. Invalid arguments cause errors regardless of
@var{noerror}.
If @var{count} is a positive number @var{n}, the search is done
@var{n} times; each successive search starts at the end of the
previous match. If all these successive searches succeed, the
function call succeeds, moving point and returning its new value.
Otherwise the function call fails, with results depending on the value
of @var{noerror}, as described above. If @var{count} is a negative
number @minus{}@var{n}, the search is done @var{n} times in the opposite
(backward) direction.
In the following example, point is initially before the @samp{T}.
Evaluating the search call moves point to the end of that line (between
the @samp{t} of @samp{hat} and the newline).
@example
@group
---------- Buffer: foo ----------
I read "@point{}The cat in the hat
comes back" twice.
---------- Buffer: foo ----------
@end group
@group
(re-search-forward "[a-z]+" nil t 5)
@result{} 27
---------- Buffer: foo ----------
I read "The cat in the hat@point{}
comes back" twice.
---------- Buffer: foo ----------
@end group
@end example
@end deffn
@c This anchor is referenced by re-search-backward's docstring.
@anchor{re-search-backward}
@deffn Command re-search-backward regexp &optional limit noerror count
This function searches backward in the current buffer for a string of
text that is matched by the regular expression @var{regexp}, leaving
point at the beginning of the first text found.
This function is analogous to @code{re-search-forward}, but they are not
simple mirror images. @code{re-search-forward} finds the match whose
beginning is as close as possible to the starting point. If
@code{re-search-backward} were a perfect mirror image, it would find the
match whose end is as close as possible. However, in fact it finds the
match whose beginning is as close as possible (and yet ends before the
starting point). The reason for this is that matching a regular
expression at a given spot always works from beginning to end, and
starts at a specified beginning position.
A true mirror-image of @code{re-search-forward} would require a special
feature for matching regular expressions from end to beginning. It's
not worth the trouble of implementing that.
@end deffn
@defun string-match regexp string &optional start
This function returns the index of the start of the first match for
the regular expression @var{regexp} in @var{string}, or @code{nil} if
there is no match. If @var{start} is non-@code{nil}, the search starts
at that index in @var{string}.
For example,
@example
@group
(string-match
"quick" "The quick brown fox jumped quickly.")
@result{} 4
@end group
@group
(string-match
"quick" "The quick brown fox jumped quickly." 8)
@result{} 27
@end group
@end example
@noindent
The index of the first character of the
string is 0, the index of the second character is 1, and so on.
If this function finds a match, the index of the first character beyond
the match is available as @code{(match-end 0)}. @xref{Match Data}.
@example
@group
(string-match
"quick" "The quick brown fox jumped quickly." 8)
@result{} 27
@end group
@group
(match-end 0)
@result{} 32
@end group
@end example
@end defun
@defun string-match-p regexp string &optional start
This predicate function does what @code{string-match} does, but it
avoids modifying the match data.
@end defun
@defun looking-at regexp
This function determines whether the text in the current buffer directly
following point matches the regular expression @var{regexp}. ``Directly
following'' means precisely that: the search is ``anchored'' and it can
succeed only starting with the first character following point. The
result is @code{t} if so, @code{nil} otherwise.
This function does not move point, but it does update the match data.
@xref{Match Data}. If you need to test for a match without modifying
the match data, use @code{looking-at-p}, described below.
In this example, point is located directly before the @samp{T}. If it
were anywhere else, the result would be @code{nil}.
@example
@group
---------- Buffer: foo ----------
I read "@point{}The cat in the hat
comes back" twice.
---------- Buffer: foo ----------
(looking-at "The cat in the hat$")
@result{} t
@end group
@end example
@end defun
@defun looking-back regexp limit &optional greedy
This function returns @code{t} if @var{regexp} matches the text
immediately before point (i.e., ending at point), and @code{nil} otherwise.
Because regular expression matching works only going forward, this is
implemented by searching backwards from point for a match that ends at
point. That can be quite slow if it has to search a long distance.
You can bound the time required by specifying a non-@code{nil} value
for @var{limit}, which says not to search before @var{limit}. In this
case, the match that is found must begin at or after @var{limit}.
Here's an example:
@example
@group
---------- Buffer: foo ----------
I read "@point{}The cat in the hat
comes back" twice.
---------- Buffer: foo ----------
(looking-back "read \"" 3)
@result{} t
(looking-back "read \"" 4)
@result{} nil
@end group
@end example
If @var{greedy} is non-@code{nil}, this function extends the match
backwards as far as possible, stopping when a single additional
previous character cannot be part of a match for @var{regexp}. When
the match is extended, its starting position is allowed to occur
before @var{limit}.
@c https://debbugs.gnu.org/5689
As a general recommendation, try to avoid using @code{looking-back}
wherever possible, since it is slow. For this reason, there are no
plans to add a @code{looking-back-p} function.
@end defun
@defun looking-at-p regexp
This predicate function works like @code{looking-at}, but without
updating the match data.
@end defun
@defvar search-spaces-regexp
If this variable is non-@code{nil}, it should be a regular expression
that says how to search for whitespace. In that case, any group of
spaces in a regular expression being searched for stands for use of
this regular expression. However, spaces inside of constructs such as
@samp{[@dots{}]} and @samp{*}, @samp{+}, @samp{?} are not affected by
@code{search-spaces-regexp}.
Since this variable affects all regular expression search and match
constructs, you should bind it temporarily for as small as possible
a part of the code.
@end defvar
@node POSIX Regexps
@section POSIX Regular Expression Searching
@cindex backtracking and POSIX regular expressions
The usual regular expression functions do backtracking when necessary
to handle the @samp{\|} and repetition constructs, but they continue
this only until they find @emph{some} match. Then they succeed and
report the first match found.
This section describes alternative search functions which perform the
full backtracking specified by the POSIX standard for regular expression
matching. They continue backtracking until they have tried all
possibilities and found all matches, so they can report the longest
match, as required by POSIX@. This is much slower, so use these
functions only when you really need the longest match.
The POSIX search and match functions do not properly support the
non-greedy repetition operators (@pxref{Regexp Special, non-greedy}).
This is because POSIX backtracking conflicts with the semantics of
non-greedy repetition.
@deffn Command posix-search-forward regexp &optional limit noerror count
This is like @code{re-search-forward} except that it performs the full
backtracking specified by the POSIX standard for regular expression
matching.
@end deffn
@deffn Command posix-search-backward regexp &optional limit noerror count
This is like @code{re-search-backward} except that it performs the full
backtracking specified by the POSIX standard for regular expression
matching.
@end deffn
@defun posix-looking-at regexp
This is like @code{looking-at} except that it performs the full
backtracking specified by the POSIX standard for regular expression
matching.
@end defun
@defun posix-string-match regexp string &optional start
This is like @code{string-match} except that it performs the full
backtracking specified by the POSIX standard for regular expression
matching.
@end defun
@node Match Data
@section The Match Data
@cindex match data
Emacs keeps track of the start and end positions of the segments of
text found during a search; this is called the @dfn{match data}.
Thanks to the match data, you can search for a complex pattern, such
as a date in a mail message, and then extract parts of the match under
control of the pattern.
Because the match data normally describe the most recent search only,
you must be careful not to do another search inadvertently between the
search you wish to refer back to and the use of the match data. If you
can't avoid another intervening search, you must save and restore the
match data around it, to prevent it from being overwritten.
Notice that all functions are allowed to overwrite the match data
unless they're explicitly documented not to do so. A consequence is
that functions that are run implicitly in the background
(@pxref{Timers}, and @ref{Idle Timers}) should likely save and restore
the match data explicitly.
@menu
* Replacing Match:: Replacing a substring that was matched.
* Simple Match Data:: Accessing single items of match data,
such as where a particular subexpression started.
* Entire Match Data:: Accessing the entire match data at once, as a list.
* Saving Match Data:: Saving and restoring the match data.
@end menu
@node Replacing Match
@subsection Replacing the Text that Matched
@cindex replace matched text
This function replaces all or part of the text matched by the last
search. It works by means of the match data.
@cindex case in replacements
@defun replace-match replacement &optional fixedcase literal string subexp
This function performs a replacement operation on a buffer or string.
If you did the last search in a buffer, you should omit the
@var{string} argument or specify @code{nil} for it, and make sure that
the current buffer is the one in which you performed the last search.
Then this function edits the buffer, replacing the matched text with
@var{replacement}. It leaves point at the end of the replacement
text.
If you performed the last search on a string, pass the same string as
@var{string}. Then this function returns a new string, in which the
matched text is replaced by @var{replacement}.
If @var{fixedcase} is non-@code{nil}, then @code{replace-match} uses
the replacement text without case conversion; otherwise, it converts
the replacement text depending upon the capitalization of the text to
be replaced. If the original text is all upper case, this converts
the replacement text to upper case. If all words of the original text
are capitalized, this capitalizes all the words of the replacement
text. If all the words are one-letter and they are all upper case,
they are treated as capitalized words rather than all-upper-case
words.
If @var{literal} is non-@code{nil}, then @var{replacement} is inserted
exactly as it is, the only alterations being case changes as needed.
If it is @code{nil} (the default), then the character @samp{\} is treated
specially. If a @samp{\} appears in @var{replacement}, then it must be
part of one of the following sequences:
@table @asis
@item @samp{\&}
@cindex @samp{&} in replacement
This stands for the entire text being replaced.
@item @samp{\@var{n}}, where @var{n} is a digit
@cindex @samp{\@var{n}} in replacement
This stands for the text that matched the @var{n}th subexpression in
the original regexp. Subexpressions are those expressions grouped
inside @samp{\(@dots{}\)}. If the @var{n}th subexpression never
matched, an empty string is substituted.
@item @samp{\\}
@cindex @samp{\} in replacement
This stands for a single @samp{\} in the replacement text.
@item @samp{\?}
This stands for itself (for compatibility with @code{replace-regexp}
and related commands; @pxref{Regexp Replace,,, emacs, The GNU
Emacs Manual}).
@end table
@noindent
Any other character following @samp{\} signals an error.
The substitutions performed by @samp{\&} and @samp{\@var{n}} occur
after case conversion, if any. Therefore, the strings they substitute
are never case-converted.
If @var{subexp} is non-@code{nil}, that says to replace just
subexpression number @var{subexp} of the regexp that was matched, not
the entire match. For example, after matching @samp{foo \(ba*r\)},
calling @code{replace-match} with 1 as @var{subexp} means to replace
just the text that matched @samp{\(ba*r\)}.
@end defun
@defun match-substitute-replacement replacement &optional fixedcase literal string subexp
This function returns the text that would be inserted into the buffer
by @code{replace-match}, but without modifying the buffer. It is
useful if you want to present the user with actual replacement result,
with constructs like @samp{\@var{n}} or @samp{\&} substituted with
matched groups. Arguments @var{replacement} and optional
@var{fixedcase}, @var{literal}, @var{string} and @var{subexp} have the
same meaning as for @code{replace-match}.
@end defun
@node Simple Match Data
@subsection Simple Match Data Access
This section explains how to use the match data to find out what was
matched by the last search or match operation, if it succeeded.
You can ask about the entire matching text, or about a particular
parenthetical subexpression of a regular expression. The @var{count}
argument in the functions below specifies which. If @var{count} is
zero, you are asking about the entire match. If @var{count} is
positive, it specifies which subexpression you want.
Recall that the subexpressions of a regular expression are those
expressions grouped with escaped parentheses, @samp{\(@dots{}\)}. The
@var{count}th subexpression is found by counting occurrences of
@samp{\(} from the beginning of the whole regular expression. The first
subexpression is numbered 1, the second 2, and so on. Only regular
expressions can have subexpressions---after a simple string search, the
only information available is about the entire match.
Every successful search sets the match data. Therefore, you should
query the match data immediately after searching, before calling any
other function that might perform another search. Alternatively, you
may save and restore the match data (@pxref{Saving Match Data}) around
the call to functions that could perform another search. Or use the
functions that explicitly do not modify the match data;
e.g., @code{string-match-p}.
@c This is an old comment and presumably there is no prospect of this
@c changing now. But still the advice stands.
A search which fails may or may not alter the match data. In the
current implementation, it does not, but we may change it in the
future. Don't try to rely on the value of the match data after a
failing search.
@defun match-string count &optional in-string
This function returns, as a string, the text matched in the last search
or match operation. It returns the entire text if @var{count} is zero,
or just the portion corresponding to the @var{count}th parenthetical
subexpression, if @var{count} is positive.
If the last such operation was done against a string with
@code{string-match}, then you should pass the same string as the
argument @var{in-string}. After a buffer search or match,
you should omit @var{in-string} or pass @code{nil} for it; but you
should make sure that the current buffer when you call
@code{match-string} is the one in which you did the searching or
matching. Failure to follow this advice will lead to incorrect results.
The value is @code{nil} if @var{count} is out of range, or for a
subexpression inside a @samp{\|} alternative that wasn't used or a
repetition that repeated zero times.
@end defun
@defun match-string-no-properties count &optional in-string
This function is like @code{match-string} except that the result
has no text properties.
@end defun
@defun match-beginning count
If the last regular expression search found a match, this function
returns the position of the start of the matching text or of a
subexpression of it.
If @var{count} is zero, then the value is the position of the start of
the entire match. Otherwise, @var{count} specifies a subexpression in
the regular expression, and the value of the function is the starting
position of the match for that subexpression.
The value is @code{nil} for a subexpression inside a @samp{\|}
alternative that wasn't used or a repetition that repeated zero times.
@end defun
@defun match-end count
This function is like @code{match-beginning} except that it returns the
position of the end of the match, rather than the position of the
beginning.
@end defun
Here is an example of using the match data, with a comment showing the
positions within the text:
@example
@group
(string-match "\\(qu\\)\\(ick\\)"
"The quick fox jumped quickly.")
;0123456789
@result{} 4
@end group
@group
(match-string 0 "The quick fox jumped quickly.")
@result{} "quick"
(match-string 1 "The quick fox jumped quickly.")
@result{} "qu"
(match-string 2 "The quick fox jumped quickly.")
@result{} "ick"
@end group
@group
(match-beginning 1) ; @r{The beginning of the match}
@result{} 4 ; @r{with @samp{qu} is at index 4.}
@end group
@group
(match-beginning 2) ; @r{The beginning of the match}
@result{} 6 ; @r{with @samp{ick} is at index 6.}
@end group
@group
(match-end 1) ; @r{The end of the match}
@result{} 6 ; @r{with @samp{qu} is at index 6.}
(match-end 2) ; @r{The end of the match}
@result{} 9 ; @r{with @samp{ick} is at index 9.}
@end group
@end example
Here is another example. Point is initially located at the beginning
of the line. Searching moves point to between the space and the word
@samp{in}. The beginning of the entire match is at the 9th character of
the buffer (@samp{T}), and the beginning of the match for the first
subexpression is at the 13th character (@samp{c}).
@example
@group
(list
(re-search-forward "The \\(cat \\)")
(match-beginning 0)
(match-beginning 1))
@result{} (17 9 13)
@end group
@group
---------- Buffer: foo ----------
I read "The cat @point{}in the hat comes back" twice.
^ ^
9 13
---------- Buffer: foo ----------
@end group
@end example
@noindent
(In this case, the index returned is a buffer position; the first
character of the buffer counts as 1.)
@node Entire Match Data
@subsection Accessing the Entire Match Data
The functions @code{match-data} and @code{set-match-data} read or
write the entire match data, all at once.
@defun match-data &optional integers reuse reseat
This function returns a list of positions (markers or integers) that
record all the information on the text that the last search matched.
Element zero is the position of the beginning of the match for the
whole expression; element one is the position of the end of the match
for the expression. The next two elements are the positions of the
beginning and end of the match for the first subexpression, and so on.
In general, element
@ifnottex
number 2@var{n}
@end ifnottex
@tex
number {\mathsurround=0pt $2n$}
@end tex
corresponds to @code{(match-beginning @var{n})}; and
element
@ifnottex
number 2@var{n} + 1
@end ifnottex
@tex
number {\mathsurround=0pt $2n+1$}
@end tex
corresponds to @code{(match-end @var{n})}.
Normally all the elements are markers or @code{nil}, but if
@var{integers} is non-@code{nil}, that means to use integers instead
of markers. (In that case, the buffer itself is appended as an
additional element at the end of the list, to facilitate complete
restoration of the match data.) If the last match was done on a
string with @code{string-match}, then integers are always used,
since markers can't point into a string.
If @var{reuse} is non-@code{nil}, it should be a list. In that case,
@code{match-data} stores the match data in @var{reuse}. That is,
@var{reuse} is destructively modified. @var{reuse} does not need to
have the right length. If it is not long enough to contain the match
data, it is extended. If it is too long, the length of @var{reuse}
stays the same, but the elements that were not used are set to
@code{nil}. The purpose of this feature is to reduce the need for
garbage collection.
If @var{reseat} is non-@code{nil}, all markers on the @var{reuse} list
are reseated to point to nowhere.
As always, there must be no possibility of intervening searches between
the call to a search function and the call to @code{match-data} that is
intended to access the match data for that search.
@example
@group
(match-data)
@result{} (#<marker at 9 in foo>
#<marker at 17 in foo>
#<marker at 13 in foo>
#<marker at 17 in foo>)
@end group
@end example
@end defun
@defun set-match-data match-list &optional reseat
This function sets the match data from the elements of @var{match-list},
which should be a list that was the value of a previous call to
@code{match-data}. (More precisely, anything that has the same format
will work.)
If @var{match-list} refers to a buffer that doesn't exist, you don't get
an error; that sets the match data in a meaningless but harmless way.
If @var{reseat} is non-@code{nil}, all markers on the @var{match-list} list
are reseated to point to nowhere.
@c TODO Make it properly obsolete.
@findex store-match-data
@code{store-match-data} is a semi-obsolete alias for @code{set-match-data}.
@end defun
@node Saving Match Data
@subsection Saving and Restoring the Match Data
When you call a function that may search, you may need to save
and restore the match data around that call, if you want to preserve the
match data from an earlier search for later use. Here is an example
that shows the problem that arises if you fail to save the match data:
@example
@group
(re-search-forward "The \\(cat \\)")
@result{} 48
(foo) ; @r{@code{foo} does more searching.}
(match-end 0)
@result{} 61 ; @r{Unexpected result---not 48!}
@end group
@end example
You can save and restore the match data with @code{save-match-data}:
@defmac save-match-data body@dots{}
This macro executes @var{body}, saving and restoring the match
data around it. The return value is the value of the last form in
@var{body}.
@end defmac
You could use @code{set-match-data} together with @code{match-data} to
imitate the effect of the special form @code{save-match-data}. Here is
how:
@example
@group
(let ((data (match-data)))
(unwind-protect
@dots{} ; @r{Ok to change the original match data.}
(set-match-data data)))
@end group
@end example
Emacs automatically saves and restores the match data when it runs
process filter functions (@pxref{Filter Functions}) and process
sentinels (@pxref{Sentinels}).
@ignore
Here is a function which restores the match data provided the buffer
associated with it still exists.
@smallexample
@group
(defun restore-match-data (data)
@c It is incorrect to split the first line of a doc string.
@c If there's a problem here, it should be solved in some other way.
"Restore the match data DATA unless the buffer is missing."
(catch 'foo
(let ((d data))
@end group
(while d
(and (car d)
(null (marker-buffer (car d)))
@group
;; @file{match-data} @r{buffer is deleted.}
(throw 'foo nil))
(setq d (cdr d)))
(set-match-data data))))
@end group
@end smallexample
@end ignore
@node Search and Replace
@section Search and Replace
@cindex replacement after search
@cindex searching and replacing
If you want to find all matches for a regexp in part of the buffer,
and replace them, the best way is to write an explicit loop using
@code{re-search-forward} and @code{replace-match}, like this:
@example
(while (re-search-forward "foo[ \t]+bar" nil t)
(replace-match "foobar"))
@end example
@noindent
@xref{Replacing Match,, Replacing the Text that Matched}, for a
description of @code{replace-match}.
However, replacing matches in a string is more complex, especially
if you want to do it efficiently. So Emacs provides a function to do
this.
@defun replace-regexp-in-string regexp rep string &optional fixedcase literal subexp start
This function copies @var{string} and searches it for matches for
@var{regexp}, and replaces them with @var{rep}. It returns the
modified copy. If @var{start} is non-@code{nil}, the search for
matches starts at that index in @var{string}, and the returned value
does not include the first @var{start} characters of @var{string}.
To get the whole transformed string, concatenate the first
@var{start} characters of @var{string} with the return value.
This function uses @code{replace-match} to do the replacement, and it
passes the optional arguments @var{fixedcase}, @var{literal} and
@var{subexp} along to @code{replace-match}.
Instead of a string, @var{rep} can be a function. In that case,
@code{replace-regexp-in-string} calls @var{rep} for each match,
passing the text of the match as its sole argument. It collects the
value @var{rep} returns and passes that to @code{replace-match} as the
replacement string. The match data at this point are the result
of matching @var{regexp} against a substring of @var{string}.
@end defun
If you want to write a command along the lines of @code{query-replace},
you can use @code{perform-replace} to do the work.
@defun perform-replace from-string replacements query-flag regexp-flag delimited-flag &optional repeat-count map start end backward region-noncontiguous-p
This function is the guts of @code{query-replace} and related
commands. It searches for occurrences of @var{from-string} in the
text between positions @var{start} and @var{end} and replaces some or
all of them. If @var{start} is @code{nil} (or omitted), point is used
instead, and the end of the buffer's accessible portion is used for
@var{end}. (If the optional argument @var{backward} is
non-@code{nil}, the search starts at @var{end} and goes backward.)
If @var{query-flag} is @code{nil}, it replaces all
occurrences; otherwise, it asks the user what to do about each one.
If @var{regexp-flag} is non-@code{nil}, then @var{from-string} is
considered a regular expression; otherwise, it must match literally. If
@var{delimited-flag} is non-@code{nil}, then only replacements
surrounded by word boundaries are considered.
The argument @var{replacements} specifies what to replace occurrences
with. If it is a string, that string is used. It can also be a list of
strings, to be used in cyclic order.
If @var{replacements} is a cons cell, @w{@code{(@var{function}
. @var{data})}}, this means to call @var{function} after each match to
get the replacement text. This function is called with two arguments:
@var{data}, and the number of replacements already made.
If @var{repeat-count} is non-@code{nil}, it should be an integer. Then
it specifies how many times to use each of the strings in the
@var{replacements} list before advancing cyclically to the next one.
If @var{from-string} contains upper-case letters, then
@code{perform-replace} binds @code{case-fold-search} to @code{nil}, and
it uses the @var{replacements} without altering their case.
Normally, the keymap @code{query-replace-map} defines the possible
user responses for queries. The argument @var{map}, if
non-@code{nil}, specifies a keymap to use instead of
@code{query-replace-map}.
Non-@code{nil} @var{region-noncontiguous-p} means that the region
between @var{start} and @var{end} is composed of noncontiguous pieces.
The most common example of this is a rectangular region, where the
pieces are separated by newline characters.
This function uses one of two functions to search for the next
occurrence of @var{from-string}. These functions are specified by the
values of two variables: @code{replace-re-search-function} and
@code{replace-search-function}. The former is called when the
argument @var{regexp-flag} is non-@code{nil}, the latter when it is
@code{nil}.
@end defun
@defvar query-replace-map
This variable holds a special keymap that defines the valid user
responses for @code{perform-replace} and the commands that use it, as
well as @code{y-or-n-p} and @code{map-y-or-n-p}. This map is unusual
in two ways:
@itemize @bullet
@item
The key bindings are not commands, just symbols that are meaningful
to the functions that use this map.
@item
Prefix keys are not supported; each key binding must be for a
single-event key sequence. This is because the functions don't use
@code{read-key-sequence} to get the input; instead, they read a single
event and look it up ``by hand''.
@end itemize
@end defvar
Here are the meaningful bindings for @code{query-replace-map}.
Several of them are meaningful only for @code{query-replace} and
friends.
@table @code
@item act
Do take the action being considered---in other words, ``yes''.
@item skip
Do not take action for this question---in other words, ``no''.
@item exit
Answer this question ``no'', and give up on the entire series of
questions, assuming that the answers will be ``no''.
@item exit-prefix
Like @code{exit}, but add the key that was pressed to
@code{unread-command-events} (@pxref{Event Input Misc}).
@item act-and-exit
Answer this question ``yes'', and give up on the entire series of
questions, assuming that subsequent answers will be ``no''.
@item act-and-show
Answer this question ``yes'', but show the results---don't advance yet
to the next question.
@item automatic
Answer this question and all subsequent questions in the series with
``yes'', without further user interaction.
@item backup
Move back to the previous place that a question was asked about.
@item undo
Undo last replacement and move back to the place where that
replacement was performed.
@item undo-all
Undo all replacements and move back to the place where the first
replacement was performed.
@item edit
Enter a recursive edit to deal with this question---instead of any
other action that would normally be taken.
@item edit-replacement
Edit the replacement for this question in the minibuffer.
@item delete-and-edit
Delete the text being considered, then enter a recursive edit to replace
it.
@item recenter
@itemx scroll-up
@itemx scroll-down
@itemx scroll-other-window
@itemx scroll-other-window-down
Perform the specified window scroll operation, then ask the same
question again. Only @code{y-or-n-p} and related functions use this
answer.
@item quit
Perform a quit right away. Only @code{y-or-n-p} and related functions
use this answer.
@item help
Display some help, then ask again.
@end table
@defvar multi-query-replace-map
This variable holds a keymap that extends @code{query-replace-map} by
providing additional keybindings that are useful in multi-buffer
replacements. The additional bindings are:
@table @code
@item automatic-all
Answer this question and all subsequent questions in the series with
``yes'', without further user interaction, for all remaining buffers.
@item exit-current
Answer this question ``no'', and give up on the entire series of
questions for the current buffer. Continue to the next buffer in the
sequence.
@end table
@end defvar
@defvar replace-search-function
This variable specifies a function that @code{perform-replace} calls
to search for the next string to replace. Its default value is
@code{search-forward}. Any other value should name a function of 3
arguments: the first 3 arguments of @code{search-forward}
(@pxref{String Search}).
@end defvar
@defvar replace-re-search-function
This variable specifies a function that @code{perform-replace} calls
to search for the next regexp to replace. Its default value is
@code{re-search-forward}. Any other value should name a function of 3
arguments: the first 3 arguments of @code{re-search-forward}
(@pxref{Regexp Search}).
@end defvar
@node Standard Regexps
@section Standard Regular Expressions Used in Editing
@cindex regexps used standardly in editing
@cindex standard regexps used in editing
This section describes some variables that hold regular expressions
used for certain purposes in editing:
@defopt page-delimiter
This is the regular expression describing line-beginnings that separate
pages. The default value is @code{"^\014"} (i.e., @code{"^^L"} or
@code{"^\C-l"}); this matches a line that starts with a formfeed
character.
@end defopt
The following two regular expressions should @emph{not} assume the
match always starts at the beginning of a line; they should not use
@samp{^} to anchor the match. Most often, the paragraph commands do
check for a match only at the beginning of a line, which means that
@samp{^} would be superfluous. When there is a nonzero left margin,
they accept matches that start after the left margin. In that case, a
@samp{^} would be incorrect. However, a @samp{^} is harmless in modes
where a left margin is never used.
@defopt paragraph-separate
This is the regular expression for recognizing the beginning of a line
that separates paragraphs. (If you change this, you may have to
change @code{paragraph-start} also.) The default value is
@w{@code{"[@ \t\f]*$"}}, which matches a line that consists entirely of
spaces, tabs, and form feeds (after its left margin).
@end defopt
@defopt paragraph-start
This is the regular expression for recognizing the beginning of a line
that starts @emph{or} separates paragraphs. The default value is
@w{@code{"\f\\|[ \t]*$"}}, which matches a line containing only
whitespace or starting with a form feed (after its left margin).
@end defopt
@defopt sentence-end
If non-@code{nil}, the value should be a regular expression describing
the end of a sentence, including the whitespace following the
sentence. (All paragraph boundaries also end sentences, regardless.)
If the value is @code{nil}, as it is by default, then the function
@code{sentence-end} constructs the regexp. That is why you
should always call the function @code{sentence-end} to obtain the
regexp to be used to recognize the end of a sentence.
@end defopt
@defun sentence-end
This function returns the value of the variable @code{sentence-end},
if non-@code{nil}. Otherwise it returns a default value based on the
values of the variables @code{sentence-end-double-space}
(@pxref{Definition of sentence-end-double-space}),
@code{sentence-end-without-period}, and
@code{sentence-end-without-space}.
@end defun
|