Source

pynie / src / builtins / funcs.pir

Full commit
   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
=head1 NAME

src/builtins/funcs.pir - built-in functions


=head1 DESCRIPTION

Implements Python's built-in functions. Descriptions are taken from:
http://docs.python.org/lib/built-in-funcs.html

NOTE: most functions are not implemented yet, only stubs are supplied.

=head1 Functions

=over 4

=cut

.namespace []
.loadlib 'trans_ops'

=item abs(x)

Return the absolute value of a number. The argument may be a plain or
long integer or a floating point number. If the argument is a complex
number, its magnitude is returned.

=cut

.sub 'abs'
    .param pmc x
    $P0 = abs x
    .return ($P0)
.end


=item all(iterable)

Return True if all elements of the iterable are true.

=cut

.sub 'all'
    .param pmc iterable
    .local pmc iterator, result, obj
    iterator = iter iterable
    result = new 'Integer' # should be boolean or whatever

    .local int bool
  loop_check:
    unless iterator goto loop_end
    obj = shift iterator
    bool = istrue obj
    unless bool goto fail
    goto loop_check
  loop_end:

    result = 1
    .return (result)

  fail:
    result = 0
    .return (result)
.end


=item any(iterable)

Return True if any element of the iterable is true.

=cut

.sub 'any'
    .param pmc iterable
    .local pmc iterator, result, obj
    iterator = iter iterable
    result = new 'Integer' # should be bool
    .local int bool

 loop_check:
    unless iterator goto fail
    obj = shift iterator
    bool = istrue obj
    unless bool goto loop_check

    result = 1
    .return (result)

 fail:
    result = 0
    .return (result)
.end


=item bool([x])

Convert a value to a Boolean, using the standard truth testing procedure.
If x is false or omitted, this returns False; otherwise it returns True.
bool is also a class, which is a subclass of int. Class bool cannot be
subclassed further. Its only instances are False and True.

=cut

.sub 'bool'
    .param pmc x :optional
    .param int has_x :opt_flag

    .local pmc result
    result = new 'Integer' # should be bool or whatever

    if has_x == 0 goto fail
    $I0 = x
    unless $I0 goto fail
    result = 1
    .return (result)

  fail:
    result = 0
    .return (result)
.end


=item chr(i)

Return a string of one character whose ASCII code is the integer i.
For example, chr(97) returns the string 'a'. This is the inverse of ord().
The argument must be in the range [0..255], inclusive; ValueError will
be raised if i is outside that range.

=cut

.sub 'chr'
    .param int i
    if i < 0 goto valueerror
    if i > 255 goto valueerror
    .local pmc result
    result = new [ 'str' ]
    $S0 = chr i
    result = $S0
    .return (result)

  valueerror:
    $P0 = new 'Exception'
    $P0 = "ValueError"
    throw $P0
.end



=item classmethod(function)

Return a class method for function.
A class method receives the class as implicit first argument,
just like an instance method receives the instance.
To declare a class method, use this idiom:

    class C:
        @classmethod
        def f(cls, arg1, arg2, ...): ...

The @classmethod form is a function decorator - see the description
of function definitions in chapter 7 of the Python Reference Manual for details.

It can be called either on the class (such as C.f()) or on an
instance (such as C().f()). The instance is ignored except for its class.
If a class method is called for a derived class, the derived class object
is passed as the implied first argument.

Class methods are different than C++ or Java static methods. If you want
those, see staticmethod() in this section.

For more information on class methods, consult the documentation on the
standard type hierarchy in chapter 3 of the Python Reference Manual
(at the bottom). New in version 2.2. Changed in version 2.4: Function
decorator syntax added.

=cut

.sub 'classmethod'
    .param pmc function

    $P0 = new 'Exception'
    $P0 = 'NotImplementedError'      # XXX
    throw $P0
.end


=item compile(string, filename, kind[, flags[, dont_inherit]])

Compile the string into a code object. Code objects can be executed by an exec
statement or evaluated by a call to eval(). The filename argument should give
the file from which the code was read; pass some recognizable value if it
wasn't read from a file ('<string>' is commonly used). The kind argument
specifies what kind of code must be compiled; it can be 'exec' if string
consists of a sequence of statements, 'eval' if it consists of a single
expression, or 'single' if it consists of a single interactive statement
(in the latter case, expression statements that evaluate to something else
than None will be printed).

When compiling multi-line statements, two caveats apply: line endings must be
represented by a single newline character ('\n'), and the input must be
terminated by at least one newline character. If line endings are represented
by '\r\n', use the string replace() method to change them into '\n'.

The optional arguments flags and dont_inherit (which are new in Python 2.2)
control which future statements (see PEP 236) affect the compilation of string.
If neither is present (or both are zero) the code is compiled with those future
statements that are in effect in the code that is calling compile. If the flags
argument is given and dont_inherit is not (or is zero) then the future
statements specified by the flags argument are used in addition to those that
would be used anyway. If dont_inherit is a non-zero integer then the flags
argument is it - the future statements in effect around the call to compile
are ignored.

Future statements are specified by bits which can be bitwise or-ed together to
specify multiple statements. The bitfield required to specify a given feature
can be found as the compiler_flag attribute on the _Feature instance in the
__future__ module.

=cut

.sub 'compile'
    .param pmc str
    .param pmc filename
    .param pmc kind
    .param pmc flags :optional
    .param pmc dont_inherit :optional

    $P0 = new 'Exception'
    $P0 = 'NotImplementedError'      # XXX
    throw $P0
.end

=item complex([real[, imag]])

