src/pmc/fixedbooleanarray.pmc

   1 /*
   2 Copyright (C) 2001-2010, Parrot Foundation.
   3 $Id$
   4
   5 =head1 NAME
   6
   7 src/pmc/fixedbooleanarray.pmc - fixed size array for booleans only
   8
   9 =head1 DESCRIPTION
  10
  11 The C<FixedBooleanArray> PMC implements an array of fixed size, which
  12 stores booleans.  It uses the C<Boolean> PMC for all conversions.  The
  13 C<FixedBooleanArray> PMC is extended by the C<ResizableBooleanArray>
  14 PMC.
  15
  16 =head2 Functions
  17
  18 =over 4
  19
  20 =item C<static UINTVAL get_size_in_bytes(UINTVAL size)>
  21
  22 Auxiliar function to avoid repeating the size evaluation.
  23
  24 =cut
  25
  26 */
  27
  28 #define BITS_PER_CHAR 8
  29
  30 PARROT_INLINE
  31 static UINTVAL
  32 get_size_in_bytes(UINTVAL size)
  33 {
  34     return (size + BITS_PER_CHAR - 1) / BITS_PER_CHAR;
  35 }
  36
  37
  38 pmclass FixedBooleanArray auto_attrs provides array {
  39     ATTR UINTVAL         size;             /* # of bits this fba holds */
  40     ATTR UINTVAL         resize_threshold; /* max capacity before resizing */
  41     ATTR unsigned char * bit_array;        /* where the bits go */
  42
  43 /*
  44
  45 =back
  46
  47 =head2 Vtable functions
  48
  49 =over 4
  50
  51 =item C<void init()>
  52
  53 Initializes the array.
  54
  55 =cut
  56
  57 */
  58
  59     VTABLE void init() {
  60         PObj_custom_destroy_SET(SELF);
  61     }
  62
  63 /*
  64
  65 =item C<void init_int(INTVAL size)>
  66
  67 Initializes the array.
  68
  69 =cut
  70
  71 */
  72
  73     VTABLE void init_int(INTVAL size) {
  74         const size_t size_in_bytes = get_size_in_bytes(size);
  75
  76         if (size < 0)
  77             Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_OUT_OF_BOUNDS,
  78                 _("FixedBooleanArray: Cannot set array size to a negative number (%d)"), size);
  79
  80         SET_ATTR_size(INTERP, SELF, size);
  81         SET_ATTR_resize_threshold(INTERP, SELF, size_in_bytes * BITS_PER_CHAR);
  82         SET_ATTR_bit_array(INTERP, SELF, mem_gc_allocate_n_zeroed_typed(INTERP, size_in_bytes,
  83                                                                         unsigned char));
  84         PObj_custom_destroy_SET(SELF);
  85     }
  86
  87
  88 /*
  89
  90 =item C<void destroy()>
  91
  92 Destroys the array.
  93
  94 =cut
  95
  96 */
  97
  98     VTABLE void destroy() {
  99         unsigned char *bit_array;
 100         GET_ATTR_bit_array(INTERP, SELF, bit_array);
 101         if (bit_array)
 102             mem_gc_free(INTERP, bit_array);
 103     }
 104
 105 /*
 106
 107 =item C<PMC *clone()>
 108
 109 Creates and returns a copy of the array.
 110
 111 =cut
 112
 113 */
 114
 115     VTABLE PMC *clone() {
 116         unsigned char * my_bit_array, * clone_bit_array;
 117         UINTVAL         resize_threshold, size;
 118         PMC *   const   dest   = Parrot_pmc_new(INTERP, SELF->vtable->base_type);
 119
 120         GET_ATTR_bit_array(INTERP, SELF, my_bit_array);
 121         GET_ATTR_size(INTERP, SELF, size);
 122         GET_ATTR_resize_threshold(INTERP, SELF, resize_threshold);
 123
 124         if (my_bit_array) {
 125             const size_t size_in_bytes = get_size_in_bytes(resize_threshold);
 126
 127             SET_ATTR_size(INTERP, dest, size);
 128             SET_ATTR_resize_threshold(INTERP, dest, resize_threshold);
 129
 130             clone_bit_array = mem_gc_allocate_n_typed(INTERP, size_in_bytes, unsigned char);
 131             mem_sys_memcopy(clone_bit_array, my_bit_array, size_in_bytes);
 132
 133             SET_ATTR_bit_array(INTERP, dest, clone_bit_array);
 134         }
 135
 136         PObj_custom_destroy_SET(dest);
 137         return dest;
 138     }
 139
 140 /*
 141
 142 =item C<INTVAL get_bool()>
 143
 144 Returns whether the array has any elements (meaning been initialized, for a
 145 fixed sized array).
 146
 147 =cut
 148
 149 */
 150     VTABLE INTVAL get_bool() {
 151         return SELF.elements() ? 1 : 0;
 152     }
 153
 154 /*
 155
 156 =item C<INTVAL elements()>
 157
 158 =cut
 159
 160 */
 161
 162     VTABLE INTVAL elements() {
 163         UINTVAL size;
 164         GET_ATTR_size(INTERP, SELF, size);
 165         return size;
 166     }
 167
 168 /*
 169
 170 =item C<INTVAL get_integer()>
 171
 172 Returns the number of elements in the array.
 173
 174 =cut
 175
 176 */
 177
 178     VTABLE INTVAL get_integer() {
 179         return SELF.elements();
 180     }
 181
 182 /*
 183
 184 =item C<INTVAL get_integer_keyed_int(INTVAL key)>
 185
 186 Returns the integer value of the element at index C<key>.
 187
 188 =cut
 189
 190 */
 191
 192     VTABLE INTVAL get_integer_keyed_int(INTVAL key) {
 193         UINTVAL               size;
 194         const unsigned char * bit_array;
 195         GET_ATTR_bit_array(INTERP, SELF, bit_array);
 196         GET_ATTR_size(INTERP, SELF, size);
 197
 198         if (key < 0 || (UINTVAL)key >= size)
 199             Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_OUT_OF_BOUNDS,
 200                 "FixedBooleanArray: index out of bounds!");
 201
 202         return (bit_array[key / BITS_PER_CHAR] & (1 << (key % BITS_PER_CHAR))) ? 1 : 0;
 203     }
 204
 205 /*
 206
 207 =item C<INTVAL get_integer_keyed(PMC *key)>
 208
 209 Returns the integer value of the element at index C<*key>.
 210
 211 =cut
 212
 213 */
 214
 215     VTABLE INTVAL get_integer_keyed(PMC *key) {
 216         /* simple int keys only */
 217         const INTVAL k = VTABLE_get_integer(INTERP, key);
 218         return SELF.get_integer_keyed_int(k);
 219     }
 220
 221
 222 /*
 223
 224 =item C<FLOATVAL get_number_keyed_int(INTVAL key)>
 225
 226 Returns the floating-point value of the element at index C<key>.
 227
 228 =cut
 229
 230 */
 231
 232     VTABLE FLOATVAL get_number_keyed_int(INTVAL key) {
 233         const INTVAL i = SELF.get_integer_keyed_int(key);
 234         return (FLOATVAL)i;
 235     }
 236
 237 /*
 238
 239 =item C<FLOATVAL get_number_keyed(PMC *key)>
 240
 241 Returns the floating-point value of the element at index C<*key>.
 242
 243 =cut
 244
 245 */
 246
 247     VTABLE FLOATVAL get_number_keyed(PMC *key) {
 248         const INTVAL k = VTABLE_get_integer(INTERP, key);
 249         return SELF.get_number_keyed_int(k);
 250     }
 251
 252 /*
 253
 254 =item C<STRING *get_string()>
 255
 256 Returns the Parrot string representation of the array.
 257
 258 =cut
 259
 260 */
 261
 262     VTABLE STRING *get_string() {
 263         STRING *zero, *one;
 264         STRING *str   = NULL;
 265         UINTVAL i;
 266         UINTVAL elems = SELF.elements();
 267
 268         zero = CONST_STRING(INTERP, "0");
 269         one  = CONST_STRING(INTERP, "1");
 270
 271         for (i = 0; i < elems; i++) {
 272             if (SELF.get_integer_keyed_int((INTVAL)i))
 273                 str = Parrot_str_concat(INTERP, str, one, 0);
 274             else
 275                 str = Parrot_str_concat(INTERP, str, zero, 0);
 276         }
 277
 278         return str;
 279
 280     }
 281
 282 /*
 283
 284 =item C<STRING *get_string_keyed_int(INTVAL key)>
 285
 286 Returns the Parrot string value of the element at index C<key>.
 287
 288 =cut
 289
 290 */
 291
 292     VTABLE STRING *get_string_keyed_int(INTVAL key) {
 293         PMC * const val = SELF.get_pmc_keyed_int(key);
 294         return VTABLE_get_string(INTERP, val);
 295     }
 296
 297 /*
 298
 299 =item C<STRING *get_string_keyed(PMC *key)>
 300
 301 Returns the Parrot string value of the element at index C<*key>.
 302
 303 =cut
 304
 305 */
 306
 307     VTABLE STRING *get_string_keyed(PMC *key) {
 308         const INTVAL k = VTABLE_get_integer(INTERP, key);
 309         return SELF.get_string_keyed_int(k);
 310     }
 311
 312
 313 /*
 314
 315 =item C<PMC *get_pmc_keyed_int(INTVAL key)>
 316
 317 Returns the PMC value of the element at index C<key>.
 318
 319 =cut
 320
 321 */
 322
 323     VTABLE PMC *get_pmc_keyed_int(INTVAL key) {
 324         PMC  * const ret = Parrot_pmc_new(INTERP, enum_class_Boolean);
 325         const INTVAL val = SELF.get_integer_keyed_int(key);
 326         VTABLE_set_integer_native(INTERP, ret, val);
 327         return ret;
 328     }
 329
 330 /*
 331
 332 =item C<PMC *get_pmc_keyed(PMC *key)>
 333
 334 Returns the PMC value of the element at index C<*key>.
 335
 336 =cut
 337
 338 */
 339
 340     VTABLE PMC *get_pmc_keyed(PMC *key) {
 341         const INTVAL k = VTABLE_get_integer(INTERP, key);
 342         return SELF.get_pmc_keyed_int(k);
 343     }
 344
 345 /*
 346
 347 =item C<void set_integer_native(INTVAL size)>
 348
 349 Resizes the array to C<size> elements.
 350
 351 =cut
 352
 353 */
 354
 355     VTABLE void set_integer_native(INTVAL size) {
 356         const size_t size_in_bytes = get_size_in_bytes(size);
 357         UINTVAL old_size;
 358         unsigned char *bit_array;
 359
 360         GET_ATTR_size(INTERP, SELF, old_size);
 361
 362         if (old_size || size < 1)
 363             Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_OUT_OF_BOUNDS,
 364                 "FixedBooleanArray: Can't resize!");
 365
 366         SET_ATTR_size(INTERP, SELF, size);
 367         SET_ATTR_resize_threshold(INTERP, SELF, size_in_bytes * BITS_PER_CHAR);
 368         bit_array = mem_gc_allocate_n_typed(INTERP, size_in_bytes, unsigned char);
 369         memset(bit_array, 0, size_in_bytes);
 370         SET_ATTR_bit_array(INTERP, SELF, bit_array);
 371     }
 372
 373 /*
 374
 375 =item C<void set_integer_keyed_int(INTVAL key, INTVAL value)>
 376
 377 Sets the integer value of the element at index C<key> to C<value>.
 378
 379 =cut
 380
 381 */
 382
 383     VTABLE void set_integer_keyed_int(INTVAL key, INTVAL value) {
 384         UINTVAL size;
 385         unsigned char * bit_array;
 386         GET_ATTR_bit_array(INTERP, SELF, bit_array);
 387         GET_ATTR_size(INTERP, SELF, size);
 388
 389         if (key < 0 || (UINTVAL)key >= size)
 390             Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_OUT_OF_BOUNDS,
 391                 "FixedBooleanArray: index out of bounds!");
 392
 393         if (value)
 394             bit_array[key/BITS_PER_CHAR] |=  (1 << (key % BITS_PER_CHAR));
 395         else
 396             bit_array[key/BITS_PER_CHAR] &= ~(1 << (key % BITS_PER_CHAR));
 397     }
 398
 399 /*
 400
 401 =item C<void set_integer_keyed(PMC *key, INTVAL value)>
 402
 403 Sets the integer value of the element at index C<key> to C<value>.
 404
 405 =cut
 406
 407 */
 408
 409     VTABLE void set_integer_keyed(PMC *key, INTVAL value) {
 410         const INTVAL k = VTABLE_get_integer(INTERP, key);
 411         SELF.set_integer_keyed_int(k, value);
 412     }
 413
 414 /*
 415
 416 =item C<void set_number_keyed_int(INTVAL key, FLOATVAL value)>
 417
 418 Sets the floating-point value of the element at index C<key> to
 419 C<value>.
 420
 421 =cut
 422
 423 */
 424
 425     VTABLE void set_number_keyed_int(INTVAL key, FLOATVAL value) {
 426         SELF.set_integer_keyed_int(key, !FLOAT_IS_ZERO(value));
 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         INTVAL tempInt;
 457         PMC * const tempPMC = Parrot_pmc_new(INTERP, enum_class_Boolean);
 458
 459         VTABLE_set_string_native(INTERP, tempPMC, value);
 460         tempInt = VTABLE_get_integer(INTERP, tempPMC);
 461
 462         SELF.set_integer_keyed_int(key, tempInt);
 463     }
 464
 465 /*
 466
 467 =item C<void set_string_keyed(PMC *key, STRING *value)>
 468
 469 Sets the string value of the element at index C<key> to
 470 C<value>.
 471
 472 =cut
 473
 474 */
 475
 476     VTABLE void set_string_keyed(PMC *key, STRING *value) {
 477         const INTVAL k = VTABLE_get_integer(INTERP, key);
 478         SELF.set_string_keyed_int(k, value);
 479     }
 480
 481 /*
 482
 483 =item C<void set_pmc_keyed_int(INTVAL key, PMC *src)>
 484
 485 Sets the PMC value of the element at index C<key> to C<*src>.
 486
 487 =cut
 488
 489 */
 490
 491     VTABLE void set_pmc_keyed_int(INTVAL key, PMC *src) {
 492         const INTVAL tempInt = VTABLE_get_integer(INTERP, src);
 493         SELF.set_integer_keyed_int(key, tempInt);
 494     }
 495
 496 /*
 497
 498 =item C<void set_pmc_keyed(PMC *key, PMC *value)>
 499
 500 Sets the string value of the element at index C<key> to
 501 C<value>.
 502
 503 =cut
 504
 505 */
 506
 507     VTABLE void set_pmc_keyed(PMC *key, PMC *value) {
 508         const INTVAL k = VTABLE_get_integer(INTERP, key);
 509         SELF.set_pmc_keyed_int(k, value);
 510     }
 511
 512 /*
 513
 514 =item C<PMC *get_iter()>
 515
 516 Return a new iterator for SELF.
 517
 518 =cut
 519
 520 */
 521
 522     VTABLE PMC *get_iter() {
 523         return Parrot_pmc_new_init(INTERP, enum_class_ArrayIterator, SELF);
 524     }
 525
 526
 527
 528 /*
 529
 530 =back
 531
 532 =head2 Freeze/thaw Interface
 533
 534 =over 4
 535
 536 =item C<void freeze(PMC *info)>
 537
 538 Used to archive the string.
 539
 540 =cut
 541
 542 */
 543     VTABLE void freeze(PMC *info) {
 544         UINTVAL          size, resize_threshold;
 545         unsigned char  * bit_array;
 546         STRING   *       s;
 547         GET_ATTR_size(INTERP, SELF, size);
 548         GET_ATTR_resize_threshold(INTERP, SELF, resize_threshold);
 549         GET_ATTR_bit_array(INTERP, SELF, bit_array);
 550
 551         s = Parrot_str_new(INTERP, (char*)bit_array,
 552                 (resize_threshold / BITS_PER_CHAR));
 553
 554         VTABLE_push_integer(INTERP, info, size);
 555         VTABLE_push_string(INTERP, info, s);
 556     }
 557
 558 /*
 559
 560 =item C<void thaw(PMC *info)>
 561
 562 Used to unarchive the string.
 563
 564 =cut
 565
 566 */
 567     VTABLE void thaw(PMC *info) {
 568         SUPER(info);
 569
 570         {
 571             unsigned char * bit_array;
 572             UINTVAL         threshold;
 573             const INTVAL    size      = VTABLE_shift_integer(INTERP, info);
 574             STRING * const  s         = VTABLE_shift_string(INTERP, info);
 575
 576             bit_array = (unsigned char *)Parrot_str_to_cstring(INTERP, s);
 577             threshold = Parrot_str_byte_length(interp, s) * BITS_PER_CHAR;
 578
 579             SET_ATTR_size(INTERP, SELF, size);
 580             SET_ATTR_resize_threshold(INTERP, SELF, threshold);
 581             SET_ATTR_bit_array(INTERP, SELF, bit_array);
 582         }
 583     }
 584
 585 /*
 586
 587 =back
 588
 589 =head2 Methods
 590
 591 =over 4
 592
 593 =item C<METHOD fill(INTVAL fill)>
 594
 595 Sets all of the entires to true if fill is a true value, otherwise
 596 sets them all to false.
 597
 598 =cut
 599
 600 */
 601
 602     METHOD fill(INTVAL fill) {
 603         UINTVAL         size;
 604         unsigned char * bit_array;
 605         size_t          size_in_bytes;
 606
 607         GET_ATTR_bit_array(INTERP, SELF, bit_array);
 608         GET_ATTR_size(INTERP, SELF, size);
 609         size_in_bytes  = get_size_in_bytes(size);
 610
 611         if (size_in_bytes)
 612             memset(bit_array, fill ? 0xff : 0, size_in_bytes);
 613     }
 614 }
 615
 616 /*
 617
 618 =back
 619
 620 =head1 SEE ALSO
 621
 622 F<docs/pdds/pdd17_basic_types.pod>.
 623
 624 =cut
 625
 626 */
 627
 628 /*
 629  * Local variables:
 630  *   c-file-style: "parrot"
 631  * End:
 632  * vim: expandtab shiftwidth=4:
 633  */