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
  
Changes since Pike 7.6: 
---------------------------------------------------------------------- 
 
This is a high level list of changes between Pike 7.6 and Pike 7.8. 
General bug fixes, build fixes and optimizations are not mentioned 
here. For a complete list of changes, please consult the CVS changelog 
either directly or through Code Librarian. 
 
 
New / improved language functionality 
------------------------------------- 
 
o New syntax to index from the end in range operations. 
 
  A "<" can be added before an index in the [..] operator to count 
  from the end instead, beginning with 0 for the last element. This is 
  convenient to e.g. chop off the last element in an array: a[..<1]. 
 
o New `[..] operator function. 
 
  Range operations have been separated from the `[] operator function 
  and are now handled by the new `[..] which provides greater control 
  for how the range bounds are specified. For compatibility, if there 
  is no `[..] then `[] is still called for range operations. 
 
  The `[..] callback will get four arguments, start value, start type, 
  end value and end type. The type arguments is any of 
  Pike.INDEX_FROM_BEG, Pike.INDEX_FROM_END or Pike.OPEN_BOUND. Here 
  are a few examples of what input arguments different calls would 
  generate. 
 
    [..]      0   OPEN_BOUND       0   OPEN_BOUND 
    [1..]     1   INDEX_FROM_BEG   0   OPEN_BOUND 
    [..2]     0   OPEN_BOUND       2   INDEX_FROM_BEG 
    [3..4]    3   INDEX_FROM_BEG   4   INDEX_FROM_BEG 
    [<5..]    5   INDEX_FROM_END   0   OPEN_BOUND 
    [6..<7]   6   INDEX_FROM_BEG   7   INDEX_FROM_END 
 
o Generalized this and this_program. 
 
  It is now possible to refer to inherits in objects. Example: 
 
    class A { 
      int a; 
      void foo() { werror("A\n"); } 
    } 
    class B { 
      inherit A; 
      int b; 
      void foo() { werror("B\n"); } 
      A::this_program get_a() { return A::this; } 
    } 
 
  In the above B()->get_a() will return an object with two symbols, 
  'a' and 'foo', but B()->get_a()->foo() will still write "B\n". 
 
o Added support for getters and setters. 
 
  It is now possible to simulate variables with functions. Example: 
 
    class A { 
      private int a; 
      int `b() { return a; }            // Getter for the symbol b. 
      void `b=(int c) { a = c; }        // Setter for the symbol b. 
      int c() 
      { 
        return b;                       // Calls `b(). 
      } 
    } 
 
    object a = A(); 
    a->b = 17;                          // Calls `b=(17). 
    werror("%d\n", a->b);               // Calls `b(). 
 
o Casting to derived types. 
 
  It is now possible to call a value of type type to perform the 
  corresponding value cast. eg: 
 
    typedef string MyString; 
 
    return MyString(17);                // Casts 17 to "17". 
 
o Unicode escapes. 
 
  Pike now understands the common way to escape unicode chars, using 
  \uxxxx and \Uxxxxxxxx escapes. These escapes works both in string 
  and character literals and in the preprocessor. The latter means 
  that unicode escapes can be used in identifiers, which is useful if 
  they contain characters that can't be represented raw in the source 
  code charset. 
 
o Stricter type checker for function calls. 
 
  The type checker for function calls is now based on the concept of 
  currification. This should provide for error messages that are more 
  easily understood. It also is much better att typechecking function 
  calls utilizing the splice (@) operator. The mechanisms used by the 
  typechecker are also made available as Pike.get_first_arg_type(), 
  Pike.low_check_call() and Pike.get_return_type(). 
 
o Stricter typing of strings. 
 
  The string type may now have an optional value range. 
 
    string(0..255) bytes; 
 
o Support for having multiple different active backend implementations. 
 
  In Pike 7.6 and earlier, there could only be one active backend 
  implementation at a time, which was the one selected for best 
  performance with lots of files (cf Pike.Backend below). This led 
  to problems when Pike attempted to run poll-device based backends 
  on older versions of operating systems where poll devices aren't 
  available, and with extra overhead when the backend was only used 
  with a very small set of files. 
 
  Basic backend implementations: 
 
  - Pike.PollDeviceBackend 
    This is a backend that is implemented based on keeping the state in 
    the operating system kernel and thus eliminating the need to send the 
    state in every system call. This is however not available on all 
    operating systems. Currently supported are /dev/poll (Solaris, etc), 
    epoll(2) (Linux) and kqueue(2) (FreeBSD, MacOS X). 
 
  - Pike.PollBackend 
    This is a backend that is implemented based on the poll(2) system call. 
    This is typically available on all System V or Linux based systems. 
 
  - Pike.SelectBackend 
    This is a backend that is implmented based on the BSD select(2) system 
    call. This backend is available on all operating systems supported by 
    Pike. 
 
  Derived backend implementations: 
 
  - Pike.Backend 
    This is the backend selected among the basic backend implementations, 
    which is likely to have the best performance when there are lots of 
    files in the backend. 
 
  - Pike.SmallBackend 
    This is the backend selected among the basic backend implementations, 
    which is likely to have the best performance when there are very few 
    files in the backend. 
 
  Note that there is also a default backend object: 
 
  - Pike.DefaultBackend 
    This is the Pike.Backend object that is used for file callbacks and 
    call outs if no other backend object has been specified. 
 
o cpp 
 
  The preprocessor now supports macro expansion in the #include and #string 
  directives. 
 
    #include USER_SETTINGS 
 
o Destruct reason passed to lfun::destroy. 
 
  lfun::destroy now receives an integer flag that tells why the object 
  is being destructed, e.g. if it was an explicit call to destroy(), 
  running out of references, or reaped by the garbage collector. 
 
  These integers are defined in the new Object module as 
  DESTRUCT_EXPLICIT, DESTRUCT_NO_REFS, DESTRUCT_GC and 
  DESTRUCT_CLEANUP. 
 