Create a complex number with the value real + imag*j or convert a string or
number to a complex number. If the first parameter is a string, it will be
interpreted as a complex number and the function must be called without a
second parameter. The second parameter can never be a string. Each argument
may be any numeric type (including complex). If imag is omitted, it defaults
to zero and the function serves as a numeric conversion function like int(),
long() and float(). If both arguments are omitted, returns 0j.

=cut

.sub 'complex'
    .param pmc real :optional
    .param pmc imag :optional

    $P0 = new 'Exception'
    $P0 = 'NotImplementedError'      # XXX
    throw $P0
.end


=item delattr(object, name)

This is a relative of setattr(). The arguments are an object and a string.
The string must be the name of one of the object's attributes. The function
deletes the named attribute, provided the object allows it. For example,
delattr(x, 'foobar') is equivalent to del x.foobar.

=cut

.sub 'delattr'
    .param pmc obj
    .param pmc name

    $P0 = new 'Exception'
    $P0 = 'NotImplementedError'      # XXX
    throw $P0
.end


=item dict([mapping-or-sequence])

Return a new dictionary initialized from an optional positional argument or
from a set of keyword arguments. If no arguments are given, return a new empty
dictionary. If the positional argument is a mapping object, return a dictionary
mapping the same keys to the same values as does the mapping object. Otherwise
the positional argument must be a sequence, a container that supports iteration,
or an iterator object. The elements of the argument must each also be of one of
those kinds, and each must in turn contain exactly two objects. The first is
used as a key in the new dictionary, and the second as the key's value. If a
given key is seen more than once, the last value associated with it is retained
in the new dictionary.

If keyword arguments are given, the keywords themselves with their associated
values are added as items to the dictionary. If a key is specified both in the
positional argument and as a keyword argument, the value associated with the
keyword is retained in the dictionary. For example, these all return a dictionary
equal to {"one": 2, "two": 3}:

        * dict({'one': 2, 'two': 3})
        * dict({'one': 2, 'two': 3}.items())
        * dict({'one': 2, 'two': 3}.iteritems())
        * dict(zip(('one', 'two'), (2, 3)))
        * dict([['two', 3], ['one', 2]])
        * dict(one=2, two=3)
        * dict([(['one', 'two'][i-2], i) for i in (2, 3)])

New in version 2.2. Changed in version 2.3: Support for building a dictionary
from keyword arguments added.

=cut


.sub 'dict' :multi()
    $P0 = new 'dict'
    .return ($P0)
.end

.sub 'dict' :multi('dict')
    .param pmc dict
    $P0 = clone dict
    .return ($P0)
.end

.sub 'dict' :multi('list')
    .param pmc sequence

    .local pmc result, iterator

    result = new 'dict'
    iterator = iter sequence

loop:
    unless iterator goto done
    
    $P0 = shift iterator
    $I0 = 'len'($P0)
    unless $I0 == 2 goto type_error
    # unpack the 2 element tuple
    $P1 = $P0.'shift'()
    $P2 = $P0.'shift'()
    
    # put entry in dict
    result[$P1] = $P2

    goto loop

done:
    .return (result)

type_error:
    $P0 = new 'Exception'
    $P0 = 'TypeError'
    throw $P0
.end


=item dir([object])

Without arguments, return the list of names in the current local symbol table.
With an argument, attempts to return a list of valid attributes for that object.
This information is gleaned from the object's __dict__ attribute, if defined,
and from the class or type object. The list is not necessarily complete. If the
object is a module object, the list contains the names of the module's attributes.
If the object is a type or class object, the list contains the names of its
attributes, and recursively of the attributes of its bases. Otherwise, the list
contains the object's attributes' names, the names of its class's attributes,
and recursively of the attributes of its class's base classes. The resulting
list is sorted alphabetically. For example:

    >>> import struct
    >>> dir()
    ['__builtins__', '__doc__', '__name__', 'struct']
    >>> dir(struct)
    ['__doc__', '__name__', 'calcsize', 'error', 'pack', 'unpack']

Note: Because dir() is supplied primarily as a convenience for use at an
interactive prompt, it tries to supply an interesting set of names more than it
tries to supply a rigorously or consistently defined set of names, and its
detailed behavior may change across releases.

=cut

.sub 'dir'
    .param pmc obj :optional

    $P0 = new 'Exception'
    $P0 = 'NotImplementedError'      # XXX
    throw $P0
.end

=item divmod(a, b)

