src/ops/set.ops

   1 /*
   2  * $Id$
   3 ** set.ops
   4 */
   5
   6 =head1 NAME
   7
   8 set.ops - Assignment Opcodes
   9
  10 =head1 DESCRIPTION
  11
  12 These operations all set registers to various values.
  13
  14 When making changes to any ops file, run C<make bootstrap-ops> to regenerate
  15 all generated ops files.
  16
  17 =over 4
  18
  19 =cut
  20
  21 ########################################
  22
  23 =item B<clone>(out STR, in STR)
  24
  25 Effectively the same as set $1, $2, except that if $2 is a null STRING, $1 gets
  26 a new empty string instead.
  27
  28 =cut
  29
  30 inline op clone(out STR, in STR) :base_mem {
  31     /* cloning a NULL STRING produces an empty STRING; TT #964 */
  32     $1 = STRING_IS_NULL($2)
  33        ? Parrot_str_new(interp, NULL, 0)
  34        : $2;
  35 }
  36
  37 ########################################
  38
  39 =item B<set>(out INT, in INT)
  40
  41 =item B<set>(out INT, in NUM)
  42
  43 A floating-point number is truncated (rounded toward zero) when assigned
  44 to an integer register.
  45
  46 =item B<set>(out INT, invar PMC)
  47
  48 =item B<set>(out INT, invar PMC)
  49
  50 =item B<set>(out INT, in STR)
  51
  52 =item B<set>(out NUM, in INT)
  53
  54 =item B<set>(out NUM, in NUM)
  55
  56 =item B<set>(out NUM, invar PMC)
  57
  58 =item B<set>(out NUM, in STR)
  59
  60 =item B<set>(invar PMC, in INT)
  61
  62 =item B<set>(invar PMC, in NUM)
  63
  64 =item B<set>(out PMC, invar PMC)
  65
  66 =item B<set>(invar PMC, invar STR)
  67
  68 =item B<set>(out STR, in INT)
  69
  70 =item B<set>(out STR, in NUM)
  71
  72 =item B<set>(out STR, invar PMC)
  73
  74 =item B<set>(out STR, inconst STR)
  75
  76 =item B<set>(out STR, invar STR)
  77
  78 =item B<set>(out PMC, inconst PMC)
  79
  80 =item B<set>(invar PMC, inconst STR)
  81
  82 Set $1 to $2.
  83
  84 =cut
  85
  86 inline op set(out INT, in INT) :base_core {
  87     $1 = $2;
  88 }
  89
  90 inline op set(out INT, in NUM) :base_core {
  91     $1 = (INTVAL)($2);
  92 }
  93
  94 inline op set(out INT, in STR) :base_core {
  95     $1 = Parrot_str_to_int(interp, $2);
  96 }
  97
  98 inline op set(out NUM, in NUM) :base_core {
  99     $1 = $2;
 100 }
 101
 102 inline op set(out NUM, in INT) :base_core {
 103     $1 = (FLOATVAL)$2;
 104 }
 105
 106 inline op set(out NUM, in STR) :base_core {
 107     $1 = Parrot_str_to_num(interp, $2);
 108 }
 109
 110 inline op set(out NUM, invar PMC) :base_core {
 111     $1 = VTABLE_get_number(interp, $2);
 112 }
 113
 114 inline op set(out STR, invar PMC) :base_core {
 115     $1 = VTABLE_get_string(interp, $2);
 116 }
 117
 118 inline op set(out STR, invar STR) :base_core {
 119     $1 = $2;
 120 }
 121
 122 inline op set(out STR, inconst STR) :base_core {
 123     $1 = $2;
 124 }
 125
 126 inline op set(out STR, in INT) :base_core {
 127     $1 = Parrot_str_from_int(interp, $2);
 128 }
 129
 130 inline op set(out STR, in NUM) :base_core {
 131     $1 = Parrot_str_from_num(interp, $2);
 132 }
 133
 134 inline op set(out PMC, inconst PMC) :base_core {
 135     $1 = $2;
 136 }
 137
 138 inline op set(out PMC, invar PMC) :base_core {
 139     $1 = $2;
 140 }
 141
 142 inline op set(invar PMC, in INT) :base_core {
 143     VTABLE_set_integer_native(interp, $1, $2);
 144 }
 145
 146 inline op set(invar PMC, in NUM) :base_core {
 147     VTABLE_set_number_native(interp, $1, $2);
 148 }
 149
 150 inline op set(invar PMC, invar STR) :base_core {
 151     VTABLE_set_string_native(interp, $1, $2);
 152 }
 153
 154 inline op set(invar PMC, inconst STR) :base_core {
 155     VTABLE_set_string_native(interp, $1, $2);
 156 }
 157 inline op set(out INT, invar PMC) :base_core {
 158     $1 = VTABLE_get_integer(interp, $2);
 159 }
 160
 161 =back
 162
 163 =cut
 164
 165 ########################################
 166
 167 =head2 PMC assignment operations: Px = x
 168
 169 =over 4
 170
 171 =item B<assign>(invar PMC, in INT)
 172
 173 =item B<assign>(invar PMC, in NUM)
 174
 175 Assign a new value $2, to PMC $1. Same as the equivalent B<set> opcodes.
 176
 177 =item B<assign>(invar PMC, in STR)
 178
 179 =item B<assign>(invar PMC, invar PMC)
 180
 181 Assign a new value $2, to PMC $1 by copying the value.
 182
 183 =item B<assign>(out STR, in STR)
 184
 185 Assign a new value to a string by reusing the string header.
 186
 187 =item B<setref>(invar PMC, invar PMC)
 188
 189 Make $1 refer to $2 by calling C<set_pmc>.
 190
 191 =item B<deref>(out PMC, invar PMC)
 192
 193 Not strictly an assignment operation: Put into $1 the PMC that the
 194 reference PMC $2 refers to.
 195
 196 =cut
 197
 198 inline op assign(invar PMC, invar PMC) :base_core {
 199     VTABLE_assign_pmc(interp, $1, $2);
 200 }
 201
 202 inline op assign(invar PMC, in INT) :base_core {
 203     VTABLE_set_integer_native(interp, $1, $2);
 204 }
 205
 206 inline op assign(invar PMC, in NUM) :base_core {
 207     VTABLE_set_number_native(interp, $1, $2);
 208 }
 209
 210 inline op assign(invar PMC, in STR) :base_core {
 211     VTABLE_assign_string_native(interp, $1, $2);
 212 }
 213
 214 inline op assign(out STR, in STR) :base_core {
 215     $1 = $2;
 216 }
 217
 218 inline op setref(invar PMC, invar PMC) :base_core {
 219     VTABLE_set_pmc(interp, $1, $2);
 220 }
 221
 222 inline op deref(out PMC, invar PMC) :base_ref {
 223     $1 = VTABLE_get_pmc(interp, $2);
 224 }
 225
 226 =back
 227
 228 =cut
 229
 230 ########################################
 231
 232 =head2 Keyed set operations: Px[ INTKEY ] = Bx
 233
 234 =over 4
 235
 236 =item B<set>(invar PMC, in INTKEY, in INT)
 237
 238 =item B<set>(invar PMC, in INTKEY, in NUM)
 239
 240 =item B<set>(invar PMC, in INTKEY, in STR)
 241
 242 =item B<set>(invar PMC, in INTKEY, invar PMC)
 243
 244 =cut
 245
 246 inline op set(invar PMC, in INTKEY, in INT) :base_core {
 247     VTABLE_set_integer_keyed_int(interp, $1, $2, $3);
 248 }
 249
 250 inline op set(invar PMC, in INTKEY, in NUM) :base_core {
 251     VTABLE_set_number_keyed_int(interp, $1, $2, $3);
 252 }
 253
 254 inline op set(invar PMC, in INTKEY, in STR) :base_core {
 255     VTABLE_set_string_keyed_int(interp, $1, $2, $3);
 256 }
 257
 258 inline op set(invar PMC, in INTKEY, invar PMC) :base_core {
 259     VTABLE_set_pmc_keyed_int(interp, $1, $2, $3);
 260 }
 261
 262 =back
 263
 264 =cut
 265
 266 ########################################
 267
 268 =head2 Keyed get operations: Ax = Px[ INTKEY ]
 269
 270 =over 4
 271
 272 =item B<set>(out INT, invar PMC, in INTKEY)
 273
 274 =item B<set>(out NUM, invar PMC, in INTKEY)
 275
 276 =item B<set>(out STR, invar PMC, in INTKEY)
 277
 278 =item B<set>(out PMC, invar PMC, in INTKEY)
 279
 280 =cut
 281
 282 inline op set(out INT, invar PMC, in INTKEY) :base_core {
 283     $1 = VTABLE_get_integer_keyed_int(interp, $2, $3);
 284 }
 285
 286 inline op set(out NUM, invar PMC, in INTKEY) :base_core {
 287     $1 = VTABLE_get_number_keyed_int(interp, $2, $3);
 288 }
 289
 290 inline op set(out STR, invar PMC, in INTKEY) :base_core {
 291     $1 = VTABLE_get_string_keyed_int(interp, $2, $3);
 292 }
 293
 294 inline op set(out PMC, invar PMC, in INTKEY) :base_core {
 295     $1 = VTABLE_get_pmc_keyed_int(interp, $2, $3);
 296 }
 297
 298 =back
 299
 300 =cut
 301
 302 ########################################
 303
 304 =head2 Keyed set operations: Px[ KEY ] = Bx
 305
 306 =over 4
 307
 308 =item B<set>(invar PMC, in KEY, in INT)
 309
 310 =item B<set>(invar PMC, in KEY, in NUM)
 311
 312 =item B<set>(invar PMC, in KEY, in STR)
 313
 314 =item B<set>(invar PMC, in KEY, invar PMC)
 315
 316 =cut
 317
 318 inline op set(invar PMC, in KEY, in INT) :base_core {
 319     VTABLE_set_integer_keyed(interp, $1, $2, $3);
 320 }
 321
 322 inline op set(invar PMC, in KEY, in NUM) :base_core {
 323     VTABLE_set_number_keyed(interp, $1, $2, $3);
 324 }
 325
 326 inline op set(invar PMC, in KEY, in STR) :base_core {
 327     VTABLE_set_string_keyed(interp, $1, $2, $3);
 328 }
 329
 330 inline op set(invar PMC, in KEY, invar PMC) :base_core {
 331     VTABLE_set_pmc_keyed(interp, $1, $2, $3);
 332 }
 333
 334 =back
 335
 336 =cut
 337
 338 ########################################
 339
 340 =head2 Keyed get operations: Ax = Px[ KEY ]
 341
 342 =over 4
 343
 344 =item B<set>(out INT, invar PMC, in KEY)
 345
 346 =item B<set>(out NUM, invar PMC, in KEY)
 347
 348 =item B<set>(out STR, invar PMC, in KEY)
 349
 350 =item B<set>(out PMC, invar PMC, in KEY)
 351
 352 =cut
 353
 354 inline op set(out INT, invar PMC, in KEY) :base_core {
 355     $1 = VTABLE_get_integer_keyed(interp, $2, $3);
 356 }
 357
 358 inline op set(out NUM, invar PMC, in KEY) :base_core {
 359     $1 = VTABLE_get_number_keyed(interp, $2, $3);
 360 }
 361
 362 inline op set(out STR, invar PMC, in KEY) :base_core {
 363     $1 = VTABLE_get_string_keyed(interp, $2, $3);
 364 }
 365
 366 inline op set(out PMC, invar PMC, in KEY) :base_core {
 367     $1 = VTABLE_get_pmc_keyed(interp, $2, $3);
 368 }
 369
 370 =item B<clone>(out PMC, invar PMC)
 371
 372 Makes a copy of the PMC in $2 and puts it in $1.
 373
 374 =cut
 375
 376 inline op clone(out PMC, invar PMC) :base_mem {
 377     $1 = VTABLE_clone(interp, $2);
 378 }
 379
 380 =item B<clone>(out PMC, invar PMC, in PMC)
 381
 382 Makes a copy of the PMC in $2 and puts it in $1, using the arguments in $3.
 383
 384 =cut
 385
 386 inline op clone(out PMC, invar PMC, in PMC) :base_mem {
 387     $1 = VTABLE_clone_pmc(interp, $2, $3);
 388 }
 389
 390 =item B<copy>(inout PMC, invar PMC)
 391
 392 Morphs the PMC in $1 to the type of the PMC in $2, then assigns $2 to $1.
 393
 394 =cut
 395
 396 inline op copy(inout PMC, invar PMC) :base_mem {
 397     if (PMC_IS_NULL($1)) {
 398         opcode_t * const dest = expr NEXT();
 399         opcode_t * const handler = Parrot_ex_throw_from_op_args(interp, dest,
 400                 EXCEPTION_NULL_REG_ACCESS, "Null PMC in copy");
 401         goto ADDRESS(handler);
 402     }
 403     else {
 404         PMC   * const clone = VTABLE_clone(interp, $2);
 405         /* Preserve the metadata on the destination. */
 406         PMC   * const meta  = VTABLE_getprops(interp, $1);
 407
 408         /* avoid leaks and unreachable memory by destroying the destination PMC */
 409         Parrot_pmc_destroy(interp, $1);
 410
 411         /* the source PMC knows how to clone itself, but we must reuse the
 412          * destination header */
 413         memmove($1, clone, sizeof (PMC));
 414
 415         /* don't let the clone's destruction destroy the destination's data */
 416         PObj_custom_destroy_CLEAR(clone);
 417         PMC_data(clone)        = NULL;
 418         PMC_metadata(clone)    = NULL;
 419
 420         /* Restore metadata. */
 421         if (!PMC_IS_NULL(meta)) {
 422             PMC * const iter = VTABLE_get_iter(interp, meta);
 423             while (VTABLE_get_bool(interp, iter)) {
 424                 STRING * const key = VTABLE_shift_string(interp, iter);
 425                 PMC * const value  = VTABLE_get_pmc_keyed_str(interp, meta, key);
 426                 VTABLE_setprop(interp, $1, key, value);
 427             }
 428         }
 429     }
 430 }
 431
 432 =back
 433
 434 =cut
 435
 436 ###############################################################################
 437
 438 =head2 Register operations
 439
 440 These operations effect entire sets of registers.
 441
 442 =over 4
 443
 444 =cut
 445
 446 ########################################
 447
 448 =item B<null>(out INT)
 449
 450 =item B<null>(out NUM)
 451
 452 Set register $1 to zero.
 453
 454 =item B<null>(out STR)
 455
 456 Set register $1 to a NULL string value.
 457
 458 =item B<null>(out PMC)
 459
 460 Set register $1 to PMCNULL.
 461
 462 =cut
 463
 464 inline op null(out STR) :base_core {
 465     $1 = STRINGNULL;
 466 }
 467
 468 inline op null(out INT) :base_core {
 469     $1 = 0;
 470 }
 471
 472 inline op null(out PMC) :base_core {
 473     $1 = PMCNULL;
 474 }
 475
 476 inline op null(out NUM) :base_core {
 477     $1 = 0;
 478 }
 479
 480 =back
 481
 482 =cut
 483
 484 ###############################################################################
 485
 486 =head1 COPYRIGHT
 487
 488 Copyright (C) 2001-2010, Parrot Foundation.
 489
 490 =head1 LICENSE
 491
 492 This program is free software. It is subject to the same license
 493 as the Parrot interpreter itself.
 494
 495 =cut
 496
 497 /*
 498  * Local variables:
 499  *   c-file-style: "parrot"
 500  * End:
 501  * vim: expandtab shiftwidth=4:
 502  */