src/pmc/cpointer.pmc

   1 /*
   2 Copyright (C) 2008-2009, Parrot Foundation.
   3 $Id$
   4
   5 =head1 NAME
   6
   7 src/pmc/cpointer.pmc - CPointer
   8
   9 =head1 DESCRIPTION
  10
  11 The CPointer PMC creates a PMC abstraction for a typed C pointer. It is
  12 particularly used by the C<CallSignature> PMC, for the return values of a
  13 C-level PCC invocation using a C<CallSignature> to pass the arguments and fetch
  14 the results.
  15
  16 =head2 Attributes
  17
  18 A CPointer PMC has two attributes:
  19
  20 =over 4
  21
  22 =item pointer
  23
  24 A C<void *> pointer to an integer, number, string, or PMC.
  25
  26 =item sig
  27
  28 A string signature for the pointer. The possible signature values follow the
  29 standard defined for PCC.
  30
  31   I   a Parrot integer (INTVAL)
  32   N   a Parrot number  (FLOATVAL)
  33   S   a Parrot string  (STRING *)
  34   P   a Parrot object  (PMC *)
  35
  36 =back
  37
  38
  39 =head2 Vtable Functions
  40
  41 These are the vtable functions for the CPointer class.
  42
  43 =over 4
  44
  45 =cut
  46
  47 */
  48
  49 pmclass CPointer auto_attrs {
  50     ATTR void   *pointer; /* The stored pointer. */
  51     ATTR STRING *sig;     /* A string signature for the pointer. */
  52
  53 /*
  54
  55 =item C<void init()>
  56
  57 Initializes the pointer object.
  58
  59 =cut
  60
  61 */
  62
  63     VTABLE void init() {
  64         SET_ATTR_pointer(INTERP, SELF, NULL);
  65         SET_ATTR_sig(INTERP, SELF, NULL);
  66
  67         PObj_custom_mark_destroy_SETALL(SELF);
  68     }
  69
  70 /*
  71
  72 =item C<void mark()>
  73
  74 Marks the signature as live. Also marks a STRING or PMC pointed to by the
  75 pointer.
  76
  77 =cut
  78
  79 */
  80
  81     VTABLE void mark() {
  82         STRING *sig;
  83         GET_ATTR_sig(INTERP, SELF, sig);
  84         if (sig) {
  85             void *pointer;
  86             GET_ATTR_pointer(INTERP, SELF, pointer);
  87             Parrot_gc_mark_PObj_alive(interp, (PObj *)sig);
  88
  89             if (pointer) {
  90                 if (Parrot_str_equal(interp, sig, CONST_STRING(interp, "P"))) {
  91                     PMC ** const pmc_pointer = (PMC **) pointer;
  92                     PARROT_ASSERT(*pmc_pointer);
  93                     Parrot_gc_mark_PObj_alive(interp, (PObj *) *pmc_pointer);
  94                 }
  95                 else if (Parrot_str_equal(interp, sig, CONST_STRING(interp, "S"))) {
  96                     STRING ** const str_pointer = (STRING **) pointer;
  97                     PARROT_ASSERT(*str_pointer);
  98                     Parrot_gc_mark_PObj_alive(interp, (PObj *) *str_pointer);
  99                 }
 100             }
 101         }
 102     }
 103
 104 /*
 105
 106 =item C<void destroy()>
 107
 108 Destroys the PMC and frees all allocated memory.
 109
 110 =cut
 111
 112 */
 113
 114     VTABLE void destroy() {
 115     }
 116
 117 /*
 118
 119 =item C<PMC *clone()>
 120
 121 Creates and returns a clone of the pointer.
 122
 123 =cut
 124
 125 */
 126
 127     VTABLE PMC *clone() {
 128         PMC * const dest = pmc_new_noinit(INTERP, SELF->vtable->base_type);
 129         PObj_custom_mark_SET(dest);
 130         PMC_data(dest) = PMC_data(SELF);
 131         return dest;
 132     }
 133
 134 /*
 135
 136 =item C<void *get_pointer()>
 137
 138 Returns the pointer.
 139
 140 =cut
 141
 142 */
 143
 144     VTABLE void *get_pointer() {
 145         Parrot_CPointer_attributes * const data = PARROT_CPOINTER(SELF);
 146         return data->pointer;
 147     }
 148
 149 /*
 150
 151 =item C<void set_pointer(void *)>
 152
 153 Sets the pointer.
 154
 155 =cut
 156
 157 */
 158
 159     VTABLE void set_pointer(void *value) {
 160         Parrot_CPointer_attributes * const data = PARROT_CPOINTER(SELF);
 161         data->pointer = value;
 162     }
 163
 164 /*
 165
 166 =item C<STRING *get_string_keyed_str(STRING *key)>
 167
 168 Returns the string signature.
 169
 170 =cut
 171
 172 */
 173
 174     VTABLE STRING *get_string_keyed_str(STRING *key) {
 175         Parrot_CPointer_attributes * const data = PARROT_CPOINTER(SELF);
 176         UNUSED(key)
 177
 178         return data->sig;
 179     }
 180
 181 /*
 182
 183 =item C<void set_string_keyed_str(STRING *key, STRING *value)>
 184
 185 Sets the string signature.
 186
 187 =cut
 188
 189 */
 190
 191     VTABLE void set_string_keyed_str(STRING *key, STRING *value) {
 192         Parrot_CPointer_attributes * const data = PARROT_CPOINTER(SELF);
 193         UNUSED(key)
 194
 195         data->sig = value;
 196     }
 197
 198 /*
 199
 200 =item C<INTVAL get_integer()>
 201
 202 Returns the integer value that the pointer points to (if the pointer is to an
 203 integer or PMC).
 204
 205 =cut
 206
 207 */
 208
 209     VTABLE INTVAL get_integer() {
 210         Parrot_CPointer_attributes * const data = PARROT_CPOINTER(SELF);
 211
 212         if (Parrot_str_equal(interp, data->sig, CONST_STRING(interp, "I"))) {
 213             const INTVAL * const int_pointer = (INTVAL *) data->pointer;
 214             return *int_pointer;
 215         }
 216         else if (Parrot_str_equal(interp, data->sig, CONST_STRING(interp, "P"))) {
 217             PMC ** const pmc_pointer = (PMC **) data->pointer;
 218             return VTABLE_get_integer(interp, *pmc_pointer);
 219         }
 220         Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_INVALID_OPERATION,
 221                 "Unable to fetch integer value, the pointer is not an integer");
 222
 223     }
 224
 225 /*
 226
 227 =item C<void set_integer_native(INTVAL value)>
 228
 229 Sets the integer value that the pointer points to (if the pointer is to an
 230 integer or PMC).
 231
 232 =cut
 233
 234 */
 235
 236     VTABLE void set_integer_native(INTVAL value) {
 237         Parrot_CPointer_attributes * const data = PARROT_CPOINTER(SELF);
 238
 239         if (Parrot_str_equal(interp, data->sig, CONST_STRING(interp, "I"))) {
 240             INTVAL * const int_pointer = (INTVAL *) data->pointer;
 241             *int_pointer = value;
 242         }
 243         else if (Parrot_str_equal(interp, data->sig, CONST_STRING(interp, "P"))) {
 244             PMC ** const pmc_pointer = (PMC **) data->pointer;
 245             VTABLE_set_integer_native(interp, *pmc_pointer, value);
 246         }
 247         else {
 248             Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_INVALID_OPERATION,
 249                     "Unable to set integer value, the pointer is not an integer");
 250         }
 251     }
 252
 253 /*
 254
 255 =item C<FLOATVAL get_number()>
 256
 257 Returns the floating point value that the pointer points to (if the pointer is
 258 to a number or PMC).
 259
 260 =cut
 261
 262 */
 263
 264     VTABLE FLOATVAL get_number() {
 265         Parrot_CPointer_attributes * const data = PARROT_CPOINTER(SELF);
 266
 267         if (Parrot_str_equal(interp, data->sig, CONST_STRING(interp, "N"))) {
 268             const FLOATVAL * const num_pointer = (FLOATVAL *) data->pointer;
 269             return *num_pointer;
 270         }
 271         else if (Parrot_str_equal(interp, data->sig, CONST_STRING(interp, "P"))) {
 272             PMC ** const pmc_pointer = (PMC **) data->pointer;
 273             return VTABLE_get_number(interp, *pmc_pointer);
 274         }
 275         Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_INVALID_OPERATION,
 276                 "Unable to fetch number value, the pointer is not a number");
 277     }
 278
 279 /*
 280
 281 =item C<void set_number_native(FLOATVAL value)>
 282
 283 Sets the floating point value that the pointer points to (if the pointer is
 284 to a number or PMC).
 285
 286 =cut
 287
 288 */
 289
 290     VTABLE void set_number_native(FLOATVAL value) {
 291         Parrot_CPointer_attributes * const data = PARROT_CPOINTER(SELF);
 292
 293         if (Parrot_str_equal(interp, data->sig, CONST_STRING(interp, "N"))) {
 294             FLOATVAL * const num_pointer = (FLOATVAL *) data->pointer;
 295             *num_pointer = value;
 296         }
 297         else if (Parrot_str_equal(interp, data->sig, CONST_STRING(interp, "P"))) {
 298             PMC ** const pmc_pointer = (PMC **) data->pointer;
 299             VTABLE_set_number_native(interp, *pmc_pointer, value);
 300         }
 301         else {
 302             Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_INVALID_OPERATION,
 303                     "Unable to set number value, the pointer is not a number");
 304         }
 305     }
 306
 307 /*
 308
 309 =item C<STRING *get_string()>
 310
 311 Returns the Parrot string value that the pointer points to (if the pointer is
 312 to a string or PMC).
 313
 314 =cut
 315
 316 */
 317
 318     VTABLE STRING *get_string() {
 319         Parrot_CPointer_attributes * const data = PARROT_CPOINTER(SELF);
 320
 321         if (Parrot_str_equal(interp, data->sig, CONST_STRING(interp, "S"))) {
 322             STRING ** const str_pointer = (STRING **) data->pointer;
 323             return *str_pointer;
 324         }
 325         else if (Parrot_str_equal(interp, data->sig, CONST_STRING(interp, "P"))) {
 326             PMC ** const pmc_pointer = (PMC **) data->pointer;
 327             return VTABLE_get_string(interp, *pmc_pointer);
 328         }
 329         Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_INVALID_OPERATION,
 330                 "Unable to fetch string value, the pointer is not a string");
 331     }
 332
 333 /*
 334
 335 =item C<void set_string_native(STRING *value)>
 336
 337 Sets the Parrot string value that the pointer points to (if the pointer is
 338 to a string or PMC).
 339
 340 =cut
 341
 342 */
 343
 344     VTABLE void set_string_native(STRING *value) {
 345         Parrot_CPointer_attributes * const data = PARROT_CPOINTER(SELF);
 346
 347         if (Parrot_str_equal(interp, data->sig, CONST_STRING(interp, "S"))) {
 348             STRING ** const str_pointer = (STRING **) data->pointer;
 349             *str_pointer = value;
 350         }
 351         else if (Parrot_str_equal(interp, data->sig, CONST_STRING(interp, "P"))) {
 352             PMC ** const pmc_pointer = (PMC **) data->pointer;
 353             VTABLE_set_string_native(interp, *pmc_pointer, value);
 354         }
 355         else {
 356             Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_INVALID_OPERATION,
 357                     "Unable to set string value, the pointer is not a string");
 358         }
 359     }
 360
 361 /*
 362
 363 =item C<PMC *get_pmc()>
 364
 365 Returns the PMC value that the pointer points to (if the pointer is to a PMC).
 366
 367 =cut
 368
 369 */
 370
 371     VTABLE PMC *get_pmc() {
 372         const Parrot_CPointer_attributes * const data = PARROT_CPOINTER(SELF);
 373
 374         if (Parrot_str_equal(interp, data->sig, CONST_STRING(interp, "P"))) {
 375             PMC ** const pmc_pointer = (PMC **) data->pointer;
 376             return *pmc_pointer;
 377         }
 378         Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_INVALID_OPERATION,
 379                 "Unable to fetch PMC value, the pointer is not a PMC");
 380     }
 381
 382 /*
 383
 384 =item C<void set_pmc(PMC *value)>
 385
 386 Sets the PMC value that the pointer points to (if the pointer is to a PMC).
 387
 388 =cut
 389
 390 */
 391
 392     VTABLE void set_pmc(PMC *value) {
 393         const Parrot_CPointer_attributes * const data = PARROT_CPOINTER(SELF);
 394
 395         if (Parrot_str_equal(interp, data->sig, CONST_STRING(interp, "P"))) {
 396             PMC ** const pmc_pointer = (PMC **) data->pointer;
 397             *pmc_pointer = value;
 398         }
 399         else {
 400             Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_INVALID_OPERATION,
 401                     "Unable to set PMC value, the pointer is not a PMC");
 402         }
 403     }
 404
 405 /*
 406
 407 =item C<INTVAL get_bool()>
 408
 409 Returns whether the pointer is not C<NULL>.
 410
 411 =cut
 412
 413 */
 414
 415     VTABLE INTVAL get_bool() {
 416         const Parrot_CPointer_attributes * const data = PARROT_CPOINTER(SELF);
 417         return (INTVAL)(data->pointer != NULL);
 418     }
 419
 420 /*
 421
 422 =item C<INTVAL is_same(PMC *pmc2)>
 423
 424 Returns whether the pointer has the same value as C<*pmc2>.
 425
 426 =cut
 427
 428 */
 429
 430     VTABLE INTVAL is_same(PMC *pmc2) {
 431         const Parrot_CPointer_attributes * const data = PARROT_CPOINTER(SELF);
 432         return (INTVAL)(SELF->vtable  == pmc2->vtable &&
 433                         data->pointer == VTABLE_get_pointer(interp, pmc2));
 434     }
 435 }
 436
 437 /*
 438
 439 =back
 440
 441 =cut
 442
 443 */
 444
 445 /*
 446  * Local variables:
 447  *   c-file-style: "parrot"
 448  * End:
 449  * vim: expandtab shiftwidth=4:
 450  */