File: pcre.c

package info (click to toggle)
pennmush 1.8.0p4-1
  • links: PTS
  • area: main
  • in suites: sarge
  • size: 8,068 kB
  • ctags: 6,319
  • sloc: ansic: 68,221; sh: 7,056; perl: 1,150; makefile: 284
file content (7713 lines) | stat: -rw-r--r-- 238,907 bytes parent folder | download | duplicates (2)
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
2604
2605
2606
2607
2608
2609
2610
2611
2612
2613
2614
2615
2616
2617
2618
2619
2620
2621
2622
2623
2624
2625
2626
2627
2628
2629
2630
2631
2632
2633
2634
2635
2636
2637
2638
2639
2640
2641
2642
2643
2644
2645
2646
2647
2648
2649
2650
2651
2652
2653
2654
2655
2656
2657
2658
2659
2660
2661
2662
2663
2664
2665
2666
2667
2668
2669
2670
2671
2672
2673
2674
2675
2676
2677
2678
2679
2680
2681
2682
2683
2684
2685
2686
2687
2688
2689
2690
2691
2692
2693
2694
2695
2696
2697
2698
2699
2700
2701
2702
2703
2704
2705
2706
2707
2708
2709
2710
2711
2712
2713
2714
2715
2716
2717
2718
2719
2720
2721
2722
2723
2724
2725
2726
2727
2728
2729
2730
2731
2732
2733
2734
2735
2736
2737
2738
2739
2740
2741
2742
2743
2744
2745
2746
2747
2748
2749
2750
2751
2752
2753
2754
2755
2756
2757
2758
2759
2760
2761
2762
2763
2764
2765
2766
2767
2768
2769
2770
2771
2772
2773
2774
2775
2776
2777
2778
2779
2780
2781
2782
2783
2784
2785
2786
2787
2788
2789
2790
2791
2792
2793
2794
2795
2796
2797
2798
2799
2800
2801
2802
2803
2804
2805
2806
2807
2808
2809
2810
2811
2812
2813
2814
2815
2816
2817
2818
2819
2820
2821
2822
2823
2824
2825
2826
2827
2828
2829
2830
2831
2832
2833
2834
2835
2836
2837
2838
2839
2840
2841
2842
2843
2844
2845
2846
2847
2848
2849
2850
2851
2852
2853
2854
2855
2856
2857
2858
2859
2860
2861
2862
2863
2864
2865
2866
2867
2868
2869
2870
2871
2872
2873
2874
2875
2876
2877
2878
2879
2880
2881
2882
2883
2884
2885
2886
2887
2888
2889
2890
2891
2892
2893
2894
2895
2896
2897
2898
2899
2900
2901
2902
2903
2904
2905
2906
2907
2908
2909
2910
2911
2912
2913
2914
2915
2916
2917
2918
2919
2920
2921
2922
2923
2924
2925
2926
2927
2928
2929
2930
2931
2932
2933
2934
2935
2936
2937
2938
2939
2940
2941
2942
2943
2944
2945
2946
2947
2948
2949
2950
2951
2952
2953
2954
2955
2956
2957
2958
2959
2960
2961
2962
2963
2964
2965
2966
2967
2968
2969
2970
2971
2972
2973
2974
2975
2976
2977
2978
2979
2980
2981
2982
2983
2984
2985
2986
2987
2988
2989
2990
2991
2992
2993
2994
2995
2996
2997
2998
2999
3000
3001
3002
3003
3004
3005
3006
3007
3008
3009
3010
3011
3012
3013
3014
3015
3016
3017
3018
3019
3020
3021
3022
3023
3024
3025
3026
3027
3028
3029
3030
3031
3032
3033
3034
3035
3036
3037
3038
3039
3040
3041
3042
3043
3044
3045
3046
3047
3048
3049
3050
3051
3052
3053
3054
3055
3056
3057
3058
3059
3060
3061
3062
3063
3064
3065
3066
3067
3068
3069
3070
3071
3072
3073
3074
3075
3076
3077
3078
3079
3080
3081
3082
3083
3084
3085
3086
3087
3088
3089
3090
3091
3092
3093
3094
3095
3096
3097
3098
3099
3100
3101
3102
3103
3104
3105
3106
3107
3108
3109
3110
3111
3112
3113
3114
3115
3116
3117
3118
3119
3120
3121
3122
3123
3124
3125
3126
3127
3128
3129
3130
3131
3132
3133
3134
3135
3136
3137
3138
3139
3140
3141
3142
3143
3144
3145
3146
3147
3148
3149
3150
3151
3152
3153
3154
3155
3156
3157
3158
3159
3160
3161
3162
3163
3164
3165
3166
3167
3168
3169
3170
3171
3172
3173
3174
3175
3176
3177
3178
3179
3180
3181
3182
3183
3184
3185
3186
3187
3188
3189
3190
3191
3192
3193
3194
3195
3196
3197
3198
3199
3200
3201
3202
3203
3204
3205
3206
3207
3208
3209
3210
3211
3212
3213
3214
3215
3216
3217
3218
3219
3220
3221
3222
3223
3224
3225
3226
3227
3228
3229
3230
3231
3232
3233
3234
3235
3236
3237
3238
3239
3240
3241
3242
3243
3244
3245
3246
3247
3248
3249
3250
3251
3252
3253
3254
3255
3256
3257
3258
3259
3260
3261
3262
3263
3264
3265
3266
3267
3268
3269
3270
3271
3272
3273
3274
3275
3276
3277
3278
3279
3280
3281
3282
3283
3284
3285
3286
3287
3288
3289
3290
3291
3292
3293
3294
3295
3296
3297
3298
3299
3300
3301
3302
3303
3304
3305
3306
3307
3308
3309
3310
3311
3312
3313
3314
3315
3316
3317
3318
3319
3320
3321
3322
3323
3324
3325
3326
3327
3328
3329
3330
3331
3332
3333
3334
3335
3336
3337
3338
3339
3340
3341
3342
3343
3344
3345
3346
3347
3348
3349
3350
3351
3352
3353
3354
3355
3356
3357
3358
3359
3360
3361
3362
3363
3364
3365
3366
3367
3368
3369
3370
3371
3372
3373
3374
3375
3376
3377
3378
3379
3380
3381
3382
3383
3384
3385
3386
3387
3388
3389
3390
3391
3392
3393
3394
3395
3396
3397
3398
3399
3400
3401
3402
3403
3404
3405
3406
3407
3408
3409
3410
3411
3412
3413
3414
3415
3416
3417
3418
3419
3420
3421
3422
3423
3424
3425
3426
3427
3428
3429
3430
3431
3432
3433
3434
3435
3436
3437
3438
3439
3440
3441
3442
3443
3444
3445
3446
3447
3448
3449
3450
3451
3452
3453
3454
3455
3456
3457
3458
3459
3460
3461
3462
3463
3464
3465
3466
3467
3468
3469
3470
3471
3472
3473
3474
3475
3476
3477
3478
3479
3480
3481
3482
3483
3484
3485
3486
3487
3488
3489
3490
3491
3492
3493
3494
3495
3496
3497
3498
3499
3500
3501
3502
3503
3504
3505
3506
3507
3508
3509
3510
3511
3512
3513
3514
3515
3516
3517
3518
3519
3520
3521
3522
3523
3524
3525
3526
3527
3528
3529
3530
3531
3532
3533
3534
3535
3536
3537
3538
3539
3540
3541
3542
3543
3544
3545
3546
3547
3548
3549
3550
3551
3552
3553
3554
3555
3556
3557
3558
3559
3560
3561
3562
3563
3564
3565
3566
3567
3568
3569
3570
3571
3572
3573
3574
3575
3576
3577
3578
3579
3580
3581
3582
3583
3584
3585
3586
3587
3588
3589
3590
3591
3592
3593
3594
3595
3596
3597
3598
3599
3600
3601
3602
3603
3604
3605
3606
3607
3608
3609
3610
3611
3612
3613
3614
3615
3616
3617
3618
3619
3620
3621
3622
3623
3624
3625
3626
3627
3628
3629
3630
3631
3632
3633
3634
3635
3636
3637
3638
3639
3640
3641
3642
3643
3644
3645
3646
3647
3648
3649
3650
3651
3652
3653
3654
3655
3656
3657
3658
3659
3660
3661
3662
3663
3664
3665
3666
3667
3668
3669
3670
3671
3672
3673
3674
3675
3676
3677
3678
3679
3680
3681
3682
3683
3684
3685
3686
3687
3688
3689
3690
3691
3692
3693
3694
3695
3696
3697
3698
3699
3700
3701
3702
3703
3704
3705
3706
3707
3708
3709
3710
3711
3712
3713
3714
3715
3716
3717
3718
3719
3720
3721
3722
3723
3724
3725
3726
3727
3728
3729
3730
3731
3732
3733
3734
3735
3736
3737
3738
3739
3740
3741
3742
3743
3744
3745
3746
3747
3748
3749
3750
3751
3752
3753
3754
3755
3756
3757
3758
3759
3760
3761
3762
3763
3764
3765
3766
3767
3768
3769
3770
3771
3772
3773
3774
3775
3776
3777
3778
3779
3780
3781
3782
3783
3784
3785
3786
3787
3788
3789
3790
3791
3792
3793
3794
3795
3796
3797
3798
3799
3800
3801
3802
3803
3804
3805
3806
3807
3808
3809
3810
3811
3812
3813
3814
3815
3816
3817
3818
3819
3820
3821
3822
3823
3824
3825
3826
3827
3828
3829
3830
3831
3832
3833
3834
3835
3836
3837
3838
3839
3840
3841
3842
3843
3844
3845
3846
3847
3848
3849
3850
3851
3852
3853
3854
3855
3856
3857
3858
3859
3860
3861
3862
3863
3864
3865
3866
3867
3868
3869
3870
3871
3872
3873
3874
3875
3876
3877
3878
3879
3880
3881
3882
3883
3884
3885
3886
3887
3888
3889
3890
3891
3892
3893
3894
3895
3896
3897
3898
3899
3900
3901
3902
3903
3904
3905
3906
3907
3908
3909
3910
3911
3912
3913
3914
3915
3916
3917
3918
3919
3920
3921
3922
3923
3924
3925
3926
3927
3928
3929
3930
3931
3932
3933
3934
3935
3936
3937
3938
3939
3940
3941
3942
3943
3944
3945
3946
3947
3948
3949
3950
3951
3952
3953
3954
3955
3956
3957
3958
3959
3960
3961
3962
3963
3964
3965
3966
3967
3968
3969
3970
3971
3972
3973
3974
3975
3976
3977
3978
3979
3980
3981
3982
3983
3984
3985
3986
3987
3988
3989
3990
3991
3992
3993
3994
3995
3996
3997
3998
3999
4000
4001
4002
4003
4004
4005
4006
4007
4008
4009
4010
4011
4012
4013
4014
4015
4016
4017
4018
4019
4020
4021
4022
4023
4024
4025
4026
4027
4028
4029
4030
4031
4032
4033
4034
4035
4036
4037
4038
4039
4040
4041
4042
4043
4044
4045
4046
4047
4048
4049
4050
4051
4052
4053
4054
4055
4056
4057
4058
4059
4060
4061
4062
4063
4064
4065
4066
4067
4068
4069
4070
4071
4072
4073
4074
4075
4076
4077
4078
4079
4080
4081
4082
4083
4084
4085
4086
4087
4088
4089
4090
4091
4092
4093
4094
4095
4096
4097
4098
4099
4100
4101
4102
4103
4104
4105
4106
4107
4108
4109
4110
4111
4112
4113
4114
4115
4116
4117
4118
4119
4120
4121
4122
4123
4124
4125
4126
4127
4128
4129
4130
4131
4132
4133
4134
4135
4136
4137
4138
4139
4140
4141
4142
4143
4144
4145
4146
4147
4148
4149
4150
4151
4152
4153
4154
4155
4156
4157
4158
4159
4160
4161
4162
4163
4164
4165
4166
4167
4168
4169
4170
4171
4172
4173
4174
4175
4176
4177
4178
4179
4180
4181
4182
4183
4184
4185
4186
4187
4188
4189
4190
4191
4192
4193
4194
4195
4196
4197
4198
4199
4200
4201
4202
4203
4204
4205
4206
4207
4208
4209
4210
4211
4212
4213
4214
4215
4216
4217
4218
4219
4220
4221
4222
4223
4224
4225
4226
4227
4228
4229
4230
4231
4232
4233
4234
4235
4236
4237
4238
4239
4240
4241
4242
4243
4244
4245
4246
4247
4248
4249
4250
4251
4252
4253
4254
4255
4256
4257
4258
4259
4260
4261
4262
4263
4264
4265
4266
4267
4268
4269
4270
4271
4272
4273
4274
4275
4276
4277
4278
4279
4280
4281
4282
4283
4284
4285
4286
4287
4288
4289
4290
4291
4292
4293
4294
4295
4296
4297
4298
4299
4300
4301
4302
4303
4304
4305
4306
4307
4308
4309
4310
4311
4312
4313
4314
4315
4316
4317
4318
4319
4320
4321
4322
4323
4324
4325
4326
4327
4328
4329
4330
4331
4332
4333
4334
4335
4336
4337
4338
4339
4340
4341
4342
4343
4344
4345
4346
4347
4348
4349
4350
4351
4352
4353
4354
4355
4356
4357
4358
4359
4360
4361
4362
4363
4364
4365
4366
4367
4368
4369
4370
4371
4372
4373
4374
4375
4376
4377
4378
4379
4380
4381
4382
4383
4384
4385
4386
4387
4388
4389
4390
4391
4392
4393
4394
4395
4396
4397
4398
4399
4400
4401
4402
4403
4404
4405
4406
4407
4408
4409
4410
4411
4412
4413
4414
4415
4416
4417
4418
4419
4420
4421
4422
4423
4424
4425
4426
4427
4428
4429
4430
4431
4432
4433
4434
4435
4436
4437
4438
4439
4440
4441
4442
4443
4444
4445
4446
4447
4448
4449
4450
4451
4452
4453
4454
4455
4456
4457
4458
4459
4460
4461
4462
4463
4464
4465
4466
4467
4468
4469
4470
4471
4472
4473
4474
4475
4476
4477
4478
4479
4480
4481
4482
4483
4484
4485
4486
4487
4488
4489
4490
4491
4492
4493
4494
4495
4496
4497
4498
4499
4500
4501
4502
4503
4504
4505
4506
4507
4508
4509
4510
4511
4512
4513
4514
4515
4516
4517
4518
4519
4520
4521
4522
4523
4524
4525
4526
4527
4528
4529
4530
4531
4532
4533
4534
4535
4536
4537
4538
4539
4540
4541
4542
4543
4544
4545
4546
4547
4548
4549
4550
4551
4552
4553
4554
4555
4556
4557
4558
4559
4560
4561
4562
4563
4564
4565
4566
4567
4568
4569
4570
4571
4572
4573
4574
4575
4576
4577
4578
4579
4580
4581
4582
4583
4584
4585
4586
4587
4588
4589
4590
4591
4592
4593
4594
4595
4596
4597
4598
4599
4600
4601
4602
4603
4604
4605
4606
4607
4608
4609
4610
4611
4612
4613
4614
4615
4616
4617
4618
4619
4620
4621
4622
4623
4624
4625
4626
4627
4628
4629
4630
4631
4632
4633
4634
4635
4636
4637
4638
4639
4640
4641
4642
4643
4644
4645
4646
4647
4648
4649
4650
4651
4652
4653
4654
4655
4656
4657
4658
4659
4660
4661
4662
4663
4664
4665
4666
4667
4668
4669
4670
4671
4672
4673
4674
4675
4676
4677
4678
4679
4680
4681
4682
4683
4684
4685
4686
4687
4688
4689
4690
4691
4692
4693
4694
4695
4696
4697
4698
4699
4700
4701
4702
4703
4704
4705
4706
4707
4708
4709
4710
4711
4712
4713
4714
4715
4716
4717
4718
4719
4720
4721
4722
4723
4724
4725
4726
4727
4728
4729
4730
4731
4732
4733
4734
4735
4736
4737
4738
4739
4740
4741
4742
4743
4744
4745
4746
4747
4748
4749
4750
4751
4752
4753
4754
4755
4756
4757
4758
4759
4760
4761
4762
4763
4764
4765
4766
4767
4768
4769
4770
4771
4772
4773
4774
4775
4776
4777
4778
4779
4780
4781
4782
4783
4784
4785
4786
4787
4788
4789
4790
4791
4792
4793
4794
4795
4796
4797
4798
4799
4800
4801
4802
4803
4804
4805
4806
4807
4808
4809
4810
4811
4812
4813
4814
4815
4816
4817
4818
4819
4820
4821
4822
4823
4824
4825
4826
4827
4828
4829
4830
4831
4832
4833
4834
4835
4836
4837
4838
4839
4840
4841
4842
4843
4844
4845
4846
4847
4848
4849
4850
4851
4852
4853
4854
4855
4856
4857
4858
4859
4860
4861
4862
4863
4864
4865
4866
4867
4868
4869
4870
4871
4872
4873
4874
4875
4876
4877
4878
4879
4880
4881
4882
4883
4884
4885
4886
4887
4888
4889
4890
4891
4892
4893
4894
4895
4896
4897
4898
4899
4900
4901
4902
4903
4904
4905
4906
4907
4908
4909
4910
4911
4912
4913
4914
4915
4916
4917
4918
4919
4920
4921
4922
4923
4924
4925
4926
4927
4928
4929
4930
4931
4932
4933
4934
4935
4936
4937
4938
4939
4940
4941
4942
4943
4944
4945
4946
4947
4948
4949
4950
4951
4952
4953
4954
4955
4956
4957
4958
4959
4960
4961
4962
4963
4964
4965
4966
4967
4968
4969
4970
4971
4972
4973
4974
4975
4976
4977
4978
4979
4980
4981
4982
4983
4984
4985
4986
4987
4988
4989
4990
4991
4992
4993
4994
4995
4996
4997
4998
4999
5000
5001
5002
5003
5004
5005
5006
5007
5008
5009
5010
5011
5012
5013
5014
5015
5016
5017
5018
5019
5020
5021
5022
5023
5024
5025
5026
5027
5028
5029
5030
5031
5032
5033
5034
5035
5036
5037
5038
5039
5040
5041
5042
5043
5044
5045
5046
5047
5048
5049
5050
5051
5052
5053
5054
5055
5056
5057
5058
5059
5060
5061
5062
5063
5064
5065
5066
5067
5068
5069
5070
5071
5072
5073
5074
5075
5076
5077
5078
5079
5080
5081
5082
5083
5084
5085
5086
5087
5088
5089
5090
5091
5092
5093
5094
5095
5096
5097
5098
5099
5100
5101
5102
5103
5104
5105
5106
5107
5108
5109
5110
5111
5112
5113
5114
5115
5116
5117
5118
5119
5120
5121
5122
5123
5124
5125
5126
5127
5128
5129
5130
5131
5132
5133
5134
5135
5136
5137
5138
5139
5140
5141
5142
5143
5144
5145
5146
5147
5148
5149
5150
5151
5152
5153
5154
5155
5156
5157
5158
5159
5160
5161
5162
5163
5164
5165
5166
5167
5168
5169
5170
5171
5172
5173
5174
5175
5176
5177
5178
5179
5180
5181
5182
5183
5184
5185
5186
5187
5188
5189
5190
5191
5192
5193
5194
5195
5196
5197
5198
5199
5200
5201
5202
5203
5204
5205
5206
5207
5208
5209
5210
5211
5212
5213
5214
5215
5216
5217
5218
5219
5220
5221
5222
5223
5224
5225
5226
5227
5228
5229
5230
5231
5232
5233
5234
5235
5236
5237
5238
5239
5240
5241
5242
5243
5244
5245
5246
5247
5248
5249
5250
5251
5252
5253
5254
5255
5256
5257
5258
5259
5260
5261
5262
5263
5264
5265
5266
5267
5268
5269
5270
5271
5272
5273
5274
5275
5276
5277
5278
5279
5280
5281
5282
5283
5284
5285
5286
5287
5288
5289
5290
5291
5292
5293
5294
5295
5296
5297
5298
5299
5300
5301
5302
5303
5304
5305
5306
5307
5308
5309
5310
5311
5312
5313
5314
5315
5316
5317
5318
5319
5320
5321
5322
5323
5324
5325
5326
5327
5328
5329
5330
5331
5332
5333
5334
5335
5336
5337
5338
5339
5340
5341
5342
5343
5344
5345
5346
5347
5348
5349
5350
5351
5352
5353
5354
5355
5356
5357
5358
5359
5360
5361
5362
5363
5364
5365
5366
5367
5368
5369
5370
5371
5372
5373
5374
5375
5376
5377
5378
5379
5380
5381
5382
5383
5384
5385
5386
5387
5388
5389
5390
5391
5392
5393
5394
5395
5396
5397
5398
5399
5400
5401
5402
5403
5404
5405
5406
5407
5408
5409
5410
5411
5412
5413
5414
5415
5416
5417
5418
5419
5420
5421
5422
5423
5424
5425
5426
5427
5428
5429
5430
5431
5432
5433
5434
5435
5436
5437
5438
5439
5440
5441
5442
5443
5444
5445
5446
5447
5448
5449
5450
5451
5452
5453
5454
5455
5456
5457
5458
5459
5460
5461
5462
5463
5464
5465
5466
5467
5468
5469
5470
5471
5472
5473
5474
5475
5476
5477
5478
5479
5480
5481
5482
5483
5484
5485
5486
5487
5488
5489
5490
5491
5492
5493
5494
5495
5496
5497
5498
5499
5500
5501
5502
5503
5504
5505
5506
5507
5508
5509
5510
5511
5512
5513
5514
5515
5516
5517
5518
5519
5520
5521
5522
5523
5524
5525
5526
5527
5528
5529
5530
5531
5532
5533
5534
5535
5536
5537
5538
5539
5540
5541
5542
5543
5544
5545
5546
5547
5548
5549
5550
5551
5552
5553
5554
5555
5556
5557
5558
5559
5560
5561
5562
5563
5564
5565
5566
5567
5568
5569
5570
5571
5572
5573
5574
5575
5576
5577
5578
5579
5580
5581
5582
5583
5584
5585
5586
5587
5588
5589
5590
5591
5592
5593
5594
5595
5596
5597
5598
5599
5600
5601
5602
5603
5604
5605
5606
5607
5608
5609
5610
5611
5612
5613
5614
5615
5616
5617
5618
5619
5620
5621
5622
5623
5624
5625
5626
5627
5628
5629
5630
5631
5632
5633
5634
5635
5636
5637
5638
5639
5640
5641
5642
5643
5644
5645
5646
5647
5648
5649
5650
5651
5652
5653
5654
5655
5656
5657
5658
5659
5660
5661
5662
5663
5664
5665
5666
5667
5668
5669
5670
5671
5672
5673
5674
5675
5676
5677
5678
5679
5680
5681
5682
5683
5684
5685
5686
5687
5688
5689
5690
5691
5692
5693
5694
5695
5696
5697
5698
5699
5700
5701
5702
5703
5704
5705
5706
5707
5708
5709
5710
5711
5712
5713
5714
5715
5716
5717
5718
5719
5720
5721
5722
5723
5724
5725
5726
5727
5728
5729
5730
5731
5732
5733
5734
5735
5736
5737
5738
5739
5740
5741
5742
5743
5744
5745
5746
5747
5748
5749
5750
5751
5752
5753
5754
5755
5756
5757
5758
5759
5760
5761
5762
5763
5764
5765
5766
5767
5768
5769
5770
5771
5772
5773
5774
5775
5776
5777
5778
5779
5780
5781
5782
5783
5784
5785
5786
5787
5788
5789
5790
5791
5792
5793
5794
5795
5796
5797
5798
5799
5800
5801
5802
5803
5804
5805
5806
5807
5808
5809
5810
5811
5812
5813
5814
5815
5816
5817
5818
5819
5820
5821
5822
5823
5824
5825
5826
5827
5828
5829
5830
5831
5832
5833
5834
5835
5836
5837
5838
5839
5840
5841
5842
5843
5844
5845
5846
5847
5848
5849
5850
5851
5852
5853
5854
5855
5856
5857
5858
5859
5860
5861
5862
5863
5864
5865
5866
5867
5868
5869
5870
5871
5872
5873
5874
5875
5876
5877
5878
5879
5880
5881
5882
5883
5884
5885
5886
5887
5888
5889
5890
5891
5892
5893
5894
5895
5896
5897
5898
5899
5900
5901
5902
5903
5904
5905
5906
5907
5908
5909
5910
5911
5912
5913
5914
5915
5916
5917
5918
5919
5920
5921
5922
5923
5924
5925
5926
5927
5928
5929
5930
5931
5932
5933
5934
5935
5936
5937
5938
5939
5940
5941
5942
5943
5944
5945
5946
5947
5948
5949
5950
5951
5952
5953
5954
5955
5956
5957
5958
5959
5960
5961
5962
5963
5964
5965
5966
5967
5968
5969
5970
5971
5972
5973
5974
5975
5976
5977
5978
5979
5980
5981
5982
5983
5984
5985
5986
5987
5988
5989
5990
5991
5992
5993
5994
5995
5996
5997
5998
5999
6000
6001
6002
6003
6004
6005
6006
6007
6008
6009
6010
6011
6012
6013
6014
6015
6016
6017
6018
6019
6020
6021
6022
6023
6024
6025
6026
6027
6028
6029
6030
6031
6032
6033
6034
6035
6036
6037
6038
6039
6040
6041
6042
6043
6044
6045
6046
6047
6048
6049
6050
6051
6052
6053
6054
6055
6056
6057
6058
6059
6060
6061
6062
6063
6064
6065
6066
6067
6068
6069
6070
6071
6072
6073
6074
6075
6076
6077
6078
6079
6080
6081
6082
6083
6084
6085
6086
6087
6088
6089
6090
6091
6092
6093
6094
6095
6096
6097
6098
6099
6100
6101
6102
6103
6104
6105
6106
6107
6108
6109
6110
6111
6112
6113
6114
6115
6116
6117
6118
6119
6120
6121
6122
6123
6124
6125
6126
6127
6128
6129
6130
6131
6132
6133
6134
6135
6136
6137
6138
6139
6140
6141
6142
6143
6144
6145
6146
6147
6148
6149
6150
6151
6152
6153
6154
6155
6156
6157
6158
6159
6160
6161
6162
6163
6164
6165
6166
6167
6168
6169
6170
6171
6172
6173
6174
6175
6176
6177
6178
6179
6180
6181
6182
6183
6184
6185
6186
6187
6188
6189
6190
6191
6192
6193
6194
6195
6196
6197
6198
6199
6200
6201
6202
6203
6204
6205
6206
6207
6208
6209
6210
6211
6212
6213
6214
6215
6216
6217
6218
6219
6220
6221
6222
6223
6224
6225
6226
6227
6228
6229
6230
6231
6232
6233
6234
6235
6236
6237
6238
6239
6240
6241
6242
6243
6244
6245
6246
6247
6248
6249
6250
6251
6252
6253
6254
6255
6256
6257
6258
6259
6260
6261
6262
6263
6264
6265
6266
6267
6268
6269
6270
6271
6272
6273
6274
6275
6276
6277
6278
6279
6280
6281
6282
6283
6284
6285
6286
6287
6288
6289
6290
6291
6292
6293
6294
6295
6296
6297
6298
6299
6300
6301
6302
6303
6304
6305
6306
6307
6308
6309
6310
6311
6312
6313
6314
6315
6316
6317
6318
6319
6320
6321
6322
6323
6324
6325
6326
6327
6328
6329
6330
6331
6332
6333
6334
6335
6336
6337
6338
6339
6340
6341
6342
6343
6344
6345
6346
6347
6348
6349
6350
6351
6352
6353
6354
6355
6356
6357
6358
6359
6360
6361
6362
6363
6364
6365
6366
6367
6368
6369
6370
6371
6372
6373
6374
6375
6376
6377
6378
6379
6380
6381
6382
6383
6384
6385
6386
6387
6388
6389
6390
6391
6392
6393
6394
6395
6396
6397
6398
6399
6400
6401
6402
6403
6404
6405
6406
6407
6408
6409
6410
6411
6412
6413
6414
6415
6416
6417
6418
6419
6420
6421
6422
6423
6424
6425
6426
6427
6428
6429
6430
6431
6432
6433
6434
6435
6436
6437
6438
6439
6440
6441
6442
6443
6444
6445
6446
6447
6448
6449
6450
6451
6452
6453
6454
6455
6456
6457
6458
6459
6460
6461
6462
6463
6464
6465
6466
6467
6468
6469
6470
6471
6472
6473
6474
6475
6476
6477
6478
6479
6480
6481
6482
6483
6484
6485
6486
6487
6488
6489
6490
6491
6492
6493
6494
6495
6496
6497
6498
6499
6500
6501
6502
6503
6504
6505
6506
6507
6508
6509
6510
6511
6512
6513
6514
6515
6516
6517
6518
6519
6520
6521
6522
6523
6524
6525
6526
6527
6528
6529
6530
6531
6532
6533
6534
6535
6536
6537
6538
6539
6540
6541
6542
6543
6544
6545
6546
6547
6548
6549
6550
6551
6552
6553
6554
6555
6556
6557
6558
6559
6560
6561
6562
6563
6564
6565
6566
6567
6568
6569
6570
6571
6572
6573
6574
6575
6576
6577
6578
6579
6580
6581
6582
6583
6584
6585
6586
6587
6588
6589
6590
6591
6592
6593
6594
6595
6596
6597
6598
6599
6600
6601
6602
6603
6604
6605
6606
6607
6608
6609
6610
6611
6612
6613
6614
6615
6616
6617
6618
6619
6620
6621
6622
6623
6624
6625
6626
6627
6628
6629
6630
6631
6632
6633
6634
6635
6636
6637
6638
6639
6640
6641
6642
6643
6644
6645
6646
6647
6648
6649
6650
6651
6652
6653
6654
6655
6656
6657
6658
6659
6660
6661
6662
6663
6664
6665
6666
6667
6668
6669
6670
6671
6672
6673
6674
6675
6676
6677
6678
6679
6680
6681
6682
6683
6684
6685
6686
6687
6688
6689
6690
6691
6692
6693
6694
6695
6696
6697
6698
6699
6700
6701
6702
6703
6704
6705
6706
6707
6708
6709
6710
6711
6712
6713
6714
6715
6716
6717
6718
6719
6720
6721
6722
6723
6724
6725
6726
6727
6728
6729
6730
6731
6732
6733
6734
6735
6736
6737
6738
6739
6740
6741
6742
6743
6744
6745
6746
6747
6748
6749
6750
6751
6752
6753
6754
6755
6756
6757
6758
6759
6760
6761
6762
6763
6764
6765
6766
6767
6768
6769
6770
6771
6772
6773
6774
6775
6776
6777
6778
6779
6780
6781
6782
6783
6784
6785
6786
6787
6788
6789
6790
6791
6792
6793
6794
6795
6796
6797
6798
6799
6800
6801
6802
6803
6804
6805
6806
6807
6808
6809
6810
6811
6812
6813
6814
6815
6816
6817
6818
6819
6820
6821
6822
6823
6824
6825
6826
6827
6828
6829
6830
6831
6832
6833
6834
6835
6836
6837
6838
6839
6840
6841
6842
6843
6844
6845
6846
6847
6848
6849
6850
6851
6852
6853
6854
6855
6856
6857
6858
6859
6860
6861
6862
6863
6864
6865
6866
6867
6868
6869
6870
6871
6872
6873
6874
6875
6876
6877
6878
6879
6880
6881
6882
6883
6884
6885
6886
6887
6888
6889
6890
6891
6892
6893
6894
6895
6896
6897
6898
6899
6900
6901
6902
6903
6904
6905
6906
6907
6908
6909
6910
6911
6912
6913
6914
6915
6916
6917
6918
6919
6920
6921
6922
6923
6924
6925
6926
6927
6928
6929
6930
6931
6932
6933
6934
6935
6936
6937
6938
6939
6940
6941
6942
6943
6944
6945
6946
6947
6948
6949
6950
6951
6952
6953
6954
6955
6956
6957
6958
6959
6960
6961
6962
6963
6964
6965
6966
6967
6968
6969
6970
6971
6972
6973
6974
6975
6976
6977
6978
6979
6980
6981
6982
6983
6984
6985
6986
6987
6988
6989
6990
6991
6992
6993
6994
6995
6996
6997
6998
6999
7000
7001
7002
7003
7004
7005
7006
7007
7008
7009
7010
7011
7012
7013
7014
7015
7016
7017
7018
7019
7020
7021
7022
7023
7024
7025
7026
7027
7028
7029
7030
7031
7032
7033
7034
7035
7036
7037
7038
7039
7040
7041
7042
7043
7044
7045
7046
7047
7048
7049
7050
7051
7052
7053
7054
7055
7056
7057
7058
7059
7060
7061
7062
7063
7064
7065
7066
7067
7068
7069
7070
7071
7072
7073
7074
7075
7076
7077
7078
7079
7080
7081
7082
7083
7084
7085
7086
7087
7088
7089
7090
7091
7092
7093
7094
7095
7096
7097
7098
7099
7100
7101
7102
7103
7104
7105
7106
7107
7108
7109
7110
7111
7112
7113
7114
7115
7116
7117
7118
7119
7120
7121
7122
7123
7124
7125
7126
7127
7128
7129
7130
7131
7132
7133
7134
7135
7136
7137
7138
7139
7140
7141
7142
7143
7144
7145
7146
7147
7148
7149
7150
7151
7152
7153
7154
7155
7156
7157
7158
7159
7160
7161
7162
7163
7164
7165
7166
7167
7168
7169
7170
7171
7172
7173
7174
7175
7176
7177
7178
7179
7180
7181
7182
7183
7184
7185
7186
7187
7188
7189
7190
7191
7192
7193
7194
7195
7196
7197
7198
7199
7200
7201
7202
7203
7204
7205
7206
7207
7208
7209
7210
7211
7212
7213
7214
7215
7216
7217
7218
7219
7220
7221
7222
7223
7224
7225
7226
7227
7228
7229
7230
7231
7232
7233
7234
7235
7236
7237
7238
7239
7240
7241
7242
7243
7244
7245
7246
7247
7248
7249
7250
7251
7252
7253
7254
7255
7256
7257
7258
7259
7260
7261
7262
7263
7264
7265
7266
7267
7268
7269
7270
7271
7272
7273
7274
7275
7276
7277
7278
7279
7280
7281
7282
7283
7284
7285
7286
7287
7288
7289
7290
7291
7292
7293
7294
7295
7296
7297
7298
7299
7300
7301
7302
7303
7304
7305
7306
7307
7308
7309
7310
7311
7312
7313
7314
7315
7316
7317
7318
7319
7320
7321
7322
7323
7324
7325
7326
7327
7328
7329
7330
7331
7332
7333
7334
7335
7336
7337
7338
7339
7340
7341
7342
7343
7344
7345
7346
7347
7348
7349
7350
7351
7352
7353
7354
7355
7356
7357
7358
7359
7360
7361
7362
7363
7364
7365
7366
7367
7368
7369
7370
7371
7372
7373
7374
7375
7376
7377
7378
7379
7380
7381
7382
7383
7384
7385
7386
7387
7388
7389
7390
7391
7392
7393
7394
7395
7396
7397
7398
7399
7400
7401
7402
7403
7404
7405
7406
7407
7408
7409
7410
7411
7412
7413
7414
7415
7416
7417
7418
7419
7420
7421
7422
7423
7424
7425
7426
7427
7428
7429
7430
7431
7432
7433
7434
7435
7436
7437
7438
7439
7440
7441
7442
7443
7444
7445
7446
7447
7448
7449
7450
7451
7452
7453
7454
7455
7456
7457
7458
7459
7460
7461
7462
7463
7464
7465
7466
7467
7468
7469
7470
7471
7472
7473
7474
7475
7476
7477
7478
7479
7480
7481
7482
7483
7484
7485
7486
7487
7488
7489
7490
7491
7492
7493
7494
7495
7496
7497
7498
7499
7500
7501
7502
7503
7504
7505
7506
7507
7508
7509
7510
7511
7512
7513
7514
7515
7516
7517
7518
7519
7520
7521
7522
7523
7524
7525
7526
7527
7528
7529
7530
7531
7532
7533
7534
7535
7536
7537
7538
7539
7540
7541
7542
7543
7544
7545
7546
7547
7548
7549
7550
7551
7552
7553
7554
7555
7556
7557
7558
7559
7560
7561
7562
7563
7564
7565
7566
7567
7568
7569
7570
7571
7572
7573
7574
7575
7576
7577
7578
7579
7580
7581
7582
7583
7584
7585
7586
7587
7588
7589
7590
7591
7592
7593
7594
7595
7596
7597
7598
7599
7600
7601
7602
7603
7604
7605
7606
7607
7608
7609
7610
7611
7612
7613
7614
7615
7616
7617
7618
7619
7620
7621
7622
7623
7624
7625
7626
7627
7628
7629
7630
7631
7632
7633
7634
7635
7636
7637
7638
7639
7640
7641
7642
7643
7644
7645
7646
7647
7648
7649
7650
7651
7652
7653
7654
7655
7656
7657
7658
7659
7660
7661
7662
7663
7664
7665
7666
7667
7668
7669
7670
7671
7672
7673
7674
7675
7676
7677
7678
7679
7680
7681
7682
7683
7684
7685
7686
7687
7688
7689
7690
7691
7692
7693
7694
7695
7696
7697
7698
7699
7700
7701
7702
7703
7704
7705
7706
7707
7708
7709
7710
7711
7712
7713
/*************************************************
*      Perl-Compatible Regular Expressions       *
*************************************************/


