src/ops/object.ops

   1 /*
   2
   3 $Id$
   4
   5 object.ops
   6
   7 */
   8
   9 =head1 NAME
  10
  11 object.ops - Class and Object Opcodes
  12
  13 =head1 DESCRIPTION
  14
  15 Parrot's library of object ops
  16
  17 When making changes to any ops file, run C<make bootstrap-ops> to regenerate
  18 all generated ops files.
  19
  20 =over 4
  21
  22 =cut
  23
  24 =item B<callmethodcc>(invar PMC, in STR)
  25
  26 Call method $2 with invocant $1 and generate a new return continuation.
  27 The invocant ($1) is used for method lookup. The object is passed as
  28 the first argument in B<set_args>.
  29
  30 Throws a Method_Not_Found_Exception for a non-existent method.
  31
  32 =item B<callmethodcc>(invar PMC, invar PMC)
  33
  34 Like above but use the Sub object $2 as method.
  35
  36 =item B<callmethod>(invar PMC, in STR, invar PMC)
  37
  38 =item B<callmethod>(invar PMC, invar PMC, invar PMC)
  39
  40 Like above, but use continuation $3 instead of creating a new continuation.
  41
  42 =cut
  43
  44 =item B<tailcallmethod>(invar PMC, in STR)
  45
  46 =item B<tailcallmethod>(invar PMC, invar PMC)
  47
  48 Make a tailcall to method $2 with invocant $1.
  49
  50 =cut
  51
  52 op callmethodcc(invar PMC, in STR) :object_base :flow {
  53     PMC      * const object     = $1;
  54     STRING   * const meth       = $2;
  55     opcode_t * const next       = expr NEXT();
  56
  57     PMC      * const method_pmc = VTABLE_find_method(interp, object, meth);
  58     opcode_t *dest              = NULL;
  59
  60     Parrot_pcc_set_pc_func(interp, CURRENT_CONTEXT(interp), next);
  61
  62     if (!PMC_IS_NULL(method_pmc)) {
  63         PMC * const signature = Parrot_pcc_get_signature(interp,
  64                                     CURRENT_CONTEXT(interp));
  65         if (!PMC_IS_NULL(signature))
  66             Parrot_pcc_set_object(interp, signature, object);
  67
  68         interp->current_cont = NEED_CONTINUATION;
  69         dest                 = VTABLE_invoke(interp, method_pmc, next);
  70     }
  71     else {
  72         PMC * const _class = VTABLE_get_class(interp, object);
  73         if (PMC_IS_NULL(_class)) {
  74             dest = Parrot_ex_throw_from_op_args(interp, next,
  75                 EXCEPTION_METHOD_NOT_FOUND,
  76                 "Method '%Ss' not found for non-object", meth);
  77         }
  78         else {
  79             dest = Parrot_ex_throw_from_op_args(interp, next,
  80                 EXCEPTION_METHOD_NOT_FOUND,
  81                 "Method '%Ss' not found for invocant of class '%Ss'", meth,
  82                 VTABLE_get_string(interp, _class));
  83         }
  84     }
  85
  86     goto ADDRESS(dest);
  87 }
  88
  89 op callmethodcc(invar PMC, invar PMC) :object_base :flow {
  90     opcode_t        *dest;
  91     opcode_t * const next  = expr NEXT();
  92     PMC      *       signature  = Parrot_pcc_get_signature(interp,
  93                                     CURRENT_CONTEXT(interp));
  94
  95     Parrot_pcc_set_pc_func(interp, CURRENT_CONTEXT(interp), next);
  96
  97     if (!PMC_IS_NULL(signature))
  98         Parrot_pcc_set_object(interp, signature, $1);
  99     interp->current_cont   = NEED_CONTINUATION;
 100     dest                   = VTABLE_invoke(interp, $2, next);
 101
 102     goto ADDRESS(dest);
 103 }
 104
 105 op callmethod(invar PMC, in STR, invar PMC) :object_base :flow {
 106     PMC      * const object     = $1;
 107     STRING   * const meth       = $2;
 108     opcode_t * const next       = expr NEXT();
 109
 110     PMC      * const method_pmc = VTABLE_find_method(interp, object, meth);
 111     opcode_t *dest              = NULL;
 112     PMC      *       signature  = Parrot_pcc_get_signature(interp,
 113                                     CURRENT_CONTEXT(interp));
 114
 115     Parrot_pcc_set_pc_func(interp, CURRENT_CONTEXT(interp), next);
 116
 117     if (PMC_IS_NULL(method_pmc)) {
 118         dest = Parrot_ex_throw_from_op_args(interp, next, EXCEPTION_METHOD_NOT_FOUND,
 119             "Method '%Ss' not found for invocant of class '%Ss'", meth,
 120             VTABLE_get_string(interp, VTABLE_get_class(interp, object)));
 121     }
 122     else {
 123         if (!PMC_IS_NULL(signature))
 124             Parrot_pcc_set_object(interp, signature, object);
 125         interp->current_cont = $3;
 126         dest = (opcode_t *)VTABLE_invoke(interp, method_pmc, next);
 127     }
 128     goto ADDRESS(dest);
 129 }
 130
 131 op callmethod(invar PMC, invar PMC, invar PMC) :object_base :flow {
 132     PMC      * const object     = $1;
 133     PMC      * const method_pmc = $2;
 134     opcode_t * const next       = expr NEXT();
 135
 136     opcode_t *dest;
 137     PMC      *       signature  = Parrot_pcc_get_signature(interp,
 138                                     CURRENT_CONTEXT(interp));
 139
 140     Parrot_pcc_set_pc_func(interp, CURRENT_CONTEXT(interp), next);
 141
 142     if (!PMC_IS_NULL(signature))
 143         Parrot_pcc_set_object(interp, signature, object);
 144     interp->current_cont = $3;
 145     dest = (opcode_t *)VTABLE_invoke(interp, method_pmc, next);
 146     goto ADDRESS(dest);
 147 }
 148
 149 op tailcallmethod(invar PMC, in STR) :object_base :flow {
 150     opcode_t * const next       = expr NEXT();
 151     PMC      * const object     = $1;
 152     STRING   * const meth       = $2;
 153     PMC      * const method_pmc = VTABLE_find_method(interp, object, meth);
 154
 155     opcode_t *dest;
 156     PMC      *       signature  = Parrot_pcc_get_signature(interp,
 157                                     CURRENT_CONTEXT(interp));
 158
 159     if (PMC_IS_NULL(method_pmc)) {
 160         dest = Parrot_ex_throw_from_op_args(interp, next, EXCEPTION_METHOD_NOT_FOUND,
 161             "Method '%Ss' not found for invocant of class '%Ss'", meth,
 162             VTABLE_get_string(interp, VTABLE_get_class(interp, object)));
 163     }
 164     else {
 165         interp->current_cont = Parrot_pcc_get_continuation(interp, CURRENT_CONTEXT(interp));
 166         PObj_get_FLAGS(interp->current_cont) |= SUB_FLAG_TAILCALL;
 167         if (!PMC_IS_NULL(signature))
 168             Parrot_pcc_set_object(interp, signature, object);
 169         dest = (opcode_t *)VTABLE_invoke(interp, method_pmc, next);
 170     }
 171     goto ADDRESS(dest);
 172 }
 173
 174 op tailcallmethod(invar PMC, invar PMC) :object_base :flow {
 175     opcode_t * const next       = expr NEXT();
 176     PMC      * const object     = $1;
 177     PMC      * const method_pmc = $2;
 178
 179     opcode_t *dest;
 180     PMC      *       signature  = Parrot_pcc_get_signature(interp,
 181                                     CURRENT_CONTEXT(interp));
 182
 183     interp->current_cont = Parrot_pcc_get_continuation(interp, CURRENT_CONTEXT(interp));
 184     PObj_get_FLAGS(interp->current_cont) |= SUB_FLAG_TAILCALL;
 185
 186     if (!PMC_IS_NULL(signature))
 187         Parrot_pcc_set_object(interp, signature, object);
 188     dest = (opcode_t *)VTABLE_invoke(interp, method_pmc, next);
 189     goto ADDRESS(dest);
 190 }
 191
 192 =item B<addmethod>(invar PMC, in STR, invar PMC)
 193
 194 Adds $3 as a method named $2 to $1.
 195
 196 =cut
 197
 198 inline op addmethod(invar PMC, in STR, invar PMC) :object_classes {
 199     VTABLE_add_method(interp, $1, $2, $3);
 200 }
 201
 202
 203 =item B<can>(out INT, invar PMC, in STR)
 204
 205 Sets result $1 to the result of the "can" vtable function for PMC $2,
 206 given method $3.
 207
 208 =cut
 209
 210 inline op can(out INT, invar PMC, in STR) :object_base {
 211     $1 = VTABLE_can(interp, $2, $3);
 212 }
 213
 214
 215 =item B<does>(out INT, invar PMC, in STR)
 216
 217 Sets result $1 to the result of the "does" vtable function for PMC $2,
 218 given the role of name $3.
 219
 220 =cut
 221
 222 inline op does(out INT, invar PMC, in STR) :object_base {
 223     $1 = $3 ? VTABLE_does(interp, $2, $3) : 0;
 224 }
 225
 226 =item B<does>(out INT, invar PMC, in PMC)
 227
 228 Sets result $1 to the result of the "does" vtable function for PMC $2,
 229 given the role $3.
 230
 231 =cut
 232
 233 inline op does(out INT, invar PMC, in PMC) :object_base {
 234     $1 = $3 ? VTABLE_does_pmc(interp, $2, $3) : 0;
 235 }
 236
 237 =item B<isa>(out INT, invar PMC, in STR)
 238
 239 =item B<isa>(out INT, invar PMC, in PMC)
 240
 241 Sets result $1 to the result of the "isa" vtable function for PMC $2,
 242 given class $3.
 243
 244 =cut
 245
 246 inline op isa(out INT, invar PMC, in STR) :object_base {
 247     $1 = $3 ? VTABLE_isa(interp, $2, $3) : 0;
 248 }
 249
 250 inline op isa(out INT, invar PMC, in PMC) :object_base {
 251     $1 = $3 ? VTABLE_isa_pmc(interp, $2, $3) : 0;
 252 }
 253
 254 ###############################################################################
 255
 256 =item B<newclass>(out PMC, in STR)
 257
 258 Create a new Parrot-style class, named $2, and puts the new PMC for it
 259 into $1.
 260
 261 =item B<newclass>(out PMC, in PMC)
 262
 263 Create a new Parrot-style class, with the name given in $2 as a key,
 264 namespace, or string PMC.
 265
 266 =cut
 267
 268 inline op newclass(out PMC, in STR) :object_classes {
 269     PMC * const name = Parrot_pmc_new(interp, enum_class_String);
 270     VTABLE_set_string_native(interp, name, $2);
 271     $1 = Parrot_pmc_new_init(interp, enum_class_Class, name);
 272 }
 273
 274 inline op newclass(out PMC, in PMC) :object_classes {
 275     $1 = Parrot_pmc_new_init(interp, enum_class_Class, $2);
 276 }
 277
 278 =item B<subclass>(out PMC, in PMC)
 279
 280 =item B<subclass>(out PMC, in PMC, in STR)
 281
 282 =item B<subclass>(out PMC, in PMC, in PMC)
 283
 284 Create a new class, put in $1, that is a subclass of $2.  $3, if available
 285 and not null, is the name of the new class--if not, the subclass is an
 286 anonymous subclass.
 287
 288 =cut
 289
 290 inline op subclass(out PMC, in PMC) :object_classes :flow {
 291     PMC      * const parent_class = Parrot_oo_get_class(interp, $2);
 292     opcode_t * const next         = expr NEXT();
 293
 294     if (PMC_IS_NULL(parent_class)) {
 295         opcode_t *handler = Parrot_ex_throw_from_op_args(interp, next,
 296             EXCEPTION_NO_CLASS,
 297             "Class '%Ss' doesn't exist", VTABLE_get_string(interp, $2));
 298         goto ADDRESS(handler);
 299     }
 300     $1 = Parrot_pmc_new(interp, enum_class_Class);
 301     VTABLE_add_parent(interp, $1, parent_class);
 302     goto ADDRESS(next);
 303 }
 304
 305 inline op subclass(out PMC, in PMC, in STR) :object_classes :flow {
 306     PMC      * const parent_class = Parrot_oo_get_class(interp, $2);
 307     opcode_t * const next         = expr NEXT();
 308
 309     if (PMC_IS_NULL(parent_class)) {
 310         opcode_t * handler = Parrot_ex_throw_from_op_args(interp, next,
 311             EXCEPTION_NO_CLASS,
 312             "Class '%Ss' doesn't exist", VTABLE_get_string(interp, $2));
 313         goto ADDRESS(handler);
 314     }
 315     $1 = Parrot_oo_newclass_from_str(interp, $3);
 316     VTABLE_add_parent(interp, $1, parent_class);
 317     goto ADDRESS(next);
 318 }
 319
 320 inline op subclass(out PMC, in PMC, in PMC) :object_classes :flow {
 321     PMC      * const parent_class = Parrot_oo_get_class(interp, $2);
 322     opcode_t * const next         = expr NEXT();
 323
 324     if (PMC_IS_NULL(parent_class)) {
 325         opcode_t *handler = Parrot_ex_throw_from_op_args(interp, next,
 326             EXCEPTION_NO_CLASS,
 327             "Class '%Ss' doesn't exist", VTABLE_get_string(interp, $2));
 328         goto ADDRESS(handler);
 329     }
 330     $1 = Parrot_pmc_new_init(interp, enum_class_Class, $3);
 331     VTABLE_add_parent(interp, $1, parent_class);
 332     goto ADDRESS(next);
 333 }
 334
 335 =item B<subclass>(out PMC, in STR)
 336
 337 =item B<subclass>(out PMC, in STR, in STR)
 338
 339 =item B<subclass>(out PMC, in STR, in PMC)
 340
 341 Create a new class, put in $1, that is a subclass of the class named $2.
 342 $3, if available and not null, is the name of the new class--if not, the
 343 subclass is an anonymous subclass.
 344
 345 =cut
 346
 347
 348 op subclass(out PMC, in STR) :object_classes :flow {
 349     PMC      * const parent_class = Parrot_oo_get_class_str(interp, $2);
 350     opcode_t * const next         = expr NEXT();
 351
 352     if (PMC_IS_NULL(parent_class)) {
 353         opcode_t *handler = Parrot_ex_throw_from_op_args(interp, next,
 354             EXCEPTION_NO_CLASS,
 355             "Class '%Ss' doesn't exist", $2);
 356         goto ADDRESS(handler);
 357     }
 358
 359     $1 = Parrot_pmc_new(interp, enum_class_Class);
 360     VTABLE_add_parent(interp, $1, parent_class);
 361     goto ADDRESS(next);
 362 }
 363
 364 op subclass(out PMC, in STR, in STR) :object_classes :flow {
 365     PMC      * const parent_class = Parrot_oo_get_class_str(interp, $2);
 366     opcode_t * const next         = expr NEXT();
 367
 368     if (PMC_IS_NULL(parent_class)) {
 369         opcode_t *handler = Parrot_ex_throw_from_op_args(interp, next,
 370             EXCEPTION_NO_CLASS,
 371             "Class '%Ss' doesn't exist", $2);
 372         goto ADDRESS(handler);
 373     }
 374
 375     $1  = Parrot_oo_newclass_from_str(interp, $3);
 376     VTABLE_add_parent(interp, $1, parent_class);
 377     goto ADDRESS(next);
 378 }
 379
 380 op subclass(out PMC, in STR, in PMC) :object_classes :flow {
 381     PMC      * const parent_class = Parrot_oo_get_class_str(interp, $2);
 382     opcode_t * const next         = expr NEXT();
 383
 384     if (PMC_IS_NULL(parent_class)) {
 385         opcode_t *handler = Parrot_ex_throw_from_op_args(interp, next,
 386             EXCEPTION_NO_CLASS,
 387             "Class '%Ss' doesn't exist", $2);
 388         goto ADDRESS(handler);
 389     }
 390
 391     $1 = Parrot_pmc_new_init(interp, enum_class_Class, $3);
 392     VTABLE_add_parent(interp, $1, parent_class);
 393     goto ADDRESS(next);
 394 }
 395
 396 ###############################################################################
 397
 398 =item B<get_class>(out PMC, in STR)
 399
 400 =item B<get_class>(out PMC, in PMC)
 401
 402 Find the PMC for a class, by string name, key or namespace.  This op does
 403 C<not> find the class of an instance of an object.  use C<typeof> for that.
 404
 405 =cut
 406
 407 inline op get_class(out PMC, in STR) :object_classes {
 408     $1 = Parrot_oo_get_class_str(interp, $2);
 409 }
 410
 411 inline op get_class(out PMC, in PMC) :object_classes {
 412     $1 = Parrot_oo_get_class(interp, $2);
 413 }
 414
 415 ###############################################################################
 416
 417 =item B<class>(out PMC, invar PMC)
 418
 419 Get the class PMC for the object in $2 and put it in $1.
 420
 421 =cut
 422
 423 inline op class(out PMC, invar PMC) :object_classes {
 424     $1 = VTABLE_get_class(interp, $2);
 425 }
 426
 427 ##################################################
 428
 429
 430 =item B<addparent>(invar PMC, invar PMC)
 431
 432 Add class $2 to the list of parent classes for $1.
 433
 434 =cut
 435
 436 inline op addparent(invar PMC, invar PMC) :object_classes {
 437     VTABLE_add_parent(interp, $1, $2);
 438 }
 439
 440 =item B<removeparent>(invar PMC, invar PMC)
 441
 442 Remove class $2 from class $1's list of parents.
 443
 444 =cut
 445
 446 inline op removeparent(invar PMC, invar PMC) :object_classes {
 447     VTABLE_remove_parent(interp, $1, $2);
 448 }
 449
 450 =item B<addrole>(invar PMC, invar PMC)
 451
 452 Compose the role $2 into $1.
 453
 454 =cut
 455
 456 inline op addrole(invar PMC, invar PMC) :object_classes {
 457     VTABLE_add_role(interp, $1, $2);
 458 }
 459
 460 =item B<addattribute>(invar PMC, in STR)
 461
 462 Add the attribute named $2 to the class $1.
 463
 464 =cut
 465
 466 inline op addattribute(invar PMC, in STR) :object_classes {
 467     VTABLE_add_attribute(interp, $1, $2, PMCNULL);
 468 }
 469
 470 =item B<removeattribute>(invar PMC, in STR) B<(unimplemented)>
 471
 472 Remove attribute $2 from class $1, specified by name.
 473
 474 =cut
 475
 476 op removeattribute(invar PMC, in STR) :object_classes {
 477     VTABLE_remove_attribute(interp, $1, $2);
 478 }
 479
 480 =item B<getattribute>(out PMC, invar PMC, in STR)
 481
 482 Get the attribute $3 from object $2 and put the result in $1.
 483
 484 =item B<getattribute>(out PMC, invar PMC, in PMC, in STR)
 485
 486 Get the attribute $4 from the parent $3 of object $2 and put the
 487 result in $1. (This is useful for storing data for a parent class
 488 attribute that is overridden in a child class.) The parent $3 is a
 489 class name, namespace, or key PMC.
 490
 491 =cut
 492
 493 inline op getattribute(out PMC, invar PMC, in STR) :object_classes {
 494     $1 = VTABLE_get_attr_str(interp, $2, $3);
 495 }
 496
 497 inline op getattribute(out PMC, invar PMC, in PMC, in STR) :object_classes {
 498     $1 = VTABLE_get_attr_keyed(interp, $2, $3, $4);
 499 }
 500
 501 =item B<setattribute>(invar PMC, in STR, invar PMC)
 502
 503 Set attribute $2 of object $1 to $3.
 504
 505 =item B<setattribute>(invar PMC, in PMC, in STR, invar PMC)
 506
 507 Set attribute $3 of the parent $2 of object $1 to $4. (This is useful
 508 for storing data for a parent class attribute that is overridden in a
 509 child class.) The parent $2 is a class name, namespace, or key PMC.
 510
 511 =cut
 512
 513 inline op setattribute(invar PMC, in STR, invar PMC) :object_classes {
 514     VTABLE_set_attr_str(interp, $1, $2, $3);
 515 }
 516
 517 inline op setattribute(invar PMC, in PMC, in STR, invar PMC) :object_classes {
 518     VTABLE_set_attr_keyed(interp, $1, $2, $3, $4);
 519 }
 520
 521 ###############################################################################
 522
 523 =item B<inspect>(out PMC, in PMC)
 524
 525 Sets $1 to a PMC hash of all introspection data available for $2, keyed on
 526 name.
 527
 528 =item B<inspect>(out PMC, in PMC, in STR)
 529
 530 Sets $1 to a PMC Hash, Array, String, Integer, or Number value with
 531 introspection information corresponding to the requested string name.
 532
 533 =cut
 534
 535 inline op inspect(out PMC, in PMC) :object_classes {
 536     $1 = VTABLE_inspect(interp, $2);
 537 }
 538
 539 inline op inspect(out PMC, in PMC, in STR) :object_classes {
 540     $1 = VTABLE_inspect_str(interp, $2, $3);
 541 }
 542
 543 =back
 544
 545 =head1 COPYRIGHT
 546
 547 Copyright (C) 2001-2009, Parrot Foundation.
 548
 549 =head1 LICENSE
 550
 551 This program is free software. It is subject to the same license
 552 as the Parrot interpreter itself.
 553
 554 =cut
 555
 556 /*
 557  * Local variables:
 558  *   c-file-style: "parrot"
 559  * End:
 560  * vim: expandtab shiftwidth=4:
 561  */