src/pmc/fixedstringarray.pmc

   1 /*
   2 Copyright (C) 2001-2010, Parrot Foundation.
   3 $Id$
   4
   5 =head1 NAME
   6
   7 src/pmc/fixedstringarray.pmc - fixed size array for strings only
   8
   9 =head1 DESCRIPTION
  10
  11 This class, FixedStringArray, implements an array of fixed size which
  12 stores Parrot strings.
  13
  14 =head2 Functions
  15
  16 =over 4
  17
  18 =cut
  19
  20 */
  21
  22 pmclass FixedStringArray auto_attrs provides array {
  23     ATTR STRING **str_array; /* where the STRINGs are stored */
  24     ATTR UINTVAL  size;      /* element count */
  25
  26 /*
  27
  28 =back
  29
  30 =head2 Methods
  31
  32 =over 4
  33
  34 =item C<void init()>
  35
  36 Initializes the array.
  37
  38 =cut
  39
  40 */
  41
  42     VTABLE void init() {
  43         PObj_custom_mark_destroy_SETALL(SELF);
  44     }
  45
  46 /*
  47
  48 =item C<void init_int(INTVAL size)>
  49
  50 Initializes the array.
  51
  52 =cut
  53
  54 */
  55
  56     VTABLE void init_int(INTVAL size) {
  57         if (size < 0)
  58             Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_OUT_OF_BOUNDS,
  59                 _("FixedStringArray: Cannot set array size to a negative number (%d)"), size);
  60         SET_ATTR_size(INTERP, SELF, size);
  61         SET_ATTR_str_array(INTERP, SELF, mem_gc_allocate_n_zeroed_typed(INTERP, size, STRING *));
  62         PObj_custom_mark_destroy_SETALL(SELF);
  63     }
  64
  65
  66 /*
  67
  68 =item C<void destroy()>
  69
  70 Destroys the array.
  71
  72 =cut
  73
  74 */
  75
  76     VTABLE void destroy() {
  77
  78         STRING **str_array;
  79
  80         GET_ATTR_str_array(INTERP, SELF, str_array);
  81
  82         if (str_array)
  83             mem_gc_free(INTERP, str_array);
  84     }
  85
  86 /*
  87
  88 =item C<PMC *clone()>
  89
  90 Creates and returns a copy of the array.
  91
  92 =cut
  93
  94 */
  95
  96     VTABLE PMC *clone() {
  97
  98         STRING    **my_str_array, **dest_str_array;
  99         PMC        *const dest = Parrot_pmc_new(INTERP, SELF->vtable->base_type);
 100
 101         GET_ATTR_str_array(INTERP, SELF, my_str_array);
 102
 103         if (my_str_array) {
 104             INTVAL size;
 105             size_t mem_size;
 106
 107             GET_ATTR_size(INTERP, SELF, size);
 108             mem_size = size * sizeof (STRING *);
 109
 110             dest_str_array = mem_gc_allocate_n_zeroed_typed(INTERP, size, STRING *);
 111             mem_sys_memcopy(dest_str_array, my_str_array, mem_size);
 112             SET_ATTR_str_array(INTERP, dest, dest_str_array);
 113             SET_ATTR_size(INTERP, dest, size);
 114
 115             PObj_custom_mark_destroy_SETALL(dest);
 116         }
 117
 118         return dest;
 119     }
 120
 121 /*
 122
 123 =item C<void mark()>
 124
 125 Marks the array as live.
 126
 127 =cut
 128
 129 */
 130
 131     VTABLE void mark() {
 132
 133         STRING **str_array;
 134         GET_ATTR_str_array(INTERP, SELF, str_array);
 135
 136         if (str_array) {
 137             UINTVAL size, i;
 138             GET_ATTR_size(INTERP, SELF, size);
 139
 140             for (i = 0; i < size; i++) {
 141                 Parrot_gc_mark_STRING_alive(INTERP, str_array[i]);
 142             }
 143         }
 144     }
 145
 146 /*
 147
 148 =item C<INTVAL get_bool()>
 149
 150 Returns 1 if the array has any elements; otherwise, returns 0.
 151 Since this is a fixed size array, C<get_bool> will always
 152 return true once the array has been initialized and had its
 153 size set by C<set_integer_native>.
 154
 155 =cut
 156
 157 */
 158     VTABLE INTVAL get_bool() {
 159         const INTVAL size = SELF.elements();
 160         return (INTVAL)(size != 0);
 161     }
 162
 163 /*
 164
 165 =item C<PMC *get_iter()>
 166
 167 Gets an iterator for the array.
 168
 169 =cut
 170
 171 */
 172     VTABLE PMC *get_iter() {
 173         return Parrot_pmc_new_init(INTERP, enum_class_ArrayIterator, SELF);
 174     }
 175
 176 /*
 177
 178 =item C<INTVAL elements()>
 179
 180 Returns the number of elements in the array.
 181
 182 =cut
 183
 184 */
 185
 186     VTABLE INTVAL elements() {
 187         UINTVAL size;
 188         GET_ATTR_size(INTERP, SELF, size);
 189         return size;
 190     }
 191
 192 /*
 193
 194 =item C<INTVAL get_integer()>
 195
 196 Returns the number of elements in the array.
 197
 198 =cut
 199
 200 */
 201
 202     VTABLE INTVAL get_integer() {
 203         return SELF.elements();
 204     }
 205
 206 /*
 207
 208 =item C<FLOATVAL get_number()>
 209
 210 Returns the number of elements in the array.
 211
 212 =cut
 213
 214 */
 215
 216     VTABLE FLOATVAL get_number() {
 217         const INTVAL e = SELF.elements();
 218         return (FLOATVAL)e;
 219     }
 220
 221 /*
 222
 223 =item C<INTVAL get_integer_keyed_int(INTVAL key)>
 224
 225 Returns the integer value of the element at index C<key>.
 226
 227 =cut
 228
 229 */
 230
 231     VTABLE INTVAL get_integer_keyed_int(INTVAL key) {
 232         STRING * const element = SELF.get_string_keyed_int(key);
 233         return Parrot_str_to_int(interp, element);
 234     }
 235
 236 /*
 237
 238 =item C<INTVAL get_integer_keyed(PMC *key)>
 239
 240 Returns the integer value of the element at index C<*key>.
 241
 242 =cut
 243
 244 */
 245
 246     VTABLE INTVAL get_integer_keyed(PMC *key) {
 247         /* simple int keys only */
 248         const INTVAL k = VTABLE_get_integer(INTERP, key);
 249         return SELF.get_integer_keyed_int(k);
 250     }
 251
 252
 253 /*
 254
 255 =item C<FLOATVAL get_number_keyed_int(INTVAL key)>
 256
 257 Returns the floating-point value of the element at index C<key>.
 258
 259 =cut
 260
 261 */
 262
 263     VTABLE FLOATVAL get_number_keyed_int(INTVAL key) {
 264         STRING * const element = SELF.get_string_keyed_int(key);
 265         return Parrot_str_to_num(interp, element);
 266     }
 267
 268 /*
 269
 270 =item C<FLOATVAL get_number_keyed(PMC *key)>
 271
 272 Returns the floating-point value of the element at index C<*key>.
 273
 274 =cut
 275
 276 */
 277
 278     VTABLE FLOATVAL get_number_keyed(PMC *key) {
 279         const INTVAL k = VTABLE_get_integer(INTERP, key);
 280         return SELF.get_number_keyed_int(k);
 281     }
 282
 283 /*
 284
 285 =item C<STRING *get_string_keyed_int(INTVAL key)>
 286
 287 Returns the Parrot string value of the element at index C<key>.
 288
 289 =cut
 290
 291 */
 292
 293     VTABLE STRING *get_string_keyed_int(INTVAL key) {
 294         STRING **str_array;
 295         UINTVAL  size;
 296
 297         GET_ATTR_size(INTERP, SELF, size);
 298         if (key < 0 || (UINTVAL)key >= size)
 299             Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_OUT_OF_BOUNDS,
 300                 "FixedStringArray: index out of bounds!");
 301
 302         GET_ATTR_str_array(INTERP, SELF, str_array);
 303         return str_array[key];
 304     }
 305
 306 /*
 307
 308 =item C<STRING *get_string_keyed(PMC *key)>
 309
 310 Returns the Parrot string value of the element at index C<*key>.
 311
 312 =cut
 313
 314 */
 315
 316     VTABLE STRING *get_string_keyed(PMC *key) {
 317         const INTVAL k = VTABLE_get_integer(INTERP, key);
 318         return SELF.get_string_keyed_int(k);
 319     }
 320
 321
 322 /*
 323
 324 =item C<PMC *get_pmc_keyed_int(INTVAL key)>
 325
 326 Returns the PMC value of the element at index C<key>.
 327
 328 =cut
 329
 330 */
 331
 332     VTABLE PMC *get_pmc_keyed_int(INTVAL key) {
 333         PMC    * const ret = Parrot_pmc_new(INTERP, enum_class_String);
 334         STRING * const val = SELF.get_string_keyed_int(key);
 335
 336         VTABLE_set_string_native(INTERP, ret, val);
 337         return ret;
 338     }
 339
 340 /*
 341
 342 =item C<PMC *get_pmc_keyed(PMC *key)>
 343
 344 Returns the PMC value of the element at index C<*key>.
 345
 346 =cut
 347
 348 */
 349
 350     VTABLE PMC *get_pmc_keyed(PMC *key) {
 351         const INTVAL k = VTABLE_get_integer(INTERP, key);
 352         return SELF.get_pmc_keyed_int(k);
 353     }
 354
 355 /*
 356
 357 =item C<void set_integer_native(INTVAL size)>
 358
 359 Sets the size of the array to C<size> elements. Once the array
 360 has been given an initial size, attempts to resize it will
 361 cause an exception to be thrown.
 362
 363 =cut
 364
 365 */
 366
 367     VTABLE void set_integer_native(INTVAL new_size) {
 368
 369         UINTVAL  old_size;
 370         GET_ATTR_size(INTERP, SELF, old_size);
 371
 372         if (old_size || new_size < 1)
 373             Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_OUT_OF_BOUNDS,
 374                 "FixedStringArray: Can't resize!");
 375
 376         SET_ATTR_size(INTERP, SELF, new_size);
 377         SET_ATTR_str_array(INTERP, SELF,
 378                 mem_gc_allocate_n_zeroed_typed(INTERP, new_size, STRING*));
 379
 380         PObj_custom_mark_destroy_SETALL(SELF);
 381     }
 382
 383 /*
 384
 385 =item C<void set_integer_keyed_int(INTVAL key, INTVAL value)>
 386
 387 Sets the integer value of the element at index C<key> to C<value>.
 388
 389 =cut
 390
 391 */
 392
 393     VTABLE void set_integer_keyed_int(INTVAL key, INTVAL value) {
 394         STRING *val = Parrot_str_from_int(interp, value);
 395         SELF.set_string_keyed_int(key, val);
 396     }
 397
 398 /*
 399
 400 =item C<void set_integer_keyed(PMC *key, INTVAL value)>
 401
 402 Sets the integer value of the element at index C<key> to C<value>.
 403
 404 =cut
 405
 406 */
 407
 408     VTABLE void set_integer_keyed(PMC *key, INTVAL value) {
 409         const INTVAL k = VTABLE_get_integer(INTERP, key);
 410         SELF.set_integer_keyed_int(k, value);
 411     }
 412
 413 /*
 414
 415 =item C<void set_number_keyed_int(INTVAL key, FLOATVAL value)>
 416
 417 Sets the floating-point value of the element at index C<key> to
 418 C<value>.
 419
 420 =cut
 421
 422 */
 423
 424     VTABLE void set_number_keyed_int(INTVAL key, FLOATVAL value) {
 425         STRING *val = Parrot_str_from_num(interp, value);
 426         SELF.set_string_keyed_int(key, val);
 427     }
 428
 429 /*
 430
 431 =item C<void set_number_keyed(PMC *key, FLOATVAL value)>
 432
 433 Sets the floating-point value of the element at index C<key> to
 434 C<value>.
 435
 436 =cut
 437
 438 */
 439
 440     VTABLE void set_number_keyed(PMC *key, FLOATVAL value) {
 441         const INTVAL k = VTABLE_get_integer(INTERP, key);
 442         SELF.set_number_keyed_int(k, value);
 443     }
 444
 445 /*
 446
 447 =item C<void set_string_keyed_int(INTVAL key, STRING *value)>
 448
 449 Sets the Parrot string value of the element at index C<key> to C<value>.
 450
 451 =cut
 452
 453 */
 454
 455     VTABLE void set_string_keyed_int(INTVAL key, STRING *value) {
 456         STRING **str_array;
 457
 458         if (key < 0 || key >= SELF.elements())
 459             Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_OUT_OF_BOUNDS,
 460                 "FixedStringArray: index out of bounds!");
 461
 462         GET_ATTR_str_array(INTERP, SELF, str_array);
 463
 464         str_array[key] = value;
 465     }
 466
 467 /*
 468
 469 =item C<void set_string_keyed(PMC *key, STRING *value)>
 470
 471 Sets the string value of the element at index C<key> to
 472 C<value>.
 473
 474 =cut
 475
 476 */
 477
 478     VTABLE void set_string_keyed(PMC *key, STRING *value) {
 479         const INTVAL k = VTABLE_get_integer(INTERP, key);
 480         SELF.set_string_keyed_int(k, value);
 481     }
 482
 483 /*
 484
 485 =item C<void set_pmc_keyed_int(INTVAL key, PMC *src)>
 486
 487 Sets the PMC value of the element at index C<key> to C<*src>.
 488
 489 =cut
 490
 491 */
 492
 493     VTABLE void set_pmc_keyed_int(INTVAL key, PMC *src) {
 494         STRING * const temp = VTABLE_get_string(INTERP, src);
 495         SELF.set_string_keyed_int(key, temp);
 496     }
 497
 498 /*
 499
 500 =item C<void set_pmc_keyed(PMC *key, PMC *value)>
 501
 502 Sets the string value of the element at index C<key> to
 503 C<value>.
 504
 505 =cut
 506
 507 */
 508
 509     VTABLE void set_pmc_keyed(PMC *key, PMC *value) {
 510         const INTVAL k = VTABLE_get_integer(INTERP, key);
 511         SELF.set_pmc_keyed_int(k, value);
 512     }
 513
 514 /*
 515
 516 =item C<STRING *get_string()>
 517
 518 =item C<STRING *get_repr()>
 519
 520 Returns the Parrot string representation C<key>.
 521
 522 =cut
 523
 524 */
 525     VTABLE STRING *get_string() {
 526         return STATICSELF.get_repr();
 527     }
 528
 529     VTABLE STRING *get_repr() {
 530
 531         STRING       *res = CONST_STRING(INTERP, "[ ");
 532         const INTVAL  n   = SELF.get_integer();
 533         INTVAL        j;
 534
 535         for (j = 0; j < n; ++j) {
 536             STRING * const val = SELF.get_string_keyed_int(j);
 537             res = Parrot_str_append(INTERP, res, CONST_STRING(INTERP, "\""));
 538             res = Parrot_str_append(INTERP, res, val);
 539             res = Parrot_str_append(INTERP, res, CONST_STRING(INTERP, "\""));
 540
 541             if (j < n - 1)
 542                 res = Parrot_str_append(INTERP, res, CONST_STRING(INTERP, ", "));
 543         }
 544
 545         res = Parrot_str_append(INTERP, res, CONST_STRING(INTERP, " ]"));
 546         return res;
 547     }
 548
 549
 550 /*
 551
 552 =item C<INTVAL is_equal(PMC *value)>
 553
 554 The C<==> operation. Compares two array to hold equal elements.
 555
 556 =cut
 557
 558 */
 559
 560     VTABLE INTVAL is_equal(PMC *value) {
 561         INTVAL j, n;
 562
 563         if (value->vtable->base_type != SELF->vtable->base_type)
 564             return 0;
 565
 566         n = SELF.elements();
 567
 568         if (VTABLE_elements(INTERP, value) != n)
 569             return 0;
 570
 571         for (j = 0; j < n; ++j) {
 572             STRING * const item1 = SELF.get_string_keyed_int(j);
 573             STRING * const item2 = VTABLE_get_string_keyed_int(INTERP, value, j);
 574
 575             if (item1 == item2)
 576                 continue;
 577
 578             if (item1 == NULL ||  item2 == NULL)
 579                 return 0;
 580
 581             if (!Parrot_str_equal(interp, item1, item2))
 582                 return 0;
 583         }
 584
 585         return 1;
 586     }
 587
 588 /*
 589
 590 =back
 591
 592 =head2 Freeze/thaw Interface
 593
 594 =over 4
 595
 596 =item C<void freeze(PMC *info)>
 597
 598 Used to archive the string.
 599
 600 =cut
 601
 602 */
 603     VTABLE void freeze(PMC *info) {
 604         STRING           **str_array;
 605         UINTVAL            size, i;
 606
 607         GET_ATTR_size(INTERP, SELF, size);
 608         GET_ATTR_str_array(INTERP, SELF, str_array);
 609         VTABLE_push_integer(INTERP, info, size);
 610
 611         for (i = 0; i < size; ++i)
 612             VTABLE_push_string(INTERP, info, str_array[i]);
 613     }
 614
 615 /*
 616
 617 =item C<void thaw(PMC *info)>
 618
 619 Used to unarchive the string.
 620
 621 =cut
 622
 623 */
 624     VTABLE void thaw(PMC *info) {
 625         UINTVAL  i, size;
 626         STRING **str_array;
 627
 628         SELF.init();
 629         SUPER(info);
 630
 631         size   = VTABLE_shift_integer(INTERP, info);
 632         SELF.set_integer_native((INTVAL)size);
 633         GET_ATTR_str_array(INTERP, SELF, str_array);
 634
 635         for (i = 0; i < size; ++i)
 636             str_array[i] = VTABLE_shift_string(INTERP, info);
 637     }
 638 }
 639
 640 /*
 641
 642 =back
 643
 644 =head1 SEE ALSO
 645
 646 F<docs/pdds/pdd17_basic_types.pod>.
 647
 648 =cut
 649
 650 */
 651
 652 /*
 653  * Local variables:
 654  *   c-file-style: "parrot"
 655  * End:
 656  * vim: expandtab shiftwidth=4:
 657  */