/* This is a library of functions to support regular expressions whose syntax
and semantics are as close as possible to those of the Perl 5 language. See
the file Tech.Notes for some information on the internals.

Written by: Philip Hazel <ph10@cam.ac.uk>

           Copyright (c) 1997-2003 University of Cambridge

-----------------------------------------------------------------------------
Permission is granted to anyone to use this software for any purpose on any
computer system, and to redistribute it freely, subject to the following
restrictions:

1. This software is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

2. The origin of this software must not be misrepresented, either by
   explicit claim or by omission.

3. Altered versions must be plainly marked as such, and must not be
   misrepresented as being the original software.

4. If PCRE is embedded in any software that is released under the GNU
   General Purpose Licence (GPL), then the terms of that licence shall
   supersede any condition above with which it is incompatible.
-----------------------------------------------------------------------------
*/

/* Modified by Shawn Wagner for PennMUSH to fit in one file and remove
   things we don't use, like a bunch of API functions and utf-8
   support. If you want the full thing, see http://www.pcre.org. */
/* Modified by Alan Schwartz for PennMUSH to change the use of
 * 'isblank' as a variable (reported to Philip Hazel for pcre 4.5) */

#include "config.h"
#include <limits.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#include <stddef.h>
#include <setjmp.h>
#include "pcre.h"
#include "confmagic.h"
#undef min
#undef max

/* Bits of PCRE's conf.h */
#define NEWLINE '\n'
#define LINK_SIZE   2
#define MATCH_LIMIT 100000
#define NO_RECURSE

/* Bits of internal.h */
/* This header contains definitions that are shared between the different
modules, but which are not relevant to the outside. */

#define PCRE_DEFINITION		/* Win32 __declspec(export) trigger for .dll */
#define EXPORT

/* PCRE keeps offsets in its compiled code as 2-byte quantities by default.
These are used, for example, to link from the start of a subpattern to its
alternatives and its end. The use of 2 bytes per offset limits the size of the
compiled regex to around 64K, which is big enough for almost everybody.
However, I received a request for an even bigger limit. For this reason, and
also to make the code easier to maintain, the storing and loading of offsets
from the byte string is now handled by the macros that are defined here.

The macros are controlled by the value of LINK_SIZE. This defaults to 2 in
the config.h file, but can be overridden by using -D on the command line. This
is automated on Unix systems via the "configure" command. */

#define PUT(a,n,d)   \
  (a[n] = (d) >> 8), \
  (a[(n)+1] = (d) & 255)

#define GET(a,n) \
  (((a)[n] << 8) | (a)[(n)+1])

#define MAX_PATTERN_SIZE (1 << 16)


/* Convenience macro defined in terms of the others */

#define PUTINC(a,n,d)   PUT(a,n,d), a += LINK_SIZE


/* PCRE uses some other 2-byte quantities that do not change when the size of
offsets changes. There are used for repeat counts and for other things such as
capturing parenthesis numbers in back references. */

#define PUT2(a,n,d)   \
  a[n] = (d) >> 8; \
  a[(n)+1] = (d) & 255

#define GET2(a,n) \
  (((a)[n] << 8) | (a)[(n)+1])

#define PUT2INC(a,n,d)  PUT2(a,n,d), a += 2

/* These are the public options that can change during matching. */

#define PCRE_IMS (PCRE_CASELESS|PCRE_MULTILINE|PCRE_DOTALL)

/* Private options flags start at the most significant end of the four bytes,
but skip the top bit so we can use ints for convenience without getting tangled
with negative values. The public options defined in pcre.h start at the least
significant end. Make sure they don't overlap, though now that we have expanded
to four bytes there is plenty of space. */

#define PCRE_FIRSTSET      0x40000000	/* first_byte is set */
#define PCRE_REQCHSET      0x20000000	/* req_byte is set */
#define PCRE_STARTLINE     0x10000000	/* start after \n for multiline */
#define PCRE_ICHANGED      0x08000000	/* i option changes within regex */

/* Options for the "extra" block produced by pcre_study(). */

#define PCRE_STUDY_MAPPED   0x01	/* a map of starting chars exists */

/* Masks for identifying the public options which are permitted at compile
time, run time or study time, respectively. */

#define PUBLIC_OPTIONS \
  (PCRE_CASELESS|PCRE_EXTENDED|PCRE_ANCHORED|PCRE_MULTILINE| \
   PCRE_DOTALL|PCRE_DOLLAR_ENDONLY|PCRE_EXTRA|PCRE_UNGREEDY|PCRE_UTF8| \
   PCRE_NO_AUTO_CAPTURE|PCRE_NO_UTF8_CHECK)

#define PUBLIC_EXEC_OPTIONS \
  (PCRE_ANCHORED|PCRE_NOTBOL|PCRE_NOTEOL|PCRE_NOTEMPTY|PCRE_NO_UTF8_CHECK)

#define PUBLIC_STUDY_OPTIONS 0	/* None defined */

/* Magic number to provide a small check against being handed junk. */

#define MAGIC_NUMBER  0x50435245UL	/* 'PCRE' */

/* Negative values for the firstchar and reqchar variables */

#define REQ_UNSET (-2)
#define REQ_NONE  (-1)

/* Flags added to firstbyte or reqbyte; a "non-literal" item is either a
variable-length repeat, or a anything other than literal characters. */

#define REQ_CASELESS 0x0100	/* indicates caselessness */
#define REQ_VARY     0x0200	/* reqbyte followed non-literal item */

/* Miscellaneous definitions */

typedef int BOOL;

#define FALSE   0
#define TRUE    1

/* Escape items that are just an encoding of a particular data value. Note that
ESC_n is defined as yet another macro, which is set in config.h to either \n
(the default) or \r (which some people want). */

#ifndef ESC_e
#define ESC_e 27
#endif

#ifndef ESC_f
#define ESC_f '\f'
#endif

#ifndef ESC_n
#define ESC_n NEWLINE
#endif

#ifndef ESC_r
#define ESC_r '\r'
#endif

/* We can't officially use ESC_t because it is a POSIX reserved identifier
(presumably because of all the others like size_t). */

#ifndef ESC_tee
#define ESC_tee '\t'
#endif

/* These are escaped items that aren't just an encoding of a particular data
value such as \n. They must have non-zero values, as check_escape() returns
their negation. Also, they must appear in the same order as in the opcode
definitions below, up to ESC_z. There's a dummy for OP_ANY because it
corresponds to "." rather than an escape sequence. The final one must be
ESC_REF as subsequent values are used for \1, \2, \3, etc. There is are two
tests in the code for an escape greater than ESC_b and less than ESC_Z to
detect the types that may be repeated. These are the types that consume a
character. If any new escapes are put in between that don't consume a
character, that code will have to change. */

enum { ESC_A = 1, ESC_G, ESC_B, ESC_b, ESC_D, ESC_d, ESC_S, ESC_s, ESC_W,
  ESC_w, ESC_dum1, ESC_C, ESC_Z, ESC_z, ESC_E, ESC_Q, ESC_REF
};

/* Flag bits and data types for the extended class (OP_XCLASS) for classes that
contain UTF-8 characters with values greater than 255. */

#define XCL_NOT    0x01		/* Flag: this is a negative class */
#define XCL_MAP    0x02		/* Flag: a 32-byte map is present */

#define XCL_END       0		/* Marks end of individual items */
#define XCL_SINGLE    1		/* Single item (one multibyte char) follows */
#define XCL_RANGE     2		/* A range (two multibyte chars) follows */


/* Opcode table: OP_BRA must be last, as all values >= it are used for brackets
that extract substrings. Starting from 1 (i.e. after OP_END), the values up to
OP_EOD must correspond in order to the list of escapes immediately above.
Note that whenever this list is updated, the two macro definitions that follow
must also be updated to match. */

enum {
  OP_END,			/* 0 End of pattern */

  /* Values corresponding to backslashed metacharacters */

  OP_SOD,			/* 1 Start of data: \A */
  OP_SOM,			/* 2 Start of match (subject + offset): \G */
  OP_NOT_WORD_BOUNDARY,		/*  3 \B */
  OP_WORD_BOUNDARY,		/*  4 \b */
  OP_NOT_DIGIT,			/*  5 \D */
  OP_DIGIT,			/*  6 \d */
  OP_NOT_WHITESPACE,		/*  7 \S */
  OP_WHITESPACE,		/*  8 \s */
  OP_NOT_WORDCHAR,		/*  9 \W */
  OP_WORDCHAR,			/* 10 \w */
  OP_ANY,			/* 11 Match any character */
  OP_ANYBYTE,			/* 12 Match any byte (\C); different to OP_ANY for UTF-8 */
  OP_EODN,			/* 13 End of data or \n at end of data: \Z. */
  OP_EOD,			/* 14 End of data: \z */

  OP_OPT,			/* 15 Set runtime options */
  OP_CIRC,			/* 16 Start of line - varies with multiline switch */
  OP_DOLL,			/* 17 End of line - varies with multiline switch */
  OP_CHARS,			/* 18 Match string of characters */
  OP_NOT,			/* 19 Match anything but the following char */

  OP_STAR,			/* 20 The maximizing and minimizing versions of */
  OP_MINSTAR,			/* 21 all these opcodes must come in pairs, with */
  OP_PLUS,			/* 22 the minimizing one second. */
  OP_MINPLUS,			/* 23 This first set applies to single characters */
  OP_QUERY,			/* 24 */
  OP_MINQUERY,			/* 25 */
  OP_UPTO,			/* 26 From 0 to n matches */
  OP_MINUPTO,			/* 27 */
  OP_EXACT,			/* 28 Exactly n matches */

  OP_NOTSTAR,			/* 29 The maximizing and minimizing versions of */
  OP_NOTMINSTAR,		/* 30 all these opcodes must come in pairs, with */
  OP_NOTPLUS,			/* 31 the minimizing one second. */
  OP_NOTMINPLUS,		/* 32 This set applies to "not" single characters */
  OP_NOTQUERY,			/* 33 */
  OP_NOTMINQUERY,		/* 34 */
  OP_NOTUPTO,			/* 35 From 0 to n matches */
  OP_NOTMINUPTO,		/* 36 */
  OP_NOTEXACT,			/* 37 Exactly n matches */

  OP_TYPESTAR,			/* 38 The maximizing and minimizing versions of */
  OP_TYPEMINSTAR,		/* 39 all these opcodes must come in pairs, with */
  OP_TYPEPLUS,			/* 40 the minimizing one second. These codes must */
  OP_TYPEMINPLUS,		/* 41 be in exactly the same order as those above. */
  OP_TYPEQUERY,			/* 42 This set applies to character types such as \d */
  OP_TYPEMINQUERY,		/* 43 */
  OP_TYPEUPTO,			/* 44 From 0 to n matches */
  OP_TYPEMINUPTO,		/* 45 */
  OP_TYPEEXACT,			/* 46 Exactly n matches */

  OP_CRSTAR,			/* 47 The maximizing and minimizing versions of */
  OP_CRMINSTAR,			/* 48 all these opcodes must come in pairs, with */
  OP_CRPLUS,			/* 49 the minimizing one second. These codes must */
  OP_CRMINPLUS,			/* 50 be in exactly the same order as those above. */
  OP_CRQUERY,			/* 51 These are for character classes and back refs */
  OP_CRMINQUERY,		/* 52 */
  OP_CRRANGE,			/* 53 These are different to the three seta above. */
  OP_CRMINRANGE,		/* 54 */

  OP_CLASS,			/* 55 Match a character class, chars < 256 only */
  OP_NCLASS,			/* 56 Same, but the bitmap was created from a negative
				   class - the difference is relevant only when a UTF-8
				   character > 255 is encountered. */

  OP_XCLASS,			/* 57 Extended class for handling UTF-8 chars within the
				   class. This does both positive and negative. */

  OP_REF,			/* 58 Match a back reference */
  OP_RECURSE,			/* 59 Match a numbered subpattern (possibly recursive) */
  OP_CALLOUT,			/* 60 Call out to external function if provided */

  OP_ALT,			/* 61 Start of alternation */
  OP_KET,			/* 62 End of group that doesn't have an unbounded repeat */
  OP_KETRMAX,			/* 63 These two must remain together and in this */
  OP_KETRMIN,			/* 64 order. They are for groups the repeat for ever. */

  /* The assertions must come before ONCE and COND */

  OP_ASSERT,			/* 65 Positive lookahead */
  OP_ASSERT_NOT,		/* 66 Negative lookahead */
  OP_ASSERTBACK,		/* 67 Positive lookbehind */
  OP_ASSERTBACK_NOT,		/* 68 Negative lookbehind */
  OP_REVERSE,			/* 69 Move pointer back - used in lookbehind assertions */

  /* ONCE and COND must come after the assertions, with ONCE first, as there's
     a test for >= ONCE for a subpattern that isn't an assertion. */

  OP_ONCE,			/* 70 Once matched, don't back up into the subpattern */
  OP_COND,			/* 71 Conditional group */
  OP_CREF,			/* 72 Used to hold an extraction string number (cond ref) */

  OP_BRAZERO,			/* 73 These two must remain together and in this */
  OP_BRAMINZERO,		/* 74 order. */

  OP_BRANUMBER,			/* 75 Used for extracting brackets whose number is greater
				   than can fit into an opcode. */

  OP_BRA			/* 76 This and greater values are used for brackets that
				   extract substrings up to a basic limit. After that,
				   use is made of OP_BRANUMBER. */
};

/* WARNING: There is an implicit assumption in study.c that all opcodes are
less than 128 in value. This makes handling UTF-8 character sequences easier.
*/


/* This macro defines textual names for all the opcodes. There are used only
for debugging, in pcre.c when DEBUG is defined, and also in pcretest.c. The
macro is referenced only in printint.c. */

#define OP_NAME_LIST \
  "End", "\\A", "\\G", "\\B", "\\b", "\\D", "\\d",                \
  "\\S", "\\s", "\\W", "\\w", "Any", "Anybyte", "\\Z", "\\z",     \
  "Opt", "^", "$", "chars", "not",                                \
  "*", "*?", "+", "+?", "?", "??", "{", "{", "{",                 \
  "*", "*?", "+", "+?", "?", "??", "{", "{", "{",                 \
  "*", "*?", "+", "+?", "?", "??", "{", "{", "{",                 \
  "*", "*?", "+", "+?", "?", "??", "{", "{",                      \
  "class", "nclass", "xclass", "Ref", "Recurse", "Callout",       \
  "Alt", "Ket", "KetRmax", "KetRmin", "Assert", "Assert not",     \
  "AssertB", "AssertB not", "Reverse", "Once", "Cond", "Cond ref",\
  "Brazero", "Braminzero", "Branumber", "Bra"


/* This macro defines the length of fixed length operations in the compiled
regex. The lengths are used when searching for specific things, and also in the
debugging printing of a compiled regex. We use a macro so that it can be
incorporated both into pcre.c and pcretest.c without being publicly exposed.

As things have been extended, some of these are no longer fixed lenths, but are
minima instead. For example, the length of a single-character repeat may vary
in UTF-8 mode. The code that uses this table must know about such things. */

#define OP_LENGTHS \
  1,                             /* End                                    */ \
  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /* \A, \G, \B, \B, \D, \d, \S, \s, \W, \w */ \
  1, 1, 1, 1, 2, 1, 1,           /* Any, Anybyte, \Z, \z, Opt, ^, $        */ \
  2,                             /* Chars - the minimum length             */ \
  2,                             /* not                                    */ \
  /* Positive single-char repeats                            ** These are  */ \
  2, 2, 2, 2, 2, 2,              /* *, *?, +, +?, ?, ??      ** minima in  */ \
  4, 4, 4,                       /* upto, minupto, exact     ** UTF-8 mode */ \
  /* Negative single-char repeats - only for chars < 256                   */ \
  2, 2, 2, 2, 2, 2,              /* NOT *, *?, +, +?, ?, ??                */ \
  4, 4, 4,                       /* NOT upto, minupto, exact               */ \
  /* Positive type repeats                                                 */ \
  2, 2, 2, 2, 2, 2,              /* Type *, *?, +, +?, ?, ??               */ \
  4, 4, 4,                       /* Type upto, minupto, exact              */ \
  /* Character class & ref repeats                                         */ \
  1, 1, 1, 1, 1, 1,              /* *, *?, +, +?, ?, ??                    */ \
  5, 5,                          /* CRRANGE, CRMINRANGE                    */ \
 33,                             /* CLASS                                  */ \
 33,                             /* NCLASS                                 */ \
  0,                             /* XCLASS - variable length               */ \
  3,                             /* REF                                    */ \
  1+LINK_SIZE,                   /* RECURSE                                */ \
  2,                             /* CALLOUT                                */ \
  1+LINK_SIZE,                   /* Alt                                    */ \
  1+LINK_SIZE,                   /* Ket                                    */ \
  1+LINK_SIZE,                   /* KetRmax                                */ \
  1+LINK_SIZE,                   /* KetRmin                                */ \
  1+LINK_SIZE,                   /* Assert                                 */ \
  1+LINK_SIZE,                   /* Assert not                             */ \
  1+LINK_SIZE,                   /* Assert behind                          */ \
  1+LINK_SIZE,                   /* Assert behind not                      */ \
  1+LINK_SIZE,                   /* Reverse                                */ \
  1+LINK_SIZE,                   /* Once                                   */ \
  1+LINK_SIZE,                   /* COND                                   */ \
  3,                             /* CREF                                   */ \
  1, 1,                          /* BRAZERO, BRAMINZERO                    */ \
  3,                             /* BRANUMBER                              */ \
  1+LINK_SIZE                    /* BRA                                    */ \


/* The highest extraction number before we have to start using additional
bytes. (Originally PCRE didn't have support for extraction counts highter than
this number.) The value is limited by the number of opcodes left after OP_BRA,
i.e. 255 - OP_BRA. We actually set it a bit lower to leave room for additional
opcodes. */

#define EXTRACT_BASIC_MAX  150

/* A magic value for OP_CREF to indicate the "in recursion" condition. */

#define CREF_RECURSE  0xffff

/* The texts of compile-time error messages are defined as macros here so that
they can be accessed by the POSIX wrapper and converted into error codes.  Yes,
I could have used error codes in the first place, but didn't feel like changing
just to accommodate the POSIX wrapper. */

#define ERR1  "\\ at end of pattern"
#define ERR2  "\\c at end of pattern"
#define ERR3  "unrecognized character follows \\"
#define ERR4  "numbers out of order in {} quantifier"
#define ERR5  "number too big in {} quantifier"
#define ERR6  "missing terminating ] for character class"
#define ERR7  "invalid escape sequence in character class"
#define ERR8  "range out of order in character class"
#define ERR9  "nothing to repeat"
#define ERR10 "operand of unlimited repeat could match the empty string"
#define ERR11 "internal error: unexpected repeat"
#define ERR12 "unrecognized character after (?"
#define ERR13 "POSIX named classes are supported only within a class"
#define ERR14 "missing )"
#define ERR15 "reference to non-existent subpattern"
#define ERR16 "erroffset passed as NULL"
#define ERR17 "unknown option bit(s) set"
#define ERR18 "missing ) after comment"
#define ERR19 "parentheses nested too deeply"
#define ERR20 "regular expression too large"
#define ERR21 "failed to get memory"
#define ERR22 "unmatched parentheses"
#define ERR23 "internal error: code overflow"
#define ERR24 "unrecognized character after (?<"
#define ERR25 "lookbehind assertion is not fixed length"
#define ERR26 "malformed number after (?("
#define ERR27 "conditional group contains more than two branches"
#define ERR28 "assertion expected after (?("
#define ERR29 "(?R or (?digits must be followed by )"
#define ERR30 "unknown POSIX class name"
#define ERR31 "POSIX collating elements are not supported"
#define ERR32 "this version of PCRE is not compiled with PCRE_UTF8 support"
#define ERR33 "spare error"
#define ERR34 "character value in \\x{...} sequence is too large"
#define ERR35 "invalid condition (?(0)"
#define ERR36 "\\C not allowed in lookbehind assertion"
#define ERR37 "PCRE does not support \\L, \\l, \\N, \\P, \\p, \\U, \\u, or \\X"
#define ERR38 "number after (?C is > 255"
#define ERR39 "closing ) for (?C expected"
#define ERR40 "recursive call could loop indefinitely"
#define ERR41 "unrecognized character after (?P"
#define ERR42 "syntax error after (?P"
#define ERR43 "two named groups have the same name"
#define ERR44 "invalid UTF-8 string"

/* All character handling must be done as unsigned characters. Otherwise there
are problems with top-bit-set characters and functions such as isspace().
However, we leave the interface to the outside world as char *, because that
should make things easier for callers. We define a short type for unsigned char
to save lots of typing. I tried "uchar", but it causes problems on Digital
Unix, where it is defined in sys/types, so use "uschar" instead. */

typedef unsigned char uschar;

/* The real format of the start of the pcre block; the index of names and the
code vector run on as long as necessary after the end. */

typedef struct real_pcre {
  unsigned long int magic_number;
  size_t size;			/* Total that was malloced */
  const unsigned char *tables;	/* Pointer to tables */
  unsigned long int options;
  unsigned short int top_bracket;
  unsigned short int top_backref;
  unsigned short int first_byte;
  unsigned short int req_byte;
  unsigned short int name_entry_size;	/* Size of any name items; 0 => none */
  unsigned short int name_count;	/* Number of name items */
} real_pcre;

/* The format of the block used to store data from pcre_study(). */

typedef struct pcre_study_data {
  size_t size;			/* Total that was malloced */
  uschar options;
  uschar start_bits[32];
} pcre_study_data;

/* Structure for passing "static" information around between the functions
doing the compiling, so that they are thread-safe. */

typedef struct compile_data {
  const uschar *lcc;		/* Points to lower casing table */
  const uschar *fcc;		/* Points to case-flipping table */
  const uschar *cbits;		/* Points to character type table */
  const uschar *ctypes;		/* Points to table of type maps */
  const uschar *start_code;	/* The start of the compiled code */
  uschar *name_table;		/* The name/number table */
  int names_found;		/* Number of entries so far */
  int name_entry_size;		/* Size of each entry */
  int top_backref;		/* Maximum back reference */
  unsigned int backref_map;	/* Bitmap of low back refs */
  int req_varyopt;		/* "After variable item" flag for reqbyte */
} compile_data;

/* Structure for maintaining a chain of pointers to the currently incomplete
branches, for testing for left recursion. */

typedef struct branch_chain {
  struct branch_chain *outer;
  uschar *current;
} branch_chain;

/* Structure for items in a linked list that represents an explicit recursive
call within the pattern. */

typedef struct recursion_info {
  struct recursion_info *prevrec;	/* Previous recursion record (or NULL) */
  int group_num;		/* Number of group that was called */
  const uschar *after_call;	/* "Return value": points after the call in the expr */
  const uschar *save_start;	/* Old value of md->start_match */
  int *offset_save;		/* Pointer to start of saved offsets */
  int saved_max;		/* Number of saved offsets */
} recursion_info;

/* When compiling in a mode that doesn't use recursive calls to match(),
a structure is used to remember local variables on the heap. It is defined in
pcre.c, close to the match() function, so that it is easy to keep it in step
with any changes of local variable. However, the pointer to the current frame
must be saved in some "static" place over a longjmp(). We declare the
structure here so that we can put a pointer in the match_data structure.
NOTE: This isn't used for a "normal" compilation of pcre. */

struct heapframe;

/* Structure for passing "static" information around between the functions
doing the matching, so that they are thread-safe. */

typedef struct match_data {
  unsigned long int match_call_count;	/* As it says */
  unsigned long int match_limit;	/* As it says */
  int *offset_vector;		/* Offset vector */
  int offset_end;		/* One past the end */
  int offset_max;		/* The maximum usable for return data */
  const uschar *lcc;		/* Points to lower casing table */
  const uschar *ctypes;		/* Points to table of type maps */
  BOOL offset_overflow;		/* Set if too many extractions */
  BOOL notbol;			/* NOTBOL flag */
  BOOL noteol;			/* NOTEOL flag */
  BOOL utf8;			/* UTF8 flag */
  BOOL endonly;			/* Dollar not before final \n */
  BOOL notempty;		/* Empty string match not wanted */
  const uschar *start_code;	/* For use when recursing */
  const uschar *start_subject;	/* Start of the subject string */
  const uschar *end_subject;	/* End of the subject string */
  const uschar *start_match;	/* Start of this match attempt */
  const uschar *end_match_ptr;	/* Subject position at end match */
  int end_offset_top;		/* Highwater mark at end of match */
  int capture_last;		/* Most recent capture number */
  int start_offset;		/* The start offset value */
  recursion_info *recursive;	/* Linked list of recursion data */
  void *callout_data;		/* To pass back to callouts */
  struct heapframe *thisframe;	/* Used only when compiling for no recursion */
} match_data;

/* Bit definitions for entries in the pcre_ctypes table. */

#define ctype_space   0x01
#define ctype_letter  0x02
#define ctype_digit   0x04
#define ctype_xdigit  0x08
#define ctype_word    0x10	/* alphameric or '_' */
#define ctype_meta    0x80	/* regexp meta char or zero (end pattern) */

/* Offsets for the bitmap tables in pcre_cbits. Each table contains a set
of bits for a class map. Some classes are built by combining these tables. */

#define cbit_space     0	/* [:space:] or \s */
#define cbit_xdigit   32	/* [:xdigit:] */
#define cbit_digit    64	/* [:digit:] or \d */
#define cbit_upper    96	/* [:upper:] */
#define cbit_lower   128	/* [:lower:] */
#define cbit_word    160	/* [:word:] or \w */
#define cbit_graph   192	/* [:graph:] */
#define cbit_print   224	/* [:print:] */
#define cbit_punct   256	/* [:punct:] */
#define cbit_cntrl   288	/* [:cntrl:] */
#define cbit_length  320	/* Length of the cbits table */

/* Offsets of the various tables from the base tables pointer, and
total length. */

#define lcc_offset      0
#define fcc_offset    256
#define cbits_offset  512
#define ctypes_offset (cbits_offset + cbit_length)
#define tables_length (ctypes_offset + 256)

/* End of internal.h */
/* chartables.c */
/*************************************************
*      Perl-Compatible Regular Expressions       *
*************************************************/

/* This file is automatically written by the dftables auxiliary 
program. If you edit it by hand, you might like to edit the Makefile to 
prevent its ever being regenerated.

This file is #included in the compilation of pcre.c to build the default
character tables which are used when no tables are passed to the compile
function. */

static unsigned char pcre_default_tables[] = {

/* This table is a lower casing table. */

  0, 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, 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, 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,

/* This table is a case flipping table. */

  0, 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, 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, 91, 92, 93, 94, 95,
  96, 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, 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,

/* This table contains bit maps for various character classes.
Each map is 32 bytes long and the bits run from the least
significant end of each byte. The classes that have their own
maps are: space, xdigit, digit, upper, lower, word, graph
print, punct, and cntrl. Other classes are built from combinations. */

  0x00, 0x3e, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x03,
  0x7e, 0x00, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x03,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0xfe, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xff, 0x07,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x03,
  0xfe, 0xff, 0xff, 0x87, 0xfe, 0xff, 0xff, 0x07,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

  0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xff, 0xff,
  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

  0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

  0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0x00, 0xfc,
  0x01, 0x00, 0x00, 0xf8, 0x01, 0x00, 0x00, 0x78,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

  0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

/* This table identifies various classes of character by individual bits:
  0x01   white space character
  0x02   letter
  0x04   decimal digit
  0x08   hexadecimal digit
  0x10   alphanumeric or '_'
  0x80   regular expression metacharacter or binary zero
*/

  0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/*   0-  7 */
  0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0x00,	/*   8- 15 */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/*  16- 23 */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/*  24- 31 */
  0x01, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00,	/*    - '  */
  0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x80, 0x00,	/*  ( - /  */
  0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c,	/*  0 - 7  */
  0x1c, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,	/*  8 - ?  */
  0x00, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x12,	/*  @ - G  */
  0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,	/*  H - O  */
  0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,	/*  P - W  */
  0x12, 0x12, 0x12, 0x80, 0x00, 0x00, 0x80, 0x10,	/*  X - _  */
  0x00, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x12,	/*  ` - g  */
  0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,	/*  h - o  */
  0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,	/*  p - w  */
  0x12, 0x12, 0x12, 0x80, 0x80, 0x00, 0x00, 0x00,	/*  x -127 */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/* 128-135 */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/* 136-143 */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/* 144-151 */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/* 152-159 */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/* 160-167 */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/* 168-175 */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/* 176-183 */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/* 184-191 */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/* 192-199 */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/* 200-207 */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/* 208-215 */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/* 216-223 */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/* 224-231 */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/* 232-239 */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/* 240-247 */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};				/* 248-255 */

/* End of chartables.c */
/* get.c */
/* This module contains some convenience functions for extracting substrings
from the subject string after a regex match has succeeded. The original idea
for these functions came from Scott Wimer <scottw@cgibuilder.com>. */


/*************************************************
*      Copy captured string to given buffer      *
*************************************************/

/* This function copies a single captured substring into a given buffer.
Note that we use memcpy() rather than strncpy() in case there are binary zeros
in the string.

Arguments:
  subject        the subject string that was matched
  ovector        pointer to the offsets table
  stringcount    the number of substrings that were captured
                   (i.e. the yield of the pcre_exec call, unless
                   that was zero, in which case it should be 1/3
                   of the offset table size)
  stringnumber   the number of the required substring
  buffer         where to put the substring
  size           the size of the buffer

Returns:         if successful:
                   the length of the copied string, not including the zero
                   that is put on the end; can be zero
                 if not successful:
                   PCRE_ERROR_NOMEMORY (-6) buffer too small
                   PCRE_ERROR_NOSUBSTRING (-7) no such captured substring
*/

int
pcre_copy_substring(const char *subject, int *ovector, int stringcount,
		    int stringnumber, char *buffer, int size)
{
  int yield;
  if (stringnumber < 0 || stringnumber >= stringcount)
    return PCRE_ERROR_NOSUBSTRING;
  stringnumber *= 2;
  yield = ovector[stringnumber + 1] - ovector[stringnumber];
  if (size < yield + 1)
    return PCRE_ERROR_NOMEMORY;
  memcpy(buffer, subject + ovector[stringnumber], yield);
  buffer[yield] = 0;
  return yield;
}



/* End of get.c */
/* maketables.c */
/*************************************************
*           Create PCRE character tables         *
*************************************************/

/* This function builds a set of character tables for use by PCRE and returns
a pointer to them. They are build using the ctype functions, and consequently
their contents will depend upon the current locale setting. When compiled as
part of the library, the store is obtained via pcre_malloc(), but when compiled
inside dftables, use malloc().

Arguments:   none
Returns:     pointer to the contiguous block of data
*/