Take two (non complex) numbers as arguments and return a pair of numbers
consisting of their quotient and remainder when using long division.
With mixed operand types, the rules for binary arithmetic operators apply.
For plain and long integers, the result is the same as (a // b, a % b).
For floating point numbers the result is (q, a % b), where q is usually
math.floor(a / b) but may be 1 less than that. In any case q * b + a % b
is very close to a, if a % b is non-zero it has the same sign as b, and
0 <= abs(a % b) < abs(b).

Changed in version 2.3: Using divmod() with complex numbers is deprecated.

=cut

.sub 'divmod'
    .param pmc a
    .param pmc b

    $P0 = new 'Exception'
    $P0 = 'NotImplementedError'      # XXX
    throw $P0
.end


=item enumerate(iterable)

Return an enumerate object. iterable must be a sequence, an iterator, or
some other object which supports iteration. The next() method of the
iterator returned by enumerate() returns a tuple containing a count
(from zero) and the corresponding value obtained from iterating over
iterable. enumerate() is useful for obtaining an indexed series:
(0, seq[0]), (1, seq[1]), (2, seq[2]), .... New in version 2.3.

=cut

.sub 'enumerate'
    .param pmc iterable

    $P0 = new 'Exception'
    $P0 = 'NotImplementedError'      # XXX
    throw $P0
.end


=item eval(expression[, globals[, locals]])

The arguments are a string and optional globals and locals. If provided,
globals must be a dictionary. If provided, locals can be any mapping object.
Changed in version 2.4: formerly locals was required to be a dictionary.

The expression argument is parsed and evaluated as a Python expression
(technically speaking, a condition list) using the globals and locals
dictionaries as global and local name space. If the globals dictionary
is present and lacks '__builtins__', the current globals are copied into
globals before expression is parsed. This means that expression normally
has full access to the standard __builtin__ module and restricted
environments are propagated. If the locals dictionary is omitted it
defaults to the globals dictionary. If both dictionaries are omitted,
the expression is executed in the environment where eval is called.
The return value is the result of the evaluated expression.
Syntax errors are reported as exceptions. Example:

    >>> x = 1
    >>> print eval('x+1')
    2

This function can also be used to execute arbitrary code objects
(such as those created by compile()). In this case pass a code object
instead of a string. The code object must have been compiled passing
'eval' as the kind argument.

Hints: dynamic execution of statements is supported by the exec statement.
Execution of statements from a file is supported by the execfile() function.
The globals() and locals() functions returns the current global and local
dictionary, respectively, which may be useful to pass around for use by
eval() or execfile().

=cut

.sub 'eval'
    .param pmc expr
    .param pmc globals :optional
    .param pmc locals  :optional

    $P0 = new 'Exception'
    $P0 = 'NotImplementedError'      # XXX
    throw $P0
.end

=item file(filename[, mode[, bufsize]])

Constructor function for the file type, described further in section 3.9,
``File Objects''. The constructor's arguments are the same as those of
the open() built-in function described below.

When opening a file, it's preferable to use open() instead of invoking this
constructor directly. file is more suited to type testing (for example,
writing "isinstance(f, file)").

New in version 2.2.

=cut

.sub 'file'
    .param pmc filename
    .param pmc mode    :optional
    .param pmc bufsize :optional

    $P0 = new 'Exception'
    $P0 = 'NotImplementedError'      # XXX
    throw $P0
.end


=item filter(function, list)

Construct a list from those elements of list for which function returns true.
list may be either a sequence, a container which supports iteration, or an
iterator, If list is a string or a tuple, the result also has that type;
otherwise it is always a list. If function is None, the identity function
is assumed, that is, all elements of list that are false are removed.

Note that filter(function, list) is equivalent to [item for item in list if
function(item)] if function is not None and [item for item in list if item]
if function is None.

=cut

.sub 'filter'
    .param pmc function
    .param pmc list

    $P0 = new 'Exception'
    $P0 = 'NotImplementedError'      # XXX
    throw $P0
.end


=item float([x])

Convert a string or a number to floating point. If the argument is a string,
it must contain a possibly signed decimal or floating point number, possibly
embedded in whitespace. Otherwise, the argument may be a plain or long integer
or a floating point number, and a floating point number with the same value
(within Python's floating point precision) is returned. If no argument is
given, returns 0.0.

Note: When passing in a string, values for NaN and Infinity may be returned,
depending on the underlying C library. The specific set of strings accepted
which cause these values to be returned depends entirely on the C library
and is known to vary.

=cut

.sub 'float'
    .param pmc x :optional

    $P0 = new 'Exception'
    $P0 = 'NotImplementedError'      # XXX
    throw $P0
.end


=item frozenset([iterable])

Return a frozenset object whose elements are taken from iterable. Frozensets
are sets that have no update methods but can be hashed and used as members of
other sets or as dictionary keys. The elements of a frozenset must be immutable
themselves. To represent sets of sets, the inner sets should also be frozenset
objects. If iterable is not specified, returns a new empty set, frozenset([]).
New in version 2.4.

=cut

.sub 'frozenset'
    .param pmc iterable :optional

    $P0 = new 'Exception'
    $P0 = 'NotImplementedError'      # XXX
    throw $P0
.end


=item getattr(object, name[, default])

Return the value of the named attributed of object. name must be a string.
If the string is the name of one of the object's attributes, the result is
the value of that attribute. For example, getattr(x, 'foobar') is equivalent
to x.foobar. If the named attribute does not exist, default is returned if
provided, otherwise AttributeError is raised.

=cut

.sub 'getattr'
    .param pmc obj
    .param pmc name
    .param pmc default :optional

    $P0 = new 'Exception'
    $P0 = 'NotImplementedError'      # XXX
    throw $P0
.end

=item globals()

Return a dictionary representing the current global symbol table. This is
always the dictionary of the current module (inside a function or method,
this is the module where it is defined, not the module from which it is called).

=cut

.sub 'globals'
    $P0 = new 'Exception'
    $P0 = 'NotImplementedError'      # XXX
    throw $P0
.end

=item hasattr(object, name)

The arguments are an object and a string. The result is True if the string
is the name of one of the object's attributes, False if not.
(This is implemented by calling getattr(object, name) and seeing whether
it raises an exception or not.)

=cut

.sub 'hasattr'
    .param pmc obj
    .param pmc name

    $P0 = new 'Exception'
    $P0 = 'NotImplementedError'      # XXX
    throw $P0
.end


=item hash(object)

Return the hash value of the object (if it has one). Hash values are integers.
They are used to quickly compare dictionary keys during a dictionary lookup.
Numeric values that compare equal have the same hash value (even if they are
of different types, as is the case for 1 and 1.0).

=cut

.sub 'hash'
    .param pmc obj

    $P0 = new 'Exception'
    $P0 = 'NotImplementedError'      # XXX
    throw $P0
.end



=item help([object])

Invoke the built-in help system. (This function is intended for interactive use.)
If no argument is given, the interactive help system starts on the interpreter
console. If the argument is a string, then the string is looked up as the name
of a module, function, class, method, keyword, or documentation topic, and a
help page is printed on the console. If the argument is any other kind of object,
a help page on the object is generated. New in version 2.2.

=cut

.sub 'help'
    .param pmc obj :optional

    $P0 = new 'Exception'
    $P0 = 'NotImplementedError'      # XXX
    throw $P0
.end

=item hex(x)

Convert an integer number (of any size) to a hexadecimal string. The result
is a valid Python expression. Changed in version 2.4: Formerly only returned an
unsigned literal.

=cut

.sub 'hex'
    .param pmc x

    .local int digit
    .local string digit_str, result, prefix
    
    $I0 = x
    
    unless $I0 == 0 goto is_nonzero
    .return ('0x0')

is_nonzero:
    result = ''
    unless $I0 < 0 goto is_positive
    # is negative
    prefix = '-0x'
    $I0 = -$I0
    goto loop

is_positive:
    prefix = '0x'

loop:
    digit = $I0 & 0xf
    $I0 >>= 4
    
    digit_str = substr '0123456789abcdef', digit, 1
    result = digit_str . result
    if $I0 > 0 goto loop

    result = prefix . result
    .return (result)
.end


=item id(object)

Return the ``identity'' of an object. This is an integer (or long integer)
which is guaranteed to be unique and constant for this object during its
lifetime. Two objects with non-overlapping lifetimes may have the same id()
value. (Implementation note: this is the address of the object.)

=cut

.sub 'id'
    .param pmc obj

    $P0 = new 'Exception'
    $P0 = 'NotImplementedError'      # XXX
    throw $P0
.end


=item input([prompt])

Equivalent to eval(raw_input(prompt)). Warning: This function is not safe
from user errors! It expects a valid Python expression as input; if the
input is not syntactically valid, a SyntaxError will be raised. Other
exceptions may be raised if there is an error during evaluation.
(On the other hand, sometimes this is exactly what you need when writing
a quick script for expert use.)

If the readline module was loaded, then input() will use it to provide
elaborate line editing and history features.

Consider using the raw_input() function for general input from users.

=cut

.sub 'input'
    .param pmc prompt :optional

    $P0 = new 'Exception'
    $P0 = 'NotImplementedError'      # XXX
    throw $P0
.end


=item int([x[, radix]])

Convert a string or number to a plain integer. If the argument is a
string, it must contain a possibly signed decimal number representable
as a Python integer, possibly embedded in whitespace. The radix parameter
gives the base for the conversion and may be any integer in the range
[2, 36], or zero. If radix is zero, the proper radix is guessed based
on the contents of string; the interpretation is the same as for integer
literals. If radix is specified and x is not a string, TypeError is raised.
Otherwise, the argument may be a plain or long integer or a floating point
number. Conversion of floating point numbers to integers truncates
(towards zero). If the argument is outside the integer range a long object
will be returned instead. If no arguments are given, returns 0.

=cut

.sub 'int'
    .param pmc x :optional
    .param pmc radix :optional

    $P0 = new 'Exception'
    $P0 = 'NotImplementedError'      # XXX
    throw $P0
.end


=item isinstance(object, classinfo)

Return true if the object argument is an instance of the classinfo argument,
or of a (direct or indirect) subclass thereof. Also return true if classinfo
is a type object and object is an object of that type. If object is not a class
instance or an object of the given type, the function always returns false.
If classinfo is neither a class object nor a type object, it may be a tuple of
class or type objects, or may recursively contain other such tuples
(other sequence types are not accepted). If classinfo is not a class, type,
or tuple of classes, types, and such tuples, a TypeError exception is raised.
Changed in version 2.2: Support for a tuple of type information was added.

=cut

.sub 'isinstance'
    .param pmc obj
    .param pmc classinfo
    
    $I0 = isa obj, classinfo
    .return ($I0)
.end


=item issubclass(class, classinfo)

Return true if class is a subclass (direct or indirect) of classinfo. A class
is considered a subclass of itself. classinfo may be a tuple of class objects,
in which case every entry in classinfo will be checked. In any other case, a
TypeError exception is raised. Changed in version 2.3: Support for a tuple of
type information was added.

=cut

.sub 'issubclass'
    .param pmc class
    .param pmc classinfo

    $P0 = new 'Exception'
    $P0 = 'NotImplementedError'      # XXX
    throw $P0
.end


=item iter(o[, sentinel])

Return an iterator object. The first argument is interpreted very differently
depending on the presence of the second argument. Without a second argument,
o must be a collection object which supports the iteration protocol
(the __iter__() method), or it must support the sequence protocol
(the __getitem__() method with integer arguments starting at 0).
If it does not support either of those protocols, TypeError is raised.
If the second argument, sentinel, is given, then o must be a callable object.
The iterator created in this case will call o with no arguments for each call
to its next() method; if the value returned is equal to sentinel, StopIteration
will be raised, otherwise the value will be returned. New in version 2.2.

=cut

.sub 'iter'
    .param pmc o
    .param pmc sentinel :optional

    $P0 = new 'Exception'
    $P0 = 'NotImplementedError'      # XXX
    throw $P0
.end

=item len(s)

Return the length (the number of items) of an object. The argument may be a
sequence (string, tuple or list) or a mapping (dictionary).

=cut

.sub 'len'
    .param pmc s
    $I0 = elements s
    $P0 = new 'Integer'
    $P0 = $I0
    .return ($P0)
.end


=item locals()

Update and return a dictionary representing the current local symbol table.
Warning: The contents of this dictionary should not be modified; changes may not
affect the values of local variables used by the interpreter.

=cut

.sub 'locals'
    $P0 = new 'Exception'
    $P0 = 'NotImplementedError'      # XXX
    throw $P0
.end

=item long([x[, radix]])

Convert a string or number to a long integer. If the argument is a string,
it must contain a possibly signed number of arbitrary size, possibly embedded
in whitespace. The radix argument is interpreted in the same way as for int(),
and may only be given when x is a string. Otherwise, the argument may be a
plain or long integer or a floating point number, and a long integer with the
same value is returned. Conversion of floating point numbers to integers
truncates (towards zero). If no arguments are given, returns 0L.

=cut

.sub 'long'
    .param pmc x     :optional
    .param pmc radix :optional

    $P0 = new 'Exception'
    $P0 = 'NotImplementedError'      # XXX
    throw $P0
.end

=item map(function, list, ...)

Apply function to every item of list and return a list of the results. If
additional list arguments are passed, function must take that many arguments
and is applied to the items of all lists in parallel; if a list is shorter
than another it is assumed to be extended with None items. If function is
None, the identity function is assumed; if there are multiple list arguments,
map() returns a list consisting of tuples containing the corresponding items
from all lists (a kind of transpose operation). The list arguments may be any
kind of sequence; the result is always a list.

=cut

.sub 'map'
    .param pmc function
    .param pmc list
    .param pmc args :slurpy

    # XXX allow function to be None
    # XXX return an iterator rather than a list (as per Python 3.0)

    .local int num_lists
    .local pmc result, list_array, iter_array, func_params

    list_array = args
    unshift list_array, list
    num_lists = elements list_array

    # Build list of iterators, one for each list
    iter_array = new 'FixedPMCArray'
    iter_array = num_lists
    $I0 = 0
make_iter_array_loop:
    $P0 = list_array[$I0]
    $P1 = iter $P0
    iter_array[$I0] = $P1
    inc $I0
    unless $I0 >= num_lists goto make_iter_array_loop


    # Now iterate over all the lists together
    result = new [ 'list' ]
loop:
    func_params = new 'FixedPMCArray'
    func_params = num_lists
    
    # get one element from each iterator
    $I0 = 0
make_func_params_loop:
    $P0 = iter_array[$I0]
    # XXX extra None's should be added if any list is shorter than the others
    unless $P0 goto done      # stop when done iterating over any of the lists    
    $P1 = shift $P0
    func_params[$I0] = $P1
    inc $I0
    unless $I0 >= num_lists goto make_func_params_loop

    # call function and add function result to result list
    $P0 = function(func_params :flat)
    push result, $P0
    goto loop
    
done:
    .return (result)
.end


=item max(s[, args...][key])

With a single argument s, return the largest item of a non-empty sequence
(such as a string, tuple or list). With more than one argument, return the
largest of the arguments.

The optional key argument specifies a one-argument ordering function like
that used for list.sort(). The key argument, if supplied, must be in keyword
form (for example, "max(a,b,c,key=func)"). Changed in version 2.5: Added
support for the optional key argument.

=cut

.sub 'max'
    .param pmc s
    .param pmc args :slurpy
	#.param pmc key :named :optional        XXX

	.local pmc iterator, result
	
	$I0 = elements args
	if $I0 > 0 goto multiple_args
	
	iterator = iter s
	result = shift iterator
	goto loop_check

multiple_args:
	iterator = iter args
	result = s

loop_check:
	.local pmc i
	unless iterator goto loop_end
	i = shift iterator
	unless i > result goto loop_check
	set result, i
	goto loop_check

loop_end:
	.return (result)
.end


=item min(s[, args...][key])

With a single argument s, return the smallest item of a non-empty sequence
(such as a string, tuple or list). With more than one argument, return the
smallest of the arguments.

The optional key argument specifies a one-argument ordering function like
that used for list.sort(). The key argument, if supplied, must be in keyword
form (for example, "min(a,b,c,key=func)"). Changed in version 2.5: Added
support for the optional key argument.

=cut

.sub 'min'
    .param pmc s
    .param pmc args :slurpy
	#.param pmc key :named :optional        XXX

	.local pmc iterator, result

	$I0 = elements args
	if $I0 > 0 goto multiple_args

	iterator = iter s
	result = shift iterator
	goto loop_check

multiple_args:
	iterator = iter args
	result = s

loop_check:
	.local pmc i
	unless iterator goto loop_end
	i = shift iterator
	unless i < result goto loop_check
	set result, i
	goto loop_check

loop_end:
	.return (result)
.end


=item object()

Return a new featureless object. object is a base for all new style classes.
It has the methods that are common to all instances of new style classes.
New in version 2.2.

Changed in version 2.3: This function does not accept any arguments.
Formerly, it accepted arguments but ignored them.

=cut

.sub 'object'
    $P0 = new 'Exception'
    $P0 = 'NotImplementedError'      # XXX
    throw $P0
.end

=item oct(x)

Convert an integer number (of any size) to an octal string. The result is a
valid Python expression. Changed in version 2.4: Formerly only returned an
unsigned literal.

=cut

.sub 'oct'
    .param pmc x

    $P0 = new 'Exception'
    $P0 = 'NotImplementedError'      # XXX
    throw $P0
.end


=item open(filename[, mode[, bufsize]])

Open a file, returning an object of the file type described in section 3.9,
``File Objects''. If the file cannot be opened, IOError is raised. When
opening a file, it's preferable to use open() instead of invoking the file
constructor directly.

The first two arguments are the same as for stdio's fopen(): filename is the
file name to be opened, and mode is a string indicating how the file is to be opened.

The most commonly-used values of mode are 'r' for reading, 'w' for writing
(truncating the file if it already exists), and 'a' for appending
(which on some Unix systems means that all writes append to the end of the
file regardless of the current seek position). If mode is omitted, it
defaults to 'r'. When opening a binary file, you should append 'b' to the
mode value to open the file in binary mode, which will improve portability.
(Appending 'b' is useful even on systems that don't treat binary and text
files differently, where it serves as documentation.) See below for more
possible values of mode.

The optional bufsize argument specifies the file's desired buffer size: 0
means unbuffered, 1 means line buffered, any other positive value means use
a buffer of (approximately) that size. A negative bufsize means to use the
system default, which is usually line buffered for tty devices and fully
buffered for other files. If omitted, the system default is used.2.3

Modes 'r+', 'w+' and 'a+' open the file for updating (note that 'w+'
truncates the file). Append 'b' to the mode to open the file in binary mode,
on systems that differentiate between binary and text files; on systems that
don't have this distinction, adding the 'b' has no effect.

In addition to the standard fopen() values mode may be 'U' or 'rU'. Python is
usually built with universal newline support; supplying 'U' opens the file as
a text file, but lines may be terminated by any of the following: the
Unix end-of-line convention '\n', the Macintosh convention '\r', or the Windows
convention '\r\n'. All of these external representations are seen as '\n' by
the Python program. If Python is built without universal newline support a mode
with 'U' is the same as normal text mode. Note that file objects so opened also
have an attribute called newlines which has a value of None (if no newlines
have yet been seen), '\n', '\r', '\r\n', or a tuple containing all the newline
types seen.

Python enforces that the mode, after stripping 'U', begins with 'r', 'w' or 'a'.

Changed in version 2.5: Restriction on first letter of mode string introduced.

=cut

.sub 'open'
    .param pmc filename
    .param pmc mode :optional
    .param pmc bufsize :optional

    $P0 = new 'Exception'
    $P0 = 'NotImplementedError'      # XXX
    throw $P0
.end

=item ord(c)

Given a string of length one, return an integer representing the Unicode code
point of the character when the argument is a unicode object, or the value of
the byte when the argument is an 8-bit string. For example, ord('a') returns
the integer 97, ord(u'\u2020') returns 8224. This is the inverse of chr() for
8-bit strings and of unichr() for unicode objects. If a unicode argument is
given and Python was built with UCS2 Unicode, then the character's code point
must be in the range [0..65535] inclusive; otherwise the string length is two,
and a TypeError will be raised.

=cut

.sub 'ord'
    .param pmc c
	
	$S0 = c
	$I0 = length $S0
	if $I0 != 1 goto typeerror 
	$I1 = ord $S0
	
    .return ($I1)

  typeerror:
    $P0 = new 'Exception'
    $P0 = "TypeError"
    throw $P0

.end


=item pow(x, y[, z])

Return x to the power y; if z is present, return x to the power y, modulo z
(computed more efficiently than pow(x, y) % z). The two-argument form
pow(x, y) is equivalent to using the power operator: x**y.

The arguments must have numeric types. With mixed operand types, the coercion
rules for binary arithmetic operators apply. For int and long int operands,
the result has the same type as the operands (after coercion) unless the
second argument is negative; in that case, all arguments are converted to
float and a float result is delivered. For example, 10**2 returns 100, but
10**-2 returns 0.01. (This last feature was added in Python 2.2.
In Python 2.1 and before, if both arguments were of integer types and the
second argument was negative, an exception was raised.) If the second
argument is negative, the third argument must be omitted. If z is present,
x and y must be of integer types, and y must be non-negative.
(This restriction was added in Python 2.2. In Python 2.1 and before,
floating 3-argument pow() returned platform-dependent results depending on
floating-point rounding accidents.)

=cut

.sub 'pow'
    .param pmc x
    .param pmc y
    .param pmc z :optional
    .param int has_z :opt_flag

	if has_z goto when_has_z
    
	$P0 = pow x, y
	.return ($P0)

when_has_z:

    # use a fast exponentiation method
    .local int X, Y, Z
    X = x
    Y = y
    Z = z
    
    $I0 = 1
    loop:
        unless Y > 0 goto endloop
        $I1 = band Y, 1
        bitcheck:
            unless $I1 == 1 goto endbitcheck
            $I1 = $I0 * X
            $I0 = mod $I1, Z
        endbitcheck:
        
        Y = shr Y, 1
        $I1 = X * X
        X = mod $I1, Z
        
        goto loop
    endloop:

	.return ($I0)
.end



=item property([fget[, fset[, fdel[, doc]]]])

Return a property attribute for new-style classes (classes that derive
from object).

fget is a function for getting an attribute value, likewise fset is a function
for setting, and fdel a function for del'ing, an attribute. Typical use is to
define a managed attribute x:

  class C(object):
    def __init__(self): self.__x = None
    def getx(self): return self._x
    def setx(self, value): self._x = value
    def delx(self): del self._x
    x = property(getx, setx, delx, "I'm the 'x' property.")

If given, doc will be the docstring of the property attribute. Otherwise, the
property will copy fget's docstring (if it exists). This makes it possible to
create read-only properties easily using property() as a decorator:

  class Parrot(object):
    def __init__(self):
        self._voltage = 100000

    @property
    def voltage(self):
        """Get the current voltage."""
        return self._voltage

turns the voltage() method into a ``getter'' for a read-only attribute with
the same name.

New in version 2.2. Changed in version 2.5: Use fget's docstring if no doc given.

=cut

.sub 'property'
    .param pmc fget :optional
    .param pmc fset :optional
    .param pmc fdel :optional
    .param pmc doc :optional

    $P0 = new 'Exception'
    $P0 = 'NotImplementedError'      # XXX
    throw $P0
.end


=item range([start,] stop[, step])

This is a versatile function to create lists containing arithmetic
progressions. It is most often used in for loops. The arguments must be plain
integers. If the step argument is omitted, it defaults to 1. If the start
argument is omitted, it defaults to 0. The full form returns a list of plain
integers [start, start + step, start + 2 * step, ...]. If step is positive,
the last element is the largest start + i * step less than stop; if step is
negative, the last element is the smallest start + i * step greater than stop.
step must not be zero (or else ValueError is raised). Example:

    >>> range(10)
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    >>> range(1, 11)
    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    >>> range(0, 30, 5)
    [0, 5, 10, 15, 20, 25]
    >>> range(0, 10, 3)
    [0, 3, 6, 9]
    >>> range(0, -10, -1)
    [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
    >>> range(0)
    []
    >>> range(1, 0)
    []

=cut

.sub 'range'
     .param pmc stop
      # XXX start, step

     .local int stopn
     .local pmc lst
     .local pmc tmp

     $I0 = 0
     lst = new [ 'list' ]
     stopn = stop
loop:
     unless $I0 < stopn goto done
     tmp = new 'Integer'
     tmp = $I0
     push lst, tmp

     inc $I0
     goto loop
done:
     .return (lst)
.end


=item repr(object)

Return a string containing a printable representation of an object. This is
the same value yielded by conversions (reverse quotes). It is sometimes useful
to be able to access this operation as an ordinary function. For many types,
this function makes an attempt to return a string that would yield an object
with the same value when passed to eval().

=cut

.sub 'repr'
    .param pmc obj
    .local string result

    $I0 = can obj, '__repr__'
    unless $I0 goto no_repr
    .tailcall obj.'__repr__'()

no_repr:
    result = obj
    .return (result)
.end

=item reversed(seq)

Return a reverse iterator. seq must be an object which supports the sequence
protocol (the __len__() method and the __getitem__() method with integer
arguments starting at 0). New in version 2.4.

=cut

.sub 'reversed'
    .param pmc seq

    $P0 = new 'Exception'
    $P0 = 'NotImplementedError'      # XXX
    throw $P0
.end

=item round(x[, n])

Return the floating point value x rounded to n digits after the decimal point.
If n is omitted, it defaults to zero. The result is a floating point number.
Values are rounded to the closest multiple of 10 to the power minus n; if two
multiples are equally close, rounding is done away from 0 (so. for example,
round(0.5) is 1.0 and round(-0.5) is -1.0).

=cut

.sub 'round'
    .param pmc x
    .param pmc n :optional

    $P0 = new 'Exception'
    $P0 = 'NotImplementedError'      # XXX
    throw $P0
.end

=item set([iterable])

Return a set whose elements are taken from iterable. The elements must be
immutable. To represent sets of sets, the inner sets should be frozenset
objects. If iterable is not specified, returns a new empty set, set([]).
New in version 2.4.

=cut

.sub 'set'
    .param pmc iterable :optional

    $P0 = new 'Exception'
    $P0 = 'NotImplementedError'      # XXX
    throw $P0
.end

=item setattr(object, name, value)

This is the counterpart of getattr(). The arguments are an object, a
string and an arbitrary value. The string may name an existing attribute
or a new attribute. The function assigns the value to the attribute, provided
the object allows it. For example, setattr(x, 'foobar', 123) is
equivalent to x.foobar = 123.

=cut

.sub 'setattr'
    .param pmc obj
    .param pmc name
    .param pmc value

    $P0 = new 'Exception'
    $P0 = 'NotImplementedError'      # XXX
    throw $P0
.end

=item slice([start,] stop[, step])

Return a slice object representing the set of indices specified by
range(start, stop, step). The start and step arguments default to None.
Slice objects have read-only data attributes start, stop and step which
merely return the argument values (or their default). They have no other
explicit functionality; however they are used by Numerical Python and
other third party extensions. Slice objects are also generated when
extended indexing syntax is used. For example: "a[start:stop:step]"
or "a[start:stop, i]".

=cut

.sub 'slice'
    .param pmc start #:optional?
    .param pmc stop
    .param pmc step :optional

    $P0 = new 'Exception'
    $P0 = 'NotImplementedError'      # XXX
    throw $P0
.end


=item sorted(iterable[, cmp[, key[, reverse]]])

Return a new sorted list from the items in iterable.

The optional arguments cmp, key, and reverse have the same meaning as those
for the list.sort() method (described in section 3.6.4).

cmp specifies a custom comparison function of two arguments (iterable elements)
which should return a negative, zero or positive number depending on whether
the first argument is considered smaller than, equal to, or larger than the
second argument: "cmp=lambda x,y: cmp(x.lower(), y.lower())"

key specifies a function of one argument that is used to extract a comparison
key from each list element: "key=str.lower"

reverse is a boolean value. If set to True, then the list elements are sorted
as if each comparison were reversed.

In general, the key and reverse conversion processes are much faster than
specifying an equivalent cmp function. This is because cmp is called multiple
times for each list element while key and reverse touch each element only once.

New in version 2.4.

=cut

.sub 'sorted'
    .param pmc iterable
    .param pmc cmp :optional
    .param pmc key :optional
    .param pmc reverse :optional

    $P0 = new 'Exception'
    $P0 = 'NotImplementedError'      # XXX
    throw $P0
.end


=item staticmethod(function)

Return a static method for function.

A static method does not receive an implicit first argument. To declare a
static method, use this idiom:

    class C:
        @staticmethod
        def f(arg1, arg2, ...): ...

The @staticmethod form is a function decorator - see the description of
function definitions in chapter 7 of the Python Reference Manual for details.

It can be called either on the class (such as C.f()) or on an instance
(such as C().f()). The instance is ignored except for its class.

Static methods in Python are similar to those found in Java or C++.
For a more advanced concept, see classmethod() in this section.

For more information on static methods, consult the documentation on the
standard type hierarchy in chapter 3 of the Python Reference Manual
(at the bottom). New in version 2.2. Changed in version 2.4:
Function decorator syntax added.

=cut

.sub 'staticmethod'
    .param pmc function

    $P0 = new 'Exception'
    $P0 = 'NotImplementedError'      # XXX
    throw $P0
.end


=item sum(sequence[, start])

Sums start and the items of a sequence, from left to right, and returns the
total. start defaults to 0. The sequence's items are normally numbers, and are
not allowed to be strings. The fast, correct way to concatenate sequence of
strings is by calling ''.join(sequence). Note that sum(range(n), m) is
equivalent to reduce(operator.add, range(n), m) New in version 2.3.

=cut

.sub 'sum'
    .param pmc sequence
    .param pmc start :optional
	.param int has_start :opt_flag
	
	.local num result
	unless has_start goto no_start
	result = start
	goto setup_loop
no_start:
	result = 0

setup_loop:
    .local pmc iterator
    iterator = iter sequence

    .local int i
loop_check:
    unless iterator goto loop_end
    i = shift iterator
	result += i
    goto loop_check

loop_end:
    .return (result)
.end

=item super(type[, object-or-type])

Return the superclass of type. If the second argument is omitted the super
object returned is unbound. If the second argument is an object,
isinstance(obj, type) must be true. If the second argument is a type,
issubclass(type2, type) must be true. super() only works for new-style classes.

A typical use for calling a cooperative superclass method is:

    class C(B):
        def meth(self, arg):
            super(C, self).meth(arg)

Note that super is implemented as part of the binding process for explicit
dotted attribute lookups such as "super(C, self).__getitem__(name)".
Accordingly, super is undefined for implicit lookups using statements or
operators such as "super(C, self)[name]". New in version 2.2.

=cut

.sub 'super'
    .param pmc type
    .param pmc obj_or_type :optional

    $P0 = new 'Exception'
    $P0 = 'NotImplementedError'      # XXX
    throw $P0
.end


=item tuple([sequence])

Return a tuple whose items are the same and in the same order as sequence's
items. sequence may be a sequence, a container that supports iteration, or
an iterator object. If sequence is already a tuple, it is returned unchanged.
For instance, tuple('abc') returns ('a', 'b', 'c') and tuple([1, 2, 3])
returns (1, 2, 3). If no argument is given, returns a new empty tuple, ().

=cut

.sub 'tuple'
    .param pmc sequence :optional

    $P0 = new 'Exception'
    $P0 = 'NotImplementedError'      # XXX
    throw $P0
.end


=item type(object)

Return the type of an object. The return value is a type object.
The isinstance() built-in function is recommended for testing the
type of an object.

With three arguments, type functions as a constructor as detailed below.

=cut

.sub 'type' :multi(pmc)
    .param pmc obj
    $P0 = typeof obj
    .return ($P0)
.end


=item type(name, bases, dict)

Return a new type object. This is essentially a dynamic form of the class
statement. The name string is the class name and becomes the __name__
attribute; the bases tuple itemizes the base classes and becomes the
__bases__ attribute; and the dict dictionary is the namespace containing
definitions for class body and becomes the __dict__ attribute.
For example, the following two statements create identical type objects:

      >>> class X(object):
      ...     a = 1
      ...
      >>> X = type('X', (object,), dict(a=1))

New in version 2.2.

=cut

.sub 'type' :multi(pmc, pmc, pmc)
    .param pmc name
    .param pmc bases
    .param pmc dict

    $P0 = new 'Exception'
    $P0 = 'NotImplementedError'      # XXX
    throw $P0
.end


=item vars([object])

Without arguments, return a dictionary corresponding to the current
local symbol table. With a module, class or class instance object as
argument (or anything else that has a __dict__ attribute), returns a
dictionary corresponding to the object's symbol table. The returned
dictionary should not be modified: the effects on the corresponding
symbol table are undefined.2.4

=cut

.sub 'vars'
    .param pmc obj :optional

    $P0 = new 'Exception'
    $P0 = 'NotImplementedError'      # XXX
    throw $P0
.end


=item zip([iterable, ...])

This function returns a list of tuples, where the i-th tuple contains the
i-th element from each of the argument sequences or iterables. The returned
 list is truncated in length to the length of the shortest argument sequence.
 When there are multiple arguments which are all of the same length, zip()
 is similar to map() with an initial argument of None. With a single sequence
 argument, it returns a list of 1-tuples. With no arguments, it returns an
 empty list. New in version 2.0.

Changed in version 2.4: Formerly, zip() required at least one argument
and zip() raised a TypeError instead of returning an empty list.

=cut

.sub 'zip'
    .param pmc iterable :optional
    .param pmc args :slurpy

    $P0 = new 'Exception'
    $P0 = 'NotImplementedError'      # XXX
    throw $P0
.end




=back

=head1 AUTHOR

Pynie is authored and maintained by Patrick R. Michaud.

=cut

# Local Variables:
#   mode: pir
#   fill-column: 100
# End:
# vim: expandtab shiftwidth=4 ft=pir: