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