const unsigned char *
pcre_maketables(void)
{
  unsigned char *yield, *p;
  int i;

#ifndef DFTABLES
  yield = (unsigned char *) malloc(tables_length);
#else
  yield = (unsigned char *) malloc(tables_length);
#endif

  if (yield == NULL)
    return NULL;
  p = yield;

/* First comes the lower casing table */

  for (i = 0; i < 256; i++)
    *p++ = tolower(i);

/* Next the case-flipping table */

  for (i = 0; i < 256; i++)
    *p++ = islower(i) ? toupper(i) : tolower(i);

/* Then the character class tables. Don't try to be clever and save effort
on exclusive ones - in some locales things may be different. Note that the
table for "space" includes everything "isspace" gives, including VT in the
default locale. This makes it work for the POSIX class [:space:]. */

  memset(p, 0, cbit_length);
  for (i = 0; i < 256; i++) {
    if (isdigit(i)) {
      p[cbit_digit + i / 8] |= 1 << (i & 7);
      p[cbit_word + i / 8] |= 1 << (i & 7);
    }
    if (isupper(i)) {
      p[cbit_upper + i / 8] |= 1 << (i & 7);
      p[cbit_word + i / 8] |= 1 << (i & 7);
    }
    if (islower(i)) {
      p[cbit_lower + i / 8] |= 1 << (i & 7);
      p[cbit_word + i / 8] |= 1 << (i & 7);
    }
    if (i == '_')
      p[cbit_word + i / 8] |= 1 << (i & 7);
    if (isspace(i))
      p[cbit_space + i / 8] |= 1 << (i & 7);
    if (isxdigit(i))
      p[cbit_xdigit + i / 8] |= 1 << (i & 7);
    if (isgraph(i))
      p[cbit_graph + i / 8] |= 1 << (i & 7);
    if (isprint(i))
      p[cbit_print + i / 8] |= 1 << (i & 7);
    if (ispunct(i))
      p[cbit_punct + i / 8] |= 1 << (i & 7);
    if (iscntrl(i))
      p[cbit_cntrl + i / 8] |= 1 << (i & 7);
  }
  p += cbit_length;

/* Finally, the character type table. In this, we exclude VT from the white
space chars, because Perl doesn't recognize it as such for \s and for comments
within regexes. */

  for (i = 0; i < 256; i++) {
    int x = 0;
    if (i != 0x0b && isspace(i))
      x += ctype_space;
    if (isalpha(i))
      x += ctype_letter;
    if (isdigit(i))
      x += ctype_digit;
    if (isxdigit(i))
      x += ctype_xdigit;
    if (isalnum(i) || i == '_')
      x += ctype_word;

    /* Note: strchr includes the terminating zero in the characters it considers.
       In this instance, that is ok because we want binary zero to be flagged as a
       meta-character, which in this sense is any character that terminates a run
       of data characters. */

    if (strchr("*+?{^.$|()[", i) != 0)
      x += ctype_meta;
    *p++ = x;
  }

  return yield;
}

/* End of maketables.c */
/* study.c */
/*************************************************
*      Set a bit and maybe its alternate case    *
*************************************************/

/* Given a character, set its bit in the table, and also the bit for the other
version of a letter if we are caseless.

Arguments:
  start_bits    points to the bit map
  c             is the character
  caseless      the caseless flag
  cd            the block with char table pointers

Returns:        nothing
*/

static void
set_bit(uschar * start_bits, int c, BOOL caseless, compile_data * cd)
{
  start_bits[c / 8] |= (1 << (c & 7));
  if (caseless && (cd->ctypes[c] & ctype_letter) != 0)
    start_bits[cd->fcc[c] / 8] |= (1 << (cd->fcc[c] & 7));
}



/*************************************************
*          Create bitmap of starting chars       *
*************************************************/

/* This function scans a compiled unanchored expression and attempts to build a
bitmap of the set of initial characters. If it can't, it returns FALSE. As time
goes by, we may be able to get more clever at doing this.

Arguments:
  code         points to an expression
  start_bits   points to a 32-byte table, initialized to 0
  caseless     the current state of the caseless flag
  utf8         TRUE if in UTF-8 mode
  cd           the block with char table pointers

Returns:       TRUE if table built, FALSE otherwise
*/

static BOOL
set_start_bits(const uschar * code, uschar * start_bits, BOOL caseless,
	       BOOL utf8, compile_data * cd)
{
  register int c;

/* This next statement and the later reference to dummy are here in order to
trick the optimizer of the IBM C compiler for OS/2 into generating correct
code. Apparently IBM isn't going to fix the problem, and we would rather not
disable optimization (in this module it actually makes a big difference, and
the pcre module can use all the optimization it can get). */

  volatile int dummy;

  do {
    const uschar *tcode = code + 1 + LINK_SIZE;
    BOOL try_next = TRUE;

    while (try_next) {
      /* If a branch starts with a bracket or a positive lookahead assertion,
         recurse to set bits from within them. That's all for this branch. */

      if ((int) *tcode >= OP_BRA || *tcode == OP_ASSERT) {
	if (!set_start_bits(tcode, start_bits, caseless, utf8, cd))
	  return FALSE;
	try_next = FALSE;
      }

      else
	switch (*tcode) {
	default:
	  return FALSE;

	  /* Skip over callout */

	case OP_CALLOUT:
	  tcode += 2;
	  break;

	  /* Skip over extended extraction bracket number */

	case OP_BRANUMBER:
	  tcode += 3;
	  break;

	  /* Skip over lookbehind and negative lookahead assertions */

	case OP_ASSERT_NOT:
	case OP_ASSERTBACK:
	case OP_ASSERTBACK_NOT:
	  do
	    tcode += GET(tcode, 1);
	  while (*tcode == OP_ALT);
	  tcode += 1 + LINK_SIZE;
	  break;

	  /* Skip over an option setting, changing the caseless flag */

	case OP_OPT:
	  caseless = (tcode[1] & PCRE_CASELESS) != 0;
	  tcode += 2;
	  break;

	  /* BRAZERO does the bracket, but carries on. */

	case OP_BRAZERO:
	case OP_BRAMINZERO:
	  if (!set_start_bits(++tcode, start_bits, caseless, utf8, cd))
	    return FALSE;
	  dummy = 1;
	  do
	    tcode += GET(tcode, 1);
	  while (*tcode == OP_ALT);
	  tcode += 1 + LINK_SIZE;
	  break;

	  /* Single-char * or ? sets the bit and tries the next item */

	case OP_STAR:
	case OP_MINSTAR:
	case OP_QUERY:
	case OP_MINQUERY:
	  set_bit(start_bits, tcode[1], caseless, cd);
	  tcode += 2;
	  break;

	  /* Single-char upto sets the bit and tries the next */

	case OP_UPTO:
	case OP_MINUPTO:
	  set_bit(start_bits, tcode[3], caseless, cd);
	  tcode += 4;
	  break;

	  /* At least one single char sets the bit and stops */

	case OP_EXACT:		/* Fall through */
	  tcode++;

	case OP_CHARS:		/* Fall through */
	  tcode++;

	case OP_PLUS:
	case OP_MINPLUS:
	  set_bit(start_bits, tcode[1], caseless, cd);
	  try_next = FALSE;
	  break;

	  /* Single character type sets the bits and stops */

	case OP_NOT_DIGIT:
	  for (c = 0; c < 32; c++)
	    start_bits[c] |= ~cd->cbits[c + cbit_digit];
	  try_next = FALSE;
	  break;

	case OP_DIGIT:
	  for (c = 0; c < 32; c++)
	    start_bits[c] |= cd->cbits[c + cbit_digit];
	  try_next = FALSE;
	  break;

	case OP_NOT_WHITESPACE:
	  for (c = 0; c < 32; c++)
	    start_bits[c] |= ~cd->cbits[c + cbit_space];
	  try_next = FALSE;
	  break;

	case OP_WHITESPACE:
	  for (c = 0; c < 32; c++)
	    start_bits[c] |= cd->cbits[c + cbit_space];
	  try_next = FALSE;
	  break;

	case OP_NOT_WORDCHAR:
	  for (c = 0; c < 32; c++)
	    start_bits[c] |= ~cd->cbits[c + cbit_word];
	  try_next = FALSE;
	  break;

	case OP_WORDCHAR:
	  for (c = 0; c < 32; c++)
	    start_bits[c] |= cd->cbits[c + cbit_word];
	  try_next = FALSE;
	  break;

	  /* One or more character type fudges the pointer and restarts, knowing
	     it will hit a single character type and stop there. */

	case OP_TYPEPLUS:
	case OP_TYPEMINPLUS:
	  tcode++;
	  break;

	case OP_TYPEEXACT:
	  tcode += 3;
	  break;

	  /* Zero or more repeats of character types set the bits and then
	     try again. */

	case OP_TYPEUPTO:
	case OP_TYPEMINUPTO:
	  tcode += 2;		/* Fall through */

	case OP_TYPESTAR:
	case OP_TYPEMINSTAR:
	case OP_TYPEQUERY:
	case OP_TYPEMINQUERY:
	  switch (tcode[1]) {
	  case OP_ANY:
	    return FALSE;

	  case OP_NOT_DIGIT:
	    for (c = 0; c < 32; c++)
	      start_bits[c] |= ~cd->cbits[c + cbit_digit];
	    break;

	  case OP_DIGIT:
	    for (c = 0; c < 32; c++)
	      start_bits[c] |= cd->cbits[c + cbit_digit];
	    break;

	  case OP_NOT_WHITESPACE:
	    for (c = 0; c < 32; c++)
	      start_bits[c] |= ~cd->cbits[c + cbit_space];
	    break;

	  case OP_WHITESPACE:
	    for (c = 0; c < 32; c++)
	      start_bits[c] |= cd->cbits[c + cbit_space];
	    break;

	  case OP_NOT_WORDCHAR:
	    for (c = 0; c < 32; c++)
	      start_bits[c] |= ~cd->cbits[c + cbit_word];
	    break;

	  case OP_WORDCHAR:
	    for (c = 0; c < 32; c++)
	      start_bits[c] |= cd->cbits[c + cbit_word];
	    break;
	  }

	  tcode += 2;
	  break;

	  /* Character class where all the information is in a bit map: set the
	     bits and either carry on or not, according to the repeat count. If it was
	     a negative class, and we are operating with UTF-8 characters, any byte
	     with a value >= 0xc4 is a potentially valid starter because it starts a
	     character with a value > 255. */

	case OP_NCLASS:
	  if (utf8) {
	    start_bits[24] |= 0xf0;	/* Bits for 0xc4 - 0xc8 */
	    memset(start_bits + 25, 0xff, 7);	/* Bits for 0xc9 - 0xff */
	  }
	  /* Fall through */

	case OP_CLASS:
	  {
	    tcode++;

	    /* In UTF-8 mode, the bits in a bit map correspond to character
	       values, not to byte values. However, the bit map we are constructing is
	       for byte values. So we have to do a conversion for characters whose
	       value is > 127. In fact, there are only two possible starting bytes for
	       characters in the range 128 - 255. */

	    if (utf8) {
	      for (c = 0; c < 16; c++)
		start_bits[c] |= tcode[c];
	      for (c = 128; c < 256; c++) {
		if ((tcode[c / 8] && (1 << (c & 7))) != 0) {
		  int d = (c >> 6) | 0xc0;	/* Set bit for this starter */
		  start_bits[d / 8] |= (1 << (d & 7));	/* and then skip on to the */
		  c = (c & 0xc0) + 0x40 - 1;	/* next relevant character. */
		}
	      }
	    }

	    /* In non-UTF-8 mode, the two bit maps are completely compatible. */

	    else {
	      for (c = 0; c < 32; c++)
		start_bits[c] |= tcode[c];
	    }

	    /* Advance past the bit map, and act on what follows */

	    tcode += 32;
	    switch (*tcode) {
	    case OP_CRSTAR:
	    case OP_CRMINSTAR:
	    case OP_CRQUERY:
	    case OP_CRMINQUERY:
	      tcode++;
	      break;

	    case OP_CRRANGE:
	    case OP_CRMINRANGE:
	      if (((tcode[1] << 8) + tcode[2]) == 0)
		tcode += 5;
	      else
		try_next = FALSE;
	      break;

	    default:
	      try_next = FALSE;
	      break;
	    }
	  }
	  break;		/* End of bitmap class handling */

	}			/* End of switch */
    }				/* End of try_next loop */

    code += GET(code, 1);	/* Advance to next branch */
  }
  while (*code == OP_ALT);
  return TRUE;
}



/*************************************************
*          Study a compiled expression           *
*************************************************/

/* This function is handed a compiled expression that it must study to produce
information that will speed up the matching. It returns a pcre_extra block
which then gets handed back to pcre_exec().

Arguments:
  re        points to the compiled expression
  options   contains option bits
  errorptr  points to where to place error messages;
            set NULL unless error

Returns:    pointer to a pcre_extra block, with study_data filled in and the
              appropriate flag set;
            NULL on error or if no optimization possible
*/

EXPORT pcre_extra *
pcre_study(const pcre * external_re, int options, const char **errorptr)
{
  uschar start_bits[32];
  pcre_extra *extra;
  pcre_study_data *study;
  const real_pcre *re = (const real_pcre *) external_re;
  uschar *code = (uschar *) re + sizeof(real_pcre) +
    (re->name_count * re->name_entry_size);
  compile_data compile_block;

  *errorptr = NULL;

  if (re == NULL || re->magic_number != MAGIC_NUMBER) {
    *errorptr = "argument is not a compiled regular expression";
    return NULL;
  }

  if ((options & ~PUBLIC_STUDY_OPTIONS) != 0) {
    *errorptr = "unknown or incorrect option bit(s) set";
    return NULL;
  }

/* For an anchored pattern, or an unanchored pattern that has a first char, or
a multiline pattern that matches only at "line starts", no further processing
at present. */

  if ((re->options & (PCRE_ANCHORED | PCRE_FIRSTSET | PCRE_STARTLINE)) != 0)
    return NULL;

/* Set the character tables in the block which is passed around */

  compile_block.lcc = re->tables + lcc_offset;
  compile_block.fcc = re->tables + fcc_offset;
  compile_block.cbits = re->tables + cbits_offset;
  compile_block.ctypes = re->tables + ctypes_offset;

/* See if we can find a fixed set of initial characters for the pattern. */

  memset(start_bits, 0, 32 * sizeof(uschar));
  if (!set_start_bits(code, start_bits, (re->options & PCRE_CASELESS) != 0,
		      (re->options & PCRE_UTF8) != 0, &compile_block))
    return NULL;

/* Get a pcre_extra block and a pcre_study_data block. The study data is put in
the latter, which is pointed to by the former, which may also get additional
data set later by the calling program. At the moment, the size of
pcre_study_data is fixed. We nevertheless save it in a field for returning via
the pcre_fullinfo() function so that if it becomes variable in the future, we
don't have to change that code. */

  extra = (pcre_extra *) malloc(sizeof(pcre_extra) + sizeof(pcre_study_data));

  if (extra == NULL) {
    *errorptr = "failed to get memory";
    return NULL;
  }

  study = (pcre_study_data *) ((char *) extra + sizeof(pcre_extra));
  extra->flags = PCRE_EXTRA_STUDY_DATA;
  extra->study_data = study;

  study->size = sizeof(pcre_study_data);
  study->options = PCRE_STUDY_MAPPED;
  memcpy(study->start_bits, start_bits, sizeof(start_bits));

  return extra;
}

/* End of study.c */
/* pcre.c */
#define DPRINTF(p)		/*nothing */

/* Maximum number of items on the nested bracket stacks at compile time. This
applies to the nesting of all kinds of parentheses. It does not limit
un-nested, non-capturing parentheses. This number can be made bigger if
necessary - it is used to dimension one int and one unsigned char vector at
compile time. */

#define BRASTACK_SIZE 200


/* Maximum number of ints of offset to save on the stack for recursive calls.
If the offset vector is bigger, malloc is used. This should be a multiple of 3,
because the offset vector is always a multiple of 3 long. */

#define REC_STACK_SAVE_MAX 30


/* The number of bytes in a literal character string above which we can't add
any more is set at 250 in order to allow for UTF-8 characters. (In theory it
could be 255 when UTF-8 support is excluded, but that means that some of the
test output would be different, which just complicates things.) */

#define MAXLIT 250


/* The maximum remaining length of subject we are prepared to search for a
req_byte match. */

#define REQ_BYTE_MAX 1000


/* Table of sizes for the fixed-length opcodes. It's defined in a macro so that
the definition is next to the definition of the opcodes in internal.h. */

static const uschar OP_lengths[] = { OP_LENGTHS };

/* Min and max values for the common repeats; for the maxima, 0 => infinity */

static const char rep_min[] = { 0, 0, 1, 1, 0, 0 };
static const char rep_max[] = { 0, 0, 0, 0, 1, 1 };

/* Table for handling escaped characters in the range '0'-'z'. Positive returns
are simple data values; negative values are for special things like \d and so
on. Zero means further processing is needed (for things like \x), or the escape
is invalid. */

static const short int escapes[] = {
  0, 0, 0, 0, 0, 0, 0, 0,	/* 0 - 7 */
  0, 0, ':', ';', '<', '=', '>', '?',	/* 8 - ? */
  '@', -ESC_A, -ESC_B, -ESC_C, -ESC_D, -ESC_E, 0, -ESC_G,	/* @ - G */
  0, 0, 0, 0, 0, 0, 0, 0,	/* H - O */
  0, -ESC_Q, 0, -ESC_S, 0, 0, 0, -ESC_W,	/* P - W */
  0, 0, -ESC_Z, '[', '\\', ']', '^', '_',	/* X - _ */
  '`', 7, -ESC_b, 0, -ESC_d, ESC_e, ESC_f, 0,	/* ` - g */
  0, 0, 0, 0, 0, 0, ESC_n, 0,	/* h - o */
  0, 0, ESC_r, -ESC_s, ESC_tee, 0, 0, -ESC_w,	/* p - w */
  0, 0, -ESC_z			/* x - z */
};



/* Tables of names of POSIX character classes and their lengths. The list is
terminated by a zero length entry. The first three must be alpha, upper, lower,
as this is assumed for handling case independence. */

static const char *const posix_names[] = {
  "alpha", "lower", "upper",
  "alnum", "ascii", "blank", "cntrl", "digit", "graph",
  "print", "punct", "space", "word", "xdigit"
};

static const uschar posix_name_lengths[] = {
  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 4, 6, 0
};

/* Table of class bit maps for each POSIX class; up to three may be combined
to form the class. The table for [:blank:] is dynamically modified to remove
the vertical space characters. */

static const int posix_class_maps[] = {
  cbit_lower, cbit_upper, -1,	/* alpha */
  cbit_lower, -1, -1,		/* lower */
  cbit_upper, -1, -1,		/* upper */
  cbit_digit, cbit_lower, cbit_upper,	/* alnum */
  cbit_print, cbit_cntrl, -1,	/* ascii */
  cbit_space, -1, -1,		/* blank - a GNU extension */
  cbit_cntrl, -1, -1,		/* cntrl */
  cbit_digit, -1, -1,		/* digit */
  cbit_graph, -1, -1,		/* graph */
  cbit_print, -1, -1,		/* print */
  cbit_punct, -1, -1,		/* punct */
  cbit_space, -1, -1,		/* space */
  cbit_word, -1, -1,		/* word - a Perl extension */
  cbit_xdigit, -1, -1		/* xdigit */
};

/* Table to identify digits and hex digits. This is used when compiling
patterns. Note that the tables in chartables are dependent on the locale, and
may mark arbitrary characters as digits - but the PCRE compiling code expects
to handle only 0-9, a-z, and A-Z as digits when compiling. That is why we have
a private table here. It costs 256 bytes, but it is a lot faster than doing
character value tests (at least in some simple cases I timed), and in some
applications one wants PCRE to compile efficiently as well as match
efficiently.

For convenience, we use the same bit definitions as in chartables:

  0x04   decimal digit
  0x08   hexadecimal digit

Then we can use ctype_digit and ctype_xdigit in the code. */

static const unsigned char digitab[] = {
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/*   0-  7 */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/*   8- 15 */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/*  16- 23 */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/*  24- 31 */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/*    - '  */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/*  ( - /  */
  0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,	/*  0 - 7  */
  0x0c, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/*  8 - ?  */
  0x00, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00,	/*  @ - G  */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/*  H - O  */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/*  P - W  */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/*  X - _  */
  0x00, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00,	/*  ` - g  */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/*  h - o  */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/*  p - w  */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/*  x -127 */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/* 128-135 */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/* 136-143 */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/* 144-151 */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/* 152-159 */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/* 160-167 */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/* 168-175 */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/* 176-183 */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/* 184-191 */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/* 192-199 */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/* 200-207 */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/* 208-215 */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/* 216-223 */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/* 224-231 */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/* 232-239 */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/* 240-247 */
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};				/* 248-255 */



/* Definition to allow mutual recursion */

static BOOL
compile_regex(int, int, int *, uschar **, const uschar **, const char **,
	      BOOL, int, int *, int *, branch_chain *, compile_data *);

/* Structure for building a chain of data that actually lives on the
stack, for holding the values of the subject pointer at the start of each
subpattern, so as to detect when an empty string has been matched by a
subpattern - to break infinite loops. When NO_RECURSE is set, these blocks
are on the heap, not on the stack. */

typedef struct eptrblock {
  struct eptrblock *epb_prev;
  const uschar *epb_saved_eptr;
} eptrblock;

/* Flag bits for the match() function */

#define match_condassert   0x01	/* Called to check a condition assertion */
#define match_isgroup      0x02	/* Set if start of bracketed group */

/* Non-error returns from the match() function. Error returns are externally
defined PCRE_ERROR_xxx codes, which are all negative. */

#define MATCH_MATCH        1
#define MATCH_NOMATCH      0



/*************************************************
*               Global variables                 *
*************************************************/

/* PCRE is thread-clean and doesn't use any global variables in the normal
sense. However, it calls memory allocation and free functions via the four
indirections below, and it can optionally do callouts. These values can be
changed by the caller, but are shared between all threads. However, when
compiling for Virtual Pascal, things are done differently (see pcre.in). */

#ifndef VPCOMPAT
#ifdef __cplusplus
extern "C" void *(*pcre_malloc) (size_t) = malloc;
extern "C" void (*pcre_free) (void *) = free;
extern "C" void *(*pcre_stack_malloc) (size_t) = malloc;
extern "C" void (*pcre_stack_free) (void *) = free;
extern "C" int (*pcre_callout) (pcre_callout_block *) = NULL;
#else
void *(*pcre_malloc) (size_t) = malloc;
void (*pcre_free) (void *) = free;
void *(*pcre_stack_malloc) (size_t) = malloc;
void (*pcre_stack_free) (void *) = free;
int (*pcre_callout) (pcre_callout_block *) = NULL;
#endif
#endif


/*************************************************
*    Macros and tables for character handling    *
*************************************************/

/* When UTF-8 encoding is being used, a character is no longer just a single
byte. The macros for character handling generate simple sequences when used in
byte-mode, and more complicated ones for UTF-8 characters. */

#define GETCHAR(c, eptr) c = *eptr;
#define GETCHARINC(c, eptr) c = *eptr++;
#define GETCHARINCTEST(c, eptr) c = *eptr++;
#define GETCHARLEN(c, eptr, len) c = *eptr;
#define BACKCHAR(eptr)


/*************************************************
*            Handle escapes                      *
*************************************************/

/* This function is called when a \ has been encountered. It either returns a
positive value for a simple escape such as \n, or a negative value which
encodes one of the more complicated things such as \d. When UTF-8 is enabled,
a positive value greater than 255 may be returned. On entry, ptr is pointing at
the \. On exit, it is on the final character of the escape sequence.

Arguments:
  ptrptr     points to the pattern position pointer
  errorptr   points to the pointer to the error message
  bracount   number of previous extracting brackets
  options    the options bits
  isclass    TRUE if inside a character class

Returns:     zero or positive => a data character
             negative => a special escape sequence
             on error, errorptr is set
*/

static int
check_escape(const uschar ** ptrptr, const char **errorptr, int bracount,
	     int options, BOOL isclass)
{
  const uschar *ptr = *ptrptr;
  int c, i;

/* If backslash is at the end of the pattern, it's an error. */

  c = *(++ptr);
  if (c == 0)
    *errorptr = ERR1;

/* Non-alphamerics are literals. For digits or letters, do an initial lookup in
a table. A non-zero result is something that can be returned immediately.
Otherwise further processing may be required. */

  else if (c < '0' || c > 'z') {
  } /* Not alphameric */
  else if ((i = escapes[c - '0']) != 0)
    c = i;


/* Escapes that need further processing, or are illegal. */

  else {
    const uschar *oldptr;
    switch (c) {
      /* A number of Perl escapes are not handled by PCRE. We give an explicit
         error. */

    case 'l':
    case 'L':
    case 'N':
    case 'p':
    case 'P':
    case 'u':
    case 'U':
    case 'X':
      *errorptr = ERR37;
      break;

      /* The handling of escape sequences consisting of a string of digits
         starting with one that is not zero is not straightforward. By experiment,
         the way Perl works seems to be as follows:

         Outside a character class, the digits are read as a decimal number. If the
         number is less than 10, or if there are that many previous extracting
         left brackets, then it is a back reference. Otherwise, up to three octal
         digits are read to form an escaped byte. Thus \123 is likely to be octal
         123 (cf \0123, which is octal 012 followed by the literal 3). If the octal
         value is greater than 377, the least significant 8 bits are taken. Inside a
         character class, \ followed by a digit is always an octal number. */

    case '1':
    case '2':
    case '3':
    case '4':
    case '5':
    case '6':
    case '7':
    case '8':
    case '9':

      if (!isclass) {
	oldptr = ptr;
	c -= '0';
	while ((digitab[ptr[1]] & ctype_digit) != 0)
	  c = c * 10 + *(++ptr) - '0';
	if (c < 10 || c <= bracount) {
	  c = -(ESC_REF + c);
	  break;
	}
	ptr = oldptr;		/* Put the pointer back and fall through */
      }

      /* Handle an octal number following \. If the first digit is 8 or 9, Perl
         generates a binary zero byte and treats the digit as a following literal.
         Thus we have to pull back the pointer by one. */

      if ((c = *ptr) >= '8') {
	ptr--;
	c = 0;
	break;
      }

      /* \0 always starts an octal number, but we may drop through to here with a
         larger first octal digit. */

    case '0':
      c -= '0';
      while (i++ < 2 && ptr[1] >= '0' && ptr[1] <= '7')
	c = c * 8 + *(++ptr) - '0';
      c &= 255;			/* Take least significant 8 bits */
      break;

      /* \x is complicated when UTF-8 is enabled. \x{ddd} is a character number
         which can be greater than 0xff, but only if the ddd are hex digits. */

    case 'x':

      /* Read just a single hex char */

      c = 0;
      while (i++ < 2 && (digitab[ptr[1]] & ctype_xdigit) != 0) {
	int cc;			/* Some compilers don't like ++ */
	cc = *(++ptr);		/* in initializers */
	if (cc >= 'a')
	  cc -= 32;		/* Convert to upper case */
	c = c * 16 + cc - ((cc < 'A') ? '0' : ('A' - 10));
      }
      break;

      /* Other special escapes not starting with a digit are straightforward */

    case 'c':
      c = *(++ptr);
      if (c == 0) {
	*errorptr = ERR2;
	return 0;
      }

      /* A letter is upper-cased; then the 0x40 bit is flipped. This coding
         is ASCII-specific, but then the whole concept of \cx is ASCII-specific.
         (However, an EBCDIC equivalent has now been added.) */

      if (c >= 'a' && c <= 'z')
	c -= 32;
      c ^= 0x40;
      break;

      /* PCRE_EXTRA enables extensions to Perl in the matter of escapes. Any
         other alphameric following \ is an error if PCRE_EXTRA was set; otherwise,
         for Perl compatibility, it is a literal. This code looks a bit odd, but
         there used to be some cases other than the default, and there may be again
         in future, so I haven't "optimized" it. */

    default:
      if ((options & PCRE_EXTRA) != 0)
	switch (c) {
	default:
	  *errorptr = ERR3;
	  break;
	}
      break;
    }
  }

  *ptrptr = ptr;
  return c;
}



/*************************************************
*            Check for counted repeat            *
*************************************************/

/* This function is called when a '{' is encountered in a place where it might
start a quantifier. It looks ahead to see if it really is a quantifier or not.
It is only a quantifier if it is one of the forms {ddd} {ddd,} or {ddd,ddd}
where the ddds are digits.

Arguments:
  p         pointer to the first char after '{'

Returns:    TRUE or FALSE
*/

static BOOL
is_counted_repeat(const uschar * p)
{
  if ((digitab[*p++] & ctype_digit) == 0)
    return FALSE;
  while ((digitab[*p] & ctype_digit) != 0)
    p++;
  if (*p == '}')
    return TRUE;

  if (*p++ != ',')
    return FALSE;
  if (*p == '}')
    return TRUE;

  if ((digitab[*p++] & ctype_digit) == 0)
    return FALSE;
  while ((digitab[*p] & ctype_digit) != 0)
    p++;

  return (*p == '}');
}



/*************************************************
*         Read repeat counts                     *
*************************************************/

/* Read an item of the form {n,m} and return the values. This is called only
after is_counted_repeat() has confirmed that a repeat-count quantifier exists,
so the syntax is guaranteed to be correct, but we need to check the values.

Arguments:
  p          pointer to first char after '{'
  minp       pointer to int for min
  maxp       pointer to int for max
             returned as -1 if no max
  errorptr   points to pointer to error message

Returns:     pointer to '}' on success;
             current ptr on error, with errorptr set
*/

static const uschar *
read_repeat_counts(const uschar * p, int *minp, int *maxp,
		   const char **errorptr)
{
  int min = 0;
  int max = -1;

  while ((digitab[*p] & ctype_digit) != 0)
    min = min * 10 + *p++ - '0';

  if (*p == '}')
    max = min;
  else {
    if (*(++p) != '}') {
      max = 0;
      while ((digitab[*p] & ctype_digit) != 0)
	max = max * 10 + *p++ - '0';
      if (max < min) {
	*errorptr = ERR4;
	return p;
      }
    }
  }

/* Do paranoid checks, then fill in the required variables, and pass back the
pointer to the terminating '}'. */

  if (min > 65535 || max > 65535)
    *errorptr = ERR5;
  else {
    *minp = min;
    *maxp = max;
  }
  return p;
}



/*************************************************
*      Find first significant op code            *
*************************************************/

/* This is called by several functions that scan a compiled expression looking
for a fixed first character, or an anchoring op code etc. It skips over things
that do not influence this. For some calls, a change of option is important.

Arguments:
  code       pointer to the start of the group
  options    pointer to external options
  optbit     the option bit whose changing is significant, or
               zero if none are

Returns:     pointer to the first significant opcode
*/

static const uschar *
first_significant_code(const uschar * code, int *options, int optbit)
{
  for (;;) {
    switch ((int) *code) {
    case OP_OPT:
      if (optbit > 0 && ((int) code[1] & optbit) != (*options & optbit))
	*options = (int) code[1];
      code += 2;
      break;

    case OP_ASSERT_NOT:
    case OP_ASSERTBACK:
    case OP_ASSERTBACK_NOT:
      do
	code += GET(code, 1);
      while (*code == OP_ALT);
      /* Fall through */

    case OP_CALLOUT:
    case OP_CREF:
    case OP_BRANUMBER:
    case OP_WORD_BOUNDARY:
    case OP_NOT_WORD_BOUNDARY:
      code += OP_lengths[*code];
      break;

    default:
      return code;
    }
  }
/* Control never reaches here */
}




/*************************************************
*        Find the fixed length of a pattern      *
*************************************************/

/* Scan a pattern and compute the fixed length of subject that will match it,
if the length is fixed. This is needed for dealing with backward assertions.
In UTF8 mode, the result is in characters rather than bytes.

Arguments:
  code     points to the start of the pattern (the bracket)
  options  the compiling options

Returns:   the fixed length, or -1 if there is no fixed length,
             or -2 if \C was encountered
*/

static int
find_fixedlength(uschar * code, int options)
{
  int length = -1;

  register int branchlength = 0;
  register uschar *cc = code + 1 + LINK_SIZE;

/* Scan along the opcodes for this branch. If we get to the end of the
branch, check the length against that of the other branches. */

  for (;;) {
    int d;
    register int op = *cc;
    if (op >= OP_BRA)
      op = OP_BRA;

    switch (op) {
    case OP_BRA:
    case OP_ONCE:
    case OP_COND:
      d = find_fixedlength(cc, options);
      if (d < 0)
	return d;
      branchlength += d;
      do
	cc += GET(cc, 1);
      while (*cc == OP_ALT);
      cc += 1 + LINK_SIZE;
      break;

      /* Reached end of a branch; if it's a ket it is the end of a nested
         call. If it's ALT it is an alternation in a nested call. If it is
         END it's the end of the outer call. All can be handled by the same code. */

    case OP_ALT:
    case OP_KET:
    case OP_KETRMAX:
    case OP_KETRMIN:
    case OP_END:
      if (length < 0)
	length = branchlength;
      else if (length != branchlength)
	return -1;
      if (*cc != OP_ALT)
	return length;
      cc += 1 + LINK_SIZE;
      branchlength = 0;
      break;

      /* Skip over assertive subpatterns */

    case OP_ASSERT:
    case OP_ASSERT_NOT:
    case OP_ASSERTBACK:
    case OP_ASSERTBACK_NOT:
      do
	cc += GET(cc, 1);
      while (*cc == OP_ALT);
      /* Fall through */

      /* Skip over things that don't match chars */

    case OP_REVERSE:
    case OP_BRANUMBER:
    case OP_CREF:
    case OP_OPT:
    case OP_CALLOUT:
    case OP_SOD:
    case OP_SOM:
    case OP_EOD:
    case OP_EODN:
    case OP_CIRC:
    case OP_DOLL:
    case OP_NOT_WORD_BOUNDARY:
    case OP_WORD_BOUNDARY:
      cc += OP_lengths[*cc];
      break;

      /* Handle char strings. In UTF-8 mode we must count characters, not bytes.
         This requires a scan of the string, unfortunately. We assume valid UTF-8
         strings, so all we do is reduce the length by one for every byte whose bits
         are 10xxxxxx. */

    case OP_CHARS:
      branchlength += *(++cc);
      cc += *cc + 1;
      break;

      /* Handle exact repetitions. The count is already in characters, but we
         need to skip over a multibyte character in UTF8 mode.  */

    case OP_EXACT:
      branchlength += GET2(cc, 1);
      cc += 4;
      break;

    case OP_TYPEEXACT:
      branchlength += GET2(cc, 1);
      cc += 4;
      break;

      /* Handle single-char matchers */

    case OP_NOT_DIGIT:
    case OP_DIGIT:
    case OP_NOT_WHITESPACE:
    case OP_WHITESPACE:
    case OP_NOT_WORDCHAR:
    case OP_WORDCHAR:
    case OP_ANY:
      branchlength++;
      cc++;
      break;

      /* The single-byte matcher isn't allowed */

    case OP_ANYBYTE:
      return -2;

      /* Check a class for variable quantification */


    case OP_CLASS:
    case OP_NCLASS:
      cc += 33;

      switch (*cc) {
      case OP_CRSTAR:
      case OP_CRMINSTAR:
      case OP_CRQUERY:
      case OP_CRMINQUERY:
	return -1;

      case OP_CRRANGE:
      case OP_CRMINRANGE:
	if (GET2(cc, 1) != GET2(cc, 3))
	  return -1;
	branchlength += GET2(cc, 1);
	cc += 5;
	break;

      default:
	branchlength++;
      }
      break;

      /* Anything else is variable length */

    default:
      return -1;
    }
  }
/* Control never gets here */
}