o Improved support for mixin. 
 
  The Pike compiler now supports mixin for symbols that have been 
  declared protected. Mixin is the concept of overloading symbols 
  via multiple inheritance. In previous versions of Pike the mixin 
  paradigm was only supported for public symbols. For more information 
  about mixin see eg http://en.wikipedia.org/wiki/Mixin . 
 
o Implicit and explicit create(). 
 
  The compiler now supports defining classes with both an implicit 
  and an explicit create(). 
 
    class A (int i) 
    { 
      protected string j; 
      protected void create(string j) 
      { 
        A::j = reverse(j); 
      } 
    } 
 
o Warnings for unused private symbols. 
 
  The compiler now checks that all symbols that have been declared 
  private actually are used. 
 
o Warnings for unused local variables. 
 
  The compiler now checks that all local variables are used. 
 
o Unicode 
 
  Case information and the Unicode module are updated to Unicode 
  5.1.0. 
 
o The keyword protected 
 
  The modifier protected is now an alias for the modifier static. 
  NOTE: In the next release static will be deprecated. 
 
o extern declared variables 
   
  Variables can now be declared as 'extern'. This means that 
  inheriting classes must have them. They can be used like normal 
  variables in the base class. 
 
  Example:  
    class A 
    { 
        extern int a; 
        int dummy() { return ++a; } 
    } 
 
o __attribute__ and __deprecated__ 
 
  It's now possible to set custom attributes on types, so that 
  it is possible to make custom type checking. This is currently 
  used to improve the argument checking for sprintf() and related 
  functions, and for marking symbols as deprecated. 
  eg: 
 
    __deprecated__ mixed obsolete_function(); 
    __deprecated__(mixed) obsolete_return_value(); 
    mixed fun(__deprecated__(mixed) obsolete_arg); 
    __deprecated__(mixed) obsolete_variable; 
 
  The deprecated type flag using __deprecated__ is a convenience 
  syntax to use instead of e.g. 
 
    void f(void|__attribute__("deprecated",int) timeout) 
 
  Other uses of __attribute__ in type declarations can be seen in e.g. 
  the type for werror(): 
 
    > typeof(werror); 
    (1) Result: scope(0,function(string : int) | 
        function(__attribute__("sprintf_format", string), 
                 __attribute__("sprintf_args", mixed) ... : int) | 
        function(array(string), mixed ... : int)) 
 
o __func__ 
 
  The symbol __func__ now evaluates to the name of the current 
  function. Note that this name currently can differ from the 
  declared name in case of local functions (i.e. lambdas). Note 
  also that __func__ behaves like a literal string, so implicit 
  string concatenation is supported. eg: 
 
    error("Error in " __func__ ".\n"); 
 
o __DIR__ 
 
  __DIR__ is a new preprocessor symbol that resolves to the directory 
  that the current file is placed in. Similar to how __FILE__ points 
  out the file the code is placed in. 
 
o #pragma {no_,}deprecation_warnings 
 
  Warnings for use of deprecated symbols can be turned off for a 
  segment of code with 
 
    #pragma no_deprecation_warnings 
 
  and turned on again with 
 
    #pragma deprecation_warnings 
 
o Compatibility name spaces 
 
  Older versions of a function can be reached through its version name 
  space. For example the 7.4 version of the hash function can be 
  called through 7.4::hash(). 
 
o Iterator API 
 
  The iterator API method Iterator->next() is no longer optional. 
 
o IPv6 
 
  Support for IPv6 has been improved. 
 
 
Extensions and New Functions 
---------------------------- 
 
o exit() 
 
  Exit now takes optional arguments to act as a werror in addition to 
  exiting the process. 
 
    exit(1, "Error while opening file %s: %s\n", path, strerror(errno())); 
 
o getenv()/putenv() 
 
  getenv() and putenv() are now accessing and modifying the real 
  environment. 
 
o get_dir() 
 
  Calling get_dir() with no arguments will now return the directory 
  listing for the current directory. 
 
o undefinedp()/destructedp() 
 
  undefinedp() and destructedp() have been added as more readable 
  alternatives to zero_type(). 
 
o limit() 
 
  The new toplevel function limit(a, x, b) is a convenience function 
  that works like min(max(a,x),b). 
 
o listxattr(), getxattr(), setxattr(), removexattr() 
 
  The new xattr functions listxattr(), getxattr(), setxattr and 
  removexattr() allows extended file attributes to be modified from 
  within Pike. 
 
o sprintf() and sscanf() 
 
  - sprintf() now attempts to lookup the name of the program when 
    formatting types of objects and programs. 
 
  - The new formatting directive %H can be used to format a string as 
    a binary hollerith string. 
 
      > sprintf("%2H", "Hello"); 
      (1) Result: "\0\5Hello" 
 
  - The new formatting directive %q can be used to format a atring as 
    a quoted string, quoting all control character and non-8-bit 
    characters as well as quote characters. Like %O but always on one 
    line. 
 
      > sprintf("%q", "abc \x00 \" \' \12345"); 
      (1) Result: "\"abc \\0 \\\" ' \\u14e5\"" 
 
  - Ranges in sscanf sets can now start with ^, even at the beginning 
    of the set specifier. Example: %[^-^] matches a set with only ^ in 
    it. To negate a set with - in it, the - character must now be the 
    last character in the set specifier. 
 
o encode/decode value and programs 
 
   --with-portable-bytecode is now the default. Pike programs that have 
   been dumped on one architecture now can be decoded on another. 
 
o gethrtime, gethrvtime, gauge 
 
  Added support for POSIX style timers using clock_gettime(3). Notably 
  this fixes nice high resolution thread local cpu time and monotonic 
  real time on reasonably modern Linux systems. 
 
  There are new constants CPU_TIME_* and REAL_TIME_* in the System 
  module to allow pike code to query various properties of the CPU and 
  real time clocks in use. 
 
o ADT.BitBuffer 
  
  Added read() method that reads whole bytes from the buffer and 
  returns as a string. 
 
o ADT.Queue 
 
  It is now possible to use sizeof() and values() on a Queue object to 
  get the size of the queue and all elements in the queue as an array. 
 
