src/pmc/sarray.pmc

   1 /*
   2 Copyright (C) 2001-2008, The Perl Foundation.
   3 $Id$
   4
   5 =head1 NAME
   6
   7 src/pmc/sarray.pmc - Simple Array or Subroutine Parameter Array
   8
   9 =head1 DESCRIPTION
  10
  11 Simple Array or Subroutine Parameter Array PMC.
  12 SArray data are kept in an malloced array of C<HashEntry>s:
  13
  14 =over 4
  15
  16 =item 0 C<start_idx>
  17
  18 First index, for C<shift>.
  19
  20 =item 1 C<end_idx>
  21
  22 Last index, for C<push>.
  23
  24 =item 2...
  25
  26 Data.
  27
  28 =back
  29
  30 SArrays are fixed size, implying that the first operation on it must be
  31 setting its size, and that only the most important vtable methods are
  32 implemented.
  33
  34 Currently SArrays are used for:
  35
  36 =over 4
  37
  38 =item Global data per interpreter
  39
  40 =item Implementing lists, see F<src/list.c>.
  41
  42 =item Base class of the Exception PMC, see F<src/exception.pmc>
  43
  44 =back
  45
  46 =head2 Functions
  47
  48 =over 4
  49
  50 =cut
  51
  52 */
  53
  54 #include "parrot/parrot.h"
  55
  56 /*
  57
  58 =item C<static PARROT_INLINE INTVAL
  59 ret_int(PARROT_INTERP, const HashEntry *e)>
  60
  61 Processes C<*e>, returning the appropriate integer, or raising an
  62 exception if necessary.
  63
  64 =cut
  65
  66 */
  67
  68 static PARROT_INLINE INTVAL
  69 ret_int(PARROT_INTERP, const HashEntry *e)
  70 {
  71     switch (e->type) {
  72         case enum_hash_int:
  73             return UVal_int(e->val);
  74         case enum_hash_pmc:
  75             return VTABLE_get_integer(interp, UVal_pmc(e->val));
  76         default:
  77             break;
  78     }
  79
  80     real_exception(interp, NULL, E_IndexError, "SArray: Entry not an integer!");
  81 }
  82
  83 /*
  84
  85 =item C<static PARROT_INLINE FLOATVAL
  86 ret_num(PARROT_INTERP, const HashEntry *e)>
  87
  88 Processes C<*e>, returning the appropriate floating-point number, or
  89 raising an exception if necessary.
  90
  91 =cut
  92
  93 */
  94
  95 static PARROT_INLINE FLOATVAL
  96 ret_num(PARROT_INTERP, const HashEntry *e)
  97 {
  98     switch (e->type) {
  99         case enum_hash_num:
 100             return UVal_num(e->val);
 101         case enum_hash_pmc:
 102             return VTABLE_get_number(interp, UVal_pmc(e->val));
 103         default:
 104             break;
 105     }
 106
 107     real_exception(interp, NULL, E_IndexError, "SArray: Entry not a number!");
 108 }
 109
 110 /*
 111
 112 =item C<static PARROT_INLINE STRING *
 113 ret_string(PARROT_INTERP, HashEntry *e)>
 114
 115 Processes C<*e>, returning the appropriate Parrot string, or raising an
 116 exception if necessary.
 117
 118 =cut
 119
 120 */
 121
 122 static PARROT_INLINE STRING*
 123 ret_string(PARROT_INTERP, const HashEntry *e)
 124 {
 125     switch (e->type) {
 126         case enum_hash_string:
 127             return UVal_str(e->val);
 128         case enum_hash_pmc:
 129             return VTABLE_get_string(interp, UVal_pmc(e->val));
 130         default:
 131             break;
 132     }
 133
 134     real_exception(interp, NULL, E_IndexError, "SArray: Entry not a string!");
 135 }
 136
 137 /*
 138
 139 =item C<static PARROT_INLINE PMC *
 140 ret_pmc(PARROT_INTERP, const HashEntry *e)>
 141
 142 Processes C<*e>, returning the appropriate PMC, or raising an exception
 143 if necessary.
 144
 145 =cut
 146
 147 */
 148
 149 static PARROT_INLINE PMC*
 150 ret_pmc(PARROT_INTERP, const HashEntry *e)
 151 {
 152     PMC *ret;
 153     switch (e->type) {
 154         case enum_hash_int:
 155             ret = pmc_new(interp, enum_class_Undef);
 156             VTABLE_set_integer_native(interp, ret, UVal_int(e->val));
 157             return ret;
 158         case enum_hash_num:
 159             ret = pmc_new(interp, enum_class_Undef);
 160             VTABLE_set_number_native(interp, ret, UVal_num(e->val));
 161             return ret;
 162         case enum_hash_string:
 163             ret = pmc_new(interp, enum_class_Undef);
 164             VTABLE_set_string_native(interp, ret, UVal_str(e->val));
 165             return ret;
 166         case enum_hash_pmc:
 167             return UVal_pmc(e->val);
 168         default:
 169             real_exception(interp, NULL, E_IndexError, "SArray: Unknown entry!");
 170     }
 171 }
 172
 173 /*
 174
 175 =item C<static PARROT_INLINE HashEntry *
 176 shift_entry(PARROT_INTERP, PMC *self)>
 177
 178 Removes and returns the first element from the array.
 179
 180 =cut
 181
 182 */
 183
 184 static PARROT_INLINE HashEntry *
 185 shift_entry(PARROT_INTERP, PMC *self)
 186 {
 187     HashEntry   * const e    = (HashEntry *) PMC_data(self);
 188     INTVAL       start_index = UVal_int(e[0].val);
 189     const INTVAL end_index   = UVal_int(e[1].val);
 190     HashEntry   *ret;
 191
 192     if (start_index >= end_index)
 193         real_exception(interp, NULL, OUT_OF_BOUNDS,
 194             "SArray index out of bounds!");
 195
 196     ret = (HashEntry *) PMC_data(self) + (2 + start_index++);
 197
 198     /* Update the starting index */
 199     UVal_int(e[0].val) = start_index;
 200     return ret;
 201 }
 202
 203 /*
 204
 205 =item C<static PARROT_INLINE HashEntry *
 206 get_entry(PARROT_INTERP, PMC *self, INTVAL key)>
 207
 208 Returns the element for index C<key>.
 209
 210 =cut
 211
 212 */
 213
 214 static PARROT_INLINE HashEntry*
 215 get_entry(PARROT_INTERP, PMC *self, INTVAL key)
 216 {
 217     HashEntry   *e           = (HashEntry *)PMC_data(self);
 218     const INTVAL start_index = UVal_int(e[0].val);
 219     const INTVAL end_index   = UVal_int(e[1].val);
 220
 221     if (key < 0)
 222         key += end_index;
 223
 224     key += start_index;   /* lower bound if already shifted */
 225
 226     if (key < start_index || key >= end_index)
 227         real_exception(interp, NULL, OUT_OF_BOUNDS,
 228             "SArray index out of bounds!");
 229
 230     return (HashEntry *)PMC_data(self) + (2 + key);
 231 }
 232
 233 pmclass SArray need_ext provides array {
 234
 235 /*
 236
 237 =back
 238
 239 =head2 Methods
 240
 241 =over 4
 242
 243 =item C<void init()>
 244
 245 Initializes the array.
 246
 247 =cut
 248
 249 */
 250
 251     VTABLE void init() {
 252         PMC_int_val(SELF) = 0;
 253         PMC_data(SELF)    = NULL;
 254     }
 255
 256
 257 /*
 258
 259 =item C<void mark()>
 260
 261 Marks the array as live.
 262
 263 =cut
 264
 265 */
 266
 267     VTABLE void mark() {
 268         HashEntry *e;
 269         int        i, start, end;
 270
 271         if (!PMC_data(SELF))
 272             return;
 273
 274         e     = (HashEntry *)PMC_data(SELF);
 275         start = UVal_int(e[0].val);
 276         end   = UVal_int(e[1].val);
 277         e     = (HashEntry *)PMC_data(SELF) + (2 + start);
 278
 279         for (i = start; i < end; i++, e++) {
 280             switch (e->type) {
 281                 case enum_hash_string:
 282                     if (UVal_str(e->val))
 283                         pobject_lives(INTERP, (PObj *)UVal_str(e->val));
 284                     break;
 285                 case enum_hash_pmc:
 286                     if (UVal_pmc(e->val))
 287                         pobject_lives(INTERP, (PObj *)UVal_pmc(e->val));
 288                     break;
 289                 default:
 290                     break;
 291             }
 292         }
 293     }
 294
 295 /*
 296
 297 =item C<void destroy()>
 298
 299 Destroys the array.
 300
 301 =cut
 302
 303 */
 304
 305     VTABLE void destroy() {
 306         if (PMC_data(SELF))
 307             mem_sys_free(PMC_data(SELF));
 308         PMC_data(SELF) = NULL;
 309     }
 310
 311 /*
 312
 313 =item C<PMC *clone()>
 314
 315 Creates and returns a copy of the array.
 316
 317 =cut
 318
 319 */
 320
 321     VTABLE PMC *clone() {
 322         HashEntry *e, *d;
 323         int i, start, end;
 324         INTVAL size;
 325         PMC * const dest = pmc_new(INTERP, SELF->vtable->base_type);
 326
 327         if (!PMC_data(SELF))
 328             return dest;
 329
 330         size              = PMC_int_val(SELF);
 331         PMC_int_val(dest) = size;
 332         PMC_data(dest)    = mem_allocate_n_zeroed_typed(2 + size, HashEntry);
 333
 334         e     = (HashEntry *)PMC_data(SELF);
 335         d     = (HashEntry *)PMC_data(dest);
 336         start = UVal_int(e[0].val);
 337         end   = UVal_int(e[1].val);
 338
 339         UVal_int(d[0].val) = start;
 340         UVal_int(d[1].val) = end;
 341
 342         e = (HashEntry *)PMC_data(SELF) + (2 + start);
 343         d = (HashEntry *)PMC_data(dest) + (2 + start);
 344
 345         for (i = start; i < end; i++, e++, d++) {
 346             d->type = e->type;
 347             switch (e->type) {
 348                 case enum_hash_int:
 349                     UVal_int(d->val) = UVal_int(e->val);
 350                     break;
 351                 case enum_hash_num:
 352                     UVal_num(d->val) = UVal_num(e->val);
 353                     break;
 354                 case enum_hash_string:
 355                     UVal_str(d->val) =
 356                         string_copy(INTERP, UVal_str(e->val));
 357                     break;
 358                 case enum_hash_pmc:
 359                     UVal_pmc(d->val) =
 360                         VTABLE_clone(INTERP, UVal_pmc(e->val));
 361                     break;
 362                 default:
 363                     break;
 364             }
 365         }
 366
 367         PObj_custom_mark_destroy_SETALL(dest);
 368         return dest;
 369     }
 370
 371 /*
 372
 373 =item C<INTVAL get_bool()>
 374
 375 Returns whether the array has any elements.
 376
 377 =cut
 378
 379 */
 380
 381     VTABLE INTVAL get_bool() {
 382         INTVAL size = SELF.elements();
 383         return (INTVAL)(size != 0);
 384     }
 385
 386 /*
 387
 388 =item C<INTVAL elements()>
 389
 390 =cut
 391
 392 */
 393
 394     VTABLE INTVAL elements() {
 395         HashEntry *e;
 396
 397         if (!PMC_data(SELF))
 398             return 0;
 399
 400         e = (HashEntry *)PMC_data(SELF);
 401         return UVal_int(e[1].val) - UVal_int(e[0].val);
 402     }
 403
 404 /*
 405
 406 =item C<INTVAL get_integer()>
 407
 408 Returns the number of elements in the array.
 409
 410 =cut
 411
 412 */
 413
 414     VTABLE INTVAL get_integer() {
 415         return SELF.elements();
 416     }
 417
 418 /*
 419
 420 =item C<INTVAL type_keyed_int(INTVAL key)>
 421
 422 Returns the type of the element at index C<key>.
 423
 424 =cut
 425
 426 */
 427
 428     VTABLE INTVAL type_keyed_int(INTVAL key) {
 429         HashEntry *e = get_entry(INTERP, SELF, key);
 430         return e->type;
 431     }
 432
 433 /*
 434
 435 =item C<INTVAL get_integer_keyed_int(INTVAL key)>
 436
 437 Returns the integer value of the element at index C<key>.
 438
 439 =cut
 440
 441 */
 442
 443     VTABLE INTVAL get_integer_keyed_int(INTVAL key) {
 444         HashEntry *e = get_entry(INTERP, SELF, key);
 445         return ret_int(INTERP, e);
 446     }
 447
 448 /*
 449
 450 =item C<INTVAL get_integer_keyed(PMC *key)>
 451
 452 Returns the integer value of the element at index C<*key>.
 453
 454 =cut
 455
 456 */
 457
 458     VTABLE INTVAL get_integer_keyed(PMC *key) {
 459         /* simple int keys only */
 460         INTVAL k = key_integer(INTERP, key);
 461         return SELF.get_integer_keyed_int(k);
 462     }
 463
 464 /*
 465
 466 =item C<INTVAL shift_integer()>
 467
 468 Removes the first element from the array and returns its integer value.
 469
 470 =cut
 471
 472 */
 473
 474     VTABLE INTVAL shift_integer() {
 475         HashEntry *ret = shift_entry(INTERP, SELF);
 476         return ret_int(INTERP, ret);
 477     }
 478
 479 /*
 480
 481 =item C<FLOATVAL get_number_keyed_int(INTVAL key)>
 482
 483 Returns the floating-point value of the element at index C<key>.
 484
 485 =cut
 486
 487 */
 488
 489     VTABLE FLOATVAL get_number_keyed_int(INTVAL key) {
 490         HashEntry *e = get_entry(INTERP, SELF, key);
 491         return ret_num(INTERP, e);
 492     }
 493
 494 /*
 495
 496 =item C<FLOATVAL get_number_keyed(PMC *key)>
 497
 498 Returns the floating-point value of the element at index C<*key>.
 499
 500 =cut
 501
 502 */
 503
 504     VTABLE FLOATVAL get_number_keyed(PMC *key) {
 505         INTVAL k = key_integer(INTERP, key);
 506         return SELF.get_number_keyed_int(k);
 507     }
 508
 509 /*
 510
 511 =item C<FLOATVAL shift_float()>
 512
 513 Removes the first element from the array and returns its floating-point
 514 value.
 515
 516 =cut
 517
 518 */
 519
 520     VTABLE FLOATVAL shift_float() {
 521         HashEntry *ret = shift_entry(INTERP, SELF);
 522         return ret_num(INTERP, ret);
 523     }
 524
 525 /*
 526
 527 =item C<STRING *get_string_keyed_int(INTVAL key)>
 528
 529 Returns the Parrot string value of the element at index C<key>.
 530
 531 =cut
 532
 533 */
 534
 535     VTABLE STRING *get_string_keyed_int(INTVAL key) {
 536         HashEntry *e = get_entry(INTERP, SELF, key);
 537         return ret_string(INTERP, e);
 538     }
 539
 540 /*
 541
 542 =item C<STRING *get_string_keyed(PMC *key)>
 543
 544 Returns the Parrot string value of the element at index C<*key>.
 545
 546 =cut
 547
 548 */
 549
 550     VTABLE STRING *get_string_keyed(PMC *key) {
 551         INTVAL k = key_integer(INTERP, key);
 552         return SELF.get_string_keyed_int(k);
 553     }
 554
 555 /*
 556
 557 =item C<STRING *shift_string()>
 558
 559 Removes the first element from the array and returns its Parrot string
 560 value.
 561
 562 =cut
 563
 564 */
 565
 566     VTABLE STRING *shift_string() {
 567         HashEntry *ret = shift_entry(INTERP, SELF);
 568         return ret_string(INTERP, ret);
 569     }
 570
 571 /*
 572
 573 =item C<PMC *get_pmc_keyed_int(INTVAL key)>
 574
 575 Returns the PMC value of the element at index C<key>.
 576
 577 =cut
 578
 579 */
 580
 581     VTABLE PMC *get_pmc_keyed_int(INTVAL key) {
 582         HashEntry *e = get_entry(INTERP, SELF, key);
 583         return ret_pmc(INTERP, e);
 584     }
 585
 586 /*
 587
 588 =item C<PMC *get_pmc_keyed(PMC *key)>
 589
 590 Returns the PMC value of the element at index C<*key>.
 591
 592 =cut
 593
 594 */
 595
 596     VTABLE PMC *get_pmc_keyed(PMC *key) {
 597         INTVAL k = key_integer(INTERP, key);
 598         return SELF.get_pmc_keyed_int(k);
 599     }
 600
 601 /*
 602
 603 =item C<PMC *shift_pmc()>
 604
 605 Removes the first element from the array and returns its PMC value.
 606
 607 =cut
 608
 609 */
 610
 611     VTABLE PMC *shift_pmc() {
 612         HashEntry *ret = shift_entry(INTERP, SELF);
 613         return ret_pmc(INTERP, ret);
 614     }
 615
 616 /*
 617
 618 =item C<void set_integer_native(INTVAL size)>
 619
 620 Resizes the array to C<size> elements.
 621
 622 =cut
 623
 624 */
 625
 626     VTABLE void set_integer_native(INTVAL size) {
 627         if (PMC_int_val(SELF))
 628             real_exception(interp, NULL, E_IndexError, "SArray: Can't resize!");
 629
 630         PMC_int_val(SELF) = size;
 631
 632         /* Probably ought to actually copy this... */
 633
 634         if (PMC_data(SELF))
 635           mem_sys_free(PMC_data(SELF));
 636
 637         PMC_data(SELF) = mem_allocate_n_zeroed_typed(2 + size, HashEntry);
 638         PObj_custom_mark_destroy_SETALL(SELF);
 639     }
 640
 641 /*
 642
 643 =item C<void set_integer_keyed_int(INTVAL key, INTVAL value)>
 644
 645 Sets the integer value of the element at index C<key> to C<value>.
 646
 647 =cut
 648
 649 */
 650
 651     VTABLE void set_integer_keyed_int(INTVAL key, INTVAL value) {
 652         HashEntry *e;
 653
 654         if (key < 0 || key >= PMC_int_val(SELF))
 655             real_exception(interp, NULL, E_IndexError, "SArray index out of bounds!");
 656
 657         e                = (HashEntry *)PMC_data(SELF) + (2 + key);
 658         e->type          = enum_hash_int;
 659         UVal_int(e->val) = value;
 660         e                = (HashEntry *)PMC_data(SELF) + 1;
 661
 662         if (key >= UVal_int(e->val))
 663             UVal_int(e->val) = key + 1;
 664     }
 665
 666 /*
 667
 668 =item C<void push_integer(INTVAL value)>
 669
 670 Adds an element with integer value C<value> to the end of the array.
 671
 672 =cut
 673
 674 */
 675
 676     VTABLE void push_integer(INTVAL value) {
 677         HashEntry *e;
 678         INTVAL     nextix;
 679
 680         if (!PMC_data(SELF))
 681             real_exception(interp, NULL, E_IndexError, "SArray index out of bounds!");
 682
 683         e      = (HashEntry *)PMC_data(SELF) + 1;
 684         nextix = UVal_int(e->val);
 685
 686         SELF.set_integer_keyed_int(nextix, value);
 687     }
 688
 689 /*
 690
 691 =item C<void set_number_keyed_int(INTVAL key, FLOATVAL value)>
 692
 693 Sets the floating-point value of the element at index C<key> to
 694 C<value>.
 695
 696 =cut
 697
 698 */
 699
 700     VTABLE void set_number_keyed_int(INTVAL key, FLOATVAL value) {
 701         HashEntry *e;
 702
 703         if (key < 0 || key >= PMC_int_val(SELF))
 704             real_exception(interp, NULL, E_IndexError, "SArray index out of bounds!");
 705
 706         e                = (HashEntry *)PMC_data(SELF) + (2 + key);
 707         e->type          = enum_hash_num;
 708         UVal_num(e->val) = value;
 709         e                = (HashEntry *)PMC_data(SELF) + 1;
 710
 711         if (key >= UVal_int(e->val))
 712             UVal_int(e->val) = key + 1;
 713     }
 714
 715 /*
 716
 717 =item C<void push_float(FLOATVAL value)>
 718
 719 Adds an element with floating-point value C<value> to the end of the array.
 720
 721 =cut
 722
 723 */
 724
 725     VTABLE void push_float(FLOATVAL value) {
 726         HashEntry *e;
 727         INTVAL     nextix;
 728
 729         if (!PMC_data(SELF))
 730             real_exception(interp, NULL, E_IndexError, "SArray index out of bounds!");
 731
 732         e      = (HashEntry *) PMC_data(SELF) + 1;
 733         nextix = UVal_int(e->val);
 734
 735         SELF.set_number_keyed_int(nextix, value);
 736     }
 737
 738 /*
 739
 740 =item C<void set_string_keyed_int(INTVAL key, STRING *value)>
 741
 742 Sets the Parrot string value of the element at index C<key> to C<value>.
 743
 744 =cut
 745
 746 */
 747
 748     VTABLE void set_string_keyed_int(INTVAL key, STRING *value) {
 749         HashEntry *e;
 750
 751         if (key < 0 || key >= PMC_int_val(SELF))
 752             real_exception(interp, NULL, E_IndexError, "SArray index out of bounds!");
 753
 754         e                = (HashEntry *)PMC_data(SELF) + (2 + key);
 755         e->type          = enum_hash_string;
 756         UVal_str(e->val) = value;
 757         e                = (HashEntry *)PMC_data(SELF) + 1;
 758
 759         if (key >= UVal_int(e->val))
 760             UVal_int(e->val) = key + 1;
 761     }
 762
 763 /*
 764
 765 =item C<void push_string(STRING *value)>
 766
 767 Adds an element with Parrot string value C<*value> to the end of the
 768 array.
 769
 770 =cut
 771
 772 */
 773
 774     VTABLE void push_string(STRING *value) {
 775         HashEntry *e;
 776         INTVAL     nextix;
 777
 778         if (!PMC_data(SELF))
 779             real_exception(interp, NULL, E_IndexError,
 780                     "SArray index out of bounds!");
 781
 782         e      = (HashEntry *)PMC_data(SELF) + 1;
 783         nextix = UVal_int(e->val);
 784
 785         SELF.set_string_keyed_int(nextix, value);
 786     }
 787
 788 /*
 789
 790 =item C<void set_pmc_keyed_int(INTVAL key, PMC *src)>
 791
 792 Sets the PMC value of the element at index C<key> to C<*src>.
 793
 794 =cut
 795
 796 */
 797
 798     VTABLE void set_pmc_keyed_int(INTVAL key, PMC *src) {
 799         HashEntry *e;
 800
 801         if (key < 0 || key >= PMC_int_val(SELF))
 802             real_exception(interp, NULL, E_IndexError, "SArray index out of bounds!");
 803
 804         e       = (HashEntry *) PMC_data(SELF) + (2 + key);
 805         e->type = enum_hash_pmc;
 806
 807         GC_WRITE_BARRIER(INTERP, SELF, UVal_pmc(e->val), src);
 808         UVal_pmc(e->val) = src;
 809         e                = (HashEntry *) PMC_data(SELF) + 1;
 810
 811         if (key >= UVal_int(e->val))
 812             UVal_int(e->val) = key + 1;
 813     }
 814
 815 /*
 816
 817 =item C<void push_pmc(PMC *value)>
 818
 819 Adds an element with PMC value C<*value> to the end of the array.
 820
 821 =cut
 822
 823 */
 824
 825     void push_pmc(PMC *value) {
 826         HashEntry *e;
 827         INTVAL     nextix;
 828
 829         if (!PMC_data(SELF))
 830             real_exception(interp, NULL, E_IndexError,
 831                     "SArray index out of bounds!");
 832
 833         e      = (HashEntry *)PMC_data(SELF) + 1;
 834         nextix = UVal_int(e->val);
 835
 836         SELF.set_pmc_keyed_int(nextix, value);
 837     }
 838
 839 }
 840 /*
 841
 842 =back
 843
 844 =head1 SEE ALSO
 845
 846 F<docs/pdds/pdd03_calling_conventions.pod>.
 847
 848 =head1 HISTORY
 849
 850 Initial version 2003.07.04 by leo
 851
 852 2003.11.06 boemmels renamed HASH_ENTRY to HashEntry
 853
 854 =cut
 855
 856 */
 857
 858 /*
 859  * Local variables:
 860  *   c-file-style: "parrot"
 861  * End:
 862  * vim: expandtab shiftwidth=4:
 863  */