/*************************************************
*    Scan compiled regex for numbered bracket    *
*************************************************/

/* This little function scans through a compiled pattern until it finds a
capturing bracket with the given number.

Arguments:
  code        points to start of expression
  utf8        TRUE in UTF-8 mode
  number      the required bracket number

Returns:      pointer to the opcode for the bracket, or NULL if not found
*/

static const uschar *
find_bracket(const uschar * code, BOOL utf8, int number)
{
  utf8 = utf8;			/* Stop pedantic compilers complaining */

  for (;;) {
    register int c = *code;
    if (c == OP_END)
      return NULL;
    else if (c == OP_CHARS)
      code += code[1] + OP_lengths[c];
    else if (c > OP_BRA) {
      int n = c - OP_BRA;
      if (n > EXTRACT_BASIC_MAX)
	n = GET2(code, 2 + LINK_SIZE);
      if (n == number)
	return (uschar *) code;
      code += OP_lengths[OP_BRA];
    } else {
      code += OP_lengths[c];

    }
  }
}



/*************************************************
*   Scan compiled regex for recursion reference  *
*************************************************/

/* This little function scans through a compiled pattern until it finds an
instance of OP_RECURSE.

Arguments:
  code        points to start of expression
  utf8        TRUE in UTF-8 mode

Returns:      pointer to the opcode for OP_RECURSE, or NULL if not found
*/

static const uschar *
find_recurse(const uschar * code, BOOL utf8)
{
  utf8 = utf8;			/* Stop pedantic compilers complaining */

  for (;;) {
    register int c = *code;
    if (c == OP_END)
      return NULL;
    else if (c == OP_RECURSE)
      return code;
    else if (c == OP_CHARS)
      code += code[1] + OP_lengths[c];
    else if (c > OP_BRA) {
      code += OP_lengths[OP_BRA];
    } else {
      code += OP_lengths[c];

    }
  }
}



/*************************************************
*    Scan compiled branch for non-emptiness      *
*************************************************/

/* This function scans through a branch of a compiled pattern to see whether it
can match the empty string or not. It is called only from could_be_empty()
below. Note that first_significant_code() skips over assertions. If we hit an
unclosed bracket, we return "empty" - this means we've struck an inner bracket
whose current branch will already have been scanned.

Arguments:
  code        points to start of search
  endcode     points to where to stop
  utf8        TRUE if in UTF8 mode

Returns:      TRUE if what is matched could be empty
*/

static BOOL
could_be_empty_branch(const uschar * code, const uschar * endcode, BOOL utf8)
{
  register int c;
  for (code = first_significant_code(code + 1 + LINK_SIZE, NULL, 0);
       code < endcode;
       code = first_significant_code(code + OP_lengths[c], NULL, 0)) {
    const uschar *ccode;

    c = *code;

    if (c >= OP_BRA) {
      BOOL empty_branch;
      if (GET(code, 1) == 0)
	return TRUE;		/* Hit unclosed bracket */

      /* Scan a closed bracket */

      empty_branch = FALSE;
      do {
	if (!empty_branch && could_be_empty_branch(code, endcode, utf8))
	  empty_branch = TRUE;
	code += GET(code, 1);
      }
      while (*code == OP_ALT);
      if (!empty_branch)
	return FALSE;		/* All branches are non-empty */
      code += 1 + LINK_SIZE;
      c = *code;
    }

    else
      switch (c) {
	/* Check for quantifiers after a class */

      case OP_CLASS:
      case OP_NCLASS:
	ccode = code + 33;

	switch (*ccode) {
	case OP_CRSTAR:	/* These could be empty; continue */
	case OP_CRMINSTAR:
	case OP_CRQUERY:
	case OP_CRMINQUERY:
	  break;

	default:		/* Non-repeat => class must match */
	case OP_CRPLUS:	/* These repeats aren't empty */
	case OP_CRMINPLUS:
	  return FALSE;

	case OP_CRRANGE:
	case OP_CRMINRANGE:
	  if (GET2(ccode, 1) > 0)
	    return FALSE;	/* Minimum > 0 */
	  break;
	}
	break;

	/* Opcodes that must match a character */

      case OP_NOT_DIGIT:
      case OP_DIGIT:
      case OP_NOT_WHITESPACE:
      case OP_WHITESPACE:
      case OP_NOT_WORDCHAR:
      case OP_WORDCHAR:
      case OP_ANY:
      case OP_ANYBYTE:
      case OP_CHARS:
      case OP_NOT:
      case OP_PLUS:
      case OP_MINPLUS:
      case OP_EXACT:
      case OP_NOTPLUS:
      case OP_NOTMINPLUS:
      case OP_NOTEXACT:
      case OP_TYPEPLUS:
      case OP_TYPEMINPLUS:
      case OP_TYPEEXACT:
	return FALSE;

	/* End of branch */

      case OP_KET:
      case OP_KETRMAX:
      case OP_KETRMIN:
      case OP_ALT:
	return TRUE;

	/* In UTF-8 mode, STAR, MINSTAR, QUERY, MINQUERY, UPTO, and MINUPTO  may be
	   followed by a multibyte character */

      }
  }

  return TRUE;
}



/*************************************************
*    Scan compiled regex for non-emptiness       *
*************************************************/

/* This function is called to check for left recursive calls. We want to check
the current branch of the current pattern to see if it could match the empty
string. If it could, we must look outwards for branches at other levels,
stopping when we pass beyond the bracket which is the subject of the recursion.

Arguments:
  code        points to start of the recursion
  endcode     points to where to stop (current RECURSE item)
  bcptr       points to the chain of current (unclosed) branch starts
  utf8        TRUE if in UTF-8 mode

Returns:      TRUE if what is matched could be empty
*/

static BOOL
could_be_empty(const uschar * code, const uschar * endcode,
	       branch_chain * bcptr, BOOL utf8)
{
  while (bcptr != NULL && bcptr->current >= code) {
    if (!could_be_empty_branch(bcptr->current, endcode, utf8))
      return FALSE;
    bcptr = bcptr->outer;
  }
  return TRUE;
}



/*************************************************
*           Check for POSIX class syntax         *
*************************************************/

/* This function is called when the sequence "[:" or "[." or "[=" is
encountered in a character class. It checks whether this is followed by an
optional ^ and then a sequence of letters, terminated by a matching ":]" or
".]" or "=]".

Argument:
  ptr      pointer to the initial [
  endptr   where to return the end pointer
  cd       pointer to compile data

Returns:   TRUE or FALSE
*/

static BOOL
check_posix_syntax(const uschar * ptr, const uschar ** endptr,
		   compile_data * cd)
{
  int terminator;		/* Don't combine these lines; the Solaris cc */
  terminator = *(++ptr);	/* compiler warns about "non-constant" initializer. */
  if (*(++ptr) == '^')
    ptr++;
  while ((cd->ctypes[*ptr] & ctype_letter) != 0)
    ptr++;
  if (*ptr == terminator && ptr[1] == ']') {
    *endptr = ptr;
    return TRUE;
  }
  return FALSE;
}




/*************************************************
*          Check POSIX class name                *
*************************************************/

/* This function is called to check the name given in a POSIX-style class entry
such as [:alnum:].

Arguments:
  ptr        points to the first letter
  len        the length of the name

Returns:     a value representing the name, or -1 if unknown
*/

static int
check_posix_name(const uschar * ptr, int len)
{
  register int yield = 0;
  while (posix_name_lengths[yield] != 0) {
    if (len == posix_name_lengths[yield] &&
	strncmp((const char *) ptr, posix_names[yield], len) == 0)
      return yield;
    yield++;
  }
  return -1;
}


/*************************************************
*    Adjust OP_RECURSE items in repeated group   *
*************************************************/

/* OP_RECURSE items contain an offset from the start of the regex to the group
that is referenced. This means that groups can be replicated for fixed
repetition simply by copying (because the recursion is allowed to refer to
earlier groups that are outside the current group). However, when a group is
optional (i.e. the minimum quantifier is zero), OP_BRAZERO is inserted before
it, after it has been compiled. This means that any OP_RECURSE items within it
that refer to the group itself or any contained groups have to have their
offsets adjusted. That is the job of this function. Before it is called, the
partially compiled regex must be temporarily terminated with OP_END.

Arguments:
  group      points to the start of the group
  adjust     the amount by which the group is to be moved
  utf8       TRUE in UTF-8 mode
  cd         contains pointers to tables etc.

Returns:     nothing
*/

static void
adjust_recurse(uschar * group, int adjust, BOOL utf8, compile_data * cd)
{
  uschar *ptr = group;
  while ((ptr = (uschar *) find_recurse(ptr, utf8)) != NULL) {
    int offset = GET(ptr, 1);
    if (cd->start_code + offset >= group)
      PUT(ptr, 1, offset + adjust);
    ptr += 1 + LINK_SIZE;
  }
}



/*************************************************
*           Compile one branch                   *
*************************************************/

/* Scan the pattern, compiling it into the code vector. If the options are
changed during the branch, the pointer is used to change the external options
bits.

Arguments:
  optionsptr     pointer to the option bits
  brackets       points to number of extracting brackets used
  code           points to the pointer to the current code point
  ptrptr         points to the current pattern pointer
  errorptr       points to pointer to error message
  firstbyteptr   set to initial literal character, or < 0 (REQ_UNSET, REQ_NONE)
  reqbyteptr     set to the last literal character required, else < 0
  bcptr          points to current branch chain
  cd             contains pointers to tables etc.

Returns:         TRUE on success
                 FALSE, with *errorptr set on error
*/

static BOOL
compile_branch(int *optionsptr, int *brackets, uschar ** codeptr,
	       const uschar ** ptrptr, const char **errorptr, int *firstbyteptr,
	       int *reqbyteptr, branch_chain * bcptr, compile_data * cd)
{
  int repeat_type, op_type;
  int repeat_min = 0, repeat_max = 0;	/* To please picky compilers */
  int bravalue = 0;
  int length;
  int greedy_default, greedy_non_default;
  int firstbyte, reqbyte;
  int zeroreqbyte, zerofirstbyte;
  int req_caseopt, reqvary, tempreqvary;
  int condcount = 0;
  int options = *optionsptr;
  register int c;
  register uschar *code = *codeptr;
  uschar *tempcode;
  BOOL inescq = FALSE;
  BOOL groupsetfirstbyte = FALSE;
  const uschar *ptr = *ptrptr;
  const uschar *tempptr;
  uschar *previous = NULL;
  uschar class[32];

  BOOL utf8 = FALSE;

/* Set up the default and non-default settings for greediness */

  greedy_default = ((options & PCRE_UNGREEDY) != 0);
  greedy_non_default = greedy_default ^ 1;

/* Initialize no first char, no required char. REQ_UNSET means "no char
matching encountered yet". It gets changed to REQ_NONE if we hit something that
matches a non-fixed char first char; reqbyte just remains unset if we never
find one.

When we hit a repeat whose minimum is zero, we may have to adjust these values
to take the zero repeat into account. This is implemented by setting them to
zerofirstbyte and zeroreqbyte when such a repeat is encountered. The individual
item types that can be repeated set these backoff variables appropriately. */

  firstbyte = reqbyte = zerofirstbyte = zeroreqbyte = REQ_UNSET;

/* The variable req_caseopt contains either the REQ_CASELESS value or zero,
according to the current setting of the caseless flag. REQ_CASELESS is a bit
value > 255. It is added into the firstbyte or reqbyte variables to record the
case status of the value. */

  req_caseopt = ((options & PCRE_CASELESS) != 0) ? REQ_CASELESS : 0;

/* Switch on next character until the end of the branch */

  for (;; ptr++) {
    BOOL negate_class;
    BOOL possessive_quantifier;
    int class_charcount;
    int class_lastchar;
    int newoptions;
    int recno;
    int skipbytes;
    int subreqbyte;
    int subfirstbyte;

    c = *ptr;
    if (inescq && c != 0)
      goto NORMAL_CHAR;

    if ((options & PCRE_EXTENDED) != 0) {
      if ((cd->ctypes[c] & ctype_space) != 0)
	continue;
      if (c == '#') {
	/* The space before the ; is to avoid a warning on a silly compiler
	   on the Macintosh. */
	while ((c = *(++ptr)) != 0 && c != NEWLINE) ;
	if (c != 0)
	  continue;		/* Else fall through to handle end of string */
      }
    }

    switch (c) {
      /* The branch terminates at end of string, |, or ). */

    case 0:
    case '|':
    case ')':
      *firstbyteptr = firstbyte;
      *reqbyteptr = reqbyte;
      *codeptr = code;
      *ptrptr = ptr;
      return TRUE;

      /* Handle single-character metacharacters. In multiline mode, ^ disables
         the setting of any following char as a first character. */

    case '^':
      if ((options & PCRE_MULTILINE) != 0) {
	if (firstbyte == REQ_UNSET)
	  firstbyte = REQ_NONE;
      }
      previous = NULL;
      *code++ = OP_CIRC;
      break;

    case '$':
      previous = NULL;
      *code++ = OP_DOLL;
      break;

      /* There can never be a first char if '.' is first, whatever happens about
         repeats. The value of reqbyte doesn't change either. */

    case '.':
      if (firstbyte == REQ_UNSET)
	firstbyte = REQ_NONE;
      zerofirstbyte = firstbyte;
      zeroreqbyte = reqbyte;
      previous = code;
      *code++ = OP_ANY;
      break;

      /* Character classes. If the included characters are all < 255 in value, we
         build a 32-byte bitmap of the permitted characters, except in the special
         case where there is only one such character. For negated classes, we build
         the map as usual, then invert it at the end. However, we use a different
         opcode so that data characters > 255 can be handled correctly.

         If the class contains characters outside the 0-255 range, a different
         opcode is compiled. It may optionally have a bit map for characters < 256,
         but those above are are explicitly listed afterwards. A flag byte tells
         whether the bitmap is present, and whether this is a negated class or not.
       */

    case '[':
      previous = code;

      /* PCRE supports POSIX class stuff inside a class. Perl gives an error if
         they are encountered at the top level, so we'll do that too. */

      if ((ptr[1] == ':' || ptr[1] == '.' || ptr[1] == '=') &&
	  check_posix_syntax(ptr, &tempptr, cd)) {
	*errorptr = (ptr[1] == ':') ? ERR13 : ERR31;
	goto FAILED;
      }

      /* If the first character is '^', set the negation flag and skip it. */

      if ((c = *(++ptr)) == '^') {
	negate_class = TRUE;
	c = *(++ptr);
      } else {
	negate_class = FALSE;
      }

      /* Keep a count of chars with values < 256 so that we can optimize the case
         of just a single character (as long as it's < 256). For higher valued UTF-8
         characters, we don't yet do any optimization. */

      class_charcount = 0;
      class_lastchar = -1;


      /* Initialize the 32-char bit map to all zeros. We have to build the
         map in a temporary bit of store, in case the class contains only 1
         character (< 256), because in that case the compiled code doesn't use the
         bit map. */

      memset(class, 0, 32 * sizeof(uschar));

      /* Process characters until ] is reached. By writing this as a "do" it
         means that an initial ] is taken as a data character. The first pass
         through the regex checked the overall syntax, so we don't need to be very
         strict here. At the start of the loop, c contains the first byte of the
         character. */

      do {

	/* Inside \Q...\E everything is literal except \E */

	if (inescq) {
	  if (c == '\\' && ptr[1] == 'E') {
	    inescq = FALSE;
	    ptr++;
	    continue;
	  } else
	    goto LONE_SINGLE_CHARACTER;
	}

	/* Handle POSIX class names. Perl allows a negation extension of the
	   form [:^name:]. A square bracket that doesn't match the syntax is
	   treated as a literal. We also recognize the POSIX constructions
	   [.ch.] and [=ch=] ("collating elements") and fault them, as Perl
	   5.6 and 5.8 do. */

	if (c == '[' &&
	    (ptr[1] == ':' || ptr[1] == '.' || ptr[1] == '=') &&
	    check_posix_syntax(ptr, &tempptr, cd)) {
	  BOOL local_negate = FALSE;
	  int posix_class, i;
	  register const uschar *cbits = cd->cbits;

	  if (ptr[1] != ':') {
	    *errorptr = ERR31;
	    goto FAILED;
	  }

	  ptr += 2;
	  if (*ptr == '^') {
	    local_negate = TRUE;
	    ptr++;
	  }

	  posix_class = check_posix_name(ptr, tempptr - ptr);
	  if (posix_class < 0) {
	    *errorptr = ERR30;
	    goto FAILED;
	  }

	  /* If matching is caseless, upper and lower are converted to
	     alpha. This relies on the fact that the class table starts with
	     alpha, lower, upper as the first 3 entries. */

	  if ((options & PCRE_CASELESS) != 0 && posix_class <= 2)
	    posix_class = 0;

	  /* Or into the map we are building up to 3 of the static class
	     tables, or their negations. The [:blank:] class sets up the same
	     chars as the [:space:] class (all white space). We remove the vertical
	     white space chars afterwards. */

	  posix_class *= 3;
	  for (i = 0; i < 3; i++) {
	    BOOL blankclass = strncmp((char *) ptr, "blank", 5) == 0;
	    int taboffset = posix_class_maps[posix_class + i];
	    if (taboffset < 0)
	      break;
	    if (local_negate) {
	      for (c = 0; c < 32; c++)
		class[c] |= ~cbits[c + taboffset];
	      if (blankclass)
		class[1] |= 0x3c;
	    } else {
	      for (c = 0; c < 32; c++)
		class[c] |= cbits[c + taboffset];
	      if (blankclass)
		class[1] &= ~0x3c;
	    }
	  }

	  ptr = tempptr + 1;
	  class_charcount = 10;	/* Set > 1; assumes more than 1 per class */
	  continue;		/* End of POSIX syntax handling */
	}

	/* Backslash may introduce a single character, or it may introduce one
	   of the specials, which just set a flag. Escaped items are checked for
	   validity in the pre-compiling pass. The sequence \b is a special case.
	   Inside a class (and only there) it is treated as backspace. Elsewhere
	   it marks a word boundary. Other escapes have preset maps ready to
	   or into the one we are building. We assume they have more than one
	   character in them, so set class_charcount bigger than one. */

	if (c == '\\') {
	  c = check_escape(&ptr, errorptr, *brackets, options, TRUE);
	  if (-c == ESC_b)
	    c = '\b';		/* \b is backslash in a class */

	  if (-c == ESC_Q) {	/* Handle start of quoted string */
	    if (ptr[1] == '\\' && ptr[2] == 'E') {
	      ptr += 2;		/* avoid empty string */
	    } else
	      inescq = TRUE;
	    continue;
	  }

	  else if (c < 0) {
	    register const uschar *cbits = cd->cbits;
	    class_charcount = 10;	/* Greater than 1 is what matters */
	    switch (-c) {
	    case ESC_d:
	      for (c = 0; c < 32; c++)
		class[c] |= cbits[c + cbit_digit];
	      continue;

	    case ESC_D:
	      for (c = 0; c < 32; c++)
		class[c] |= ~cbits[c + cbit_digit];
	      continue;

	    case ESC_w:
	      for (c = 0; c < 32; c++)
		class[c] |= cbits[c + cbit_word];
	      continue;

	    case ESC_W:
	      for (c = 0; c < 32; c++)
		class[c] |= ~cbits[c + cbit_word];
	      continue;

	    case ESC_s:
	      for (c = 0; c < 32; c++)
		class[c] |= cbits[c + cbit_space];
	      class[1] &= ~0x08;	/* Perl 5.004 onwards omits VT from \s */
	      continue;

	    case ESC_S:
	      for (c = 0; c < 32; c++)
		class[c] |= ~cbits[c + cbit_space];
	      class[1] |= 0x08;	/* Perl 5.004 onwards omits VT from \s */
	      continue;

	      /* Unrecognized escapes are faulted if PCRE is running in its
	         strict mode. By default, for compatibility with Perl, they are
	         treated as literals. */

	    default:
	      if ((options & PCRE_EXTRA) != 0) {
		*errorptr = ERR7;
		goto FAILED;
	      }
	      c = *ptr;		/* The final character */
	    }
	  }

	  /* Fall through if we have a single character (c >= 0). This may be
	     > 256 in UTF-8 mode. */

	}


	/* End of backslash handling */
	/* A single character may be followed by '-' to form a range. However,
	   Perl does not permit ']' to be the end of the range. A '-' character
	   here is treated as a literal. */
	if (ptr[1] == '-' && ptr[2] != ']') {
	  int d;
	  ptr += 2;

	  d = *ptr;

	  /* The second part of a range can be a single-character escape, but
	     not any of the other escapes. Perl 5.6 treats a hyphen as a literal
	     in such circumstances. */

	  if (d == '\\') {
	    const uschar *oldptr = ptr;
	    d = check_escape(&ptr, errorptr, *brackets, options, TRUE);

	    /* \b is backslash; any other special means the '-' was literal */

	    if (d < 0) {
	      if (d == -ESC_b)
		d = '\b';
	      else {
		ptr = oldptr - 2;
		goto LONE_SINGLE_CHARACTER;	/* A few lines below */
	      }
	    }
	  }

	  /* Check that the two values are in the correct order */

	  if (d < c) {
	    *errorptr = ERR8;
	    goto FAILED;
	  }

	  /* If d is greater than 255, we can't just use the bit map, so set up
	     for the UTF-8 supporting class type. If we are not caseless, we can
	     just set up a single range. If we are caseless, the characters < 256
	     are handled with a bitmap, in order to get the case-insensitive
	     handling. */

	  /* We use the bit map if the range is entirely < 255, or if part of it
	     is < 255 and matching is caseless. */

	  for (; c <= d; c++) {
	    class[c / 8] |= (1 << (c & 7));
	    if ((options & PCRE_CASELESS) != 0) {
	      int uc = cd->fcc[c];	/* flip case */
	      class[uc / 8] |= (1 << (uc & 7));
	    }
	    class_charcount++;	/* in case a one-char range */
	    class_lastchar = c;
	  }

	  continue;		/* Go get the next char in the class */
	}

	/* Handle a lone single character - we can get here for a normal
	   non-escape char, or after \ that introduces a single character. */

      LONE_SINGLE_CHARACTER:

	/* Handle a multibyte character */

	/* Handle a single-byte character */
	{
	  class[c / 8] |= (1 << (c & 7));
	  if ((options & PCRE_CASELESS) != 0) {
	    c = cd->fcc[c];	/* flip case */
	    class[c / 8] |= (1 << (c & 7));
	  }
	  class_charcount++;
	  class_lastchar = c;
	}
      }

      /* Loop until ']' reached; the check for end of string happens inside the
         loop. This "while" is the end of the "do" above. */

      while ((c = *(++ptr)) != ']' || inescq);

      /* If class_charcount is 1, we saw precisely one character with a value <
         256. In UTF-8 mode, we can optimize if there were no characters >= 256 and
         the one character is < 128. In non-UTF-8 mode we can always optimize.

         The optimization throws away the bit map. We turn the item into a
         1-character OP_CHARS if it's positive, or OP_NOT if it's negative. Note
         that OP_NOT does not support multibyte characters. In the positive case, it
         can cause firstbyte to be set. Otherwise, there can be no first char if
         this item is first, whatever repeat count may follow. In the case of
         reqbyte, save the previous value for reinstating. */

      if (class_charcount == 1) {
	zeroreqbyte = reqbyte;
	if (negate_class) {
	  if (firstbyte == REQ_UNSET)
	    firstbyte = REQ_NONE;
	  zerofirstbyte = firstbyte;
	  *code++ = OP_NOT;
	} else {
	  if (firstbyte == REQ_UNSET) {
	    zerofirstbyte = REQ_NONE;
	    firstbyte = class_lastchar | req_caseopt;
	  } else {
	    zerofirstbyte = firstbyte;
	    reqbyte = class_lastchar | req_caseopt | cd->req_varyopt;
	  }
	  *code++ = OP_CHARS;
	  *code++ = 1;
	}
	*code++ = class_lastchar;
	break;			/* End of class handling */
      }


      /* End of 1-byte optimization */
      /* Otherwise, if this is the first thing in the branch, there can be no
         first char setting, whatever the repeat count. Any reqbyte setting must
         remain unchanged after any kind of repeat. */
      if (firstbyte == REQ_UNSET)
	firstbyte = REQ_NONE;
      zerofirstbyte = firstbyte;
      zeroreqbyte = reqbyte;

      /* If there are characters with values > 255, we have to compile an
         extended class, with its own opcode. If there are no characters < 256,
         we can omit the bitmap. */


      /* If there are no characters > 255, negate the 32-byte map if necessary,
         and copy it into the code vector. If this is the first thing in the branch,
         there can be no first char setting, whatever the repeat count. Any reqbyte
         setting must remain unchanged after any kind of repeat. */

      if (negate_class) {
	*code++ = OP_NCLASS;
	for (c = 0; c < 32; c++)
	  code[c] = ~class[c];
      } else {
	*code++ = OP_CLASS;
	memcpy(code, class, 32);
      }
      code += 32;
      break;

      /* Various kinds of repeat */

    case '{':
      if (!is_counted_repeat(ptr + 1))
	goto NORMAL_CHAR;
      ptr = read_repeat_counts(ptr + 1, &repeat_min, &repeat_max, errorptr);
      if (*errorptr != NULL)
	goto FAILED;
      goto REPEAT;

    case '*':
      repeat_min = 0;
      repeat_max = -1;
      goto REPEAT;

    case '+':
      repeat_min = 1;
      repeat_max = -1;
      goto REPEAT;

    case '?':
      repeat_min = 0;
      repeat_max = 1;

    REPEAT:
      if (previous == NULL) {
	*errorptr = ERR9;
	goto FAILED;
      }

      if (repeat_min == 0) {
	firstbyte = zerofirstbyte;	/* Adjust for zero repeat */
	reqbyte = zeroreqbyte;	/* Ditto */
      }

      /* Remember whether this is a variable length repeat */

      reqvary = (repeat_min == repeat_max) ? 0 : REQ_VARY;

      op_type = 0;		/* Default single-char op codes */
      possessive_quantifier = FALSE;	/* Default not possessive quantifier */

      /* Save start of previous item, in case we have to move it up to make space
         for an inserted OP_ONCE for the additional '+' extension. */

      tempcode = previous;

      /* If the next character is '+', we have a possessive quantifier. This
         implies greediness, whatever the setting of the PCRE_UNGREEDY option.
         If the next character is '?' this is a minimizing repeat, by default,
         but if PCRE_UNGREEDY is set, it works the other way round. We change the
         repeat type to the non-default. */

      if (ptr[1] == '+') {
	repeat_type = 0;	/* Force greedy */
	possessive_quantifier = TRUE;
	ptr++;
      } else if (ptr[1] == '?') {
	repeat_type = greedy_non_default;
	ptr++;
      } else
	repeat_type = greedy_default;

      /* If previous was a recursion, we need to wrap it inside brackets so that
         it can be replicated if necessary. */

      if (*previous == OP_RECURSE) {
	memmove(previous + 1 + LINK_SIZE, previous, 1 + LINK_SIZE);
	code += 1 + LINK_SIZE;
	*previous = OP_BRA;
	PUT(previous, 1, code - previous);
	*code = OP_KET;
	PUT(code, 1, code - previous);
	code += 1 + LINK_SIZE;
      }

      /* If previous was a string of characters, chop off the last one and use it
         as the subject of the repeat. If there was only one character, we can
         abolish the previous item altogether. If a one-char item has a minumum of
         more than one, ensure that it is set in reqbyte - it might not be if a
         sequence such as x{3} is the first thing in a branch because the x will
         have gone into firstbyte instead.  */

      if (*previous == OP_CHARS) {
	/* Deal with UTF-8 characters that take up more than one byte. It's
	   easier to write this out separately than try to macrify it. Use c to
	   hold the length of the character in bytes, plus 0x80 to flag that it's a
	   length rather than a small character. */


	/* Handle the case of a single byte - either with no UTF8 support, or
	   with UTF-8 disabled, or for a UTF-8 character < 128. */

	{
	  c = *(--code);
	  if (code == previous + 2) {	/* There was only one character */
	    code = previous;	/* Abolish the previous item */
	    if (repeat_min > 1)
	      reqbyte = c | req_caseopt | cd->req_varyopt;
	  } else {
	    previous[1]--;	/* adjust length */
	    tempcode = code;	/* Adjust position to be moved for '+' */
	  }
	}

	goto OUTPUT_SINGLE_REPEAT;	/* Code shared with single character types */
      }

      /* If previous was a single negated character ([^a] or similar), we use
         one of the special opcodes, replacing it. The code is shared with single-
         character repeats by setting opt_type to add a suitable offset into
         repeat_type. OP_NOT is currently used only for single-byte chars. */

      else if (*previous == OP_NOT) {
	op_type = OP_NOTSTAR - OP_STAR;	/* Use "not" opcodes */
	c = previous[1];
	code = previous;
	goto OUTPUT_SINGLE_REPEAT;
      }

      /* If previous was a character type match (\d or similar), abolish it and
         create a suitable repeat item. The code is shared with single-character
         repeats by setting op_type to add a suitable offset into repeat_type. */

      else if (*previous < OP_EODN) {
	op_type = OP_TYPESTAR - OP_STAR;	/* Use type opcodes */
	c = *previous;
	code = previous;

      OUTPUT_SINGLE_REPEAT:

	/* If the maximum is zero then the minimum must also be zero; Perl allows
	   this case, so we do too - by simply omitting the item altogether. */

	if (repeat_max == 0)
	  goto END_REPEAT;

	/* Combine the op_type with the repeat_type */

	repeat_type += op_type;

	/* A minimum of zero is handled either as the special case * or ?, or as
	   an UPTO, with the maximum given. */

	if (repeat_min == 0) {
	  if (repeat_max == -1)
	    *code++ = OP_STAR + repeat_type;
	  else if (repeat_max == 1)
	    *code++ = OP_QUERY + repeat_type;
	  else {
	    *code++ = OP_UPTO + repeat_type;
	    PUT2INC(code, 0, repeat_max);
	  }
	}

	/* The case {1,} is handled as the special case + */

	else if (repeat_min == 1 && repeat_max == -1)
	  *code++ = OP_PLUS + repeat_type;

	/* The case {n,n} is just an EXACT, while the general case {n,m} is
	   handled as an EXACT followed by an UPTO. An EXACT of 1 is optimized. */

	else {
	  if (repeat_min != 1) {
	    *code++ = OP_EXACT + op_type;	/* NB EXACT doesn't have repeat_type */
	    PUT2INC(code, 0, repeat_min);
	  }

	  /* If the mininum is 1 and the previous item was a character string,
	     we either have to put back the item that got cancelled if the string
	     length was 1, or add the character back onto the end of a longer
	     string. For a character type nothing need be done; it will just get
	     put back naturally. Note that the final character is always going to
	     get added below, so we leave code ready for its insertion. */

	  else if (*previous == OP_CHARS) {
	    if (code == previous)
	      code += 2;
	    else
	      /* In UTF-8 mode, a multibyte char has its length in c, with the 0x80
	         bit set as a flag. The length will always be between 2 and 6. */

	      previous[1]++;
	  }

	  /*  For a single negated character we also have to put back the
	     item that got cancelled. At present this applies only to single byte
	     characters in any mode. */

	  else if (*previous == OP_NOT)
	    code++;

	  /* If the maximum is unlimited, insert an OP_STAR. Before doing so,
	     we have to insert the character for the previous code. In UTF-8 mode,
	     long characters have their length in c, with the 0x80 bit as a flag. */

	  if (repeat_max < 0) {
	    *code++ = c;
	    *code++ = OP_STAR + repeat_type;
	  }

	  /* Else insert an UPTO if the max is greater than the min, again
	     preceded by the character, for the previously inserted code. */

	  else if (repeat_max != repeat_min) {
	    *code++ = c;
	    repeat_max -= repeat_min;
	    *code++ = OP_UPTO + repeat_type;
	    PUT2INC(code, 0, repeat_max);
	  }
	}

	/* The character or character type itself comes last in all cases. */


	*code++ = c;
      }

      /* If previous was a character class or a back reference, we put the repeat
         stuff after it, but just skip the item if the repeat was {0,0}. */

      else if (*previous == OP_CLASS ||
	       *previous == OP_NCLASS || *previous == OP_REF) {
	if (repeat_max == 0) {
	  code = previous;
	  goto END_REPEAT;
	}
	if (repeat_min == 0 && repeat_max == -1)
	  *code++ = OP_CRSTAR + repeat_type;
	else if (repeat_min == 1 && repeat_max == -1)
	  *code++ = OP_CRPLUS + repeat_type;
	else if (repeat_min == 0 && repeat_max == 1)
	  *code++ = OP_CRQUERY + repeat_type;
	else {
	  *code++ = OP_CRRANGE + repeat_type;
	  PUT2INC(code, 0, repeat_min);
	  if (repeat_max == -1)
	    repeat_max = 0;	/* 2-byte encoding for max */
	  PUT2INC(code, 0, repeat_max);
	}
      }

      /* If previous was a bracket group, we may have to replicate it in certain
         cases. */

      else if (*previous >= OP_BRA || *previous == OP_ONCE ||
	       *previous == OP_COND) {
	register int i;
	int ketoffset = 0;
	int len = code - previous;
	uschar *bralink = NULL;

	/* If the maximum repeat count is unlimited, find the end of the bracket
	   by scanning through from the start, and compute the offset back to it
	   from the current code pointer. There may be an OP_OPT setting following
	   the final KET, so we can't find the end just by going back from the code
	   pointer. */

	if (repeat_max == -1) {
	  register uschar *ket = previous;
	  do
	    ket += GET(ket, 1);
	  while (*ket != OP_KET);
	  ketoffset = code - ket;
	}

	/* The case of a zero minimum is special because of the need to stick
	   OP_BRAZERO in front of it, and because the group appears once in the
	   data, whereas in other cases it appears the minimum number of times. For
	   this reason, it is simplest to treat this case separately, as otherwise
	   the code gets far too messy. There are several special subcases when the
	   minimum is zero. */

	if (repeat_min == 0) {
	  /* If the maximum is also zero, we just omit the group from the output
	     altogether. */

	  if (repeat_max == 0) {
	    code = previous;
	    goto END_REPEAT;
	  }

	  /* If the maximum is 1 or unlimited, we just have to stick in the
	     BRAZERO and do no more at this point. However, we do need to adjust
	     any OP_RECURSE calls inside the group that refer to the group itself or
	     any internal group, because the offset is from the start of the whole
	     regex. Temporarily terminate the pattern while doing this. */

	  if (repeat_max <= 1) {
	    *code = OP_END;
	    adjust_recurse(previous, 1, utf8, cd);
	    memmove(previous + 1, previous, len);
	    code++;
	    *previous++ = OP_BRAZERO + repeat_type;
	  }

	  /* If the maximum is greater than 1 and limited, we have to replicate
	     in a nested fashion, sticking OP_BRAZERO before each set of brackets.
	     The first one has to be handled carefully because it's the original
	     copy, which has to be moved up. The remainder can be handled by code
	     that is common with the non-zero minimum case below. We have to
	     adjust the value or repeat_max, since one less copy is required. Once
	     again, we may have to adjust any OP_RECURSE calls inside the group. */

	  else {
	    int offset;
	    *code = OP_END;
	    adjust_recurse(previous, 2 + LINK_SIZE, utf8, cd);
	    memmove(previous + 2 + LINK_SIZE, previous, len);
	    code += 2 + LINK_SIZE;
	    *previous++ = OP_BRAZERO + repeat_type;
	    *previous++ = OP_BRA;

	    /* We chain together the bracket offset fields that have to be
	       filled in later when the ends of the brackets are reached. */

	    offset = (bralink == NULL) ? 0 : previous - bralink;
	    bralink = previous;
	    PUTINC(previous, 0, offset);
	  }

	  repeat_max--;
	}

	/* If the minimum is greater than zero, replicate the group as many
	   times as necessary, and adjust the maximum to the number of subsequent
	   copies that we need. If we set a first char from the group, and didn't
	   set a required char, copy the latter from the former. */

	else {
	  if (repeat_min > 1) {
	    if (groupsetfirstbyte && reqbyte < 0)
	      reqbyte = firstbyte;
	    for (i = 1; i < repeat_min; i++) {
	      memcpy(code, previous, len);
	      code += len;
	    }
	  }
	  if (repeat_max > 0)
	    repeat_max -= repeat_min;
	}

	/* This code is common to both the zero and non-zero minimum cases. If
	   the maximum is limited, it replicates the group in a nested fashion,
	   remembering the bracket starts on a stack. In the case of a zero minimum,
	   the first one was set up above. In all cases the repeat_max now specifies
	   the number of additional copies needed. */

	if (repeat_max >= 0) {
	  for (i = repeat_max - 1; i >= 0; i--) {
	    *code++ = OP_BRAZERO + repeat_type;

	    /* All but the final copy start a new nesting, maintaining the
	       chain of brackets outstanding. */

	    if (i != 0) {
	      int offset;
	      *code++ = OP_BRA;
	      offset = (bralink == NULL) ? 0 : code - bralink;
	      bralink = code;
	      PUTINC(code, 0, offset);
	    }

	    memcpy(code, previous, len);
	    code += len;
	  }

	  /* Now chain through the pending brackets, and fill in their length
	     fields (which are holding the chain links pro tem). */

	  while (bralink != NULL) {
	    int oldlinkoffset;
	    int offset = code - bralink + 1;
	    uschar *bra = code - offset;
	    oldlinkoffset = GET(bra, 1);
	    bralink = (oldlinkoffset == 0) ? NULL : bralink - oldlinkoffset;
	    *code++ = OP_KET;
	    PUTINC(code, 0, offset);
	    PUT(bra, 1, offset);
	  }
	}

	/* If the maximum is unlimited, set a repeater in the final copy. We
	   can't just offset backwards from the current code point, because we
	   don't know if there's been an options resetting after the ket. The
	   correct offset was computed above. */

	else
	  code[-ketoffset] = OP_KETRMAX + repeat_type;
      }

      /* Else there's some kind of shambles */

      else {
	*errorptr = ERR11;
	goto FAILED;
      }

      /* If the character following a repeat is '+', we wrap the entire repeated
         item inside OP_ONCE brackets. This is just syntactic sugar, taken from
         Sun's Java package. The repeated item starts at tempcode, not at previous,
         which might be the first part of a string whose (former) last char we
         repeated. However, we don't support '+' after a greediness '?'. */

      if (possessive_quantifier) {
	int len = code - tempcode;
	memmove(tempcode + 1 + LINK_SIZE, tempcode, len);
	code += 1 + LINK_SIZE;
	len += 1 + LINK_SIZE;
	tempcode[0] = OP_ONCE;
	*code++ = OP_KET;
	PUTINC(code, 0, len);
	PUT(tempcode, 1, len);
      }

      /* In all case we no longer have a previous item. We also set the
         "follows varying string" flag for subsequently encountered reqbytes if
         it isn't already set and we have just passed a varying length item. */

    END_REPEAT:
      previous = NULL;
      cd->req_varyopt |= reqvary;
      break;


      /* Start of nested bracket sub-expression, or comment or lookahead or
         lookbehind or option setting or condition. First deal with special things
         that can come after a bracket; all are introduced by ?, and the appearance
         of any of them means that this is not a referencing group. They were
         checked for validity in the first pass over the string, so we don't have to
         check for syntax errors here.  */

    case '(':
      newoptions = options;
      skipbytes = 0;

      if (*(++ptr) == '?') {
	int set, unset;
	int *optset;

	switch (*(++ptr)) {
	case '#':		/* Comment; skip to ket */
	  ptr++;
	  while (*ptr != ')')
	    ptr++;
	  continue;

	case ':':		/* Non-extracting bracket */
	  bravalue = OP_BRA;
	  ptr++;
	  break;

	case '(':
	  bravalue = OP_COND;	/* Conditional group */

	  /* Condition to test for recursion */

	  if (ptr[1] == 'R') {
	    code[1 + LINK_SIZE] = OP_CREF;
	    PUT2(code, 2 + LINK_SIZE, CREF_RECURSE);
	    skipbytes = 3;
	    ptr += 3;
	  }

	  /* Condition to test for a numbered subpattern match. We know that
	     if a digit follows ( then there will just be digits until ) because
	     the syntax was checked in the first pass. */

	  else if ((digitab[ptr[1]] && ctype_digit) != 0) {
	    int condref;	/* Don't amalgamate; some compilers */
	    condref = *(++ptr) - '0';	/* grumble at autoincrement in declaration */
	    while (*(++ptr) != ')')
	      condref = condref * 10 + *ptr - '0';
	    if (condref == 0) {
	      *errorptr = ERR35;
	      goto FAILED;
	    }
	    ptr++;
	    code[1 + LINK_SIZE] = OP_CREF;
	    PUT2(code, 2 + LINK_SIZE, condref);
	    skipbytes = 3;
	  }
	  /* For conditions that are assertions, we just fall through, having
	     set bravalue above. */
	  break;

	case '=':		/* Positive lookahead */
	  bravalue = OP_ASSERT;
	  ptr++;
	  break;

	case '!':		/* Negative lookahead */
	  bravalue = OP_ASSERT_NOT;
	  ptr++;
	  break;

	case '<':		/* Lookbehinds */
	  switch (*(++ptr)) {
	  case '=':		/* Positive lookbehind */
	    bravalue = OP_ASSERTBACK;
	    ptr++;
	    break;

	  case '!':		/* Negative lookbehind */
	    bravalue = OP_ASSERTBACK_NOT;
	    ptr++;
	    break;
	  }
	  break;

	case '>':		/* One-time brackets */
	  bravalue = OP_ONCE;
	  ptr++;
	  break;

	case 'C':		/* Callout - may be followed by digits */
	  *code++ = OP_CALLOUT;
	  {
	    int n = 0;
	    while ((digitab[*(++ptr)] & ctype_digit) != 0)
	      n = n * 10 + *ptr - '0';
	    if (n > 255) {
	      *errorptr = ERR38;
	      goto FAILED;
	    }
	    *code++ = n;
	  }
	  previous = NULL;
	  continue;

	case 'P':		/* Named subpattern handling */
	  if (*(++ptr) == '<') {	/* Definition */
	    int i, namelen;
	    uschar *slot = cd->name_table;
	    const uschar *name;	/* Don't amalgamate; some compilers */
	    name = ++ptr;	/* grumble at autoincrement in declaration */

	    while (*ptr++ != '>') ;
	    namelen = ptr - name - 1;

	    for (i = 0; i < cd->names_found; i++) {
	      int crc = memcmp(name, slot + 2, namelen);
	      if (crc == 0) {
		if (slot[2 + namelen] == 0) {
		  *errorptr = ERR43;
		  goto FAILED;
		}
		crc = -1;	/* Current name is substring */
	      }
	      if (crc < 0) {
		memmove(slot + cd->name_entry_size, slot,
			(cd->names_found - i) * cd->name_entry_size);
		break;
	      }
	      slot += cd->name_entry_size;
	    }

	    PUT2(slot, 0, *brackets + 1);
	    memcpy(slot + 2, name, namelen);
	    slot[2 + namelen] = 0;
	    cd->names_found++;
	    goto NUMBERED_GROUP;
	  }

	  if (*ptr == '=' || *ptr == '>') {	/* Reference or recursion */
	    int i, namelen;
	    int type = *ptr++;
	    const uschar *name = ptr;
	    uschar *slot = cd->name_table;

	    while (*ptr != ')')
	      ptr++;
	    namelen = ptr - name;

	    for (i = 0; i < cd->names_found; i++) {
	      if (strncmp((char *) name, (char *) slot + 2, namelen) == 0)
		break;
	      slot += cd->name_entry_size;
	    }
	    if (i >= cd->names_found) {
	      *errorptr = ERR15;
	      goto FAILED;
	    }

	    recno = GET2(slot, 0);

	    if (type == '>')
	      goto HANDLE_RECURSION;	/* A few lines below */

	    /* Back reference */

	    previous = code;
	    *code++ = OP_REF;
	    PUT2INC(code, 0, recno);
	    cd->backref_map |= (recno < 32) ? (1 << recno) : 1;
	    if (recno > cd->top_backref)
	      cd->top_backref = recno;
	    continue;
	  }

	  /* Should never happen */
	  break;

	case 'R':		/* Pattern recursion */
	  ptr++;		/* Same as (?0)      */
	  /* Fall through */

	  /* Recursion or "subroutine" call */

	case '0':
	case '1':
	case '2':
	case '3':
	case '4':
	case '5':
	case '6':
	case '7':
	case '8':
	case '9':
	  {
	    const uschar *called;
	    recno = 0;
	    while ((digitab[*ptr] & ctype_digit) != 0)
	      recno = recno * 10 + *ptr++ - '0';

	    /* Come here from code above that handles a named recursion */

	  HANDLE_RECURSION:

	    previous = code;

	    /* Find the bracket that is being referenced. Temporarily end the
	       regex in case it doesn't exist. */

	    *code = OP_END;
	    called = (recno == 0) ?
	      cd->start_code : find_bracket(cd->start_code, utf8, recno);

	    if (called == NULL) {
	      *errorptr = ERR15;
	      goto FAILED;
	    }

	    /* If the subpattern is still open, this is a recursive call. We
	       check to see if this is a left recursion that could loop for ever,
	       and diagnose that case. */

	    if (GET(called, 1) == 0
		&& could_be_empty(called, code, bcptr, utf8)) {
	      *errorptr = ERR40;
	      goto FAILED;
	    }

	    /* Insert the recursion/subroutine item */

	    *code = OP_RECURSE;
	    PUT(code, 1, called - cd->start_code);
	    code += 1 + LINK_SIZE;
	  }
	  continue;

	  /* Character after (? not specially recognized */

	default:		/* Option setting */
	  set = unset = 0;
	  optset = &set;

	  while (*ptr != ')' && *ptr != ':') {
	    switch (*ptr++) {
	    case '-':
	      optset = &unset;
	      break;

	    case 'i':
	      *optset |= PCRE_CASELESS;
	      break;
	    case 'm':
	      *optset |= PCRE_MULTILINE;
	      break;
	    case 's':
	      *optset |= PCRE_DOTALL;
	      break;
	    case 'x':
	      *optset |= PCRE_EXTENDED;
	      break;
	    case 'U':
	      *optset |= PCRE_UNGREEDY;
	      break;
	    case 'X':
	      *optset |= PCRE_EXTRA;
	      break;
	    }
	  }

	  /* Set up the changed option bits, but don't change anything yet. */

	  newoptions = (options | set) & (~unset);

	  /* If the options ended with ')' this is not the start of a nested
	     group with option changes, so the options change at this level. Compile
	     code to change the ims options if this setting actually changes any of
	     them. We also pass the new setting back so that it can be put at the
	     start of any following branches, and when this group ends (if we are in
	     a group), a resetting item can be compiled.

	     Note that if this item is right at the start of the pattern, the
	     options will have been abstracted and made global, so there will be no
	     change to compile. */

	  if (*ptr == ')') {
	    if ((options & PCRE_IMS) != (newoptions & PCRE_IMS)) {
	      *code++ = OP_OPT;
	      *code++ = newoptions & PCRE_IMS;
	    }

	    /* Change options at this level, and pass them back for use
	       in subsequent branches. Reset the greedy defaults and the case
	       value for firstbyte and reqbyte. */

	    *optionsptr = options = newoptions;
	    greedy_default = ((newoptions & PCRE_UNGREEDY) != 0);
	    greedy_non_default = greedy_default ^ 1;
	    req_caseopt = ((options & PCRE_CASELESS) != 0) ? REQ_CASELESS : 0;

	    previous = NULL;	/* This item can't be repeated */
	    continue;		/* It is complete */
	  }

	  /* If the options ended with ':' we are heading into a nested group
	     with possible change of options. Such groups are non-capturing and are
	     not assertions of any kind. All we need to do is skip over the ':';
	     the newoptions value is handled below. */

	  bravalue = OP_BRA;
	  ptr++;
	}
      }

      /* If PCRE_NO_AUTO_CAPTURE is set, all unadorned brackets become
         non-capturing and behave like (?:...) brackets */

      else if ((options & PCRE_NO_AUTO_CAPTURE) != 0) {
	bravalue = OP_BRA;
      }

      /* Else we have a referencing group; adjust the opcode. If the bracket
         number is greater than EXTRACT_BASIC_MAX, we set the opcode one higher, and
         arrange for the true number to follow later, in an OP_BRANUMBER item. */

      else {
      NUMBERED_GROUP:
	if (++(*brackets) > EXTRACT_BASIC_MAX) {
	  bravalue = OP_BRA + EXTRACT_BASIC_MAX + 1;
	  code[1 + LINK_SIZE] = OP_BRANUMBER;
	  PUT2(code, 2 + LINK_SIZE, *brackets);
	  skipbytes = 3;
	} else
	  bravalue = OP_BRA + *brackets;
      }

      /* Process nested bracketed re. Assertions may not be repeated, but other
         kinds can be. We copy code into a non-register variable in order to be able
         to pass its address because some compilers complain otherwise. Pass in a
         new setting for the ims options if they have changed. */

      previous = (bravalue >= OP_ONCE) ? code : NULL;
      *code = bravalue;
      tempcode = code;
      tempreqvary = cd->req_varyopt;	/* Save value before bracket */

      if (!compile_regex(newoptions,	/* The complete new option state */
			 options & PCRE_IMS,	/* The previous ims option state */
			 brackets,	/* Extracting bracket count */
			 &tempcode,	/* Where to put code (updated) */
			 &ptr,	/* Input pointer (updated) */
			 errorptr,	/* Where to put an error message */
			 (bravalue == OP_ASSERTBACK || bravalue == OP_ASSERTBACK_NOT),	/* TRUE if back assert */
			 skipbytes,	/* Skip over OP_COND/OP_BRANUMBER */
			 &subfirstbyte,	/* For possible first char */
			 &subreqbyte,	/* For possible last char */
			 bcptr,	/* Current branch chain */
			 cd))	/* Tables block */
	goto FAILED;

      /* At the end of compiling, code is still pointing to the start of the
         group, while tempcode has been updated to point past the end of the group
         and any option resetting that may follow it. The pattern pointer (ptr)
         is on the bracket. */

      /* If this is a conditional bracket, check that there are no more than
         two branches in the group. */

      else if (bravalue == OP_COND) {
	uschar *tc = code;
	condcount = 0;

	do {
	  condcount++;
	  tc += GET(tc, 1);
	}
	while (*tc != OP_KET);

	if (condcount > 2) {
	  *errorptr = ERR27;
	  goto FAILED;
	}

	/* If there is just one branch, we must not make use of its firstbyte or
	   reqbyte, because this is equivalent to an empty second branch. */

	if (condcount == 1)
	  subfirstbyte = subreqbyte = REQ_NONE;
      }

      /* Handle updating of the required and first characters. Update for normal
         brackets of all kinds, and conditions with two branches (see code above).
         If the bracket is followed by a quantifier with zero repeat, we have to
         back off. Hence the definition of zeroreqbyte and zerofirstbyte outside the
         main loop so that they can be accessed for the back off. */

      zeroreqbyte = reqbyte;
      zerofirstbyte = firstbyte;
      groupsetfirstbyte = FALSE;

      if (bravalue >= OP_BRA || bravalue == OP_ONCE || bravalue == OP_COND) {
	/* If we have not yet set a firstbyte in this branch, take it from the
	   subpattern, remembering that it was set here so that a repeat of more
	   than one can replicate it as reqbyte if necessary. If the subpattern has
	   no firstbyte, set "none" for the whole branch. In both cases, a zero
	   repeat forces firstbyte to "none". */

	if (firstbyte == REQ_UNSET) {
	  if (subfirstbyte >= 0) {
	    firstbyte = subfirstbyte;
	    groupsetfirstbyte = TRUE;
	  } else
	    firstbyte = REQ_NONE;
	  zerofirstbyte = REQ_NONE;
	}

	/* If firstbyte was previously set, convert the subpattern's firstbyte
	   into reqbyte if there wasn't one, using the vary flag that was in
	   existence beforehand. */

	else if (subfirstbyte >= 0 && subreqbyte < 0)
	  subreqbyte = subfirstbyte | tempreqvary;

	/* If the subpattern set a required byte (or set a first byte that isn't
	   really the first byte - see above), set it. */

	if (subreqbyte >= 0)
	  reqbyte = subreqbyte;
      }

      /* For a forward assertion, we take the reqbyte, if set. This can be
         helpful if the pattern that follows the assertion doesn't set a different
         char. For example, it's useful for /(?=abcde).+/. We can't set firstbyte
         for an assertion, however because it leads to incorrect effect for patterns
         such as /(?=a)a.+/ when the "real" "a" would then become a reqbyte instead
         of a firstbyte. This is overcome by a scan at the end if there's no
         firstbyte, looking for an asserted first char. */

      else if (bravalue == OP_ASSERT && subreqbyte >= 0)
	reqbyte = subreqbyte;

      /* Now update the main code pointer to the end of the group. */

      code = tempcode;

      /* Error if hit end of pattern */

      if (*ptr != ')') {
	*errorptr = ERR14;
	goto FAILED;
      }
      break;

      /* Check \ for being a real metacharacter; if not, fall through and handle
         it as a data character at the start of a string. Escape items are checked
         for validity in the pre-compiling pass. */

    case '\\':
      tempptr = ptr;
      c = check_escape(&ptr, errorptr, *brackets, options, FALSE);

      /* Handle metacharacters introduced by \. For ones like \d, the ESC_ values
         are arranged to be the negation of the corresponding OP_values. For the
         back references, the values are ESC_REF plus the reference number. Only
         back references and those types that consume a character may be repeated.
         We can test for values between ESC_b and ESC_Z for the latter; this may
         have to change if any new ones are ever created. */

      if (c < 0) {
	if (-c == ESC_Q) {	/* Handle start of quoted string */
	  if (ptr[1] == '\\' && ptr[2] == 'E')
	    ptr += 2;		/* avoid empty string */
	  else
	    inescq = TRUE;
	  continue;
	}

	/* For metasequences that actually match a character, we disable the
	   setting of a first character if it hasn't already been set. */

	if (firstbyte == REQ_UNSET && -c > ESC_b && -c < ESC_Z)
	  firstbyte = REQ_NONE;

	/* Set values to reset to if this is followed by a zero repeat. */

	zerofirstbyte = firstbyte;
	zeroreqbyte = reqbyte;

	/* Back references are handled specially */

	if (-c >= ESC_REF) {
	  int number = -c - ESC_REF;
	  previous = code;
	  *code++ = OP_REF;
	  PUT2INC(code, 0, number);
	} else {
	  previous = (-c > ESC_b && -c < ESC_Z) ? code : NULL;
	  *code++ = -c;
	}
	continue;
      }

      /* Data character: reset and fall through */

      ptr = tempptr;
      c = '\\';

      /* Handle a run of data characters until a metacharacter is encountered.
         The first character is guaranteed not to be whitespace or # when the
         extended flag is set. */

    NORMAL_CHAR:
    default:
      previous = code;
      *code = OP_CHARS;
      code += 2;
      length = 0;

      do {
	/* If in \Q...\E, check for the end; if not, we always have a literal */

	if (inescq) {
	  if (c == '\\' && ptr[1] == 'E') {
	    inescq = FALSE;
	    ptr++;
	  } else {
	    *code++ = c;
	    length++;
	  }
	  continue;
	}

	/* Skip white space and comments for /x patterns */

	if ((options & PCRE_EXTENDED) != 0) {
	  if ((cd->ctypes[c] & ctype_space) != 0)
	    continue;
	  if (c == '#') {
	    /* The space before the ; is to avoid a warning on a silly compiler
	       on the Macintosh. */
	    while ((c = *(++ptr)) != 0 && c != NEWLINE) ;
	    if (c == 0)
	      break;
	    continue;
	  }
	}

	/* Backslash may introduce a data char or a metacharacter. Escaped items
	   are checked for validity in the pre-compiling pass. Stop the string
	   before a metaitem. */

	if (c == '\\') {
	  tempptr = ptr;
	  c = check_escape(&ptr, errorptr, *brackets, options, FALSE);
	  if (c < 0) {
	    ptr = tempptr;
	    break;
	  }

	  /* If a character is > 127 in UTF-8 mode, we have to turn it into
	     two or more bytes in the UTF-8 encoding. */

	}

	/* Ordinary character or single-char escape */

	*code++ = c;
	length++;
      }

      /* This "while" is the end of the "do" above. */

      while (length < MAXLIT && (cd->ctypes[c = *(++ptr)] & ctype_meta) == 0);

      /* Update the first and last requirements. These are always bytes, even in
         UTF-8 mode. However, there is a special case to be considered when there
         are only one or two characters. Because this gets messy in UTF-8 mode, the
         code is kept separate. When we get here "length" contains the number of
         bytes. */


      /* This is the code for non-UTF-8 operation, either without UTF-8 support,
         or when UTF-8 is not enabled. */

      {
	/* firstbyte was not previously set; take it from this string */

	if (firstbyte == REQ_UNSET) {
	  if (length == 1) {
	    zerofirstbyte = REQ_NONE;
	    firstbyte = previous[2] | req_caseopt;
	    zeroreqbyte = reqbyte;
	  } else {
	    zerofirstbyte = firstbyte = previous[2] | req_caseopt;
	    zeroreqbyte = (length > 2) ?
	      (code[-2] | req_caseopt | cd->req_varyopt) : reqbyte;
	    reqbyte = code[-1] | req_caseopt | cd->req_varyopt;
	  }
	}

	/* firstbyte was previously set */

	else {
	  zerofirstbyte = firstbyte;
	  zeroreqbyte = (length == 1) ? reqbyte :
	    code[-2] | req_caseopt | cd->req_varyopt;
	  reqbyte = code[-1] | req_caseopt | cd->req_varyopt;
	}
      }

      /* Set the length in the data vector, and advance to the next state. */

      previous[1] = length;
      if (length < MAXLIT)
	ptr--;
      break;
    }
  }				/* end of big loop */

/* Control never reaches here by falling through, only by a goto for all the
error states. Pass back the position in the pattern so that it can be displayed
to the user for diagnosing the error. */

FAILED:
  *ptrptr = ptr;
  return FALSE;
}