o ADT.Stack 
 
  Stack objects can now be cast to arrays to get all elements on the 
  stack. 
 
o ADT.Struct 
 
  - New Item class SByte, SWord and SLong represents a signed byte, 
    word and longword respectively. 
 
  - The Item classes int8, uint8, int16, uint16, int32, uint32, int64 
    and uint64 are aliases for already existing Item classes. 
 
  - sizeof() now works for empty Struct objects. 
 
  - sizeof() can be used on individual Item objects. 
 
  - Struct objects can now be used as Items in other Structs. 
 
    class Pair 
    { 
      inherit ADT.Struct; 
      Item id = uint8(); 
      Item val = uint64(); 
    } 
 
    class File 
    { 
      inherit ADT.Struct; 
      Item magic = Chars(4); 
      Item one = Pair(); 
      Item two = Pair(); 
    } 
 
o Array 
 
  - New function combinations() returns all combinations of a 
    specified length with elements from a given array. 
 
  - Added push(), pop(), shift() and unshift() functions for Perl 
    weirdos. 
 
o Calendar 
 
  - Added new calendar Badi, used in the Baha'i religion. 
 
  - Fixed bugs in discordian, where the year() was off by 1166 and 
    now() was off 5 month per year. 
 
  - Time objects now handle * and / with floats. A split() method has 
    been added for more advanced splitting where the preferred time 
    quanta can be given as an argument. 
 
  - A new formatting method format_ext_time_short() has been added to 
    Time objects. 
 
  - Timezones are now read from /etc/localtime, if available. 
 
  - Cleaned up year-day (yd) handling so that it never goes below 1. 
    Instead be careful to use either year (y) or week-year (wy) 
    depending on context. 
 
  - Fixed inconsistent range handling in year() and years() that made 
    them almost but not quite zero-based. Now they are one-based just 
    like day()/days(), month()/months() etc. 
 
  - Cleaned up conversion between weeks and years: E.g. if a week has 
    days in two years then converting it to years will produce a range 
    of both years. The attempt to always map a week to a single year 
    is gone since it's inconsistent with how other overlapping time 
    ranges are handled. If the user wants to convert a week to the 
    year it "unambiguously" belongs to, (s)he can do 
    Calendar.ISO.Year(week->year_no()). 
 
  - Did away with the attempt to map leap days between February 24th 
    and 29th before and after year 2000, since doing so breaks date 
    arithmetic. 
 
  - The last four changes above are not entirely compatible. 
    Compatibility with 7.6 and older is retained with #pike 7.6. 
 
o CompilerEnvironment & CompilerEnvironment()->PikeCompiler 
 
  The Pike compiler has been refactored to be more object-oriented and 
  more transparent. It is now possible to customize the compiler by 
  overloading functions in the above two classes. The compiler object 
  used by Pike internally is available through the global constant 
  DefaultCompilerEnvironment. 
 
o Debug 
 
  The new function count_objects() will return the different kinds of 
  objects existing within the Pike process. Useful when trying to 
  pinpoint a leak of Pike objects. 
 
o Error 
 
  The new function mkerror() will normalize any thrown value into a 
  proper error object (or 0). 
 
o Filesystem 
 
  Traversion has been extended with two new create arguments. The 
  first one is a flag to supress errors and the other is a sorting 
  function which will be applied to the entries in every directory. 
  This callback can also be used to filter the directory entries. 
 
o Float 
 
  The function isnan() can be used to check if a float is Not a 
  Number. 
 
    > Float.isnan(Math.inf/Math.inf); 
    (1) Result: 1 
 
o Gdbm 
 
  Gdbm databases can be opened in synchronous mode or locking mode by 
  adding "s" or "l" respectively in the mode parameter to the create 
  method. 
 
o Geography.Position 
 
  It is now possible to encode Position objects with encode_value(). 
 
o GLUE 
 
  - The default event callback will now exit both on Exit and Escape 
    events. 
 
  - The texture, list and light id generators will now be created 
    after we are sure that GL has been initialized, to prevent crashes 
    on several systems. 
 
  - BaseTexture and BaseDWIM now supports clamped textures. 
 
o Gmp 
 
  Many small changes to fix Gmp build issues on different platforms. 
  The most visible being that the Gmp module now is statically linked 
  to work around Mac OS X 10.5 linker issues. 
 
o Gz 
 
  - Added compress() and uncompress() functions as an simpler and more 
    efficient but non-streaming interface. 
 
  - Support for RLE And FIXED compression method, if supported by 
    zlib. Give Gz.RLE or Gz.FIXED to the strategy argument of 
    compress() or the deflate constructor. 
 
  - Added support for configurable compression window size. This is 
    the last argument to compress() and the constructor for 
    inflate/deflate. 
 
o Image.Colortable 
 
  - The new method greyp() can be used to query if the color in the 
    color object is grey. 
 
  - Partial support for serializing color objects. Dithering type and 
    lookup mode is not currently saved. 
 
o Image.Dims 
 
  Support for parsing out the dimensions of TIFF files has been added. 
 
o Image.FreeType 
 
  - Added support for handling monochrome (bitmap) fonts. 
 
o Image.Image 
 
  - Image object can now be serialized and deserialized with 
    encode_value() and decode_value(). 
 
  - It is possible to convert the colors in an image object to and 
    from YUV (YCrCb) with the new rgb_to_yuv() and yuv_to_rgb() 
    methods. 
 
o Image.Layer 
 
  - It is now possible to get the raw bitmap data of a layer by 
    casting the layer object to a string. 
 
o Image.PNG 
 
  - Properly decode cHRM (chrome), sBIT (sbit), gAMA (gamma), pHYs 
    (physical), oFFs (offset), tIME (time) chunks. 
 
  - The compression level and strategy when compressing PNG images can 
    be controlled by passing "zlevel" and "zstrategy" options to the 
    encode() method. Available strategies are filtered, huffman, rle 
    and fixed. 
 
      Image.PNG.encode( img, ([ "zlevel":9, "zstrategy":Gz.RLE ]) ); 
 
o Image.TIFF 
 
  Added support for little endian TIFF files. 
 
