src/pmc/unmanagedstruct.pmc

   1 /*
   2 Copyright (C) 2001-2008, The Perl Foundation.
   3 $Id$
   4
   5 =head1 NAME
   6
   7 src/pmc/unmanagedstruct.pmc - C struct with unmanaged memory
   8
   9 =head1 DESCRIPTION
  10
  11 PMC class to hold C C<struct>s that Parrot's not responsible for
  12 disposing of.
  13
  14 Buffer can be accessed using keyed assignments to PMC. Out of
  15 bounds access will very likely segfault.
  16
  17 =head2 Functions
  18
  19 =over 4
  20
  21 =cut
  22
  23 */
  24
  25 #include "parrot/parrot.h"
  26 #include "parrot/compiler.h"
  27
  28 static INTVAL key_2_idx(PARROT_INTERP, PMC *pmc, PMC *key);
  29 static size_t calc_offsets(PARROT_INTERP, PMC*, PMC *init, size_t toff);
  30
  31 /*
  32
  33 =item C<static char *
  34 char_offset_int(PARROT_INTERP, PMC *pmc, INTVAL ix, int *type)>
  35
  36 Returns the pointer for the element at index C<ix>, and sets the element
  37 type in C<*type>.
  38
  39 =cut
  40
  41 */
  42
  43 static char *
  44 char_offset_int(PARROT_INTERP, PMC *pmc, INTVAL ix, int *type)
  45 {
  46     size_t offs, n;
  47     ix *= 3;
  48
  49     if (!PMC_pmc_val(pmc))
  50         real_exception(interp, NULL, E_ValueError,
  51                 "Missing struct initializer");
  52
  53     n = (size_t)VTABLE_elements(interp, PMC_pmc_val(pmc));
  54
  55     if ((size_t)ix >= n)
  56         real_exception(interp, NULL, E_ValueError,
  57                 "Non existent elements in struct "
  58                 "ix = %d n=%d", (int)ix, (int)n);
  59
  60     /* use structure init */
  61     *type = (int) VTABLE_get_integer_keyed_int(interp,
  62         PMC_pmc_val(pmc), ix);
  63
  64     offs  = (size_t) VTABLE_get_integer_keyed_int(interp,
  65         PMC_pmc_val(pmc), ix + 2);
  66
  67     return ((char *)PMC_data(pmc)) + offs;
  68 }
  69
  70 /*
  71
  72 =item C<static INTVAL
  73 key_2_idx(PARROT_INTERP, PMC *pmc, PMC *key)>
  74
  75 Returns the index for the element associated with key C<*key>. Raises an
  76 exception if the key doesn't exist.
  77
  78 =cut
  79
  80 */
  81
  82 static INTVAL
  83 key_2_idx(PARROT_INTERP, PMC *pmc, PMC *key)
  84 {
  85     int ix = 0;
  86
  87     if (!PMC_pmc_val(pmc))
  88         real_exception(interp, NULL, E_ValueError,
  89                 "Missing struct initializer");
  90
  91     if (PObj_get_FLAGS(key) & KEY_string_FLAG) {
  92         PMC * const types = PMC_pmc_val(pmc);
  93
  94         if (types->vtable->base_type == enum_class_OrderedHash) {
  95             Hash       * const hash = (Hash *)PMC_struct_val(types);
  96             HashBucket * const b    = parrot_hash_get_bucket(interp, hash,
  97                 key_string(interp, key));
  98
  99             if (!b)
 100                 real_exception(interp, NULL, E_KeyError, "key doesn't exist");
 101
 102             ix = b - hash->bs;
 103         }
 104         else
 105             real_exception(interp, NULL, E_TypeError,
 106                     "unhandled type aggregate");
 107
 108         ix /= 3;
 109     }
 110     else
 111         ix = key_integer(interp, key);
 112
 113     return ix;
 114 }
 115
 116 /*
 117
 118 =item C<static char *
 119 char_offset_key(PARROT_INTERP, PMC *pmc, PMC *key, int *type)>
 120
 121 Returns the pointer for the element associated with key C<*key>, and
 122 sets the element type in C<*type>.
 123
 124 =cut
 125
 126 */
 127
 128 static char *
 129 char_offset_key(PARROT_INTERP, PMC *pmc, PMC *key, int *type)
 130 {
 131     size_t offs, count, size, max;
 132     int    ix;
 133     PMC   *next, *init;
 134     char  *p;
 135
 136 #ifdef STRUCT_DEBUG
 137     trace_key_dump(interp, key);
 138 #endif
 139
 140     ix   = key_2_idx(interp, pmc, key);
 141     next = key_next(interp, key);
 142     p    = char_offset_int(interp, pmc, ix, type);
 143     ix  *= 3;
 144
 145     if (!next)
 146         return p;
 147
 148     if (PObj_get_FLAGS(next) & KEY_integer_FLAG)
 149         count = key_integer(interp, next);
 150     else
 151         count = 1;
 152
 153     init = PMC_pmc_val(pmc);
 154     max  = (size_t)VTABLE_get_integer_keyed_int(interp, init, ix + 1);
 155
 156 #ifdef STRUCT_DEBUG
 157     PIO_eprintf(interp, " count = %d ix = %d max = %d\n",
 158             (int)count, (int)ix, (int)max);
 159 #endif
 160
 161     if (*type == enum_type_struct_ptr || *type == enum_type_struct) {
 162         /* the struct PMC is hanging off the initializer element
 163          * as property "_struct"
 164          */
 165         PMC * const ptr = VTABLE_get_pmc_keyed_int(interp, init, ix);
 166         init            = VTABLE_getprop(interp, ptr, CONST_STRING(interp, "_struct"));
 167
 168         PARROT_ASSERT(init &&
 169             (init->vtable->base_type == enum_class_UnManagedStruct ||
 170              init->vtable->base_type == enum_class_ManagedStruct));
 171
 172         /* array of structs */
 173         if (max > 1) {
 174             if (key_next(interp, next))
 175                 next = key_next(interp, next);
 176
 177             offs = PMC_int_val(init);
 178
 179 #ifdef STRUCT_DEBUG
 180             PIO_eprintf(interp, "offs = %d\n", (int)offs);
 181 #endif
 182
 183             p += offs * count;
 184         }
 185         if (init->vtable->base_type == enum_class_UnManagedStruct) {
 186             /* now point PMC_data of this struct to the real data */
 187             if (*type == enum_type_struct_ptr) {
 188                 /* that is either a pointer */
 189                 PARROT_ASSERT((PTR2INTVAL(p) & (PARROT_PTR_ALIGNMENT - 1)) == 0);
 190                 PMC_data(init) = *(void**)p;
 191             }
 192             else {
 193                 /* or just an offset for nested structs */
 194                 PMC_data(init) = p;
 195             }
 196         }
 197         else if (init->vtable->base_type == enum_class_ManagedStruct &&
 198             *type == enum_type_struct_ptr) {
 199             /* a nested struct pointer belonging to us
 200              * p is the location of the struct pointer in the
 201              * outer struct, the inner is at PMC_data(init)
 202              */
 203             PARROT_ASSERT((PTR2INTVAL(p) & (PARROT_PTR_ALIGNMENT - 1)) == 0);
 204             *(void **)p = PMC_data(init);
 205         }
 206
 207         return char_offset_key(interp, init, next, type);
 208     }
 209
 210     if (count >= max)
 211         real_exception(interp, NULL, E_LookupError,
 212                 "Non existent array element in struct: "
 213                 "count = %d max=%d", (int)count, (int)max);
 214     size = data_types[*type - enum_first_type].size;
 215     return p + count * size;
 216 }
 217
 218 /*
 219
 220 =item C<static INTVAL
 221 ret_int(PARROT_INTERP, const char *p, int type)>
 222
 223 Returns the element of type C<type> starting at C<*p> as an C<INTVAL>.
 224
 225 If, for example, C<char> or c<short> type size doesn't match, this will fail
 226 we need some more configure support for type sizes.
 227
 228 =cut
 229
 230 */
 231
 232 static INTVAL
 233 ret_int(PARROT_INTERP, const char *p, int type)
 234     __attribute__nonnull__(1);
 235
 236 static INTVAL
 237 ret_int(PARROT_INTERP, const char *p, int type)
 238 {
 239     switch (type) {
 240         case enum_type_INTVAL:
 241             return *(const INTVAL*) p;
 242
 243 #if INT_SIZE == 4
 244         case enum_type_int32:
 245         case enum_type_uint32:
 246 #endif
 247
 248 #if INT_SIZE == 8
 249         case enum_type_int64:
 250         case enum_type_uint64:
 251 #endif
 252
 253         case enum_type_int:
 254             return *(const int *)p;
 255
 256 #if (LONG_SIZE == 4) && !(INT_SIZE == 4) /* Unlikely combination. */
 257         case enum_type_int32:
 258         case enum_type_uint32:
 259 #endif
 260
 261 #if (LONG_SIZE == 8) && !(INT_SIZE == 8)
 262         case enum_type_int64:
 263         case enum_type_uint64:
 264 #endif
 265
 266         case enum_type_long:
 267         case enum_type_ulong:
 268             return *(const long *)p;
 269
 270 #if SHORT_SIZE == 2
 271         case enum_type_int16:
 272         case enum_type_uint16:
 273 #endif
 274
 275         /* If SHORT_SIZE != 2 getting int16s requires extra tricks. */
 276         case enum_type_short:
 277             return *(const short *)p;
 278         case enum_type_uint8:
 279         case enum_type_uchar:
 280         {
 281             const unsigned char *uc = (const unsigned char *)p;
 282             return (INTVAL)*uc;
 283         }
 284         case enum_type_int8:
 285         case enum_type_char:
 286             return *p;
 287         default:
 288             real_exception(interp, NULL, 1,
 289                 "returning unhandled int type in struct");
 290     }
 291 }
 292
 293 /*
 294
 295 =item C<static FLOATVAL
 296 ret_float(PARROT_INTERP, const char *p, int type)>
 297
 298 Returns the element of type C<type> starting at C<*p> as a C<FLOATVAL>.
 299
 300 =cut
 301
 302 */
 303
 304 static FLOATVAL
 305 ret_float(PARROT_INTERP, const char *p, int type)
 306     __attribute__nonnull__(1);
 307
 308 static FLOATVAL
 309 ret_float(PARROT_INTERP, const char *p, int type)
 310 {
 311     switch (type) {
 312         case enum_type_FLOATVAL:
 313             return (FLOATVAL) *(const FLOATVAL *)p;
 314         case enum_type_float:
 315             return (FLOATVAL) *(const float *)p;
 316         case enum_type_double:
 317             return (FLOATVAL) *(const double *)p;
 318         default:
 319             real_exception(interp, NULL, 1,
 320                 "returning unhandled float type in struct");
 321     }
 322 }
 323
 324 /*
 325
 326 =item C<static STRING*
 327 ret_string(PARROT_INTERP, char *p, int type)>
 328
 329 Returns the element of type C<type> starting at C<*p> as a Parrot string.
 330
 331 =cut
 332
 333 */
 334
 335 static STRING*
 336 ret_string(PARROT_INTERP, char *p, int type)
 337 {
 338     if (type == enum_type_cstr) {
 339         char  *cstr = *(char **) p;
 340         size_t len  = strlen(cstr);
 341         return string_make(interp, cstr, len, "iso-8859-1", PObj_external_FLAG);
 342     }
 343
 344     real_exception(interp, NULL, E_TypeError,
 345         "returning unhandled string type in struct");
 346 }
 347
 348 /*
 349
 350 =item C<static PMC*
 351 ret_pmc(PARROT_INTERP, PMC *pmc, char *p, int type, INTVAL idx)>
 352
 353 Returns the element of type C<type> starting at C<*p> as a PMC.
 354
 355 =cut
 356
 357 */
 358
 359 static PMC*
 360 ret_pmc(PARROT_INTERP, PMC *pmc, char *p, int type, INTVAL idx)
 361 {
 362     PMC *ret = NULL, *init, *ptr;
 363
 364     switch (type) {
 365         case enum_type_func_ptr:
 366             /* this is a raw function pointer - not a PMC */
 367             ret  = *(PMC**) p;
 368
 369             /* now check if initializer has a signature attached */
 370             init = PMC_pmc_val(pmc);
 371             ptr  = VTABLE_get_pmc_keyed_int(interp, init, idx*3);
 372
 373             if (ptr->pmc_ext && PMC_metadata(ptr)) {
 374                 STRING *signature_str = CONST_STRING(interp, "_signature");
 375                 PMC *sig = VTABLE_getprop(interp, ptr, signature_str);
 376                 if (VTABLE_defined(interp, sig)) {
 377                     STRING *sig_str = VTABLE_get_string(interp, sig);
 378                     ret             = pmc_new(interp, enum_class_NCI);
 379                     VTABLE_set_pointer_keyed_str(interp, ret, sig_str,
 380                             *(PMC **)p);
 381                 }
 382             }
 383
 384             return ret;
 385         case enum_type_struct_ptr:
 386             /* check the metadata for an initializer */
 387             init = PMC_pmc_val(pmc);
 388             ptr  = VTABLE_get_pmc_keyed_int(interp, init, idx * 3);
 389
 390             /* grab the struct from the metadata */
 391             if (ptr->pmc_ext && PMC_metadata(ptr)) {
 392                 ret = VTABLE_getprop(interp, ptr, CONST_STRING(interp, "_struct"));
 393             }
 394             else {
 395                 real_exception(interp, NULL, E_TypeError,
 396                         "no initializer available for nested struct");
 397             }
 398
 399             /* assign the pointer */
 400             PMC_data(ret) = *(void**)p;
 401
 402             return ret;
 403         default:
 404             real_exception(interp, NULL, E_TypeError,
 405                     "returning unhandled pmc type (%d) in struct", type);
 406     }
 407 }
 408
 409 /*
 410
 411 =item C<static void
 412 set_int(PARROT_INTERP, char *p, int type, INTVAL value)>
 413
 414 =cut
 415
 416 */
 417
 418 static void
 419 set_int(PARROT_INTERP, char *p, int type, INTVAL value)
 420 {
 421     switch (type) {
 422         case enum_type_uint8:
 423         case enum_type_int8:
 424         case enum_type_char:
 425         case enum_type_uchar:
 426             *(char *)p = (char)(value & 0xff);
 427             break;
 428         case enum_type_INTVAL:
 429             *(INTVAL *)p = value;
 430             break;
 431         case enum_type_int:
 432             *(int *)p = value;
 433             break;
 434         case enum_type_int16:
 435         case enum_type_uint16:
 436         case enum_type_short:
 437             *(short *)p = (short)value;
 438             break;
 439         default:
 440             real_exception(interp, NULL, 1,
 441                 "setting unhandled int type in struct");
 442             break;
 443     }
 444 }
 445
 446 /*
 447
 448 =item C<static void
 449 set_float(PARROT_INTERP, char *p, int type, FLOATVAL value)>
 450
 451 Sets the value of the element of type C<type> starting at C<*p> to
 452 C<value>.
 453
 454 =cut
 455
 456 */
 457
 458 static void
 459 set_float(PARROT_INTERP, char *p, int type, FLOATVAL value)
 460 {
 461     switch (type) {
 462         case enum_type_FLOATVAL:
 463             *(FLOATVAL *)p = (FLOATVAL)value;
 464             break;
 465         case enum_type_float:
 466             *(float *)p = (float)value;
 467             break;
 468         case enum_type_double:
 469             *(double *)p = (double)value;
 470             break;
 471         default:
 472             real_exception(interp, NULL, 1,
 473                 "setting unhandled float type in struct");
 474             break;
 475     }
 476 }
 477
 478 /*
 479
 480 =item C<static void
 481 set_string(PARROT_INTERP, char *p, int type, STRING *value)>
 482
 483 Sets the value of the element of type C<type> starting at C<*p> to
 484 C<*value>.
 485
 486 =cut
 487
 488 */
 489
 490 static void
 491 set_string(PARROT_INTERP, char *p, int type, STRING *value)
 492 {
 493     if (type == enum_type_cstr) {
 494         /* assuming 0-terminated C-string here;
 495          * we can't use string_to_cstring easily */
 496         char *cstr  = value->strstart;
 497         *(char **)p = cstr;
 498     }
 499     else
 500         real_exception(interp, NULL, 1,
 501             "setting unhandled string type in struct (%d)", type);
 502 }
 503
 504 /*
 505
 506 =item C<static int
 507 calc_align(PARROT_INTERP, PMC *pmc, PMC *type_pmc,
 508         int type, int offs)>
 509
 510 Alignment of contained structures is the alignment of the
 511 biggest item in that C<struct>.
 512
 513 i386: C<long long> or C<double> is aligned on 4.
 514
 515 This is recursive as structure definitions.
 516
 517 =cut
 518
 519 */
 520
 521 static int
 522 calc_align(PARROT_INTERP, PMC *pmc, PMC *type_pmc,
 523         int type, int offs)
 524 {
 525     int  align       = data_types[type - enum_first_type].size;
 526     PMC *nested      = NULL;
 527     PMC *nested_init = NULL;
 528
 529     if (type == enum_type_struct || type == enum_type_struct_ptr) {
 530         /* a nested structs alignment is the biggest item in it
 531          * so go through that struct and check
 532          */
 533         nested = VTABLE_getprop(interp, type_pmc, CONST_STRING(interp, "_struct"));
 534         nested_init = PMC_pmc_val(nested);
 535     }
 536     if (type == enum_type_struct) {
 537         size_t i, n    = (size_t)VTABLE_elements(interp, nested_init);
 538         int    a_max   = 0;
 539         int    new_offs;
 540
 541         if (n % 3)
 542             real_exception(interp, NULL, E_TypeError,
 543                     "Illegal initializer for struct");
 544
 545         for (i = 0; i < n; i += 3) {
 546             PMC *nested_type_pmc = VTABLE_get_pmc_keyed_int(interp,
 547                     nested_init, i);
 548             int  nested_type     = (int)VTABLE_get_integer(interp,
 549                 nested_type_pmc);
 550             new_offs             = calc_align(interp, nested,
 551                     nested_type_pmc, nested_type, offs);
 552
 553             if (new_offs > a_max)
 554                 a_max = new_offs;
 555         }
 556
 557         align = a_max;
 558     }
 559
 560     if (align && offs % align) {
 561         const int diff = align - (offs % align);
 562         offs += diff;
 563     }
 564
 565     if (type == enum_type_struct || type == enum_type_struct_ptr)
 566         calc_offsets(interp, nested, nested_init, 0);
 567
 568     return offs;
 569 }
 570
 571 /*
 572
 573 =item C<static size_t
 574 calc_offsets(PARROT_INTERP, PMC *pmc, PMC *value, size_t toff)>
 575
 576 Calculates the offsets for the C<struct>. See C<init_pmc()> for a
 577 description of C<*value>.
 578
 579 =cut
 580
 581 */
 582
 583 static size_t
 584 calc_offsets(PARROT_INTERP, PMC *pmc, PMC *value, size_t toff)
 585 {
 586     size_t i, n = (size_t)VTABLE_elements(interp, value);
 587     int size;
 588
 589     if (n % 3)
 590         real_exception(interp, NULL, E_TypeError,
 591                 "Illegal initializer for struct");
 592
 593     for (i = 0; i < n; i += 3) {
 594         PMC *type_pmc = VTABLE_get_pmc_keyed_int(interp, value, i);
 595         int  type     = (int)VTABLE_get_integer(interp, type_pmc);
 596         int  count    = (int)VTABLE_get_integer_keyed_int(interp, value, i + 1);
 597         int  offs     = (int)VTABLE_get_integer_keyed_int(interp, value, i + 2);
 598
 599         if (type < enum_first_type || type >= enum_last_type)
 600             real_exception(interp, NULL, E_TypeError,
 601                     "Illegal type in initializer for struct");
 602
 603         if (count <= 0) {
 604             count = 1;
 605             VTABLE_set_integer_keyed_int(interp, value, i+1, count);
 606         }
 607
 608         if (offs <= 0) {
 609             offs = toff = calc_align(interp, pmc, type_pmc, type, toff);
 610             VTABLE_set_integer_keyed_int(interp, value, i+2, offs);
 611         }
 612         else
 613             toff = offs;
 614
 615         if (type == enum_type_struct) {
 616             PMC *nested = VTABLE_getprop(interp, type_pmc, CONST_STRING(interp, "_struct"));
 617             size        = PMC_int_val(nested);
 618         }
 619         else
 620             size = data_types[type - enum_first_type].size;
 621
 622         toff += count * size;
 623
 624         /* set / allocate size */
 625         if (i == n - 3)
 626             VTABLE_set_integer_native(interp, pmc, toff);
 627     }
 628
 629     return toff;
 630 }
 631
 632 pmclass UnManagedStruct extends default need_ext no_ro {
 633
 634 /*
 635
 636 =back
 637
 638 =head2 Methods
 639
 640 =over 4
 641
 642 =item C<void init()>
 643
 644 Initializes the C<struct> with a default value of C<NULL>.
 645
 646 =cut
 647
 648 */
 649
 650     VTABLE void init() {
 651         PMC_pmc_val(SELF) = NULL;
 652     }
 653
 654 /*
 655
 656 =item C<void init_pmc(PMC *value)>
 657
 658 Initialize the struct with some data.
 659
 660 C<*value> should be an array of triples of:
 661
 662 =over 4
 663
 664 =item 0
 665
 666 The datatype. See the C<enum> in F<include/parrot/datatypes.h>.
 667
 668 =item 1
 669
 670 The count.
 671
 672 =item 2
 673
 674 The offset.
 675
 676 =back
 677
 678 =cut
 679
 680 */
 681
 682     VTABLE void init_pmc(PMC *value) {
 683         SELF.set_pmc(value);
 684     }
 685
 686 /*
 687
 688 =item C<void set_pmc(PMC *value)>
 689
 690 Sets C<*value> (see C<init_pmc()> and calculates the offsets.
 691
 692 =cut
 693
 694 */
 695
 696     VTABLE void set_pmc(PMC *value) {
 697         PMC_pmc_val(SELF) = value;
 698         PObj_custom_mark_SET(SELF);
 699         calc_offsets(INTERP, SELF, value, 0);
 700     }
 701
 702 /*
 703
 704 =item C<void mark()>
 705
 706 Marks the C<struct> as live.
 707
 708 =cut
 709
 710 */
 711
 712     VTABLE void mark() {
 713         if (PMC_pmc_val(SELF))
 714             pobject_lives(INTERP, (PObj *)PMC_pmc_val(SELF));
 715     }
 716
 717 /*
 718
 719 =item C<INTVAL is_equal(PMC *value)>
 720
 721 Returns whether the two C<struct>s are equivalent.
 722
 723 =cut
 724
 725 */
 726
 727     VTABLE INTVAL is_equal(PMC *value) {
 728         return (SELF->vtable == value->vtable &&
 729             PMC_data(SELF) == PMC_data(value));
 730     }
 731
 732 /*
 733
 734 =item C<INTVAL defined()>
 735
 736 Returns whether the C<struct> is defined.
 737
 738 =cut
 739
 740 */
 741
 742     VTABLE INTVAL defined() {
 743         return PMC_data(SELF) != NULL;
 744     }
 745
 746 /*
 747
 748 =item C<INTVAL get_integer()>
 749
 750 Returns the size of the C<struct>.
 751
 752 =cut
 753
 754 */
 755
 756     VTABLE INTVAL get_integer() {
 757         return PMC_int_val(SELF);
 758     }
 759
 760 /*
 761
 762 =item C<void set_integer_native(INTVAL size)>
 763
 764 Sets the size of the C<struct>.
 765
 766 =cut
 767
 768 */
 769
 770     VTABLE void set_integer_native(INTVAL size) {
 771         PMC_int_val(SELF) = size;
 772     }
 773
 774 /*
 775
 776 =item C<INTVAL get_integer_keyed_int(INTVAL ix)>
 777
 778 Returns the integer value at index C<ix>.
 779
 780 =cut
 781
 782 */
 783
 784     VTABLE INTVAL get_integer_keyed_int(INTVAL ix) {
 785         int   type;
 786         char *p = char_offset_int(INTERP, pmc, ix, &type);
 787         return ret_int(INTERP, p, type);
 788     }
 789
 790 /*
 791
 792 =item C<INTVAL get_integer_keyed(PMC *key)>
 793
 794 Returns the integer value associated with C<*key>.
 795
 796 =cut
 797
 798 */
 799
 800     VTABLE INTVAL get_integer_keyed(PMC *key) {
 801         int   type;
 802         char *p = char_offset_key(INTERP, pmc, key, &type);
 803         return ret_int(INTERP, p, type);
 804     }
 805
 806 /*
 807
 808 =item C<FLOATVAL get_number_keyed_int(INTVAL key)>
 809
 810 Returns the floating-point value at index C<ix>.
 811
 812 =cut
 813
 814 */
 815
 816     VTABLE FLOATVAL get_number_keyed_int(INTVAL key) {
 817         int   type;
 818         char *p = char_offset_int(INTERP, pmc, key, &type);
 819         return ret_float(INTERP, p, type);
 820     }
 821
 822 /*
 823
 824 =item C<FLOATVAL get_number_keyed(PMC *key)>
 825
 826 Returns the floating-point value associated with C<*key>.
 827
 828 =cut
 829
 830 */
 831
 832     VTABLE FLOATVAL get_number_keyed(PMC *key) {
 833         int   type;
 834         char *p = char_offset_key(INTERP, pmc, key, &type);
 835         return ret_float(INTERP, p, type);
 836     }
 837
 838 /*
 839
 840 =item C<STRING *get_string_keyed_int(INTVAL key)>
 841
 842 Returns the Parrot string value at index C<ix>.
 843
 844 =cut
 845
 846 */
 847
 848     VTABLE STRING *get_string_keyed_int(INTVAL key) {
 849         int   type;
 850         char *p = char_offset_int(INTERP, pmc, key, &type);
 851         return ret_string(INTERP, p, type);
 852     }
 853
 854 /*
 855
 856 =item C<STRING *get_string_keyed(PMC *key)>
 857
 858 Returns the Parrot string value associated with C<*key>.
 859
 860 =cut
 861
 862 */
 863
 864     VTABLE STRING *get_string_keyed(PMC *key) {
 865         int   type;
 866         char *p = char_offset_key(INTERP, pmc, key, &type);
 867         return ret_string(INTERP, p, type);
 868     }
 869
 870 /*
 871
 872 =item C<PMC *get_pmc_keyed_int(INTVAL key)>
 873
 874 Returns the PMC value at index C<ix>.
 875
 876 =cut
 877
 878 */
 879
 880     VTABLE PMC *get_pmc_keyed_int(INTVAL key) {
 881         int   type;
 882         char *p = char_offset_int(INTERP, pmc, key, &type);
 883         return ret_pmc(INTERP, pmc, p, type, key);
 884     }
 885
 886 /*
 887
 888 =item C<PMC *get_pmc_keyed(PMC *key)>
 889
 890 Returns the PMC value associated with C<*key>.
 891
 892 =cut
 893
 894 */
 895
 896     VTABLE PMC *get_pmc_keyed(PMC *key) {
 897         int   type;
 898         char *p = char_offset_key(INTERP, pmc, key, &type);
 899         return ret_pmc(INTERP, pmc, p, type, key_2_idx(INTERP, pmc, key));
 900     }
 901
 902 /*
 903
 904 =item C<void *get_pointer()>
 905
 906 Returns the pointer to the actual C C<struct>.
 907
 908 =cut
 909
 910 */
 911
 912     VTABLE void *get_pointer() {
 913         return PMC_data(SELF);
 914     }
 915
 916 /*
 917
 918 =item C<void set_pointer(void *value)>
 919
 920 Set the pointer to the actual C C<struct>.
 921
 922 =cut
 923
 924 */
 925
 926     VTABLE void set_pointer(void *value) {
 927         PMC_data(SELF) = value;
 928     }
 929
 930 /*
 931
 932 =item C<void set_integer_keyed_int(INTVAL ix, INTVAL value)>
 933
 934 Sets the value of the element at index C<ix> to C<value>.
 935
 936 =cut
 937
 938 */
 939
 940     VTABLE void set_integer_keyed_int(INTVAL ix, INTVAL value) {
 941         int   type;
 942         char *p = char_offset_int(INTERP, pmc, ix, &type);
 943         set_int(INTERP, p, type, value);
 944     }
 945
 946 /*
 947
 948 =item C<void set_integer_keyed(PMC *key, INTVAL value)>
 949
 950 Sets the value of the element associated with key C<*key> to C<value>.
 951
 952 May cause segfaults if value is out of bounds.
 953
 954 =cut
 955
 956 */
 957
 958     VTABLE void set_integer_keyed(PMC *key, INTVAL value) {
 959         int   type;
 960         char *p = char_offset_key(INTERP, pmc, key, &type);
 961         set_int(INTERP, p, type, value);
 962     }
 963
 964 /*
 965
 966 =item C<void set_number_keyed_int(INTVAL key, FLOATVAL value)>
 967
 968 Sets the value of the element at index C<ix> to C<value>.
 969
 970 =cut
 971
 972 */
 973
 974     VTABLE void set_number_keyed_int(INTVAL key, FLOATVAL value) {
 975         int   type;
 976         char *p = char_offset_int(INTERP, pmc, key, &type);
 977         set_float(INTERP, p, type, value);
 978     }
 979
 980 /*
 981
 982 =item C<void set_number_keyed(PMC *key, FLOATVAL value)>
 983
 984 Sets the value of the element associated with key C<*key> to C<value>.
 985
 986 =cut
 987
 988 */
 989
 990     VTABLE void set_number_keyed(PMC *key, FLOATVAL value) {
 991         int type;
 992         char *p = char_offset_key(INTERP, pmc, key, &type);
 993         set_float(INTERP, p, type, value);
 994     }
 995
 996 /*
 997
 998 =item C<void set_string_keyed_int(INTVAL key, STRING *value)>
 999
1000 Sets the value of the element at index C<key> to C<*value>.
1001
1002 =cut
1003
1004 */
1005
1006     VTABLE void set_string_keyed_int(INTVAL key, STRING *value) {
1007         int   type;
1008         char *p = char_offset_int(INTERP, pmc, key, &type);
1009         set_string(INTERP, p, type, value);
1010     }
1011
1012 /*
1013
1014 =item C<void set_string_keyed(PMC *key, STRING *value)>
1015
1016 Sets the value of the element associated with key C<*key> to C<*value>.
1017
1018 =cut
1019
1020 */
1021
1022     VTABLE void set_string_keyed(PMC *key, STRING *value) {
1023         int   type;
1024         char *p = char_offset_key(INTERP, pmc, key, &type);
1025         set_string(INTERP, p, type, value);
1026     }
1027
1028 }
1029
1030 /*
1031
1032 =back
1033
1034 =head1 HISTORY
1035
1036 Initial revision by sean 2002/08/04
1037
1038 =head1 SEE ALSO
1039
1040 F<docs/pmc/struct.pod>
1041
1042 =cut
1043
1044 */
1045
1046 /*
1047  * Local variables:
1048  *   c-file-style: "parrot"
1049  * End:
1050  * vim: expandtab shiftwidth=4:
1051  */