/*************************************************
*     Compile sequence of alternatives           *
*************************************************/

/* On entry, ptr is pointing past the bracket character, but on return
it points to the closing bracket, or vertical bar, or end of string.
The code variable is pointing at the byte into which the BRA operator has been
stored. If the ims options are changed at the start (for a (?ims: group) or
during any branch, we need to insert an OP_OPT item at the start of every
following branch to ensure they get set correctly at run time, and also pass
the new options into every subsequent branch compile.

Argument:
  options        option bits, including any changes for this subpattern
  oldims         previous settings of ims option bits
  brackets       -> int containing the number of extracting brackets used
  codeptr        -> the address of the current code pointer
  ptrptr         -> the address of the current pattern pointer
  errorptr       -> pointer to error message
  lookbehind     TRUE if this is a lookbehind assertion
  skipbytes      skip this many bytes at start (for OP_COND, OP_BRANUMBER)
  firstbyteptr   place to put the first required character, or a negative number
  reqbyteptr     place to put the last required character, or a negative number
  bcptr          pointer to the chain of currently open branches
  cd             points to the data block with tables pointers etc.

Returns:      TRUE on success
*/

static BOOL
compile_regex(int options, int oldims, int *brackets, uschar ** codeptr,
	      const uschar ** ptrptr, const char **errorptr, BOOL lookbehind,
	      int skipbytes, int *firstbyteptr, int *reqbyteptr,
	      branch_chain * bcptr, compile_data * cd)
{
  const uschar *ptr = *ptrptr;
  uschar *code = *codeptr;
  uschar *last_branch = code;
  uschar *start_bracket = code;
  uschar *reverse_count = NULL;
  int firstbyte, reqbyte;
  int branchfirstbyte, branchreqbyte;
  branch_chain bc;

  bc.outer = bcptr;
  bc.current = code;

  firstbyte = reqbyte = REQ_UNSET;

/* Offset is set zero to mark that this bracket is still open */

  PUT(code, 1, 0);
  code += 1 + LINK_SIZE + skipbytes;

/* Loop for each alternative branch */

  for (;;) {
    /* Handle a change of ims options at the start of the branch */

    if ((options & PCRE_IMS) != oldims) {
      *code++ = OP_OPT;
      *code++ = options & PCRE_IMS;
    }

    /* Set up dummy OP_REVERSE if lookbehind assertion */

    if (lookbehind) {
      *code++ = OP_REVERSE;
      reverse_count = code;
      PUTINC(code, 0, 0);
    }

    /* Now compile the branch */

    if (!compile_branch(&options, brackets, &code, &ptr, errorptr,
			&branchfirstbyte, &branchreqbyte, &bc, cd)) {
      *ptrptr = ptr;
      return FALSE;
    }

    /* If this is the first branch, the firstbyte and reqbyte values for the
       branch become the values for the regex. */

    if (*last_branch != OP_ALT) {
      firstbyte = branchfirstbyte;
      reqbyte = branchreqbyte;
    }

    /* If this is not the first branch, the first char and reqbyte have to
       match the values from all the previous branches, except that if the previous
       value for reqbyte didn't have REQ_VARY set, it can still match, and we set
       REQ_VARY for the regex. */

    else {
      /* If we previously had a firstbyte, but it doesn't match the new branch,
         we have to abandon the firstbyte for the regex, but if there was previously
         no reqbyte, it takes on the value of the old firstbyte. */

      if (firstbyte >= 0 && firstbyte != branchfirstbyte) {
	if (reqbyte < 0)
	  reqbyte = firstbyte;
	firstbyte = REQ_NONE;
      }

      /* If we (now or from before) have no firstbyte, a firstbyte from the
         branch becomes a reqbyte if there isn't a branch reqbyte. */

      if (firstbyte < 0 && branchfirstbyte >= 0 && branchreqbyte < 0)
	branchreqbyte = branchfirstbyte;

      /* Now ensure that the reqbytes match */

      if ((reqbyte & ~REQ_VARY) != (branchreqbyte & ~REQ_VARY))
	reqbyte = REQ_NONE;
      else
	reqbyte |= branchreqbyte;	/* To "or" REQ_VARY */
    }

    /* If lookbehind, check that this branch matches a fixed-length string,
       and put the length into the OP_REVERSE item. Temporarily mark the end of
       the branch with OP_END. */

    if (lookbehind) {
      int length;
      *code = OP_END;
      length = find_fixedlength(last_branch, options);
      DPRINTF(("fixed length = %d\n", length));
      if (length < 0) {
	*errorptr = (length == -2) ? ERR36 : ERR25;
	*ptrptr = ptr;
	return FALSE;
      }
      PUT(reverse_count, 0, length);
    }

    /* Reached end of expression, either ')' or end of pattern. Go back through
       the alternative branches and reverse the chain of offsets, with the field in
       the BRA item now becoming an offset to the first alternative. If there are
       no alternatives, it points to the end of the group. The length in the
       terminating ket is always the length of the whole bracketed item. If any of
       the ims options were changed inside the group, compile a resetting op-code
       following, except at the very end of the pattern. Return leaving the pointer
       at the terminating char. */

    if (*ptr != '|') {
      int length = code - last_branch;
      do {
	int prev_length = GET(last_branch, 1);
	PUT(last_branch, 1, length);
	length = prev_length;
	last_branch -= length;
      }
      while (length > 0);

      /* Fill in the ket */

      *code = OP_KET;
      PUT(code, 1, code - start_bracket);
      code += 1 + LINK_SIZE;

      /* Resetting option if needed */

      if ((options & PCRE_IMS) != oldims && *ptr == ')') {
	*code++ = OP_OPT;
	*code++ = oldims;
      }

      /* Set values to pass back */

      *codeptr = code;
      *ptrptr = ptr;
      *firstbyteptr = firstbyte;
      *reqbyteptr = reqbyte;
      return TRUE;
    }

    /* Another branch follows; insert an "or" node. Its length field points back
       to the previous branch while the bracket remains open. At the end the chain
       is reversed. It's done like this so that the start of the bracket has a
       zero offset until it is closed, making it possible to detect recursion. */

    *code = OP_ALT;
    PUT(code, 1, code - last_branch);
    bc.current = last_branch = code;
    code += 1 + LINK_SIZE;
    ptr++;
  }
/* Control never reaches here */
}




/*************************************************
*          Check for anchored expression         *
*************************************************/

/* Try to find out if this is an anchored regular expression. Consider each
alternative branch. If they all start with OP_SOD or OP_CIRC, or with a bracket
all of whose alternatives start with OP_SOD or OP_CIRC (recurse ad lib), then
it's anchored. However, if this is a multiline pattern, then only OP_SOD
counts, since OP_CIRC can match in the middle.

We can also consider a regex to be anchored if OP_SOM starts all its branches.
This is the code for \G, which means "match at start of match position, taking
into account the match offset".

A branch is also implicitly anchored if it starts with .* and DOTALL is set,
because that will try the rest of the pattern at all possible matching points,
so there is no point trying again.... er ....

.... except when the .* appears inside capturing parentheses, and there is a
subsequent back reference to those parentheses. We haven't enough information
to catch that case precisely.

At first, the best we could do was to detect when .* was in capturing brackets
and the highest back reference was greater than or equal to that level.
However, by keeping a bitmap of the first 31 back references, we can catch some
of the more common cases more precisely.

Arguments:
  code           points to start of expression (the bracket)
  options        points to the options setting
  bracket_map    a bitmap of which brackets we are inside while testing; this
                  handles up to substring 31; after that we just have to take
                  the less precise approach
  backref_map    the back reference bitmap

Returns:     TRUE or FALSE
*/

static BOOL
is_anchored(register const uschar * code, int *options,
	    unsigned int bracket_map, unsigned int backref_map)
{
  do {
    const uschar *scode =
      first_significant_code(code + 1 + LINK_SIZE, options, PCRE_MULTILINE);
    register int op = *scode;

    /* Capturing brackets */

    if (op > OP_BRA) {
      int new_map;
      op -= OP_BRA;
      if (op > EXTRACT_BASIC_MAX)
	op = GET2(scode, 2 + LINK_SIZE);
      new_map = bracket_map | ((op < 32) ? (1 << op) : 1);
      if (!is_anchored(scode, options, new_map, backref_map))
	return FALSE;
    }

    /* Other brackets */

    else if (op == OP_BRA || op == OP_ASSERT || op == OP_ONCE || op == OP_COND) {
      if (!is_anchored(scode, options, bracket_map, backref_map))
	return FALSE;
    }

    /* .* is not anchored unless DOTALL is set and it isn't in brackets that
       are or may be referenced. */

    else if ((op == OP_TYPESTAR || op == OP_TYPEMINSTAR) &&
	     (*options & PCRE_DOTALL) != 0) {
      if (scode[1] != OP_ANY || (bracket_map & backref_map) != 0)
	return FALSE;
    }

    /* Check for explicit anchoring */

    else if (op != OP_SOD && op != OP_SOM &&
	     ((*options & PCRE_MULTILINE) != 0 || op != OP_CIRC))
      return FALSE;
    code += GET(code, 1);
  }
  while (*code == OP_ALT);	/* Loop for each alternative */
  return TRUE;
}



/*************************************************
*         Check for starting with ^ or .*        *
*************************************************/

/* This is called to find out if every branch starts with ^ or .* so that
"first char" processing can be done to speed things up in multiline
matching and for non-DOTALL patterns that start with .* (which must start at
the beginning or after \n). As in the case of is_anchored() (see above), we
have to take account of back references to capturing brackets that contain .*
because in that case we can't make the assumption.

Arguments:
  code           points to start of expression (the bracket)
  bracket_map    a bitmap of which brackets we are inside while testing; this
                  handles up to substring 31; after that we just have to take
                  the less precise approach
  backref_map    the back reference bitmap

Returns:         TRUE or FALSE
*/