o Int 
 
  Int.inf is an object that can be used as an infinitly large integer. 
 
o Java 
 
  - If possible, Pike now uses libffi instead of creating our own 
    trampolines. Adding libffi as a bundle is supported. 
 
  - Added built-in support for SPARC64 trampolines. 
 
  - The method signature fuzzy-matcher now only considers Pike strings 
    to match formal parameters of type String, Object, Comparable, 
    CharSequence or java.io.Serializable. 
 
  - When the fuzzy-matcher can not decide on a single method 
    signature, all candidates are now listed in the error message. 
 
o Locale.Charset 
 
  - The character name normalizer now recognizes Unicode prefixes, 
    e.g. "unicode-1-1-utf-7", though the Unicode version itself is 
    ignored. 
 
  - Added support for the following character sets 
 
    GB18030/GBK (CP936) 
    UTF-EBCDIC 
    DIN-31624 (ISO-IR-38) 
    ISO-5426:1980 (ISO-IR-53) 
    ISO-6438:1996 (ISO-IR-39, ISO-IR-216) 
    ISO-6937:2001 (ISO-IR-156) 
    GSM 03.38 
    Mysql Latin 1 
 
  - Added typed encode and decode error objects, 
    Locale.Charset.EncodeError and Locale.Charset.DecodeError, to make 
    it possible to catch such errors in a better way. 
 
  - ISO-IR non-spacers are now converted into combiners. 
 
o Math 
 
  - Matrix multiplication was bugged and gave B*A instead of A*B, 
    which is now fixed. 
 
  - Matrix objects now have xsize() and ysize() methods to query their 
    dimensions. 
 
  - To ease your logarithmic needs log2() and logn() have been added. 
 
o MIME 
 
  - Added remapping variants of the encode words functions with 
    encode_word_text_remapped(), encode_word_quoted(), 
    encode_words_quoted_remapped() and 
    encode_words_quoted_labled_remapped(). 
 
  - Added workaround for a bug in Microsoft Internet Explorer where it 
    forgets to properly quote backslashes in the Content-Disposition 
    field. 
 
  - Fixed a bug that could occur when casting MIME.Message objects to 
    strings. 
 
o Mysql 
 
  - Two functions set_charset() and get_charset() have been added to 
    set and query the connection charset. The create() function also 
    takes a "charset" setting in the options mapping. 
 
  - Improved Unicode support. The MySQL driver now supports 
    (possibly wide) Unicode queries and text return values, handling 
    the connection charset and all encoding/decoding internally. This 
    is enabled by setting the charset to "unicode", or through the new 
    functions set_unicode_encode_mode() and set_unicode_decode_mode(). 
    See their documentation for further details. 
 
o Odbc 
 
  The Odbc module has been updated to support the UnixODBC library, and 
  several issues with Unicode and FreeTDS handling have been fixed. 
 
o Oracle 
 
  - The module has been updated to work with Oracle 10. 
 
  - An approximation of the number of rows in a result object can be 
    queried from the new function num_rows(). 
 
o Parser.HTML 
 
  - Allow string and array as argument to _set_*_callback(). Those 
    variants work just like a function only returning the string or 
    array. 
   
o Parser.Pike and Parser.C 
 
  - Parser.Pike and Parser.C have been rewritten in C for increased 
    performance. 
 
  - The #string directives should be handled correctly now. 
 
o Parser.RCS 
 
  - The RCS parser has been rewritten to be more robust with regards 
    to broken RCS data. 
 
o Parser.XML.NSTree 
 
  - Added add_child_before() and add_child_after() methods to the 
    NSNode object. 
 
o Parser.XML.Simple 
 
  - The autoconvert() function, used to autodetect the character 
    encoding of an XML file and decode it, has been moved from being a 
    method of the Parser.XML.Simple object to being a function in the 
    Parser.XML module. 
 
o Parser.XML.SloppyDOM 
 
  Yet another DOM-like module aimed at quickly and conveniently parse 
  an xml snippet (or whole document) to access its parts. Nodes can be 
  selected using a subset of XPath. 
 
  Footnote: This module was previously part of Roxen WebServer. 
 
o Parser.XML.Tree 
 
  The module code has been refactored and a second "simple" interface 
  has been added. The (new) SimpleNode interface implements a node tree 
  interface similar to the (old) Node interface, with two major 
  differences: 
 
  - The SimpleNodes do not have parent pointers, this means that they 
    do not generate cyclic data structures (and thus less garbage, and 
    no need for zap_tree()), but also that it is no longer possible to 
    find the root of a tree from any node in the tree. 
 
  - Some methods in SimpleNode return different values than the 
    corresponding method in Node; notably SimpleNode()->add_child(), 
    which returns the current node rather than the argument. 
 
  The refactoring also added individual classes for all of the XML node 
  types (both for Nodes and for SimpleNodes). This allows for stricter 
  typing of code involving XML tree manipulation. 
 
  Several new functions added to manipulate and insert nodes in the 
  XML tree. 
 
  The module now also has a much better knowledge of DTDs and DOCTYPEs. 
 
o Parser.XML.Validating 
 
  - get_external_entity() now gets the callback info mapping as 
    the third argument rather than a constant zero. 
 
  - SYSTEM URIs are now normalized during parsing if possible. 
 
  - parse() and parse_dtd() now accept getting the base URI for the 
    parsed data as the second argument. 
 
  - Improved error reporting. 
 
  - Several issues with the parsing of DTDs have been fixed. 
 
o Postgres 
 
  - Extended the SQL query interface to include affected_rows() and 
    streaming_query() as well as variable bindings. 
 
  - Automatic binary or text transfer for queryarguments and resultrows. 
 
  Note: A new native Postgres driver has also been added; see 
  Sql.pgsql. 
 
