summaryrefslogtreecommitdiff
path: root/macros/texinfo/texinfo/js/examples/kawa/news.texi
blob: c08fa1cd5efce99bc7e37a06f8f5c006fe4b8749 (plain)
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
These changes are in more-or-less reverse chronological order, with the
most recent changes first.

See also the list of @uref{../qexo/news.html,Qexo (XQuery)-specific
changes}.

@subheading In Git repository (invoke branch) since last release
@itemize
@item
Binary release are now built for Java 8.
The repository source code is now set up for Java 8.
(Biulding fro Java 6 or 7 is still supported.
Java 5 might also work, but not not been tested recently.)
@item
Most places where you could declare a new identifier
binding have been generalized to accept @ref{Variables and Patterns,patterns},
including literals and boolean @stxref{guard}s.
@item
The new form @ref{def-match,@code{match}} form is a generalization
of @code{case} using patterns.
@item
The internal calling convention used for ``apply'' (ie. calling
an unknown-at-compile-time procedure) has been completely changed.
@item
Major changes to strings:
@itemize
@item
@emph{Incompatible change:} String literals are now
@code{gnu.lists.IString} rather than @code{java.lang.String}.
The advantage of using @code{gnu.lists.IString} is that @code{string-ref}
and @code{string-length} are (roughly) constant-time, rather than
having to linearly scan the string.
@item
@emph{Incompatible change:}
The procedures @code{string-append}, @code{string-map},
@code{substring}, @code{list->string}, @code{vector->string},
@code{string-downcase}, @code{string-upcase}, @code{string-foldcase}, 
@code{string-titlecase}, and the constructor @code{string}
return an immutable string (an @code{IString}).
(The function @code{string-copy} is similar to @code{substring},
but returns a mutable string.)
This is a work-in-progress with the goal of implementing
@uref{http://srfi.schemers.org/srfi-140/srfi-140.html,SRFI-140}:
Other procedures will be changed to return immutable strings.

If you @code{(import (scheme base))} standard procedures
such as @code{string-append} will return mutable strings;
if you @code{(import (kawa base))} the procedures will return immutable strings.
The command-line options @code{--r5rs} or @code{--r6rs} or @code{--r7rs}
override the default so these procedures return mutable strings.
@item
@emph{Incompatible change:}
Treating a string as a sequence is now simpler but possibly slower:
The @var{I}'th element is now the @var{I}'th Unicode code point.
Indexing with function-call syntax
@code{(@var{string} @var{i})} is the same as @code{(string-ref @var{string} @var{i})} and
@code{(length @var{string})} is the same as @code{(string-length @var{string})}.
This applies to all classes that implement @code{java.lang.CharSequence}.
Indexing may be a linear-time operation (thus much slower),
unless the string is an @code{IString} (in which case it is constant-time),
@item
@emph{Incompatible change:} Before, if a Java parameter type
was @code{java.lang.String} Kawa would accept any value, converting it
using Object's @code{toString} method.
Now Kawa will reject an argument if it is not a @code{java.lang.CharSequence}.
@item
New procedures: @code{istring?}, @code{reverse-list->string},
@code{string-any}, @code{string-concatenate}, @code{string-concatenate-reverse},
@code{string-contains}, @code{string-contains-right},
@code{string-count}, @code{string-drop},  @code{string-drop-right},
@code{string-every}, @code{string-filter}, @code{string-fold},
@code{string-fold-right}, @code{string-for-each-index},
@code{string-index}, @code{string-index-right}, @code{string-join},
@code{string-map-index}, @code{string-null?},
@code{string-prefix?}, @code{string-prefix-length},
@code{string-repeat}, @code{string-remove}, @code{string-replace},
@code{string-skip}, @code{string-skip-right}, @code{string-split},
@code{string-suffix?}, @code{string-suffix-length},
@code{string-tabulate}, @code{string-take}, @code{string-take-right},
@code{string-trim}, @code{string-trim-right}, @code{string-trim-both},
@code{string-unfold}, @code{string-unfold-right},
@code{string->utf16}, @code{string->utf16be}, @code{string->utf16le},
@code{utf16->string}, @code{utf16be->string}, @code{utf16le->string},
@code{xsubstring}.
These follow SRFI-140 and return immutable strings.
(Some of these had previously been available in SRFI-13,
but the older versions return mutable strings.)
@end itemize
@item
@emph{Incompatible change:} Kawa traditionally followed Java in allowing you
to pass an array with the ``rest'' arguments to a varargs method.
For example, you could write:

@verbatim
(define args (Object[] 3 "cm"))
(java.lang.String:format "length:%s%s" args)
@end verbatim

This is no longer allowed. Instead,
use the splice operator:

@verbatim
(java.lang.String:format "length:%s%s" @args)
@end verbatim
@item
@emph{Incompatible change:} You used to be able to write a
type-specifier in a formal parameter or return type without
using @samp{::}, as in:
@example
(define (incr (x int)) int (+ x 1))
@end example
This is no longer allowed, because it conflicts with the
syntax for patterns.  Instead you have to write:
@example
(define (incr (x ::int)) ::int (+ x 1))
@end example
@item
New type aliases @code{bitvector} and @code{c16vector}.
The latter is a @ref{Uniform vectors,uniform vector} type for wrapping @code{char[]} arrays.
@item
You can convert a Java array (for example a @code{int[]} to the corresponing uniform vector type
(for example @code{u32vector}) using the @code{as} pseudo-function or the corresponding
conversion procedure (for example @code{->u32vector}).  The result shares storage with the
array, so changes in one will update the other.
@item
The expression @code{(module-class)} evaluates to the
containing module class.
@item
Change the @ref{Mangling,mangling} for field and local variables names
to match the @uref{https://blogs.oracle.com/jrose/entry/symbolic_freedom_in_the_vm,Symbolic Freedom} style.
@item
Internally, expressions now record their ending position (line/column),
in addition to the starting position.
@end itemize

@c @subheading In Git repository (master branch) since last release
@c @anchor{#in-git-repository-since-last-release}

@subheading Kawa 2.4 (April 30, 2017)

@itemize
@item
Final 2.x release.
Minor updates and fixes.
@end itemize

@subheading Kawa 2.3 (January 13, 2017)

@itemize
@item
Moved Kawa's source code repository (version control system)
to use git, hosted at @uref{https://gitlab.com/kashell/Kawa,GitLab}.
@item
Issues (bugs, feature requests, etc) should now be reported using the
@uref{https://gitlab.com/kashell/Kawa/issues,GitLab Issue Tracker}.
@item
New @code{with-docbook-stylesheets} to make it easier to build
the documentation with better functionality and look.
@item
The command-line option @code{console:jline-mouse=yes}
enables moving the input cursor using a mouse click,
when using JLine in the REPL on common xterm-like terminals.
This is disabled by default because it conflicts with
other mouse actions, such as making a selection for copying text.
You can press shift to get the terminal's standard mouse handling.
@end itemize

@subheading Kawa 2.2 (November 12, 2016)

@itemize
@item
A binary release is no longer just a Kawa @code{.jar} file,
but is now a @code{zip} archive that also includes
shell/batch scripts for running Kawa, useful
third-party libraries, and the complete documentation in EPUB format.
The archives are named @code{kawa-version.zip}.
@item
The @code{kawa --browse-manual} switch makes it easy to
@ref{browse-manual-option,browse the local documentation}.
@item
The @ref{Composable pictures,@code{(kawa pictures}) library} lets
you create ``picture'' objects,
display them, transform them, combine them, and more.
@item
There is a new @ref{Pretty-printing,API for pretty-printing}.
@item
Basic support for Java 9 (though still some issues).
@item
Generated files like @code{Makefile.in} and @code{configure} are no
longer in the Subversion source code repository, though they are still
included in the distributed @code{kawa-version.tar.gz} releases. The new
top-level script @code{autogen.sh} should be run before
@code{configure}.
@item
Kawa traditionally followed Java in allowing you to pass an array with
the "rest" arguments to a varargs method. (A "varargs" method includes
Java varargs methods, as well as Kawa methods with a @code{#!rest}
parameter that is explicitly typed to be an array type.) For example,
you could write:

@verbatim
(define args (Object[] 3 "cm"))
(java.lang.String:format "length:%s%s" args)
@end verbatim

This is deprecated, and may stop working in a future release. Instead,
use the splice operator:

@verbatim
(java.lang.String:format "length:%s%s" @args)
@end verbatim

@item
More options for @ref{Ranges,range objects}.  For example,
you can write @code{[1 by: 2 <=: 9]}.

@item
Many enhancements to @ref{Arrays,arrays} and vectors:

@itemize
@item
Shape specifiers (used when creating an array) can now be one of a
rank-2 array of low/high-bounds, as in SRFI-25; a vector of upper
bounds; or a vector of ranges.
@item
New type specifiers for array: @code{array} is any array (i.e. any
@code{gnu.lists.Array}); @code{array@var{N}} is the same restricted to rank
@code{@var{N}}; @code{array[etype]} or @code{arrayN[etype]} restrict the types
of elements to @code{etype}.

If the @code{etype} is a primitive type (for example
@code{array2[double]}) then indexing is optimized to method calls that
avoid object allocation.

@item
Generalized array indexing: If A is an array (or a vector), then the
expression:@*
@code{(A I J K ...)}@*
in general evaluates to an array B such that:@*
@code{(B i1 i2 ... j1 j2 ... k1 k2 ... ...)} is@*
@code{(A (I i1 i2 ..) (J j1 j2 ...) (K k1 k2 ...) ...)}

If an index I is an integer, it is treated as a zero-index array - a
scalar.

For example: if @code{(define B (A 2 [4 <: 10]))} then @code{(B i)} is
@code{(A 2 (+ i 4))}.

@item
The procedure @code{array-index-ref} is does the above indexing
explicitly: @code{(array-index-ref A I J K ...)} is
@code{(A I J K ...)}. The result is a read-only snapshot.
@item
The procedure @code{array-index-share} is like @code{array-index-ref}
but creates a modifiable view into argument array.
@item
@code{(build-array shape procedure)} is a general constructor for lazy
arrays: If @code{A} is the result, then @code{(A i j k ...)} is
@code{(procedure [I J K ...])}.
@item
@code{array-transform} creates a view, with a mapping of the indexes.
@item
Other new procedures (like those in the Racket math package):
@code{array-size}, @code{array-fill!}, @code{array-copy!},
@code{array-transform}, @code{array-reshape}, @code{array-flatten},
@code{array->vector}, @code{index-array}, @code{build-array}.
@item
Add Common Lisp array reader syntax (@code{#rankA}) with
@uref{https://www.gnu.org/software/guile/manual/html_node/Array-Syntax.html,Guile
extensions}, including reader sypport for multi-dimensional uniform
(primitive) arrays. This is also used when printing arrays.
@item
New @code{format-array} procedure print an array a tabular 2-dimensional
(APL-like) format. This format is used by default in the top-level of
the REPL.
@end itemize

@item
Print bit-vectors using the Common Lisp (and Guile) reader syntax.
For example @code{#*1100110}. Enhanced the reader to read this format.

@item
Various REPL enhancements and new features:

@itemize
@item
The @code{-w} switch to create a new REPL window
can be followed by various sub-options to control @emph{how} and
where the window is created.
For example @code{-wbrowser} creates a new window
using your default web browser.
@item
Prompts are now normally specified using @code{printf}-style templates.
The normal prompt template is specified by the @code{input-prompt1}
variable, while continuation lines use @code{input-prompt2}. These can
be initialized by command-line options @code{console:prompt1} and
@code{console:prompt2}, or otherwise use language-specific defaults. You
can still use @code{set-input-port-prompter!} to set a more general
prompt-procedure, but it is now only called for the initial line of a
command, not continuation lines.
@item
The new @code{--with-jline3} configure option builds support for the
@uref{https://github.com/jline/jline3,JLine (version 3)} library for
handling console input, similar to GNU readline.
@item
Context-dependent command-completion (tab-completion) works when using
JLine.
@end itemize

@item
Various REPL enhancements when using @uref{http://domterm.org/,DomTerm}.
@itemize
@item
If you ``print'' an XML/HTML node, it gets inserted into the DomTerm
objects.  You print images, tables, fancy text, and more.
@item
If you ``print'' a picture object or a @code{BuferredImage}
the picture is shown in the DomTerm console.
@item
You can load or modify styles with the @code{domterm-load-stylesheet}
procedure.
@item
When pretty-printing, calculation of line-breaks and indentation
is handled by DomTerm.
If you change the window width, DomTerm will dynamically
re-calculate the line-breaks of previous pretten output.
This works even in the case of a session saved to an HTML
file, as long as JavaScript is enabled.
@item
Hide/show buttons are emitted as part of the default prompt.
@end itemize
@item
Multiple literals that have the same value (as in @code{equal?}) get
compiled to the same object.
@item
The syntax @code{&<[expr]} is now equivalent to @code{&<@{&[expr]@}},
assuming @code{expr} is an expression that evaluates to a string that
named an existing file. That file is read is the result is the contents
of the file (as if by @code{(path-data expr)}).

@end itemize

@subheading Kawa 2.1 (October 26, 2015)
@anchor{#kawa-2.1-october-26-2015}
Lots of little changes, and some big changes to sequences and strings.

@itemize
@item
Enhancements to the Kawa tutorial.
@item
Added @code{parameter} as a new typename, for Scheme parameter objects.
It can be parameterized (for example @code{parameter[string]}) for
better type inference when "calling" (reading) the parameter.
@item
We now define ``interactive mode'' as a REPL or a source module that
uses the default global top-level environment @emph{or} a source module
imported/required by a interactive module. Interactive mode attempts to
support dynamic re-definition and re-loading of function and other
definitions. This is a work-in-progres; interactive mode currently uses
extra indirection to support re-definitions (at a slight performance
cost).
@item
Various changes and fixes in Path/URI handling. Most significantly, the
resolve argorithm used by @code{resolve-uri} was re-written to use the
algorithm from RFC-3986, rather than the obsolete RFC-2396 algorithm
used by @code{java.net.URI.resolve}.
@item
Change to mangle class and package name in
@uref{https://blogs.oracle.com/jrose/entry/symbolic_freedom_in_the_vm,Symbolic
Freedom} style. This means that class names and class filenames usually
match the source file, even if special charaters are used, except for a
small number of disallowed characters. Note this is currently
@emph{only} used for class and package names.
@item
Allow @code{'synchronized} and @code{'strictfp} as access flags for
methods.
@item
You can now have a type-specifier for @code{define-variable}.

@item
Better support for forward references between macros.

@item
Added unsigned primitive integer types @code{ubyte}, @code{ushort},
@code{uint}, and @code{ulong}. These are represented at run-time by the
corresponding signed types, but Kawa generates code to do unsigned
arithmethic and comparisons. Corresponding boxed classes are
@code{gnu.math.UByte}, @code{gnu.math.UShort}, @code{gnu.math.UInt}, and
@code{gnu.math.ULong}.

@item
Improvements and unification of sequences and strings:

@itemize
@item
The new @code{sequence} type generalizes lists, vectors, arrays,
strings, and more. It is implemented as the @code{java.util.List}
interface, but strings (@code{java.lang.CharSequence}) and Java arrays
are compatible with @code{sequence} and converted as needed.
@item
The @code{length} function is generalized to arbitrary sequences. (For
strings it uses the @code{CharSequence.length} method, which returns the
number of (16-bit) code units. This is different from the
@code{string-length} function, which returns the number of Unicode code
points.)
@item
A new pseudo-character value @code{#\ignorable-char} is introduced. It
is ignored in string-construction contexts.
@item
The function-call syntax for indexing works for all sequences. If the
sequence is a string, the result is the Unicode (20-bit) scalar value at
the specified index. If index references the trailing surrogate of a
surrogate pair the result is @code{#\ignorable-char}. This allows
efficient indexing of strings: Handing of surrogate pairs are handled
automatically as long as @code{#\ignorable-char} is skipped.
@item
Indexing of uniform vector types (such as @code{s64vector} or
@code{f64vector} or @code{u16vector}) now return the ``standard''
primitive type (such as @code{long} or @code{double}) or the new
unsigned primitive (such as @code{ushort}). This improves performance
(since we can generally use primitive types), and improves compatibility
with Java arrays. Specifically, @code{s64vector} now implements
@code{Sequence<Long>}, and thus @code{java.util.List<Long>} Note that
indexing a @code{f64vector} returns a @code{double} which as an object
is a @code{java.lang.Double}, not the Kawa floating-point type
@code{gnu.math.DFloNum}. The result is usually the same, but @code{eqv?}
might return a different result than previously.
@item
The arguments to @code{map}, @code{for-each}, and @code{vector-for-each}
can now be any sequence (including strings and native arrays). The
arguments to @code{vector-for-each} can now be arbitrary
@code{java.util.List} values. All of these are inlined. If the sequence
type is known, more efficient custom code is generated.

@item
A range represents an enumerable sequence, normally integers, but it is
represented compactly using the start value, the step (usually 1), and
size. There is a new convenient syntax for writing a range: if @code{i}
and @code{j} are integers then @code{[i <=: j]} is the sequence of
integers starting at @code{i} and ending at @code{j} (inclusive). You
can also write @code{[i <=: j]} (excludes the upper bound),
@code{[i >: j]} (counts down to @code{j}, exclusive), and
@code{[i >=: j]} (counts down to @code{j}, inclusive).
@item
You can use a sequences of integers to index a sequence. The result is
the sequence of the selected elements. In general
@code{(seq [i0 ... in])} is @code{[(seq i0) ... (seq in)]}. This work
well with ranges: @code{(seq [i <: j])} is the subsequence of @code{seq}
from @code{i} to @code{j} (exclusive).

If the @code{seq} is a string (a @code{CharSequence}) then the result is
also a string. In this case the indexing behavior is slightly different
in that indexing selects (16-bit) code units, which are combined to a
string.

@end itemize

@item
A new @code{dynamic} type is like @code{Object}. However, it forces
runtime lookup and type-checking, and supresses compile-time type check
and errors. (This is similar to C#. It is useful as an escape hatch if
we ever implement traditional strict static type-checking.)
@item
Specifying the parameter type or return type of a function or method
without a '@code{::}' is deprecated and results in a warning.

@item
In @code{--r7rs} mode: The '@code{l}' exponent suffix of a number
literal creates a floating-point double, rather than a
@code{BigInteger}.
@item
Added the hyperbolic functions: sinh, cosh, tanh, asinh, acosh, atanh.
@item
The @code{equal?} function can now handle cyclic lists and vectors. So
can @code{equal-hash}.
@item
The command-line option @code{--with-arg-count=N} allows finer control
of command-line-processing. It is used before an ``action'', and
specifies the @code{N} arguments following the action are set as the
command-line-arguments. After the action, command-line-processing
continues following those @code{N} arguments.
@item
Added the R6RS module @code{(rnrs arithmetic bitwise)}.
@item
The @code{kawa.repl} argument processor now handles @code{-D} options.
@item
The new @code{class} sub-form of @code{import} allows you to import
classes, and give them abbreviated names, like the Java @code{import}
statement. The new form is more compact and convenient than
@code{define-alias}.

You can also use a classname directly, as a symbol, instead of writing
it in the form of a list:

@verbatim
(import (only java.lang.Math PI))
@end verbatim

@item
In the @code{only} clause of the @code{import} syntax you can now
directly rename, without having to write a @code{rename} clause.
@item
Changes in the calling-convention for @code{--full-tailcalls} yields a
substantial speed-up in some situations.
@item
The type of boolean literals @code{#f} and @code{#t} is now primitive
@code{boolean} rather than @code{java.lang.Boolean}.
@item
General multi-dimensional arrays can be indexed with function call
notation. E.g. @code{(arr i j k)} is equivalent to
@code{(array-ref a i j k)}. You can also use @code{set!} with either
@code{array-ref} or function call notation.
@item
The @code{#!null} value (Java @code{null}) is now considered false, not
true. Likewise for non-canonical false Boolean objects (i.e. all
instances of @code{java.lang.Boolean} for which @code{booleanValue}
returns false, not just @code{Boolean.FALSE}).

@item
New standard libraries @code{(kawa base)} and @code{(kawa reflect)}.
@item
You can now use patterns in the @code{let} form and related forms.

@item
Implemented the @uref{http://en.wikipedia.org/wiki/Lambda_lifting,lambda
lifting} optimzation.
@item
An expression that has type T is now considered compatible with a
context requiring an interface type I only if T implements I (or T is
Object). (Before they were considered possibly-compatible if T was
non-final because the run-time class might be a subclass of T that
implements I.)
@item
New @code{--console} flag forces input to be treated as an interactive
console, with prompting. This is needed on Windows under Emacs, where
@code{System.console()} gives the wrong result.
@item
You can now in a sub-class reference fields from not-yet-compiled
super-classes. (This doesn't work for methods yet.)
@item
The @code{(? name::type value)} operator supports conditional binding.
The @code{(! name::type value)} operator supports unconditional binding;
it is similar to @code{define-constant}, but supports patterns.

@item
More efficient implementation of @code{call-with-values}: If either
argument is a fixed-arity lambda expression it is inlined. Better
type-checking of both @code{call-with-values} and @code{values}.

@item
Jamison Hope enhanced the support for quaternions, primarily the new
@code{(kawa rotations)} library.
@end itemize

@subheading Kawa 2.0 (December 2 2014)
@anchor{#kawa-2.0-december-2-2014}
There are many new features, but the big one is R7RS compatibility.

@itemize
@item
New @code{define-alias} can define aliases for static class members.
@item
The treatment of keywords is changing to not be self-evaluating (in
Scheme). If you want a literal keyword, you should quote it. Unquoted
keywords should only be used for keyword arguments. (This will be
enforced in a future release.) The compiler now warns about badly formed
keyword arguments, for example if a value is missing following a
keyword.
@item
The default is now Java 7, rather than Java 6. This means the checked-in
source code is pre-processed for Java 7, and future binary releases will
require Java 7.
@item
The behavior of parameters and fluid variables has changed. Setting a
parameter no longer changes its value in already-running sub-threads.
The implementation is simpler and should be more efficient.

@item
The form @code{define-early-constant} is similar to
@code{define-constant}, but it is evaluated in a module's class
initializer (or constructor in the case of a non-static definition).
@item
Almost all of R7RS is now working:

@itemize
@item
Importing a SRFI library can now use the syntax
@code{(import (srfi N [name]))}
@item
The various standard libraries such as @code{(scheme base)} are
implemented.
@item
The functions @code{eval} and @code{load} can now take an
environment-specifier. Implemented the @code{environment} function.
@item
Extended @code{numerator}, @code{denominator}, @code{gcd}, and
@code{lcm} to inexacts.
@item
The full R7RS library functionality is working, including
@code{define-library} The keyword @code{export} is now a synonym for
@code{module-export}, and both support the @code{rename} keyword. The
@code{prefix} option of @code{import} now works.

@item
The @code{cond-expand} form now supports the @code{library} clause.
@item
Implemented @code{make-promise} and @code{delay-force} (equivalent to
the older name @code{lazy}).
@item
Changed @code{include} so that by default it first seaches the directory
containing the included file, so by default it has the same effect as
@code{include-relative}. However, you can override the search path with
the @code{-Dkawa.include.path} property. Also implemented
@code{include-ci}.
@item
Implemented @code{define-values}.
@item
Fixed @code{string->number} to correctly handle a radix specifier in the
string.
@item
The @code{read} procedure now returns mutable pairs.
@item
If you need to use @code{...} in a @code{syntax-rules} template you can
use @code{(... template)}, which disables the special meaning of
@code{...} in @code{template}. (This is an extension of the older
@code{(... ...)}.)
@item
Alternatively, you can can write
@code{(syntax-rules dots (literals) rules)}. The symbol @code{dots}
replaces the functionality of @code{...} in the @code{rules}.
@item
An underscore @code{_} in a @code{syntax-rules} pattern matches
anything, and is ignored.
@item
The @code{syntax-error} syntax (renamed from @code{%syntax-error})
allows error reporting in @code{syntax-rules} macros. (The older
Kawa-specific @code{syntax-error} procedure was renamed to
@code{report-syntax-error}.)
@item
Implemented and documented R7RS exception handling: The syntax
@code{guard} and the procedures @code{with-exception-handler},
@code{raise}, and @code{raise-continuable} all work. The @code{error}
procedure is R7RS-compatible, and the procedures @code{error-object?},
@code{error-object-message}, @code{error-object-irritants},
@code{file-error?}, and @code{read-error?} were implemented.

@item
Implemented @code{emergency-exit}, and modified @code{exit} so
finally-blocks are executed.

@item
Implemented @code{exact-integer?}, @code{floor/}, @code{floor-quotient},
@code{floor-remainder}, @code{truncate/}, @code{truncate-quotient}, and
@code{truncate-remainder}.
@item
The @code{letrec*} syntax is now supported. (It works the same as
@code{letrec}, which is an allowed extension of @code{letrec}.)

@item
The functions @code{utf8->string} and @code{string->utf8} are now
documented in the manual.

@end itemize

@item
The changes to characters and strings are worth covering separately:

@itemize
@item
The @code{character} type is now a new primitive type (implemented as
@code{int}). This can avoid boxing (object allocation)
@item
There is also a new @code{character-or-eof}. (A union of
@code{character} and the EOF value, except the latter is encoded as -1,
thus avoiding object allocation.) The functions read-char and
@code{peek-char} now return a @code{character-or-eof} value.
@item
Functions like @code{string-ref} that take a character index would not
take into account non-BMP characters (those whose value is greater than
@code{#xffff}, thus requiring two surrogate characters). This was
contrary to R6RS/R7RS. This has been fixed, though at some performance
cost . (For example @code{string-ref} and @code{string-length} are no
longer constant-time.)
@item
Implemented a @uref{Strings.html#String-Cursor-API,@code{string-cursor}
API} (based on Chibi Scheme). Thes allow efficient indexing, based on
opaque cursors (actually counts of 16-bits @code{char}s).
@item
Optimized @code{string-for-each}, which is now the preferred way to
iterate through a string.
@item
Implemented @code{string-map}.
@item
New function @code{string-append!} for in-place appending to a mutable
string.
@item
New function @code{string-replace!} for replacing a substring of a
string with some other string.
@item
The SRFI-13 function @code{string-append/shared} is no longer
automatically visible; you have to @code{(import (srfi :13 strings))} or
similar.
@end itemize

@item
The @code{module-name} form allows the name to be a list, as in a
R6RS/R7RS-style library name.
@item
The syntax @code{@@expression} is a @emph{splicing form}. The
@code{expression} must evaluate to a sequence (vector, list, array,
etc). The function application or constructor form is equivalent to all
the elements of the sequence.
@item
The parameter object @code{current-path} returns (or sets) the default
directory of the current thread.
@item
Add convenience procedures and syntax for @uref{Processes.html,working
with processes}: @code{run-process}, @code{process-exit-wait},
@code{process-exit-ok?}, @code{&cmd}, @code{&`}, @code{&sh}.
@item
The functions @code{path-bytes}, and @code{path-data} can
@uref{http://www.gnu.org/software/kawa/Reading-and-writing-whole-files.html,read
or write the entire contents of a file}. Alternatively, you can use the
short-hand syntax: @code{&<@{pname@}} @code{&>@{pname@}}
@code{&>>@{pname@}}. These work with "blobs" which may be text or binary
depending on context.
@item
The initial values of @code{(current-output-port)} and
@code{(current-error-port)} are now hybrid textual/binary ports. This
means you can call @code{write-bytevector} and @code{write-u8} on them,
making it possible for an application to write binary data to standard
output. Similarly, initial value of @code{(current-input-port)} is a
hybrid textual/binary port, but only if there is no console (standard
input is not a tty).

@item
Jamison Hope contributed support for
@uref{http://en.wikipedia.org/wiki/Quaternion,quaternions}, a
generalization of complex numbers containing 4 real components.

@item
Andrea Bernardini contributed an optimized implementation of @code{case}
expressions. He was sponsored by Google Summer of Code.
@item
The @code{kawa.sh} shell script (which is installed as @code{kawa} when
@emph{not} configuring with @code{--enable-kawa-frontend}) now handles
@code{-D} and @code{-J} options. The @code{kawa.sh} script is now also
built when usint Ant.
@item
The @code{cond-expand} features @code{java-6} though @code{java-9} are
now set based on the @code{System} property @code{"java.version"}
(rather than how Kawa was configured).
@item
An Emacs-style @code{coding} declaration allows you to specify the
encoding of a Scheme source file.
@item
The command-line option @code{--debug-syntax-pattern-match} prints
logging importation to standard error when a @code{syntax-rules} or
@code{syntax-case} pattern matches.
@item
@uref{http://srfi.schemers.org/srfi-60/srfi-60.html,SRFI-60 (Integers as
Bits)} is now fully implemented.

@item
Ported @uref{http://srfi.schemers.org/srfi-101/srfi-101.html,SRFI-101}.
These are immutable (read-only) lists with fast (logarithmic) indexing
and functional update (i.e. return a modified list). These are
implemented by a @code{RAPair} class which extends the generic
@code{pair} type, which means that most code that expects a standard
list will work on these lists as well.

@item
The class @code{kawa.lib.kawa.expressions} contains an experimental
Scheme API for manipulating and validating expressions.
@item
Internal: Changed representation used for multiple values to an abstract
class with multiple implementations.

@item
Internal: Started converting to more standard Java code formatting and
indentation conventions, rather than GNU conventions. Some files
converted; this is ongoing work.
@item
Internal: Various I/O-related classes moved to new package
@code{gnu.kawa.io}.

@item
Various changes to the @code{configure+make} build framework: A C
compiler is now only needed if you configure with
@code{--enable-kawa-frontend}. Improved support for building under
Windows (using MinGW/MSYS).

@item
Support for building with @uref{http://gcc.gnu.org/java/,GCJ} was
removed.

@end itemize

@subheading Kawa 1.14 (October 4, 2013)
@anchor{#kawa-1.14-october-4-2013}
@itemize
@item
You can pass flags from the @code{kawa} front-end to the @code{java}
launcher using @code{-J} and @code{-D} flags. The @code{kawa} front-end
now passes the @code{kawa.command.line} property to Java; this is used
by the @code{(command-line)} procedure.
@item
Various improvements to the shell-script handling, including
@uref{Scripts.html,re-written documentation}.
@item
Some initial support for Java 8.

@item
More of R7RS is now working:

@itemize
@item
After adding list procedures @code{make-list}, @code{list-copy},
@code{list-set!} all the R7RS list procedures are implemented.
@item
Other added procedures: @code{square}, @code{boolean=?},
@code{string-copy!}, @code{digit-value},
@code{get-environment-variable}, @code{get-environment-variables},
@code{current-second}, @code{current-jiffy}, @code{jiffies-per-second},
and @code{features}.
@item
The predicates @code{finite?}, @code{infinite?}, and @code{nan?} are
generalized to complex numbers.
@item
The procedures @code{write}, @code{write-simple}, and
@code{write-shared} are now consistent with R7RS.
@item
String and character comparison functions are generalized to more than
two arguments (but restricted to strings or characters, respectively).
@item
The procedures @code{string-copy}, @code{string->list}, and
@code{string-fill!} now take optional (start,end)-bounds. All of the
R7RS string functions are now implemented.
@item
Support @code{=>} syntax in @code{case} form.
@item
Support backslash-escaped special characters in symbols when inside
vertical bars, such as @code{'|Hello\nworld|}.
@item
The new functions and syntax are documented in the @uref{index.html,Kawa
manual}; look for the functions in the @uref{Overall-Index.html,index}.
@end itemize

@item
Added @code{define-private-alias} keyword.
@item
Extended @uref{Strings.html#String-templates,string quasi-literals
(templates)} as specified by
@uref{http://srfi.schemers.org/srfi-109/srfi-109.html,SRFI-109}. For
example, if @code{name} has the value @code{"John"}, then:

@verbatim
&{Hello &[name]!}
@end verbatim

evaluates to: @code{"Hello John!"}.

@item
Named quasi-literal constructors as specified by
@uref{http://srfi.schemers.org/srfi-108/srfi-108.html,SRFI-108}.
@item
A symbol having the form @code{->type} is a type conversion function
that converts a value to @code{type}.
@item
New and improved check for void-valued expressions in a context
requiring a value. This is controlled by the new option
@code{--warn-void-used}, which defaults to true.

@item
The @code{datum->syntax} procedure takes an optional third parameter to
specify the source location. See @code{testsuite/srfi-108-test.scm} for
an example.
@item
Instead of specifying @code{--main} the command line, you can now
specify @code{(module-compile-options: main: #t)} in the Scheme file.
This makes it easier to compile one or more application (main) modules
along with other modules.
@item
A change to the data structure used to detect never-returning procedure
uses a lot less memory. (Kawa 1.13 implemented a conservative detection
of when a procedure cannot return. This analysis would sometimes cause
the Kawa compiler to run out of memory. The improved analysis uses the
same basic algorithm, but with a more space-efficient ``inverted'' data
structure.)
@item
Multiple fixes to get Emacs Lisp (JEmacs) working (somewhat) again.
@end itemize

@subheading Kawa 1.13 (December 10, 2012)
@anchor{#kawa-1.13-december-10-2012}
@itemize
@item
We now do a simple (conservative) analysis of when a procedure cannot
return. This is combined with earlier and more precise analysis of
reachable code. Not only does this catch programmer errors better, but
it also avoids some internal compiler errors, because Kawa could get
confused by unreachable code.
@item
Implement 2-argument version of @code{log} function, as specified by
R6RS and R7RS (and, prematurely, the Kawa documentation).
@item
Implement the R7RS @code{bytevector} functions. The @code{bytevector}
type is a synonym for older @code{u8vector} type.

@item
Implement R7RS @code{vector} procedures. Various procedures now take
(start,end)-bounds.

@item
Implement most of the R7RS input/output proecdures. Most significant
enhancement is support for R7RS-conforming binary ports.
@item
Various enhancements to the manual, including merging in lots of text
from R7RS.
@item
Improved Android support, including a more convenient Ant script
contributed by Julien Rousseau. Also, documentation merged into manual.
@end itemize

@subheading Kawa 1.12 (May 30, 2012)
@anchor{#kawa-1.12-may-30-2012}
@itemize
@item
Implement a compile-time data-flow framework, similar to Single Static
Assignment. This enables better type inference, improves some
warnings/errors, and enables some optimizations.

@item
Jamison Hope added support for co-variant return types and bridge
methods for generics.
@item
Macros were improved and more standards-conforming:
@itemize
@item
@code{datum->syntax} and @code{syntax->datum} are preferred names for
@code{datum->syntax-object} and @code{syntax-object->datum}.
@item
Implemented @code{bound-identifier=?} and re-wrote implementation of
@code{free-identifier=?}.

@item
Implement @code{unsyntax} and @code{unsyntax-splicing}, along with the
reader prefixes @code{#,} and @code{#,@@}.
@end itemize

@item
New and improved lazy evaluation functionality:

@itemize
@item
Lazy values (resulting from @code{delay} or @code{future}) are
implicitly forced as needed. This makes ``lazy programming'' more
convenient.
@item
New type @code{promise}.
@item
The semantics of promises (@code{delay} etc) is now compatible with
@uref{http://srfi.schemers.org/srfi-45/srfi-45.html,SRFI 45}.
@item
``Blank promises'' are useful for passing data between processes, logic
programmming, and more. New functions @code{promise-set-value!},
@code{promise-set-alias!}, @code{promise-set-exception!}, and
@code{promise-set-thunk!}.
@item
The stream functions of
@uref{http://srfi.schemers.org/srfi-41/srfi-41.html,SRFI-41} were
re-implemented to use the new promise functionality.
@end itemize

@item
Different functions in the same module can be compiled with or without
full tailcall support. You can control this by using
@code{full-tailcalls} in @code{with-compile-options}. You can also
control @code{full-tailcalls} using @code{module-compile-options}.

@item
Charles Turner (sponsored by @uref{http://code.google.com/soc/,Google's
Summer of Code}) enhanced the printer with support for
@uref{http://srfi.schemers.org/srfi-38/,SRFI-38: External Representation
for Data With Shared Structure}.

@item
Optimize tail-recursion in module-level procedures. (We used to only do
this for internal functions, for reasons that are no longer relevant.)

@item
Add support for building Kawa on Windows using configure+make
(autotools) and Cygwin.

@item
Some support for parameterized (generic) types:

@verbatim
  Type[Arg1 Arg2 ... ArgN]
@end verbatim

is more-or-less equivalent to Java's:

@verbatim
  Type<Arg1, Arg2, ..., ArgN>
@end verbatim

@item
New language options @code{--r5rs}, @code{--r6rs}, and @code{--r7rs}
provide better compatibility with those Scheme standards. (This is a
work-in-progress.) For example @code{--r6rs} aims to disable Kawa
extensions that conflict with R6RS. It does not aim to disable all
extensions, only incompatible extensions. So far these extensions
disable the colon operator and keyword literals. Selecting @code{--r5rs}
makes symbols by default case-insensitive.

@item
The special tokens @code{#!fold-case} and @code{#!no-fold-case} act like
comments except they enable or disable case-folding of symbols. The old
@code{symbol-read-case} global is now only checked when a LispReader is
created, not each time a symbol is read.
@item
You can now use square brackets to construct immutable sequences
(vectors).
@item
A record type defined using @code{define-record-type} is now compiled to
a class that is a member of the module class.

@item
Annotations are now supported.
@uref{http://per.bothner.com/blog/2011/Using-JAXB-annotations/,This
example} shows how to use
@uref{http://java.sun.com/xml/downloads/jaxb.html,JAXB} annotations to
automatically convert between between Java objects and XML files.
@item
Prevent mutation of vector literals.

@item
More R6RS procedures: @code{vector-map}, @code{vector-for-each},
@code{string-for-each}, @code{real-valued?}, @code{rational-valued?},
@code{integer-valued?}, @code{finite?}, @code{infinite?}, @code{nan?},
@code{exact-integer-sqrt}.

@item
@uref{http://srfi.schemers.org/srfi-14/srfi-14.html,SRFI-14} ("character
sets") and @uref{http://srfi.schemers.org/srfi-41/srfi-41.html,SRFI-41}
("streams") are now supported, thanks to porting done by Jamison Hope.

@item
Kawa now runs under JDK 1.7. This mostly involved fixing some errors in
@code{StackMapTable} generation.

@item
You can now have a class created by @code{define-simple-class} with the
same name as the module class. For example
@code{(define-simple-class foo ...)} in a file @code{foo.scm}. The
defined class will serve dual-purpose as the module class.
@item
Improvements in separating compile-time from run-time code, reducing the
size of the runtime jar used for compiled code.
@item
In the @code{cond-expand} conditional form you can now use
@code{class-exists:ClassName} as a feature ``name'' to tests that
@code{ClassName} exists.
@end itemize

@subheading Kawa 1.11 (November 11, 2010)
@anchor{#kawa-1.11-november-11-2010}
@itemize
@item
A new Kawa logo, contributed by @uref{http://jcubic.pl,Jakub
Jankiewicz}.
@item
A new @code{--warn-unknown-member} option, which generalizes
@code{--warn-invoke-unknown-method} to fields as well as methods.
@item
A new @uref{ant-kawac.html,@code{kawac} task}, useful for Ant
@code{build.xml} files, contributed by Jamison Hope.
@item
@uref{http://per.bothner.com/blog/2010/AndroidHelloScheme,Updated
Android support}.
@item
New @uref{Enumerations.html,@code{define-enum} macro} contributed by
Jamison Hope.
@item
Access specifiers @code{'final} and @code{'enum} are now allowed in
@code{define-class} and related forms.
@item
Optimized @code{odd?} and @code{even?}.
@item
If you specify the type of a @code{#!rest} parameter as an array type,
that will now be used for the "varargs" method parameter. (Before only
object arrays did this.)
@item
When constructing an object and there is no matching constructor method,
look for "@code{add}" methods in addition to "@code{set}" methods. Also,
allow passing constructor args as well as keyword setters.
@uref{Allocating-objects.html,See here} for the gory details.
@item
New @code{expand} function (contributed by Helmut Eller, and enabled by
@code{(require 'syntax-utils)}) for converting Scheme expressions to
macro-expanded forms.
@item
@uref{Anonymous-classes.html#SAM-conversion,SAM-conversion}: In a
context that expects a Single Abstract Method (SAM) type (for example
@code{java.lang.Runnable}), if you pass a lambda you will get an
@code{object} where the lambda implements the abstract method.

@item
In interactive mode allow dynamic rebinding of procedures. I.e. if you
re-define a procedure, the old procedure objects gets modified in-place
and re-used, rather than creating a new procedure object. Thus calls in
existing procedures will call the new version.

@item
Fix various threading issues related to compilation and eval.

@item
When @code{format} returns a string, return a @code{java.lang.String}
rather than a @code{gnu.lists.FString}. Also, add some minor
optimization.
@item
Inheritance of environments and fluid variables now work properly for
all child threads, not just ones created using @code{future}.

@end itemize

@subheading Kawa 1.10 (July 24, 2010)
@anchor{#kawa-1.10-july-24-2010}
@itemize
@item
Now defaults to using Java 6, when compiling from source. The pre-built
@code{jar} works with Java 5, but makes use of some Java 6 features
(@code{javax.script}, built-in HTTP server) if available.
@item
You can write @uref{XML-literals.html,XML literals} in Scheme code
prefixed by a @code{#}, for example:

@verbatim
#<p>The result is &{result}.</p>
@end verbatim

@item
New functions @code{element-name} and @code{attribute-name}.
@item
Various @uref{Server-side-scripts.html,Web server improvements}. You
have the option of using JDK 6's builtin
@uref{Options.html#Options-for-web-servers,web-server} for
@uref{Self-configuring-page-scripts.html,auto-configued web pages}.
Automatic import of web server functions, so you should not need to
@code{(import 'http)} any more.
@item
Kawa @uref{Hash-tables.html,hashtables} now extend @code{java.util.Map}.

@item
If a source file is specified on the @code{kawa} command line without
any options, it is read and compiled as a whole module before it is run.
In contrast, if you want to read and evaluate a source file line-by-line
you must use the @code{-f} flag.

@item
You can specify a class name on the @code{kawa} command line:

@verbatim
$ kawa fully.qualified.name
@end verbatim

This is like the @code{java} command. but you don't need to specify the
path to the Kawa runtime library, and you don't need a @code{main}
method (as long as the class is @code{Runnable}).

@item
The usual bug-fixes, including better handling of the @code{~F}
@code{format} directive; and fix in handling of macro hygiene of the
@code{lambda} (@uref{https://savannah.gnu.org/bugs/index.php?27042,bug
#27042}).

@item
Spaces are now optional before and after the '::' in type specifiers.
The preferred syntax leave no space after the '::', as in:

@verbatim
(define xx ::int 1)
@end verbatim

@item
@code{define-for-syntax} and @code{begin-for-syntax} work.

@item
You can now use @code{car}, @code{cdr} etc to work with @code{syntax}
objects that wrap lists, as in SRFI-72.

@item
You can now define a package alias:

@verbatim
(define-alias jutil java.util)
(define mylist :: jutil:List (jutil:ArrayList))
@end verbatim

@item
@code{--module-static} is now the default. A new
@code{--module-nonstatic} (or @code{--no-module-static}) option can be
used to get the old behavior.

@item
You can use @code{access:} to specify that a field is @code{'volatile}
or @code{'transient}.

@item
You can now have type-specifiers for multiple variables in a @code{do}.

@item
Imported variables are read-only.

@item
Exported variables are only made into Locations when needed.

@item
The letter used for the exponent in a floating-point literal determines
its type: @code{12s2} is a @code{java.lang.Float}, @code{12d2} is a
@code{java.lang.Double}, @code{12l2} is a @code{java.math.BigInteger},
@code{12e2} is a @code{gnu.math.DFloat}.

@item
Internal: Asking for a @code{.class} file using
@code{getResourceAsStream} on an @code{ArrayClassLoader} will now open a
@code{ByteArrayInputStream} on the class bytes.

@item
A new @code{disassemble} function.

@item
If @code{exp1} has type @code{int}, the type of @code{(+ exp1 1)} is now
(32-bit) @code{int}, rather than (unlimited-precision) @code{integer}.
Similar for @code{long} expressions, other arithmetic operations (as
appropriate), and other untyped integer literals (as long as they fit in
32/64 bits respectively).

@item
Many more oprimization/specializations of arithmetic, especially when
argument types are known.

@item
Top-level bindings in a module compiled with @code{--main} are now
implicitly module-private, unless there is an explicit
@code{module-export}.

@item
@uref{http://srfi.schemers.org/srfi-2/srfi-2.html,SRFI-2}
(@code{and-let*}: an @code{and} with local bindings, a guarded @code{*}
special form) is now supported.

@item
The reader now supports shared sub-objects, as in
@uref{http://srfi.schemers.org/srfi-38/srfi-38.html,SRFI-38} and Common
Lisp: @code{(#2=(3 4) 9 #2# #2#)}. (Writing shared sub-objects is not
yet implemented.)

@item
A module compiled with @code{--main} by default exports no bindings
(unless overriden by an explicit @code{module-export}).

@item
Factor out compile-time only code from run-time code. The new
@code{kawart-version.jar} is smaller because it has less compile-time
only code. (Work in progress.)
@item
More changes for R6RS compatibility:

@itemize
@item
The reader now recognizes @code{+nan.0}, @code{+inf.0} and variations.

@item
The @code{div}, @code{mod}, @code{div0}, @code{mod0},
@code{div-and-mod}, @code{div0-and-mod0}, @code{inexact} and
@code{exact} functions were implemented.

@item
@code{command-line} and @code{exit}.

@end itemize

@end itemize

@subheading Kawa 1.9.90 (August 8, 2009)
@anchor{#kawa-1.9.90-august-8-2009}
@itemize
@item
Support for @code{javax.script}.

@item
Support for @uref{Regular-expressions.html,regular expressions}.

@item
Performance improvements:

@itemize
@item
Emit @code{iinc} instruction (to increment a local @code{int} by a
constant).

@item
Inline the @code{not} function if the argument is constant.

@item
If @code{call-with-current-continuation} is only used to exit a block in
the current method, optimize to a @code{goto}.

@item
Generate @code{StackMapTable} attributes when targeting Java 6.

@item
Kawa can now inline a function with multiple calls (without code
duplication) if all call sites have the same return location
(continuation). For example: @code{(if p (f a) (f b))}. Also mutually
tail-recursive functions are inlined, so you get constant stack space
even without @code{--full-tailcalls}. (Thanks for Helmut Eller for a
prototype.)
@end itemize

@item
A number of changes for R6RS compatibility:

@itemize
@item
The @code{char-titlecase}, @code{char-foldcase}, @code{char-title-case?}
library functions are implemented.

@item
Imported variables are read-only.

@item
Support the R6RS @code{import} keyword, including support for renaming.

@item
Support the R6RS @code{export} keyword (though without support for
renaming).

@item
Implemented the @code{(rnrs hashtables)} library.

@item
Implemented the @code{(rnrs sorting)} library.

@item
CommonLisp-style keyword syntax is no longer supported (for Scheme): A
colon followed by an identifier is no longer a keyword (though an
identifier followed by a colon is still a keyword). (One reason for this
change is to support SRFI-97.)

@item
The character names @code{#\delete}, @code{#\alarm}, @code{#\vtab} are
now supported. The old names @code{#\del}, @code{#\rubout}, and
@code{#\bel} are deprecated.

@item
Hex escapes in character literals are supported. These are now printed
where we before printed octal escapes.

@item
A hex escape in a string literal should be terminated by a semi-colon,
but for compatibily any other non-hex-digit will also terminate the
escape. (A terminating semi-colon will be skipped, though a different
terminator will be included in the string.)

@item
A backslash-whitespace escape in a string literal will not only ignore
the whitespace through the end of the line, but also any initial
whitespace at the start of the following line.

@item
The comment prefix @code{#;} skips the following S-expression, as
specified by
@uref{http://srfi.schemers.org/srfi-62/srfi-62.html,SRFI-62}.

@item
All the
@uref{http://www.r6rs.org/final/html/r6rs-lib/r6rs-lib-Z-H-12.html#node_sec_11.4,R6RS
exact bitwise arithmetic} functions are now implemented and
@uref{Logical-Number-Operations.html,documented in the manual}. The new
standard functions (for example @code{bitwise-and}) are now preferred
over the old functions (for example @code{logand}).

@item
If @code{delete-file} fails, throws an exception instead of returning
@code{#f}.

@end itemize

@item
The code-base now by default assumes Java 5 (JDK 1.5 or newer), and
pre-built @code{jar} files will require Java 5. Also, the Kawa source
code now uses generics, so you need to use a generics-aware
@code{javac}, passing it the appropriate @code{--target} flag.

@item
New SRFIs supported:

@itemize
@item
@uref{http://srfi.schemers.org/srfi-62/srfi-62.html,SRFI-62} -
S-expression comments.

@item
@uref{http://srfi.schemers.org/srfi-64/srfi-64.html,SRFI-64} - Scheme
API for test suites.

@item
@uref{http://srfi.schemers.org/srfi-95/srfi-95.html,SRFI-95} - Sorting
and Merging.

@item
@uref{http://srfi.schemers.org/srfi-97/srfi-97.html,SRFI-97} - Names for
SRFI Libraries. This is a naming convention for R6RS @code{import}
statements to reference SRFI libraries.

@end itemize

@item
In BRL text outside square brackets (or nested like @code{]this[}) now
evaluates to @code{UnescapedData}, which a Scheme quoted string
evaluates to @code{String}, rather than an @code{FString}. (All of the
mentioned types implement @code{java.lang.CharSequence}.)

@item
You can now
@uref{http://per.bothner.com/blog/2009/AndroidHelloScheme/,run Kawa
Scheme programs on Android}, Google's mobile-phone operating system.

@item
The macro @code{resource-url} is useful for accessing resources.

@item
A new command-line option @code{--target} (or @code{-target}) similar to
@code{javac}'s @code{-target} option.

@item
If there is no console, by default create a window as if @code{-w} was
specificed.

@item
If a class method (defined in @code{define-class},
@code{define-simple-class} or @code{object}) does not have its parameter
or return type specified, search the super-classes/interfaces for
matching methods (same name and number of parameters), and if these are
consistent, use that type.

@item
Trying to modify the @code{car} or @code{cdr} of a literal list now
throws an exception.

@item
The @code{.zip} archive created by @code{compile-file} is now
compressed.

@item
Java5-style varargs-methods are recognized as such.

@item
When evaluating or loading a source file, we now always compile to
bytecode, rather than interpreting ``simple'' expressions. This makes
semantics and performance more consistent, and gives us better exception
stack traces.

@item
The Scheme type specifier @code{<integer>} now handles automatic
conversion from @code{java.math.BigInteger} and the @code{java.lang}
classes @code{Long}, @code{Integer}, @code{Short}, and @code{Byte}. The
various standard functions that work on @code{<integer>} (for example
@code{gcd} and @code{arithmetic-shift}) can be passed (say) a
@code{java.lang.Integer}. The generic functions such as @code{+} and the
real function @code{modulo} should also work. (The result is still a
@code{gnu.math.IntNum}.)

@item
If a name such as (@code{java.util}) is lexically unbound, and there is
a known package with that name, return the @code{java.lang.Package}
instance. Also, the colon operator is extended so that
@code{package:name} evaluates to the @code{Class} for
@code{package.name}.

@item
@code{`prefix:,expression} works - it finds a symbol in @code{prefix}'s
package (aka namespace), whose local-name is the value of
@code{expression}.

@item
A quantity @code{3.0cm} is now syntactic sugar for
@code{(* 3.0 unit:cm)}. Similarly:@*
@code{(define-unit name value)}@*
is equivalent to:@*
@code{(define-constant unit:name value)}@*
This means that unit names follow normal name-lookup rules (except being
in the @code{unit} ``package''), so for example you can have local unit
definitions.

@item
You can specify whether a class has public or package access, and
whether it is translated to an interface or class.

@item
You can declare an abstract method by writing @code{#!abstract} as its
body.

@item
If a name of the form @code{type?} is undefined, but @code{type} is
defined, then treat the former as
@code{(lambda (x) (instance? x type))}.
@item
A major incompatible (but long-sought) change: Java strings (i.e.
@code{java.lang.String} values) are now Scheme strings, rather than
Scheme symbols. Since Scheme strings are mutable, while Java
@code{String}s are not, we use a different type for mutable strings:
@code{gnu.lists.FString} (this is not a change). Scheme string literals
are @code{java.lang.String} values. The common type for Scheme string is
@code{java.lang.CharSequence} (which was introducted in JDK 1.4).

Scheme symbols are now instances of
@uref{api/gnu/mapping/Symbol.html,@code{gnu.mapping.Symbol}},
specifically the @code{SimpleSymbol} class.

@item
A fully-qualified class name such as @code{java.lang.Integer} now
evaluates to the corresponding @code{java.lang.Class} object. I.e. it is
equivalent to the Java term @code{java.lang.Integer.class}. This assumes
that the name does not have a lexical binding, @emph{and} that it exists
in the class-path at compile time.

Array class names (such as @code{java.lang.Integer[]}) and primitive
types (such as @code{int}) also work.

The older angle-bracket syntax @code{<java.lang.Integer>} also works and
has the same meaning. It also evaluates to a @code{Class}. It used to
evaluate to a @uref{api/gnu/bytecode/Type.html,@code{Type}}, so this is
a change.

The name bound by a @code{define-simple-class} now evaluates to a
@code{Class}, rather than a
@uref{api/gnu/bytecode/ClassType.html,@code{ClassType}}. A
@code{define-simple-class} is not allowed to reference non-static
module-level bindings; for that use @code{define-class}.

@item
New convenience macro
@uref{Syntax-and-conditional-compilation.html,@code{define-syntax-case}}.

@end itemize

@subheading Kawa 1.9.1 (January 23, 2007)
@anchor{#kawa-1.9.1-january-23-2007}
@itemize
@item
Fix some problems building Kawa from source using @code{configure+make}.
@end itemize

@subheading Kawa 1.9.0 (January 21, 2007)
@anchor{#kawa-1.9.0-january-21-2007}
@itemize
@item
New types and functions for working with @uref{Paths.html,paths and
URIs}.

@item
Reader macros URI, namespace, duration.

@item
Simplified @uref{Source-distribution.html,build using gcj}, and added
configure flag --with-gcj-dbtool.

@item
If two ``word'' values are written, a space is written between them. A
word is most Scheme values, including numbers and lists. A Scheme string
is treated as a word by @code{write} but by not @code{display}.

@item
A new @code{--pedantic} command-line flag. It currently only affects the
XQuery parser.

@item
The @code{load-compile} procedure was removed.

@item
The string printed by the @code{--version} switch now includes the
Subversion revision and date (but only if Kawa was built using
@code{make} rather than @code{ant} from a checked-out Subversion tree).

@item
Kawa development now uses the
@uref{http://subversion.tigris.org/,Subversion (svn)} version control
system instead of CVS.

@item
Show file/line/column on unbound symbols (both when interpreted and when
compiled).

@item
Cycles are now allowed between @code{require}'d modules. Also, compiling
at set of modules that depend on each other can now specified on the
compilation command line in any order, as long as needed @code{require}
forms are given.

@item
The @uref{PathExpressions.html,``colon notation'' has been
generalized.}. The syntax @code{object:name} generally means to extract
a component with a given @code{name} from @code{object}, which may be an
object, a class, or a namespace.

@item
New command-line options @code{--debug-error-prints-stack-trace} and
@code{--debug-warning-prints-stack-trace} provide stack trace on static
error messages.

@item
The @uref{Software-License.html,license for the Kawa software} has been
changed to the
@uref{http://opensource.org/licenses/mit-license.php,X11/MIT license}.

@item
A much more @uref{Array-operations.html,convenient syntax for working
with Java arrays}.

The same function-call syntax also works for Scheme vectors, uniform
vectors, strings, lists - and anything else that implements
@code{java.util.List}.

@item
The fields and methods of a class and its bases classes are in scope
within methods of the class.
@item
Unnamed procedures (such as lambda expressions) are printed with the
source filename and line.

@item
The numeric compare functions (@code{=}, @code{<=}, etc) and
@code{number->string} now work when passed standard Java @code{Number}
objects (such as @code{java.lang.Long} or @code{java.math.BigDecimal}).
@item
@uref{http://srfi.schemers.org/srfi-10/srfi-10.html,SRFI-10} is now
implemented, providing the @code{#,(name args ...)} form. Predefined
constructor @code{name}s so far are @code{URI} and @code{namespace}. The
@code{define-reader-ctor} function is available if you
@code{(require 'srfi-10)}.

@item
A new @code{--script} option makes it easier to write Unix shell
scripts.

@item
Allow general URLs for loading (including the @code{-f} flag),
compilation and @code{open-input-file}, if the ``file name'' starts with
a URL ``scheme'' like @code{http:}.

@item
Classes defined (@emph{e.g.} with @code{define-simple-class}) in a
module can now mutually reference each other. On the other hand, you can
no longer @code{define-class} if the class extends a class rather than
an interface; you must use @code{define-simple-class}.

@item
@code{KawaPageServlet} now automatically selects language.

@item
@code{provide} macro.
@item
@code{quasisyntax} and the convenience syntax @code{#`}, from
@uref{http://srfi.schemers.org/srfi-72/srfi-72.html,SRFI-72}.
@item
@code{define-for-syntax}, @code{syntax-source}, @code{syntax-line}, and
@code{syntax-column}, for better compatibility with mzscheme.
@item
@uref{http://srfi.schemers.org/srfi-34/srfi-34.html,SRFI-34} (Exception
Handling for Programs), which implements @code{with-exception-handler},
@code{guard}, and @code{raise}, is now available, if you
@code{(require 'srfi-34)}.@*
Also, @uref{http://srfi.schemers.org/srfi-35/srfi-35.html,SRFI-35}
(Conditions) is available, if you @code{(require 'srfi-35)}.
@item
The @code{case-lambda} form from
@uref{http://srfi.schemers.org/srfi-16/srfi-16.html,SRFI-16} is now
implemented more efficiently.

@end itemize

@subheading Kawa 1.8 (October 18, 2005)
@anchor{#kawa-1.8-october-18-2005}
@uref{http://srfi.schemers.org/srfi-69/srfi-69.html,SRFI-69 ``Basic hash
tables''} is now available, if you @code{(require 'hash-table)} or
@code{(require 'srfi-69)}. This is an optimized and Java-compatible port
whose default hash function calls the standard @code{hashCode} method.

A @code{define-simple-class} can now have one (or more) explicit
constructor methods. These have the spcial name @code{*init*}. You can
call superclass constructors or sibling constructors (@code{this}
constructor calls) using the (admittedly verbose but powerful)
@code{invoke-special} form.

The @code{runnable} function creates a @code{Runnable} from a
@code{Procedure}. It is implemented using the new class
@code{RunnableClosure}, which is now also used to implement
@code{future}.

The @code{kawa} command can now be run ``in-place'' from the build
directory: @code{$build_dir/bin/kawa}.

The special field name @code{class} in @code{(static-name type 'class)}
or @code{(prefix:.class)} returns the @code{java.lang.Class} object
corresponding to the @code{type} or @code{prefix}. This is similar to
the Java syntax.

Contructing an instance (perhaps using @code{make}) of a class defined
using @code{define-simple-class} in the current module is much more
efficient, since it no longer uses reflection. (Optimizing classes
defined using @code{define-class} is more difficult.) The constructor
function defined by the @code{define-record-type} macro is also
optimized.

You can now access instance methods using this short-hand:
@code{(*:methodname instance arg ...)}@*
This is equivalent to: @code{(invoke instance 'methodname arg ...)}

You can now also access a fields using the same colon-notation as used
for accessing methods, except you write a dot before the field name:@*
@code{(type:.fieldname)} @code{ ;; }is like:
@code{(static-field type 'fieldname)}.@*
@code{(*:.fieldname instance)} @code{;;} is like:
@code{(field 'fieldname instance)}@*
@code{(type:.fieldname instance)} @code{;;} is like:
@code{(*:.fieldname (as instance type))}@*
These all work with @code{set!} - for example:
@code{(set! (*:.fieldname instance) value)}.

In the above uses of colon-notation, a @code{type} can be any one of:@*
- a namespace prefix bound using @code{define-namespace} to a namespace
uri of the form @code{"class:classname"};@*
- a namespace prefix using @code{define-namespace} bound to a
@code{<classname>} name, which can be a fully-qualified class name or a
locally-declared class, or an alias (which might be an imported
class);@*
- a fully qualified name of a class (that exists at compile-time), as in
@code{(java.lang.Integer:toHexString 123)}; or@*
- a @code{<classname>} variable, for example:
@code{(<list>:list3 11 12 13)}.

New fluid variables @code{*print-base*}, @code{*print-radix*},
@code{*print-right-margin*}, and @code{*print-miser-width*} can control
output formatting. (These are based on Common Lisp.)

You can new emit elipsis (@code{...}) in the output of a @code{syntax}
template using the syntax @code{(... ...)}, as in other
@code{syntax-case} implementations.

The @code{args-fold} program-argument processor from
@uref{http://srfi.schemers.org/srfi-37/srfi-37.html,SRFI-37} is
available after you @code{(require 'args-fold)} or
@code{(require 'srfi-37)}.

The @code{fluid-let} form now works with lexical bindings, and should be
more compatible with other Scheme implementations.

@code{(module-export namespace:prefix)} can be used to export a
namespace prefix.

Static modules are now implemented more similarly to non-static modules.
Specifically, the module body is not automatically run by the class
initializer. To get the old behavior, use the new
@code{--module-static-run} flag. Alternatively, instead of
@code{(module-static #t)} use @code{(module-static 'init-run)}.

Implement @uref{http://srfi.schemers.org/srfi-39/srfi-39.html,SRFI-39}
"Parameter-objects". These are like anonymous fluid values and use the
same implementation. @code{current-input-port},
@code{current-output-port}, and @code{current-error-port} are now
parameters.

Infer types of variables declared with a @code{let}.

Character comparisons (such as @code{char-=?}, @code{char-ci<?})
implemented much more efficiently --- and (if using Java5) work for
characters not in the Basic Multilingual Plane.

Major re-write of symbol and namespace handling. A
@uref{api/gnu/mapping/Symbol.html,@code{Symbol}} is now immutable,
consisting of a "print-name" and a pointer to a
@uref{api/gnu/mapping/Namespace.html,@code{Namespace}} (package). An
@uref{api/gnu/mapping/Environment.html,@code{Environment}} is a mapping
from @code{Symbol} to
@uref{api/gnu/mapping/Location.html,@code{Location}}.

Rename @code{Interpreter} to
@uref{api/gnu/expr/Language.html,@code{Language}} and
@code{LispInterpreter} to
@uref{api/gnu/kawa/lispexpr/LispLanguage.html,@code{LispLanguage}}.

Constant-time property list operations.

Namespace-prefixes are now always resolved at compile-time, never at
run-time.

@code{(define-namespace PREFIX <CLASS>)} is loosely the same as
@code{(define-namespace PREFIX "class:CLASS")} but does the right thing
for classes defined in this module, including nested or non-simple
classes.

Macros capture proper scope automatically, not just when using require.
This allows some internal macros to become private.

Major re-write of the macro-handling and hygiene framework. Usable
support for @code{syntax-case}; in fact some of the primitives (such as
@code{if}) are now implemented using @code{syntax-case}.
@code{(syntax form)} (or the short-cut @code{#!form)} evaluates to a
syntax object. @code{(define-syntax (mac x) tr)} same as
@code{(define-syntax mac (lambda (x) tr))}. The following non-hygienic
forms are equivalent:

@verbatim
  (define-macro (macro-name (param ...) transformer)
  (define-macro macro-name (lambda (param ...) transformer))
  (defmacro macro-name (PARAM ...) transformer)
@end verbatim

Allow vectors and more general ellipsis-forms in patterns and templates.

A new configure switch @code{--with-java-source=version} allows you to
tweak the Kawa sources to match Java compiler and libraries you're
using. The default (and how the sources are distributed) is @code{2}
(for "Java 2" -- jdk 1.2 or better), but you can also select "@code{1}"
(for jdk 1.1.x), and "@code{5}" for Java 5 (jdk 1.5). You can also
specify a jdk version number: "@code{1.4.1}" is equivalent to "2" (for
now). Note the default source-base is incompatible with Java 5 (or more
generally JAXB 1.3 or DOM 3), unless you also @code{--disable-xml}.

Configure argument @code{--with-servlet}[@code{=servlet-api.jar}]
replaces @code{--enable-servlet}.

Function argument in error message are now numbered starting at one.
Type errors now give better error messages.

A new function calling convention, used for @code{--full-tailcalls}. A
function call is split up in two parts: A
@code{match0}/.../@code{matchN} method checks that the actual arguments
match the expected formal arguments, and leaves them in the per-thread
@uref{api/gnu/mapping/CallContext.html,@code{CallContext}}. Then after
the calling function returns, a zero-argument @code{apply()} methods
evaluates the function body. This new convention has long-term
advantages (performance, full continuations), but the most immediate
benefit is better handling of generic (otherloaded) functions. There are
also improved error messages.

Real numbers, characters, Lisp/Scheme strings
(@uref{api/gnu/lists/FString.html,@code{FString}}) and symbols all now
implement the @code{Comparable} interface.

In @code{define-class}/@code{define-simple-class}: [Most of this work
was funded by @uref{http://www.mercedsystems.com/,Merced Systems}.]

@itemize
@item
You can specify
@code{access: }[@code{'private}|@code{'protected}|@code{'publi}c|@code{'package}]
to set the Java access permissions of fields and methods.
@item
Methods can be static by using the @code{access: 'static} specifier.
@item
The reflective routines @code{invoke} , @code{field} ,
@code{static-field} , @code{slot-ref} , @code{slot-set!} can now access
non-public methods/fields when appropriate.
@item
Such classes are no longer initialized when the containing module is
loaded.
@item
The @code{expr} in @code{init-form: expr} is now evaluated in the outer
scope.
@item
A new @code{init: expr} evalues @code{expr} in the inner scope.
@item
An option name following @code{allocation:} can now be a string literal
or a quoted symbol. The latter is preferred: @code{allocation: 'class}.
@item
Added @code{'static} as a synonym for @code{'class} following
@code{allocation:}.
@item
Initialization of static field (@code{allocation: 'class init: expr})
now works, and is performed at class initialization time.
@item
You can use unnamed ``dummy fields'' to add initialization-time actions
not tied to a field:

@verbatim
  (define-simple-class Foo ()
    (:init (perform-some-action)))
@end verbatim

@end itemize

@subheading Kawa 1.7.90 (2003)
@anchor{#kawa-1.7.90-2003}
Various fixes and better error messages in number parsing. Some
optimizations for the divide function.

New framework for controlling compiler warnings and other features,
supporting command-line flags, and the Scheme forms
@code{with-compile-options} and @code{module-compile-options}. The flag
@code{--warn-undefined-variable} is useful for catching typos.
Implementation funded by @uref{http://www.mercedsystems.com/,Merced
Systems}.

New @code{invoke-special} syntax form (implemented by Chris Dean).

New @code{define-variable} form (similar to Common Lisp's
@code{defvar}).

@subheading Kawa 1.7 (June 7, 2003)
@anchor{#kawa-1.7-june-7-2003}
@uref{api/gnu/kawa/servlet/KawaPageServlet.html,@code{KawaPageServlet}}
allows automatic loading and on-the-fly compilation in a servlet engine.
See
@uref{../qexo/simple-xquery-webapp.html,http://www.gnu.org/software/qexo/simple-xquery-webapp.html}.

The default source-base requires various Java 2 features, such as
collection. However, @code{make-select1} will comment out Java2
dependencies, allowing you to build Kawa with an older Java
implementation.

The @code{-f} flag and the load function can take an absolute URL. New
Scheme functions @code{load-relative} and @code{base-uri}.

Imported implementation of cut and cute from
@uref{http://srfi.schemers.org/srfi-26/srfi-26.html,SRFI-26} (Notation
for Specializing Parameters without Currying).

The way top-level definitions (including Scheme procedures) are mapped
into Java fields is changed to use a mostly reversible mapping. (The
mapping to method names remains more natural but non-reversible.)

@code{define-alias} of types can now be exported from a module.

New @code{--no-inline} and @code{--inline=none} options.

You can use @code{define-namespace} to define ``namespace aliases''.
This is used for the new short-hard syntax for method invocation:@*
@code{(define-namespace Int32 "class:java.lang.Integer")}@*
@code{(Int32:toHexString 255)} => @code{"ff"}@*
@code{(Int32:toString (Int32:new "00255"))} => @code{"255"}@*
Alternatively, you can write:@*
@code{(java.lang.Integer:toHexString 255)} => @code{"ff"}

@uref{http://srfi.schemers.org/srfi-9/srfi-9.html,SRFI-9}
(define-record-type) has been implemented, and compiled to a
@code{define-class}, with efficient code.

The configure option @code{--with-collections} is now the default.

Unknowns are no longer automatically static.

If type not specified in a declaration, don't infer it from it initial
value. If no return type is specified for a function, default to
@code{Object}, rather than the return type of the body. (The latter
leads to undesirable different behaviour if definitions are
re-arranged.)

You can now define and use classes defined using @code{object},
@code{define-class}, and @code{define-simple-class} from the
``interpreter'', as well as the compiler. Also, a bug where inherited
fields did not get initialized has been fixed.

There are several new procedures useful for servlets.

Numerical comparisions (@code{<}, @code{<=}, etc) now generates
optimized bytecode if the types of the operands have certain known
types. including efficient code for @code{<int>}, @code{<long>},
@code{<double>}, and @code{<integer>}. Much more code can now (with type
declaration) be written just as efficiently in Scheme as in Java.

There have been some internal re-arranging of how Expressions are
processed. The Scheme-specific Translator type now inherits from
Compilation, which replaces the old Parser class. A Complation is now
allocated much earlier, as part of parsing, and includes a
SourceMessages object. SourcesMessages now includes (default) line
number, which is used by Compilation for the "current" line numbers. The
ExpWalker class includes a SourceMessages instance (which it gets from
the Compilation). CanInline.inline method now takes ExpWalker parameter.
Checking of the number or parameters, and mapping known procedures to
Java methods are now both done during the inlining pass.

The user-visible effect is that Kawa can now emit error mesages more
cleanly more places; the inlining pass can be more agressive, and can
emit better error messages, which yields better type information. This
gives us better code with fewer warnings about unknown methods.

@subheading Changes from Kawa 1.6.98 to 1.6.99.
@anchor{#changes-from-kawa-1.6.98-to-1.6.99.}
A new language front-end handles a tiny subset of XSLT. An example is
the check-format-users test in gnu/xquery/testsuite/Makefile.

There are now converters between SAX2 and Consumer events, and a basic
implementation of XMLReader based on XMLParser.

The function as-xml prints a value in XML format.

Srfi-0 (cond-expand), srfi-8 (receive), and srfi-25 (multi-dimensional
arrays) are now implemented. So is srfi-1 (list library), though that
requires doing (require 'list-lib).

The JEmacs code is being re-organized, splitting out the Swing-dependent
code into a separate gnu.jemacs.swing package. This should make it
easier to add JEmacs implementation without Swing.

The class gnu.expr.Interpreter has various new 'eval' methods that are
useful for evaluating Scheme/BRL/XQuery/... expressions from Java.

Kawa now uses current versions of autoconf, autoamke, and libtool,
allowing the use of automake file inclusion.

The comparisons @code{<<}, @code{<=}, @code{-}, @code{>}, and @code{=>}
now compile to optimized Java arithmetic if both operands are
@code{<int>} or a literal that fits in @code{<int>}.

@subheading Changes from Kawa 1.6.97 to 1.6.98
@anchor{#changes-from-kawa-1.6.97-to-1.6.98}
Generated HTML and Postscrpt documents are no longer included in the
source distribution. Get @code{kawa-doc-version.tar.gz} instead.

(format #t ...) and (format PORT ...) now returns #!void instead of #t.

Support fluid bindings (fluid-let) for any thread, not just Future and
main.

A Unix script header @code{#!/PROGRAM} is ignored.

You can now take the same Kawa "web" program (written in Scheme,
KRL/BRL, or XQuery) and run it as either a servlet or a CGI script.

There are a number of new functions for accessing HTTP requests and
generating HTTP responses.

Kawa now supports a new experimental programming KRL (the "Kawa Report
Language"). You select this language using --krl on the Kawa command
link. It allows Scheme code to be inside template files, like HTML
pages, using a syntax based on BRL (brl.sourceforge.net). However, KRL
has soem experimental changes to both BRL and standard Scheme. There is
also a BRL-compatibile mode, selected using --brl, though that currently
only supports a subset of BRL functions.

If language is not explicitly specified and you're running a source file
(e.g. "java kawa.repl myscript.xql"), Kawa tried to derive the language
from the the filename extension (e.g. "xql"). It still defaults to
Scheme if there is no extension or the extension is unrecognized.

New command-line option --output-format alias --format can be used to
over-ride the format used to write out top-level (repl, load) values.

XMLPrinter can now print in (non-well-formed-XML) HTML.

@subheading Changes from Kawa 1.6.96 to 1.6.97
@anchor{#changes-from-kawa-1.6.96-to-1.6.97}
Changed lots of error messages to use pairs of single quotes rather than
starting with a backquote (accent grave): 'name' instead of `name'. Many
newer fonts make the latter look bad, so it is now discouraged.

The types @code{<String>} and @code{<java.lang.String>} new behave
differently. The type @code{<java.lang.String>} now works just like
(say) @code{<java.util.Hashtable>}. Converting an object to a
@code{<java.lang.String>} is done by a simple coercion, so the incoming
value must be a java.lang.String reference or null. The special type
@code{<String>} converts any object to a java.string.String by calling
toString; it also handles null by specially testing for it.

For convenience (and backwards compatibility) Kawa uses the type
@code{<String>} (rather than @code{<java.lang.String>}) when it sees the
Java type @code{java.lang}.String, for example in the argument to an
@code{invoke}.

The default behaviour of '[' and '] was changed back to be token (word)
constituents, matching R5RS and Common Lisp. However, you can easily
change this behaviour using the new setBrackMode method or the
defaultBracketMode static field in ReadTable.

You can now build Kawa from source using the Ant build system (from
Apache's Jakarta project), as an alternative to using the traditional
configure+make system. An advantage of Ant is that it works on most Java
systems, without requiring a Unix shell and commands. Specifically, this
makes it easy to build Kawa under MS-Windows. Thanks to James White for
contributing this support.

Added (current-error-port) which does the obvious.

The new let-values and let-values* macros from srfi-11 provide a more
convenient way to use multiple values.

All the abstract apply* and eval* methods now specify 'throws
Throwable'. A bunch of code was changed to match. The main visible
advantage is that the throw and primitive-throw procedures work for any
Throwable without requiring it to be (confusingly) wrapped.

@subheading Changes from Kawa 1.6.95 to 1.6.96
@anchor{#changes-from-kawa-1.6.95-to-1.6.96}
A new compilation flag --servlet generates a Servlet which can be
deployed in a servlet engin like Tomcat. This is experimental, but it
seesm to work for both Scheme source and XQuery source.

The interface gnu.lists.CharSequence was renamed to avoid conflitcs with
the (similar) interface java.lang.CharSequence in JDK 1.4beta.

New --help option (contributed by Andreas Schlapbach).

Changed the code generation used when --full-tailcalls. It now is closer
to that used by default, in that we don't generate a class for each
non-inlined procedure. In both cases calling an unknown procedure
involves executing a switch statement to select a method. In addition to
generating fewer classes and simplifying one of the more fragile parts
of Kawa, it is also a step towards how full continuations will be
implemented.

Changed the convention for name "mangling" - i.e. how Scheme names are
mapped into Java names. Now, if a Scheme name is a valid Java name it is
used as is; otherwise a reversible mangling using "$" characters is
used. Thus the Scheme names @code{'<} and @code{'$Leq} are both mapped
into the same Java name @code{"$Leq"}. However, other names not
containing "@code{$}" should no longer clash, including pairs like
"@code{char-letter?}" and "@code{charLetter?}" and "@code{isCharLetter}"
which used to be all mapped to "@code{isCharLetter}". Now only names
containing "@code{$}" can be ambiguous.

If the compiler can determine that all the operands of (+ ...) or (-
...) are floating-point, then it will generate optimized code using Java
primitive arithmetic.

Guile-style keyword syntax '#:KEYWORD' is recognized. (Note this
conflicts with Common Lisp syntax for uninterned symbols.)

New syntax forms define-class and define-simple-class allow you to
define classes more easily. define-class supports true multiple
inheritance and first class class values, where each Scheme class is
compiled to a pair of an inteface and a class. define-simple-class
generates more efficient and Java-compatible classes.

@subheading Changes from Kawa 1.6.94 to 1.6.95.
@anchor{#changes-from-kawa-1.6.94-to-1.6.95.}
A new language "xquery" implements a (so far small subset of) XQuery,
the draft XML Query languaage.

Various internal (Java API) changes: Changes to gnu.expr.Interpreter to
make it easier to add non-Lisp-like languages; gnu.lists.Consumer now
has an endAttribute method that need to be called after each attribute,
rather than endAttributes that was called after all of them.

If configured with --with-gcj, Kawa builds and intalls a 'gckawa' script
to simlify linking with needed libraries.

The @code{setter} function is now inlined, and
@code{(set! (field X 'N) V)} and @code{(set! (static-field <T> "N) V)}
are now inlined.

If configured @code{--with-gcj}, then a @code{gckawa} helper script is
installed, to make it easier to link Kawa+gcj-compiled applications.

@subheading Changes from Kawa 1.6.92 to 1.6.94
@anchor{#changes-from-kawa-1.6.92-to-1.6.94}
The JEmacs code now depends on CommonLisp, rather than vice versa, which
means Commonlisp no longer depends on Swing, and can be built with GCJ.
CommonLisp and JEmacs symbols are now implemented using Binding, not
String.

@subheading Changes from Kawa 1.6.90 to 1.6.92
@anchor{#changes-from-kawa-1.6.90-to-1.6.92}
Kawa now installs as a .jar file (kawa.jar symlinked to
kawa-VERSION.jar), rather than a collection of .class files.

The Kawa manual includes instructions for how to build Kawa using GCJ,
and how to compile Scheme code to a native executable using GCJ.

Kawa now has builtin pretty-printer support, using an algorithm from
Steel Bank Common Lisp converted from Lisp to Java. The high-level
Common Lisp pretty-printing features are mostly not yet implemented, but
the low-level support is there. The standard output and error ports
default to pretty-printing.

A new formatting framework uses the Consumer interface from gnu.lists.
You can associate a format with an output port. Common Lisp and JEmacs
finally print using their respective syntaxes.

All output ports (OutPort instances) are now automatically flushed on
program exit, using a new WriterManager helper class.

The new commmand-line option --debug-print-expr causes the Expression
for each expression to be printed. The option --debug-print-final-expr
is similar, but prints Expressions after optimization and just before
compilation. They are printed using the new pretty-printer.

Changed calling convention for --full-tailcalls to write results to a
Consumer, usually a TreeList or something to be printed. A top-level
ModuleBody now uses the same CpsProcedure convention. This is useful for
generating xml or html.

New libtool support allows kawa to be built as a shared library.

The new configure flag --with-gcj uses gcj to compile Kawa to both
.class files and native code. This is experimental.

@subheading Changes from Kawa 1.6.70 to 1.6.90
@anchor{#changes-from-kawa-1.6.70-to-1.6.90}
The reader (for Scheme and Lisp) has been re-written to be table-driven,
based on the design of Common Lisp readtables.

The new gnu.lists package has new implementations of sequence-related
classes. It replaces most of gnu.kawa.util. See the package.html file.

If the expected type of a non-unary @code{+} or @code{-} is @code{<int>}
or @code{<long>} and the operands are integeral types, then the operands
will converted to the primitive integer type and the addition or
subtraction done using primitive arithmetic. Similarly if the expected
type is @code{<float>} or @code{<long>} and the operands have
appropriate type. This optimization an make a big performance
difference. (We still need to also optimize compare operations like
@code{(< x y)} to really benefit from @code{<int>} declarations of loop
variables.)

The implementation of procedure closures has been changed to basically
be the same as top-level procedures (except when --full-tailcalls is
specified): Each procedure is now an instance of a ModuleMethod, which
each "frame" is an instance of ModuleBody, just like for top-level
functions. This sometimes reduces the number of classes generated, but
more importantly it simplifies the implementation.

A new @uref{api/gnu/xml/package-summary.html,@code{gnu.xml}} package
contains XML-related code, currently an XML parser and printer, plus
some XPath support. The class
@uref{api/gnu/lists/TreeList.html,@code{gnu.lists.TreeList}} (alias
@code{<document>}) is useful for compactly representing nested
structures, including XML documents. If you @code{(require 'xml)} you
will get Scheme interfaces (@code{print-as-xml} and
@code{parse-xml-from-url}) to these classes.

New package gnu.kawa.functions, for primitive functions (written in
Java).

The map and for-each procedure is now inlined. This is most especially
beneficial when it allows the mapped-over procedure to also be inlined,
such as when that procedure is a lambda expression.

Added documentation on compiling with Jikes. Renamed some classes to
avoid warning when compiling with Jikes.

The reverse! procedure was added.

Internal changes: * If a variable reference is unknown, create a
Declaration instance with the IS_UNKNOWN flag to represent an imported
binding. * The ExpWalker framework for "tree walking" Expressions had a
bit of reorganization. * New package gnu.kawa.functions, for primitive
functions (written in Java).

Added a hook for constant-folding and other optimization/inlining at
traversal (ExpWalker) time. Optimization of + and - procedures to use
primitive Java operations when the operands are primitive types.

Implementation of SRFI-17. Change the definitions of (set! (f x ...)
val) to ((setter f) x ... val), rather then the old ((setter f) val x
...). You can now associate a setter with a procedure, either using
make-procedure or set-procedure-property!. Also, (setter f) is now
inlined, when possible.

Internally, Syntax (and hence Macro) no longer extend Declaration.

Various Java-level changes, which may be reflected in Scheme later: *
gnu.kawa.util.Consumer interface is similar to ObjectOutput and SAX's
ContentHandler interfaces. * A gnu.expr.ConsumerTarget is used when
evaluating to an implicit Consumer. * These interfaces will make it easy
to write functional-style but efficient code for transforming data
streams, including XML. * gnu.kawa.util.FString is now variable-size.

@subheading Changes from Kawa 1.6.68 to 1.6.70
@anchor{#changes-from-kawa-1.6.68-to-1.6.70}
The bare beginnings of Common Lisp support, enabled by the --commonlisp
(or --clisp) command line option. This is so far little more than a hack
of the EmacsLisp support, but with lexical scoping and CL-style format.

@subheading Changes from Kawa 1.6.66 to 1.6.68
@anchor{#changes-from-kawa-1.6.66-to-1.6.68}
JEmacs news:

@itemize
@item
Define emacs-version as Kawa version but with leading 0 instead of 1.
For example, the current value is "0.6.68 JEmacs".
@item
New testsuite directory.
@item
Improved autoload framework. Handle ELisp autoload comments.
@item
Handle escape and meta-key.
@item
Handle lot more of ELisp.
@item
Lots more is now done in ELisp, using .el files imported from XEmacs.
@item
Incomplete support for setting mark, including using selection.
@item
Basic (but incomplete) implementation of (interactive spec).
@item
Common Lisp extensions: typep, default arguments.
@item
A new status.html file to note what works and what doesn't.
@end itemize

You can now specify in @code{define} and @code{define-private} the type
of a variable. If the variable is module-level,
@code{(define name :: <type> value)} creates a field named
``@code{name}'' having the specified type and initial value. (If type is
not specified, the default is not @code{Object}, but rather a
@code{Binding} that @emph{contains} the variable's value.)

You can now define the type of a module-level variable: In
(define[-private] :: type expression) New (define-constant name [::
type] expression) definition form.

A procedure can now have arbitrary properties associated with it. Use
procedure-property and set-procedure-property! to get and set them.

The new procedure make-procedure creates a generic procedure that may
contain one or more methods, as well as specified properties.

New declaration form define-base-unit. Both it and define-unit have been
re-implemented to be module-safe. Basically '(define-unit ft 12in)' is
sugar for '(define-constant ft$unit (... (* 12 in$unit)))', where
ft$unit and in$unit are standard identifiers managed by the module
system. Also, the output syntax for units and quantities is cleaner.

The new declaration (module-export name ...) allows control over the
names exported from a module. The new declaration (module-static ...)
allows control over which definitions are static and which are
non-static. This makes it easier to use a module as a Java class.

Procedures names that accidentally clash with inherited method names
(such as "run") are now re-named.

Simple aliases (define-aliases defining an alias for a variable name)
are implemented more efficiently.

The package hierarchy is getter cleaner, with fewer cyclic dependencies:
The gnu.math package no longer has any dependencies on kawa.* or gnu.*.
Two classes were moved from gnu.text to other classes, avoiding another
cyclic package dependency between gnu.text and gnu.mapping. The new
gnu.kawa.lispexpr is for compile-time handling of Lisp-like languages.

Compliation of literals has been re-done. A class that can be used in a
literal no longer needs to be declared as Compilable. Instead, you
declare it as implementaing java.io.Externalizable, and make sure it has
appropriate methods.

All the standard "data" types (i.e. not procedures or ports) now
implement java.io.Externalizable, and can thus be serialized. If they
appear in literals, they can also be compiled.

Created a new class gnu.kawa.util.AbstractString, with the Scheme alias
@code{<abstract-string>}. The old gnu.kawa.util.FString now extends
AbstractString. A new class CharBuffer provides an growable buffer, with
markers (automatically-adjusted positions). Many of the Scheme
@code{<string>} procedures now work on @code{<abstract-string>}. The
JEmacs BufferContnat class (contains the characters of a buffer) now
extends CharBuffer.

Some JEmacs changes to support a "mode" concept, as well as preliminary
support for inferior-process and telnet modes.

New section in manual / web page for projects using Kawa.

The record feasture (make-record-type etc) how handles "funny" type and
fields names that need to be "mangled" to Java names.

Re-did implementation of define-alias. For example, you can define
type-aliases:@*
@code{(define-alias <marker> <gnu.jemacs.buffer.Marker>)}@*
and then use <marker> instead of <gnu.jemacs.buffer.Marker>.

@code{(field array 'length)} now works.

@subheading Changes from Kawa 1.6.64 to 1.6.66
@anchor{#changes-from-kawa-1.6.64-to-1.6.66}
Added documentation to the manual for Homogeneous numeric vector
datatypes (SRFI-4).

You can now specify characters using their Unicode value: #\u05d0 is
alef.

Kawa now uses a more mnemonic name mangling Scheme. For example, a
Scheme function named @code{<=} would get compiled to method
@code{$Ls$Eq}.

There is now working and useful module support, thought not all features
are implemented. The basic idea is that a module can be any class that
has a default constructor (or all of whose fields and methods are
static); the public fields and methods of such a class are its exported
definitions. Compiling a Scheme file produces such a module. Doing:@*
@code{ (require <classname>)}@*
will create an anonymous instance of @code{<classname>} (if needed), and
add all its exported definitions to the current environment. Note that
if you import a class in a module you are compiling, then an instance of
the module will be created at compile-time, and imported definitions are
not re-imported. (For now you must compile a module, you cannot just
load it.)

The define-private keyword creates a module-local definition.

New syntax to override some properties of the current module:@*
@code{(module-name <name>)} overrides the default name for a module.@*
@code{(module-extends <class>)} specifies the super-class.@*
@code{(module-implements <interface> ...)} specfies the implemented
interfaces.

The syntax: (require 'keyword) is syntactic sugar for (require
<classname>) where the classname is find is a "module catalog"
(currently hard-wired). This provides compatibility with Slib. The Slib
"features" gen-write, pretty-print, pprint-file, and printf are now
available in Kawa; more will be added, depending on time and demand. See
the package directory gnu/kawa/slib for what is available.

@subheading Changes from Kawa 1.6.62 to 1.6.64
@anchor{#changes-from-kawa-1.6.62-to-1.6.64}
A lot of improvements to JEmacs (see JEmacs.SourceForge.net).

kawa-compiled-VERSION.zip is replaced by kawa-compiled-VERSION.jar.

You can now use Kawa to generate applets, using the new --applet switch,
Check the "Applet compilation" section in the manual. Generating an
application using the --main flag should work again. Neither --applet
nor --main has Scheme hard-wired any more.

A new macro `(this)' evaluates to the "this object" - the current
instance of the current class. The current implementation is incomplete,
and buggy, but it will have to do for now.

The command-line argument -f FILENAME will load the same files types as
load.

When a source file is compiled, the top-level definitions (procedures,
variables, and macros) are compiled to final fields on the resulting
class. This are not automatically entered into the current environment;
instead that is the responsibility of whoever loads the compiled class.
This is a major step towards a module system for Kawa.

There is a new form define-private which is like define, except that the
defined name is not exported from the current module.

A procedure that has optional arguments is now typically compiled into
multiple methods. If it's a top-level procedure, these will be methods
in the modules "ModuleBody" class, with the same (mangled) name. The
compiler can in many cases call the appropriate method directly.
Usually, each method takes a fixed number of arguments, which means we
save the overhead of creating an array for the arguments.

A top-level procedure declared using the form (define (NAME ARS ...)
BODY ..) is assumed to be "constant" if it isn't assigned to in the
current compilation unit. A call in the same compilation unit will now
be implemented as a direct method call. This is not done if the prcedure
is declared with the form: (define NAME (lambda (ARGS ,,,) BODY ...)

gnu.expr.Declaration no longer inherits from gnu.bytecode.Variable.

A gnu.mapping.Environment now resolves hash index collisions using
"double hashing" and "open addressing" instead of "chaining" through
Binding. This allows a Binding to appear in multiple Environments.

The classes Sequence, Pair, PairWithPosition, FString, and Char were
moved from kawa.lang to the new package gnu.kawa.util. It seems that
these classes (except perhaps Char) belong together. The classes List
and Vector were also moved, and at the same time renamed to LList and
FVector, respectively, to avoid clashed with classes in java.util.

New data types and procedures for "uniform vectors" of primitive types
were implemented. These follow the SRFI-4 specification, which you can
find at http://srfi.schemers.org/srfi-4/srfi-4.html .

You can now use the syntax @code{name :: type} to specify the type of a
parameter. For example:@*
@code{(define (vector-length x :: <vector>) (invoke x 'length))}@*
The following also works:@*
@code{(define (vector-length (x :: <vector>)) ...)}.

@code{(define-member-alias name object [fname])} is new syntactic sugar
for @code{(define-alias name (field object fname))}, where the default
for @code{fname} is the mangling of @code{name}.

@subheading Changes from Kawa 1.6.60 to 1.6.62
@anchor{#changes-from-kawa-1.6.60-to-1.6.62}
The new function `invoke' allows you to call a Java method. All of
`invoke', `invoke-static' and `make' now select the bets method. They
are also inlined at compile time in many cases. Specifically, if there
is a method known to be definitely applicable, based on compile-time
types of the argument expressions, the compiler will choose the most
specific such method.

The functions slot-ref, slot-set!, field, and static-field are now
inlined by the compiler when it can.

Added open-input-string, open-output-string, get-output-string from
SRFI-6. See http://srfi.schemers.org/srfi-6/srfi-6.html.

The manual has a new section "Mapping Scheme names to Java names", and a
new chapter "Types". The chapters "Extensions", "Objects and Classes",
and "Low-level functions" have been extensivley re-organized.

The Kawa license has been simplified. There used to be two licenses: One
for the packages gnu.*, and one for the packages kawa.*. There latter
has been replaced by the former. The "License" section of the manual was
also improved.

@subheading Changes from Kawa 1.6.59 to 1.6.60
@anchor{#changes-from-kawa-1.6.59-to-1.6.60}
There is a new package gnu.kawa.reflect. Some classes that used to be in
kawa.lang or kawa.standard are now there.

The procedures slot-ref and slot-set! are now available. They are
equivalent to the existing `field', but reading a field `x' will look
for `getX' method if there is no public `x' field; writing to a field
will look for `setX'.

The procedure `make' makes it convenient to create new objects.

There is now a teaser screen snapshot of "JEmacs" at
http://www.bothner.com/~per/papers/jemacs.png.

The html version of the manual now has a primitive index. The manual has
been slightly re-organized, with a new "Classes and Objects" chapter.

The new functions invoke-static and class-methods allow you to call an
arbitary Java method. They both take a class specification and a method
name. The result of class-methods is a generic procedure consisting of
those methods whose names match. (Instance methods are also matched;
they are treated the asme as class methods with an extra initial
argument.) The invoke-static function also takes extra arguments, and
actually calls the "best"-matching method. An example:

@verbatim
        (invoke-static <java.lang.Thread> 'sleep 100)
@end verbatim

Many fewer classes are now generated when compiling a Scheme file. It
used to be that each top-level procedure got compiled to its own class;
that is no longer the case. The change should lead to faster startup and
less resource use, but procedure application will probably be noticably
slower (though not so much slower as when reflection is used). The
reason for the slowdown is that we in the general case now do an extra
method call, plus a not-yet-optimized switch statement. This change is
part of the new Kawa module system. That will allow the compiler to
substitute direct methods calls in more cases, which I hope will more
than make up for the slowdown.

A Scheme procedure is now in general compiled to a Java method whose
name is a "mangling" of the Scheme procedure's name. If the procedure
takes a variable number of parameters, then "$V" is added to the name;
this indicates that the last argument is a Java array containing the
rest of the arguments. Conversely, calling a Java method whose name ends
in "$V" passes any excess arguments in the last argument, which must be
an array type.

Many changes to the "Emacs-emulation" library in gnu.jemacs.buffer: *
Implemented commands to read and save files. * We ask for file and
buffer names using a dialog pop-up window. * Split windows correctly, so
that the windows that are not split keep their sizes, the windows being
split gets split as specified, and the frame does not change size. Now
also handles horizonal splits. * Fairly good support for buffer-local
keymaps and Emacs-style keymap search order. A new class BufferKeymap
manages the active keymaps of a buffer. Multi-key key-sequences are
handled. Pending prefix keys are remembered on a per-buffer basis
(whereas Emacs does it globally).

There is now some low-level support for generic procedures.

The R5RS primitives let-syntax and letrec-syntax for defining local
syntax extensions (macros) should now work. Also define-syntax works as
an internal definition. All of these should now be properly "hygienic".
(There is one known exception: symbols listed among the literals lists
are matched as raw symbols, rather that checking that the symbol has the
same binding, if any, as at the defining site.) The plan is to support
general functions as hygienic rewriters, as in the Chez Scheme
"syntax-case" system; as one part of that plan, the syntax-case
primitive is available, but so far without any of the supporting
machinary to support hygiene.

The read-line procedure was added. This allows you to efficiently read a
line from an input port. The interface is the same as scsh and Guile.

@subheading Changes from Kawa 1.6.58 to 1.6.59
@anchor{#changes-from-kawa-1.6.58-to-1.6.59}
define-alias now works both top-level and inside a function.

Optimized eqv? so if one of the arguments is constant and not Char or
Numeric, inline it the same way eq? is. (This helps case when the labels
are symbols, which help the "lattice" benchmark.) ???

The Emacs-related packages are now grouped under a new gnu.jemacs
package.

Improved framework for catching errors. This means improved error
messages when passing a parameter of the wrong type. Many standard
procedures have been improved.

Simplified, documented, and tested (!) procedure for building Kawa from
source under Windows (95/98/NT).

New macros trace and untrace for tracing procedures. After executing
(trace PROCEDURE), debugging output will be written (to the standard
error port) every time PROCEDURE is called, with the parameters and
return value. Use (untrace PROCEDURE) to turn tracing off.

New utility functions (system-tmpdir) and (make-temporary-file
[format]).

A new (unfinished) framework supports multiple languages. The
command-line option --elisp selects Emacs Lisp, while --scheme (the
default) selects Scheme. (The only difference so far is the reader
syntax; that will change.)

The `format' function now provides fairly complete functionality for
CommonLisp-style formatting. (See the Comon Lisp hyperspec at
http://www.harlequin.com/education/books/HyperSpec/Body/sec_22-3.html.)
The floating point formatters (~F, ~E, ~G, ~$) now pass the formatst.scm
test (from Slib, but with some "fixes"; in the testsuite directory).
Also, output ports now track column numbers, so @code{~T} and @code{~&}
also work correctly.

A new package gnu.emacs provides various building blocks for building an
Emacs-like text editor. These classes are only compiled when Kawa is
configured with the new --with-swing configuration option. This is a
large initial step towards "JEmacs" - an Emacs re-implemented to use
Kawa, Java, and Swing, but with full support (using gnu.elisp) for
traditional Emacs Lisp. For more imformation see
gnu/emacs/overview.html.

A new configuration option --with-swing can be used if Swing is
available. It is currently only used in gnu.emacs, but that may change.

@subheading Changes from Kawa 1.6.56 to 1.6.58
@anchor{#changes-from-kawa-1.6.56-to-1.6.58}
Kawa is now "properly tail-recursive" if you invoke it with the
--full-tail-calls flag. (Exception: the eval procedure does not perform
proper tail calls, in violation of R5RS. This will be fixed in a future
release.) Code compiled when --full-tail-calls is in effect is also
properly tail-recursive. Procedures compiled with --full-tail-calls can
call procedures compiled without it, and vice versa (but of course
without doing proper tail calls). The default is still
--no-full-tail-calls, partly because of performance concerns, partly
because that provides better compatibility with Java conventions and
tools.

The keywords let (including named let), let*, and letrec support type
specifiers for the declared variables For example:

@verbatim
    (let ((lst :: <list> (foo x))) (reverse lst))
@end verbatim

Square brackets [ ... ] are allowed as a synonym of parentheses ( ... ).

@subheading Changes from Kawa 1.6.55 to 1.6.57
@anchor{#changes-from-kawa-1.6.55-to-1.6.57}
A new command-line flag --server PORT specifies that Kawa should run as
a telnet server on the specified PORT, creating a new read-eval-print
loop for each connection. This allows you to connect using any telnet
client program to a remote "Kawa server".

A new front-end program, written in C, that provides editing of input
lines, using the GNU readline library. This is a friendlier interface
than the plain "java kawa.repl". However, because kawa.c needs readline
and suitable networking library support, it is not built by default, but
only when you configure Kawa with the --enable-kawa-frontend flag.

The way Scheme names are mapped ("mangled") into Java identifiers is now
more natural. E.g. "foo-bar?" now is mapped to "isFooBar".

New syntax (object (SUPERS ...) FIELD-AND-METHODS ...) for creating a
new object instance of an anonymous class. Now fairly powerful.

New procedures field and static-field for more convenient field access.

Syntactic sugar: @code{(lambda args <type> body)} ->
@code{(lambda args (as <type> body))}. This is especially useful for
declaring methods in classes.

A new synchonized form allows you to synchronize on an arbitrary Java
object, and execute some forms while having an exclusive lock on the
object. (The syntax matches that used by Skij.)

@subheading Changes from Kawa 1.6.53 to 1.6.55
@anchor{#changes-from-kawa-1.6.53-to-1.6.55}
New --debug-dump-zip option writes out a .zip file for compilation.
(Useful for debugging Kawa.)

You can now declare parameter types.

Lot of work on more efficient procedure representation and calling
convention: Inlining, directly callable statics method, plus some
procedures no longer generate a separate Class.

Local functions that are only called from one locations, except for
tail-recursion, are now inlined. This inlines do loops, and most "named
let" loops.

New representation of closures (closures with captured local variables).
We no longer use an array for the closure. Instead we store the captured
variables in the Procedure itself. This should be faster (since we can
use field accesses rather than array indexing, which requires bounds
checking), and avoids a separate environment object.

If the compiler sees a function call whose (non-lexically-bound) name
matches an existing (globally-defined) procedure, and that procedure
instance has a static method named either "apply" or the mangled
procedure name, them the compiler emits a direct call to that method.
This can make a very noticable speed difference, though it may violate
strict Scheme sementics, and some code may break.

Partial support for first-class "location" variables.

@subheading Changes from Kawa 1.6.53 to 1.6.54
@anchor{#changes-from-kawa-1.6.53-to-1.6.54}
Created new packages gnu.mapping and gnu.expr. Many classes were moved
from kawa.lang to the new packages. (This is part of the long-term
process of splitting Kawa into more manageable chunks, separating the
Scheme-specific code from the language-independent code, and moving
classes under the gnu hierarchy.)

You can now write keywords with the colon first (e.g. :KEYWORD), which
has exactly the same effect and meaning as putting the colon last (e.g.
KEYWORD:). The latter is preferred is being more consistent with normal
English use of punctuation, but the former is allowed for compatibility
with soem other Scheme implementations and Common Lisp.

@subheading Changes from Kawa 1.6.52 to 1.6.53
@anchor{#changes-from-kawa-1.6.52-to-1.6.53}
The new package gnu.text contains facilities for reading, formatting,
and manipulating text. Some classes in kawa.lang where moved to there.

Added string-upcase!, string-downcase!, string-capitalize!,
string-upcase, string-downcase, and string-capitalize; compatible with
Slib.

Character constants can now use octal notation (as in Guile). Writing a
character uses octal format when that seems best.

A format function, similar to that in Common Lisp (and Slib) has been
added.

The default parameter of a #!optional or #!key parameter can now be
#!null.

@subheading Changes since Kawa 1.6.51
@anchor{#changes-since-kawa-1.6.51}
The "record" feature has been changed to that a "record-type descriptor"
is now a gnu.bytecode.ClassType (a @code{<record-type>}), rather than a
java.lang.Class. Thus make-record-type now returns a
@code{<record-typee>}, not a Class, and @code{record-type-descriptor}
takes a @code{<record-typee>}, not a Class.

More robust Eval interfaces.

New Lexer abstract class. New ScmRead class (which extends Lexer) now
contains the Scheme reader (moved from Inport). Now read errors are kept
in queue, and can be recovered from.

Comparing an exact rational and an inexact real (double) is now done as
if by first converting the double to exact, to satisfy R5RS.

@subheading Changes since Kawa 1.6.1
@anchor{#changes-since-kawa-1.6.1}
The compile virtual method in Expression now takes a Target object,
representing the "destination". The special ConditionalTarget is used to
evaluate the test of an 'if expression. This allows us to generate much
better code for and, or, eq?, not and nested if inside an if.

Added port-line, port-column, and set-port-line! to match Guile.

The Makefiles have been written so all out-of-date .java (or .scm).
files in a directory are compiled using a single invocation of javac (or
kawa). Building Kawa should now be much faster. (But note that this
depends on unreleased recent autoamke changes.)

How the Kawa version number is compiled into Kawa was changed to make it
easier for people who want to build from source on non-Unix-like
systems.

A new gnu.ecmascript package contains an extremely incomplete
implementation of ECMSScript, the ECMA standardized version of
JavaScript. It includes an ECMAScript lexer (basically complete), parser
(the framework is there but most of the language is missing), incomplete
expression evaluation, and a read-eval-print-loop (for testing only).

@subheading Changes in Kawa 1.6.1
@anchor{#changes-in-kawa-1.6.1}
Improved Kawa home page with extra links, pointer to Java-generated api
docs, and homepages for gnu.math and gnu.bytecode.

Implemented system, make-process, and some related procedures.

Added macros for primitive access to object fields, static fields, and
Java arrays. Added constant-fold syntax, and used it for the other
macros.

The --main flag compiles Scheme code to an application (containing a
main method), which can be be invoked directly by a Java interpreter.

Implemented --version (following GNU standards) as kawa.repl
command-line flag.

@subheading Changes since Kawa 1.5.93
@anchor{#changes-since-kawa-1.5.93}
Adding make procedure to create new objects/records.

Extended (set! (f . args) value) to be equivalent to ((setter f) value .
args). Implemented setter, as well as (setter car) and (setter cdr).

Can now get and set a record field value using an application: (rec
'fname) gets the value of the field named fname in record rec. (set!
(rec 'fname) value) sets the value of the field named fname in rec.

A partial re-write of the implementation of input ports and the Scheme
reader, to fix some problems, add some features, and improve
performance.

Compiled .class files are now installed in $(datadir)/java, rather than
$(prefix)/java. By default, that means they are installed in
/usr/local/shared/java, rather than /usr/local/java.

There is now internal infrastructure to support inlining of procedures,
and general procedure-specific optimized code generation.

There is better testing that the right number of arguments are passed to
a procedure, and better error messages when you don't. If the procedure
is inlined, you get a compile-time error message.

The functions created by primitive-constructor,
primitive-virtual-method, primitive-static-method, and
primitive-interface-method are now first-class procedure values. They
use the Java reflection facily, except when the compiler can directly
inline them (in which case it generates the same efficient bytecodes as
before).

New functions instance? (tests type membership) and as (converts).

The kawa.html is now split into several files, one per chapter. The
table of contents is now kawa_toc.html.

The syntactic form try-catch provides low-level exception handler
support. It is basically the same as Java's try/catch form, but in
Scheme syntax. The new procedure primitive-throw throws an exception
object.

The higher-level catch and throw procedures implement exception handling
where the handler is specified with a "key" (a symbol). These functions
were taken from Guile.

The error function has been generalized to take multiple arguments (as
in Guile). It is now a wrapper around (throw 'misc-error ...).

There is a new "friendly" GUI access to the Kawa command-line. If you
invoke kawa.repl with the -w flag, a new interaction window is created.
This is uses the AWT TextArea class. You can create multiple "consoles".
They can either share top-level enevironments, or have separate
environments. This window interface has some nice features, including
editing. Added a scheme-window procedure, which is another way to create
a window.

@subheading Changes since Kawa 1.5
@anchor{#changes-since-kawa-1.5}
The default prompt now shows continuations lines differently.

The copy-file function was added.

The variable port-char-encoding controls how external files are
converted to/from internal Unicode characters. It also controls whether
CR and CR-LF are converted to LF.

The reader by default no longer down-cases letters in symbols. A new
variable symbol-read-case control how case is handled: 'P (the default)
preserves case; 'U upper-cases letters; 'D or -" down-cases letters; and
'I inverts case.

The gnu.bytecode package now supports exception handlers. The new
syntactic form try-finally supports a cleanup hook that is run after
some other code finishes (normally or abnormally). Try-finally is used
to implement dynamic-wind and fluid-let.

The environment handling has been improved to support thread-specific
environments, a thread-safe fluid-let, and multiple top-levels. (The
latter still needs a bit of work.)

The gnu.bytecode package has been extensively changed. There are new
classes representing the various standard Attributes, and data
associated with an attribute is now stored there.

Added new procedures environment-bound? and
scheme-implementation-version.

Scheme symbols are represented as java.lang.String objects. Interned
symbols are interned Strings; uninterned symbols are uninterned Strings.
Note that Java strings literals are automatically interned in JDK 1.1.
This change makes symbols slightly more efficient, and moves Kawa closer
to Java.

Ports now use the JDK 1.1 character-based Reader and Writer classes,
rather than the byte-oriented InputStream and OutputStream classes. This
supports different reading and writing different character encodings [in
theory - there is no support yet for other than Ascii or binary files].

An interactive input port now has a prompt function associated with it.
It is settable with set-input-port-prompter!. The prompt function takes
one argument (the input port), and returns a prompt string. There are
also user functions for inquiring about the current line and column
number of an input port.

The R4RS procedures transcript-on and transcript-off are implemented.

Standard types can be referred to using syntax similar to RScheme. For
example Scheme strings now have the type @code{<string>} which is
preferred to "@code{kawa.lang.FString}" (which in addition to being
longer, is also more suspectible to changes in internal implementation).
Though these types are first-class values, this is so far mainly useful
for invoking primitive methods.

@subheading Changes from Kawa 1.4 to 1.5
@anchor{#changes-from-kawa-1.4-to-1.5}
Execute a ~/.kawarc.scm file on startup, if it exists.

Add a number of functions for testing, renaming, and deleting files.
These are meant to be compatible with scsh, Guile, and MIT Scheme:
file-exists?, file-directory?, file-readable?, file-writable?,
delete-file, rename-file, create-diretory, and the variable
home-directory.

Fixed some small bugs, mainly in gnu.math and in load.

Generalize apply to accept an arbitrary Sequence, or a primitive Java
array.

@subheading Changes from Kawa 1.2 to 1.4
@anchor{#changes-from-kawa-1.2-to-1.4}
The codegen package has been renamed gnu.bytecode. The kawa.math package
has been moved to gnu.math. Both packages have new license: No
restrictions if you use an unmodified release, but GNU General Public
License. Let me know if that causes problems. The rest of Kawa still has
the old license.

Implement defmacro and gentemp.

Implement make-record-type and related functions to create and use new
record types. A record type is implemented as a java.lang.Class object,
and this feature depends on the new reflection features of JDK 1.1.

Implement keywords, and extend lambda parameter lists to support
#!optional #!rest and #!keyword parameters (following DSSSL).

Added more primitives to call arbitrary interface and constructor
methods.

@subheading Changes from Kawa 1.0 to 1.2
@anchor{#changes-from-kawa-1.0-to-1.2}
Added primitives to make it easy to call arbitrary Java methods from
Scheme.

Exact rational arithetic is now fully implemented. All integer functions
now believed to correctly handle bignums. Logical operations on exact
integers have been implemented. These include all the logical functions
from Guile.

Complex numbers are implemented (except @{,a@}@{sin,cos,tan@}).
Quantities (with units) are implemented (as in DSSSL).

Eval is available, as specified for R5RS. Also implemented are
scheme-report-environment, null-environment, and
interaction-environment.

Internal define is implemented.

Rough support for multiple threads is implemented.

Moved kawa class to kawa/repl. Merged in kawac (compiler) functionality.
A 'kawa' shell-script is now created. This is now the preferred
interface to both the interactive evaluator and the compiler (on
Unix-like systems).

Now builds "without a snag" using Cafe 1.51 under Win95. (Symantec JIT
(ver 2.00b19) requires disabling JIT - @code{JAVA_COMPCMD=disable}.)
Compiles under JDK 1.1 beta (with some warnings).

A testsuite (and testing framework) was added.

Documentation moved to doc directory. There is now an internals
overview, in doc/kawa-tour.ps.

@subheading Changes since 0.4
@anchor{#changes-since-0.4}
The numeric classes have been re-written. There is partial support for
bignums (infinite-precision integers), but divide (for example) has not
been implemented yet. The representation of bignums uses 2's complement,
where the "big digits" are laid out so as to be compatible with the mpn
functions of the GNU Multi-Precision library (gmp). (The intent is that
a future version of Kawa will support an option to use gmp native
functions for speed.)

The kawa application takes a number of useful command-line switches.

Basically all of R4RS has been implemented. All the essential forms and
functions are implemented. Almost all of the optional forms are
implemented. The exceptions are transcript-on, transcript-off, and the
functions for complex numbers, and fractions (exact non-integer
rationals).

Loading a source file with load now wraps the entire file in a lambda
(named "atFileLevel"). This is for better error reporting, and
consistency with compile-file.

@subheading Changes since 0.3
@anchor{#changes-since-0.3}
The hygienic macros described in the appendix to R4RS are now impemented
(but only the define-syntax form). They are used to implement the
standard "do" form.

The R5RS multiple value functions @code{values} and
@code{call-with-values} are implemented.

Macros (and primitive syntax) can now be autoloaded as well as
procedures.

New kawac application compiles to one or more .class files.

Compile time errors include line numbers. Uncaught exceptions cause a
stack trace that includes .scm line numbers. This makes it more
practical to debug Kawa with a Java debugger.

Quasiquotation is implemented.

Various minor bug fixes and optimizations.

@subheading Changes since 0.2
@anchor{#changes-since-0.2}
The biggest single change is that Scheme procedures are now compiled to
Java bytecodes. This is mainly for efficiency, but it also allows us to
do tail-recursion-elimination in some cases.

The "codegen" library is included. This is a toolkit that handles most
of the details needed to generate Java bytecode (.class) files.

The internal structure of Kawa has been extensively re-written,
especially how syntax transforms, eval, and apply are done, largely due
to the needs for compilation.

Almost all the R4RS procedures are now implemented, except that there
are still large gaps in Section 6.5 "Numbers".