static BOOL
is_startline(const uschar * code, unsigned int bracket_map,
	     unsigned int backref_map)
{
  do {
    const uschar *scode = first_significant_code(code + 1 + LINK_SIZE, NULL, 0);
    register int op = *scode;

    /* Capturing brackets */

    if (op > OP_BRA) {
      int new_map;
      op -= OP_BRA;
      if (op > EXTRACT_BASIC_MAX)
	op = GET2(scode, 2 + LINK_SIZE);
      new_map = bracket_map | ((op < 32) ? (1 << op) : 1);
      if (!is_startline(scode, new_map, backref_map))
	return FALSE;
    }

    /* Other brackets */

    else if (op == OP_BRA || op == OP_ASSERT || op == OP_ONCE || op == OP_COND) {
      if (!is_startline(scode, bracket_map, backref_map))
	return FALSE;
    }

    /* .* is not anchored unless DOTALL is set and it isn't in brackets that
       may be referenced. */

    else if (op == OP_TYPESTAR || op == OP_TYPEMINSTAR) {
      if (scode[1] != OP_ANY || (bracket_map & backref_map) != 0)
	return FALSE;
    }

    /* Check for explicit circumflex */

    else if (op != OP_CIRC)
      return FALSE;
    code += GET(code, 1);
  }
  while (*code == OP_ALT);	/* Loop for each alternative */
  return TRUE;
}



/*************************************************
*       Check for asserted fixed first char      *
*************************************************/

/* During compilation, the "first char" settings from forward assertions are
discarded, because they can cause conflicts with actual literals that follow.
However, if we end up without a first char setting for an unanchored pattern,
it is worth scanning the regex to see if there is an initial asserted first
char. If all branches start with the same asserted char, or with a bracket all
of whose alternatives start with the same asserted char (recurse ad lib), then
we return that char, otherwise -1.

Arguments:
  code       points to start of expression (the bracket)
  options    pointer to the options (used to check casing changes)
  inassert   TRUE if in an assertion

Returns:     -1 or the fixed first char
*/

static int
find_firstassertedchar(const uschar * code, int *options, BOOL inassert)
{
  register int c = -1;
  do {
    int d;
    const uschar *scode =
      first_significant_code(code + 1 + LINK_SIZE, options, PCRE_CASELESS);
    register int op = *scode;

    if (op >= OP_BRA)
      op = OP_BRA;

    switch (op) {
    default:
      return -1;

    case OP_BRA:
    case OP_ASSERT:
    case OP_ONCE:
    case OP_COND:
      if ((d = find_firstassertedchar(scode, options, op == OP_ASSERT)) < 0)
	return -1;
      if (c < 0)
	c = d;
      else if (c != d)
	return -1;
      break;

    case OP_EXACT:		/* Fall through */
      scode++;

    case OP_CHARS:		/* Fall through */
      scode++;

    case OP_PLUS:
    case OP_MINPLUS:
      if (!inassert)
	return -1;
      if (c < 0) {
	c = scode[1];
	if ((*options & PCRE_CASELESS) != 0)
	  c |= REQ_CASELESS;
      } else if (c != scode[1])
	return -1;
      break;
    }

    code += GET(code, 1);
  }
  while (*code == OP_ALT);
  return c;
}







/*************************************************
*        Compile a Regular Expression            *
*************************************************/

/* This function takes a string and returns a pointer to a block of store
holding a compiled version of the expression.

Arguments:
  pattern      the regular expression
  options      various option bits
  errorptr     pointer to pointer to error text
  erroroffset  ptr offset in pattern where error was detected
  tables       pointer to character tables or NULL

Returns:       pointer to compiled data block, or NULL on error,
               with errorptr and erroroffset set
*/

EXPORT pcre *
pcre_compile(const char *pattern, int options, const char **errorptr,
	     int *erroroffset, const unsigned char *tables)
{
  real_pcre *re;
  int length = 1 + LINK_SIZE;	/* For initial BRA plus length */
  int runlength;
  int c, firstbyte, reqbyte;
  int bracount = 0;
  int branch_extra = 0;
  int branch_newextra;
  int item_count = -1;
  int name_count = 0;
  int max_name_size = 0;
  BOOL inescq = FALSE;
  unsigned int brastackptr = 0;
  size_t size;
  uschar *code;
  const uschar *codestart;
  const uschar *ptr;
  compile_data compile_block;
  int brastack[BRASTACK_SIZE];
  uschar bralenstack[BRASTACK_SIZE];

/* We can't pass back an error message if errorptr is NULL; I guess the best we
can do is just return NULL. */

  if (errorptr == NULL)
    return NULL;
  *errorptr = NULL;

/* However, we can give a message for this error */

  if (erroroffset == NULL) {
    *errorptr = ERR16;
    return NULL;
  }
  *erroroffset = 0;

/* Can't support UTF8 unless PCRE has been compiled to include the code. */

  if ((options & PCRE_UTF8) != 0) {
    *errorptr = ERR32;
    return NULL;
  }

  if ((options & ~PUBLIC_OPTIONS) != 0) {
    *errorptr = ERR17;
    return NULL;
  }

/* Set up pointers to the individual character tables */

  if (tables == NULL)
    tables = pcre_default_tables;
  compile_block.lcc = tables + lcc_offset;
  compile_block.fcc = tables + fcc_offset;
  compile_block.cbits = tables + cbits_offset;
  compile_block.ctypes = tables + ctypes_offset;

/* Maximum back reference and backref bitmap. This is updated for numeric
references during the first pass, but for named references during the actual
compile pass. The bitmap records up to 31 back references to help in deciding
whether (.*) can be treated as anchored or not. */

  compile_block.top_backref = 0;
  compile_block.backref_map = 0;

/* Reflect pattern for debugging output */

  DPRINTF(("------------------------------------------------------------------\n"));
  DPRINTF(("%s\n", pattern));

/* The first thing to do is to make a pass over the pattern to compute the
amount of store required to hold the compiled code. This does not have to be
perfect as long as errors are overestimates. At the same time we can detect any
flag settings right at the start, and extract them. Make an attempt to correct
for any counted white space if an "extended" flag setting appears late in the
pattern. We can't be so clever for #-comments. */

  ptr = (const uschar *) (pattern - 1);
  while ((c = *(++ptr)) != 0) {
    int min, max;
    int class_optcount;
    int bracket_length;
    int duplength;

    /* If we are inside a \Q...\E sequence, all chars are literal */

    if (inescq)
      goto NORMAL_CHAR;

    /* Otherwise, first check for ignored whitespace and comments */

    if ((options & PCRE_EXTENDED) != 0) {
      if ((compile_block.ctypes[c] & ctype_space) != 0)
	continue;
      if (c == '#') {
	/* The space before the ; is to avoid a warning on a silly compiler
	   on the Macintosh. */
	while ((c = *(++ptr)) != 0 && c != NEWLINE) ;
	if (c == 0)
	  break;
	continue;
      }
    }

    item_count++;		/* Is zero for the first non-comment item */

    switch (c) {
      /* A backslashed item may be an escaped "normal" character or a
         character type. For a "normal" character, put the pointers and
         character back so that tests for whitespace etc. in the input
         are done correctly. */

    case '\\':
      {
	const uschar *save_ptr = ptr;
	c = check_escape(&ptr, errorptr, bracount, options, FALSE);
	if (*errorptr != NULL)
	  goto PCRE_ERROR_RETURN;
	if (c >= 0) {
	  ptr = save_ptr;
	  c = '\\';
	  goto NORMAL_CHAR;
	}
      }

      /* If \Q, enter "literal" mode */

      if (-c == ESC_Q) {
	inescq = TRUE;
	continue;
      }

      /* Other escapes need one byte, and are of length one for repeats */

      length++;

      /* A back reference needs an additional 2 bytes, plus either one or 5
         bytes for a repeat. We also need to keep the value of the highest
         back reference. */

      if (c <= -ESC_REF) {
	int refnum = -c - ESC_REF;
	compile_block.backref_map |= (refnum < 32) ? (1 << refnum) : 1;
	if (refnum > compile_block.top_backref)
	  compile_block.top_backref = refnum;
	length += 2;		/* For single back reference */
	if (ptr[1] == '{' && is_counted_repeat(ptr + 2)) {
	  ptr = read_repeat_counts(ptr + 2, &min, &max, errorptr);
	  if (*errorptr != NULL)
	    goto PCRE_ERROR_RETURN;
	  if ((min == 0 && (max == 1 || max == -1)) || (min == 1 && max == -1))
	    length++;
	  else
	    length += 5;
	  if (ptr[1] == '?')
	    ptr++;
	}
      }
      continue;

    case '^':			/* Single-byte metacharacters */
    case '.':
    case '$':
      length++;
      continue;

    case '*':			/* These repeats won't be after brackets; */
    case '+':			/* those are handled separately */
    case '?':
      length++;
      goto POSESSIVE;		/* A few lines below */

      /* This covers the cases of braced repeats after a single char, metachar,
         class, or back reference. */

    case '{':
      if (!is_counted_repeat(ptr + 1))
	goto NORMAL_CHAR;
      ptr = read_repeat_counts(ptr + 1, &min, &max, errorptr);
      if (*errorptr != NULL)
	goto PCRE_ERROR_RETURN;

      /* These special cases just insert one extra opcode */

      if ((min == 0 && (max == 1 || max == -1)) || (min == 1 && max == -1))
	length++;

      /* These cases might insert additional copies of a preceding character. */

      else {

	/* Not UTF-8 mode: all characters are one byte */
	{
	  if (min != 1) {
	    length--;		/* Uncount the original char or metachar */
	    if (min > 0)
	      length += 4;
	  }

	  length += (max > 0) ? 4 : 2;
	}
      }

      if (ptr[1] == '?')
	ptr++;			/* Needs no extra length */

    POSESSIVE:			/* Test for possessive quantifier */
      if (ptr[1] == '+') {
	ptr++;
	length += 2 + 2 * LINK_SIZE;	/* Allow for atomic brackets */
      }
      continue;

      /* An alternation contains an offset to the next branch or ket. If any ims
         options changed in the previous branch(es), and/or if we are in a
         lookbehind assertion, extra space will be needed at the start of the
         branch. This is handled by branch_extra. */

    case '|':
      length += 1 + LINK_SIZE + branch_extra;
      continue;

      /* A character class uses 33 characters provided that all the character
         values are less than 256. Otherwise, it uses a bit map for low valued
         characters, and individual items for others. Don't worry about character
         types that aren't allowed in classes - they'll get picked up during the
         compile. A character class that contains only one single-byte character
         uses 2 or 3 bytes, depending on whether it is negated or not. Notice this
         where we can. (In UTF-8 mode we can do this only for chars < 128.) */

    case '[':
      class_optcount = 0;


      if (*(++ptr) == '^')
	ptr++;

      /* Written as a "do" so that an initial ']' is taken as data */

      if (*ptr != 0)
	do {
	  /* Inside \Q...\E everything is literal except \E */

	  if (inescq) {
	    if (*ptr != '\\' || ptr[1] != 'E')
	      goto NON_SPECIAL_CHARACTER;
	    inescq = FALSE;
	    ptr += 1;
	    continue;
	  }

	  /* Outside \Q...\E, check for escapes */

	  if (*ptr == '\\') {
	    int ch = check_escape(&ptr, errorptr, bracount, options, TRUE);
	    if (*errorptr != NULL)
	      goto PCRE_ERROR_RETURN;

	    /* \b is backspace inside a class */

	    if (-ch == ESC_b)
	      ch = '\b';

	    /* \Q enters quoting mode */

	    if (-ch == ESC_Q) {
	      inescq = TRUE;
	      continue;
	    }

	    /* Handle escapes that turn into characters */

	    if (ch >= 0) {
	      class_optcount++;	/* for possible optimization */
	    } else
	      class_optcount = 10;	/* \d, \s etc; make sure > 1 */
	  }

	  /* Check the syntax for POSIX stuff. The bits we actually handle are
	     checked during the real compile phase. */

	  else if (*ptr == '[' && check_posix_syntax(ptr, &ptr, &compile_block)) {
	    ptr++;
	    class_optcount = 10;	/* Make sure > 1 */
	  }

	  /* Anything else just increments the possible optimization count. If
	     there are wide characters, we are going to have to use an XCLASS. */

	  else {
	  NON_SPECIAL_CHARACTER:
	    class_optcount++;

	  }
	}
	while (*(++ptr) != 0 && (inescq || *ptr != ']'));	/* Concludes "do" above */

      if (*ptr == 0) {		/* Missing terminating ']' */
	*errorptr = ERR6;
	goto PCRE_ERROR_RETURN;
      }

      /* We can optimize when there was only one optimizable character. Repeats
         for positive and negated single one-byte chars are handled by the general
         code. Here, we handle repeats for the class opcodes. */

      if (class_optcount == 1)
	length += 3;
      else {
	length += 33;

	/* A repeat needs either 1 or 5 bytes. If it is a possessive quantifier,
	   we also need extra for wrapping the whole thing in a sub-pattern. */

	if (*ptr != 0 && ptr[1] == '{' && is_counted_repeat(ptr + 2)) {
	  ptr = read_repeat_counts(ptr + 2, &min, &max, errorptr);
	  if (*errorptr != NULL)
	    goto PCRE_ERROR_RETURN;
	  if ((min == 0 && (max == 1 || max == -1)) || (min == 1 && max == -1))
	    length++;
	  else
	    length += 5;
	  if (ptr[1] == '+') {
	    ptr++;
	    length += 2 + 2 * LINK_SIZE;
	  } else if (ptr[1] == '?')
	    ptr++;
	}
      }
      continue;

      /* Brackets may be genuine groups or special things */

    case '(':
      branch_newextra = 0;
      bracket_length = 1 + LINK_SIZE;

      /* Handle special forms of bracket, which all start (? */

      if (ptr[1] == '?') {
	int set, unset;
	int *optset;

	switch (c = ptr[2]) {
	  /* Skip over comments entirely */
	case '#':
	  ptr += 3;
	  while (*ptr != 0 && *ptr != ')')
	    ptr++;
	  if (*ptr == 0) {
	    *errorptr = ERR18;
	    goto PCRE_ERROR_RETURN;
	  }
	  continue;

	  /* Non-referencing groups and lookaheads just move the pointer on, and
	     then behave like a non-special bracket, except that they don't increment
	     the count of extracting brackets. Ditto for the "once only" bracket,
	     which is in Perl from version 5.005. */

	case ':':
	case '=':
	case '!':
	case '>':
	  ptr += 2;
	  break;

	  /* (?R) specifies a recursive call to the regex, which is an extension
	     to provide the facility which can be obtained by (?p{perl-code}) in
	     Perl 5.6. In Perl 5.8 this has become (??{perl-code}).

	     From PCRE 4.00, items such as (?3) specify subroutine-like "calls" to
	     the appropriate numbered brackets. This includes both recursive and
	     non-recursive calls. (?R) is now synonymous with (?0). */

	case 'R':
	  ptr++;

	case '0':
	case '1':
	case '2':
	case '3':
	case '4':
	case '5':
	case '6':
	case '7':
	case '8':
	case '9':
	  ptr += 2;
	  if (c != 'R')
	    while ((digitab[*(++ptr)] & ctype_digit) != 0) ;
	  if (*ptr != ')') {
	    *errorptr = ERR29;
	    goto PCRE_ERROR_RETURN;
	  }
	  length += 1 + LINK_SIZE;

	  /* If this item is quantified, it will get wrapped inside brackets so
	     as to use the code for quantified brackets. We jump down and use the
	     code that handles this for real brackets. */

	  if (ptr[1] == '+' || ptr[1] == '*' || ptr[1] == '?' || ptr[1] == '{') {
	    length += 2 + 2 * LINK_SIZE;	/* to make bracketed */
	    duplength = 5 + 3 * LINK_SIZE;
	    goto HANDLE_QUANTIFIED_BRACKETS;
	  }
	  continue;

	  /* (?C) is an extension which provides "callout" - to provide a bit of
	     the functionality of the Perl (?{...}) feature. An optional number may
	     follow (default is zero). */

	case 'C':
	  ptr += 2;
	  while ((digitab[*(++ptr)] & ctype_digit) != 0) ;
	  if (*ptr != ')') {
	    *errorptr = ERR39;
	    goto PCRE_ERROR_RETURN;
	  }
	  length += 2;
	  continue;

	  /* Named subpatterns are an extension copied from Python */

	case 'P':
	  ptr += 3;
	  if (*ptr == '<') {
	    const uschar *p;	/* Don't amalgamate; some compilers */
	    p = ++ptr;		/* grumble at autoincrement in declaration */
	    while ((compile_block.ctypes[*ptr] & ctype_word) != 0)
	      ptr++;
	    if (*ptr != '>') {
	      *errorptr = ERR42;
	      goto PCRE_ERROR_RETURN;
	    }
	    name_count++;
	    if (ptr - p > max_name_size)
	      max_name_size = (ptr - p);
	    break;
	  }

	  if (*ptr == '=' || *ptr == '>') {
	    while ((compile_block.ctypes[*(++ptr)] & ctype_word) != 0) ;
	    if (*ptr != ')') {
	      *errorptr = ERR42;
	      goto PCRE_ERROR_RETURN;
	    }
	    break;
	  }

	  /* Unknown character after (?P */

	  *errorptr = ERR41;
	  goto PCRE_ERROR_RETURN;

	  /* Lookbehinds are in Perl from version 5.005 */

	case '<':
	  ptr += 3;
	  if (*ptr == '=' || *ptr == '!') {
	    branch_newextra = 1 + LINK_SIZE;
	    length += 1 + LINK_SIZE;	/* For the first branch */
	    break;
	  }
	  *errorptr = ERR24;
	  goto PCRE_ERROR_RETURN;

	  /* Conditionals are in Perl from version 5.005. The bracket must either
	     be followed by a number (for bracket reference) or by an assertion
	     group, or (a PCRE extension) by 'R' for a recursion test. */

	case '(':
	  if (ptr[3] == 'R' && ptr[4] == ')') {
	    ptr += 4;
	    length += 3;
	  } else if ((digitab[ptr[3]] & ctype_digit) != 0) {
	    ptr += 4;
	    length += 3;
	    while ((digitab[*ptr] & ctype_digit) != 0)
	      ptr++;
	    if (*ptr != ')') {
	      *errorptr = ERR26;
	      goto PCRE_ERROR_RETURN;
	    }
	  } else {		/* An assertion must follow */

	    ptr++;		/* Can treat like ':' as far as spacing is concerned */
	    if (ptr[2] != '?' ||
		(ptr[3] != '=' && ptr[3] != '!' && ptr[3] != '<')) {
	      ptr += 2;		/* To get right offset in message */
	      *errorptr = ERR28;
	      goto PCRE_ERROR_RETURN;
	    }
	  }
	  break;

	  /* Else loop checking valid options until ) is met. Anything else is an
	     error. If we are without any brackets, i.e. at top level, the settings
	     act as if specified in the options, so massage the options immediately.
	     This is for backward compatibility with Perl 5.004. */

	default:
	  set = unset = 0;
	  optset = &set;
	  ptr += 2;

	  for (;; ptr++) {
	    c = *ptr;
	    switch (c) {
	    case 'i':
	      *optset |= PCRE_CASELESS;
	      continue;

	    case 'm':
	      *optset |= PCRE_MULTILINE;
	      continue;

	    case 's':
	      *optset |= PCRE_DOTALL;
	      continue;

	    case 'x':
	      *optset |= PCRE_EXTENDED;
	      continue;

	    case 'X':
	      *optset |= PCRE_EXTRA;
	      continue;

	    case 'U':
	      *optset |= PCRE_UNGREEDY;
	      continue;

	    case '-':
	      optset = &unset;
	      continue;

	      /* A termination by ')' indicates an options-setting-only item; if
	         this is at the very start of the pattern (indicated by item_count
	         being zero), we use it to set the global options. This is helpful
	         when analyzing the pattern for first characters, etc. Otherwise
	         nothing is done here and it is handled during the compiling
	         process.

	         [Historical note: Up to Perl 5.8, options settings at top level
	         were always global settings, wherever they appeared in the pattern.
	         That is, they were equivalent to an external setting. From 5.8
	         onwards, they apply only to what follows (which is what you might
	         expect).] */

	    case ')':
	      if (item_count == 0) {
		options = (options | set) & (~unset);
		set = unset = 0;	/* To save length */
		item_count--;	/* To allow for several */
	      }

	      /* Fall through */

	      /* A termination by ':' indicates the start of a nested group with
	         the given options set. This is again handled at compile time, but
	         we must allow for compiled space if any of the ims options are
	         set. We also have to allow for resetting space at the end of
	         the group, which is why 4 is added to the length and not just 2.
	         If there are several changes of options within the same group, this
	         will lead to an over-estimate on the length, but this shouldn't
	         matter very much. We also have to allow for resetting options at
	         the start of any alternations, which we do by setting
	         branch_newextra to 2. Finally, we record whether the case-dependent
	         flag ever changes within the regex. This is used by the "required
	         character" code. */

	    case ':':
	      if (((set | unset) & PCRE_IMS) != 0) {
		length += 4;
		branch_newextra = 2;
		if (((set | unset) & PCRE_CASELESS) != 0)
		  options |= PCRE_ICHANGED;
	      }
	      goto END_OPTIONS;

	      /* Unrecognized option character */

	    default:
	      *errorptr = ERR12;
	      goto PCRE_ERROR_RETURN;
	    }
	  }

	  /* If we hit a closing bracket, that's it - this is a freestanding
	     option-setting. We need to ensure that branch_extra is updated if
	     necessary. The only values branch_newextra can have here are 0 or 2.
	     If the value is 2, then branch_extra must either be 2 or 5, depending
	     on whether this is a lookbehind group or not. */

	END_OPTIONS:
	  if (c == ')') {
	    if (branch_newextra == 2 &&
		(branch_extra == 0 || branch_extra == 1 + LINK_SIZE))
	      branch_extra += branch_newextra;
	    continue;
	  }

	  /* If options were terminated by ':' control comes here. Fall through
	     to handle the group below. */
	}
      }

      /* Extracting brackets must be counted so we can process escapes in a
         Perlish way. If the number exceeds EXTRACT_BASIC_MAX we are going to
         need an additional 3 bytes of store per extracting bracket. However, if
         PCRE_NO_AUTO)CAPTURE is set, unadorned brackets become non-capturing, so we
         must leave the count alone (it will aways be zero). */

      else if ((options & PCRE_NO_AUTO_CAPTURE) == 0) {
	bracount++;
	if (bracount > EXTRACT_BASIC_MAX)
	  bracket_length += 3;
      }

      /* Save length for computing whole length at end if there's a repeat that
         requires duplication of the group. Also save the current value of
         branch_extra, and start the new group with the new value. If non-zero, this
         will either be 2 for a (?imsx: group, or 3 for a lookbehind assertion. */

      if (brastackptr >= sizeof(brastack) / sizeof(int)) {
	*errorptr = ERR19;
	goto PCRE_ERROR_RETURN;
      }

      bralenstack[brastackptr] = branch_extra;
      branch_extra = branch_newextra;

      brastack[brastackptr++] = length;
      length += bracket_length;
      continue;

      /* Handle ket. Look for subsequent max/min; for certain sets of values we
         have to replicate this bracket up to that many times. If brastackptr is
         0 this is an unmatched bracket which will generate an error, but take care
         not to try to access brastack[-1] when computing the length and restoring
         the branch_extra value. */

    case ')':
      length += 1 + LINK_SIZE;
      if (brastackptr > 0) {
	duplength = length - brastack[--brastackptr];
	branch_extra = bralenstack[brastackptr];
      } else
	duplength = 0;

      /* The following code is also used when a recursion such as (?3) is
         followed by a quantifier, because in that case, it has to be wrapped inside
         brackets so that the quantifier works. The value of duplength must be
         set before arrival. */

    HANDLE_QUANTIFIED_BRACKETS:

      /* Leave ptr at the final char; for read_repeat_counts this happens
         automatically; for the others we need an increment. */

      if ((c = ptr[1]) == '{' && is_counted_repeat(ptr + 2)) {
	ptr = read_repeat_counts(ptr + 2, &min, &max, errorptr);
	if (*errorptr != NULL)
	  goto PCRE_ERROR_RETURN;
      } else if (c == '*') {
	min = 0;
	max = -1;
	ptr++;
      } else if (c == '+') {
	min = 1;
	max = -1;
	ptr++;
      } else if (c == '?') {
	min = 0;
	max = 1;
	ptr++;
      } else {
	min = 1;
	max = 1;
      }

      /* If the minimum is zero, we have to allow for an OP_BRAZERO before the
         group, and if the maximum is greater than zero, we have to replicate
         maxval-1 times; each replication acquires an OP_BRAZERO plus a nesting
         bracket set. */

      if (min == 0) {
	length++;
	if (max > 0)
	  length += (max - 1) * (duplength + 3 + 2 * LINK_SIZE);
      }

      /* When the minimum is greater than zero, we have to replicate up to
         minval-1 times, with no additions required in the copies. Then, if there
         is a limited maximum we have to replicate up to maxval-1 times allowing
         for a BRAZERO item before each optional copy and nesting brackets for all
         but one of the optional copies. */

      else {
	length += (min - 1) * duplength;
	if (max > min)		/* Need this test as max=-1 means no limit */
	  length += (max - min) * (duplength + 3 + 2 * LINK_SIZE)
	    - (2 + 2 * LINK_SIZE);
      }

      /* Allow space for once brackets for "possessive quantifier" */

      if (ptr[1] == '+') {
	ptr++;
	length += 2 + 2 * LINK_SIZE;
      }
      continue;

      /* Non-special character. For a run of such characters the length required
         is the number of characters + 2, except that the maximum run length is
         MAXLIT. We won't get a skipped space or a non-data escape or the start of a
         # comment as the first character, so the length can't be zero. */

    NORMAL_CHAR:
    default:
      length += 2;
      runlength = 0;
      do {

	/* If in a \Q...\E sequence, check for end; otherwise it's a literal */
	if (inescq) {
	  if (c == '\\' && ptr[1] == 'E') {
	    inescq = FALSE;
	    ptr++;
	  } else
	    runlength++;
	  continue;
	}

	/* Skip whitespace and comments for /x */

	if ((options & PCRE_EXTENDED) != 0) {
	  if ((compile_block.ctypes[c] & ctype_space) != 0)
	    continue;
	  if (c == '#') {
	    /* The space before the ; is to avoid a warning on a silly compiler
	       on the Macintosh. */
	    while ((c = *(++ptr)) != 0 && c != NEWLINE) ;
	    continue;
	  }
	}

	/* Backslash may introduce a data char or a metacharacter; stop the
	   string before the latter. */

	if (c == '\\') {
	  const uschar *saveptr = ptr;
	  c = check_escape(&ptr, errorptr, bracount, options, FALSE);
	  if (*errorptr != NULL)
	    goto PCRE_ERROR_RETURN;
	  if (c < 0) {
	    ptr = saveptr;
	    break;
	  }

	  /* In UTF-8 mode, add on the number of additional bytes needed to
	     encode this character, and save the total length in case this is a
	     final char that is repeated. */

	}

	/* Ordinary character or single-char escape */

	runlength++;
      }

      /* This "while" is the end of the "do" above. */

      while (runlength < MAXLIT &&
	     (compile_block.ctypes[c = *(++ptr)] & ctype_meta) == 0);

      /* If we hit a meta-character, back off to point to it */

      if (runlength < MAXLIT)
	ptr--;

      /* If the last char in the string is a UTF-8 multibyte character, we must
         set lastcharlength correctly. If it was specified as an escape, this will
         already have been done above. However, we also have to support in-line
         UTF-8 characters, so check backwards from where we are. */


      length += runlength;
      continue;
    }
  }

  length += 2 + LINK_SIZE;	/* For final KET and END */

  if (length > MAX_PATTERN_SIZE) {
    *errorptr = ERR20;
    return NULL;
  }

/* Compute the size of data block needed and get it, either from malloc or
externally provided function. */

  size = length + sizeof(real_pcre) + name_count * (max_name_size + 3);
  re = (real_pcre *) malloc(size);

  if (re == NULL) {
    *errorptr = ERR21;
    return NULL;
  }

/* Put in the magic number, and save the size, options, and table pointer */

  re->magic_number = MAGIC_NUMBER;
  re->size = size;
  re->options = options;
  re->tables = tables;
  re->name_entry_size = max_name_size + 3;
  re->name_count = name_count;

/* The starting points of the name/number translation table and of the code are
passed around in the compile data block. */

  compile_block.names_found = 0;
  compile_block.name_entry_size = max_name_size + 3;
  compile_block.name_table = (uschar *) re + sizeof(real_pcre);
  codestart = compile_block.name_table + re->name_entry_size * re->name_count;
  compile_block.start_code = codestart;
  compile_block.req_varyopt = 0;

/* Set up a starting, non-extracting bracket, then compile the expression. On
error, *errorptr will be set non-NULL, so we don't need to look at the result
of the function here. */

  ptr = (const uschar *) pattern;
  code = (uschar *) codestart;
  *code = OP_BRA;
  bracount = 0;
  (void) compile_regex(options, options & PCRE_IMS, &bracount, &code, &ptr,
		       errorptr, FALSE, 0, &firstbyte, &reqbyte, NULL,
		       &compile_block);
  re->top_bracket = bracount;
  re->top_backref = compile_block.top_backref;

/* If not reached end of pattern on success, there's an excess bracket. */

  if (*errorptr == NULL && *ptr != 0)
    *errorptr = ERR22;

/* Fill in the terminating state and check for disastrous overflow, but
if debugging, leave the test till after things are printed out. */

  *code++ = OP_END;

  if (code - codestart > length)
    *errorptr = ERR23;

/* Give an error if there's back reference to a non-existent capturing
subpattern. */

  if (re->top_backref > re->top_bracket)
    *errorptr = ERR15;

/* Failed to compile, or error while post-processing */

  if (*errorptr != NULL) {
    free(re);
  PCRE_ERROR_RETURN:
    *erroroffset = ptr - (const uschar *) pattern;
    return NULL;
  }

/* If the anchored option was not passed, set the flag if we can determine that
the pattern is anchored by virtue of ^ characters or \A or anything else (such
as starting with .* when DOTALL is set).

Otherwise, if we know what the first character has to be, save it, because that
speeds up unanchored matches no end. If not, see if we can set the
PCRE_STARTLINE flag. This is helpful for multiline matches when all branches
start with ^. and also when all branches start with .* for non-DOTALL matches.
*/

  if ((options & PCRE_ANCHORED) == 0) {
    int temp_options = options;
    if (is_anchored(codestart, &temp_options, 0, compile_block.backref_map))
      re->options |= PCRE_ANCHORED;
    else {
      if (firstbyte < 0)
	firstbyte = find_firstassertedchar(codestart, &temp_options, FALSE);
      if (firstbyte >= 0) {	/* Remove caseless flag for non-caseable chars */
	int ch = firstbyte & 255;
	re->first_byte = ((firstbyte & REQ_CASELESS) != 0 &&
			  compile_block.fcc[ch] == ch) ? ch : firstbyte;
	re->options |= PCRE_FIRSTSET;
      } else if (is_startline(codestart, 0, compile_block.backref_map))
	re->options |= PCRE_STARTLINE;
    }
  }

/* For an anchored pattern, we use the "required byte" only if it follows a
variable length item in the regex. Remove the caseless flag for non-caseable
chars. */

  if (reqbyte >= 0 &&
      ((re->options & PCRE_ANCHORED) == 0 || (reqbyte & REQ_VARY) != 0)) {
    int ch = reqbyte & 255;
    re->req_byte = ((reqbyte & REQ_CASELESS) != 0 &&
		    compile_block.fcc[ch] ==
		    ch) ? (reqbyte & ~REQ_CASELESS) : reqbyte;
    re->options |= PCRE_REQCHSET;
  }

/* Print out the compiled data for debugging */


  return (pcre *) re;
}



/*************************************************
*          Match a back-reference                *
*************************************************/

/* If a back reference hasn't been set, the length that is passed is greater
than the number of characters left in the string, so the match fails.

Arguments:
  offset      index into the offset vector
  eptr        points into the subject
  length      length to be matched
  md          points to match data block
  ims         the ims flags

Returns:      TRUE if matched
*/

static BOOL
match_ref(int offset, register const uschar * eptr, int length, match_data * md,
	  unsigned long int ims)
{
  const uschar *p = md->start_subject + md->offset_vector[offset];


/* Always fail if not enough characters left */

  if (length > md->end_subject - eptr)
    return FALSE;

/* Separate the caselesss case for speed */

  if ((ims & PCRE_CASELESS) != 0) {
    while (length-- > 0)
      if (md->lcc[*p++] != md->lcc[*eptr++])
	return FALSE;
  } else {
    while (length-- > 0)
      if (*p++ != *eptr++)
	return FALSE;
  }

  return TRUE;
}




/***************************************************************************
****************************************************************************
                   RECURSION IN THE match() FUNCTION

The match() function is highly recursive. Some regular expressions can cause
it to recurse thousands of times. I was writing for Unix, so I just let it
call itself recursively. This uses the stack for saving everything that has
to be saved for a recursive call. On Unix, the stack can be large, and this
works fine.

It turns out that on non-Unix systems there are problems with programs that
use a lot of stack. (This despite the fact that every last chip has oodles
of memory these days, and techniques for extending the stack have been known
for decades.) So....

There is a fudge, triggered by defining NO_RECURSE, which avoids recursive
calls by keeping local variables that need to be preserved in blocks of memory
obtained from malloc instead instead of on the stack. Macros are used to
achieve this so that the actual code doesn't look very different to what it
always used to.
****************************************************************************
***************************************************************************/


/* These versions of the macros use the stack, as normal */

#ifndef NO_RECURSE
#define REGISTER register
#define RMATCH(rx,ra,rb,rc,rd,re,rf,rg) rx = match(ra,rb,rc,rd,re,rf,rg)
#define RRETURN(ra) return ra
#else


/* These versions of the macros manage a private stack on the heap. Note
that the rd argument of RMATCH isn't actually used. It's the md argument of
match(), which never actually changes. */

#define REGISTER

#define RMATCH(rx,ra,rb,rc,rd,re,rf,rg)\
  {\
  heapframe *newframe = (pcre_stack_malloc)(sizeof(heapframe));\
  if (setjmp(frame->Xwhere) == 0)\
    {\
    newframe->Xeptr = ra;\
    newframe->Xecode = rb;\
    newframe->Xoffset_top = rc;\
    newframe->Xims = re;\
    newframe->Xeptrb = rf;\
    newframe->Xflags = rg;\
    newframe->Xprevframe = frame;\
    frame = newframe;\
    DPRINTF(("restarting from line %d\n", __LINE__));\
    goto HEAP_RECURSE;\
    }\
  else\
    {\
    DPRINTF(("longjumped back to line %d\n", __LINE__));\
    frame = md->thisframe;\
    rx = frame->Xresult;\
    }\
  }

#define RRETURN(ra)\
  {\
  heapframe *newframe = frame;\
  frame = newframe->Xprevframe;\
  (pcre_stack_free)(newframe);\
  if (frame != NULL)\
    {\
    frame->Xresult = ra;\
    md->thisframe = frame;\
    longjmp(frame->Xwhere, 1);\
    }\
  return ra;\
  }


/* Structure for remembering the local variables in a private frame */

typedef struct heapframe {
  struct heapframe *Xprevframe;

  /* Function arguments that may change */

  const uschar *Xeptr;
  const uschar *Xecode;
  int Xoffset_top;
  long int Xims;
  eptrblock *Xeptrb;
  int Xflags;

  /* Function local variables */

  const uschar *Xcallpat;
  const uschar *Xcharptr;
  const uschar *Xdata;
  const uschar *Xlastptr;
  const uschar *Xnext;
  const uschar *Xpp;
  const uschar *Xprev;
  const uschar *Xsaved_eptr;

  recursion_info Xnew_recursive;

  BOOL Xcur_is_word;
  BOOL Xcondition;
  BOOL Xminimize;
  BOOL Xprev_is_word;

  unsigned long int Xoriginal_ims;

  int Xctype;
  int Xfc;
  int Xfi;
  int Xlength;
  int Xmax;
  int Xmin;
  int Xnumber;
  int Xoffset;
  int Xop;
  int Xsave_capture_last;
  int Xsave_offset1, Xsave_offset2, Xsave_offset3;
  int Xstacksave[REC_STACK_SAVE_MAX];

  eptrblock Xnewptrb;

  /* Place to pass back result, and where to jump back to */

  int Xresult;
  jmp_buf Xwhere;

} heapframe;

#endif


/***************************************************************************
***************************************************************************/



/*************************************************
*         Match from current position            *
*************************************************/

/* On entry ecode points to the first opcode, and eptr to the first character
in the subject string, while eptrb holds the value of eptr at the start of the
last bracketed group - used for breaking infinite loops matching zero-length
strings. This function is called recursively in many circumstances. Whenever it
returns a negative (error) response, the outer incarnation must also return the
same response.

Performance note: It might be tempting to extract commonly used fields from the
md structure (e.g. utf8, end_subject) into individual variables to improve
performance. Tests using gcc on a SPARC disproved this; in the first case, it
made performance worse.

Arguments:
   eptr        pointer in subject
   ecode       position in code
   offset_top  current top pointer
   md          pointer to "static" info for the match
   ims         current /i, /m, and /s options
   eptrb       pointer to chain of blocks containing eptr at start of
                 brackets - for testing for empty matches
   flags       can contain
                 match_condassert - this is an assertion condition
                 match_isgroup - this is the start of a bracketed group

Returns:       MATCH_MATCH if matched            )  these values are >= 0
               MATCH_NOMATCH if failed to match  )
               a negative PCRE_ERROR_xxx value if aborted by an error condition
                 (e.g. stopped by recursion limit)
*/

static int
match(REGISTER const uschar * eptr, REGISTER const uschar * ecode,
      int offset_top, match_data * md, unsigned long int ims, eptrblock * eptrb,
      int flags)
{
/* These variables do not need to be preserved over recursion in this function,
so they can be ordinary variables in all cases. Mark them with "register"
because they are used a lot in loops. */

  register int rrc;		/* Returns from recursive calls */
  register int i;		/* Used for loops not involving calls to RMATCH() */
  register int c;		/* Character values not kept over RMATCH() calls */

/* When recursion is not being used, all "local" variables that have to be
preserved over calls to RMATCH() are part of a "frame" which is obtained from
heap storage. Set up the top-level frame here; others are obtained from the
heap whenever RMATCH() does a "recursion". See the macro definitions above. */

#ifdef NO_RECURSE
  heapframe *frame = (pcre_stack_malloc) (sizeof(heapframe));
  frame->Xprevframe = NULL;	/* Marks the top level */

/* Copy in the original argument variables */

  frame->Xeptr = eptr;
  frame->Xecode = ecode;
  frame->Xoffset_top = offset_top;
  frame->Xims = ims;
  frame->Xeptrb = eptrb;
  frame->Xflags = flags;

/* This is where control jumps back to to effect "recursion" */

HEAP_RECURSE:

/* Macros make the argument variables come from the current frame */

#define eptr               frame->Xeptr
#define ecode              frame->Xecode
#define offset_top         frame->Xoffset_top
#define ims                frame->Xims
#define eptrb              frame->Xeptrb
#define flags              frame->Xflags

/* Ditto for the local variables */

#define callpat            frame->Xcallpat
#define charptr            frame->Xcharptr
#define data               frame->Xdata
#define lastptr            frame->Xlastptr
#define next               frame->Xnext
#define pp                 frame->Xpp
#define prev               frame->Xprev
#define saved_eptr         frame->Xsaved_eptr

#define new_recursive      frame->Xnew_recursive

#define cur_is_word        frame->Xcur_is_word
#define condition          frame->Xcondition
#define minimize           frame->Xminimize
#define prev_is_word       frame->Xprev_is_word

#define original_ims       frame->Xoriginal_ims

#define ctype              frame->Xctype
#define fc                 frame->Xfc
#define fi                 frame->Xfi
#define length             frame->Xlength
#define max                frame->Xmax
#define min                frame->Xmin
#define number             frame->Xnumber
#define offset             frame->Xoffset
#define op                 frame->Xop
#define save_capture_last  frame->Xsave_capture_last
#define save_offset1       frame->Xsave_offset1
#define save_offset2       frame->Xsave_offset2
#define save_offset3       frame->Xsave_offset3
#define stacksave          frame->Xstacksave

#define newptrb            frame->Xnewptrb

/* When recursion is being used, local variables are allocated on the stack and
get preserved during recursion in the normal way. In this environment, fi and
i, and fc and c, can be the same variables. */

#else
#define fi i
#define fc c

  const uschar *callpat;	/* Many of these variables are used ony */
  const uschar *charptr;	/* small blocks of the code. My normal  */
  const uschar *data;		/* style of coding would have declared  */
  const uschar *lastptr;	/* them within each of those blocks.    */
  const uschar *next;		/* However, in order to accommodate the */
  const uschar *pp;		/* version of this code that uses an    */
  const uschar *prev;		/* external "stack" implemented on the  */
  const uschar *saved_eptr;	/* heap, it is easier to declare them   */
  /* all here, so the declarations can    */
  recursion_info new_recursive;	/* be cut out in a block. The only      */
  /* declarations within blocks below are */
  BOOL cur_is_word;		/* for variables that do not have to    */
  BOOL condition;		/* be preserved over a recursive call   */
  BOOL minimize;		/* to RMATCH().                         */
  BOOL prev_is_word;

  unsigned long int original_ims;

  int ctype;
  int length;
  int max;
  int min;
  int number;
  int offset;
  int op;
  int save_capture_last;
  int save_offset1, save_offset2, save_offset3;
  int stacksave[REC_STACK_SAVE_MAX];

  eptrblock newptrb;
#endif


/* OK, now we can get on with the real code of the function. Recursion is
specified by the macros RMATCH and RRETURN. When NO_RECURSE is *not* defined,
these just turn into a recursive call to match() and a "return", respectively.
However, RMATCH isn't like a function call because it's quite a complicated
macro. It has to be used in one particular way. This shouldn't, however, impact
performance when true recursion is being used. */

  if (md->match_call_count++ >= md->match_limit)
    RRETURN(PCRE_ERROR_MATCHLIMIT);

  original_ims = ims;		/* Save for resetting on ')' */

/* At the start of a bracketed group, add the current subject pointer to the
stack of such pointers, to be re-instated at the end of the group when we hit
the closing ket. When match() is called in other circumstances, we don't add to
this stack. */

  if ((flags & match_isgroup) != 0) {
    newptrb.epb_prev = eptrb;
    newptrb.epb_saved_eptr = eptr;
    eptrb = &newptrb;
  }

/* Now start processing the operations. */

  for (;;) {
    op = *ecode;
    minimize = FALSE;

    /* Opening capturing bracket. If there is space in the offset vector, save
       the current subject position in the working slot at the top of the vector. We
       mustn't change the current values of the data slot, because they may be set
       from a previous iteration of this group, and be referred to by a reference
       inside the group.

       If the bracket fails to match, we need to restore this value and also the
       values of the final offsets, in case they were set by a previous iteration of
       the same bracket.

       If there isn't enough space in the offset vector, treat this as if it were a
       non-capturing bracket. Don't worry about setting the flag for the error case
       here; that is handled in the code for KET. */

    if (op > OP_BRA) {
      number = op - OP_BRA;

      /* For extended extraction brackets (large number), we have to fish out the
         number from a dummy opcode at the start. */

      if (number > EXTRACT_BASIC_MAX)
	number = GET2(ecode, 2 + LINK_SIZE);
      offset = number << 1;

      if (offset < md->offset_max) {
	save_offset1 = md->offset_vector[offset];
	save_offset2 = md->offset_vector[offset + 1];
	save_offset3 = md->offset_vector[md->offset_end - number];
	save_capture_last = md->capture_last;

	DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2,
		 save_offset3));
	md->offset_vector[md->offset_end - number] = eptr - md->start_subject;

	do {
	  RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb,
		 match_isgroup);
	  if (rrc != MATCH_NOMATCH)
	    RRETURN(rrc);
	  md->capture_last = save_capture_last;
	  ecode += GET(ecode, 1);
	}
	while (*ecode == OP_ALT);

	DPRINTF(("bracket %d failed\n", number));

	md->offset_vector[offset] = save_offset1;
	md->offset_vector[offset + 1] = save_offset2;
	md->offset_vector[md->offset_end - number] = save_offset3;

	RRETURN(MATCH_NOMATCH);
      }

      /* Insufficient room for saving captured contents */

      else
	op = OP_BRA;
    }

    /* Other types of node can be handled by a switch */

    switch (op) {
    case OP_BRA:		/* Non-capturing bracket: optimized */
      DPRINTF(("start bracket 0\n"));
      do {
	RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb,
	       match_isgroup);
	if (rrc != MATCH_NOMATCH)
	  RRETURN(rrc);
	ecode += GET(ecode, 1);
      }
      while (*ecode == OP_ALT);
      DPRINTF(("bracket 0 failed\n"));
      RRETURN(MATCH_NOMATCH);

      /* Conditional group: compilation checked that there are no more than
         two branches. If the condition is false, skipping the first branch takes us
         past the end if there is only one branch, but that's OK because that is
         exactly what going to the ket would do. */

    case OP_COND:
      if (ecode[LINK_SIZE + 1] == OP_CREF) {	/* Condition extract or recurse test */
	offset = GET2(ecode, LINK_SIZE + 2) << 1;	/* Doubled ref number */
	condition = (offset == CREF_RECURSE * 2) ?
	  (md->recursive != NULL) :
	  (offset < offset_top && md->offset_vector[offset] >= 0);
	RMATCH(rrc, eptr, ecode + (condition ?
				   (LINK_SIZE + 4) : (LINK_SIZE + 1 +
						      GET(ecode, 1))),
	       offset_top, md, ims, eptrb, match_isgroup);
	RRETURN(rrc);
      }

      /* The condition is an assertion. Call match() to evaluate it - setting
         the final argument TRUE causes it to stop at the end of an assertion. */

      else {
	RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL,
	       match_condassert | match_isgroup);
	if (rrc == MATCH_MATCH) {
	  ecode += 1 + LINK_SIZE + GET(ecode, LINK_SIZE + 2);
	  while (*ecode == OP_ALT)
	    ecode += GET(ecode, 1);
	} else if (rrc != MATCH_NOMATCH) {
	  RRETURN(rrc);		/* Need braces because of following else */
	} else
	  ecode += GET(ecode, 1);
	RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb,
	       match_isgroup);
	RRETURN(rrc);
      }
      /* Control never reaches here */

      /* Skip over conditional reference or large extraction number data if
         encountered. */

    case OP_CREF:
    case OP_BRANUMBER:
      ecode += 3;
      break;

      /* End of the pattern. If we are in a recursion, we should restore the
         offsets appropriately and continue from after the call. */

    case OP_END:
      if (md->recursive != NULL && md->recursive->group_num == 0) {
	recursion_info *rec = md->recursive;
	DPRINTF(("Hit the end in a (?0) recursion\n"));
	md->recursive = rec->prevrec;
	memmove(md->offset_vector, rec->offset_save,
		rec->saved_max * sizeof(int));
	md->start_match = rec->save_start;
	ims = original_ims;
	ecode = rec->after_call;
	break;
      }

      /* Otherwise, if PCRE_NOTEMPTY is set, fail if we have matched an empty
         string - backtracking will then try other alternatives, if any. */

      if (md->notempty && eptr == md->start_match)
	RRETURN(MATCH_NOMATCH);
      md->end_match_ptr = eptr;	/* Record where we ended */
      md->end_offset_top = offset_top;	/* and how many extracts were taken */
      RRETURN(MATCH_MATCH);

      /* Change option settings */

    case OP_OPT:
      ims = ecode[1];
      ecode += 2;
      DPRINTF(("ims set to %02lx\n", ims));
      break;

      /* Assertion brackets. Check the alternative branches in turn - the
         matching won't pass the KET for an assertion. If any one branch matches,
         the assertion is true. Lookbehind assertions have an OP_REVERSE item at the
         start of each branch to move the current point backwards, so the code at
         this level is identical to the lookahead case. */

    case OP_ASSERT:
    case OP_ASSERTBACK:
      do {
	RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL,
	       match_isgroup);
	if (rrc == MATCH_MATCH)
	  break;
	if (rrc != MATCH_NOMATCH)
	  RRETURN(rrc);
	ecode += GET(ecode, 1);
      }
      while (*ecode == OP_ALT);
      if (*ecode == OP_KET)
	RRETURN(MATCH_NOMATCH);

      /* If checking an assertion for a condition, return MATCH_MATCH. */

      if ((flags & match_condassert) != 0)
	RRETURN(MATCH_MATCH);

      /* Continue from after the assertion, updating the offsets high water
         mark, since extracts may have been taken during the assertion. */

      do
	ecode += GET(ecode, 1);
      while (*ecode == OP_ALT);
      ecode += 1 + LINK_SIZE;
      offset_top = md->end_offset_top;
      continue;

      /* Negative assertion: all branches must fail to match */

    case OP_ASSERT_NOT:
    case OP_ASSERTBACK_NOT:
      do {
	RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL,
	       match_isgroup);
	if (rrc == MATCH_MATCH)
	  RRETURN(MATCH_NOMATCH);
	if (rrc != MATCH_NOMATCH)
	  RRETURN(rrc);
	ecode += GET(ecode, 1);
      }
      while (*ecode == OP_ALT);

      if ((flags & match_condassert) != 0)
	RRETURN(MATCH_MATCH);

      ecode += 1 + LINK_SIZE;
      continue;

      /* Move the subject pointer back. This occurs only at the start of
         each branch of a lookbehind assertion. If we are too close to the start to
         move back, this match function fails. When working with UTF-8 we move
         back a number of characters, not bytes. */

    case OP_REVERSE:

      /* No UTF-8 support, or not in UTF-8 mode: count is byte count */

      {
	eptr -= GET(ecode, 1);
	if (eptr < md->start_subject)
	  RRETURN(MATCH_NOMATCH);
      }

      /* Skip to next op code */

      ecode += 1 + LINK_SIZE;
      break;

      /* The callout item calls an external function, if one is provided, passing
         details of the match so far. This is mainly for debugging, though the
         function is able to force a failure. */

    case OP_CALLOUT:
      if (pcre_callout != NULL) {
	pcre_callout_block cb;
	cb.version = 0;		/* Version 0 of the callout block */
	cb.callout_number = ecode[1];
	cb.offset_vector = md->offset_vector;
	cb.subject = (const char *) md->start_subject;
	cb.subject_length = md->end_subject - md->start_subject;
	cb.start_match = md->start_match - md->start_subject;
	cb.current_position = eptr - md->start_subject;
	cb.capture_top = offset_top / 2;
	cb.capture_last = md->capture_last;
	cb.callout_data = md->callout_data;
	if ((rrc = (*pcre_callout) (&cb)) > 0)
	  RRETURN(MATCH_NOMATCH);
	if (rrc < 0)
	  RRETURN(rrc);
      }
      ecode += 2;
      break;

      /* Recursion either matches the current regex, or some subexpression. The
         offset data is the offset to the starting bracket from the start of the
         whole pattern. (This is so that it works from duplicated subpatterns.)

         If there are any capturing brackets started but not finished, we have to
         save their starting points and reinstate them after the recursion. However,
         we don't know how many such there are (offset_top records the completed
         total) so we just have to save all the potential data. There may be up to
         65535 such values, which is too large to put on the stack, but using malloc
         for small numbers seems expensive. As a compromise, the stack is used when
         there are no more than REC_STACK_SAVE_MAX values to store; otherwise malloc
         is used. A problem is what to do if the malloc fails ... there is no way of
         returning to the top level with an error. Save the top REC_STACK_SAVE_MAX
         values on the stack, and accept that the rest may be wrong.

         There are also other values that have to be saved. We use a chained
         sequence of blocks that actually live on the stack. Thanks to Robin Houston
         for the original version of this logic. */

    case OP_RECURSE:
      {
	callpat = md->start_code + GET(ecode, 1);
	new_recursive.group_num = *callpat - OP_BRA;

	/* For extended extraction brackets (large number), we have to fish out
	   the number from a dummy opcode at the start. */

	if (new_recursive.group_num > EXTRACT_BASIC_MAX)
	  new_recursive.group_num = GET2(callpat, 2 + LINK_SIZE);

	/* Add to "recursing stack" */

	new_recursive.prevrec = md->recursive;
	md->recursive = &new_recursive;

	/* Find where to continue from afterwards */

	ecode += 1 + LINK_SIZE;
	new_recursive.after_call = ecode;

	/* Now save the offset data. */

	new_recursive.saved_max = md->offset_end;
	if (new_recursive.saved_max <= REC_STACK_SAVE_MAX)
	  new_recursive.offset_save = stacksave;
	else {
	  new_recursive.offset_save =
	    (int *) malloc(new_recursive.saved_max * sizeof(int));
	  if (new_recursive.offset_save == NULL)
	    RRETURN(PCRE_ERROR_NOMEMORY);
	}

	memcpy(new_recursive.offset_save, md->offset_vector,
	       new_recursive.saved_max * sizeof(int));
	new_recursive.save_start = md->start_match;
	md->start_match = eptr;

	/* OK, now we can do the recursion. For each top-level alternative we
	   restore the offset and recursion data. */

	DPRINTF(("Recursing into group %d\n", new_recursive.group_num));
	do {
	  RMATCH(rrc, eptr, callpat + 1 + LINK_SIZE, offset_top, md, ims,
		 eptrb, match_isgroup);
	  if (rrc == MATCH_MATCH) {
	    md->recursive = new_recursive.prevrec;
	    if (new_recursive.offset_save != stacksave)
	      free(new_recursive.offset_save);
	    RRETURN(MATCH_MATCH);
	  } else if (rrc != MATCH_NOMATCH)
	    RRETURN(rrc);

	  md->recursive = &new_recursive;
	  memcpy(md->offset_vector, new_recursive.offset_save,
		 new_recursive.saved_max * sizeof(int));
	  callpat += GET(callpat, 1);
	}
	while (*callpat == OP_ALT);

	DPRINTF(("Recursion didn't match\n"));
	md->recursive = new_recursive.prevrec;
	if (new_recursive.offset_save != stacksave)
	  free(new_recursive.offset_save);
	RRETURN(MATCH_NOMATCH);
      }
      /* Control never reaches here */

      /* "Once" brackets are like assertion brackets except that after a match,
         the point in the subject string is not moved back. Thus there can never be
         a move back into the brackets. Friedl calls these "atomic" subpatterns.
         Check the alternative branches in turn - the matching won't pass the KET
         for this kind of subpattern. If any one branch matches, we carry on as at
         the end of a normal bracket, leaving the subject pointer. */

    case OP_ONCE:
      {
	prev = ecode;
	saved_eptr = eptr;

	do {
	  RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims,
		 eptrb, match_isgroup);
	  if (rrc == MATCH_MATCH)
	    break;
	  if (rrc != MATCH_NOMATCH)
	    RRETURN(rrc);
	  ecode += GET(ecode, 1);
	}
	while (*ecode == OP_ALT);

	/* If hit the end of the group (which could be repeated), fail */

	if (*ecode != OP_ONCE && *ecode != OP_ALT)
	  RRETURN(MATCH_NOMATCH);

	/* Continue as from after the assertion, updating the offsets high water
	   mark, since extracts may have been taken. */

	do
	  ecode += GET(ecode, 1);
	while (*ecode == OP_ALT);

	offset_top = md->end_offset_top;
	eptr = md->end_match_ptr;

	/* For a non-repeating ket, just continue at this level. This also
	   happens for a repeating ket if no characters were matched in the group.
	   This is the forcible breaking of infinite loops as implemented in Perl
	   5.005. If there is an options reset, it will get obeyed in the normal
	   course of events. */

	if (*ecode == OP_KET || eptr == saved_eptr) {
	  ecode += 1 + LINK_SIZE;
	  break;
	}

	/* The repeating kets try the rest of the pattern or restart from the
	   preceding bracket, in the appropriate order. We need to reset any options
	   that changed within the bracket before re-running it, so check the next
	   opcode. */

	if (ecode[1 + LINK_SIZE] == OP_OPT) {
	  ims = (ims & ~PCRE_IMS) | ecode[4];
	  DPRINTF(("ims set to %02lx at group repeat\n", ims));
	}

	if (*ecode == OP_KETRMIN) {
	  RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb,
		 0);
	  if (rrc != MATCH_NOMATCH)
	    RRETURN(rrc);
	  RMATCH(rrc, eptr, prev, offset_top, md, ims, eptrb, match_isgroup);
	  if (rrc != MATCH_NOMATCH)
	    RRETURN(rrc);
	} else {		/* OP_KETRMAX */

	  RMATCH(rrc, eptr, prev, offset_top, md, ims, eptrb, match_isgroup);
	  if (rrc != MATCH_NOMATCH)
	    RRETURN(rrc);
	  RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb,
		 0);
	  if (rrc != MATCH_NOMATCH)
	    RRETURN(rrc);
	}
      }
      RRETURN(MATCH_NOMATCH);

      /* An alternation is the end of a branch; scan along to find the end of the
         bracketed group and go to there. */

    case OP_ALT:
      do
	ecode += GET(ecode, 1);
      while (*ecode == OP_ALT);
      break;

      /* BRAZERO and BRAMINZERO occur just before a bracket group, indicating
         that it may occur zero times. It may repeat infinitely, or not at all -
         i.e. it could be ()* or ()? in the pattern. Brackets with fixed upper
         repeat limits are compiled as a number of copies, with the optional ones
         preceded by BRAZERO or BRAMINZERO. */

    case OP_BRAZERO:
      {
	next = ecode + 1;
	RMATCH(rrc, eptr, next, offset_top, md, ims, eptrb, match_isgroup);
	if (rrc != MATCH_NOMATCH)
	  RRETURN(rrc);
	do
	  next += GET(next, 1);
	while (*next == OP_ALT);
	ecode = next + 1 + LINK_SIZE;
      }
      break;

    case OP_BRAMINZERO:
      {
	next = ecode + 1;
	do
	  next += GET(next, 1);
	while (*next == OP_ALT);
	RMATCH(rrc, eptr, next + 1 + LINK_SIZE, offset_top, md, ims, eptrb,
	       match_isgroup);
	if (rrc != MATCH_NOMATCH)
	  RRETURN(rrc);
	ecode++;
      }
      break;

      /* End of a group, repeated or non-repeating. If we are at the end of
         an assertion "group", stop matching and return MATCH_MATCH, but record the
         current high water mark for use by positive assertions. Do this also
         for the "once" (not-backup up) groups. */

    case OP_KET:
    case OP_KETRMIN:
    case OP_KETRMAX:
      {
	prev = ecode - GET(ecode, 1);
	saved_eptr = eptrb->epb_saved_eptr;

	/* Back up the stack of bracket start pointers. */

	eptrb = eptrb->epb_prev;

	if (*prev == OP_ASSERT || *prev == OP_ASSERT_NOT ||
	    *prev == OP_ASSERTBACK || *prev == OP_ASSERTBACK_NOT ||
	    *prev == OP_ONCE) {
	  md->end_match_ptr = eptr;	/* For ONCE */
	  md->end_offset_top = offset_top;
	  RRETURN(MATCH_MATCH);
	}

	/* In all other cases except a conditional group we have to check the
	   group number back at the start and if necessary complete handling an
	   extraction by setting the offsets and bumping the high water mark. */

	if (*prev != OP_COND) {
	  number = *prev - OP_BRA;

	  /* For extended extraction brackets (large number), we have to fish out
	     the number from a dummy opcode at the start. */

	  if (number > EXTRACT_BASIC_MAX)
	    number = GET2(prev, 2 + LINK_SIZE);
	  offset = number << 1;

	  /* Test for a numbered group. This includes groups called as a result
	     of recursion. Note that whole-pattern recursion is coded as a recurse
	     into group 0, so it won't be picked up here. Instead, we catch it when
	     the OP_END is reached. */

	  if (number > 0) {
	    md->capture_last = number;
	    if (offset >= md->offset_max)
	      md->offset_overflow = TRUE;
	    else {
	      md->offset_vector[offset] =
		md->offset_vector[md->offset_end - number];
	      md->offset_vector[offset + 1] = eptr - md->start_subject;
	      if (offset_top <= offset)
		offset_top = offset + 2;
	    }

	    /* Handle a recursively called group. Restore the offsets
	       appropriately and continue from after the call. */

	    if (md->recursive != NULL && md->recursive->group_num == number) {
	      recursion_info *rec = md->recursive;
	      DPRINTF(("Recursion (%d) succeeded - continuing\n", number));
	      md->recursive = rec->prevrec;
	      md->start_match = rec->save_start;
	      memcpy(md->offset_vector, rec->offset_save,
		     rec->saved_max * sizeof(int));
	      ecode = rec->after_call;
	      ims = original_ims;
	      break;
	    }
	  }
	}

	/* Reset the value of the ims flags, in case they got changed during
	   the group. */

	ims = original_ims;
	DPRINTF(("ims reset to %02lx\n", ims));

	/* For a non-repeating ket, just continue at this level. This also
	   happens for a repeating ket if no characters were matched in the group.
	   This is the forcible breaking of infinite loops as implemented in Perl
	   5.005. If there is an options reset, it will get obeyed in the normal
	   course of events. */

	if (*ecode == OP_KET || eptr == saved_eptr) {
	  ecode += 1 + LINK_SIZE;
	  break;
	}

	/* The repeating kets try the rest of the pattern or restart from the
	   preceding bracket, in the appropriate order. */

	if (*ecode == OP_KETRMIN) {
	  RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb,
		 0);
	  if (rrc != MATCH_NOMATCH)
	    RRETURN(rrc);
	  RMATCH(rrc, eptr, prev, offset_top, md, ims, eptrb, match_isgroup);
	  if (rrc != MATCH_NOMATCH)
	    RRETURN(rrc);
	} else {		/* OP_KETRMAX */

	  RMATCH(rrc, eptr, prev, offset_top, md, ims, eptrb, match_isgroup);
	  if (rrc != MATCH_NOMATCH)
	    RRETURN(rrc);
	  RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb,
		 0);
	  if (rrc != MATCH_NOMATCH)
	    RRETURN(rrc);
	}
      }

      RRETURN(MATCH_NOMATCH);

      /* Start of subject unless notbol, or after internal newline if multiline */

    case OP_CIRC:
      if (md->notbol && eptr == md->start_subject)
	RRETURN(MATCH_NOMATCH);
      if ((ims & PCRE_MULTILINE) != 0) {
	if (eptr != md->start_subject && eptr[-1] != NEWLINE)
	  RRETURN(MATCH_NOMATCH);
	ecode++;
	break;
      }
      /* ... else fall through */

      /* Start of subject assertion */

    case OP_SOD:
      if (eptr != md->start_subject)
	RRETURN(MATCH_NOMATCH);
      ecode++;
      break;

      /* Start of match assertion */

    case OP_SOM:
      if (eptr != md->start_subject + md->start_offset)
	RRETURN(MATCH_NOMATCH);
      ecode++;
      break;

      /* Assert before internal newline if multiline, or before a terminating
         newline unless endonly is set, else end of subject unless noteol is set. */

    case OP_DOLL:
      if ((ims & PCRE_MULTILINE) != 0) {
	if (eptr < md->end_subject) {
	  if (*eptr != NEWLINE)
	    RRETURN(MATCH_NOMATCH);
	} else {
	  if (md->noteol)
	    RRETURN(MATCH_NOMATCH);
	}
	ecode++;
	break;
      } else {
	if (md->noteol)
	  RRETURN(MATCH_NOMATCH);
	if (!md->endonly) {
	  if (eptr < md->end_subject - 1 ||
	      (eptr == md->end_subject - 1 && *eptr != NEWLINE))
	    RRETURN(MATCH_NOMATCH);
	  ecode++;
	  break;
	}
      }
      /* ... else fall through */

      /* End of subject assertion (\z) */

    case OP_EOD:
      if (eptr < md->end_subject)
	RRETURN(MATCH_NOMATCH);
      ecode++;
      break;

      /* End of subject or ending \n assertion (\Z) */

    case OP_EODN:
      if (eptr < md->end_subject - 1 ||
	  (eptr == md->end_subject - 1 && *eptr != NEWLINE))
	RRETURN(MATCH_NOMATCH);
      ecode++;
      break;

      /* Word boundary assertions */

    case OP_NOT_WORD_BOUNDARY:
    case OP_WORD_BOUNDARY:
      {

	/* Find out if the previous and current characters are "word" characters.
	   It takes a bit more work in UTF-8 mode. Characters > 255 are assumed to
	   be "non-word" characters. */


	/* More streamlined when not in UTF-8 mode */

	{
	  prev_is_word = (eptr != md->start_subject) &&
	    ((md->ctypes[eptr[-1]] & ctype_word) != 0);
	  cur_is_word = (eptr < md->end_subject) &&
	    ((md->ctypes[*eptr] & ctype_word) != 0);
	}

	/* Now see if the situation is what we want */

	if ((*ecode++ == OP_WORD_BOUNDARY) ?
	    cur_is_word == prev_is_word : cur_is_word != prev_is_word)
	  RRETURN(MATCH_NOMATCH);
      }
      break;

      /* Match a single character type; inline for speed */

    case OP_ANY:
      if ((ims & PCRE_DOTALL) == 0 && eptr < md->end_subject
	  && *eptr == NEWLINE)
	RRETURN(MATCH_NOMATCH);
      if (eptr++ >= md->end_subject)
	RRETURN(MATCH_NOMATCH);
      ecode++;
      break;

      /* Match a single byte, even in UTF-8 mode. This opcode really does match
         any byte, even newline, independent of the setting of PCRE_DOTALL. */

    case OP_ANYBYTE:
      if (eptr++ >= md->end_subject)
	RRETURN(MATCH_NOMATCH);
      ecode++;
      break;

    case OP_NOT_DIGIT:
      if (eptr >= md->end_subject)
	RRETURN(MATCH_NOMATCH);
      GETCHARINCTEST(c, eptr);
      if ((md->ctypes[c] & ctype_digit) != 0)
	RRETURN(MATCH_NOMATCH);
      ecode++;
      break;

    case OP_DIGIT:
      if (eptr >= md->end_subject)
	RRETURN(MATCH_NOMATCH);
      GETCHARINCTEST(c, eptr);
      if ((md->ctypes[c] & ctype_digit) == 0)
	RRETURN(MATCH_NOMATCH);
      ecode++;
      break;

    case OP_NOT_WHITESPACE:
      if (eptr >= md->end_subject)
	RRETURN(MATCH_NOMATCH);
      GETCHARINCTEST(c, eptr);
      if ((md->ctypes[c] & ctype_space) != 0)
	RRETURN(MATCH_NOMATCH);
      ecode++;
      break;

    case OP_WHITESPACE:
      if (eptr >= md->end_subject)
	RRETURN(MATCH_NOMATCH);
      GETCHARINCTEST(c, eptr);
      if ((md->ctypes[c] & ctype_space) == 0)
	RRETURN(MATCH_NOMATCH);
      ecode++;
      break;

    case OP_NOT_WORDCHAR:
      if (eptr >= md->end_subject)
	RRETURN(MATCH_NOMATCH);
      GETCHARINCTEST(c, eptr);
      if ((md->ctypes[c] & ctype_word) != 0)
	RRETURN(MATCH_NOMATCH);
      ecode++;
      break;

    case OP_WORDCHAR:
      if (eptr >= md->end_subject)
	RRETURN(MATCH_NOMATCH);
      GETCHARINCTEST(c, eptr);
      if ((md->ctypes[c] & ctype_word) == 0)
	RRETURN(MATCH_NOMATCH);
      ecode++;
      break;

      /* Match a back reference, possibly repeatedly. Look past the end of the
         item to see if there is repeat information following. The code is similar
         to that for character classes, but repeated for efficiency. Then obey
         similar code to character type repeats - written out again for speed.
         However, if the referenced string is the empty string, always treat
         it as matched, any number of times (otherwise there could be infinite
         loops). */

    case OP_REF:
      {
	offset = GET2(ecode, 1) << 1;	/* Doubled ref number */
	ecode += 3;		/* Advance past item */

	/* If the reference is unset, set the length to be longer than the amount
	   of subject left; this ensures that every attempt at a match fails. We
	   can't just fail here, because of the possibility of quantifiers with zero
	   minima. */

	length = (offset >= offset_top || md->offset_vector[offset] < 0) ?
	  md->end_subject - eptr + 1 :
	  md->offset_vector[offset + 1] - md->offset_vector[offset];

	/* Set up for repetition, or handle the non-repeated case */

	switch (*ecode) {
	case OP_CRSTAR:
	case OP_CRMINSTAR:
	case OP_CRPLUS:
	case OP_CRMINPLUS:
	case OP_CRQUERY:
	case OP_CRMINQUERY:
	  c = *ecode++ - OP_CRSTAR;
	  minimize = (c & 1) != 0;
	  min = rep_min[c];	/* Pick up values from tables; */
	  max = rep_max[c];	/* zero for max => infinity */
	  if (max == 0)
	    max = INT_MAX;
	  break;

	case OP_CRRANGE:
	case OP_CRMINRANGE:
	  minimize = (*ecode == OP_CRMINRANGE);
	  min = GET2(ecode, 1);
	  max = GET2(ecode, 3);
	  if (max == 0)
	    max = INT_MAX;
	  ecode += 5;
	  break;

	default:		/* No repeat follows */
	  if (!match_ref(offset, eptr, length, md, ims))
	    RRETURN(MATCH_NOMATCH);
	  eptr += length;
	  continue;		/* With the main loop */
	}

	/* If the length of the reference is zero, just continue with the
	   main loop. */

	if (length == 0)
	  continue;

	/* First, ensure the minimum number of matches are present. We get back
	   the length of the reference string explicitly rather than passing the
	   address of eptr, so that eptr can be a register variable. */

	for (i = 1; i <= min; i++) {
	  if (!match_ref(offset, eptr, length, md, ims))
	    RRETURN(MATCH_NOMATCH);
	  eptr += length;
	}

	/* If min = max, continue at the same level without recursion.
	   They are not both allowed to be zero. */

	if (min == max)
	  continue;

	/* If minimizing, keep trying and advancing the pointer */

	if (minimize) {
	  for (fi = min;; fi++) {
	    RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
	    if (rrc != MATCH_NOMATCH)
	      RRETURN(rrc);
	    if (fi >= max || !match_ref(offset, eptr, length, md, ims))
	      RRETURN(MATCH_NOMATCH);
	    eptr += length;
	  }
	  /* Control never gets here */
	}

	/* If maximizing, find the longest string and work backwards */

	else {
	  pp = eptr;
	  for (i = min; i < max; i++) {
	    if (!match_ref(offset, eptr, length, md, ims))
	      break;
	    eptr += length;
	  }
	  while (eptr >= pp) {
	    RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
	    if (rrc != MATCH_NOMATCH)
	      RRETURN(rrc);
	    eptr -= length;
	  }
	  RRETURN(MATCH_NOMATCH);
	}
      }
      /* Control never gets here */



      /* Match a bit-mapped character class, possibly repeatedly. This op code is
         used when all the characters in the class have values in the range 0-255.
         The only difference between OP_CLASS and OP_NCLASS occurs when a data
         character outside the range is encountered.

         First, look past the end of the item to see if there is repeat information
         following. Then obey similar code to character type repeats - written out
         again for speed. */

    case OP_NCLASS:
    case OP_CLASS:
      {
	data = ecode + 1;	/* Save for matching */
	ecode += 33;		/* Advance past the item */

	switch (*ecode) {
	case OP_CRSTAR:
	case OP_CRMINSTAR:
	case OP_CRPLUS:
	case OP_CRMINPLUS:
	case OP_CRQUERY:
	case OP_CRMINQUERY:
	  c = *ecode++ - OP_CRSTAR;
	  minimize = (c & 1) != 0;
	  min = rep_min[c];	/* Pick up values from tables; */
	  max = rep_max[c];	/* zero for max => infinity */
	  if (max == 0)
	    max = INT_MAX;
	  break;

	case OP_CRRANGE:
	case OP_CRMINRANGE:
	  minimize = (*ecode == OP_CRMINRANGE);
	  min = GET2(ecode, 1);
	  max = GET2(ecode, 3);
	  if (max == 0)
	    max = INT_MAX;
	  ecode += 5;
	  break;

	default:		/* No repeat follows */
	  min = max = 1;
	  break;
	}

	/* First, ensure the minimum number of matches are present. */

	/* Not UTF-8 mode */
	{
	  for (i = 1; i <= min; i++) {
	    if (eptr >= md->end_subject)
	      RRETURN(MATCH_NOMATCH);
	    c = *eptr++;
	    if ((data[c / 8] & (1 << (c & 7))) == 0)
	      RRETURN(MATCH_NOMATCH);
	  }
	}

	/* If max == min we can continue with the main loop without the
	   need to recurse. */

	if (min == max)
	  continue;

	/* If minimizing, keep testing the rest of the expression and advancing
	   the pointer while it matches the class. */

	if (minimize) {
	  /* Not UTF-8 mode */
	  {
	    for (fi = min;; fi++) {
	      RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
	      if (rrc != MATCH_NOMATCH)
		RRETURN(rrc);
	      if (fi >= max || eptr >= md->end_subject)
		RRETURN(MATCH_NOMATCH);
	      c = *eptr++;
	      if ((data[c / 8] & (1 << (c & 7))) == 0)
		RRETURN(MATCH_NOMATCH);
	    }
	  }
	  /* Control never gets here */
	}

	/* If maximizing, find the longest possible run, then work backwards. */

	else {
	  pp = eptr;

	  /* Not UTF-8 mode */
	  {
	    for (i = min; i < max; i++) {
	      if (eptr >= md->end_subject)
		break;
	      c = *eptr;
	      if ((data[c / 8] & (1 << (c & 7))) == 0)
		break;
	      eptr++;
	    }
	    while (eptr >= pp) {
	      RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
	      eptr--;
	      if (rrc != MATCH_NOMATCH)
		RRETURN(rrc);
	    }
	  }

	  RRETURN(MATCH_NOMATCH);
	}
      }
      /* Control never gets here */


      /* Match an extended character class. This opcode is encountered only
         in UTF-8 mode, because that's the only time it is compiled. */


      /* Match a run of characters */

    case OP_CHARS:
      {
	register int slen = ecode[1];
	ecode += 2;


	if (slen > md->end_subject - eptr)
	  RRETURN(MATCH_NOMATCH);
	if ((ims & PCRE_CASELESS) != 0) {
	  while (slen-- > 0)
	    if (md->lcc[*ecode++] != md->lcc[*eptr++])
	      RRETURN(MATCH_NOMATCH);
	} else {
	  while (slen-- > 0)
	    if (*ecode++ != *eptr++)
	      RRETURN(MATCH_NOMATCH);
	}
      }
      break;

      /* Match a single character repeatedly; different opcodes share code. */

    case OP_EXACT:
      min = max = GET2(ecode, 1);
      ecode += 3;
      goto REPEATCHAR;

    case OP_UPTO:
    case OP_MINUPTO:
      min = 0;
      max = GET2(ecode, 1);
      minimize = *ecode == OP_MINUPTO;
      ecode += 3;
      goto REPEATCHAR;

    case OP_STAR:
    case OP_MINSTAR:
    case OP_PLUS:
    case OP_MINPLUS:
    case OP_QUERY:
    case OP_MINQUERY:
      c = *ecode++ - OP_STAR;
      minimize = (c & 1) != 0;
      min = rep_min[c];		/* Pick up values from tables; */
      max = rep_max[c];		/* zero for max => infinity */
      if (max == 0)
	max = INT_MAX;

      /* Common code for all repeated single-character matches. We can give
         up quickly if there are fewer than the minimum number of characters left in
         the subject. */

    REPEATCHAR:

      /* When not in UTF-8 mode, load a single-byte character. */
      {
	if (min > md->end_subject - eptr)
	  RRETURN(MATCH_NOMATCH);
	fc = *ecode++;
      }

      /* The value of fc at this point is always less than 256, though we may or
         may not be in UTF-8 mode. The code is duplicated for the caseless and
         caseful cases, for speed, since matching characters is likely to be quite
         common. First, ensure the minimum number of matches are present. If min =
         max, continue at the same level without recursing. Otherwise, if
         minimizing, keep trying the rest of the expression and advancing one
         matching character if failing, up to the maximum. Alternatively, if
         maximizing, find the maximum number of characters and work backwards. */

      DPRINTF(("matching %c{%d,%d} against subject %.*s\n", fc, min, max,
	       max, eptr));

      if ((ims & PCRE_CASELESS) != 0) {
	fc = md->lcc[fc];
	for (i = 1; i <= min; i++)
	  if (fc != md->lcc[*eptr++])
	    RRETURN(MATCH_NOMATCH);
	if (min == max)
	  continue;
	if (minimize) {
	  for (fi = min;; fi++) {
	    RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
	    if (rrc != MATCH_NOMATCH)
	      RRETURN(rrc);
	    if (fi >= max || eptr >= md->end_subject || fc != md->lcc[*eptr++])
	      RRETURN(MATCH_NOMATCH);
	  }
	  /* Control never gets here */
	} else {
	  pp = eptr;
	  for (i = min; i < max; i++) {
	    if (eptr >= md->end_subject || fc != md->lcc[*eptr])
	      break;
	    eptr++;
	  }
	  while (eptr >= pp) {
	    RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
	    eptr--;
	    if (rrc != MATCH_NOMATCH)
	      RRETURN(rrc);
	  }
	  RRETURN(MATCH_NOMATCH);
	}
	/* Control never gets here */
      }

      /* Caseful comparisons (includes all multi-byte characters) */

      else {
	for (i = 1; i <= min; i++)
	  if (fc != *eptr++)
	    RRETURN(MATCH_NOMATCH);
	if (min == max)
	  continue;
	if (minimize) {
	  for (fi = min;; fi++) {
	    RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
	    if (rrc != MATCH_NOMATCH)
	      RRETURN(rrc);
	    if (fi >= max || eptr >= md->end_subject || fc != *eptr++)
	      RRETURN(MATCH_NOMATCH);
	  }
	  /* Control never gets here */
	} else {
	  pp = eptr;
	  for (i = min; i < max; i++) {
	    if (eptr >= md->end_subject || fc != *eptr)
	      break;
	    eptr++;
	  }
	  while (eptr >= pp) {
	    RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
	    eptr--;
	    if (rrc != MATCH_NOMATCH)
	      RRETURN(rrc);
	  }
	  RRETURN(MATCH_NOMATCH);
	}
      }
      /* Control never gets here */

      /* Match a negated single one-byte character. The character we are
         checking can be multibyte. */

    case OP_NOT:
      if (eptr >= md->end_subject)
	RRETURN(MATCH_NOMATCH);
      ecode++;
      GETCHARINCTEST(c, eptr);
      if ((ims & PCRE_CASELESS) != 0) {
	c = md->lcc[c];
	if (md->lcc[*ecode++] == c)
	  RRETURN(MATCH_NOMATCH);
      } else {
	if (*ecode++ == c)
	  RRETURN(MATCH_NOMATCH);
      }
      break;

      /* Match a negated single one-byte character repeatedly. This is almost a
         repeat of the code for a repeated single character, but I haven't found a
         nice way of commoning these up that doesn't require a test of the
         positive/negative option for each character match. Maybe that wouldn't add
         very much to the time taken, but character matching *is* what this is all
         about... */

    case OP_NOTEXACT:
      min = max = GET2(ecode, 1);
      ecode += 3;
      goto REPEATNOTCHAR;

    case OP_NOTUPTO:
    case OP_NOTMINUPTO:
      min = 0;
      max = GET2(ecode, 1);
      minimize = *ecode == OP_NOTMINUPTO;
      ecode += 3;
      goto REPEATNOTCHAR;

    case OP_NOTSTAR:
    case OP_NOTMINSTAR:
    case OP_NOTPLUS:
    case OP_NOTMINPLUS:
    case OP_NOTQUERY:
    case OP_NOTMINQUERY:
      c = *ecode++ - OP_NOTSTAR;
      minimize = (c & 1) != 0;
      min = rep_min[c];		/* Pick up values from tables; */
      max = rep_max[c];		/* zero for max => infinity */
      if (max == 0)
	max = INT_MAX;

      /* Common code for all repeated single-character (less than 255) matches.
         We can give up quickly if there are fewer than the minimum number of
         characters left in the subject. */

    REPEATNOTCHAR:
      if (min > md->end_subject - eptr)
	RRETURN(MATCH_NOMATCH);
      fc = *ecode++;

      /* The code is duplicated for the caseless and caseful cases, for speed,
         since matching characters is likely to be quite common. First, ensure the
         minimum number of matches are present. If min = max, continue at the same
         level without recursing. Otherwise, if minimizing, keep trying the rest of
         the expression and advancing one matching character if failing, up to the
         maximum. Alternatively, if maximizing, find the maximum number of
         characters and work backwards. */

      DPRINTF(("negative matching %c{%d,%d} against subject %.*s\n", fc, min,
	       max, max, eptr));

      if ((ims & PCRE_CASELESS) != 0) {
	fc = md->lcc[fc];


	/* Not UTF-8 mode */
	{
	  for (i = 1; i <= min; i++)
	    if (fc == md->lcc[*eptr++])
	      RRETURN(MATCH_NOMATCH);
	}

	if (min == max)
	  continue;

	if (minimize) {
	  /* Not UTF-8 mode */
	  {
	    for (fi = min;; fi++) {
	      RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
	      if (rrc != MATCH_NOMATCH)
		RRETURN(rrc);
	      if (fi >= max || eptr >= md->end_subject
		  || fc == md->lcc[*eptr++])
		RRETURN(MATCH_NOMATCH);
	    }
	  }
	  /* Control never gets here */
	}

	/* Maximize case */

	else {
	  pp = eptr;

	  /* Not UTF-8 mode */
	  {
	    for (i = min; i < max; i++) {
	      if (eptr >= md->end_subject || fc == md->lcc[*eptr])
		break;
	      eptr++;
	    }
	    while (eptr >= pp) {
	      RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
	      if (rrc != MATCH_NOMATCH)
		RRETURN(rrc);
	      eptr--;
	    }
	  }

	  RRETURN(MATCH_NOMATCH);
	}
	/* Control never gets here */
      }

      /* Caseful comparisons */

      else {
	/* Not UTF-8 mode */
	{
	  for (i = 1; i <= min; i++)
	    if (fc == *eptr++)
	      RRETURN(MATCH_NOMATCH);
	}

	if (min == max)
	  continue;

	if (minimize) {
	  /* Not UTF-8 mode */
	  {
	    for (fi = min;; fi++) {
	      RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
	      if (rrc != MATCH_NOMATCH)
		RRETURN(rrc);
	      if (fi >= max || eptr >= md->end_subject || fc == *eptr++)
		RRETURN(MATCH_NOMATCH);
	    }
	  }
	  /* Control never gets here */
	}

	/* Maximize case */

	else {
	  pp = eptr;

	  /* Not UTF-8 mode */
	  {
	    for (i = min; i < max; i++) {
	      if (eptr >= md->end_subject || fc == *eptr)
		break;
	      eptr++;
	    }
	    while (eptr >= pp) {
	      RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
	      if (rrc != MATCH_NOMATCH)
		RRETURN(rrc);
	      eptr--;
	    }
	  }

	  RRETURN(MATCH_NOMATCH);
	}
      }
      /* Control never gets here */

      /* Match a single character type repeatedly; several different opcodes
         share code. This is very similar to the code for single characters, but we
         repeat it in the interests of efficiency. */

    case OP_TYPEEXACT:
      min = max = GET2(ecode, 1);
      minimize = TRUE;
      ecode += 3;
      goto REPEATTYPE;

    case OP_TYPEUPTO:
    case OP_TYPEMINUPTO:
      min = 0;
      max = GET2(ecode, 1);
      minimize = *ecode == OP_TYPEMINUPTO;
      ecode += 3;
      goto REPEATTYPE;

    case OP_TYPESTAR:
    case OP_TYPEMINSTAR:
    case OP_TYPEPLUS:
    case OP_TYPEMINPLUS:
    case OP_TYPEQUERY:
    case OP_TYPEMINQUERY:
      c = *ecode++ - OP_TYPESTAR;
      minimize = (c & 1) != 0;
      min = rep_min[c];		/* Pick up values from tables; */
      max = rep_max[c];		/* zero for max => infinity */
      if (max == 0)
	max = INT_MAX;

      /* Common code for all repeated single character type matches. Note that
         in UTF-8 mode, '.' matches a character of any length, but for the other
         character types, the valid characters are all one-byte long. */

    REPEATTYPE:
      ctype = *ecode++;		/* Code for the character type */

      /* First, ensure the minimum number of matches are present. Use inline
         code for maximizing the speed, and do the type test once at the start
         (i.e. keep it out of the loop). Also we can test that there are at least
         the minimum number of bytes before we start. This isn't as effective in
         UTF-8 mode, but it does no harm. Separate the UTF-8 code completely as that
         is tidier. */

      if (min > md->end_subject - eptr)
	RRETURN(MATCH_NOMATCH);
      if (min > 0) {

	/* Code for the non-UTF-8 case for minimum matching */

	switch (ctype) {
	case OP_ANY:
	  if ((ims & PCRE_DOTALL) == 0) {
	    for (i = 1; i <= min; i++)
	      if (*eptr++ == NEWLINE)
		RRETURN(MATCH_NOMATCH);
	  } else
	    eptr += min;
	  break;

	case OP_ANYBYTE:
	  eptr += min;
	  break;

	case OP_NOT_DIGIT:
	  for (i = 1; i <= min; i++)
	    if ((md->ctypes[*eptr++] & ctype_digit) != 0)
	      RRETURN(MATCH_NOMATCH);
	  break;

	case OP_DIGIT:
	  for (i = 1; i <= min; i++)
	    if ((md->ctypes[*eptr++] & ctype_digit) == 0)
	      RRETURN(MATCH_NOMATCH);
	  break;

	case OP_NOT_WHITESPACE:
	  for (i = 1; i <= min; i++)
	    if ((md->ctypes[*eptr++] & ctype_space) != 0)
	      RRETURN(MATCH_NOMATCH);
	  break;

	case OP_WHITESPACE:
	  for (i = 1; i <= min; i++)
	    if ((md->ctypes[*eptr++] & ctype_space) == 0)
	      RRETURN(MATCH_NOMATCH);
	  break;

	case OP_NOT_WORDCHAR:
	  for (i = 1; i <= min; i++)
	    if ((md->ctypes[*eptr++] & ctype_word) != 0)
	      RRETURN(MATCH_NOMATCH);
	  break;

	case OP_WORDCHAR:
	  for (i = 1; i <= min; i++)
	    if ((md->ctypes[*eptr++] & ctype_word) == 0)
	      RRETURN(MATCH_NOMATCH);
	  break;
	}
      }

      /* If min = max, continue at the same level without recursing */

      if (min == max)
	continue;

      /* If minimizing, we have to test the rest of the pattern before each
         subsequent match. Again, separate the UTF-8 case for speed. */

      if (minimize) {
	/* Not UTF-8 mode */
	{
	  for (fi = min;; fi++) {
	    RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
	    if (rrc != MATCH_NOMATCH)
	      RRETURN(rrc);
	    if (fi >= max || eptr >= md->end_subject)
	      RRETURN(MATCH_NOMATCH);
	    c = *eptr++;
	    switch (ctype) {
	    case OP_ANY:
	      if ((ims & PCRE_DOTALL) == 0 && c == NEWLINE)
		RRETURN(MATCH_NOMATCH);
	      break;

	    case OP_ANYBYTE:
	      break;

	    case OP_NOT_DIGIT:
	      if ((md->ctypes[c] & ctype_digit) != 0)
		RRETURN(MATCH_NOMATCH);
	      break;

	    case OP_DIGIT:
	      if ((md->ctypes[c] & ctype_digit) == 0)
		RRETURN(MATCH_NOMATCH);
	      break;

	    case OP_NOT_WHITESPACE:
	      if ((md->ctypes[c] & ctype_space) != 0)
		RRETURN(MATCH_NOMATCH);
	      break;

	    case OP_WHITESPACE:
	      if ((md->ctypes[c] & ctype_space) == 0)
		RRETURN(MATCH_NOMATCH);
	      break;

	    case OP_NOT_WORDCHAR:
	      if ((md->ctypes[c] & ctype_word) != 0)
		RRETURN(MATCH_NOMATCH);
	      break;

	    case OP_WORDCHAR:
	      if ((md->ctypes[c] & ctype_word) == 0)
		RRETURN(MATCH_NOMATCH);
	      break;
	    }
	  }
	}
	/* Control never gets here */
      }

      /* If maximizing it is worth using inline code for speed, doing the type
         test once at the start (i.e. keep it out of the loop). Again, keep the
         UTF-8 stuff separate. */

      else {
	pp = eptr;


	/* Not UTF-8 mode */
	{
	  switch (ctype) {
	  case OP_ANY:
	    if ((ims & PCRE_DOTALL) == 0) {
	      for (i = min; i < max; i++) {
		if (eptr >= md->end_subject || *eptr == NEWLINE)
		  break;
		eptr++;
	      }
	      break;
	    }
	    /* For DOTALL case, fall through and treat as \C */

	  case OP_ANYBYTE:
	    c = max - min;
	    if (c > md->end_subject - eptr)
	      c = md->end_subject - eptr;
	    eptr += c;
	    break;

	  case OP_NOT_DIGIT:
	    for (i = min; i < max; i++) {
	      if (eptr >= md->end_subject
		  || (md->ctypes[*eptr] & ctype_digit) != 0)
		break;
	      eptr++;
	    }
	    break;

	  case OP_DIGIT:
	    for (i = min; i < max; i++) {
	      if (eptr >= md->end_subject
		  || (md->ctypes[*eptr] & ctype_digit) == 0)
		break;
	      eptr++;
	    }
	    break;

	  case OP_NOT_WHITESPACE:
	    for (i = min; i < max; i++) {
	      if (eptr >= md->end_subject
		  || (md->ctypes[*eptr] & ctype_space) != 0)
		break;
	      eptr++;
	    }
	    break;

	  case OP_WHITESPACE:
	    for (i = min; i < max; i++) {
	      if (eptr >= md->end_subject
		  || (md->ctypes[*eptr] & ctype_space) == 0)
		break;
	      eptr++;
	    }
	    break;

	  case OP_NOT_WORDCHAR:
	    for (i = min; i < max; i++) {
	      if (eptr >= md->end_subject
		  || (md->ctypes[*eptr] & ctype_word) != 0)
		break;
	      eptr++;
	    }
	    break;

	  case OP_WORDCHAR:
	    for (i = min; i < max; i++) {
	      if (eptr >= md->end_subject
		  || (md->ctypes[*eptr] & ctype_word) == 0)
		break;
	      eptr++;
	    }
	    break;
	  }

	  /* eptr is now past the end of the maximum run */

	  while (eptr >= pp) {
	    RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
	    eptr--;
	    if (rrc != MATCH_NOMATCH)
	      RRETURN(rrc);
	  }
	}

	/* Get here if we can't make it match with any permitted repetitions */

	RRETURN(MATCH_NOMATCH);
      }
      /* Control never gets here */

      /* There's been some horrible disaster. Since all codes > OP_BRA are
         for capturing brackets, and there shouldn't be any gaps between 0 and
         OP_BRA, arrival here can only mean there is something seriously wrong
         in the code above or the OP_xxx definitions. */

    default:
      DPRINTF(("Unknown opcode %d\n", *ecode));
      RRETURN(PCRE_ERROR_UNKNOWN_NODE);
    }

    /* Do not stick any code in here without much thought; it is assumed
       that "continue" in the code above comes out to here to repeat the main
       loop. */

  }				/* End of main loop */
