src/pmc/capture.pmc

   1 /*
   2 Copyright (C) 2001-2008, The Perl Foundation.
   3 $Id$
   4
   5 =head1 NAME
   6
   7 src/pmc/capture.pmc - Capture PMC
   8
   9 =head1 DESCRIPTION
  10
  11 These are the vtable functions for the Capture PMC.
  12
  13 =head2 Functions
  14
  15 =over 4
  16
  17 =cut
  18
  19 */
  20
  21 #include "parrot/parrot.h"
  22
  23
  24 #define CAPTURE_DATA_SIZE   2
  25 #define CAPTURE_array_CREATE(i, obj) \
  26     if (!PARROT_CAPTURE(obj)->array) \
  27         PARROT_CAPTURE(obj)->array = pmc_new((i), enum_class_ResizablePMCArray);
  28 #define CAPTURE_hash_CREATE(i, obj) \
  29     if (!PARROT_CAPTURE(obj)->hash) \
  30         PARROT_CAPTURE(obj)->hash = pmc_new((i), enum_class_Hash);
  31
  32 pmclass Capture need_ext provides array provides hash {
  33     ATTR PMC *array;
  34     ATTR PMC *hash;
  35
  36 /*
  37
  38 =item C<void init()>
  39
  40 Initializes the Capture instance.
  41
  42 =item C<void destroy()>
  43
  44 Free structures.
  45
  46 =cut
  47
  48 */
  49
  50     VTABLE void init() {
  51         Parrot_Capture *capture = mem_allocate_typed(Parrot_Capture);
  52         PMC_data(SELF)          = capture;
  53         capture->array          = NULL;
  54         capture->hash           = NULL;
  55         PMC_int_val(SELF)       = CAPTURE_DATA_SIZE;
  56         PObj_active_destroy_SET(SELF);
  57         PObj_data_is_PMC_array_SET(SELF);
  58     }
  59
  60     VTABLE void destroy() {
  61         if (PARROT_CAPTURE(SELF)) {
  62             mem_sys_free(PARROT_CAPTURE(SELF));
  63             PMC_data(SELF) = NULL;
  64         }
  65
  66         PMC_int_val(SELF)  = 0;
  67     }
  68
  69 /*
  70
  71 =item C<void set_number_keyed_int(INTVAL key, FLOATVAL value)>
  72
  73 =item C<void set_integer_keyed_int(INTVAL key, INTVAL value)>
  74
  75 =item C<void set_pmc_keyed_int(INTVAL key, PMC *value)>
  76
  77 =item C<void set_string_keyed_int(INTVAL key, STRING *value)>
  78
  79 Sets a value in the array component of the Capture.
  80
  81 =cut
  82
  83 */
  84
  85     VTABLE void set_number_keyed_int(INTVAL key, FLOATVAL value) {
  86         CAPTURE_array_CREATE(INTERP, SELF);
  87         VTABLE_set_number_keyed_int(INTERP, PARROT_CAPTURE(SELF)->array,
  88                                     key, value);
  89     }
  90
  91     VTABLE void set_integer_keyed_int(INTVAL key, INTVAL value) {
  92         CAPTURE_array_CREATE(INTERP, SELF);
  93         VTABLE_set_integer_keyed_int(INTERP, PARROT_CAPTURE(SELF)->array,
  94                                      key, value);
  95     }
  96
  97     VTABLE void set_pmc_keyed_int(INTVAL key, PMC *value) {
  98         CAPTURE_array_CREATE(INTERP, SELF);
  99         VTABLE_set_pmc_keyed_int(INTERP, PARROT_CAPTURE(SELF)->array,
 100                                  key, value);
 101     }
 102
 103     VTABLE void set_string_keyed_int(INTVAL key, STRING *value) {
 104         CAPTURE_array_CREATE(INTERP, SELF);
 105         VTABLE_set_string_keyed_int(INTERP, PARROT_CAPTURE(SELF)->array,
 106                                     key, value);
 107     }
 108
 109 /*
 110
 111 =item C<FLOATVAL get_number_keyed_int(INTVAL key)>
 112
 113 =item C<INTVAL get_integer_keyed_int(INTVAL key)>
 114
 115 =item C<PMC *get_pmc_keyed_int(INTVAL key)>
 116
 117 =item C<STRING *get_string_keyed_int(INTVAL key)>
 118
 119 Retrieves a value in the array component of the Capture.
 120
 121 =cut
 122
 123 */
 124
 125     VTABLE FLOATVAL get_number_keyed_int(INTVAL key) {
 126         CAPTURE_array_CREATE(INTERP, SELF);
 127         return VTABLE_get_number_keyed_int(INTERP, PARROT_CAPTURE(SELF)->array,
 128                                            key);
 129     }
 130
 131     VTABLE INTVAL get_integer_keyed_int(INTVAL key) {
 132         CAPTURE_array_CREATE(INTERP, SELF);
 133         return VTABLE_get_integer_keyed_int(INTERP, PARROT_CAPTURE(SELF)->array,
 134                                             key);
 135     }
 136
 137     VTABLE PMC *get_pmc_keyed_int(INTVAL key) {
 138         CAPTURE_array_CREATE(INTERP, SELF);
 139         return VTABLE_get_pmc_keyed_int(INTERP, PARROT_CAPTURE(SELF)->array,
 140                                         key);
 141     }
 142
 143     VTABLE STRING *get_string_keyed_int(INTVAL key) {
 144         CAPTURE_array_CREATE(INTERP, SELF);
 145         return VTABLE_get_string_keyed_int(INTERP, PARROT_CAPTURE(SELF)->array,
 146                                            key);
 147     }
 148
 149 /*
 150
 151 =item C<void push_float(FLOATVAL value)>
 152
 153 =item C<void push_integer(INTVAL value)>
 154
 155 =item C<void push_pmc(PMC *value)>
 156
 157 =item C<void push_string(STRING *value)>
 158
 159 Push a value onto the array component of the Capture.
 160
 161 =item C<void unshift_float(FLOATVAL value)>
 162
 163 =item C<void unshift_integer(INTVAL value)>
 164
 165 =item C<void unshift_pmc(PMC *value)>
 166
 167 =item C<void unshift_string(STRING *value)>
 168
 169 Unshift a value onto the array component of the Capture.
 170
 171 =cut
 172
 173 */
 174
 175     VTABLE void push_float(FLOATVAL value) {
 176         CAPTURE_array_CREATE(INTERP, SELF);
 177         VTABLE_push_float(INTERP, PARROT_CAPTURE(SELF)->array, value);
 178     }
 179
 180     VTABLE void push_integer(INTVAL value) {
 181         CAPTURE_array_CREATE(INTERP, SELF);
 182         VTABLE_push_integer(INTERP, PARROT_CAPTURE(SELF)->array, value);
 183     }
 184
 185     void push_pmc(PMC *value) {
 186         CAPTURE_array_CREATE(INTERP, SELF);
 187         VTABLE_push_pmc(INTERP, PARROT_CAPTURE(SELF)->array, value);
 188     }
 189
 190     VTABLE void push_string(STRING *value) {
 191         CAPTURE_array_CREATE(INTERP, SELF);
 192         VTABLE_push_string(INTERP, PARROT_CAPTURE(SELF)->array, value);
 193     }
 194
 195     VTABLE void unshift_float(FLOATVAL value) {
 196         CAPTURE_array_CREATE(INTERP, SELF);
 197         VTABLE_unshift_float(INTERP, PARROT_CAPTURE(SELF)->array, value);
 198     }
 199
 200     VTABLE void unshift_integer(INTVAL value) {
 201         CAPTURE_array_CREATE(INTERP, SELF);
 202         VTABLE_unshift_integer(INTERP, PARROT_CAPTURE(SELF)->array, value);
 203     }
 204
 205     void unshift_pmc(PMC *value) {
 206         CAPTURE_array_CREATE(INTERP, SELF);
 207         VTABLE_unshift_pmc(INTERP, PARROT_CAPTURE(SELF)->array, value);
 208     }
 209
 210     VTABLE void unshift_string(STRING *value) {
 211         CAPTURE_array_CREATE(INTERP, SELF);
 212         VTABLE_unshift_string(INTERP, PARROT_CAPTURE(SELF)->array, value);
 213     }
 214
 215 /*
 216
 217 =item C<FLOATVAL pop_float()>
 218
 219 =item C<INTVAL pop_integer()>
 220
 221 =item C<PMC *pop_pmc()>
 222
 223 =item C<STRING *pop_string()>
 224
 225 Pop a value from the array component of the Capture.
 226
 227 =item C<FLOATVAL shift_float()>
 228
 229 =item C<INTVAL shift_integer()>
 230
 231 =item C<PMC *shift_pmc()>
 232
 233 =item C<STRING *shift_string()>
 234
 235 Shift a value from the array component of the Capture.
 236
 237 =cut
 238
 239 */
 240
 241     VTABLE FLOATVAL pop_float() {
 242         CAPTURE_array_CREATE(INTERP, SELF);
 243         return VTABLE_pop_float(INTERP, PARROT_CAPTURE(SELF)->array);
 244     }
 245
 246     VTABLE INTVAL pop_integer() {
 247         CAPTURE_array_CREATE(INTERP, SELF);
 248         return VTABLE_pop_integer(INTERP, PARROT_CAPTURE(SELF)->array);
 249     }
 250
 251     VTABLE PMC *pop_pmc() {
 252         CAPTURE_array_CREATE(INTERP, SELF);
 253         return VTABLE_pop_pmc(INTERP, PARROT_CAPTURE(SELF)->array);
 254     }
 255
 256     VTABLE STRING *pop_string() {
 257         CAPTURE_array_CREATE(INTERP, SELF);
 258         return VTABLE_pop_string(INTERP, PARROT_CAPTURE(SELF)->array);
 259     }
 260
 261     VTABLE FLOATVAL shift_float() {
 262         CAPTURE_array_CREATE(INTERP, SELF);
 263         return VTABLE_shift_float(INTERP, PARROT_CAPTURE(SELF)->array);
 264     }
 265
 266     VTABLE INTVAL shift_integer() {
 267         CAPTURE_array_CREATE(INTERP, SELF);
 268         return VTABLE_shift_integer(INTERP, PARROT_CAPTURE(SELF)->array);
 269     }
 270
 271     VTABLE PMC *shift_pmc() {
 272         CAPTURE_array_CREATE(INTERP, SELF);
 273         return VTABLE_shift_pmc(INTERP, PARROT_CAPTURE(SELF)->array);
 274     }
 275
 276     VTABLE STRING *shift_string() {
 277         CAPTURE_array_CREATE(INTERP, SELF);
 278         return VTABLE_shift_string(INTERP, PARROT_CAPTURE(SELF)->array);
 279     }
 280
 281 /*
 282
 283 =item C<INTVAL elements()>
 284
 285 Return the number of elements in the array component of the Capture.
 286
 287 =item C<INTVAL defined_keyed_int(INTVAL key)>
 288
 289 Return true if element C<key> of the array component is defined.
 290
 291 =item C<INTVAL exists_keyed_int(INTVAL key)>
 292
 293 Return true if element C<key> of the array component exists.
 294
 295 =item C<void delete_keyed_int(INTVAL key)>
 296
 297 Delete the element corresponding to C<key> in the array component.
 298
 299 =cut
 300
 301 */
 302
 303     VTABLE INTVAL elements() {
 304         if (!PARROT_CAPTURE(SELF)->array) return 0;
 305         return VTABLE_elements(INTERP, PARROT_CAPTURE(SELF)->array);
 306     }
 307
 308     VTABLE INTVAL defined_keyed_int(INTVAL key) {
 309         if (!PARROT_CAPTURE(SELF)->array)
 310             return 0;
 311
 312         return VTABLE_defined_keyed_int(INTERP, PARROT_CAPTURE(SELF)->array,
 313                                         key);
 314     }
 315
 316     VTABLE INTVAL exists_keyed_int(INTVAL key) {
 317         if (!PARROT_CAPTURE(SELF)->array)
 318             return 0;
 319
 320         return VTABLE_exists_keyed_int(INTERP, PARROT_CAPTURE(SELF)->array,
 321                                                key);
 322     }
 323
 324     VTABLE void delete_keyed_int(INTVAL key) {
 325         if (PARROT_CAPTURE(SELF)->array)
 326             VTABLE_delete_keyed_int(INTERP, PARROT_CAPTURE(SELF)->array, key);
 327     }
 328
 329 /*
 330
 331 =item C<void set_number_keyed(PMC *key, FLOATVAL value)>
 332
 333 =item C<void set_integer_keyed(PMC *key, INTVAL value)>
 334
 335 =item C<void set_pmc_keyed(PMC *key, PMC *value)>
 336
 337 =item C<void set_string_keyed(PMC *key, STRING *value)>
 338
 339 Sets a value in the hash component of the Capture.
 340
 341 =cut
 342
 343 */
 344
 345     VTABLE void set_number_keyed(PMC *key, FLOATVAL value) {
 346         CAPTURE_hash_CREATE(INTERP, SELF);
 347         VTABLE_set_number_keyed(INTERP, PARROT_CAPTURE(SELF)->hash, key, value);
 348     }
 349
 350     VTABLE void set_integer_keyed(PMC *key, INTVAL value) {
 351         CAPTURE_hash_CREATE(INTERP, SELF);
 352         VTABLE_set_integer_keyed(INTERP, PARROT_CAPTURE(SELF)->hash,
 353                                  key, value);
 354     }
 355
 356     VTABLE void set_pmc_keyed(PMC *key, PMC *value) {
 357         CAPTURE_hash_CREATE(INTERP, SELF);
 358         VTABLE_set_pmc_keyed(INTERP, PARROT_CAPTURE(SELF)->hash, key, value);
 359     }
 360
 361     VTABLE void set_string_keyed(PMC *key, STRING *value) {
 362         CAPTURE_hash_CREATE(INTERP, SELF);
 363         VTABLE_set_string_keyed(INTERP, PARROT_CAPTURE(SELF)->hash, key, value);
 364     }
 365
 366 /*
 367
 368 =item C<FLOATVAL get_number_keyed(PMC *key)>
 369
 370 =item C<INTVAL get_integer_keyed(PMC *key)>
 371
 372 =item C<PMC *get_pmc_keyed(PMC *key)>
 373
 374 =item C<STRING *get_string_keyed(PMC *key)>
 375
 376 Retrieves a value from the hash component of the Capture.
 377
 378 =cut
 379
 380 */
 381
 382     VTABLE FLOATVAL get_number_keyed(PMC *key) {
 383         CAPTURE_hash_CREATE(INTERP, SELF);
 384         return VTABLE_get_number_keyed(INTERP, PARROT_CAPTURE(SELF)->hash, key);
 385     }
 386
 387     VTABLE INTVAL get_integer_keyed(PMC *key) {
 388         CAPTURE_hash_CREATE(INTERP, SELF);
 389         return VTABLE_get_integer_keyed(INTERP, PARROT_CAPTURE(SELF)->hash,
 390                                         key);
 391     }
 392
 393     VTABLE PMC *get_pmc_keyed(PMC *key) {
 394         CAPTURE_hash_CREATE(INTERP, SELF);
 395         return VTABLE_get_pmc_keyed(INTERP, PARROT_CAPTURE(SELF)->hash, key);
 396     }
 397
 398     VTABLE STRING *get_string_keyed(PMC *key) {
 399         CAPTURE_hash_CREATE(INTERP, SELF);
 400         return VTABLE_get_string_keyed(INTERP, PARROT_CAPTURE(SELF)->hash, key);
 401     }
 402
 403 /*
 404
 405 =item C<INTVAL defined_keyed(PMC *key)>
 406
 407 Return true if element C<key> of the hash component is defined.
 408
 409 =item C<INTVAL exists_keyed(PMC *key)>
 410
 411 Return true if element C<key> of the hash component exists.
 412
 413 =item C<void delete_keyed(PMC *key)>
 414
 415 Delete the element corresponding to C<key> in the hash component.
 416
 417 =cut
 418
 419 */
 420
 421     VTABLE INTVAL defined_keyed(PMC *key) {
 422         if (!PARROT_CAPTURE(SELF)->hash) return 0;
 423         return VTABLE_defined_keyed(INTERP, PARROT_CAPTURE(SELF)->hash, key);
 424     }
 425
 426     VTABLE INTVAL exists_keyed(PMC *key) {
 427         if (!PARROT_CAPTURE(SELF)->hash) return 0;
 428         return VTABLE_exists_keyed(INTERP, PARROT_CAPTURE(SELF)->hash, key);
 429     }
 430
 431     VTABLE void delete_keyed(PMC *key) {
 432         if (PARROT_CAPTURE(SELF)->hash)
 433             VTABLE_delete_keyed(INTERP, PARROT_CAPTURE(SELF)->hash, key);
 434     }
 435
 436 /*
 437
 438 =item C<void set_pmc(PMC *capture)>
 439
 440 Set this capture to hold the value of another.
 441
 442 =cut
 443
 444 */
 445
 446     void set_pmc(PMC *capture) {
 447         if (VTABLE_isa(INTERP, capture, CONST_STRING(INTERP, "Capture"))) {
 448             PARROT_CAPTURE(SELF)->array = PARROT_CAPTURE(capture)->array;
 449             PARROT_CAPTURE(SELF)->hash = PARROT_CAPTURE(capture)->hash;
 450         }
 451         else {
 452             real_exception(INTERP, NULL, INVALID_OPERATION,
 453                            "Can only set a capture to another capture.");
 454         }
 455     }
 456
 457 /*
 458
 459 =back
 460
 461 =head2 Methods
 462
 463 =over 4
 464
 465 */
 466
 467     METHOD get_array() {
 468         PMC *capt_array;
 469         PMC *capt = SELF;
 470         /* XXX:  This workaround is for when we get here as
 471                  part of a subclass of Capture */
 472         if (PObj_is_object_TEST(SELF)) {
 473             STRING *classname = CONST_STRING(INTERP, "Capture");
 474             PMC    *classobj  = Parrot_oo_get_class_str(INTERP, classname);
 475             STRING *attribute = CONST_STRING(interp, "proxy");
 476             capt              = VTABLE_get_attr_keyed(interp, SELF, classobj, attribute);
 477         }
 478
 479         CAPTURE_array_CREATE(INTERP, capt);
 480         capt_array = PARROT_CAPTURE(capt)->array;
 481
 482         RETURN(PMC *capt_array);
 483     }
 484
 485     METHOD get_hash() {
 486         PMC *capt_hash;
 487         PMC *capt = SELF;
 488         /* XXX:  This workaround is for when we get here as
 489                  part of a subclass of Capture */
 490         if (PObj_is_object_TEST(SELF)) {
 491             STRING *classname = CONST_STRING(INTERP, "Capture");
 492             PMC    *classobj  = Parrot_oo_get_class_str(INTERP, classname);
 493             STRING *attribute = CONST_STRING(interp, "proxy");
 494             capt              = VTABLE_get_attr_keyed(interp, SELF, classobj, attribute);
 495         }
 496         CAPTURE_hash_CREATE(INTERP, capt);
 497         capt_hash = PARROT_CAPTURE(capt)->hash;
 498         RETURN(PMC *capt_hash);
 499     }
 500
 501 }
 502
 503 /*
 504
 505 =back
 506
 507 =head1 HISTORY
 508
 509 Initial version                  - Patrick Michaud 2006-11-03
 510
 511 =cut
 512
 513 */
 514
 515 /*
 516  * Local variables:
 517  *   c-file-style: "parrot"
 518  * End:
 519  * vim: expandtab shiftwidth=4:
 520  */