Source

XEmacs / etc / LNEWS

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
This is Info file LNEWS, produced by Makeinfo-1.55 from the input file
news.texi.

   This file describes the new Lisp features of Emacs version 19 as
first released to the public.  For Lisp changes in subsequent Emacs 19
releases, see the file NEWS.

New Features in the Lisp Language
=================================

   * The new function `delete' is a traditional Lisp function.  It takes
     two arguments, ELT and LIST, and deletes from LIST any elements
     that are equal to ELT.  It uses the function `equal' to compare
     elements with ELT.

   * The new function `member' is a traditional Lisp function.  It takes
     two arguments, ELT and LIST, and finds the first element of LIST
     that is equal to ELT.  It uses the function `equal' to compare
     each list element with ELT.

     The value is a sublist of LIST, whose first element is the one
     that was found.  If no matching element is found, the value is
     `nil'.

   * The new function `indirect-function' finds the effective function
     definition of an object called as a function.  If the object is a
     symbol, `indirect-function' looks in the function definition of the
     symbol.  It keeps doing this until it finds something that is not a
     symbol.

   * There are new escape sequences for use in character and string
     constants.  The escape sequence `\a' is equivalent to `\C-g', the
     ASCII BEL character (code 7).  The escape sequence `\x' followed
     by a hexidecimal number represents the character whose ASCII code
     is that number.  There is no limit on the number of digits in the
     hexidecimal value.

   * The function `read' when reading from a buffer now does not skip a
     terminator character that terminates a symbol.  It leaves that
     character to be read (or just skipped, if it is whitespace) next
     time.

   * When you use a function FUNCTION as the input stream for `read',
     it is usually called with no arguments, and should return the next
     character.  In Emacs 19, sometimes FUNCTION is called with one
     argument (always a character).  When that happens, FUNCTION should
     save the argument and arrange to return it when called next time.

   * `random' with integer argument N returns a random number between 0
     and N-1.

   * The functions `documentation' and `documentation-property' now
     take an additional optional argument which, if non-`nil', says to
     refrain from calling `substitute-command-keys'.  This way, you get
     the exact text of the documentation string as written, without the
     usual substitutions.  Make sure to call `substitute-command-keys'
     yourself if you decide to display the string.

   * The new function `invocation-name' returns as a string the program
     name that was used to run Emacs, with any directory names
     discarded.

   * The new function `map-y-or-n-p' makes it convenient to ask a series
     of similar questions.  The arguments are PROMPTER, ACTOR, LIST,
     and optional HELP.

     The value of LIST is a list of objects, or a function of no
     arguments to return either the next object or `nil' meaning there
     are no more.

     The argument PROMPTER specifies how to ask each question.  If
     PROMPTER is a string, the question text is computed like this:

          (format PROMPTER OBJECT)

     where OBJECT is the next object to ask about.

     If not a string, PROMPTER should be a function of one argument
     (the next object to ask about) and should return the question text.

     The argument ACTOR should be a function of one argument, which is
     called with each object that the user says yes for.  Its argument
     is always one object from LIST.

     If HELP is given, it is a list `(OBJECT OBJECTS ACTION)', where
     OBJECT is a string containing a singular noun that describes the
     objects conceptually being acted on; OBJECTS is the corresponding
     plural noun and ACTION is a transitive verb describing ACTOR.  The
     default is `("object" "objects" "act on")'.

     Each time a question is asked, the user may enter `y', `Y', or SPC
     to act on that object; `n', `N', or DEL to skip that object; `!'
     to act on all following objects; ESC or `q' to exit (skip all
     following objects); `.' (period) to act on the current object and
     then exit; or `C-h' to get help.

     `map-y-or-n-p' returns the number of objects acted on.

   * You can now "set" environment variables with the `setenv' command.
     This works by setting the variable `process-environment', which
     `getenv' now examines in preference to the environment Emacs
     received from its parent.

New Features for Loading Libraries
==================================

   You can now arrange to run a hook if a particular Lisp library is
loaded.

   The variable `after-load-alist' is an alist of expressions to be
evalled when particular files are loaded.  Each element looks like
`(FILENAME FORMS...)'.

   When `load' is run and the file name argument equals FILENAME, the
FORMS in the corresponding element are executed at the end of loading.
fILENAME must match exactly!  Normally FILENAME is the name of a
library, with no directory specified, since that is how `load' is
normally called.

   An error in FORMS does not undo the load, but does prevent execution
of the rest of the FORMS.

   The function `eval-after-load' provides a convenient way to add
entries to the alist.  Call it with two arguments, FILE and a form to
execute.

   The function `autoload' now supports autoloading a keymap.  Use
`keymap' as the fourth argument if the autoloaded function will become
a keymap when loaded.

   There is a new feature for specifying which functions in a library
should be autoloaded by writing special "magic" comments in that
library itself.

   Write `;;;###autoload' on a line by itself before the real
definition of the function, in its autoloadable source file; then the
command `M-x update-file-autoloads' automatically puts the `autoload'
call into `loaddefs.el'.

   You can also put other kinds of forms into `loaddefs.el', by writing
`;;;###autoload' followed on the same line by the form.  `M-x
update-file-autoloads' copies the form from that line.