/* Control never reaches here */
}


/***************************************************************************
****************************************************************************
                   RECURSION IN THE match() FUNCTION

Undefine all the macros that were defined above to handle this. */

#ifdef NO_RECURSE
#undef eptr
#undef ecode
#undef offset_top
#undef ims
#undef eptrb
#undef flags

#undef callpat
#undef charptr
#undef data
#undef lastptr
#undef next
#undef pp
#undef prev
#undef saved_eptr

#undef new_recursive

#undef cur_is_word
#undef condition
#undef minimize
#undef prev_is_word

#undef original_ims

#undef ctype
#undef length
#undef max
#undef min
#undef number
#undef offset
#undef op
#undef save_capture_last
#undef save_offset1
#undef save_offset2
#undef save_offset3
#undef stacksave

#undef newptrb

#endif

/* These two are defined as macros in both cases */

#undef fc
#undef fi

/***************************************************************************
***************************************************************************/



/*************************************************
*         Execute a Regular Expression           *
*************************************************/

/* This function applies a compiled re to a subject string and picks out
portions of the string if it matches. Two elements in the vector are set for
each substring: the offsets to the start and end of the substring.

Arguments:
  external_re     points to the compiled expression
  extra_data      points to extra data or is NULL
  subject         points to the subject string
  length          length of subject string (may contain binary zeros)
  start_offset    where to start in the subject string
  options         option bits
  offsets         points to a vector of ints to be filled in with offsets
  offsetcount     the number of elements in the vector

Returns:          > 0 => success; value is the number of elements filled in
                  = 0 => success, but offsets is not big enough
                   -1 => failed to match
                 < -1 => some kind of unexpected problem
*/

EXPORT int
pcre_exec(const pcre * external_re, const pcre_extra * extra_data,
	  const char *subject, int length, int start_offset, int options,
	  int *offsets, int offsetcount)
{
  int rc, resetcount, ocount;
  int first_byte = -1;
  int req_byte = -1;
  int req_byte2 = -1;
  unsigned long int ims = 0;
  BOOL using_temporary_offsets = FALSE;
  BOOL anchored;
  BOOL startline;
  BOOL first_byte_caseless = FALSE;
  BOOL req_byte_caseless = FALSE;
  match_data match_block;
  const uschar *start_bits = NULL;
  const uschar *start_match = (const uschar *) subject + start_offset;
  const uschar *end_subject;
  const uschar *req_byte_ptr = start_match - 1;
  const pcre_study_data *study;
  const real_pcre *re = (const real_pcre *) external_re;

/* Plausibility checks */

  if ((options & ~PUBLIC_EXEC_OPTIONS) != 0)
    return PCRE_ERROR_BADOPTION;
  if (re == NULL || subject == NULL || (offsets == NULL && offsetcount > 0))
    return PCRE_ERROR_NULL;

/* Fish out the optional data from the extra_data structure, first setting
the default values. */

  study = NULL;
  match_block.match_limit = MATCH_LIMIT;
  match_block.callout_data = NULL;

  if (extra_data != NULL) {
    register unsigned int flags = extra_data->flags;
    if ((flags & PCRE_EXTRA_STUDY_DATA) != 0)
      study = (const pcre_study_data *) extra_data->study_data;
    if ((flags & PCRE_EXTRA_MATCH_LIMIT) != 0)
      match_block.match_limit = extra_data->match_limit;
    if ((flags & PCRE_EXTRA_CALLOUT_DATA) != 0)
      match_block.callout_data = extra_data->callout_data;
  }

/* Now we have re supposedly pointing to the regex */

  if (re->magic_number != MAGIC_NUMBER)
    return PCRE_ERROR_BADMAGIC;

  anchored = ((re->options | options) & PCRE_ANCHORED) != 0;
  startline = (re->options & PCRE_STARTLINE) != 0;

  match_block.start_code =
    (const uschar *) re + sizeof(real_pcre) +
    re->name_count * re->name_entry_size;
  match_block.start_subject = (const uschar *) subject;
  match_block.start_offset = start_offset;
  match_block.end_subject = match_block.start_subject + length;
  end_subject = match_block.end_subject;

  match_block.endonly = (re->options & PCRE_DOLLAR_ENDONLY) != 0;
  match_block.utf8 = (re->options & PCRE_UTF8) != 0;

  match_block.notbol = (options & PCRE_NOTBOL) != 0;
  match_block.noteol = (options & PCRE_NOTEOL) != 0;
  match_block.notempty = (options & PCRE_NOTEMPTY) != 0;

  match_block.recursive = NULL;	/* No recursion at top level */

  match_block.lcc = re->tables + lcc_offset;
  match_block.ctypes = re->tables + ctypes_offset;


/* The ims options can vary during the matching as a result of the presence
of (?ims) items in the pattern. They are kept in a local variable so that
restoring at the exit of a group is easy. */

  ims = re->options & (PCRE_CASELESS | PCRE_MULTILINE | PCRE_DOTALL);

/* If the expression has got more back references than the offsets supplied can
hold, we get a temporary bit of working store to use during the matching.
Otherwise, we can use the vector supplied, rounding down its size to a multiple
of 3. */

  ocount = offsetcount - (offsetcount % 3);

  if (re->top_backref > 0 && re->top_backref >= ocount / 3) {
    ocount = re->top_backref * 3 + 3;
    match_block.offset_vector = (int *) malloc(ocount * sizeof(int));
    if (match_block.offset_vector == NULL)
      return PCRE_ERROR_NOMEMORY;
    using_temporary_offsets = TRUE;
    DPRINTF(("Got memory to hold back references\n"));
  } else
    match_block.offset_vector = offsets;

  match_block.offset_end = ocount;
  match_block.offset_max = (2 * ocount) / 3;
  match_block.offset_overflow = FALSE;
  match_block.capture_last = -1;

/* Compute the minimum number of offsets that we need to reset each time. Doing
this makes a huge difference to execution time when there aren't many brackets
in the pattern. */

  resetcount = 2 + re->top_bracket * 2;
  if (resetcount > offsetcount)
    resetcount = ocount;

/* Reset the working variable associated with each extraction. These should
never be used unless previously set, but they get saved and restored, and so we
initialize them to avoid reading uninitialized locations. */

  if (match_block.offset_vector != NULL) {
    register int *iptr = match_block.offset_vector + ocount;
    register int *iend = iptr - resetcount / 2 + 1;
    while (--iptr >= iend)
      *iptr = -1;
  }

/* Set up the first character to match, if available. The first_byte value is
never set for an anchored regular expression, but the anchoring may be forced
at run time, so we have to test for anchoring. The first char may be unset for
an unanchored pattern, of course. If there's no first char and the pattern was
studied, there may be a bitmap of possible first characters. */

  if (!anchored) {
    if ((re->options & PCRE_FIRSTSET) != 0) {
      first_byte = re->first_byte & 255;
      if ((first_byte_caseless =
	   ((re->first_byte & REQ_CASELESS) != 0)) == TRUE)
	first_byte = match_block.lcc[first_byte];
    } else
      if (!startline && study != NULL &&
	  (study->options & PCRE_STUDY_MAPPED) != 0)
      start_bits = study->start_bits;
  }

/* For anchored or unanchored matches, there may be a "last known required
character" set. */

  if ((re->options & PCRE_REQCHSET) != 0) {
    req_byte = re->req_byte & 255;
    req_byte_caseless = (re->req_byte & REQ_CASELESS) != 0;
    req_byte2 = (re->tables + fcc_offset)[req_byte];	/* case flipped */
  }

/* Loop for handling unanchored repeated matching attempts; for anchored regexs
the loop runs just once. */

  do {
    register int *iptr = match_block.offset_vector;
    register int *iend = iptr + resetcount;

    /* Reset the maximum number of extractions we might see. */

    while (iptr < iend)
      *iptr++ = -1;

    /* Advance to a unique first char if possible */

    if (first_byte >= 0) {
      if (first_byte_caseless)
	while (start_match < end_subject &&
	       match_block.lcc[*start_match] != first_byte)
	  start_match++;
      else
	while (start_match < end_subject && *start_match != first_byte)
	  start_match++;
    }

    /* Or to just after \n for a multiline match if possible */

    else if (startline) {
      if (start_match > match_block.start_subject + start_offset) {
	while (start_match < end_subject && start_match[-1] != NEWLINE)
	  start_match++;
      }
    }

    /* Or to a non-unique first char after study */

    else if (start_bits != NULL) {
      while (start_match < end_subject) {
	register int c = *start_match;
	if ((start_bits[c / 8] & (1 << (c & 7))) == 0)
	  start_match++;
	else
	  break;
      }
    }

    /* If req_byte is set, we know that that character must appear in the subject
       for the match to succeed. If the first character is set, req_byte must be
       later in the subject; otherwise the test starts at the match point. This
       optimization can save a huge amount of backtracking in patterns with nested
       unlimited repeats that aren't going to match. Writing separate code for
       cased/caseless versions makes it go faster, as does using an autoincrement
       and backing off on a match.

       HOWEVER: when the subject string is very, very long, searching to its end can
       take a long time, and give bad performance on quite ordinary patterns. This
       showed up when somebody was matching /^C/ on a 32-megabyte string... so we
       don't do this when the string is sufficiently long. */

    if (req_byte >= 0 && end_subject - start_match < REQ_BYTE_MAX) {
      register const uschar *p = start_match + ((first_byte >= 0) ? 1 : 0);

      /* We don't need to repeat the search if we haven't yet reached the
         place we found it at last time. */

      if (p > req_byte_ptr) {
	if (req_byte_caseless) {
	  while (p < end_subject) {
	    register int pp = *p++;
	    if (pp == req_byte || pp == req_byte2) {
	      p--;
	      break;
	    }
	  }
	} else {
	  while (p < end_subject) {
	    if (*p++ == req_byte) {
	      p--;
	      break;
	    }
	  }
	}

	/* If we can't find the required character, break the matching loop */

	if (p >= end_subject)
	  break;

	/* If we have found the required character, save the point where we
	   found it, so that we don't search again next time round the loop if
	   the start hasn't passed this character yet. */

	req_byte_ptr = p;
      }
    }

    /* When a match occurs, substrings will be set for all internal extractions;
       we just need to set up the whole thing as substring 0 before returning. If
       there were too many extractions, set the return code to zero. In the case
       where we had to get some local store to hold offsets for backreferences, copy
       those back references that we can. In this case there need not be overflow
       if certain parts of the pattern were not used. */

    match_block.start_match = start_match;
    match_block.match_call_count = 0;

    rc = match(start_match, match_block.start_code, 2, &match_block, ims, NULL,
	       match_isgroup);

    if (rc == MATCH_NOMATCH) {
      start_match++;
      continue;
    }

    if (rc != MATCH_MATCH) {
      DPRINTF((">>>> error: returning %d\n", rc));
      return rc;
    }

    /* We have a match! Copy the offset information from temporary store if
       necessary */

    if (using_temporary_offsets) {
      if (offsetcount >= 4) {
	memcpy(offsets + 2, match_block.offset_vector + 2,
	       (offsetcount - 2) * sizeof(int));
	DPRINTF(("Copied offsets from temporary memory\n"));
      }
      if (match_block.end_offset_top > offsetcount)
	match_block.offset_overflow = TRUE;

      DPRINTF(("Freeing temporary memory\n"));
      free(match_block.offset_vector);
    }

    rc = match_block.offset_overflow ? 0 : match_block.end_offset_top / 2;

    if (offsetcount < 2)
      rc = 0;
    else {
      offsets[0] = start_match - match_block.start_subject;
      offsets[1] = match_block.end_match_ptr - match_block.start_subject;
    }

    DPRINTF((">>>> returning %d\n", rc));
    return rc;
  }

/* This "while" is the end of the "do" above */

  while (!anchored && start_match <= end_subject);

  if (using_temporary_offsets) {
    DPRINTF(("Freeing temporary memory\n"));
    free(match_block.offset_vector);
  }

  DPRINTF((">>>> returning PCRE_ERROR_NOMATCH\n"));

  return PCRE_ERROR_NOMATCH;
}

/* End of pcre.c */