src/pmc/fixedpmcarray.pmc

   1 /*
   2 Copyright (C) 2001-2010, Parrot Foundation.
   3 $Id$
   4
   5 =head1 NAME
   6
   7 src/pmc/fixedpmcarray.pmc - fixed size array for PMCs only
   8
   9 =head1 DESCRIPTION
  10
  11 This class, FixedPMCArray, implements an array of fixed size which stores PMCs.
  12 It puts things into Integer, Float, or String PMCs as appropriate
  13
  14 =head2 Note
  15
  16 The flag C<PObj_private0_FLAG> is used in the C<NameSpace> PMC and should
  17 never be set for user arrays.
  18
  19 =head2 Functions
  20
  21 =over 4
  22
  23 =cut
  24
  25 */
  26
  27 #define PMC_size(x)  ((Parrot_FixedPMCArray_attributes *)PMC_data(x))->size
  28 #define PMC_array(x) ((Parrot_FixedPMCArray_attributes *)PMC_data(x))->pmc_array
  29
  30 pmclass FixedPMCArray auto_attrs provides array {
  31     ATTR INTVAL   size;      /* number of elements in the array */
  32     ATTR PMC    **pmc_array; /* pointer to PMC array */
  33
  34 /*
  35
  36 =item C<METHOD sort(PMC *cmp_func)>
  37
  38 Sort this array, optionally using the provided cmp_func
  39
  40 =cut
  41
  42 */
  43
  44     METHOD sort(PMC *cmp_func :optional) {
  45         const INTVAL n = SELF.elements();
  46
  47         if (n > 1) {
  48             /* XXX Workaround for TT #218 */
  49             if (PObj_is_object_TEST(SELF)) {
  50                 PMC *parent = SELF.get_attr_str(CONST_STRING(interp, "proxy"));
  51                 Parrot_pcc_invoke_method_from_c_args(interp, parent, CONST_STRING(interp, "sort"), "P->", cmp_func);
  52             }
  53             else
  54                 Parrot_quicksort(interp, (void **)PMC_array(SELF), n, cmp_func);
  55         }
  56         RETURN(PMC *SELF);
  57     }
  58
  59 /*
  60
  61 =back
  62
  63 =head2 Methods
  64
  65 =over 4
  66
  67 =item C<void init()>
  68
  69 Initializes the array.
  70
  71 =cut
  72
  73 */
  74
  75     VTABLE void init() {
  76         PObj_custom_mark_destroy_SETALL(SELF);
  77     }
  78
  79 /*
  80
  81 =item C<void init_int(INTVAL size)>
  82
  83 Initializes the array.
  84
  85 =cut
  86
  87 */
  88
  89     VTABLE void init_int(INTVAL size) {
  90         PMC **data;
  91         int i;
  92
  93         if (size < 0)
  94             Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_OUT_OF_BOUNDS,
  95                     _("FixedPMCArray: Cannot set array size to a negative number (%d)"),size);
  96
  97         SET_ATTR_size(INTERP, SELF, size);
  98         data           = mem_gc_allocate_n_typed(INTERP, size, PMC *);
  99
 100         for (i = 0; i < size; i++)
 101             data[i] = PMCNULL;
 102
 103         PObj_custom_destroy_SET(SELF);
 104     }
 105
 106 /*
 107
 108 =item C<void destroy()>
 109
 110 Destroys the array.
 111
 112 =cut
 113
 114 */
 115
 116     VTABLE void destroy() {
 117         if (PMC_array(SELF))
 118             mem_gc_free(INTERP, PMC_array(SELF));
 119     }
 120
 121 /*
 122
 123 =item C<PMC *clone()>
 124
 125 Creates and returns a copy of the array.
 126
 127 =cut
 128
 129 */
 130
 131     VTABLE PMC *clone() {
 132         PMC * const dest  = Parrot_pmc_new(INTERP, SELF->vtable->base_type);
 133         const INTVAL size = PMC_size(SELF);
 134
 135         if (size) {
 136             PMC_size(dest)  = size;
 137             PMC_array(dest) = mem_gc_allocate_n_zeroed_typed(INTERP, size, PMC *);
 138             mem_copy_n_typed(PMC_array(dest), PMC_array(SELF), size, PMC *);
 139             PObj_custom_mark_destroy_SETALL(dest);
 140         }
 141
 142         return dest;
 143     }
 144
 145 /*
 146
 147 =item C<INTVAL get_bool()>
 148
 149 Returns whether the array has any elements (meaning been initialized, for a
 150 fixed sized array).
 151
 152 =cut
 153
 154 */
 155     VTABLE INTVAL get_bool() {
 156         const INTVAL size = SELF.elements();
 157         return (INTVAL)(size != 0);
 158     }
 159
 160 /*
 161
 162 =item C<INTVAL elements()>
 163
 164 =cut
 165
 166 */
 167
 168     VTABLE INTVAL elements() {
 169         return PMC_size(SELF);
 170     }
 171
 172 /*
 173
 174 =item C<INTVAL get_integer()>
 175
 176 Returns the number of elements in the array.
 177
 178 =cut
 179
 180 */
 181
 182     VTABLE INTVAL get_integer() {
 183         return SELF.elements();
 184     }
 185
 186 /*
 187
 188 =item C<FLOATVAL get_number()>
 189
 190 Returns the number of elements in the array.
 191
 192 =cut
 193
 194 */
 195
 196     VTABLE FLOATVAL get_number() {
 197         const INTVAL e = SELF.elements();
 198         return (FLOATVAL)e;
 199     }
 200
 201 /*
 202
 203 =item C<STRING *get_string()>
 204
 205 Returns the number of elements in the array as a Parrot string. (??? -leo)
 206
 207 =item C<STRING *get_repr()>
 208
 209 Returns a string representation of the array contents.
 210 TT #1229: implement freeze/thaw and use that instead.
 211
 212 =cut
 213
 214 */
 215
 216     VTABLE STRING *get_string() {
 217         return Parrot_str_from_int(INTERP, SELF.elements());
 218     }
 219
 220     VTABLE STRING *get_repr() {
 221         STRING *res    = CONST_STRING(INTERP, "(");
 222         const INTVAL n = VTABLE_elements(INTERP, SELF);
 223         INTVAL  i;
 224
 225         for (i = 0; i < n; ++i) {
 226             PMC * const val = SELF.get_pmc_keyed_int(i);
 227             if (i > 0)
 228                 res = Parrot_str_append(INTERP, res, CONST_STRING(INTERP, ", "));
 229
 230             res = Parrot_str_append(INTERP, res, VTABLE_get_repr(INTERP, val));
 231         }
 232
 233         res = Parrot_str_append(INTERP, res, CONST_STRING(INTERP, ")"));
 234
 235         return res;
 236     }
 237
 238 /*
 239
 240 =item C<INTVAL get_integer_keyed_int(INTVAL key)>
 241
 242 Returns the integer value of the element at index C<key>.
 243
 244 =cut
 245
 246 */
 247
 248     VTABLE INTVAL get_integer_keyed_int(INTVAL key) {
 249         PMC * const tempPMC = SELF.get_pmc_keyed_int(key);
 250         if (PMC_IS_NULL(tempPMC))
 251             return 0;
 252         return VTABLE_get_integer(INTERP, tempPMC);
 253     }
 254
 255 /*
 256
 257 =item C<INTVAL get_integer_keyed(PMC *key)>
 258
 259 Returns the integer value of the element at index C<*key>.
 260
 261 =cut
 262
 263 */
 264
 265     VTABLE INTVAL get_integer_keyed(PMC *key) {
 266         PMC * const tempPMC = SELF.get_pmc_keyed(key);
 267         return VTABLE_get_integer(INTERP, tempPMC);
 268     }
 269
 270 /*
 271
 272 =item C<FLOATVAL get_number_keyed_int(INTVAL key)>
 273
 274 Returns the floating-point value of the element at index C<key>.
 275
 276 =cut
 277
 278 */
 279
 280     VTABLE FLOATVAL get_number_keyed_int(INTVAL key) {
 281         PMC * const tempPMC = SELF.get_pmc_keyed_int(key);
 282         return VTABLE_get_number(INTERP, tempPMC);
 283     }
 284
 285 /*
 286
 287 =item C<FLOATVAL get_number_keyed(PMC *key)>
 288
 289 Returns the floating-point value of the element at index C<*key>.
 290
 291 =cut
 292
 293 */
 294
 295     VTABLE FLOATVAL get_number_keyed(PMC *key) {
 296         PMC * const tempPMC = SELF.get_pmc_keyed(key);
 297         return VTABLE_get_number(INTERP, tempPMC);
 298     }
 299
 300 /*
 301
 302 =item C<STRING *get_string_keyed_int(INTVAL key)>
 303
 304 Returns the Parrot string value of the element at index C<key>.
 305
 306 =cut
 307
 308 */
 309
 310     VTABLE STRING *get_string_keyed_int(INTVAL key) {
 311         PMC * const retval = SELF.get_pmc_keyed_int(key);
 312
 313         if (PMC_IS_NULL(retval))
 314             return string_from_literal(interp, "");
 315
 316         return VTABLE_get_string(INTERP, retval);
 317     }
 318
 319 /*
 320
 321 =item C<STRING *get_string_keyed(PMC *key)>
 322
 323 Returns the Parrot string value of the element at index C<*key>.
 324
 325 =cut
 326
 327 */
 328
 329     VTABLE STRING *get_string_keyed(PMC *key) {
 330         PMC * const tempPMC = SELF.get_pmc_keyed(key);
 331         return VTABLE_get_string(INTERP, tempPMC);
 332     }
 333
 334 /*
 335
 336 =item C<PMC *get_pmc_keyed_int(INTVAL key)>
 337
 338 Returns the PMC value of the element at index C<key>.
 339
 340 =cut
 341
 342 */
 343
 344     VTABLE PMC *get_pmc_keyed_int(INTVAL key) {
 345         PMC **data;
 346
 347         if (key < 0 || key >= PMC_size(SELF))
 348             Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_OUT_OF_BOUNDS,
 349                 _("FixedPMCArray: index out of bounds!"));
 350
 351         data = PMC_array(SELF);
 352         return data[key];
 353     }
 354
 355 /*
 356
 357 =item C<PMC *get_pmc_keyed(PMC *key)>
 358
 359 Returns the PMC value of the element at index C<*key>.
 360
 361 =cut
 362
 363 */
 364
 365     VTABLE PMC *get_pmc_keyed(PMC *key) {
 366         const INTVAL k        = VTABLE_get_integer(INTERP, key);
 367         PMC   * const nextkey = key_next(INTERP, key);
 368         PMC   *box;
 369
 370         if (!nextkey)
 371             return SELF.get_pmc_keyed_int(k);
 372
 373         box = SELF.get_pmc_keyed_int(k);
 374
 375         if (box == NULL)
 376             box = Parrot_pmc_new(INTERP, enum_class_Undef);
 377
 378         return VTABLE_get_pmc_keyed(INTERP, box, nextkey);
 379     }
 380
 381 /*
 382
 383 =item C<void set_integer_native(INTVAL size)>
 384
 385 Sizes the array to C<size> elements. Can't be used to resize an
 386 array.
 387
 388 =cut
 389
 390 */
 391
 392     VTABLE void set_integer_native(INTVAL size) {
 393         int i;
 394         PMC **data;
 395
 396         if (PMC_size(SELF) && size)
 397             Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_OUT_OF_BOUNDS,
 398                     _("FixedPMCArray: Can't resize!"));
 399         if (!size)
 400             return;
 401
 402         if (size < 0)
 403             Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_OUT_OF_BOUNDS,
 404                     _("FixedPMCArray: Cannot set array size to a negative number"));
 405
 406         PMC_size(SELF) = size;
 407         data           = mem_gc_allocate_n_zeroed_typed(INTERP, size, PMC *);
 408
 409         for (i = 0; i < size; i++)
 410             data[i] = PMCNULL;
 411
 412         PMC_array(SELF) = data;
 413     }
 414
 415     VTABLE void set_pmc(PMC *value) {
 416         INTVAL size;
 417         INTVAL i;
 418
 419         if (SELF == value)
 420             return;
 421
 422         if (!VTABLE_does(interp, value, CONST_STRING(interp, "array")))
 423             Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_OUT_OF_BOUNDS,
 424                     _("Can't set self from this type"));
 425
 426         if (PMC_array(SELF))
 427             mem_gc_free(INTERP, PMC_array(SELF));
 428
 429         size            = PMC_size(SELF) = VTABLE_elements(INTERP, value);
 430         PMC_array(SELF) = mem_gc_allocate_n_zeroed_typed(INTERP, size, PMC *);
 431
 432         for (i = 0; i < size; i++)
 433             (PMC_array(SELF))[i] = VTABLE_get_pmc_keyed_int(INTERP, value, i);
 434
 435         PObj_custom_mark_destroy_SETALL(SELF);
 436     }
 437 /*
 438
 439 =item C<void set_integer_keyed_int(INTVAL key, INTVAL value)>
 440
 441 Sets the integer value of the element at index C<key> to C<value>.
 442
 443 =cut
 444
 445 */
 446
 447     VTABLE void set_integer_keyed_int(INTVAL key, INTVAL value) {
 448         PMC * const val = Parrot_pmc_new(INTERP, Parrot_get_ctx_HLL_type(INTERP,
 449                     enum_class_Integer));
 450
 451         VTABLE_set_integer_native(INTERP, val, value);
 452         SELF.set_pmc_keyed_int(key, val);
 453     }
 454
 455 /*
 456
 457 =item C<void set_integer_keyed(PMC *key, INTVAL value)>
 458
 459 Sets the integer value of the element at index C<key> to C<value>.
 460
 461 =cut
 462
 463 */
 464
 465     VTABLE void set_integer_keyed(PMC *key, INTVAL value) {
 466         PMC * const val = Parrot_pmc_new(INTERP, Parrot_get_ctx_HLL_type(INTERP,
 467                     enum_class_Integer));
 468
 469         VTABLE_set_integer_native(INTERP, val, value);
 470
 471         /* Let set_pmc_keyed worry about multi keys */
 472         SELF.set_pmc_keyed(key, val);
 473     }
 474
 475 /*
 476
 477 =item C<void set_number_keyed_int(INTVAL key, FLOATVAL value)>
 478
 479 Sets the floating-point value of the element at index C<key> to
 480 C<value>.
 481
 482 =cut
 483
 484 */
 485
 486     VTABLE void set_number_keyed_int(INTVAL key, FLOATVAL value) {
 487         PMC * const val = Parrot_pmc_new(INTERP, Parrot_get_ctx_HLL_type(INTERP,
 488                     enum_class_Float));
 489
 490         VTABLE_set_number_native(INTERP, val, value);
 491         SELF.set_pmc_keyed_int(key, val);
 492     }
 493
 494 /*
 495
 496 =item C<void set_number_keyed(PMC *key, FLOATVAL value)>
 497
 498 Sets the floating-point value of the element at index C<key> to
 499 C<value>.
 500
 501 =cut
 502
 503 */
 504
 505     VTABLE void set_number_keyed(PMC *key, FLOATVAL value) {
 506         const INTVAL k        = VTABLE_get_integer(INTERP, key);
 507         PMC   * const nextkey = key_next(INTERP, key);
 508
 509         if (nextkey == NULL) {
 510             SELF.set_number_keyed_int(k, value);
 511         }
 512         else {
 513             PMC *box = SELF.get_pmc_keyed_int(k);
 514
 515             /* TT #1295: autovivify an Array and insert it in SELF */
 516             if (!box)
 517                 box = Parrot_pmc_new(INTERP, SELF.type());
 518
 519             VTABLE_set_number_keyed(INTERP, box, nextkey, value);
 520         }
 521     }
 522
 523 /*
 524
 525 =item C<void set_string_keyed_int(INTVAL key, STRING *value)>
 526
 527 Sets the Parrot string value of the element at index C<key> to C<value>.
 528
 529 =cut
 530
 531 */
 532
 533     VTABLE void set_string_keyed_int(INTVAL key, STRING *value) {
 534         PMC * const val = Parrot_pmc_new(INTERP, Parrot_get_ctx_HLL_type(INTERP,
 535                     enum_class_String));
 536
 537         VTABLE_set_string_native(INTERP, val, value);
 538         SELF.set_pmc_keyed_int(key, val);
 539     }
 540
 541 /*
 542
 543 =item C<void set_string_keyed(PMC *key, STRING *value)>
 544
 545 Sets the string value of the element at index C<key> to
 546 C<value>.
 547
 548 =cut
 549
 550 */
 551
 552     VTABLE void set_string_keyed(PMC *key, STRING *value) {
 553         PMC * const val = Parrot_pmc_new(INTERP, Parrot_get_ctx_HLL_type(INTERP,
 554                     enum_class_String));
 555
 556         VTABLE_set_string_native(INTERP, val, value);
 557
 558         /* Let set_pmc_keyed worry about multi keys */
 559         SELF.set_pmc_keyed(key, val);
 560     }
 561
 562 /*
 563
 564 =item C<void set_pmc_keyed_int(INTVAL key, PMC *src)>
 565
 566 Sets the PMC value of the element at index C<key> to C<*src>.
 567
 568 =cut
 569
 570 */
 571
 572     VTABLE void set_pmc_keyed_int(INTVAL key, PMC *src) {
 573         PMC **data;
 574
 575         if (key < 0 || key >= PMC_size(SELF))
 576             Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_OUT_OF_BOUNDS,
 577                 _("FixedPMCArray: index out of bounds!"));
 578
 579         data      = PMC_array(SELF);
 580         data[key] = src;
 581     }
 582
 583 /*
 584
 585 =item C<void set_pmc_keyed(PMC *key, PMC *value)>
 586
 587 Sets the PMC at index C<key> to C<value>.
 588
 589 =cut
 590
 591 */
 592
 593     VTABLE void set_pmc_keyed(PMC *key, PMC *value) {
 594         const INTVAL k = VTABLE_get_integer(INTERP, key);
 595         PMC   *nextkey = key_next(INTERP, key);
 596
 597         if (!nextkey) {
 598             SELF.set_pmc_keyed_int(k, value);
 599         }
 600         else {
 601             PMC *box = SELF.get_pmc_keyed_int(k);
 602
 603             /* TT #1295: autovivify an Array and insert it in SELF */
 604             if (!box)
 605                 box = Parrot_pmc_new(INTERP, SELF.type());
 606
 607             VTABLE_set_pmc_keyed(INTERP, box, nextkey, value);
 608         }
 609     }
 610
 611 /*
 612
 613 =item C<INTVAL is_equal(PMC *value)>
 614
 615 The C<==> operation. Compares two array to hold equal elements.
 616
 617 =cut
 618
 619 */
 620
 621     VTABLE INTVAL is_equal(PMC *value) {
 622         INTVAL j, n;
 623
 624         if (value->vtable->base_type != SELF->vtable->base_type)
 625             return 0;
 626
 627         n = SELF.elements();
 628
 629         if (VTABLE_elements(INTERP, value) != n)
 630             return 0;
 631
 632         for (j = 0; j < n; ++j) {
 633             PMC * const item1 = SELF.get_pmc_keyed_int(j);
 634             PMC * const item2 = VTABLE_get_pmc_keyed_int(INTERP, value, j);
 635
 636             if (item1 == item2)
 637                 continue;
 638
 639             if (item1->vtable->base_type == enum_class_Null
 640             ||  item2->vtable->base_type == enum_class_Null)
 641                 return 0;
 642
 643             if (!VTABLE_is_equal(interp, item1, item2))
 644                 return 0;
 645         }
 646
 647         return 1;
 648     }
 649
 650
 651 /*
 652
 653 =item C<PMC *get_iter()>
 654
 655 Return a new iterator for SELF.
 656
 657 =cut
 658
 659 */
 660
 661     VTABLE PMC *get_iter() {
 662         return Parrot_pmc_new_init(INTERP, enum_class_ArrayIterator, SELF);
 663     }
 664
 665 /*
 666
 667 =item C<INTVAL exists_keyed_int(INTVAL key)>
 668
 669 =item C<INTVAL exists_keyed_int(PMC *key)>
 670
 671 Returns TRUE is the element at C<key> exists; otherwise returns false.
 672
 673 =cut
 674
 675 */
 676     VTABLE INTVAL exists_keyed_int(INTVAL key) {
 677         PMC **data;
 678         if (key < 0 || key >= PMC_size(SELF))
 679             Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_OUT_OF_BOUNDS,
 680                 _("FixedPMCArray: index out of bounds!"));
 681
 682         data = PMC_array(SELF);
 683         return !PMC_IS_NULL(data[key]);
 684     }
 685
 686     VTABLE INTVAL exists_keyed(PMC *key) {
 687         const INTVAL ix = VTABLE_get_integer(INTERP, key);
 688         return SELF.exists_keyed_int(ix);
 689     }
 690
 691 /*
 692
 693 =item C<void splice(PMC *value, INTVAL offset, INTVAL count)>
 694
 695 Replaces C<count> elements starting at C<offset> with the elements in C<value>.
 696
 697 If C<count> is 0 then the elements in C<value> will be inserted after
 698 C<offset>.
 699
 700 This throws an exception if any of the spliced in values are out of the range
 701 of this array.
 702
 703 =cut
 704
 705 */
 706
 707     VTABLE void splice(PMC *value, INTVAL offset, INTVAL count) {
 708         if (count + offset > PMC_size(SELF))
 709             Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_INVALID_OPERATION,
 710                 _("FixedPMCArray: index out of bounds!"));
 711
 712         for (count--; count >= 0; --count) {
 713             VTABLE_set_pmc_keyed_int(INTERP, SELF, offset + count, value);
 714         }
 715     }
 716
 717
 718 /*
 719
 720 =item C<void visit(PMC *info)>
 721
 722 This is used by freeze/thaw to visit the contents of the array.
 723
 724 C<*info> is the visit info, (see F<include/parrot/pmc_freeze.h>).
 725
 726 =item C<void freeze(PMC *info)>
 727
 728 Used to archive the array.
 729
 730 =item C<void thaw(PMC *info)>
 731
 732 Used to unarchive the array.
 733
 734 =cut
 735
 736 */
 737
 738     VTABLE void visit(PMC *info) {
 739         INTVAL  i;
 740         const INTVAL n = VTABLE_elements(INTERP, SELF);
 741         PMC   **pos    = PMC_array(SELF);
 742
 743         for (i = 0; i < n; ++i, ++pos) {
 744             VISIT_PMC(INTERP, info, *pos);
 745         }
 746
 747         SUPER(info);
 748     }
 749
 750     VTABLE void freeze(PMC *info) {
 751         SUPER(info);
 752         VTABLE_push_integer(INTERP, info, VTABLE_elements(INTERP, SELF));
 753     }
 754
 755     VTABLE void thaw(PMC *info) {
 756         SUPER(info);
 757         SELF.set_integer_native(VTABLE_shift_integer(INTERP, info));
 758     }
 759
 760 /*
 761
 762 =item C<INTVAL defined_keyed_int(INTVAL key)>
 763
 764 Returns TRUE is the element at C<key> is defined; otherwise returns false.
 765
 766 =cut
 767
 768 */
 769
 770     VTABLE INTVAL defined_keyed_int(INTVAL key) {
 771         PMC * const val = SELF.get_pmc_keyed_int(key);
 772
 773         if (PMC_IS_NULL(val))
 774             return 0;
 775
 776         return VTABLE_defined(INTERP, val);
 777     }
 778
 779 /*
 780
 781 =item C<void mark(void)>
 782
 783 Mark the array.
 784
 785 =cut
 786
 787 */
 788
 789     VTABLE void mark() {
 790         PMC ** const data = PMC_array(SELF);
 791         INTVAL i;
 792
 793         if (!data)
 794             return;
 795
 796         for (i = PMC_size(SELF) - 1; i >= 0; --i)
 797             Parrot_gc_mark_PMC_alive(interp, data[i]);
 798     }
 799
 800
 801 }
 802
 803
 804 /*
 805
 806 =back
 807
 808 =head1 SEE ALSO
 809
 810 F<docs/pdds/pdd17_basic_types.pod>.
 811
 812 =cut
 813
 814 */
 815
 816 /*
 817  * Local variables:
 818  *   c-file-style: "parrot"
 819  * End:
 820  * vim: expandtab shiftwidth=4:
 821  */