src/pmc/array.pmc

   1 /*
   2 Copyright (C) 2001-2008, The Perl Foundation.
   3 $Id$
   4
   5 =head1 NAME
   6
   7 src/pmc/array.pmc - Array PMC
   8
   9 =head1 DESCRIPTION
  10
  11 These are the vtable functions for the Array base class.
  12
  13 =head2 Functions
  14
  15 =over 4
  16
  17 =cut
  18
  19 */
  20
  21 #include "parrot/parrot.h"
  22
  23 /*
  24
  25 =item C<static PMC *undef(PARROT_INTERP)>
  26
  27 Returns a C<Undef> PMC.
  28
  29 =cut
  30
  31 */
  32
  33 static PMC *undef(PARROT_INTERP) {
  34     return pmc_new(interp, enum_class_Undef);
  35 }
  36
  37 /*
  38
  39 =item C<static PMC *retval(PARROT_INTERP, void *ret)>
  40
  41 Processes C<*ret>, returning the appropriate PMC, or raising an
  42 exception if necessary.
  43
  44 =cut
  45
  46 */
  47
  48 static PMC *retval(PARROT_INTERP, void *ret) {
  49     PMC *value;
  50
  51     if (ret == 0)
  52         real_exception(interp, NULL, E_IndexError,
  53             "Array index out of bounds!");
  54
  55     /* XXX getting non existent value, exception or undef?
  56      * current is for perlarray */
  57     if (ret == (void *)-1)
  58         value = undef(interp);
  59     else {
  60         value = *(PMC **)ret;
  61
  62         /* XXX same here */
  63         if (!value)
  64             value = undef(interp);
  65     }
  66
  67     return value;
  68 }
  69
  70 /*
  71
  72 =item C<static PMC
  73 *Parrot_Array_set_pmc_ptr(PARROT_INTERP, List *list, INTVAL key)>
  74
  75 Returns a pointer to the element at index C<key> of C<*list>. If
  76 this element was previously empty, then this function also creates
  77 and assigns an "undef" PMC to that element.
  78
  79 =cut
  80
  81 */
  82
  83 static PMC *Parrot_Array_set_pmc_ptr(PARROT_INTERP, List *list, INTVAL key) {
  84     void * const ret = list_get(interp, list, key, enum_type_PMC);
  85     PMC  *value;
  86
  87     if (ret == 0)
  88         real_exception(interp, NULL, E_IndexError,
  89             "Array index out of bounds!");
  90
  91     /* assign into a sparse or not yet set value */
  92     if (ret == (void *)-1 || *(PMC **)ret == 0) {
  93         value = undef(interp);
  94         list_assign(interp, list, key, value, enum_type_PMC);
  95     }
  96     else
  97         value = *(PMC **)ret;
  98
  99     return value;
 100 }
 101
 102
 103 pmclass Array need_ext provides array {
 104
 105 /*
 106
 107 =back
 108
 109 =head2 Methods
 110
 111 =over 4
 112
 113 =item C<void class_init()>
 114
 115 Class initialization. Creates the required memory pools.
 116
 117 =cut
 118
 119 */
 120
 121     void class_init() {
 122         /* class_init_code; called for side effects */
 123         Small_Object_Pool *List_chunks =
 124             make_bufferlike_pool(INTERP, sizeof (List_chunk));
 125         Small_Object_Pool *Lists       =
 126             make_bufferlike_pool(INTERP, sizeof (List));
 127
 128         /* XXX until there's a function to allocate a pool in an arena */
 129         UNUSED(List_chunks);
 130         UNUSED(Lists);
 131     }
 132
 133 /*
 134
 135 =item C<void init()>
 136
 137 Initializes the PMC by calling the underlying C<list_new()> function.
 138
 139 =cut
 140
 141 */
 142
 143     VTABLE void init() {
 144         list_pmc_new(INTERP, SELF);
 145         PObj_custom_mark_SET(SELF);
 146     }
 147
 148 /*
 149
 150 =item C<void init_pmc(PMC *init)>
 151
 152 Calls C<list_new_init()> to initialize the underlying list.
 153
 154 C<*init> contains the initialization information specifying initial
 155 size, number of dimensions, etc.
 156
 157 =cut
 158
 159 */
 160
 161     VTABLE void init_pmc(PMC *init) {
 162         list_pmc_new_init(INTERP, SELF, init);
 163         PObj_custom_mark_SET(SELF);
 164     }
 165
 166 /*
 167
 168 =item C<void assign_pmc(PMC *other)>
 169
 170 Copy the contents of other to self.
 171
 172 =cut
 173
 174 */
 175
 176     VTABLE void assign_pmc(PMC *other) {
 177         const INTVAL size = VTABLE_elements(INTERP, other);
 178         INTVAL       i;
 179
 180         SELF.set_integer_native(size);
 181         for (i = 0; i < size; i++) {
 182             PMC * const elem = VTABLE_get_pmc_keyed_int(INTERP, other, i);
 183             SELF.set_pmc_keyed_int(i, elem);
 184         }
 185     }
 186
 187
 188 /*
 189
 190 =item C<void set_pmc(PMC *other)>
 191
 192 Implemented as an alias to C<assign_pmc> since the behavior is the same.
 193
 194 =cut
 195
 196 */
 197
 198     VTABLE void set_pmc(PMC *other) {
 199         SELF.assign_pmc(other);
 200     }
 201
 202 /*
 203
 204 =item C<void mark()>
 205
 206 Mark the array and its contents as live.
 207
 208 =cut
 209
 210 */
 211
 212     VTABLE void mark() {
 213         list_mark(INTERP, (List *)PMC_data(SELF));
 214     }
 215
 216 /*
 217
 218 =item C<PMC *clone()>
 219
 220 Return a clone of the array.
 221
 222 =cut
 223
 224 */
 225
 226     VTABLE PMC *clone() {
 227         List       *l    = list_clone(INTERP, (List *)PMC_data(SELF));
 228         PMC * const dest = pmc_new_noinit(INTERP, SELF->vtable->base_type);
 229
 230         PObj_custom_mark_SET(dest);
 231
 232         PMC_data(dest) = l;
 233         l->container   = dest;
 234
 235         return dest;
 236     }
 237
 238 /*
 239
 240 =item C<INTVAL get_integer()>
 241
 242 Returns the number of elements in the array.
 243
 244 =cut
 245
 246 */
 247
 248     VTABLE INTVAL get_integer() {
 249         return SELF.elements();
 250     }
 251
 252 /*
 253
 254 =item C<INTVAL get_bool()>
 255
 256 Returns true if the array has one or more elements.
 257
 258 =cut
 259
 260 */
 261
 262     VTABLE INTVAL get_bool() {
 263         const INTVAL size = SELF.elements();
 264         return (INTVAL)(size != 0);
 265     }
 266
 267 /*
 268
 269 =item C<INTVAL elements()>
 270
 271 Returns the number of elements in the array.
 272
 273 =cut
 274
 275 */
 276
 277     VTABLE INTVAL elements() {
 278         return ((List *) PMC_data(SELF))->length;
 279     }
 280
 281 /*
 282
 283 =item C<FLOATVAL get_number()>
 284
 285 Returns the number of elements in the array.
 286
 287 =cut
 288
 289 */
 290
 291     VTABLE FLOATVAL get_number() {
 292         INTVAL e = SELF.elements();
 293         return (FLOATVAL)e;
 294     }
 295
 296 /*
 297
 298 =item C<STRING *get_string()>
 299
 300 Returns a string representation of the array.
 301
 302 =cut
 303
 304 */
 305
 306     VTABLE STRING *get_string() {
 307         return Parrot_sprintf_c(INTERP, "array[%p]", SELF);
 308     }
 309
 310 /*
 311
 312 =item C<INTVAL get_integer_keyed_int(INTVAL key)>
 313
 314 Returns the integer value of the element at index C<key>.
 315
 316 =cut
 317
 318 */
 319
 320     VTABLE INTVAL get_integer_keyed_int(INTVAL key) {
 321         PMC * const value = SELF.get_pmc_keyed_int(key);
 322
 323         return VTABLE_get_integer(INTERP, value);
 324     }
 325
 326 /*
 327
 328 =item C<INTVAL type_keyed_int(INTVAL key)>
 329
 330 =cut
 331
 332 */
 333
 334     VTABLE INTVAL type_keyed_int(INTVAL key) {
 335         PMC * const value = SELF.get_pmc_keyed_int(key);
 336
 337         return VTABLE_type(INTERP, value);
 338     }
 339
 340 /*
 341
 342 =item C<INTVAL get_integer_keyed(PMC *key)>
 343
 344 Returns the integer value of the element at index C<key>.
 345
 346 =cut
 347
 348 */
 349
 350     VTABLE INTVAL get_integer_keyed(PMC *key) {
 351         INTVAL ix;
 352         PMC   *nextkey, *box;
 353
 354         if (!key)
 355             return 0;
 356
 357         ix      = key_integer(INTERP, key);
 358         nextkey = key_next(INTERP, key);
 359
 360         if (!nextkey)
 361             return SELF.get_integer_keyed_int(ix);
 362
 363         box = SELF.get_pmc_keyed_int(ix);
 364
 365         if (!box)
 366             box = undef(INTERP);
 367
 368         return VTABLE_get_integer_keyed(INTERP, box, nextkey);
 369     }
 370
 371 /*
 372
 373 =item C<FLOATVAL get_number_keyed_int(INTVAL key)>
 374
 375 Returns the float value of the element at index C<key>.
 376
 377 =cut
 378
 379 */
 380
 381     VTABLE FLOATVAL get_number_keyed_int(INTVAL key) {
 382         PMC * const value = SELF.get_pmc_keyed_int(key);
 383
 384         return VTABLE_get_number(INTERP, value);
 385
 386     }
 387
 388 /*
 389
 390 =item C<FLOATVAL get_number_keyed(PMC *key)>
 391
 392 Returns the float value of the element at index C<key>.
 393
 394 =cut
 395
 396 */
 397
 398     VTABLE FLOATVAL get_number_keyed(PMC *key) {
 399         INTVAL ix;
 400         PMC *nextkey, *box;
 401
 402         if (!key)
 403             return (FLOATVAL)0;
 404
 405         ix      = key_integer(INTERP, key);
 406         nextkey = key_next(INTERP, key);
 407
 408         if (!nextkey)
 409             return SELF.get_number_keyed_int(ix);
 410
 411         box = SELF.get_pmc_keyed_int(ix);
 412
 413         if (!box)
 414             box = undef(INTERP);
 415
 416         return VTABLE_get_number_keyed(INTERP, box, nextkey);
 417     }
 418
 419 /*
 420
 421 =item C<STRING *get_string_keyed_int(INTVAL key)>
 422
 423 Returns the string value of the element at index C<key>.
 424
 425 =cut
 426
 427 */
 428
 429     VTABLE STRING *get_string_keyed_int(INTVAL key) {
 430         PMC * const value = SELF.get_pmc_keyed_int(key);
 431
 432         return VTABLE_get_string(INTERP, value);
 433     }
 434
 435 /*
 436
 437 =item C<STRING *get_string_keyed(PMC *key)>
 438
 439 Returns the string value of the element at index C<key>.
 440
 441 =cut
 442
 443 */
 444
 445     VTABLE STRING *get_string_keyed(PMC *key) {
 446         INTVAL ix;
 447         PMC   *nextkey, *box;
 448
 449         if (!key)
 450             return 0;
 451
 452         ix      = key_integer(INTERP, key);
 453         nextkey = key_next(INTERP, key);
 454
 455         if (!nextkey)
 456             return SELF.get_string_keyed_int(ix);
 457
 458         box = SELF.get_pmc_keyed_int(ix);
 459
 460         if (!box)
 461             box = undef(INTERP);
 462
 463         return VTABLE_get_string_keyed(INTERP, box, nextkey);
 464     }
 465
 466 /*
 467
 468 =item C<PMC *get_pmc_keyed_int(INTVAL key)>
 469
 470 Returns the PMC value of the element at index C<key>.
 471
 472 =cut
 473
 474 */
 475
 476     VTABLE PMC *get_pmc_keyed_int(INTVAL key) {
 477
 478         return retval(INTERP,
 479             list_get(INTERP, (List *)PMC_data(SELF), key, enum_type_PMC));
 480     }
 481
 482 /*
 483
 484 =item C<PMC *get_pmc_keyed(PMC *key)>
 485
 486 Returns the PMC value of the element at index C<key>.
 487
 488 =cut
 489
 490 */
 491
 492     VTABLE PMC *get_pmc_keyed(PMC *key) {
 493         INTVAL ix;
 494         PMC   *nextkey, *box;
 495
 496         if (!key)
 497             return 0;
 498
 499         ix      = key_integer(INTERP, key);
 500         nextkey = key_next(INTERP, key);
 501
 502         if (!nextkey)
 503             return SELF.get_pmc_keyed_int(ix);
 504
 505         box = SELF.get_pmc_keyed_int(ix);
 506
 507         if (!box)
 508             box = undef(INTERP);
 509
 510         return VTABLE_get_pmc_keyed(INTERP, box, nextkey);
 511     }
 512
 513 /*
 514
 515 =item C<void set_integer_native(INTVAL size)>
 516
 517 Sets the length of the array to C<size>.
 518
 519 =cut
 520
 521 */
 522
 523     VTABLE void set_integer_native(INTVAL size) {
 524         list_set_length(INTERP, (List *)PMC_data(SELF), size);
 525     }
 526 /*
 527
 528 =item C<void set_integer_same(PMC *value)>
 529
 530 Sets the length of the array to the number of elements in C<*value>.
 531
 532 =cut
 533
 534 */
 535
 536     VTABLE void set_integer_same(PMC *value) {
 537         const INTVAL size = VTABLE_elements(INTERP, value);
 538         list_set_length(INTERP, (List *)PMC_data(SELF), size);
 539     }
 540
 541 /*
 542
 543 =item C<void set_integer_keyed_int(INTVAL key, INTVAL value)>
 544
 545 Sets the integer value of the PMC at element C<key> to C<value>.
 546
 547 =cut
 548
 549 */
 550
 551     VTABLE void set_integer_keyed_int(INTVAL key, INTVAL value) {
 552         PMC * const ptr =
 553             Parrot_Array_set_pmc_ptr(INTERP, (List *)PMC_data(SELF), key);
 554
 555         VTABLE_set_integer_native(INTERP, ptr, value);
 556     }
 557
 558 /*
 559
 560 =item C<void set_integer_keyed(PMC *key, INTVAL value)>
 561
 562 Sets the integer value of the PMC at element C<key> to C<value>.
 563
 564 =cut
 565
 566 */
 567
 568     VTABLE void set_integer_keyed(PMC *key, INTVAL value) {
 569         INTVAL ix;
 570         PMC   *nextkey, *box;
 571
 572         if (!key)
 573             return;
 574
 575         ix      = key_integer(INTERP, key);
 576         nextkey = key_next(INTERP, key);
 577
 578         if (!nextkey) {
 579             SELF.set_integer_keyed_int(ix, value);
 580             return;
 581         }
 582
 583         box = SELF.get_pmc_keyed_int(ix);
 584
 585         /* autovivify an Array */
 586         if (!box)
 587             box = pmc_new(INTERP, SELF.type());
 588
 589         VTABLE_set_integer_keyed(INTERP, box, nextkey, value);
 590     }
 591
 592 /*
 593
 594 =item C<void set_number_keyed_int(INTVAL key, FLOATVAL value)>
 595
 596 Sets the numeric value of the PMC at element C<key> to C<value>.
 597
 598 =cut
 599
 600 */
 601
 602     VTABLE void set_number_keyed_int(INTVAL key, FLOATVAL value) {
 603         PMC * const ptr =
 604             Parrot_Array_set_pmc_ptr(INTERP, (List *)PMC_data(SELF), key);
 605
 606         VTABLE_set_number_native(INTERP, ptr, value);
 607     }
 608
 609 /*
 610
 611 =item C<void set_number_keyed(PMC *key, FLOATVAL value)>
 612
 613 Sets the numeric value of the PMC at element C<key> to C<value>.
 614
 615 =cut
 616
 617 */
 618
 619     VTABLE void set_number_keyed(PMC *key, FLOATVAL value) {
 620         INTVAL ix;
 621         PMC   *nextkey, *box;
 622
 623         if (!key)
 624             return;
 625
 626         ix      = key_integer(INTERP, key);
 627         nextkey = key_next(INTERP, key);
 628
 629         if (!nextkey) {
 630             SELF.set_number_keyed_int(ix, value);
 631             return;
 632         }
 633
 634         box = SELF.get_pmc_keyed_int(ix);
 635
 636         /* autovivify an Array */
 637         if (!box)
 638             box = pmc_new(INTERP, SELF.type());
 639
 640         VTABLE_set_number_keyed(INTERP, box, nextkey, value);
 641     }
 642
 643 /*
 644
 645 =item C<void set_string_keyed_int(INTVAL key, STRING *value)>
 646
 647 Sets the string value of the PMC at element C<key> to C<value>.
 648
 649 =cut
 650
 651 */
 652
 653     VTABLE void set_string_keyed_int(INTVAL key, STRING *value) {
 654         PMC * const ptr =
 655             Parrot_Array_set_pmc_ptr(INTERP, (List *)PMC_data(SELF), key);
 656
 657         VTABLE_set_string_native(INTERP, ptr, value);
 658     }
 659
 660 /*
 661
 662 =item C<void set_string_keyed(PMC *key, STRING *value)>
 663
 664 Sets the string value of the PMC at element C<key> to C<value>.
 665
 666 =cut
 667
 668 */
 669
 670     VTABLE void set_string_keyed(PMC *key, STRING *value) {
 671         INTVAL ix;
 672         PMC   *nextkey, *box;
 673
 674         if (!key)
 675             return;
 676
 677         ix      = key_integer(INTERP, key);
 678         nextkey = key_next(INTERP, key);
 679
 680         if (!nextkey) {
 681             VTABLE_set_string_keyed_int(INTERP, SELF, ix, value);
 682             return;
 683         }
 684
 685         box = SELF.get_pmc_keyed_int(ix);
 686
 687         /* autovivify an Array */
 688         if (!box)
 689             box = pmc_new(INTERP, SELF.type());
 690
 691         VTABLE_set_string_keyed(INTERP, box, nextkey, value);
 692     }
 693
 694 /*
 695
 696 =item C<void set_pmc_keyed_int(INTVAL idx, PMC *src)>
 697
 698 Sets the PMC at element C<idx> to C<*src>.
 699
 700 =cut
 701
 702 */
 703
 704     VTABLE void set_pmc_keyed_int(INTVAL idx, PMC *src) {
 705         const INTVAL length = ((List *)PMC_data(SELF))->length;
 706
 707         if (idx >= length || -idx > length)
 708             real_exception(INTERP, NULL, E_IndexError,
 709                 "Array index out of bounds!");
 710
 711         list_assign(INTERP, (List *)PMC_data(SELF), idx,
 712             (void *)src, enum_type_PMC);
 713     }
 714
 715 /*
 716
 717 =item C<void set_pmc_keyed(PMC *key, PMC *value)>
 718
 719 Sets the PMC at index C<key> to C<value>.
 720
 721 =cut
 722
 723 */
 724
 725     VTABLE void set_pmc_keyed(PMC *key, PMC *value) {
 726         PMC *box;
 727
 728         const INTVAL ix      = key_integer(INTERP, key);
 729         PMC * const  nextkey = key_next(INTERP, key);
 730
 731         if (!nextkey) {
 732             VTABLE_set_pmc_keyed_int(INTERP, SELF, ix, value);
 733             return;
 734         }
 735
 736         box = SELF.get_pmc_keyed_int(ix);
 737
 738         /* autovivify an Array */
 739         if (!box)
 740             box = pmc_new(INTERP, SELF.type());
 741
 742         VTABLE_set_pmc_keyed(INTERP, box, nextkey, value);
 743     }
 744
 745 /*
 746
 747 =item C<void push_integer(INTVAL value)>
 748
 749 Extends the array by adding an element of value C<value> to the end of
 750 the array.
 751
 752 =cut
 753
 754 */
 755
 756     VTABLE void push_integer(INTVAL value) {
 757         const INTVAL nextix = SELF.elements();
 758         SELF.set_integer_keyed_int(nextix, value);
 759     }
 760
 761 /*
 762
 763 =item C<void push_float(FLOATVAL value)>
 764
 765 Extends the array by adding an element of value C<value> to the end of
 766 the array.
 767
 768 =cut
 769
 770 */
 771
 772     VTABLE void push_float(FLOATVAL value) {
 773         const INTVAL nextix = SELF.elements();
 774         SELF.set_number_keyed_int(nextix, value);
 775     }
 776
 777 /*
 778
 779 =item C<void push_string(STRING *value)>
 780
 781 Extends the array by adding an element of value C<*value> to the end of
 782 the array.
 783
 784 =cut
 785
 786 */
 787
 788     VTABLE void push_string(STRING *value) {
 789         const INTVAL nextix = SELF.elements();
 790         SELF.set_string_keyed_int(nextix, value);
 791     }
 792
 793 /*
 794
 795 =item C<void push_pmc(PMC *value)>
 796
 797 Extends the array by adding an element of value C<*value> to the end of
 798 the array.
 799
 800 =cut
 801
 802 */
 803
 804     void push_pmc(PMC *value) {
 805         const INTVAL nextix = SELF.elements();
 806         SELF.set_pmc_keyed_int(nextix, value);
 807     }
 808
 809 /*
 810
 811 =item C<void unshift_integer(INTVAL value)>
 812
 813 Extends the array by adding an element of value C<value> to the start
 814 of the array.
 815
 816 =cut
 817
 818 */
 819
 820     VTABLE void unshift_integer(INTVAL value) {
 821         PMC * const val = undef(INTERP);
 822
 823         list_unshift(INTERP, (List *)PMC_data(SELF), val, enum_type_PMC);
 824         VTABLE_set_integer_native(INTERP, val, value);
 825     }
 826
 827 /*
 828
 829 =item C<void unshift_float(FLOATVAL value)>
 830
 831 Extends the array by adding an element of value C<value> to the start
 832 of the array.
 833
 834 =cut
 835
 836 */
 837
 838     VTABLE void unshift_float(FLOATVAL value) {
 839         PMC * const val = undef(INTERP);
 840
 841         list_unshift(INTERP, (List *)PMC_data(SELF), val, enum_type_PMC);
 842         VTABLE_set_number_native(INTERP, val, value);
 843     }
 844
 845 /*
 846
 847 =item C<void unshift_string(STRING *value)>
 848
 849 Extends the array by adding an element of value C<*value> to the start
 850 of the array.
 851
 852 =cut
 853
 854 */
 855
 856     VTABLE void unshift_string(STRING *value) {
 857         PMC * const val = undef(INTERP);
 858         list_unshift(INTERP, (List *)PMC_data(SELF), val, enum_type_PMC);
 859         VTABLE_set_string_native(INTERP, val, value);
 860     }
 861
 862 /*
 863
 864 =item C<void unshift_pmc(PMC *value)>
 865
 866 Extends the array by adding an element of value C<*value> to the start
 867 of the array.
 868
 869 =cut
 870
 871 */
 872
 873     void unshift_pmc(PMC *value) {
 874         list_unshift(INTERP, (List *)PMC_data(SELF), value, enum_type_PMC);
 875     }
 876
 877 /*
 878
 879 =item C<INTVAL pop_integer()>
 880
 881 Removes and returns an integer from the end of the array.
 882
 883 =cut
 884
 885 */
 886
 887     VTABLE INTVAL pop_integer() {
 888         PMC * const ptr = SELF.pop_pmc();
 889         return VTABLE_get_integer(INTERP, ptr);
 890     }
 891
 892 /*
 893
 894 =item C<FLOATVAL pop_float()>
 895
 896 Removes and returns a float value from the end of the array.
 897
 898 =cut
 899
 900 */
 901
 902     VTABLE FLOATVAL pop_float() {
 903         PMC * const ptr = SELF.pop_pmc();
 904         return VTABLE_get_number(INTERP, ptr);
 905     }
 906
 907 /*
 908
 909 =item C<STRING *pop_string()>
 910
 911 Removes and returns a string from the end of the array.
 912
 913 =cut
 914
 915 */
 916
 917     VTABLE STRING *pop_string() {
 918         PMC * const ptr = SELF.pop_pmc();
 919         return VTABLE_get_string(INTERP, ptr);
 920     }
 921
 922 /*
 923
 924 =item C<PMC *pop_pmc()>
 925
 926 Removes and returns a PMC from the end of the array.
 927
 928 =cut
 929
 930 */
 931
 932     VTABLE PMC *pop_pmc() {
 933         return retval(INTERP,
 934             list_pop(INTERP, (List *)PMC_data(SELF), enum_type_PMC));
 935     }
 936
 937 /*
 938
 939 =item C<INTVAL shift_integer()>
 940
 941 Removes and returns an integer from the start of the array.
 942
 943 =cut
 944
 945 */
 946
 947     VTABLE INTVAL shift_integer() {
 948         PMC * const ptr = SELF.shift_pmc();
 949         return VTABLE_get_integer(INTERP, ptr);
 950     }
 951
 952 /*
 953
 954 =item C<FLOATVAL shift_float()>
 955
 956 Removes and returns a float from the start of the array.
 957
 958 =cut
 959
 960 */
 961
 962     VTABLE FLOATVAL shift_float() {
 963         PMC * const ptr = SELF.shift_pmc();
 964         return VTABLE_get_number(INTERP, ptr);
 965     }
 966
 967 /*
 968
 969 =item C<STRING *shift_string()>
 970
 971 Removes and returns a string from the start of the array.
 972
 973 =cut
 974
 975 */
 976
 977     VTABLE STRING *shift_string() {
 978         PMC * const ptr = SELF.shift_pmc();
 979         return VTABLE_get_string(INTERP, ptr);
 980     }
 981
 982 /*
 983
 984 =item C<PMC *shift_pmc()>
 985
 986 Removes and returns a PMC from the start of the array.
 987
 988 =cut
 989
 990 */
 991
 992     VTABLE PMC *shift_pmc() {
 993         return retval(INTERP,
 994             list_shift(INTERP, (List *)PMC_data(SELF), enum_type_PMC));
 995     }
 996
 997 /*
 998
 999 =item C<void splice(PMC *value, INTVAL offset, INTVAL count)>
1000
1001 Replaces C<count> elements starting at C<offset> with the elements in
1002 C<value>.
1003
1004 If C<count> is 0 then the elements in C<value> will be inserted after
1005 C<offset>.
1006
1007 =cut
1008
1009 */
1010
1011     void splice(PMC *value, INTVAL offset, INTVAL count) {
1012         if (SELF->vtable->base_type != value->vtable->base_type)
1013             real_exception(INTERP, NULL, E_TypeError,
1014                 "Type mismatch in splice");
1015
1016         list_splice(INTERP, (List *)PMC_data(SELF),
1017             (List *)PMC_data(value), offset, count);
1018     }
1019
1020 /*
1021
1022 =item C<INTVAL defined_keyed_int(INTVAL key)>
1023
1024 Returns TRUE is the element at C<key> is defined; otherwise returns false.
1025
1026 =cut
1027
1028 */
1029
1030     VTABLE INTVAL defined_keyed_int(INTVAL key) {
1031         PMC  *value;
1032         void * const ret =
1033             list_get(INTERP, (List *)PMC_data(pmc), key, enum_type_PMC);
1034
1035         if (ret == 0 || ret == (void *) -1)
1036             return 0;
1037
1038         value = *(PMC **)ret;
1039
1040         if (!value)
1041             return 0;
1042
1043         return VTABLE_defined(INTERP, value);
1044     }
1045
1046 /*
1047
1048 =item C<INTVAL defined_keyed(PMC *key)>
1049
1050 Returns TRUE is the element at C<key> is defined; otherwise returns false.
1051
1052 =cut
1053
1054 */
1055
1056     VTABLE INTVAL defined_keyed(PMC *key) {
1057         PMC *box;
1058
1059         const INTVAL ix      = key_integer(INTERP, key);
1060         PMC * const  nextkey = key_next(INTERP, key);
1061
1062         if (!nextkey)
1063             return SELF.defined_keyed_int(ix);
1064
1065         box = SELF.get_pmc_keyed_int(ix);
1066
1067         if (!box)
1068             return 0;
1069
1070         return VTABLE_defined_keyed(INTERP, box, nextkey);
1071     }
1072
1073 /*
1074
1075 =item C<INTVAL exists_keyed_int(INTVAL key)>
1076
1077 Returns TRUE is the element at C<key> exists; otherwise returns false.
1078
1079 =cut
1080
1081 */
1082
1083     VTABLE INTVAL exists_keyed_int(INTVAL key) {
1084         void * ret = list_get(INTERP,
1085             (List *)PMC_data(pmc), key, enum_type_PMC);
1086
1087         if (ret == 0 || ret == (void *)-1)
1088             return 0;
1089
1090         return !PMC_IS_NULL(*(PMC **)ret);
1091     }
1092
1093 /*
1094
1095 =item C<INTVAL exists_keyed(PMC *key)>
1096
1097 Returns TRUE is the element at C<key> exists; otherwise returns false.
1098
1099 =cut
1100
1101 */
1102
1103     VTABLE INTVAL exists_keyed(PMC *key) {
1104         PMC *box;
1105
1106         const INTVAL ix      = key_integer(INTERP, key);
1107         PMC * const  nextkey = key_next(INTERP, key);
1108
1109         if (!nextkey)
1110             return SELF.exists_keyed_int(ix);
1111
1112         box = SELF.get_pmc_keyed_int(ix);
1113
1114         if (!box)
1115             return 0;
1116
1117         return VTABLE_exists_keyed(INTERP, box, nextkey);
1118     }
1119
1120 /*
1121
1122 =item C<void delete_keyed_int(INTVAL key)>
1123
1124 Removes the element at C<key>.
1125
1126 =cut
1127
1128 */
1129
1130     VTABLE void delete_keyed_int(INTVAL key) {
1131         list_splice(INTERP, (List *)PMC_data(pmc), NULL, key, 1);
1132     }
1133
1134 /*
1135
1136 =item C<void delete_keyed(PMC *key)>
1137
1138 Removes the element at C<*key>.
1139
1140 =cut
1141
1142 */
1143
1144     VTABLE void delete_keyed(PMC *key) {
1145         const INTVAL ix = key_integer(INTERP, key);
1146         list_splice(INTERP, (List *)PMC_data(pmc), NULL, ix, 1);
1147     }
1148
1149 /*
1150
1151 =item C<INTVAL is_equal(PMC *value)>
1152
1153 The C<==> operation. Compares two array to hold equal elements.
1154
1155 =cut
1156
1157 */
1158
1159     VTABLE INTVAL is_equal(PMC *value) {
1160         INTVAL j, n;
1161
1162         if (value->vtable->base_type != enum_class_Array)
1163             return 0;
1164
1165         n = SELF.elements();
1166
1167         if (VTABLE_elements(INTERP, value) != n)
1168             return 0;
1169
1170         for (j = 0; j < n; ++j) {
1171             PMC * const item1 = SELF.get_pmc_keyed_int(j);
1172             PMC * const item2 = VTABLE_get_pmc_keyed_int(INTERP, value, j);
1173
1174             if (item1 != item2)
1175                 if (!mmd_dispatch_i_pp(INTERP, item1, item2, MMD_EQ))
1176                     return 0;
1177         }
1178
1179         return 1;
1180     }
1181
1182 /*
1183
1184 =item C<PMC *slice(PMC *key, INTVAL f)>
1185
1186 Return a new iterator for the slice PMC C<key> if f == 0.
1187
1188 Return a new pythonic array slice if f == 1.
1189
1190 =item C<PMC *get_iter()>
1191
1192 Return a new iterator for SELF.
1193
1194 =cut
1195
1196 */
1197
1198     VTABLE PMC *slice(PMC *key, INTVAL f) {
1199         if (f == 0) {
1200             PMC * const iter = pmc_new_init(INTERP, enum_class_Iterator, SELF);
1201             PMC_struct_val(iter) = key;
1202             return iter;
1203         }
1204
1205         real_exception(INTERP, NULL, E_TypeError, "Array: Unknown slice type");
1206     }
1207
1208     VTABLE PMC *get_iter() {
1209         PMC * const iter     = pmc_new_init(INTERP, enum_class_Iterator, SELF);
1210         PMC * const key      = pmc_new(INTERP, enum_class_Key);
1211         PMC_struct_val(iter) = key;
1212         PObj_get_FLAGS(key) |= KEY_integer_FLAG;
1213         PMC_int_val(key)     = 0;
1214
1215         if (!((List *)PMC_data(SELF))->length)
1216             PMC_int_val(key) = -1;
1217
1218         return iter;
1219     }
1220
1221 /*
1222
1223 =item C<void visit(visit_info *info)>
1224
1225 This is used by freeze/thaw to visit the contents of the array.
1226
1227 C<*info> is the visit info, (see F<include/parrot/pmc_freeze.h>).
1228
1229 =cut
1230
1231 */
1232
1233     VTABLE void visit(visit_info *info) {
1234         list_visit(INTERP, (List *)PMC_data(SELF), info);
1235         SUPER(info);
1236     }
1237
1238 /*
1239
1240 =item C<void freeze(visit_info *info)>
1241
1242 Used to archive the array.
1243
1244 =cut
1245
1246 */
1247
1248     VTABLE void freeze(visit_info *info) {
1249         IMAGE_IO * const io = info->image_io;
1250         SUPER(info);
1251         VTABLE_push_integer(INTERP, io, VTABLE_elements(INTERP, SELF));
1252     }
1253
1254 /*
1255
1256 =item C<void thaw(visit_info *info)>
1257
1258 Used to unarchive the array.
1259
1260 =cut
1261
1262 */
1263
1264     VTABLE void thaw(visit_info *info) {
1265         IMAGE_IO * const io = info->image_io;
1266
1267         SUPER(info);
1268         if (info->extra_flags == EXTRA_IS_NULL) {
1269             SELF.set_integer_native(VTABLE_shift_integer(INTERP, io));
1270     }
1271 }
1272
1273 /*
1274
1275 =item C<PMC *share_ro()>
1276
1277 Recursively make the array read-only and shared.
1278
1279 =cut
1280
1281 */
1282     VTABLE PMC *share_ro() {
1283         PMC *_true, *ret;
1284
1285         /* prevent infinite recursion */
1286         if (PObj_is_PMC_shared_TEST(SELF))
1287             real_exception(INTERP, NULL, INVALID_OPERATION, "share_ro on "
1288                            "something that already is shared");
1289
1290         _true = pmc_new(INTERP, enum_class_Integer);
1291         VTABLE_set_integer_native(INTERP, _true, 1);
1292
1293         ret   = pt_shared_fixup(INTERP, SELF);
1294
1295         /* first set readonly */
1296         VTABLE_setprop(INTERP, ret, CONST_STRING(INTERP, "_ro"), _true);
1297
1298         /* XXX do something that deals better with sparse lists */
1299         {
1300             INTVAL i;
1301             const INTVAL max = VTABLE_elements(INTERP, ret);
1302
1303             for (i = 0; i < max; ++i) {
1304                 PMC * const value =
1305                     (PMC *)list_get(INTERP, PMC_data_typed(ret, List *),
1306                                  i, enum_type_PMC);
1307
1308                 if (!PMC_IS_NULL(value)) {
1309                     /* XXX do we need to clone first? */
1310                     PMC * const new_value = VTABLE_share_ro(INTERP, value);
1311
1312                     if (new_value != value)
1313                         list_assign(INTERP, PMC_data_typed(ret, List *),
1314                             i, new_value, enum_type_PMC);
1315                 }
1316             }
1317         }
1318
1319         /* XXX FIXME workaround lack of metadata sharing */
1320         PMC_metadata(SELF) = NULL;
1321
1322         return ret;
1323     }
1324 }
1325
1326 /*
1327
1328 =back
1329
1330 =head1 SEE ALSO
1331
1332 F<src/list.c>, F<include/parrot/list.h>
1333
1334 =head1 TODO
1335
1336 Create global immutable undef object.
1337
1338 =cut
1339
1340 */
1341
1342 /*
1343  * Local variables:
1344  *   c-file-style: "parrot"
1345  * End:
1346  * vim: expandtab shiftwidth=4:
1347  */