o Pike 
 
  - A new function count_memory() has been added which can calculate 
    the memory consumed by arbitrary data structures. Useful when 
    implementing memory caches. 
 
  - A new function get_runtime_info() has been added which returns 
    information about current ABI, if automatic bignums are enabled, 
    what bytecode method is used, the size of native floats and 
    integers and the native byte order. 
 
  - The constants INDEX_FROM_BEG, INDEX_FROM_END and OPEN_BOUND has 
    been added for use with the `[..] operator API. 
 
  - The functions low_check_call(), get_return_type() and 
    get_first_arg_type() allows for inspection of attributes and 
    return values of functions. 
 
o Pike.Backend 
 
  Besides the new multiple backend implementations described earlier, 
  backends now support two new callbacks: before_callback and 
  after_callback are two new variables in the backend objects. They 
  can be set to functions that gets called just before and after a 
  backend is waiting for events. 
 
o Process 
 
  - The new function spawn_pike() will spawn a Pike process similar to 
    the current one, using the same binary file, master and module 
    paths. 
 
  - The new function run() is an easy interface that will run a 
    process and return a mapping with all the outputs and exit code. 
 
  - Process.popen is now able to run in nonblocking mode. If a second 
    argument is provided a file object will be opened with that mode 
    and return, enabling two way communication with the new process. 
 
  - The system() function has been extended to be able to pass stdin, 
    stdout and stderr arguments to the spawn() call it performs. 
 
o Protocols.DNS 
 
  - Added support for NAPTR (RFC 3403) and SPF (RFC 4408) records. 
 
  - The gethostbyname() function now returns IPv6 addresses too, if 
    available. 
 
  - Fixed bugs in IPv6 record parsing. 
 
o Protocols.Bittorrent 
 
  - Support for gzipped and compact tracker responses. 
 
  - Many performance and bug fixes, such as 30% faster hashing of 
    files. 
 
o Protocols.HTTP 
 
  - Added support for httpu and httpmu requests. 
 
  - Queries will now throw an exception in case of an errno condition. 
 
  - A new function, do_async_method(), has been added to allow access 
    to low level asynchronous HTTP calls. 
 
  - The http_encode_string() function now knows how to encode UCS-2 
    characters. 
 
o Protocols.HTTP.Server 
 
  - If accept() fails on the open port, the Port object will continue 
    trying, to support servers with high load. 
 
o Protocols.HTTP.Query 
 
  - Added unicode_data() method that will return the payload decoded 
    according to the charset described in the Content-Type header. 
 
  - Many fixes for bugs in asynchronous mode. 
 
  - A query will not silently downgrade to http from https anymore if 
    there is no crypto support. 
 
  - Fixes for keep alive. 
 
o Protocols.LDAP 
 
  - Enabled support for paged queries. 
 
  - Added more resilience to UTF-8 encode errors. 
    Locale.Charset.DecodeError is thrown for UTF-8 decode exceptions. 
 
  - Added a connection pool for connection reuse. It is used through 
    get_connection() and return_connection(). 
 
  - Added some schema handling and use it to fix the UTF-8 conversion 
    to only affect attributes that actually are UTF-8 encoded. 
 
  - Added client.read(), client.read_attr(), 
    client.get_root_dse_attr(), client.get_basedn(), 
    client.get_scope(), client.get_attr_type_descr(), 
    get_constant_name(), and a bunch of constants for various object 
    oids, attributes, well-known object guids and other things. 
 
  - Rewrote the search filter parser to handle LDAPv3 extensible 
    matches. It now also throw errors on all syntactic errors (using a 
    new FilterError object), instead of sending a partial filter to 
    the server. It is also possible to compile filters separately 
    through make_filter(), and there is a very simple cache for 
    compiled filters through get_cached_filter(). 
 
  - Added ldap_encode_string(), ldap_decode_string(), 
    encode_dn_value(), canonicalize_dn(), parse_ldap_url(), 
    client.get_parsed_url(), and client.get_bound_dn(). 
 
  - Added client.result.fetch_all(). 
 
  - Added new flag field to client.search() to control various aspects 
    of how results are returned: SEARCH_LOWER_ATTRS lowercases all 
    attribute names. SEARCH_MULTIVAL_ARRAYS_ONLY uses arrays for 
    attribute values only for attributes that might return more than 
    one value. SEARCH_RETURN_DECODE_ERRORS may be used to avoid 
    throwing exceptions on decode errors. 
 
  - Added client.get_protocol_version(), 
    client.get_supported_controls(), and the possibility to specify 
    controls in client.search(). 
 
  - Made the result iterator somewhat more convenient: next() now 
    advances one step past the end so the next fetch() returns zero. 
 
  - Added client.error_number(), client.error_string(), and 
    client.server_error_string() to make it possible to query errors 
    when no result object is returned. 
 
o Protocols.SNMP 
 
  The readmsg() method in the protocol object now takes an optional 
  timout argument. 
 
o Protocols.TELNET.Readline 
 
  Several issues where callback functions could be lost have been fixed. 
 
o Protocols.XMLRPC 
 
  The new AsyncClient class implements an asynchronous XMLRPC client. 
 
o Regexp.PCRE.Widestring 
 
  - Replace matches in a string, with support for backreferences, now 
    possible from replace_positional(). 
 
      > Regexp.PCRE.Plain("my name is ([a-zA-Z]+)")-> 
      >> replace_positional("hello, my name is john.", 
      >> "%[0]s is my name"); 
      (1) Result: "hello, john is my name." 
 
  - Regexp.PCRE.Widestring is now reported in the basic feature list 
    (pike --features). 
 
o Sql 
 
  - Bugfixes in listing Postgres fields. 
 
  - If ENABLE_SPAWN_RSQLD is defined, rsqld will be spawned when 
    needed to complete rsql queries. 
 
  - Added streaming_query() method to Sql objects which enables larger 
    result sets than available memory. 
 
  - It is possible to iterate over the result object from big_query() 
    queries directly in foreach. 
 
  - Support UNDEFINED to designate NULL in emulated bindings. 
 
  - Support for ODBC DSN files. 
 
      Sql.Sql db = Sql.Sql("dsn://user:pass@host/database"); 
 
  - Some native support for the TDS protocol, used by Sybase and 
    Microsoft SQL server. 
 
      Sql.Sql db = Sql.Sql("tds://user:pass@host/database"); 
 
  - Support for the SQLite database added. A raw interface is 
    available through the SQLite module. 
 
      Sql.Sql db = Sql.Sql("sqlite://relative/path/to/file"); 
      Sql.Sql db = Sql.Sql("sqlite:///absolute/path/to/file"); 
 
  - Sql.pgsql.  New driver for native PostgreSQL network protocol support. 
    It implements a superset of the existing Postgres driver. 
    Current features: no library dependencies (no libpq), native binding 
    support, streaming support, NOTIFY/LISTEN support (fully eventdriven, 
    no polling), binary support for integer, float and string datatypes 
    through big_typed_query(), native support for 64-bit ints and doubles, 
    COPY FROM/TO STDIN/STDOUT support, multiple simultaneous streaming 
    queries on the same connection (i.e. multiple PostgreSQL-portal- 
    support), automatic precompilation and caching of often-used 
    long-compile-time-needing queries, extended columndescriptions, 
    accurate error messages under all circumstances, SSL-support, 
    SQL-injection protection since it will ignore everything after the 
    first semicolon delimiting the first command in the query, integrated 
    statistics, _reconnect callback for sessions that use temptables. 
 
    Performance tuned, with the helperclass _PGsql.PGsql it currently 
    is around 21% faster than the old libpq based Postgres driver 
    for smaller queries; for large bytea blobs and large texts, it 
    speeds up even more. 
 
    This driver serves URLs of the form: 
                                    pgsql:// (plain) and pgsqls:// (SSL). 
    In case the old Postgres driver is disabled, this driver takes 
    over postgres:// transparently as well. 
 
o SSL 
 
   It is now possible to set certificates to SSL connections. Example: 
 
   SSL.sslfile ssl_connection(Stdio.File conn, string my_key, 
                              string my_certificate) 
   { 
     ctx->client_rsa = Standards.PKCS.RSA.parse_private_key(my_key); 
 
     // client_certificates is an array holding arrays of certificate 
     // chains. since we've got a self-signed cert, our cert array has 
     // only 1 element. 
     ctx->client_certificates += ({ ({ my_certificate }) }); 
 
     return SSL.sslfile(conn, ctx, 1, 1); 
   } 
 
o Standards.IIM 
 
  Some bugfixes in parsing Photoshop headers and DOS EPS Binary 
  Headers. 
 
o Standards.ISO639_2 
 
  Updated with the latest ISO639-2 languages. 
 
o Standards.URI 
 
  - Updated to conform to RFC 3986. 
 
  - Added methods get_query_variables(), set_query_variables(), 
    add_query_variable() and add_query_variables() to give a better 
    API to to handle query variables. 
 
  - The new method get_http_query() returns the query part and 
    get_http_path_query() returns both the path and the query, both 
    coded according to RFC 1738. 
 
o Standards.UUID 
 
  - Added support for UUID version 5; name based with SHA hash, which 
    can be generated from the make_version5 function. 
 
  - An UUID object can now be used as namespace in the second argument 
    to make_version3 as well as the new make_version5. 
 
o Standards.XML.Wix 
 
  - Updated to support a more recent version of the Wix tool chain. 
 
  - Improved generation of 8.3-style filenames. 
 
  - Added support for Shortcut and IniFile-nodes. 
 
  - Added support for overriding the language and installer version. 
 
  - Improved support for TTF-files. 
 
o Stdio 
 
  - Stdio.cp can now work recursively in a directory tree. It will 
    also keep the permissions of files it copies. 
 
  - Added Stdio.recursive_mv which works on every OS and also when the 
    destination isn't on the same filesystem as the source. 
 
  - Added more symbolc default termcap/terminfo bindings to 
    Stdio.Readline. 
 
  - Improved support for Terminfo on NetBSD. 
 
  - read_file(), read_bytes(), write_file() and append_file() will may 
    now throw exceptions on uncommon errors such as when write_file is 
    unable to write all its data. 
 
  - Stdio.File->openat(), statat() and unlinkat() opens, stats and 
    removes a file or directory relative to an open directory. 
 
  - Stdio.FILE->unread() allows pushing back binary strings into the 
    input stream, as opposed to ungets() which pushes back lines. 
 
  - Stdio.UDP has had enable_multicast(), set_multicast_ttl(), 
    add_membership() and drop_membership() added to make real 
    multicast use possible. 
 
o String 
 
  - The function int2size has been rewritten to fixpoint as well as 
    using the more common abbreviation of "B" for byte. 
 
  - String.secure marks a string as "secure" which currently only 
    means that the memory is cleared before it is freed. 
 
o System 
 
  - resolvepath() is now enabled on more OSes and falls back to 
    realpath(3C) if resolvepath(2) doesn't exists. 
 
  - On systems that support it, setproctitle() can be used to set the 
    title of the running application. 
 
  - Added support for POSIX style timers using clock_gettime(3) to 
    allow for high resolution thread local cpu time and monotonic real 
    time on reasonable modern Linux systems for gethrvtime() and 
    gauge(). Added CPU_TIME_RESOLUTION, CPU_TIME_IMPLEMENTATION, 
    REAL_TIME_IS_MONOTONIC, REAL_TIME_RESOLUTION and 
    REAL_TIME_IMPLEMENTATION constants to tell the system 
    capabilities. 
 
o Tools.Hilfe 
 
  - Added support for tab-completion on modules, global and local 
    symbols and operators. 
 
  - Added support for file/directory completion within strings 
 
  - Added doc command and F1 key to print documentation on an item if 
    available (currently only works for modules and classes written in 
    pike). 
 
o Tools.Standalone 
 
  - "pike -x cgrep" now tries to parse Java code. 
 
  - "pike -x features" now tests for several more features. 
 
o Web.Crawler 
 
  - Bugfix to support robots.txt created on windows. 
 
  - User Agent change to "Mozilla 4.0 (PikeCrawler)" 
 
o Web.RDF 
 
  - Added add_statement() method which allows new relations to be 
    added to an RDF set. 
 
 
New modules / classes / methods added 
------------------------------------- 
 
o Fuse 
 
  FUSE (Filesystem in USErspace) provides a simple interface for 
  userspace programs to export a virtual filesystem to the Linux 
  kernel (and some other OS:es). FUSE also aims to provide a secure 
  method for non privileged users to create and mount their own 
  filesystem implementations. 
 
  This module implements the needed interfaces to make it possible to 
  write a FUSE filesystem in Pike. 
 
o ADT.List 
 
  A simple doubly linked list of values. 
 
    ADT.List l = ADT.List(1, 2, 3); 
    l->insert(-1, 0); 
    l->append(4, 5); 
    foreach(l; int index; int value) { 
      werror("  %d: value: %d\n", index, value); 
    } 
 
o ADT.Set 
 
  ADT.Set implements a datatype for sets. These sets behave much 
  like multisets, except that they are restricted to containing only 
  one instance of each member value. 
 
  From a performance viewpoint, it is probably more efficient for a 
  Pike program to use mappings to serve as sets, rather than using an 
  ADT.Set, so ADT.Set is mainly provided for the sake of completeness 
  and code readability. 
 
o Arg 
 
  The new argument parser module allows for Getopt style argument 
  parsing, but with a much simpler and object oriented API. 
 
    class Parser 
    { 
      inherit Arg.Options; 
      Opt verbose = NoOpt("-v")|NoOpt("--verbose")|Env("VERBOSE"); 
      Opt name = HasOpt("-f")|HasOpt("--file")|Default("out"); 
      Opt debug = MaybeOpt("-d")|MaybeOpt("--debug"); 
    } 
   
    void main(int argc, array(string) argv) 
    { 
      Parser p = Parser(argv); 
      werror("name: %O, verbose: %O, debug: %O\n", 
             p->name, p->verbose, p->debug); 
    } 
 
  A more simplistic interface is also available for smaller hacks and 
  programs. 
 
    void main(int argc, array(string) argv) 
    { 
      mapping opts = Arg.parse(argv); 
      argv = opts[Arg.REST]; 
    } 
 
o GSSAPI 
 
  Implements Pike access to GSS-API v2 as specified in RFC 2743. This 
  API is used to authenticate users and servers, and optionally also 
  to encrypt communication between them. The API is generic and can be 
  used without any knowledge of the actual implementation of these 
  security services, which is typically provided by the operating 
  system. 
 
  The most common implementation is Kerberos, which means that the 
  main benefit of this API is to allow clients and servers to 
  authenticate each other using Kerberos, thereby making single 
  sign-on possible in a Kerberized environment. 
 
o GTK2 
 
  Wrapper for the GTK2 library. Not yet 100% completed, but usable. 
 
o Protocols.DNS_SD 
 
  This module provides an interface to DNS Service Discovery. The 
  functionality of DNS-SD is described at <http://www.dns-sd.org/>. 
 
  Using the Proctocols.DNS_SD.Service class a Pike program can 
  announce services, for example a web site or a database server, to 
  computers on the local network. 
 
  When registering a service you need to provide the service name. 
  service type, domain and port number. You can also optionally 
  specify a TXT record. The contents of the TXT record varies between 
  different services; for example, a web server can announce a path 
  to a web page, and a printer spooler is able to list printer 
  features such as color support or two-sided printing. 
 
  The service is registered on the network for as long as the instance 
  of the Service class is valid. 
 
o Bittorrent.Tracker 
 
  Bittorrent tracker with support for scraping and UDP extension. 
 
o Protocols.HTTP.Server.Proxy 
 
  A simple HTTP proxy. 
 
o Standards.TLD 
 
  Country domains and other TLDs according to IANA. Useful when 
  parsing log information or providing live information about clients 
  connecting to your server. 
 
o Tools.Shoot 
 
  Several new tests have been added to benchmark and improve on 
  various aspects of Pike. ReplaceParallel and ReplaceSerial measure 
  the times it takes to replace multiple substrings of a string in a 
  single call to replace and with subsequent calls. 
 
  TagRemoveArraySscanf, TagRemoveDivide, TagRemoveLoop, 
  TagRemoveParserHTML, TagRemovePCRE, TagRemoveSearch and 
  TagRemoveSscanf measure different methods of completing the same 
  task; to remove XML tags from a string. 
 
o Web.CGI 
 
  Provides a CGI interface on the callee side. Retrieves information 
  from environment variables and populates the variables in the 
  Request object. 
 
 
Deprecations 
------------ 
 
o The keyword nomask has been deprecated. It was functionally 
  equivivalent with the keyword final. 
 
o Stdio.File->set_peek_file_before_read_callback() is deprecated. 
 
 
Incompatible changes 
-------------------- 
 
  These incompatible changes can be solved by adding #pike 7.6 to your 
  source file or starting Pike with -V7.6 unless otherwise noted. 
 
o main() environment 
 
  The main() method will no longer be given the environment as a 
  mapping as third argument. Use an explicit call to getenv() instead. 
 
o Array.transpose_old 
 
  This function has been removed. 
 
o Calendar 
 
  Changes made to fix inconsistensies has created som unavoidable 
  incompatibilities. See the entry for Calendar in the functional 
  changes section for details. 
 
o _Charset 
 
  The parts of this internal module that were written in Pike 
  have moved to Locale.Charset. 
 
o Crypto 
 
  The old crypto functions from Pike 7.4 have been removed. These 
  functions produced a warning when used in Pike 7.6. 
 
o Debug.describe_program 
 
  The API for this debug function has changed. 
 
o Image.Image 
 
  The functions select_colors(), map_closest(), map_fast() and 
  map_fs() has been removed. Use Image.Colortable operations instead. 
 
o Parser.XML 
 
  The XML parsers are now stricter in verifying the correctness 
  of the XML. The function compat_allow_errors can be called in the 
  create method of the Parser.XML.Simple and Parser.XML.Validating 
  (with "7.6" as argument for 7.6 compatibility). Parser.XML.Tree can 
  be created with PARSE_COMPAT_ALLOW_ERRORS_7_6 as flag. 
 
o Protocols.LDAP.client 
 
  The "dn" field wasn't properly utf-8 decoded in 7.6 and earlier. If 
  your application does it yourself, you need to use the compatibility 
  version of this class. 
 
o Protocols.TELNET 
 
  The interface functions create() and setup() are now protected symbols. 
 
o spider.XML 
 
  The spider module no longer contains the XML parser. The functions 
  isbasechar(), iscombiningchar(), isdigit(), isextender(), 
  isfirstnamechar(), ishexchar(), isidiographic(), isletter(), 
  isnamechar() and isspace() have also been moved to the Parser module. 
 
o Sql.Sql 
 
  Pike will no longer create a .column entry in SQL query responses if 
  there is no table name. 
 
o Standards.UUID 
 
  Functions new() and new_string() have been removed. Use 
  make_version1(-1)->encode() and make_version1(-1)->str() instead. 
 
o Stdio 
 
  The functions read_file(), read_bytes(), write_file() and 
  append_file() now always throw errors on error conditions, 
  to allow easier use as errno doesn't have to be checked. 
  read_file() and read_bytes() still return 0 if the file 
  does not exist. 
 
o The modules Mird, Perl and Ssleay have been removed. 
 
  Note that these modules are not available via the backwards 
  compatibility layer. 
 
 
C level module API 
------------------ 
 
o Improved support for embedding. 
 
  Several declarations and definitions (most notably the debug and 
  runtime flags) have moved from main.h to pike_embed.h, in an attempt 
  to add support for embedding. 
 
o Major compiler API cleanups. 
 
  The Pike compiler is now executing in a pike function context 
  (rather than in an efun context), and it is possible to customize 
  some of its behaviour via inherit (rather than via handler objects). 
  As a consequence the compiler is now much closer to being thread-safe. 
 
o The global variable next_timeout is no more. It has been replaced by 
  a backend-specific variable. Added backend_lower_timeout() for accessing 
  the new variable. This fixes issues GTK, GTK2 and sendfile had with the 
  new backend implementation. 
 
  NOTE! C-API incompatibility! 
  NOTE! Changed the argument for backend callbacks! 
 
  The argument is now a struct Backend_struct * when called 
  at entry (was NULL). 
  The argument is now NULL when called at exit (was 1). 
 
o Pike_fp->context 
 
  Pike_fp->context is now a pointer to the current struct inherit 
  rather than a copy of it. This allows for easier access to 
  inherited symbols in C-code. 
 
o Inherit level argument added to several object handling functions. 
 
  In order to implement subtyping of objects, an extra argument 
  "inherit_level" has been added to many object indexing related 
  functions. 
 
o .cmod: 
 
  Voidable pointer types are no longer promoted to mixed. 
 
o Support for class symbols with storage in parent scope. 
  Also added support for aliased symbols. 
 
o Machine code backend for PPC64 
 
  - Machine code generation is now supported for PowerPC in 
    64-bit ABI mode. 
 
o Objectiv-C embedding framwork 
 
  - Experimental support for interfacing with Objective-C code 
    has been added. 
 
    NOTE! This API is experimental and is subject to change 
    NOTE! without notice. 
 
o Added %c and %C to get_all_args to get char * without 
  NUL characters (no 0 valued characters inside the string). 
 
  %c: char *          Only narrow (8 bit) strings without NUL. 
      This is identical to %s. 
 
  %C: char * or NULL  Only narrow (8 bit) strings without NUL, or 0 
 
 
Building and installing 
----------------------- 
 
o Dynamic modules now become DLLs on Windows. 
 
  This means the homegrown module loader is no longer used, but it 
  also means some DLL limitations: 
 
  - PMOD_EXPORT is now required to allow access to an identifier in 
    the pike core. 
 
  - DLLs have to be recompiled too if pike.exe is recompiled. 
 
  The primary motivation for this change is to work with the new 
  library tracking (so-called "side-by-side assemblies") in Visual C++ 
  2005 and later. 
 
o Added ABI selection. 
 
  It's now possible to select whether to compile in 32bit or 64bit 
  mode at configure time by using the --with-abi option. 
 
o MinGW builds. 
 
  It's now possible to build Pike in MinGW on windows computers from 
  source distributions. 
 
o Cmod precompiler. 
 
  - The cmod precompiler (pike -x precompile) now supports declaring 
    all autogenerated identifiers as static. 
 
    NOTE! C-API incompatibility! 
    NOTE! As a side effect of this change, the DECLARATIONS statement 
    NOTE! now required in cmod files. 
 
 
New simplified method to write external C/C++ modules 
----------------------------------------------------- 
 
  It's now suggested that you do not use the fairly complex 'pike 
  internal' style of external modules (configure.in with 
  AC_MODULE_INIT etc). 
 
  It's also no longer required that you have a configure script to use 
  pike -x module. 
 
  Instead simply locate the includefiles using 'pike -x cflags', and 
  convert .cmod to .c files using 'pike -x precompile'. 
 
  An example rather minimal 'pike -x module' compatible Makefile, 
  without a configure script, using .cmod format files for a simple 
  local module: 
 
  | CC=gcc 
  | CFLAGS := -O9 -fweb -shared -Wall $(CFLAGS) $(shell $(PIKE) -x cflags) -g 
  | LD=$(CC) -shared -lGL 
  |  
  | all: Spike.so 
  | 
  | install: Spike.so 
  |     cp $< $(MODULE_INSTALL_DIR) 
  |  
  | Spike.so: Spike.o 
  |     $(LD) -o Spike.so Spike.o $(LDFLAGS) 
  |  
  | Spike.o: Spike.c 
  |  
  | Spike.c: Spike.cmod 
  |     $(PIKE) -x precompile $< > $@ 
 
  It's usually OK not to use pike -x module at all, but it will pass 
  on a few extra variables to your make (and configure script): 
 
   PIKE: How to start the pike interpreter used running pike -x module 
   MODULE_INSTALL_DIR: Where modules goes 
   LOCAL_MODULE_PATH: Alternative (user local) module location