Compilation Features
====================

   * Inline functions.

     You can define an "inline function" with `defsubst'.  Use
     `defsubst' just like `defun', and it defines a function which you
     can call in all the usual ways.  Whenever the function thus defined
     is used in compiled code, the compiler will open code it.

     You can get somewhat the same effects with a macro, but a macro
     has the limitation that you can use it only explicitly; a macro
     cannot be called with `apply', `mapcar' and so on.  Also, it takes
     some work to convert an ordinary function into a macro.  To
     convert it into an inline function, simply replace `defun' with
     `defsubst'.

     Making a function inline makes explicit calls run faster.  But it
     also has disadvantages.  For one thing, it reduces flexibility; if
     you change the definition of the function, calls already inlined
     still use the old definition until you recompile them.

     Another disadvantage is that making a large function inline can
     increase the size of compiled code both in files and in memory.
     Since the advantages of inline functions are greatest for small
     functions, you generally should not make large functions inline.

     Inline functions can be used and open coded later on in the same
     file, following the definition, just like macros.

   * The command `byte-compile-file' now offers to save any buffer
     visiting the file you are compiling.

   * The new command `compile-defun' reads, compiles and executes the
     defun containing point.  If you use this on a defun that is
     actually a function definition, the effect is to install a
     compiled version of that function.

   * Whenever you load a Lisp file or library, you now receive a
     warning if the directory contains both a `.el' file and a `.elc'
     file, and the `.el' file is newer.  This typically indicates that
     someone has updated the Lisp code but forgotten to recompile it,
     so the changes do not take effect.  The warning is a reminder to
     recompile.

   * The special form `eval-when-compile' marks the forms it contains to
     be evaluated at compile time *only*.  At top-level, this is
     analogous to the Common Lisp idiom `(eval-when (compile) ...)'.
     Elsewhere, it is similar to the Common Lisp `#.' reader macro (but
     not when interpreting).

     If you're thinking of using this feature, we recommend you
     consider whether `provide' and `require' might do the job as well.

   * The special form `eval-and-compile' is similar to
     `eval-when-compile', but the whole form is evaluated both at
     compile time and at run time.

     If you're thinking of using this feature, we recommend you consider
     whether `provide' and `require' might do the job as well.

   * Emacs Lisp has a new data type for byte-code functions.  This makes
     them faster to call, and also saves space.  Internally, a byte-code
     function object is much like a vector; however, the evaluator
     handles this data type specially when it appears as a function to
     be called.

     The printed representation for a byte-code function object is like
     that for a vector, except that it starts with `#' before the
     opening `['.  A byte-code function object must have at least four
     elements; there is no maximum number, but only the first six
     elements are actually used.  They are:

    ARGLIST
          The list of argument symbols.

    BYTE-CODE
          The string containing the byte-code instructions.

    CONSTANTS
          The vector of constants referenced by the byte code.

    STACKSIZE
          The maximum stack size this function needs.

    DOCSTRING
          The documentation string (if any); otherwise, `nil'.

    INTERACTIVE
          The interactive spec (if any).  This can be a string or a Lisp
          expression.  It is `nil' for a function that isn't
          interactive.

     The predicate `byte-code-function-p' tests whether a given object
     is a byte-code function.

     You can create a byte-code function object in a Lisp program with
     the function `make-byte-code'.  Its arguments are the elements to
     put in the byte-code function object.

     You should not try to come up with the elements for a byte-code
     function yourself, because if they are inconsistent, Emacs may
     crash when you call the function.  Always leave it to the byte
     compiler to create these objects; it, we hope, always makes the
     elements consistent.

Floating Point Numbers
======================

   You can now use floating point numbers in Emacs, if you define the
macro `LISP_FLOAT_TYPE' when you compile Emacs.

   The printed representation for floating point numbers requires
either a decimal point surrounded by digits, or an exponent, or both.
For example, `1500.0', `15e2', `15.0e2' and `1.5e3' are four ways of
writing a floating point number whose value is 1500.

   The existing predicate `numberp' now returns `t' if the argument is
any kind of number--either integer or floating.  The new predicates
`integerp' and `floatp' check for specific types of numbers.

   You can do arithmetic on floating point numbers with the ordinary
arithmetic functions, `+', `-', `*' and `/'.  If you call one of these
functions with both integers and floating point numbers among the
arguments, the arithmetic is done in floating point.  The same applies
to the numeric comparison functions such as `=' and `<'.  The remainder
function `%' does not accept floating point arguments, and neither do
the bitwise boolean operations such as `logand' or the shift functions
such as `ash'.

   There is a new arithmetic function, `abs', which returns the absolute
value of its argument.  It handles both integers and floating point
numbers.

   To convert an integer to floating point, use the function `float'.
There are four functions to convert floating point numbers to integers;
they differ in how they round.  `truncate' rounds toward 0, `floor'
rounds down, `ceil' rounds up, and `round' produces the nearest integer.

   You can use `logb' to extract the binary exponent of a floating
point number.  More precisely, it is the logarithm base 2, rounded down
to an integer.

   Emacs has several new mathematical functions that accept any kind of
number as argument, but always return floating point numbers.

`cos'
`sin'
`tan'
     Trigonometric functions.

`acos'
`asin'
`atan'
     Inverse trigonometric functions.

`exp'
     The exponential function (power of E).

`log'
     Logarithm base E.

`log10'
     Logarithm base 10

`expt'
     Raise X to power Y.

`sqrt'
     The square root function.

   The new function `string-to-number' now parses a string containing
either an integer or a floating point number, returning the number.

   The `format' function now handles the specifications `%e', `%f' and
`%g' for printing floating point numbers; likewise `message'.

   The new variable `float-output-format' controls how Lisp prints
floating point numbers.  Its value should be `nil' or a string.

   If it is a string, it should contain a `%'-spec like those accepted
by `printf' in C, but with some restrictions.  It must start with the
two characters `%.'.  After that comes an integer which is the
precision specification, and then a letter which controls the format.

   The letters allowed are `e', `f' and `g'.  Use `e' for exponential
notation (`DIG.DIGITSeEXPT').  Use `f' for decimal point notation
(`DIGITS.DIGITS').  Use `g' to choose the shorter of those two formats
for the number at hand.

   The precision in any of these cases is the number of digits following
the decimal point.  With `e', a precision of 0 means to omit the
decimal point.  0 is not allowed with `f' or `g'.

   A value of `nil' means to use the format `%.20g'.

   No matter what the value of `float-output-format', printing ensures
that the result fits the syntax rules for a floating point number.  If
it doesn't fit (for example, if it looks like an integer), it is
modified to fit.  By contrast, the `format' function formats floating
point numbers without requiring the output to fit the syntax rules for
floating point number.

New Features for Printing And Formatting Output
===============================================

   * The `format' function has a new feature: `%S'.  This print spec
     prints any kind of Lisp object, even a string, using its Lisp
     printed representation.

     By contrast, `%s' prints everything without quotation.

   * `prin1-to-string' now takes an optional second argument which says
     not to print the Lisp quotation characters.  (In other words, to
     use `princ' instead of `prin1'.)

   * The new variable `print-level' specifies the maximum depth of list
     nesting to print before cutting off all deeper structure.  A value
     of `nil' means no limit.

Changes in Basic Editing Functions
==================================

   * There are two new primitives for putting text in the kill ring:
     `kill-new' and `kill-append'.

     The function `kill-new' adds a string to the front of the kill
     ring.

     Use `kill-append' to add a string to a previous kill.  The second
     argument BEFORE-P, if non-`nil', says to add the string at the
     beginning; otherwise, it goes at the end.

     Both of these functions apply `interprogram-cut-function' to the
     entire string of killed text that ends up at the beginning of the
     kill ring.

   * The new function `current-kill' rotates the yanking pointer in the
     kill ring by N places, and returns the text at that place in the
     ring.  If the optional second argument DO-NOT-MOVE is non-`nil',
     it doesn't actually move the yanking point; it just returns the
     Nth kill forward.  If N is zero, indicating a request for the
     latest kill, `current-kill' calls `interprogram-paste-function'
     (documented below) before consulting the kill ring.

     All Emacs Lisp programs should either use `current-kill',
     `kill-new', and `kill-append' to manipulate the kill ring, or be
     sure to call `interprogram-paste-function' and
     `interprogram-cut-function' as appropriate.

   * The variables `interprogram-paste-function' and
     `interprogram-cut-function' exist so that you can provide functions
     to transfer killed text to and from other programs.

   * The `kill-region' function can now be used in read-only buffers.
     It beeps, but adds the region to the kill ring without deleting it.

   * The new function `compare-buffer-substrings' lets you compare two
     substrings of the same buffer or two different buffers.  Its
     arguments look like this:

          (compare-buffer-substrings BUF1 BEG1 END1 BUF2 BEG2 END2)

     The first three arguments specify one substring, giving a buffer
     and two positions within the buffer.  The last three arguments
     specify the other substring in the same way.

     The value is negative if the first substring is less, positive if
     the first is greater, and zero if they are equal.  The absolute
     value of the result is one plus the index of the first different
     characters.

   * Overwrite mode treats tab and newline characters specially.  You
     can now turn off this special treatment by setting
     `overwrite-binary-mode' to `t'.

   * Once the mark "exists" in a buffer, it normally never ceases to
     exist.  However, in Transient Mark mode, it may become "inactive".
     The variable `mark-active', which is always local in all buffers,
     indicates whether the mark is active: non-`nil' means yes.

     When the mark is inactive, the function `mark' normally gets an
     error.  However, `(mark t)' returns the position of the inactive
     mark.

     The function `push-mark' normally does not activate the mark.
     However, it accepts an optional third argument ACTIVATE which, if
     non-`nil', says to activate.

     A command can request deactivation of the mark upon return to the
     editor command loop by setting `deactivate-mark' to a non-`nil'
     value.  Transient Mark mode works by causing the command loop to
     take note of `deactivate-mark' and actually deactivate the mark.

     Transient Mark mode enables highlighting of the region when the
     mark is active.  This is currently implemented only under the X
     Window System.  A few other commands vary their behavior slightly
     in this case, by testing `transient-mark-mode'.  More
     specifically, they avoid special display actions such as moving
     the cursor temporarily, which are not needed when the region is
     shown by highlighting.

     The variables `activate-mark-hook' and `deactivate-mark-hook' are
     normal hooks run, respectively, when the mark becomes active and
     when it becomes inactive.  The hook `activate-mark-hook' is also
     run at the end of a command if the mark is active and the region
     may have changed.

   * The function `move-to-column' now accepts a second optional
     argument FORCE, in addition to COLUMN; if the requested column
     COLUMN is in the middle of a tab character and FORCE is non-`nil',
     `move-to-column' replaces the tab with the appropriate sequence of
     spaces so that it can place point exactly at COLUMN.

   * The search functions when successful now return the value of point
     rather than just `t'.  This affects the functions
     `search-forward', `search-backward', `word-search-forward',
     `word-search-backward', `re-search-forward', and
     `re-search-backward'.

   * When you do regular expression searching or matching, there is no
     longer a limit to how many `\(...\)' pairs you can get information
     about with `match-beginning' and `match-end'.  Also, these
     parenthetical groupings may now be nested to any degree.

   * In a regular expression, when you use an asterisk after a
     parenthetical grouping, and then ask about what range was matched
     by the grouping, Emacs 19 reports just its last occurrence.  Emacs
     18 used to report the range of all the repetitions put together.

     For example,

          (progn
           (string-match "f\\(o\\)*" "foo")
           (list (match-beginning 1)
                 (match-end 1)))

     returns `(2 3)' in Emacs 19, corresponding to just the last
     repetition of `\(o\)'.  In Emacs 18, that expression returns `(1
     3)', encompassing both repetitions.

     If you want the Emacs 18 behavior, use a grouping *containing* the
     asterisk: `"f\\(o*\\)"'.

   * The new special form `save-match-data' preserves the regular
     expression match status.  Usage: `(save-match-data BODY...)'.

   * The function `translate-region' applies a translation table to the
     characters in a part of the buffer.  Invoke it as
     `(translate-region START END TABLE)'; START and END bound the
     region to translate.

     The translation table TABLE is a string; `(aref TABLE OCHAR)'
     gives the translated character corresponding to OCHAR.  If the
     length of TABLE is less than 256, any characters with codes larger
     than the length of TABLE are not altered by the translation.

     `translate-region' returns the number of characters which were
     actually changed by the translation.  This does not count
     characters which were mapped into themselves in the translation
     table.

   * There are two new hook variables that let you notice all changes
     in all buffers (or in a particular buffer, if you make them
     buffer-local): `before-change-function' and
     `after-change-function'.

     If `before-change-function' is non-`nil', then it is called before
     any buffer modification.  Its arguments are the beginning and end
     of the region that is going to change, represented as integers.
     The buffer that's about to change is always the current buffer.

     If `after-change-function' is non-`nil', then it is called after
     any buffer modification.  It takes three arguments: the beginning
     and end of the region just changed, and the length of the text that
     existed before the change.  (To get the current length, subtract
     the region beginning from the region end.)  All three arguments are
     integers.  The buffer that has just changed is always the current
     buffer.

     Both of these variables are temporarily bound to `nil' during the
     time that either of these hooks is running.  This means that if
     one of these functions changes the buffer, that change won't run
     these functions.  If you do want hooks to be run recursively,
     write your hook functions to bind these variables back to their
     usual values.

   * The hook `first-change-hook' is run using `run-hooks' whenever a
     buffer is changed that was previously in the unmodified state.

   * The second argument to `insert-abbrev-table-description' is now
     optional.

Text Properties
===============

   Each character in a buffer or a string can have a "text property
list", much like the property list of a symbol.  The properties belong
to a particular character at a particular place, such as, the letter
`T' at the beginning of this sentence.  Each property has a name, which
is usually a symbol, and an associated value, which can be any Lisp
object--just as for properties of symbols.

   You can use the property `face' to control the font and color of
text.  Several other property names have special meanings.  You can
create properties of any name and examine them later for your own
purposes.

   Copying text between strings and buffers preserves the properties
along with the characters; this includes such diverse functions as
`substring', `insert', and `buffer-substring'.

   Since text properties are considered part of the buffer contents,
changing properties in a buffer "modifies" the buffer, and you can also
undo such changes.

   Strings with text properties have a special printed representation
which describes all the properties.  This representation is also the
read syntax for such a string.  It looks like this:

     #("CHARACTERS" PROPERTY-DATA...)

where PROPERTY-DATA is zero or more elements in groups of three as
follows:

     BEG END PLIST

The elements BEG and END are integers, and together specify a portion
of the string; PLIST is the property list for that portion.

Examining Text Properties
-------------------------

   The simplest way to examine text properties is to ask for the value
of a particular property of a particular character.  For that, use
`get-text-property'.  Use `text-properties-at' to get the entire
property list of a character.

   `(get-text-property POS PROP OBJECT)' returns the PROP property of
the character after POS in OBJECT (a buffer or string).  The argument
OBJECT is optional and defaults to the current buffer.

   `(text-properties-at POS OBJECT)' returns the entire property list
of the character after POS in the string or buffer OBJECT (which
defaults to the current buffer).

Changing Text Properties
------------------------

   There are four primitives for changing properties of a specified
range of text:

`add-text-properties'
     This function puts on specified properties, leaving other existing
     properties unaltered.

`put-text-property'
     This function puts on a single specified property, leaving others
     unaltered.

`remove-text-properties'
     This function removes specified properties, leaving other
     properties unaltered.

`set-text-properties'
     This function replaces the entire property list, leaving no
     vestige of the properties that that text used to have.

   All these functions take four arguments: START, END, PROPS, and
OBJECT.  The last argument is optional and defaults to the current
buffer.  The argument PROPS has the form of a property list.

Property Search Functions
-------------------------

   In typical use of text properties, most of the time several or many
consecutive characters have the same value for a property.  Rather than
writing your programs to examine characters one by one, it is much
faster to process chunks of text that have the same property value.

   The functions `next-property-change' and `previous-property-change'
scan forward or backward from position POS in OBJECT, looking for a
change in any property between two characters scanned.  They returns
the position between those two characters, or `nil' if no change is
found.

   The functions `next-single-property-change' and
`previous-single-property-change' are similar except that you specify a
particular property and they look for changes in the value of that
property only.  The property is the second argument, and OBJECT is
third.

Special Properties
------------------

   If a character has a `category' property, we call it the "category"
of the character.  It should be a symbol.  The properties of the symbol
serve as defaults for the properties of the character.

   You can use the property `face' to control the font and color of
text.

   You can specify a different keymap for a portion of the text by means
of a `local-map' property.  The property's value, for the character
after point, replaces the buffer's local map.

   If a character has the property `read-only', then modifying that
character is not allowed.  Any command that would do so gets an error.

   If a character has the property `modification-hooks', then its value
should be a list of functions; modifying that character calls all of
those functions.  Each function receives two arguments: the beginning
and end of the part of the buffer being modified.  Note that if a
particular modification hook function appears on several characters
being modified by a single primitive, you can't predict how many times
the function will be called.

   Insertion of text does not, strictly speaking, change any existing
character, so there is a special rule for insertion.  It compares the
`read-only' properties of the two surrounding characters; if they are
`eq', then the insertion is not allowed.  Assuming insertion is
allowed, it then gets the `modification-hooks' properties of those
characters and calls all the functions in each of them.  (If a function
appears on both characters, it may be called once or twice.)

   The special properties `point-entered' and `point-left' record hook
functions that report motion of point.  Each time point moves, Emacs
compares these two property values:

   * the `point-left' property of the character after the old location,
     and

   * the `point-entered' property of the character after the new
     location.

If these two values differ, each of them is called (if not `nil') with
two arguments: the old value of point, and the new one.

   The same comparison is made for the characters before the old and new
locations.  The result may be to execute two `point-left' functions
(which may be the same function) and/or two `point-entered' functions
(which may be the same function).  The `point-left' functions are
always called before the `point-entered' functions.

   A primitive function may examine characters at various positions
without moving point to those positions.  Only an actual change in the
value of point runs these hook functions.

New Features for Files
======================

   * The new function `file-accessible-directory-p' tells you whether
     you can open files in a particular directory.  Specify as an
     argument either a directory name or a file name which names a
     directory file.  The function returns `t' if you can open existing
     files in that directory.

   * The new function `file-executable-p' returns `t' if its argument
     is the name of a file you have permission to execute.

   * The function `file-truename' returns the "true name" of a
     specified file.  This is the name that you get by following
     symbolic links until none remain.  The argument must be an
     absolute file name.

   * New functions `make-directory' and `delete-directory' create and
     delete directories.  They both take one argument, which is the
     name of the directory as a file.

   * The function `read-file-name' now takes an additional argument
     which specifies an initial file name.  If you specify this
     argument, `read-file-name' inserts it along with the directory
     name.  It puts the cursor between the directory and the initial
     file name.

     The user can then use the initial file name unchanged, modify it,
     or simply kill it with `C-k'.

     If the variable `insert-default-directory' is `nil', then the
     default directory is not inserted, and the new argument is ignored.

   * The function `file-relative-name' does the inverse of
     expansion--it tries to return a relative name which is equivalent
     to FILENAME when interpreted relative to DIRECTORY.  (If such a
     relative name would be longer than the absolute name, it returns
     the absolute name instead.)

   * The function `file-newest-backup' returns the name of the most
     recent backup file for FILENAME, or `nil' that file has no backup
     files.

   * The list returned by `file-attributes' now has 12 elements.  The
     12th element is the file system number of the file system that the
     file is in.  This element together with the file's inode number,
     which is the 11th element, give enough information to distinguish
     any two files on the system--no two files can have the same values
     for both of these numbers.

   * The new function `set-visited-file-modtime' updates the current
     buffer's recorded modification time from the visited file's time.

     This is useful if the buffer was not read from the file normally,
     or if the file itself has been changed for some known benign
     reason.

     If you give the function an argument, that argument specifies the
     new value for the recorded modification time.  The argument should
     be a list of the form `(HIGH . LOW)' or `(HIGH LOW)' containing
     two integers, each of which holds 16 bits of the time.  (This is
     the same format that `file-attributes' uses to return time values.)

     The new function `visited-file-modtime' returns the recorded last
     modification time, in that same format.

   * The function `directory-files' now takes an optional fourth
     argument which, if non-`nil', inhibits sorting the file names.
     Use this if you want the utmost possible speed and don't care what
     order the files are processed in.

     If the order of processing is at all visible to the user, then the
     user will probably be happier if you do sort the names.

   * The variable `directory-abbrev-alist' contains an alist of
     abbreviations to use for file directories.  Each element has the
     form `(FROM . TO)', and says to replace FROM with TO when it
     appears in a directory name.  This replacement is done when
     setting up the default directory of a newly visited file.  The
     FROM string is actually a regular expression; it should always
     start with `^'.

     You can set this variable in `site-init.el' to describe the
     abbreviations appropriate for your site.

   * The function `abbreviate-file-name' applies abbreviations from
     `directory-abbrev-alist' to its argument, and substitutes `~' for
     the user's home directory.

     Abbreviated directory names are useful for directories that are
     normally accessed through symbolic links.  If you think of the
     link's name as "the name" of the directory, you can define it as
     an abbreviation for the directory's official name; then ordinarily
     Emacs will call that directory by the link name you normally use.

   * `write-region' can write a given string instead of text from the
     buffer.  Use the string as the first argument (in place of the
     starting character position).

     You can supply a second file name as the fifth argument (VISIT).
     Use this to write the data to one file (the first argument,
     FILENAME) while nominally visiting a different file (the fifth
     argument, VISIT).  The argument VISIT is used in the echo area
     message and also for file locking; VISIT is stored in
     `buffer-file-name'.

   * The value of `write-file-hooks' does not change when you switch to
     a new major mode.  The intention is that these hooks have to do
     with where the file came from, and not with what it contains.

   * There is a new hook variable for saving files:
     `write-contents-hooks'.  It works just like `write-file-hooks'
     except that switching to a new major mode clears it back to `nil'.
     Major modes should use this hook variable rather than
     `write-file-hooks'.

   * The hook `after-save-buffer-hook' runs just after a buffer has been
     saved in its visited file.

   * The new function `set-default-file-modes' sets the file protection
     for new files created with Emacs.  The argument must be an
     integer.  (It would be better to permit symbolic arguments like
     the `chmod' program, but that would take more work than this
     function merits.)

     Use the new function `default-file-modes' to read the current
     default file mode.

   * Call the new function `unix-sync' to force all pending disk output
     to happen as soon as possible.

Making Certain File Names "Magic"
=================================

   You can implement special handling for a class of file names.  You
must supply a regular expression to define the class of names (all those
which match the regular expression), plus a handler that implements all
the primitive Emacs file operations for file names that do match.

   The value of `file-name-handler-alist' is a list of handlers,
together with regular expressions that decide when to apply each
handler.  Each element has the form `(REGEXP . HANDLER)'.  If a file
name matches REGEXP, then all work on that file is done by calling
HANDLER.

   All the Emacs primitives for file access and file name transformation
check the given file name against `file-name-handler-alist', and call
HANDLER to do the work if appropriate.  The first argument given to
HANDLER is the name of the primitive; the remaining arguments are the
arguments that were passed to that primitive.  (The first of these
arguments is typically the file name itself.)  For example, if you do
this:

     (file-exists-p FILENAME)

and FILENAME has handler HANDLER, then HANDLER is called like this:

     (funcall HANDLER 'file-exists-p FILENAME)

   Here are the primitives that you can handle in this way:

     `add-name-to-file', `copy-file', `delete-directory',
     `delete-file', `directory-file-name', `directory-files',
     `dired-compress-file', `dired-uncache', `expand-file-name',
     `file-accessible-directory-p', `file-attributes',
     `file-directory-p', `file-executable-p', `file-exists-p',
     `file-local-copy', `file-modes', `file-name-all-completions',
     `file-name-as-directory', `file-name-completion',
     `file-name-directory', `file-name-nondirectory',
     `file-name-sans-versions', `file-newer-than-file-p',
     `file-readable-p', `file-symlink-p', `file-writable-p',
     `insert-directory', `insert-file-contents', `load',
     `make-directory', `make-symbolic-link', `rename-file',
     `set-file-modes', `set-visited-file-modtime',
     `unhandled-file-name-directory', `verify-visited-file-modtime',
     `write-region'.

   The handler function must handle all of the above operations, and
possibly others to be added in the future.  Therefore, it should always
reinvoke the ordinary Lisp primitive when it receives an operation it
does not recognize.  Here's one way to do this:

     (defun my-file-handler (operation &rest args)
       ;; First check for the specific operations
       ;; that we have special handling for.
       (cond ((eq operation 'insert-file-contents) ...)
             ((eq operation 'write-region) ...)
             ...
             ;; Handle any operation we don't know about.
             (t (let (file-name-handler-alist)
                  (apply operation args)))))

   The function `file-local-copy' copies file FILENAME to the local
site, if it isn't there already.  If FILENAME specifies a "magic" file
name which programs outside Emacs cannot directly read or write, this
copies the contents to an ordinary file and returns that file's name.

   If FILENAME is an ordinary file name, not magic, then this function
does nothing and returns `nil'.

   The function `unhandled-file-name-directory' is used to get a
non-magic directory name from an arbitrary file name.  It uses the
directory part of the specified file name if that is not magic.
Otherwise, it asks the file name's handler what to do.

Frames
======

   Emacs now supports multiple X windows via a new data type known as a
"frame".

   A frame is a rectangle on the screen that contains one or more Emacs
windows.  Subdividing a frame works just like subdividing the screen in
earlier versions of Emacs.

   There are two kinds of frames: terminal frames and X window frames.
Emacs creates one terminal frame when it starts up with no X display; it
uses Termcap or Terminfo to display using characters.  There is no way
to create another terminal frame after startup.  If Emacs has an X
display, it does not make a terminal frame, and there is none.

   When you are using X windows, Emacs starts out with a single X window
frame.  You can create any number of X window frames using `make-frame'.

   Use the predicate `framep' to determine whether a given Lisp object
is a frame.

   The function `redraw-frame' redisplays the entire contents of a
given frame.

Creating and Deleting Frames
----------------------------

   Use `make-frame' to create a new frame.  This is the only primitive
for creating frames.  In principle it could work under any window system
which Emacs understands; the only one we support is X.

   `make-frame' takes just one argument, which is an alist specifying
frame parameters.  Any parameters not mentioned in the argument alist
default based on the value of `default-frame-alist'; parameters not
specified there default from the standard X defaults file and X
resources.

   When you invoke Emacs, if you specify arguments for window appearance
and so forth, these go into `default-frame-alist' and that is how they
have their effect.

   You can specify the parameters for the initial startup X window
frame by setting `initial-frame-alist' in your `.emacs' file.  If these
parameters specify a separate minibuffer-only frame, and you have not
created one, Emacs creates one for you, using the parameter values
specified in `minibuffer-frame-alist'.

   You can specify the size and position of a frame using the frame
parameters `left', `top', `height' and `width'.  You must specify
either both size parameters or neither.  You must specify either both
position parameters or neither.  The geometry parameters that you don't
specify are chosen by the window manager in its usual fashion.

   The function `x-parse-geometry' converts a standard X-style geometry
string to an alist which you can use as part of the argument to
`make-frame'.

   Use the function `delete-frame' to eliminate a frame.  Frames are
like buffers where deletion is concerned; a frame actually continues to
exist as a Lisp object until it is deleted *and* there are no
references to it, but once it is deleted, it has no further effect on
the screen.

   The function `frame-live-p' returns non-`nil' if the argument (a
frame) has not been deleted.

Finding All Frames
------------------

   The function `frame-list' returns a list of all the frames that have
not been deleted.  It is analogous to `buffer-list'.  The list that you
get is newly created, so modifying the list doesn't have any effect on
the internals of Emacs.  The function `visible-frame-list' returns the
list of just the frames that are visible.

   `next-frame' lets you cycle conveniently through all the frames from
an arbitrary starting point.  Its first argument is a frame.  Its second
argument MINIBUF says what to do about minibuffers:

`nil'
     Exclude minibuffer-only frames.

a window
     Consider only the frames using that particular window as their
     minibuffer.

anything else
     Consider all frames.

Frames and Windows
------------------

   All the non-minibuffer windows in a frame are arranged in a tree of
subdivisions; the root of this tree is available via the function
`frame-root-window'.  Each window is part of one and only one frame;
you can get the frame with `window-frame'.

   At any time, exactly one window on any frame is "selected within the
frame".  You can get the frame's current selected window with
`frame-selected-window'.  The significance of this designation is that
selecting the frame selects for Emacs as a whole the window currently
selected within that frame.

   Conversely, selecting a window for Emacs with `select-window' also
makes that window selected within its frame.

Frame Visibility
----------------

   A frame may be "visible", "invisible", or "iconified".  If it is
invisible, it doesn't show in the screen, not even as an icon.  You can
set the visibility status of a frame with `make-frame-visible',
`make-frame-invisible', and `iconify-frame'.  You can examine the
visibility status with `frame-visible-p'--it returns `t' for a visible
frame, `nil' for an invisible frame, and `icon' for an iconified frame.

Selected Frame
--------------

   At any time, one frame in Emacs is the "selected frame".  The
selected window always resides on the selected frame.

 - Function: selected-frame
     This function returns the selected frame.

   The X server normally directs keyboard input to the X window that the
mouse is in.  Some window managers use mouse clicks or keyboard events
to "shift the focus" to various X windows, overriding the normal
behavior of the server.

   Lisp programs can switch frames "temporarily" by calling the function
`select-frame'.  This does not override the window manager; rather, it
escapes from the window manager's control until that control is somehow
reasserted.  The function takes one argument, a frame, and selects that
frame.  The selection lasts until the next time the user does something
to select a different frame, or until the next time this function is
called.

   Emacs cooperates with the X server and the window managers by
arranging to select frames according to what the server and window
manager ask for.  It does so by generating a special kind of input
event, called a "focus" event.  The command loop handles a focus event
by calling `internal-select-frame'.

Frame Size and Position
-----------------------

   The new functions `frame-height' and `frame-width' return the height
and width of a specified frame (or of the selected frame), measured in
characters.

   The new functions `frame-pixel-height' and `frame-pixel-width'
return the height and width of a specified frame (or of the selected
frame), measured in pixels.

   The new functions `frame-char-height' and `frame-char-width' return
the height and width of a character in a specified frame (or in the
selected frame), measured in pixels.

   `set-frame-size' sets the size of a frame, measured in characters;
its arguments are FRAME, COLS and ROWS.  To set the size with values
measured in pixels, you can use `modify-frame-parameters'.

   The function `set-frame-position' sets the position of the top left
corner of a frame.  Its arguments are FRAME, LEFT and TOP.

Frame Parameters
----------------

   A frame has many parameters that affect how it displays.  Use the
function `frame-parameters' to get an alist of all the parameters of a
given frame.  To alter parameters, use `modify-frame-parameters', which
takes two arguments: the frame to modify, and an alist of parameters to
change and their new values.  Each element of ALIST has the form `(PARM
. VALUE)', where PARM is a symbol.  Parameters that aren't meaningful
are ignored.  If you don't mention a parameter in ALIST, its value
doesn't change.

   Just what parameters a frame has depends on what display mechanism it
uses.  Here is a table of the parameters of an X window frame:

`name'
     The name of the frame.

`left'
     The screen position of the left edge.

`top'
     The screen position of the top edge.

`height'
     The height of the frame contents, in pixels.

`width'
     The width of the frame contents, in pixels.

`window-id'
     The number of the X window for the frame.

`minibuffer'
     Whether this frame has its own minibuffer.  `t' means yes, `none'
     means no, `only' means this frame is just a minibuffer, a
     minibuffer window (in some other frame) means the new frame uses
     that minibuffer.

`font'
     The name of the font for the text.

`foreground-color'
     The color to use for the inside of a character.  Use strings to
     designate colors; the X server defines the meaningful color names.

`background-color'
     The color to use for the background of text.

`mouse-color'
     The color for the mouse cursor.

`cursor-color'
     The color for the cursor that shows point.

`border-color'
     The color for the border of the frame.

`cursor-type'
     The way to display the cursor.  There are two legitimate values:
     `bar' and `box'.  The value `bar' specifies a vertical bar between
     characters as the cursor.  The value `box' specifies an ordinary
     black box overlaying the character after point; that is the
     default.

`icon-type'
     Non-`nil' for a bitmap icon, `nil' for a text icon.

`border-width'
     The width in pixels of the window border.

`internal-border-width'
     The distance in pixels between text and border.

`auto-raise'
     Non-`nil' means selecting the frame raises it.

`auto-lower'
     Non-`nil' means deselecting the frame lowers it.

`vertical-scroll-bars'
     Non-`nil' gives the frame a scroll bar for vertical scrolling.

Minibufferless Frames
---------------------

   Normally, each frame has its own minibuffer window at the bottom,
which is used whenever that frame is selected.  However, you can also
create frames with no minibuffers.  These frames must use the
minibuffer window of some other frame.

   The variable `default-minibuffer-frame' specifies where to find a
minibuffer for frames created without minibuffers of their own.  Its
value should be a frame which does have a minibuffer.

   You can also specify a minibuffer window explicitly when you create a
frame; then `default-minibuffer-frame' is not used.

X Window System Features
========================

   * The new functions `mouse-position' and `set-mouse-position' give
     access to the current position of the mouse.

     `mouse-position' returns a description of the position of the
     mouse.  The value looks like `(FRAME X . Y)', where X and Y are
     measured in pixels relative to the top left corner of the inside
     of FRAME.

     `set-mouse-position' takes three arguments, FRAME, X and Y, and
     warps the mouse cursor to that location on the screen.

   * `track-mouse' is a new special form for tracking mouse motion.
     Use it in definitions of mouse clicks that want pay to attention to
     the motion of the mouse, not just where the buttons are pressed and
     released.  Here is how to use it:

          (track-mouse BODY...)

     While BODY executes, mouse motion generates input events just as
     mouse clicks do.  BODY can read them with `read-event' or
     `read-key-sequence'.

     `track-mouse' returns the value of the last form in BODY.

     The format of these events is described under "New Input Event
     Formats."

   * `x-set-selection' sets a "selection" in the X server.  It takes
     two arguments: a selection type TYPE, and the value to assign to
     it, DATA.  If DATA is `nil', it means to clear out the selection.
     Otherwise, DATA may be a string, a symbol, an integer (or a cons
     of two integers or list of two integers), or a cons of two markers
     pointing to the same buffer.  In the last case, the selection is
     considered to be the text between the markers.  The data may also
     be a vector of valid non-vector selection values.

     Each possible TYPE has its own selection value, which changes
     independently.  The usual values of TYPE are `PRIMARY' and
     `SECONDARY'; these are symbols with upper-case names, in accord
     with X protocol conventions.  The default is `PRIMARY'.

     To get the value of the selection, call `x-get-selection'.  This
     function accesses selections set up by Emacs and those set up by
     other X clients.  It takes two optional arguments, TYPE and
     DATA-TYPE.  The default for TYPE is `PRIMARY'.

     The DATA-TYPE argument specifies the form of data conversion to
     use; meaningful values include `TEXT', `STRING', `TARGETS',
     `LENGTH', `DELETE', `FILE_NAME', `CHARACTER_POSITION',
     `LINE_NUMBER', `COLUMN_NUMBER', `OWNER_OS', `HOST_NAME', `USER',
     `CLASS', `NAME', `ATOM', and `INTEGER'.  (These are symbols with
     upper-case names in accord with X Windows conventions.) The
     default for DATA-TYPE is `STRING'.

   * The X server has a set of numbered "cut buffers" which can store
     text or other data being moved between applications.  Use
     `x-get-cut-buffer' to get the contents of a cut buffer; specify the
     cut buffer number as argument.  Use `x-set-cut-buffer' with
     argument STRING to store a new string into the first cut buffer
     (moving the other values down through the series of cut buffers,
     kill-ring-style).

     Cut buffers are considered obsolete, but Emacs supports them for
     the sake of X clients that still use them.

   * You can close the connection with the X server with the function
     `x-close-current-connection'.  This takes no arguments.

     Then you can connect to a different X server with
     `x-open-connection'.  The first argument, DISPLAY, is the name of
     the display to connect to.

     The optional second argument XRM-STRING is a string of resource
     names and values, in the same format used in the `.Xresources'
     file.  The values you specify override the resource values
     recorded in the X server itself.  Here's an example of what this
     string might look like:

          "*BorderWidth: 3\n*InternalBorder: 2\n"

   * A series of new functions give you information about the X server
     and the screen you are using.

    `x-display-screens'
          The number of screens associated with the current display.

    `x-server-version'
          The version numbers of the X server in use.

    `x-server-vendor'
          The vendor supporting the X server in use.

    `x-display-pixel-height'
          The height of this X screen in pixels.

    `x-display-mm-height'
          The height of this X screen in millimeters.

    `x-display-pixel-width'
          The width of this X screen in pixels.

    `x-display-mm-width'
          The width of this X screen in millimeters.

    `x-display-backing-store'
          The backing store capability of this screen.  Values can be
          the symbols `always', `when-mapped', or `not-useful'.

    `x-display-save-under'
          Non-`nil' if this X screen supports the SaveUnder feature.

    `x-display-planes'
          The number of planes this display supports.

    `x-display-visual-class'
          The visual class for this X screen.  The value is one of the
          symbols `static-gray', `gray-scale', `static-color',
          `pseudo-color', `true-color', and `direct-color'.

    `x-display-color-p'
          `t' if the X screen in use is a color screen.

    `x-display-color-cells'
          The number of color cells this X screen supports.

     There is also a variable `x-no-window-manager', whose value is `t'
     if no X window manager is in use.

   * The function `x-synchronize' enables or disables an X Windows
     debugging mode: synchronous communication.  It takes one argument,
     non-`nil' to enable the mode and `nil' to disable.

     In synchronous mode, Emacs waits for a response to each X protocol
     command before doing anything else.  This means that errors are
     reported right away, and you can directly find the erroneous
     command.  Synchronous mode is not the default because it is much
     slower.

   * The function `x-get-resource' retrieves a resource value from the X
     Windows defaults database.  Its three arguments are ATTRIBUTE,
     NAME and CLASS.  It searches using a key of the form
     `INSTANCE.ATTRIBUTE', with class `Emacs', where INSTANCE is the
     name under which Emacs was invoked.

     The optional arguments COMPONENT and SUBCLASS add to the key and
     the class, respectively.  You must specify both of them or neither.
     If you specify them, the key is `INSTANCE.COMPONENT.ATTRIBUTE',
     and the class is `Emacs.SUBCLASS'.

   * `x-display-color-p' returns `t' if you are using an X server with
     a color display, and `nil' otherwise.

     `x-color-defined-p' takes as argument a string describing a color;
     it returns `t' if the display supports that color.  (If the color
     is `"black"' or `"white"' then even black-and-white displays
     support it.)

   * `x-popup-menu' has been generalized.  It now accepts a keymap as
     the MENU argument.  Then the menu items are the prompt strings of
     individual key bindings, and the item values are the keys which
     have those bindings.

     You can also supply a list of keymaps as the first argument; then
     each keymap makes one menu pane (but keymaps that don't provide
     any menu items don't appear in the menu at all).

     `x-popup-menu' also accepts a mouse button event as the POSITION
     argument.  Then it displays the menu at the location at which the
     event took place.  This is convenient for mouse-invoked commands
     that pop up menus.

   * You can use the function `x-rebind-key' to change the sequence of
     characters generated by the X server for one of the keyboard keys.

     The first two arguments, KEYCODE and SHIFT-MASK, should be numbers
     representing the keyboard code and shift mask respectively.  They
     specify what key to change.

     The third argument, NEWSTRING, is the new definition of the key.
     It is a sequence of characters that the key should produce as
     input.

     The shift mask value is a combination of bits according to this
     table:

    8
          Control

    4
          Meta

    2
          Shift

    1
          Shift Lock

     If you specify `nil' for SHIFT-MASK, then the key specified by
     KEYCODE is redefined for all possible shift combinations.

     For the possible values of KEYCODE and their meanings, see the
     file `/usr/lib/Xkeymap.txt'.  Keep in mind that the codes in that
     file are in octal!

     The related function `x-rebind-keys' redefines a single keyboard
     key, specifying the behavior for each of the 16 shift masks
     independently.  The first argument is KEYCODE, as in
     `x-rebind-key'.  The second argument STRINGS is a list of 16
     elements, one for each possible shift mask value; each element
     says how to redefine the key KEYCODE with the corresponding shift
     mask value.  If an element is a string, it is the new definition.
     If an element is `nil', the definition does not change for that
     shift mask.

   * The function `x-parse-geometry' parses a string specifying window
     size and position in the usual X format.  It returns an alist
     describing which parameters were specified, and the values that
     were given for them.

     The elements of the alist look like `(PARAMETER .  VALUE)'.  The
     possible PARAMETER values are `left', `top', `width', and `height'.

New Window Features
===================

   * The new function `window-at' tells you which window contains a
     given horizontal and vertical position on a specified frame.  Call
     it with three arguments, like this:

          (window-at X COLUMN FRAME)

     The function returns the window which contains that cursor
     position in the frame FRAME.  If you omit FRAME, the selected
     frame is used.

   * The function `coordinates-in-window-p' takes two arguments and
     checks whether a particular frame position falls within a
     particular window.

          (coordinates-in-window-p COORDINATES WINDOW)

     The argument COORDINATES is a cons cell of this form:

          (X . Y)

     The two coordinates are measured in characters, and count from the
     top left corner of the screen or frame.

     The value of the function tells you what part of the window the
     position is in.  The possible values are:

    `(RELX . RELY)'
          The coordinates are inside WINDOW.  The numbers RELX and RELY
          are equivalent window-relative coordinates, counting from 0
          at the top left corner of the window.

    `mode-line'
          The coordinates are in the mode line of WINDOW.

    `vertical-split'
          The coordinates are in the vertical line between WINDOW and
          its neighbor to the right.

    `nil'
          The coordinates are not in any sense within WINDOW.

     You need not specify a frame when you call
     `coordinates-in-window-p', because it assumes you mean the frame
     which window WINDOW is on.

   * The function `minibuffer-window' now accepts a frame as argument
     and returns the minibuffer window used for that frame.  If you
     don't specify a frame, the currently selected frame is used.  The
     minibuffer window may be on the frame in question, but if that
     frame has no minibuffer of its own, it uses the minibuffer window
     of some other frame, and `minibuffer-window' returns that window.

   * Use `window-live-p' to test whether a window is still alive (that
     is, not deleted).

   * Use `window-minibuffer-p' to determine whether a given window is a
     minibuffer or not.  It no longer works to do this by comparing the
     window with the result of `(minibuffer-window)', because there can
     be more than one minibuffer window at a time (if you have multiple
     frames).

   * If you set the variable `pop-up-frames' non-`nil', then the
     functions to show something "in another window" actually create a
     new frame for the new window.  Thus, you will tend to have a frame
     for each window, and you can easily have a frame for each buffer.

     The value of the variable `pop-up-frame-function' controls how new
     frames are made.  The value should be a function which takes no
     arguments and returns a frame.  The default value is a function
     which creates a frame using parameters from `pop-up-frame-alist'.

   * `display-buffer' is the basic primitive for finding a way to show a
     buffer on the screen.  You can customize its behavior by storing a
     function in the variable `display-buffer-function'.  If this
     variable is non-`nil', then `display-buffer' calls it to do the
     work.  Your function should accept two arguments, as follows:

    BUFFER
          The buffer to be displayed.

    FLAG
          A flag which, if non-`nil', means you should find another
          window to display BUFFER in, even if it is already visible in
          the selected window.

     The function you supply will be used by commands such as
     `switch-to-buffer-other-window' and `find-file-other-window' as
     well as for your own calls to `display-buffer'.

   * `delete-window' now gives all of the deleted window's screen space
     to a single neighboring window.  Likewise, `enlarge-window' takes
     space from only one neighboring window until that window
     disappears; only then does it take from another window.

   * `next-window' and `previous-window' accept another argument,
     ALL-FRAMES.

     These functions now take three optional arguments: WINDOW, MINIBUF
     and ALL-FRAMES.  WINDOW is the window to start from (`nil' means
     use the selected window).  MINIBUF says whether to include the
     minibuffer in the windows to cycle through: `t' means yes, `nil'
     means yes if it is active, and anything else means no.

     Normally, these functions cycle through all the windows in the
     selected frame, plus the minibuffer used by the selected frame
     even if it lies in some other frame.

     If ALL-FRAMES is `t', then these functions cycle through all the
     windows in all the frames that currently exist.  If ALL-FRAMES is
     neither `t' nor `nil', then they limit themselves strictly to the
     windows in the selected frame, excluding the minibuffer in use if
     it lies in some other frame.

   * The functions `get-lru-window' and `get-largest-window' now take
     an optional argument ALL-FRAMES.  If it is non-`nil', the
     functions consider all windows on all frames.  Otherwise, they
     consider just the windows on the selected frame.

     Likewise, `get-buffer-window' takes an optional second argument
     ALL-FRAMES.

   * The variable `other-window-scroll-buffer' specifies which buffer
     `scroll-other-window' should scroll.

   * You can now mark a window as "dedicated" to its buffer.  Then
     Emacs will not try to use that window for any other buffer unless
     you explicitly request it.

     Use the new function `set-window-dedicated-p' to set the dedication
     flag of a window WINDOW to the value FLAG.  If FLAG is `t', this
     makes the window dedicated.  If FLAG is `nil', this makes the
     window non-dedicated.

     Use `window-dedicated-p' to examine the dedication flag of a
     specified window.

   * The new function `walk-windows' cycles through all visible
     windows, calling `proc' once for each window with the window as
     its sole argument.

     The optional second argument MINIBUF says whether to include
     minibuffer windows.  A value of `t' means count the minibuffer
     window even if not active.  A value of `nil' means count it only
     if active.  Any other value means not to count the minibuffer even
     if it is active.

     If the optional third argument ALL-FRAMES is `t', that means
     include all windows in all frames.  If ALL-FRAMES is `nil', it
     means to cycle within the selected frame, but include the
     minibuffer window (if MINIBUF says so) that that frame uses, even
     if it is on another frame.  If ALL-FRAMES is neither `nil' nor `t',
     `walk-windows' sticks strictly to the selected frame.

   * The function `window-end' is a counterpart to `window-start': it
     returns the buffer position of the end of the display in a given
     window (or the selected window).

   * The function `window-configuration-p' returns non-`nil' when given
     an object that is a window configuration (such as is returned by
     `current-window-configuration').

Display Features
================

   * `baud-rate' is now a variable rather than a function.  This is so
     you can set it to reflect the effective speed of your terminal,
     when the system doesn't accurately know the speed.

   * You can now remove any echo area message and make the minibuffer
     visible.  To do this, call `message' with `nil' as the only
     argument.  This clears any existing message, and lets the current
     minibuffer contents show through.  Previously, there was no
     reliable way to make sure that the minibuffer contents were
     visible.

   * The variable `temp-buffer-show-hook' has been renamed
     `temp-buffer-show-function', because its value is a single function
     (of one argument), not a normal hook.

   * The new function `force-mode-line-update' causes redisplay of the
     current buffer's mode line.

Display Tables
==============

   You can use the "display table" feature to control how all 256
possible character codes display on the screen.  This is useful for
displaying European languages that have letters not in the ASCII
character set.

   The display table maps each character code into a sequence of
"glyphs", each glyph being an image that takes up one character
position on the screen.  You can also define how to display each glyph
on your terminal, using the "glyph table".

Display Tables Proper
---------------------

   Use `make-display-table' to create a display table.  The table
initially has `nil' in all elements.

   A display table is actually an array of 261 elements.  The first 256
elements of a display table control how to display each possible text
character.  The value should be `nil' or a vector (which is a sequence
of glyphs; see below).  `nil' as an element means to display that
character following the usual display conventions.

   The remaining five elements of a display table serve special purposes
(`nil' means use the default stated below):

256
     The glyph for the end of a truncated screen line (the default for
     this is `\').

257
     The glyph for the end of a continued line (the default is `$').

258
     The glyph for the indicating an octal character code (the default
     is `\').

259
     The glyph for indicating a control characters (the default is `^').

260
     The vector of glyphs for indicating the presence of invisible
     lines (the default is `...').

   Each buffer typically has its own display table.  The display table
for the current buffer is stored in `buffer-display-table'.  (This
variable automatically becomes local if you set it.)  If this variable
is `nil', the value of `standard-display-table' is used in that buffer.

   Each window can have its own display table, which overrides the
display table of the buffer it is showing.

   If neither the selected window nor the current buffer has a display
table, and if `standard-display-table' is `nil', then Emacs uses the
usual display conventions:

   * Character codes 32 through 127 map to glyph codes 32 through 127.

   * Codes 0 through 31 map to sequences of two glyphs, where the first
     glyph is the ASCII code for `^'.

   * Character codes 128 through 255 map to sequences of four glyphs,
     where the first glyph is the ASCII code for `\', and the others
     represent digits.

   The usual display conventions are also used for any character whose
entry in the active display table is `nil'.  This means that when you
set up a display table, you need not specify explicitly what to do with
each character, only the characters for which you want unusual behavior.

Glyphs
------

   A glyph stands for an image that takes up a single character
position on the screen.  A glyph is represented in Lisp as an integer.

   The meaning of each integer, as a glyph, is defined by the glyph
table, which is the value of the variable `glyph-table'.  It should be a
vector; the Gth element defines glyph code G.  The possible definitions
of a glyph code are:

INTEGER
     Define this glyph code as an alias for code INTEGER.  This is used
     with X Windows to specify a face code.

STRING
     Send the characters in STRING to the terminal to output this
     glyph.  This alternative is available only for character
     terminals, not with X.

`NIL'
     This glyph is simple.  On an ordinary terminal, the glyph code mod
     256 is the character to output.  With X, the glyph code mod 256 is
     character to output, and the glyph code divided by 256 specifies
     the "face code" to use while outputting it.

   Any glyph code beyond the length of the glyph table is automatically
simple.

   If `glyph-table' is `nil', then all possible glyph codes are simple.

   A "face" is a named combination of a font and a pair of colors
(foreground and background).  A glyph code can specify a face id number
to use for displaying that glyph.

ISO Latin 1
-----------

   If you have a terminal that can handle the entire ISO Latin 1
character set, you can arrange to use that character set as follows:

     (standard-display-european 1)

   If you are editing buffers written in the ISO Latin 1 character set
and your terminal doesn't handle anything but ASCII, you can load the
file `iso-ascii' to set up a display table which makes the other ISO
characters display as sequences of ASCII characters.  For example, the
character "o with umlaut" displays as `{"o}'.

   Some European countries have terminals that don't support ISO Latin 1
but do support the special characters for that country's language.  You
can define a display table to work one language using such terminals.
For an example, see `lisp/iso-swed.el', which handles certain Swedish
terminals.

   You can load the appropriate display table for your terminal
automatically by writing a terminal-specific Lisp file for the terminal
type.

Overlays
========

   You can use "overlays" to alter the appearance of a buffer's text on
the screen.  An overlay is an object which belongs to a particular
buffer, and has a specified beginning and end.  It also has properties
which you can examine and set; these affect the display of the text
within the overlay.

Overlay Properties
------------------

   Overlay properties are like text properties in some respects, but the
differences are more important than the similarities.  Text properties
are considered a part of the text; overlays are specifically considered
not to be part of the text.  Thus, copying text between various buffers
and strings preserves text properties, but does not try to preserve
overlays.  Changing a buffer's text properties marks the buffer as
modified, while moving an overlay or changing its properties does not.

`face'
     This property specifies a face for displaying the text within the
     overlay.

`priority'
     This property's value (which should be a nonnegative number)
     determines the priority of the overlay.  The priority matters when
     two or more overlays cover the same character and both specify a
     face for display; the one whose `priority' value is larger takes
     priority over the other, and its face attributes override the face
     attributes of the lower priority overlay.

     Currently, all overlays take priority over text properties.  Please
     avoid using negative priority values, as we have not yet decided
     just what they should mean.

`window'
     If the `window' property is non-`nil', then the overlay applies
     only on that window.

Overlay Functions
-----------------

   Use the functions `overlay-get' and `overlay-put' to access and set
the properties of an overlay.  They take arguments like `get' and
`put', except that the first argument is an overlay rather than a
symbol.

   To create an overlay, call `(make-overlay START END)'.  You can
specify the buffer as the third argument if you wish.  To delete one,
use `delete-overlay'.

   Use `overlay-start', `overlay-end' and `overlay-buffer' to examine
the location and range of an overlay.  Use `move-overlay' to change
them; its arguments are OVERLAY, START, END and (optionally) the buffer.

   There are two functions to search for overlays: `overlays-at' and
`next-overlay-change'.  `overlays-at' returns a list of all the
overlays containing a particular position.  `(next-overlay-change POS)'
returns the position of the next overlay beginning or end following POS.

Faces
=====

   A "face" is a named collection of graphical attributes: font,
foreground color, background color and optional underlining.  Faces
control the display of text on the screen.

   Each face has its own "face id number" which distinguishes faces at
low levels within Emacs.  However, for most purposes, you can refer to
faces in Lisp programs by their names.

   Each face name is meaningful for all frames, and by default it has
the same meaning in all frames.  But you can arrange to give a
particular face name a special meaning in one frame if you wish.

Choosing a Face for Display
---------------------------

   Here are all the ways to specify which face to use for display of
text:

   * With defaults.  Each frame has a "default face", whose id number is
     zero, which is used for all text that doesn't somehow specify
     another face.

   * With text properties.  A character may have a `face' property; if
     so, it's displayed with that face.  If the character has a
     `mouse-face' property, that is used instead of the `face' property
     when the mouse is "near enough" to the character.

   * With overlays.  An overlay may have `face' and `mouse-face'
     properties too; they apply to all the text covered by the overlay.

   * With special glyphs.  Each glyph can specify a particular face id
     number.

   If these various sources together specify more than one face for a
particular character, Emacs merges the attributes of the various faces
specified.  The attributes of the faces of special glyphs come first;
then come attributes of faces from overlays, followed by those from text
properties, and last the default face.

   When multiple overlays cover one character, an overlay with higher
priority overrides those with lower priority.

   If an attribute such as the font or a color is not specified in any
of the above ways, the frame's own font or color is used.

   *Note Face Functions: (elisp)Face Functions, for functions to create
and change faces.

New Input Event Formats
=======================

   Mouse clicks, mouse movements and function keys no longer appear in
the input stream as characters; instead, other kinds of Lisp objects
represent them as input.

   * An ordinary input character event consists of a "basic code"
     between 0 and 255, plus any or all of these "modifier bits":

    meta
          The 2**23 bit in the character code indicates a character
          typed with the meta key held down.

    control
          The 2**22 bit in the character code indicates a non-ASCII
          control character.

          ASCII control characters such as `C-a' have special basic
          codes of their own, so Emacs needs no special bit to indicate
          them.  Thus, the code for `C-a' is just 1.

          But if you type a control combination not in ASCII, such as
          `%' with the control key, the numeric value you get is the
          code for `%' plus 2**22 (assuming the terminal supports
          non-ASCII control characters).

    shift
          The 2**21 bit in the character code indicates an ASCII control
          character typed with the shift key held down.

          For letters, the basic code indicates upper versus lower
          case; for digits and punctuation, the shift key selects an
          entirely different character with a different basic code.  In
          order to keep within the ASCII character set whenever
          possible, Emacs avoids using the 2**21 bit for those
          characters.

          However, ASCII provides no way to distinguish `C-A' from
          `C-a', so Emacs uses the 2**21 bit in `C-A' and not in `C-a'.

    hyper
          The 2**20 bit in the character code indicates a character
          typed with the hyper key held down.

    super
          The 2**19 bit in the character code indicates a character
          typed with the super key held down.

    alt
          The 2**18 bit in the character code indicates a character
          typed with the alt key held down.  (On some terminals, the
          key labeled ALT is actually the meta key.)

     In the future, Emacs may support a larger range of basic codes.
     We may also move the modifier bits to larger bit numbers.
     Therefore, you should avoid mentioning specific bit numbers in
     your program.  Instead, the way to test the modifier bits of a
     character is with the function `event-modifiers' (see below).

   * Function keys are represented as symbols.  The symbol's name is
     the function key's label.  For example, pressing a key labeled F1
     places the symbol `f1' in the input stream.

     There are a few exceptions to the symbol naming convention:

    `kp-add', `kp-decimal', `kp-divide', ...
          Keypad keys (to the right of the regular keyboard).

    `kp-0', `kp-1', ...
          Keypad keys with digits.

    `kp-f1', `kp-f2', `kp-f3', `kp-f4'
          Keypad PF keys.

    `left', `up', `right', `down'
          Cursor arrow keys

     You can use the modifier keys CTRL, META, HYPER, SUPER, ALT and
     SHIFT with function keys.  The way to represent them is with
     prefixes in the symbol name:

    `A-'
          The alt modifier.

    `C-'
          The control modifier.

    `H-'
          The hyper modifier.

    `M-'
          The meta modifier.

    `s-'
          The super modifier.

    `S-'
          The shift modifier.

     Thus, the symbol for the key F3 with META held down is `M-F3'.
     When you use more than one prefix, we recommend you write them in
     alphabetical order (though the order does not matter in arguments
     to the key-binding lookup and modification functions).

   * Mouse events are represented as lists.

     If you press a mouse button and release it at the same location,
     this generates a "click" event.  Mouse click events have this form:

          (BUTTON-SYMBOL
           (WINDOW (COLUMN . ROW)
            BUFFER-POS TIMESTAMP))

     Here is what the elements normally mean:

    BUTTON-SYMBOL
          indicates which mouse button was used.  It is one of the
          symbols `mouse-1', `mouse-2', ..., where the buttons are
          normally numbered left to right.

          You can also use prefixes `A-', `C-', `H-', `M-', `S-' and
          `s-' for modifiers alt, control, hyper, meta, shift and
          super, just as you would with function keys.

    WINDOW
          is the window in which the click occurred.

    COLUMN
    ROW
          are the column and row of the click, relative to the top left
          corner of WINDOW, which is `(0 . 0)'.

    BUFFER-POS
          is the buffer position of the character clicked on.

    TIMESTAMP
          is the time at which the event occurred, in milliseconds.
          (Since this value wraps around the entire range of Emacs Lisp
          integers in about five hours, it is useful only for relating
          the times of nearby events.)

     The meanings of BUFFER-POS, ROW and COLUMN are somewhat different
     when the event location is in a special part of the screen, such
     as the mode line or a scroll bar.

     If the position is in the window's scroll bar, then BUFFER-POS is
     the symbol `vertical-scroll-bar', and the pair `(COLUMN . ROW)' is
     replaced with a pair `(PORTION . WHOLE)', where PORTION is the
     distance of the click from the top or left end of the scroll bar,
     and WHOLE is the length of the entire scroll bar.

     If the position is on a mode line or the vertical line separating
     WINDOW from its neighbor to the right, then BUFFER-POS is the
     symbol `mode-line' or `vertical-line'.  In this case ROW and
     COLUMN do not have meaningful data.

   * Releasing a mouse button above a different character position
     generates a "drag" event, which looks like this:

          (BUTTON-SYMBOL
           (WINDOW1 (COLUMN1 . ROW1)
            BUFFER-POS1 TIMESTAMP1)
           (WINDOW2 (COLUMN2 . ROW2)
            BUFFER-POS2 TIMESTAMP2))

     The name of BUTTON-SYMBOL contains the prefix `drag-'.  The second
     and third elements of the event give the starting and ending
     position of the drag.

     The `drag-' prefix follows the modifier key prefixes such as `C-'
     and `M-'.

     If `read-key-sequence' receives a drag event which has no key
     binding, and the corresponding click event does have a binding, it
     changes the drag event into a click event at the drag's starting
     position.  This means that you don't have to distinguish between
     click and drag events unless you want to.

   * Click and drag events happen when you release a mouse button.
     Another kind of event happens when you press a button.  It looks
     just like a click event, except that the name of BUTTON-SYMBOL
     contains the prefix `down-'.  The `down-' prefix follows the
     modifier key prefixes such as `C-' and `M-'.

     The function `read-key-sequence', and the Emacs command loop,
     ignore any down events that don't have command bindings.  This
     means that you need not worry about defining down events unless
     you want them to do something.  The usual reason to define a down
     event is so that you can track mouse motion until the button is
     released.

   * For example, if the user presses and releases the left mouse
     button over the same location, Emacs generates a sequence of
     events like this:

          (down-mouse-1 (#<window 18 on NEWS> 2613 (0 . 38) -864320))
          (mouse-1      (#<window 18 on NEWS> 2613 (0 . 38) -864180))

     Or, while holding the control key down, the user might hold down
     the second mouse button, and drag the mouse from one line to the
     next.  That produces two events, as shown here:

          (C-down-mouse-2 (#<window 18 on NEWS> 3440 (0 . 27) -731219))
          (C-drag-mouse-2 (#<window 18 on NEWS> 3440 (0 . 27) -731219)
                          (#<window 18 on NEWS> 3510 (0 . 28) -729648))

     Or, while holding down the meta and shift keys, the user might
     press the second mouse button on the window's mode line, and then
     drag the mouse into another window.  That produces an event like
     this:

          (M-S-down-mouse-2 (#<window 18 on NEWS> mode-line (33 . 31) -457844))
          (M-S-drag-mouse-2 (#<window 18 on NEWS> mode-line (33 . 31) -457844)
                            (#<window 20 on carlton-sanskrit.tex> 161 (33 . 3)
                             -453816))

   * A key sequence that starts with a mouse click is read using the
     keymaps of the buffer in the window clicked on, not the current
     buffer.

     This does not imply that clicking in a window selects that window
     or its buffer.  The execution of the command begins with no change
     in the selected window or current buffer.  However, the command
     can switch windows or buffers if programmed to do so.

   * Mouse motion events are represented by lists.  During the
     execution of the body of a `track-mouse' form, moving the mouse
     generates events that look like this:

          (mouse-movement (WINDOW (COLUMN . ROW)
                           BUFFER-POS TIMESTAMP))

     The second element of the list describes the current position of
     the mouse, just as in a mouse click event.

     Outside of `track-mouse' forms, Emacs does not generate events for
     mere motion of the mouse, and these events do not appear.

   * Focus shifts between frames are represented by lists.

     When the mouse shifts temporary input focus from one frame to
     another, Emacs generates an event like this:

          (switch-frame NEW-FRAME)

     where NEW-FRAME is the frame switched to.

     In X windows, most window managers are set up so that just moving
     the mouse into a window is enough to set the focus there.  As far
     as the user is concerned, Emacs behaves consistently with this.
     However, there is no need for the Lisp program to know about the
     focus change until some other kind of input arrives.  So Emacs
     generates the focus event only when the user actually types a
     keyboard key or presses a mouse button in the new frame; just
     moving the mouse between frames does not generate a focus event.

     The global key map usually binds this event to the
     `internal-select-frame' function, so that characters typed at a
     frame apply to that frame's selected window.

     If the user switches frames in the middle of a key sequence, then
     Emacs delays the `switch-frame' event until the key sequence is
     over.  For example, suppose `C-c C-a' is a key sequence in the
     current buffer's keymaps.  If the user types `C-c', moves the
     mouse to another frame, and then types `C-a', `read-key-sequence'
     returns the sequence `"\C-c\C-a"', and the next call to
     `read-event' or `read-key-sequence' will return the `switch-frame'
     event.

Working with Input Events
=========================

   * Functions which work with key sequences now handle non-character
     events.  Functions like `define-key', `global-set-key', and
     `local-set-key' used to accept strings representing key sequences;
     now, since events may be arbitrary lisp objects, they also accept
     vectors.  The function `read-key-sequence' may return a string or a
     vector, depending on whether or not the sequence read contains only
     characters.

     List events may be represented by the symbols at their head; to
     bind clicks of the left mouse button, you need only present the
     symbol `mouse-1', not an entire mouse click event.  If you do put
     an event which is a list in a key sequence, only the event's head
     symbol is used in key lookups.

     For example, to globally bind the left mouse button to the function
     `mouse-set-point', you could evaluate this:

          (global-set-key [mouse-1] 'mouse-set-point)

     To bind the sequence `C-c F1' to the command `tex-view' in
     `tex-mode-map', you could evaluate this:

          (define-key tex-mode-map [?\C-c f1] 'tex-view)

     To find the binding for the function key labeled NEXT in
     `minibuffer-local-map', you could evaluate this:

          (lookup-key minibuffer-local-map [next])
               => next-history-element

     If you call the function `read-key-sequence' and then press `C-x
     C-F5', here is how it behaves:

          (read-key-sequence "Press `C-x C-F5': ")
               => [24 C-f5]

     Note that `24' is the character `C-x'.

   * The documentation functions (`single-key-description',
     `key-description', etc.) now handle the new event types.  Wherever
     a string of keyboard input characters was acceptable in previous
     versions of Emacs, a vector of events should now work.

   * Special parts of a window can have their own bindings for mouse
     events.

     When mouse events occur in special parts of a window, such as a
     mode line or a scroll bar, the event itself shows nothing
     special--only the symbol that would normally represent that mouse
     button and modifier keys.  The information about the screen region
     is kept in other parts of the event list.  But `read-key-sequence'
     translates this information into imaginary prefix keys, all of
     which are symbols: `mode-line', `vertical-line', and
     `vertical-scroll-bar'.

     For example, if you call `read-key-sequence' and then click the
     mouse on the window's mode line, this is what happens:

          (read-key-sequence "Click on the mode line: ")
               => [mode-line (mouse-1 (#<window 6 on NEWS> mode-line
                                        (40 . 63) 5959987))]

     You can define meanings for mouse clicks in special window regions
     by defining key sequences using these imaginary prefix keys.  For
     example, here is how to bind the third mouse button on a window's
     mode line delete the window:

          (global-set-key [mode-line mouse-3] 'mouse-delete-window)

     Here's how to bind the middle button (modified by META) on the
     vertical line at the right of a window to scroll the window to the
     left.

          (global-set-key [vertical-line M-mouse-2] 'scroll-left)

   * Decomposing an event symbol.

     Each symbol used to identify a function key or mouse button has a
     property named `event-symbol-elements', which is a list containing
     an unmodified version of the symbol, followed by modifiers the
     symbol name contains.  The modifiers are symbols; they include
     `shift', `control', and `meta'.  In addition, a mouse event symbol
     has one of `click', `drag', and `down'.  For example:

          (get 'f5 'event-symbol-elements)
               => (f5)
          (get 'C-f5 'event-symbol-elements)
               => (f5 control)
          (get 'M-S-f5 'event-symbol-elements)
               => (f5 meta shift)
          (get 'mouse-1 'event-symbol-elements)
               => (mouse-1 click)
          (get 'down-mouse-1 'event-symbol-elements)
               => (mouse-1 down)

     Note that the `event-symbol-elements' property for a mouse click
     explicitly contains `click', but the event symbol name itself does
     not contain `click'.

   * Use `read-event' to read input if you want to accept any kind of
     event.  The old function `read-char' now discards events other than
     keyboard characters.

   * `last-command-char' and `last-input-char' can now hold any kind of
     event.

   * The new variable `unread-command-events' is much like
     `unread-command-char'.  Its value is a list of events of any type,
     to be processed as command input in order of appearance in the
     list.

   * The function `this-command-keys' may return a string or a vector,
     depending on whether or not the sequence read contains only
     characters.  You may need to upgrade code which uses this function.

     The function `recent-keys' now returns a vector of events.  You
     may need to upgrade code which uses this function.

   * A keyboard macro's definition can now be either a string or a
     vector.  All that really matters is what elements it has.  If the
     elements are all characters, then the macro can be a string;
     otherwise, it has to be a vector.

   * The variable `last-event-frame' records which frame the last input
     event was directed to.  Usually this is the frame that was
     selected when the event was generated, but if that frame has
     redirected input focus to another frame, `last-event-frame' is the
     frame to which the event was redirected.

   * The interactive specification now allows a new code letter `e' to
     simplify commands bound to events which are lists.  This code
     supplies as an argument the complete event object.

     You can use `e' more than once in a single command's interactive
     specification.  If the key sequence which invoked the command has
     N events with parameters, the Nth `e' provides the Nth
     parameterized event.  Events which are not lists, such as function
     keys and ASCII keystrokes, do not count where `e' is concerned.

   * You can extract the starting and ending position values from a
     mouse button or motion event using the two functions `event-start'
     and `event-end'.  These two functions return different values for
     drag and motion events; for click and button-down events, they
     both return the position of the event.

   * The position, a returned by `event-start' and `event-end', is a
     list of this form:

          (WINDOW BUFFER-POSITION (COL . ROW) TIMESTAMP)

     You can extract parts of this list with the functions
     `posn-window', `posn-point', `posn-col-row', and `posn-timestamp'.

   * The function `scroll-bar-scale' is useful for computing where to
     scroll to in response to a mouse button event from a scroll bar.
     It takes two arguments, RATIO and TOTAL, and in effect multiplies
     them.  We say "in effect" because RATIO is not a number; rather a
     pair `(NUM . DENOM)'.

     Here's the usual way to use `scroll-bar-scale':

          (scroll-bar-scale (posn-col-row (event-start event))
                            (buffer-size))

Putting Keyboard Events in Strings
==================================

   In most of the places where strings are used, we conceptualize the
string as containing text characters--the same kind of characters found
in buffers or files.  Occasionally Lisp programs use strings which
conceptually contain keyboard characters; for example, they may be key
sequences or keyboard macro definitions.  There are special rules for
how to put keyboard characters into a string, because they are not
limited to the range of 0 to 255 as text characters are.

   A keyboard character typed using the META key is called a "meta
character".  The numeric code for such an event includes the 2**23 bit;
it does not even come close to fitting in a string.  However, earlier
Emacs versions used a different representation for these characters,
which gave them codes in the range of 128 to 255.  That did fit in a
string, and many Lisp programs contain string constants that use `\M-'
to express meta characters, especially as the argument to `define-key'
and similar functions.

   We provide backward compatibility to run those programs with special
rules for how to put a keyboard character event in a string.  Here are
the rules:

   * If the keyboard event value is in the range of 0 to 127, it can go
     in the string unchanged.

   * The meta variants of those events, with codes in the range of
     2**23 to 2**23+127, can also go in the string, but you must change
     their numeric values.  You must set the 2**7 bit instead of the
     2**23 bit, resulting in a value between 128 and 255.

   * Other keyboard character events cannot fit in a string.  This
     includes keyboard events in the range of 128 to 255.

   Functions such as `read-key-sequence' that can construct strings
containing events follow these rules.

   When you use the read syntax `\M-' in a string, it produces a code
in the range of 128 to 255--the same code that you get if you modify
the corresponding keyboard event to put it in the string.  Thus, meta
events in strings work consistently regardless of how they get into the
strings.

   New programs can avoid dealing with these rules by using vectors
instead of strings for key sequences when there is any possibility that
these issues might arise.

   The reason we changed the representation of meta characters as
keyboard events is to make room for basic character codes beyond 127,
and support meta variants of such larger character codes.

Menus
=====

   You can now define menus conveniently as keymaps.  Menus are normally
used with the mouse, but they can work with the keyboard also.

Defining Menus
--------------

   A keymap is suitable for menu use if it has an "overall prompt
string", which is a string that appears as an element of the keymap.  It
should describes the purpose of the menu.  The easiest way to construct
a keymap with a prompt string is to specify the string as an argument
when you run `make-keymap' or `make-sparse-keymap'.

   The individual bindings in the menu keymap should also have prompt
strings; these strings are the items in the menu.  A binding with a
prompt string looks like this:

     (CHAR STRING . REAL-BINDING)

   As far as `define-key' is concerned, the string is part of the
character's binding--the binding looks like this:

     (STRING . REAL-BINDING).

   However, only REAL-BINDING is used for executing the key.

   You can also supply a second string, called the help string, as
follows:

     (CHAR STRING HELP-STRING . REAL-BINDING)

   Currently Emacs does not actually use HELP-STRING; it knows only how
to ignore HELP-STRING in order to extract REAL-BINDING.  In the future
we hope to make HELP-STRING serve as longer documentation for the menu
item, available on request.

   The prompt string for a binding should be short--one or two words.
Its meaning should describe the command it corresponds to.

   If REAL-BINDING is `nil', then STRING appears in the menu but cannot
be selected.

   If REAL-BINDING is a symbol, and has a non-`nil' `menu-enable'
property, that property is an expression which controls whether the
menu item is enabled.  Every time the keymap is used to display a menu,
Emacs evaluates the expression, and it enables the menu item only if
the expression's value is non-`nil'.  When a menu item is disabled, it
is displayed in a "fuzzy" fashion, and cannot be selected with the
mouse.

Menus and the Mouse
-------------------

   The way to make a menu keymap produce a menu is to make it the
definition of a prefix key.

   When the prefix key ends with a mouse event, Emacs handles the menu
keymap by popping up a visible menu that you can select from with the
mouse.  When you click on a menu item, the event generated is whatever
character or symbol has the binding which brought about that menu item.

   A single keymap can appear as multiple panes, if you explicitly
arrange for this.  The way to do this is to make a keymap for each
pane, then create a binding for each of those maps in the main keymap
of the menu.  Give each of these bindings a prompt string that starts
with `@'.  The rest of the prompt string becomes the name of the pane.
See the file `lisp/mouse.el' for an example of this.  Any ordinary
bindings with prompt strings are grouped into one pane, which appears
along with the other panes explicitly created for the submaps.

   You can also get multiple panes from separate keymaps.  The full
definition of a prefix key always comes from merging the definitions
supplied by the various active keymaps (minor modes, local, and
global).  When more than one of these keymaps is a menu, each of them
makes a separate pane or panes.

Menus and the Keyboard
----------------------

   When a prefix key ending with a keyboard event (a character or
function key) has a definition that is a menu keymap, you can use the
keyboard to choose a menu item.

   Emacs displays the menu alternatives in the echo area.  If they don't
all fit at once, type SPC to see the next line of alternatives.  If you
keep typing SPC, you eventually get to the end of the menu and then
cycle around to the beginning again.

   When you have found the alternative you want, type the corresponding
character--the one whose binding is that alternative.

   In a menu intended for keyboard use, each menu item must clearly
indicate what character to type.  The best convention to use is to make
the character the first letter of the menu item prompt string.  That is
something users will understand without being told.

The Menu Bar
------------

   Under X Windows, each frame can have a "menu bar"--a permanently
displayed menu stretching horizontally across the top of the frame.  The
items of the menu bar are the subcommands of the fake "function key"
`menu-bar', as defined by all the active keymaps.

   To add an item to the menu bar, invent a fake "function key" of your
own (let's call it KEY), and make a binding for the key sequence
`[menu-bar KEY]'.  Most often, the binding is a menu keymap, so that
pressing a button on the menu bar item leads to another menu.

   In order for a frame to display a menu bar, its `menu-bar-lines'
property must be greater than zero.  Emacs uses just one line for the
menu bar itself; if you specify more than one line, the other lines
serve to separate the menu bar from the windows in the frame.  We
recommend you try one or two as the `menu-bar-lines' value.

Keymaps
=======

   * The representation of keymaps has changed to support the new event
     types.  All keymaps now have the form `(keymap ELEMENT ELEMENT
     ...)'.  Each ELEMENT takes one of the following forms:

    PROMPT-STRING
          A string as an element of the keymap marks the keymap as a
          menu, and serves as the overall prompt string for it.

    `(KEY . BINDING)'
          A cons cell binds KEY to DEFINITION.  Here KEY may be any
          sort of event head--a character, a function key symbol, or a
          mouse button symbol.

    VECTOR
          A vector of 128 elements binds all the ASCII characters; the
          Nth element holds the binding for character number N.

    `(t . BINDING)'
          A cons cell whose CAR is `t' is a default binding; anything
          not bound by previous keymap elements is given BINDING as its
          binding.

          Default bindings are important because they allow a keymap to
          bind all possible events without having to enumerate all the
          possible function keys and mouse clicks, with all possible
          modifier prefixes.

          The function `lookup-key' (and likewise other functions for
          examining a key binding) normally report only explicit
          bindings of the specified key sequence; if there is none,
          they return `nil', even if there is a default binding that
          would apply to that key sequence if it were actually typed
          in.  However, these functions now take an optional argument
          ACCEPT-DEFAULTS which, if non-`nil', says to consider default
          bindings.

          Note that if a vector in the keymap binds an ASCII character
          to `nil' (thus making it "unbound"), the default binding does
          not apply to the character.  Think of the vector element as
          an explicit binding of `nil'.

          Note also that if the keymap for a minor or major mode
          contains a default binding, it completely masks out any
          lower-priority keymaps.

   * A keymap can now inherit from another keymap.  To do this, make the
     latter keymap the "tail" of the new one.  Such a keymap looks like
     this:

          (keymap BINDINGS... . OTHER-KEYMAP)

     The effect is that this keymap inherits all the bindings of
     OTHER-KEYMAP, but can add to them or override them with BINDINGS.
     Subsequent changes in the bindings of OTHER-KEYMAP *do* affect
     this keymap.

     For example,

          (setq my-mode-map (cons 'keymap text-mode-map))

     makes a keymap that by default inherits all the bindings of Text
     mode--whatever they may be at the time a key is looked up.  Any
     bindings made explicitly in `my-mode-map' override the bindings
     inherited from Text mode, however.

   * Minor modes can now have local keymaps.  Thus, a key can act a
     special way when a minor mode is in effect, and then revert to the
     major mode or global definition when the minor mode is no longer
     in effect.  The precedence of keymaps is now: minor modes (in no
     particular order), then major mode, and lastly the global map.

     The new `current-minor-mode-maps' function returns a list of all
     the keymaps of currently enabled minor modes, in the other that
     they apply.

     To set up a keymap for a minor mode, add an element to the alist
     `minor-mode-map-alist'.  Its elements look like this:

          (SYMBOL . KEYMAP)

     The keymap KEYMAP is active whenever SYMBOL has a non-`nil' value.
     Use for SYMBOL the variable which indicates whether the minor
     mode is enabled.

     When more than one minor mode keymap is active, their order of
     precedence is the order of `minor-mode-map-alist'.  But you should
     design minor modes so that they don't interfere with each other,
     and if you do this properly, the order will not matter.

     The function `minor-mode-key-binding' returns a list of all the
     active minor mode bindings of KEY.  More precisely, it returns an
     alist of pairs `(MODENAME . BINDING)', where MODENAME is the
     variable which enables the minor mode, and BINDING is KEY's
     definition in that mode.  If KEY has no minor-mode bindings, the
     value is `nil'.

     If the first binding is a non-prefix, all subsequent bindings from
     other minor modes are omitted, since they would be completely
     shadowed.  Similarly, the list omits non-prefix bindings that
     follow prefix bindings.

   * The new function `copy-keymap' copies a keymap, producing a new
     keymap with the same key bindings in it.  If the keymap contains
     other keymaps directly, these subkeymaps are copied recursively.

     If you want to, you can define a prefix key with a binding that is
     a symbol whose function definition is another keymap.  In this
     case, `copy-keymap' does not look past the symbol; it doesn't copy
     the keymap inside the symbol.

   * `substitute-key-definition' now accepts an optional fourth
     argument, which is a keymap to use as a template.

          (substitute-key-definition olddef newdef keymap oldmap)

     finds all characters defined in OLDMAP as OLDDEF, and defines them
     in KEYMAP as NEWDEF.

     In addition, this function now operates recursively on the keymaps
     that define prefix keys within KEYMAP and OLDMAP.

Minibuffer Features
===================

   The minibuffer input functions `read-from-minibuffer' and
`completing-read' have new features.

Minibuffer History
------------------

   A new optional argument HIST specifies which history list to use.
If you specify a variable (a symbol), that variable is the history
list.  If you specify a cons cell `(VARIABLE . STARTPOS)', then
VARIABLE is the history list variable, and STARTPOS specifies the
initial history position (an integer, counting from zero which
specifies the most recent element of the history).

   If you specify STARTPOS, then you should also specify that element
of the history as INITIAL-INPUT, for consistency.

   If you don't specify HIST, then the default history list
`minibuffer-history' is used.  Other standard history lists that you
can use when appropriate include `query-replace-history',
`command-history', and `file-name-history'.

   The value of the history list variable is a list of strings, most
recent first.  You should set a history list variable to `nil' before
using it for the first time.

   `read-from-minibuffer' and `completing-read' add new elements to the
history list automatically, and provide commands to allow the user to
reuse items on the list.  The only thing your program needs to do to
use a history list is to initialize it and to pass its name to the
input functions when you wish.  But it is safe to modify the list by
hand when the minibuffer input functions are not using it.

Other Minibuffer Features
-------------------------

   The INITIAL argument to `read-from-minibuffer' and other minibuffer
input functions can now be a cons cell `(STRING . POSITION)'.  This
means to start off with STRING in the minibuffer, but put the cursor
POSITION characters from the beginning, rather than at the end.

   In `read-no-blanks-input', the INITIAL argument is now optional; if
it is omitted, the initial input string is the empty string.

New Features for Defining Commands
==================================

   * If the interactive specification begins with `@', this means to
     select the window under the mouse.  This selection takes place
     before doing anything else with the command.

     You can use both `@' and `*' together in one command; they are
     processed in order of appearance.

   * Prompts in an interactive specification can incorporate the values
     of the preceding arguments.  Emacs replaces `%'-sequences (as used
     with the `format' function) in the prompt with the interactive
     arguments that have been read so far.  For example, a command with
     this interactive specification

          (interactive "sReplace: \nsReplace %s with: ")

     prompts for the first argument with `Replace: ', and then prompts
     for the second argument with `Replace FOO with: ', where FOO is
     the string read as the first argument.

   * If a command name has a property `enable-recursive-minibuffers'
     which is non-`nil', then the command can use the minibuffer to read
     arguments even if it is invoked from the minibuffer.  The
     minibuffer command `next-matching-history-element' (normally bound
     to `M-s' in the minibuffer) uses this feature.

New Features for Reading Input
==============================

   * The function `set-input-mode' now takes four arguments.  The last
     argument is optional.  Their names are INTERRUPT, FLOW, META and
     QUIT.

     The argument INTERRUPT says whether to use interrupt-driven input.
     Non-`nil' means yes, and `nil' means no (use CBREAK mode).

     The argument FLOW says whether to enable terminal flow control.
     Non-`nil' means yes.

     The argument META controls support for input character codes above
     127.  If META is `t', Emacs converts characters with the 8th bit
     set into Meta characters.  If META is `nil', Emacs disregards the
     8th bit; this is necessary when the terminal uses it as a parity
     bit.  If META is neither `t' nor `nil', Emacs uses all 8 bits of
     input unchanged.  This is good for terminals using European 8-bit
     character sets.

     If QUIT non-`nil', it is the character to use for quitting.
     (Normally this is `C-g'.)

   * The variable `meta-flag' has been deleted; use `set-input-mode' to
     enable or disable support for a META key.  This change was made
     because `set-input-mode' can send the terminal the appropriate
     commands to enable or disable operation of the META key.

   * The new variable `extra-keyboard-modifiers' lets Lisp programs
     "press" the modifier keys on the keyboard.  The value is a bit
     mask:

    1
          The SHIFT key.

    2
          The LOCK key.

    4
          The CTL key.

    8
          The META key.

     When you use X windows, the program can press any of the modifier
     keys in this way.  Otherwise, only the CTL and META keys can be
     virtually pressed.

   * You can use the new function `keyboard-translate' to set up
     `keyboard-translate-table' conveniently.

   * Y-or-n questions using the `y-or-n-p' function now accept `C-]'
     (usually mapped to `abort-recursive-edit') as well as `C-g' to
     quit.

   * The variable `num-input-keys' is the total number of key sequences
     that the user has typed during this Emacs session.

   * A new Lisp variable, `function-key-map', holds a keymap which
     describes the character sequences sent by function keys on an
     ordinary character terminal.  This uses the same keymap data
     structure that is used to hold bindings of key sequences, but it
     has a different meaning: it specifies translations to make while
     reading a key sequence.

     If `function-key-map' "binds" a key sequence K to a vector V, then
     when K appears as a subsequence *anywhere* in a key sequence, it
     is replaced with V.

     For example, VT100 terminals send `ESC O P' when the "keypad" PF1
     key is pressed.  Thus, on a VT100, `function-key-map' should
     "bind" that sequence to `[pf1]'.  This specifies translation of
     `ESC O P' into PF1 anywhere in a key sequence.

     Thus, typing `C-c PF1' sends the character sequence `C-c ESC O P',
     but `read-key-sequence' translates this back into `C-c PF1', which
     it returns as the vector `[?\C-c PF1]'.

     Entries in `function-key-map' are ignored if they conflict with
     bindings made in the minor mode, local, or global keymaps.

     The value of `function-key-map' is usually set up automatically
     according to the terminal's Terminfo or Termcap entry, and the
     terminal-specific Lisp files.  Emacs comes with a number of
     terminal-specific files for many common terminals; their main
     purpose is to make entries in `function-key-map' beyond those that
     can be deduced from Termcap and Terminfo.

   * The variable `key-translation-map' works like `function-key-map'
     except for two things:

        * `key-translation-map' goes to work after `function-key-map' is
          finished; it receives the results of translation by
          `function-key-map'.

        * `key-translation-map' overrides actual key bindings.

     The intent of `key-translation-map' is for users to map one
     character set to another, including ordinary characters normally
     bound to `self-insert-command'.

New Syntax Table Features
=========================

   * You can use two new functions to move across characters in certain
     syntax classes.

     `skip-syntax-forward' moves point forward across characters whose
     syntax classes are mentioned in its first argument, a string.  It
     stops when it encounters the end of the buffer, or position LIM
     (the optional second argument), or a character it is not supposed
     to skip.  The function `skip-syntax-backward' is similar but moves
     backward.

   * The new function `forward-comment' moves point by comments.  It
     takes one argument, COUNT; it moves point forward across COUNT
     comments (backward, if COUNT is negative).  If it finds anything
     other than a comment or whitespace, it stops, leaving point at the
     far side of the last comment found.  It also stops after
     satisfying COUNT.

   * The new variable `words-include-escapes' affects the behavior of
     `forward-word' and everything that uses it.  If it is non-`nil',
     then characters in the "escape" and "character quote" syntax
     classes count as part of words.

   * There are two new syntax flags for use in syntax tables.

        - The prefix flag.

          The `p' flag identifies additional "prefix characters" in Lisp
          syntax.  You can set this flag with `modify-syntax-entry' by
          including the letter `p' in the syntax specification.

          These characters are treated as whitespace when they appear
          between expressions.  When they appear withing an expression,
          they are handled according to their usual syntax codes.

          The function `backward-prefix-chars' moves back over these
          characters, as well as over characters whose primary syntax
          class is prefix (`'').

        - The `b' comment style flag.

          Emacs can now supports two comment styles simultaneously.
          (This is for the sake of C++.)  More specifically, it can
          recognize two different comment-start sequences.  Both must
          share the same first character; only the second character may
          differ.  Mark the second character of the `b'-style comment
          start sequence with the `b' flag.  You can set this flag with
          `modify-syntax-entry' by including the letter `b' in the
          syntax specification.

          The two styles of comment can have different comment-end
          sequences.  A comment-end sequence (one or two characters)
          applies to the `b' style if its first character has the `b'
          flag set; otherwise, it applies to the `a' style.

          The appropriate comment syntax settings for C++ are as
          follows:

         `/'
               `124b'

         `*'
               `23'

         newline
               `>b'

          Thus `/*' is a comment-start sequence for `a' style, `//' is
          a comment-start sequence for `b' style, `*/' is a comment-end
          sequence for `a' style, and newline is a comment-end sequence
          for `b' style.

The Case Table
==============

   You can customize case conversion using the new case table feature.
A case table is a collection of strings that specifies the mapping
between upper case and lower case letters.  Each buffer has its own
case table.  You need a case table if you are using a language which
has letters that are not standard ASCII letters.

   A case table is a list of this form:

     (DOWNCASE UPCASE CANONICALIZE EQUIVALENCES)

where each element is either `nil' or a string of length 256.  The
element DOWNCASE says how to map each character to its lower-case
equivalent.  The element UPCASE maps each character to its upper-case
equivalent.  If lower and upper case characters are in 1-1
correspondence, use `nil' for UPCASE; then Emacs deduces the upcase
table from DOWNCASE.

   For some languages, upper and lower case letters are not in 1-1
correspondence.  There may be two different lower case letters with the
same upper case equivalent.  In these cases, you need to specify the
maps for both directions.

   The element CANONICALIZE maps each character to a canonical
equivalent; any two characters that are related by case-conversion have
the same canonical equivalent character.

   The element EQUIVALENCES is a map that cyclicly permutes each
equivalence class (of characters with the same canonical equivalent).

   You can provide `nil' for both CANONICALIZE and EQUIVALENCES, in
which case both are deduced from DOWNCASE and UPCASE.

   Here are the functions for working with case tables:

   `case-table-p' is a predicate that says whether a Lisp object is a
valid case table.

   `set-standard-case-table' takes one argument and makes that argument
the case table for new buffers created subsequently.
`standard-case-table' returns the current value of the new buffer case
table.

   `current-case-table' returns the case table of the current buffer.
`set-case-table' sets the current buffer's case table to the argument.

   `set-case-syntax-pair' is a convenient function for specifying a
pair of letters, upper case and lower case.  Call it with two arguments,
the upper case letter and the lower case letter.  It modifies the
standard case table and a few syntax tables that are predefined in
Emacs.  This function is intended as a subroutine for packages that
define non-ASCII character sets.

   Load the library `iso-syntax' to set up the syntax and case table for
the 256 bit ISO Latin 1 character set.

New Features for Dealing with Buffers
=====================================

   * The new function `buffer-modified-tick' returns a buffer's
     modification-count that ticks every time the buffer is modified.
     It takes one optional argument, which is the buffer you want to
     examine.  If the argument is `nil' (or omitted), the current
     buffer is used.

   * `buffer-disable-undo' is a new name for the function formerly
     known as `buffer-flush-undo'.  This turns off recording of undo
     information in the buffer given as argument.

   * The new function `generate-new-buffer-name' chooses a name that
     would be unique for a new buffer--but does not create the buffer.
     Give it one argument, a starting name.  It produces a name not in
     use for a buffer by appending a number inside of `<...>'.

   * The function `rename-buffer' now takes an optional second argument
     which tells it that if the specified new name corresponds to an
     existing buffer, it should use `generate-new-buffer-name' to
     modify the name to be unique, rather than signaling an error.

     `rename-buffer' now returns the name to which the buffer was
     renamed.

   * The function `list-buffers' now looks at the local variable
     `list-buffers-directory' in each non-file-visiting buffer, and
     shows its value where the file would normally go.  Dired sets this
     variable in each Dired buffer, so the buffer list now shows which
     directory each Dired buffer is editing.

   * The function `other-buffer' now takes an optional second argument
     VISIBLE-OK which, if non-`nil', indicates that buffers currently
     being displayed in windows may be returned even if there are other
     buffers not visible.  Normally, `other-buffer' returns a currently
     visible buffer only as a last resort, if there are no suitable
     nonvisible buffers.

   * The hook `kill-buffer-hook' now runs whenever a buffer is killed.

Local Variables Features
========================

   * If a local variable name has a non-`nil' `permanent-local'
     property, then `kill-all-local-variables' does not kill it.  Such
     local variables are "permanent"--they remain unchanged even if you
     select a different major mode.

     Permanent locals are useful when they have to do with where the
     file came from or how to save it, rather than with how to edit the
     contents.

   * The function `make-local-variable' now never changes the value of
     the variable that it makes local.  If the variable had no value
     before, it still has no value after becoming local.

   * The new function `default-boundp' tells you whether a variable has
     a default value (as opposed to being unbound in its default
     value).  If `(default-boundp 'foo)' returns `nil', then
     `(default-value 'foo)' would get an error.

     `default-boundp' is to `default-value' as `boundp' is to
     `symbol-value'.

   * The special forms `defconst' and `defvar', when the variable is
     local in the current buffer, now set the variable's default value
     rather than its local value.

New Features for Subprocesses
=============================

   * `call-process' and `call-process-region' now return a value that
     indicates how the synchronous subprocess terminated.  It is either
     a number, which is the exit status of a process, or a signal name
     represented as a string.

   * `process-status' now returns `open' and `closed' as the status
     values for network connections.

   * The standard asynchronous subprocess features work on VMS now, and
     the special VMS asynchronous subprocess functions have been
     deleted.

   * You can use the transaction queue feature for more convenient
     communication with subprocesses using transactions.

     Call `tq-create' to create a transaction queue communicating with a
     specified process.  Then you can call `tq-enqueue' to send a
     transaction.  `tq-enqueue' takes these five arguments:

          (tq-enqueue TQ QUESTION REGEXP CLOSURE FN)

     TQ is the queue to use.  (Specifying the queue has the effect of
     specifying the process to talk to.)  The argument QUESTION is the
     outgoing message which starts the transaction.  The argument FN is
     the function to call when the corresponding answer comes back; it
     is called with two arguments: CLOSURE, and the answer received.

     The argument REGEXP is a regular expression to match the entire
     answer; that's how `tq-enqueue' tells where the answer ends.

     Call `tq-close' to shut down a transaction queue and terminate its
     subprocess.

   * The function `signal-process' sends a signal to process PID, which
     need not be a child of Emacs.  The second argument SIGNAL
     specifies which signal to send; it should be an integer.

New Features for Dealing with Times And Time Delays
===================================================

   * The new function `current-time' returns the system's time value as
     a list of three integers: `(HIGH LOW MICROSEC)'.  The integers
     HIGH and LOW combine to give the number of seconds since 0:00
     January 1, 1970, which is HIGH * 2**16 + LOW.

     MICROSEC gives the microseconds since the start of the current
     second (or 0 for systems that return time only on the resolution
     of a second).

   * The function `current-time-string' accepts an optional argument
     TIME-VALUE.  If given, this specifies a time to format instead of
     the current time.  The argument should be a cons cell containing
     two integers, or a list whose first two elements are integers.
     Thus, you can use times obtained from `current-time' (see above)
     and from `file-attributes'.

   * You can now find out the user's time zone using
     `current-time-zone'.

     The value has the form `(OFFSET NAME)'.  Here OFFSET is an integer
     giving the number of seconds ahead of UTC (east of Greenwich).  A
     negative value means west of Greenwich.  The second element, NAME
     is a string giving the name of the time zone.  Both elements
     change when daylight savings time begins or ends; if the user has
     specified a time zone that does not use a seasonal time
     adjustment, then the value is constant through time.

     If the operating system doesn't supply all the information
     necessary to compute the value, both elements of the list are
     `nil'.

     The optional argument TIME-VALUE, if given, specifies a time to
     analyze instead of the current time.  The argument should be a
     cons cell containing two integers, or a list whose first two
     elements are integers.  Thus, you can use times obtained from
     `current-time' and from `file-attributes'.

   * `sit-for', `sleep-for' now let you specify the time period in
     milliseconds as well as in seconds.  The first argument gives the
     number of seconds, as before, and the optional second argument
     gives additional milliseconds.  The time periods specified by
     these two arguments are added together.

     Not all systems support this; you get an error if you specify
     nonzero milliseconds and it isn't supported.

     `sit-for' also accepts an optional third argument NODISP.  If this
     is non-`nil', `sit-for' does not redisplay.  It still waits for
     the specified time or until input is available.

   * `accept-process-output' now accepts a timeout specified by optional
     second and third arguments.  The second argument specifies the
     number of seconds, while the third specifies the number of
     milliseconds.  The time periods specified by these two arguments
     are added together.

     Not all systems support this; you get an error if you specify
     nonzero milliseconds and it isn't supported.

     The function returns `nil' if the timeout expired before output
     arrived, or non-`nil' if it did get some output.

   * You can set up a timer to call a function at a specified future
     time.  To do so, call `run-at-time', like this:

          (run-at-time TIME REPEAT FUNCTION ARGS...)

     Here, TIME is a string saying when to call the function.  The
     argument FUNCTION is the function to call later, and ARGS are the
     arguments to give it when it is called.

     The argument REPEAT specifies how often to repeat the call.  If
     REPEAT is `nil', there are no repetitions; FUNCTION is called just
     once, at TIME.  If REPEAT is an integer, it specifies a repetition
     period measured in seconds.

     Absolute times may be specified in a wide variety of formats; The
     form `HOUR:MIN:SEC TIMEZONE MONTH/DAY/YEAR', where all fields are
     numbers, works; the format that `current-time-string' returns is
     also allowed.

     To specify a relative time, use numbers followed by units.  For
     example:

    `1 min'
          denotes 1 minute from now.

    `1 min 5 sec'
          denotes 65 seconds from now.

    `1 min 2 sec 3 hour 4 day 5 week 6 fortnight 7 month 8 year'
          denotes exactly 103 months, 123 days, and 10862 seconds from
          now.

     If TIME is an integer, that specifies a relative time measured in
     seconds.

   To cancel the requested future action, pass the value that
`run-at-time' returned to the function `cancel-timer'.

Profiling Lisp Programs
=======================

   You can now make execution-time profiles of Emacs Lisp programs using
the `profile' library.  See the file `profile.el' for instructions; if
you have written a Lisp program big enough to be worth profiling, you
can surely understand them.

New Features for Lisp Debuggers
===============================

   * You can now specify which kinds of errors should invoke the Lisp
     debugger by setting the variable `debug-on-error' to a list of
     error conditions.  For example, if you set it to the list
     `(void-variable)', then only errors about a variable that has no
     value invoke the debugger.

   * The variable `command-debug-status' is used by Lisp debuggers.  It
     records the debugging status of current interactive command.  Each
     time a command is called interactively, this variable is bound to
     `nil'.  The debugger can set this variable to leave information for
     future debugger invocations during the same command.

     The advantage of this variable over some other variable in the
     debugger itself is that the data will not be visible for any other
     command invocation.

   * The function `backtrace-frame' is intended for use in Lisp
     debuggers.  It returns information about what a frame on the Lisp
     call stack is doing.  You specify one argument, which is the
     number of stack frames to count up from the current execution
     point.

     If that stack frame has not evaluated the arguments yet (or is a
     special form), the value is `(nil FUNCTION ARG-FORMS...)'.

     If that stack frame has evaluated its arguments and called its
     function already, the value is `(t FUNCTION ARG-VALUES...)'.

     In the return value, FUNCTION is whatever was supplied as CAR of
     evaluated list, or a `lambda' expression in the case of a macro
     call.  If the function has a `&rest' argument, that is represented
     as the tail of the list ARG-VALUES.

     If the argument is out of range, `backtrace-frame' returns `nil'.

Memory Allocation Changes
=========================

   The list that `garbage-collect' returns now has one additional
element.  This is a cons cell containing two numbers.  It gives
information about the number of used and free floating point numbers,
much as the first element gives such information about the number of
used and free cons cells.

   The new function `memory-limit' returns an indication of the last
address allocated by Emacs.  More precisely, it returns that address
divided by 1024.  You can use this to get a general idea of how your
actions affect the memory usage.

Hook Changes
============

   * Expanding an abbrev first runs the new hook
     `pre-abbrev-expand-hook'.

   * The editor command loop runs the normal hook `pre-command-hook'
     before each command, and runs `post-command-hook' after each
     command.

   * Auto-saving runs the new hook `auto-save-hook' before actually
     starting to save any files.

   * The new variable `revert-buffer-insert-file-contents-function'
     holds a function that `revert-buffer' now uses to read in the
     contents of the reverted buffer--instead of calling
     `insert-file-contents'.

   * The variable `lisp-indent-hook' has been renamed to
     `lisp-indent-function'.

   * The variable `auto-fill-hook' has been renamed to
     `auto-fill-function'.

   * The variable `blink-paren-hook' has been renamed to
     `blink-paren-function'.

   * The variable `temp-buffer-show-hook' has been renamed to
     `temp-buffer-show-function'.

   * The variable `suspend-hook' is now a normal hook.  It used to be a
     special kind of hook; its value had to be a single function, and
     if the function returned a non-`nil' value, then suspension was
     inhibited.

   * The new function `add-hook' provides a handy way to add a function
     to a hook variable.  For example,

          (add-hook 'text-mode-hook 'my-text-hook-function)

     arranges to call `my-text-hook-function' when entering Text mode
     or related modes.

     `add-hook' takes an optional third argument which says to add the
     new hook function at the end of the list (normally, it goes at the
     beginning).