languages/WMLScript/pmc/wmlsboolean.pmc

   1 /*
   2 Copyright (C) 2006-2008, The Perl Foundation.
   3 $Id$
   4
   5 =head1 NAME
   6
   7 pmc/wmlsboolean.pmc - WMLScript Boolean
   8
   9 =head1 DESCRIPTION
  10
  11 C<WmlsBoolean> extends C<Boolean> to provide a class with the behaviour of
  12 the WMLScript C<Boolean> type.
  13
  14 =head2 Methods
  15
  16 =over 4
  17
  18 =cut
  19
  20 */
  21
  22 #include "parrot/embed.h"
  23 #include "pmc_wmlsstring.h"
  24
  25 static INTVAL dynpmc_WmlsBoolean;
  26 static INTVAL dynpmc_WmlsFloat;
  27 static INTVAL dynpmc_WmlsInteger;
  28 static INTVAL dynpmc_WmlsInvalid;
  29 static INTVAL dynpmc_WmlsString;
  30
  31 static inline INTVAL num_cmp(FLOATVAL v1, FLOATVAL v2)
  32 {
  33     if (v1 == v2) {
  34         return 0;
  35     }
  36     else if (v1 > v2) {
  37         return 1;
  38     }
  39     else {
  40         return -1;
  41     }
  42 }
  43
  44 static inline INTVAL int_cmp(INTVAL v1, INTVAL v2)
  45 {
  46     if (v1 == v2) {
  47         return 0;
  48     }
  49     else if (v1 > v2) {
  50         return 1;
  51     }
  52     else {
  53         return -1;
  54     }
  55 }
  56
  57
  58 pmclass WmlsBoolean
  59     extends Boolean
  60     provides scalar
  61     provides boolean
  62     provides integer
  63     dynpmc
  64     group wmls_group
  65     hll WMLScript maps Boolean {
  66
  67 /* Class initialization. Caches constant strings that will be used later.
  68 */
  69     void class_init() {
  70         if (pass) {
  71             dynpmc_WmlsBoolean = pmc_type(INTERP,
  72               const_string(INTERP, "WmlsBoolean"));
  73             dynpmc_WmlsFloat = pmc_type(INTERP,
  74               const_string(INTERP, "WmlsFloat"));
  75             dynpmc_WmlsInteger = pmc_type(INTERP,
  76               const_string(INTERP, "WmlsInteger"));
  77             dynpmc_WmlsInvalid = pmc_type(INTERP,
  78               const_string(INTERP, "WmlsInvalid"));
  79             dynpmc_WmlsString = pmc_type(INTERP,
  80               const_string(INTERP, "WmlsString"));
  81         }
  82     }
  83
  84 /*
  85
  86 =item C<PMC* get_class()>
  87
  88 Return the integer 3.
  89
  90 =cut
  91
  92 */
  93     PMC* get_class() {
  94         PMC* retval = pmc_new(interp, dynpmc_WmlsInteger);
  95         PMC_int_val(retval) = 3;
  96         return retval;
  97     }
  98
  99 /*
 100
 101 =item C<STRING* get_string()>
 102
 103 Return the string "true" or "false".
 104
 105 =cut
 106
 107 */
 108     STRING* get_string() {
 109         if (PMC_int_val(SELF))
 110             return const_string(INTERP, "true");
 111         else
 112             return const_string(INTERP, "false");
 113     }
 114
 115 /*
 116
 117 =item C<void increment()>
 118
 119 =cut
 120
 121 */
 122     void increment() {
 123         const INTVAL a = SELF.get_integer();
 124         SELF.morph(dynpmc_WmlsInteger);
 125         SELF.set_integer_native(a);
 126         SELF.increment();
 127     }
 128
 129 /*
 130
 131 =item C<void decrement()>
 132
 133 =cut
 134
 135 */
 136     void decrement() {
 137         const INTVAL a = SELF.get_integer();
 138         SELF.morph(dynpmc_WmlsInteger);
 139         SELF.set_integer_native(a);
 140         SELF.decrement();
 141     }
 142
 143 /*
 144
 145 =item C<PMC* absolute(PMC *dest)>
 146
 147 =item C<void i_absolute()>
 148
 149 =cut
 150
 151 */
 152     PMC* absolute(PMC* dest) {
 153         return pmc_new(INTERP, dynpmc_WmlsInvalid);
 154     }
 155
 156     void i_absolute() {
 157         SELF.morph(dynpmc_WmlsInvalid);
 158     }
 159
 160 /*
 161
 162 =item C<PMC* neg(PMC *dest)>
 163
 164 =item C<void i_neg()>
 165
 166 =cut
 167
 168 */
 169     PMC* neg(PMC* dest) {
 170         dest = pmc_new(INTERP, dynpmc_WmlsInteger);
 171         PMC_int_val(dest) = - SELF.get_bool();
 172         return dest;
 173     }
 174
 175     void i_neg() {
 176         INTVAL result = - SELF.get_bool();
 177         SELF.morph(dynpmc_WmlsInteger);
 178         SELF.set_integer_native(result);
 179     }
 180
 181 /*
 182
 183 =item C<PMC* bitwise_not(PMC *dest)>
 184
 185 =item C<void i_bitwise_not()>
 186
 187 =cut
 188
 189 */
 190     PMC* bitwise_not(PMC* dest) {
 191         dest = pmc_new(INTERP, dynpmc_WmlsInteger);
 192         PMC_int_val(dest) = ~ SELF.get_bool();
 193         return dest;
 194     }
 195
 196     void i_bitwise_not() {
 197         INTVAL result = ~ SELF.get_bool();
 198         SELF.morph(dynpmc_WmlsInteger);
 199         SELF.set_integer_native(result);
 200     }
 201
 202 /*
 203
 204 =item C<PMC* logical_not(PMC *dest)>
 205
 206 =item C<void i_logical_not()>
 207
 208 =cut
 209
 210 */
 211     PMC* logical_not(PMC* dest) {
 212         dest = pmc_new(INTERP, dynpmc_WmlsBoolean);
 213         VTABLE_set_bool(INTERP, dest, ! SELF.get_bool());
 214         return dest;
 215     }
 216
 217     void i_logical_not() {
 218         INTVAL result = ! SELF.get_bool();
 219         SELF.set_integer_native(result);
 220     }
 221
 222 /*
 223
 224 =back
 225
 226 =head2 non-Vtable Methods
 227
 228 =over 4
 229
 230 =item C<void add(PMC *value, PMC *dest)>
 231
 232 =item C<void i_add(PMC *value)>
 233
 234 =cut
 235
 236 */
 237     PMC* add(PMC* value, PMC* dest) {
 238 MMD_WmlsInteger: {
 239             INTVAL result = SELF.get_integer()
 240                           + VTABLE_get_integer(INTERP, value);
 241             dest = pmc_new(INTERP, dynpmc_WmlsInteger);
 242             VTABLE_set_integer_native(INTERP, dest, result);
 243             return dest;
 244         }
 245 MMD_WmlsBoolean: {
 246             INTVAL result = SELF.get_integer()
 247                           + VTABLE_get_integer(INTERP, value);
 248             dest = pmc_new(INTERP, dynpmc_WmlsInteger);
 249             VTABLE_set_integer_native(INTERP, dest, result);
 250             return dest;
 251         }
 252 MMD_WmlsFloat: {
 253             FLOATVAL result = SELF.get_number()
 254                             + VTABLE_get_number(INTERP, value);
 255             dest = pmc_new(INTERP, dynpmc_WmlsFloat);
 256             VTABLE_set_number_native(INTERP, dest, result);
 257             return dest;
 258         }
 259 MMD_WmlsString: {
 260             STRING* result = string_concat(INTERP,
 261                   SELF.get_string(),
 262                   VTABLE_get_string(INTERP, value), 0);
 263             dest = pmc_new(INTERP, dynpmc_WmlsString);
 264             VTABLE_set_string_native(INTERP, dest, result);
 265             return dest;
 266         }
 267 MMD_DEFAULT: {
 268             return pmc_new(INTERP, dynpmc_WmlsInvalid);
 269         }
 270     }
 271
 272     void i_add(PMC* value) {
 273 MMD_WmlsInteger: {
 274             INTVAL result = SELF.get_integer()
 275                           + VTABLE_get_integer(INTERP, value);
 276             SELF.morph(dynpmc_WmlsInteger);
 277             SELF.set_integer_native(result);
 278         }
 279 MMD_WmlsBoolean: {
 280             INTVAL result = SELF.get_integer()
 281                           + VTABLE_get_integer(INTERP, value);
 282             SELF.morph(dynpmc_WmlsInteger);
 283             SELF.set_integer_native(result);
 284         }
 285 MMD_WmlsFloat: {
 286             FLOATVAL result = SELF.get_number()
 287                             + VTABLE_get_number(INTERP, value);
 288             SELF.morph(dynpmc_WmlsFloat);
 289             SELF.set_number_native(result);
 290         }
 291 MMD_WmlsString: {
 292             STRING* result = string_concat(INTERP,
 293                   SELF.get_string(),
 294                   VTABLE_get_string(INTERP, value), 0);
 295             SELF.morph(dynpmc_WmlsString);
 296             SELF.set_string_native(result);
 297         }
 298 MMD_DEFAULT: {
 299             SELF.morph(dynpmc_WmlsInvalid);
 300         }
 301     }
 302
 303 /*
 304
 305 =item C<PMC* subtract(PMC *value, PMC *dest)>
 306
 307 =item C<void i_subtract(PMC *value)>
 308
 309 =cut
 310
 311 */
 312     PMC* subtract(PMC* value, PMC* dest) {
 313 MMD_WmlsInteger: {
 314             INTVAL result = SELF.get_integer()
 315                           - VTABLE_get_integer(INTERP, value);
 316             dest = pmc_new(INTERP, dynpmc_WmlsInteger);
 317             VTABLE_set_integer_native(INTERP, dest, result);
 318             return dest;
 319         }
 320 MMD_WmlsBoolean: {
 321             INTVAL result = SELF.get_integer()
 322                           - VTABLE_get_integer(INTERP, value);
 323             dest = pmc_new(INTERP, dynpmc_WmlsInteger);
 324             VTABLE_set_integer_native(INTERP, dest, result);
 325             return dest;
 326         }
 327 MMD_WmlsFloat: {
 328             FLOATVAL result = SELF.get_number()
 329                             - VTABLE_get_number(INTERP, value);
 330             dest = pmc_new(INTERP, dynpmc_WmlsFloat);
 331             VTABLE_set_number_native(INTERP, dest, result);
 332             return dest;
 333         }
 334 MMD_WmlsString: {
 335             PMC *trans;
 336             Parrot_PCCINVOKE(interp, value, const_string(interp, "parseInt"),
 337                     "->P", &trans);
 338
 339             if (trans->vtable->base_type == dynpmc_WmlsInteger) {
 340                 INTVAL result = SELF.get_integer()
 341                               - VTABLE_get_integer(INTERP, trans);
 342                 dest = pmc_new(INTERP, dynpmc_WmlsInteger);
 343                 VTABLE_set_integer_native(INTERP, dest, result);
 344                 return dest;
 345             }
 346             return pmc_new(INTERP, dynpmc_WmlsInvalid);
 347         }
 348 MMD_DEFAULT: {
 349             return pmc_new(INTERP, dynpmc_WmlsInvalid);
 350         }
 351     }
 352
 353     void i_subtract(PMC* value) {
 354 MMD_WmlsInteger: {
 355             INTVAL result = SELF.get_integer()
 356                           - VTABLE_get_integer(INTERP, value);
 357             SELF.morph(dynpmc_WmlsInteger);
 358             SELF.set_integer_native(result);
 359         }
 360 MMD_WmlsBoolean: {
 361             INTVAL result = SELF.get_integer()
 362                           - VTABLE_get_integer(INTERP, value);
 363             SELF.morph(dynpmc_WmlsInteger);
 364             SELF.set_integer_native(result);
 365         }
 366 MMD_WmlsFloat: {
 367             FLOATVAL result = SELF.get_number()
 368                             - VTABLE_get_number(INTERP, value);
 369             SELF.morph(dynpmc_WmlsFloat);
 370             SELF.set_number_native(result);
 371         }
 372 MMD_WmlsString: {
 373             PMC *trans;
 374             Parrot_PCCINVOKE(interp, value, const_string(interp, "parseInt"),
 375                     "->P", &trans);
 376
 377             if (trans->vtable->base_type == dynpmc_WmlsInteger) {
 378                 INTVAL result = SELF.get_integer()
 379                               - VTABLE_get_integer(INTERP, trans);
 380                 SELF.morph(dynpmc_WmlsInteger);
 381                 SELF.set_integer_native(result);
 382             }
 383             else {
 384                 SELF.morph(dynpmc_WmlsInvalid);
 385             }
 386         }
 387 MMD_DEFAULT: {
 388             SELF.morph(dynpmc_WmlsInvalid);
 389         }
 390     }
 391
 392 /*
 393
 394 =item C<PMC* multiply(PMC *value, PMC *dest)>
 395
 396 =item C<void i_multiply(PMC *value)>
 397
 398 =cut
 399
 400 */
 401     PMC* multiply(PMC* value, PMC* dest) {
 402 MMD_WmlsInteger: {
 403             INTVAL result = SELF.get_integer()
 404                           * VTABLE_get_integer(INTERP, value);
 405             dest = pmc_new(INTERP, dynpmc_WmlsInteger);
 406             VTABLE_set_integer_native(INTERP, dest, result);
 407             return dest;
 408         }
 409 MMD_WmlsBoolean: {
 410             INTVAL result = SELF.get_integer()
 411                           * VTABLE_get_integer(INTERP, value);
 412             dest = pmc_new(INTERP, dynpmc_WmlsInteger);
 413             VTABLE_set_integer_native(INTERP, dest, result);
 414             return dest;
 415         }
 416 MMD_WmlsFloat: {
 417             FLOATVAL result = SELF.get_number()
 418                             * VTABLE_get_number(INTERP, value);
 419             dest = pmc_new(INTERP, dynpmc_WmlsFloat);
 420             VTABLE_set_number_native(INTERP, dest, result);
 421             return dest;
 422         }
 423 MMD_WmlsString: {
 424             PMC *trans;
 425             Parrot_PCCINVOKE(interp, value, const_string(interp, "parseInt"),
 426                     "->P", &trans);
 427
 428             if (trans->vtable->base_type == dynpmc_WmlsInteger) {
 429                 INTVAL result = SELF.get_integer()
 430                               * VTABLE_get_integer(INTERP, trans);
 431                 dest = pmc_new(INTERP, dynpmc_WmlsInteger);
 432                 VTABLE_set_integer_native(INTERP, dest, result);
 433                 return dest;
 434             }
 435             return pmc_new(INTERP, dynpmc_WmlsInvalid);
 436         }
 437 MMD_DEFAULT: {
 438             return pmc_new(INTERP, dynpmc_WmlsInvalid);
 439         }
 440     }
 441
 442     void i_multiply(PMC* value) {
 443 MMD_WmlsInteger: {
 444             INTVAL result = SELF.get_integer()
 445                           * VTABLE_get_integer(INTERP, value);
 446             SELF.morph(dynpmc_WmlsInteger);
 447             SELF.set_integer_native(result);
 448         }
 449 MMD_WmlsBoolean: {
 450             INTVAL result = SELF.get_integer()
 451                           * VTABLE_get_integer(INTERP, value);
 452             SELF.morph(dynpmc_WmlsInteger);
 453             SELF.set_integer_native(result);
 454         }
 455 MMD_WmlsFloat: {
 456             FLOATVAL result = SELF.get_number()
 457                             * VTABLE_get_number(INTERP, value);
 458             SELF.morph(dynpmc_WmlsFloat);
 459             SELF.set_number_native(result);
 460         }
 461 MMD_WmlsString: {
 462             PMC *trans;
 463             Parrot_PCCINVOKE(interp, value, const_string(interp, "parseInt"),
 464                     "->P", &trans);
 465
 466             if (trans->vtable->base_type == dynpmc_WmlsInteger) {
 467                 INTVAL result = SELF.get_integer()
 468                               * VTABLE_get_integer(INTERP, trans);
 469                 SELF.morph(dynpmc_WmlsInteger);
 470                 SELF.set_integer_native(result);
 471             }
 472             else {
 473                 SELF.morph(dynpmc_WmlsInvalid);
 474             }
 475         }
 476 MMD_DEFAULT: {
 477             SELF.morph(dynpmc_WmlsInvalid);
 478         }
 479     }
 480
 481 /*
 482
 483 =item C<PMC* divide(PMC *value, PMC *dest)>
 484
 485 =item C<void i_divide(PMC *value)>
 486
 487 =cut
 488
 489 */
 490     PMC* divide(PMC* value, PMC* dest) {
 491 MMD_WmlsFloat: {
 492             FLOATVAL d = VTABLE_get_number(INTERP, value);
 493             if (d != 0.0) {
 494                 FLOATVAL result = SELF.get_number() / d;
 495                 dest = pmc_new(INTERP, dynpmc_WmlsFloat);
 496                 VTABLE_set_number_native(INTERP, dest, result);
 497                 return dest;
 498             }
 499             return pmc_new(INTERP, dynpmc_WmlsInvalid);
 500         }
 501 MMD_WmlsInteger: {
 502             FLOATVAL d = VTABLE_get_number(INTERP, value);
 503             if (d != 0.0) {
 504                 FLOATVAL result = SELF.get_number() / d;
 505                 dest = pmc_new(INTERP, dynpmc_WmlsFloat);
 506                 VTABLE_set_number_native(INTERP, dest, result);
 507                 return dest;
 508             }
 509             return pmc_new(INTERP, dynpmc_WmlsInvalid);
 510         }
 511 MMD_WmlsBoolean: {
 512             FLOATVAL d = VTABLE_get_number(INTERP, value);
 513             if (d != 0.0) {
 514                 FLOATVAL result = SELF.get_number() / d;
 515                 dest = pmc_new(INTERP, dynpmc_WmlsFloat);
 516                 VTABLE_set_number_native(INTERP, dest, result);
 517                 return dest;
 518             }
 519             return pmc_new(INTERP, dynpmc_WmlsInvalid);
 520         }
 521 MMD_WmlsString: {
 522             PMC *trans;
 523             Parrot_PCCINVOKE(interp, value, const_string(interp, "parseInt"),
 524                     "->P", &trans);
 525
 526             if (trans->vtable->base_type == dynpmc_WmlsInteger) {
 527                 FLOATVAL d = VTABLE_get_number(INTERP, trans);
 528                 if (d != 0.0) {
 529                     FLOATVAL result = SELF.get_number() / d;
 530                     dest = pmc_new(INTERP, dynpmc_WmlsFloat);
 531                     VTABLE_set_number_native(INTERP, dest, result);
 532                     return dest;
 533                 }
 534             }
 535             return pmc_new(INTERP, dynpmc_WmlsInvalid);
 536         }
 537 MMD_DEFAULT: {
 538             return pmc_new(INTERP, dynpmc_WmlsInvalid);
 539         }
 540     }
 541
 542     void i_divide(PMC* value) {
 543 MMD_WmlsFloat: {
 544             FLOATVAL d = VTABLE_get_number(INTERP, value);
 545             if (d != 0.0) {
 546                 FLOATVAL result = SELF.get_number() / d;
 547                 SELF.morph(dynpmc_WmlsFloat);
 548                 SELF.set_number_native(result);
 549             }
 550             else {
 551                 SELF.morph(dynpmc_WmlsInvalid);
 552             }
 553         }
 554 MMD_WmlsInteger: {
 555             FLOATVAL d = VTABLE_get_number(INTERP, value);
 556             if (d != 0.0) {
 557                 FLOATVAL result = SELF.get_number() / d;
 558                 SELF.morph(dynpmc_WmlsFloat);
 559                 SELF.set_number_native(result);
 560             }
 561             else {
 562                 SELF.morph(dynpmc_WmlsInvalid);
 563             }
 564         }
 565 MMD_WmlsBoolean: {
 566             FLOATVAL d = VTABLE_get_number(INTERP, value);
 567             if (d != 0.0) {
 568                 FLOATVAL result = SELF.get_number() / d;
 569                 SELF.morph(dynpmc_WmlsFloat);
 570                 SELF.set_number_native(result);
 571             }
 572             else {
 573                 SELF.morph(dynpmc_WmlsInvalid);
 574             }
 575         }
 576 MMD_WmlsString: {
 577             PMC *trans;
 578             Parrot_PCCINVOKE(interp, value, const_string(interp, "parseInt"),
 579                     "->P", &trans);
 580
 581             if (trans->vtable->base_type == dynpmc_WmlsInteger) {
 582                 FLOATVAL d = VTABLE_get_integer(INTERP, trans);
 583                 if (d != 0.0) {
 584                     FLOATVAL result = SELF.get_number() / d;
 585                     SELF.morph(dynpmc_WmlsFloat);
 586                     SELF.set_number_native(result);
 587                 }
 588                 else {
 589                     SELF.morph(dynpmc_WmlsInvalid);
 590                 }
 591             }
 592             else {
 593                 SELF.morph(dynpmc_WmlsInvalid);
 594             }
 595         }
 596 MMD_DEFAULT: {
 597             SELF.morph(dynpmc_WmlsInvalid);
 598         }
 599     }
 600
 601 /*
 602
 603 =item C<PMC* floor_divide(PMC *value, PMC *dest)>
 604
 605 =item C<void i_floor_divide(PMC *value)>
 606
 607 =cut
 608
 609 */
 610     PMC* floor_divide(PMC* value, PMC* dest) {
 611 MMD_WmlsInteger: {
 612             INTVAL d = VTABLE_get_integer(INTERP, value);
 613             if (d != 0) {
 614                 INTVAL result = SELF.get_integer() / d;
 615                 dest = pmc_new(INTERP, dynpmc_WmlsInteger);
 616                 VTABLE_set_integer_native(INTERP, dest, result);
 617                 return dest;
 618             }
 619             return pmc_new(INTERP, dynpmc_WmlsInvalid);
 620         }
 621 MMD_WmlsBoolean: {
 622             INTVAL d = VTABLE_get_integer(INTERP, value);
 623             if (d != 0) {
 624                 INTVAL result = SELF.get_integer() / d;
 625                 dest = pmc_new(INTERP, dynpmc_WmlsInteger);
 626                 VTABLE_set_integer_native(INTERP, dest, result);
 627                 return dest;
 628             }
 629             return pmc_new(INTERP, dynpmc_WmlsInvalid);
 630         }
 631 MMD_WmlsString: {
 632             PMC *trans;
 633             Parrot_PCCINVOKE(interp, value, const_string(interp, "parseInt"),
 634                     "->P", &trans);
 635
 636             if (trans->vtable->base_type == dynpmc_WmlsInteger) {
 637                 INTVAL d = VTABLE_get_integer(INTERP, trans);
 638                 if (d != 0) {
 639                     INTVAL result = SELF.get_integer() / d;
 640                     dest = pmc_new(INTERP, dynpmc_WmlsInteger);
 641                     VTABLE_set_integer_native(INTERP, dest, result);
 642                     return dest;
 643                 }
 644             }
 645             return pmc_new(INTERP, dynpmc_WmlsInvalid);
 646         }
 647 MMD_DEFAULT: {
 648             return pmc_new(INTERP, dynpmc_WmlsInvalid);
 649         }
 650     }
 651
 652     void i_floor_divide(PMC* value) {
 653 MMD_WmlsInteger: {
 654             INTVAL d = VTABLE_get_integer(INTERP, value);
 655             if (d != 0) {
 656                 INTVAL result = SELF.get_integer() / d;
 657                 SELF.morph(dynpmc_WmlsInteger);
 658                 SELF.set_integer_native(result);
 659             }
 660             else {
 661                 SELF.morph(dynpmc_WmlsInvalid);
 662             }
 663         }
 664 MMD_WmlsBoolean: {
 665             INTVAL d = VTABLE_get_integer(INTERP, value);
 666             if (d != 0) {
 667                 INTVAL result = SELF.get_integer() / d;
 668                 SELF.morph(dynpmc_WmlsInteger);
 669                 SELF.set_integer_native(result);
 670             }
 671             else {
 672                 SELF.morph(dynpmc_WmlsInvalid);
 673             }
 674         }
 675 MMD_WmlsString: {
 676             PMC *trans;
 677             Parrot_PCCINVOKE(interp, value, const_string(interp, "parseInt"),
 678                     "->P", &trans);
 679
 680             if (trans->vtable->base_type == dynpmc_WmlsInteger) {
 681                 INTVAL d = VTABLE_get_integer(INTERP, trans);
 682                 if (d != 0) {
 683                     INTVAL result = SELF.get_integer() / d;
 684                     SELF.morph(dynpmc_WmlsInteger);
 685                     SELF.set_integer_native(result);
 686                 }
 687                 else {
 688                     SELF.morph(dynpmc_WmlsInvalid);
 689                 }
 690             }
 691             else {
 692                 SELF.morph(dynpmc_WmlsInvalid);
 693             }
 694         }
 695 MMD_DEFAULT: {
 696             SELF.morph(dynpmc_WmlsInvalid);
 697         }
 698     }
 699
 700 /*
 701
 702 =item C<PMC* cmodulus(PMC *value, PMC *dest)>
 703
 704 =item C<void i_cmodulus(PMC *value)>
 705
 706 =cut
 707
 708 */
 709     PMC* cmodulus(PMC* value, PMC* dest) {
 710 MMD_WmlsInteger: {
 711             INTVAL d = VTABLE_get_integer(INTERP, value);
 712             if (d != 0) {
 713                 INTVAL result = SELF.get_integer() % d;
 714                 dest = pmc_new(INTERP, dynpmc_WmlsInteger);
 715                 VTABLE_set_integer_native(INTERP, dest, result);
 716                 return dest;
 717             }
 718             return pmc_new(INTERP, dynpmc_WmlsInvalid);
 719         }
 720 MMD_WmlsBoolean: {
 721             INTVAL d = VTABLE_get_integer(INTERP, value);
 722             if (d != 0) {
 723                 INTVAL result = SELF.get_integer() % d;
 724                 dest = pmc_new(INTERP, dynpmc_WmlsInteger);
 725                 VTABLE_set_integer_native(INTERP, dest, result);
 726                 return dest;
 727             }
 728             return pmc_new(INTERP, dynpmc_WmlsInvalid);
 729         }
 730 MMD_WmlsString: {
 731             PMC *trans;
 732             Parrot_PCCINVOKE(interp, value, const_string(interp, "parseInt"),
 733                     "->P", &trans);
 734
 735             if (trans->vtable->base_type == dynpmc_WmlsInteger) {
 736                 INTVAL d = VTABLE_get_integer(INTERP, trans);
 737                 if (d != 0) {
 738                     INTVAL result = SELF.get_integer() % d;
 739                     dest = pmc_new(INTERP, dynpmc_WmlsInteger);
 740                     VTABLE_set_integer_native(INTERP, dest, result);
 741                     return dest;
 742                 }
 743             }
 744             return pmc_new(INTERP, dynpmc_WmlsInvalid);
 745         }
 746 MMD_DEFAULT: {
 747             return pmc_new(INTERP, dynpmc_WmlsInvalid);
 748         }
 749     }
 750
 751     void i_cmodulus(PMC* value) {
 752 MMD_WmlsInteger: {
 753             INTVAL d = VTABLE_get_integer(INTERP, value);
 754             if (d != 0) {
 755                 INTVAL result = SELF.get_integer() % d;
 756                 SELF.morph(dynpmc_WmlsInteger);
 757                 SELF.set_integer_native(result);
 758             }
 759             else {
 760                 SELF.morph(dynpmc_WmlsInvalid);
 761             }
 762         }
 763 MMD_WmlsBoolean: {
 764             INTVAL d = VTABLE_get_integer(INTERP, value);
 765             if (d != 0) {
 766                 INTVAL result = SELF.get_integer() % d;
 767                 SELF.morph(dynpmc_WmlsInteger);
 768                 SELF.set_integer_native(result);
 769             }
 770             else {
 771                 SELF.morph(dynpmc_WmlsInvalid);
 772             }
 773         }
 774 MMD_WmlsString: {
 775             PMC *trans;
 776             Parrot_PCCINVOKE(interp, value, const_string(interp, "parseInt"),
 777                     "->P", &trans);
 778
 779             if (trans->vtable->base_type == dynpmc_WmlsInteger) {
 780                 INTVAL d = VTABLE_get_integer(INTERP, trans);
 781                 if (d != 0) {
 782                     INTVAL result = SELF.get_integer() % d;
 783                     SELF.morph(dynpmc_WmlsInteger);
 784                     SELF.set_integer_native(result);
 785                 }
 786                 else {
 787                     SELF.morph(dynpmc_WmlsInvalid);
 788                 }
 789             }
 790             else {
 791                 SELF.morph(dynpmc_WmlsInvalid);
 792             }
 793         }
 794 MMD_DEFAULT: {
 795             SELF.morph(dynpmc_WmlsInvalid);
 796         }
 797     }
 798
 799 /*
 800
 801 =item C<PMC* bitwise_or(PMC *value, PMC *dest)>
 802
 803 =item C<void i_bitwise_or(PMC *value)>
 804
 805 =cut
 806
 807 */
 808     PMC* bitwise_or(PMC* value, PMC* dest) {
 809 MMD_WmlsInteger: {
 810             INTVAL result = SELF.get_integer()
 811                           | VTABLE_get_integer(INTERP, value);
 812             dest = pmc_new(INTERP, dynpmc_WmlsInteger);
 813             VTABLE_set_integer_native(INTERP, dest, result);
 814             return dest;
 815         }
 816 MMD_WmlsBoolean: {
 817             INTVAL result = SELF.get_integer()
 818                           | VTABLE_get_integer(INTERP, value);
 819             dest = pmc_new(INTERP, dynpmc_WmlsInteger);
 820             VTABLE_set_integer_native(INTERP, dest, result);
 821             return dest;
 822         }
 823 MMD_WmlsString: {
 824             PMC *trans;
 825             Parrot_PCCINVOKE(interp, value, const_string(interp, "parseInt"),
 826                     "->P", &trans);
 827
 828             if (trans->vtable->base_type == dynpmc_WmlsInteger) {
 829                 INTVAL result = SELF.get_integer()
 830                               | VTABLE_get_integer(INTERP, trans);
 831                 dest = pmc_new(INTERP, dynpmc_WmlsInteger);
 832                 VTABLE_set_integer_native(INTERP, dest, result);
 833                 return dest;
 834             }
 835             return pmc_new(INTERP, dynpmc_WmlsInvalid);
 836         }
 837 MMD_DEFAULT: {
 838             return pmc_new(INTERP, dynpmc_WmlsInvalid);
 839         }
 840     }
 841
 842     void i_bitwise_or(PMC* value) {
 843 MMD_WmlsInteger: {
 844             INTVAL result = SELF.get_integer()
 845                           | VTABLE_get_integer(INTERP, value);
 846             SELF.morph(dynpmc_WmlsInteger);
 847             SELF.set_integer_native(result);
 848         }
 849 MMD_WmlsBoolean: {
 850             INTVAL result = SELF.get_integer()
 851                           | VTABLE_get_integer(INTERP, value);
 852             SELF.morph(dynpmc_WmlsInteger);
 853             SELF.set_integer_native(result);
 854         }
 855 MMD_WmlsString: {
 856             PMC *trans;
 857             Parrot_PCCINVOKE(interp, value, const_string(interp, "parseInt"),
 858                     "->P", &trans);
 859
 860             if (trans->vtable->base_type == dynpmc_WmlsInteger) {
 861                 INTVAL result = SELF.get_integer()
 862                               | VTABLE_get_integer(INTERP, trans);
 863                 SELF.morph(dynpmc_WmlsInteger);
 864                 SELF.set_integer_native(result);
 865             }
 866             else {
 867                 SELF.morph(dynpmc_WmlsInvalid);
 868             }
 869         }
 870 MMD_DEFAULT: {
 871             SELF.morph(dynpmc_WmlsInvalid);
 872         }
 873     }
 874
 875 /*
 876
 877 =item C<PMC* bitwise_and(PMC *value, PMC *dest)>
 878
 879 =item C<void i_bitwise_and(PMC *value)>
 880
 881 =cut
 882
 883 */
 884     PMC* bitwise_and(PMC* value, PMC* dest) {
 885 MMD_WmlsInteger: {
 886             INTVAL result = SELF.get_integer()
 887                           & VTABLE_get_integer(INTERP, value);
 888             dest = pmc_new(INTERP, dynpmc_WmlsInteger);
 889             VTABLE_set_integer_native(INTERP, dest, result);
 890             return dest;
 891         }
 892 MMD_WmlsBoolean: {
 893             INTVAL result = SELF.get_integer()
 894                           & VTABLE_get_integer(INTERP, value);
 895             dest = pmc_new(INTERP, dynpmc_WmlsInteger);
 896             VTABLE_set_integer_native(INTERP, dest, result);
 897             return dest;
 898         }
 899 MMD_WmlsString: {
 900             PMC *trans;
 901             Parrot_PCCINVOKE(interp, value, const_string(interp, "parseInt"),
 902                     "->P", &trans);
 903
 904             if (trans->vtable->base_type == dynpmc_WmlsInteger) {
 905                 INTVAL result = SELF.get_integer()
 906                               & VTABLE_get_integer(INTERP, trans);
 907                 dest = pmc_new(INTERP, dynpmc_WmlsInteger);
 908                 VTABLE_set_integer_native(INTERP, dest, result);
 909                 return dest;
 910             }
 911             return pmc_new(INTERP, dynpmc_WmlsInvalid);
 912         }
 913 MMD_DEFAULT: {
 914             return pmc_new(INTERP, dynpmc_WmlsInvalid);
 915         }
 916     }
 917
 918     void i_bitwise_and(PMC* value) {
 919 MMD_WmlsInteger: {
 920             INTVAL result = SELF.get_integer()
 921                           & VTABLE_get_integer(INTERP, value);
 922             SELF.morph(dynpmc_WmlsInteger);
 923             SELF.set_integer_native(result);
 924         }
 925 MMD_WmlsBoolean: {
 926             INTVAL result = SELF.get_integer()
 927                           & VTABLE_get_integer(INTERP, value);
 928             SELF.morph(dynpmc_WmlsInteger);
 929             SELF.set_integer_native(result);
 930         }
 931 MMD_WmlsString: {
 932             PMC *trans;
 933             Parrot_PCCINVOKE(interp, value, const_string(interp, "parseInt"),
 934                     "->P", &trans);
 935
 936             if (trans->vtable->base_type == dynpmc_WmlsInteger) {
 937                 INTVAL result = SELF.get_integer()
 938                               & VTABLE_get_integer(INTERP, trans);
 939                 SELF.morph(dynpmc_WmlsInteger);
 940                 SELF.set_integer_native(result);
 941             }
 942             else {
 943                 SELF.morph(dynpmc_WmlsInvalid);
 944             }
 945         }
 946 MMD_DEFAULT: {
 947             SELF.morph(dynpmc_WmlsInvalid);
 948         }
 949     }
 950
 951 /*
 952
 953 =item C<void bitwise_xor(PMC *value, PMC *dest)>
 954
 955 =item C<void i_bitwise_xor(PMC *value)>
 956
 957 =cut
 958
 959 */
 960     PMC* bitwise_xor(PMC* value, PMC* dest) {
 961 MMD_WmlsInteger: {
 962             INTVAL result = SELF.get_integer()
 963                           ^ VTABLE_get_integer(INTERP, value);
 964             dest = pmc_new(INTERP, dynpmc_WmlsInteger);
 965             VTABLE_set_integer_native(INTERP, dest, result);
 966             return dest;
 967         }
 968 MMD_WmlsBoolean: {
 969             INTVAL result = SELF.get_integer()
 970                           ^ VTABLE_get_integer(INTERP, value);
 971             dest = pmc_new(INTERP, dynpmc_WmlsInteger);
 972             VTABLE_set_integer_native(INTERP, dest, result);
 973             return dest;
 974         }
 975 MMD_WmlsString: {
 976             PMC *trans;
 977             Parrot_PCCINVOKE(interp, value, const_string(interp, "parseInt"),
 978                     "->P", &trans);
 979
 980             if (trans->vtable->base_type == dynpmc_WmlsInteger) {
 981                 INTVAL result = SELF.get_integer()
 982                               ^ VTABLE_get_integer(INTERP, trans);
 983                 dest = pmc_new(INTERP, dynpmc_WmlsInteger);
 984                 VTABLE_set_integer_native(INTERP, dest, result);
 985                 return dest;
 986             }
 987             return pmc_new(INTERP, dynpmc_WmlsInvalid);
 988         }
 989 MMD_DEFAULT: {
 990             return pmc_new(INTERP, dynpmc_WmlsInvalid);
 991         }
 992     }
 993
 994     void i_bitwise_xor(PMC* value) {
 995 MMD_WmlsInteger: {
 996             INTVAL result = SELF.get_integer()
 997                           ^ VTABLE_get_integer(INTERP, value);
 998             SELF.morph(dynpmc_WmlsInteger);
 999             SELF.set_integer_native(result);
1000         }
1001 MMD_WmlsBoolean: {
1002             INTVAL result = SELF.get_integer()
1003                           ^ VTABLE_get_integer(INTERP, value);
1004             SELF.morph(dynpmc_WmlsInteger);
1005             SELF.set_integer_native(result);
1006         }
1007 MMD_WmlsString: {
1008             PMC *trans;
1009             Parrot_PCCINVOKE(interp, value, const_string(interp, "parseInt"),
1010                     "->P", &trans);
1011
1012             if (trans->vtable->base_type == dynpmc_WmlsInteger) {
1013                 INTVAL result = SELF.get_integer()
1014                               ^ VTABLE_get_integer(INTERP, trans);
1015                 SELF.morph(dynpmc_WmlsInteger);
1016                 SELF.set_integer_native(result);
1017             }
1018             else {
1019                 SELF.morph(dynpmc_WmlsInvalid);
1020             }
1021         }
1022 MMD_DEFAULT: {
1023             SELF.morph(dynpmc_WmlsInvalid);
1024         }
1025     }
1026
1027 /*
1028
1029 =item C<PMC* bitwise_shr(PMC *value, PMC *dest)>
1030
1031 =item C<void i_bitwise_shr(PMC *value)>
1032
1033 =cut
1034
1035 */
1036     PMC* bitwise_shr(PMC* value, PMC* dest) {
1037 MMD_WmlsInteger: {
1038             INTVAL result = SELF.get_integer()
1039                           >> VTABLE_get_integer(INTERP, value);
1040             dest = pmc_new(INTERP, dynpmc_WmlsInteger);
1041             VTABLE_set_integer_native(INTERP, dest, result);
1042             return dest;
1043         }
1044 MMD_WmlsBoolean: {
1045             INTVAL result = SELF.get_integer()
1046                           >> VTABLE_get_integer(INTERP, value);
1047             dest = pmc_new(INTERP, dynpmc_WmlsInteger);
1048             VTABLE_set_integer_native(INTERP, dest, result);
1049             return dest;
1050         }
1051 MMD_WmlsString: {
1052             PMC *trans;
1053             Parrot_PCCINVOKE(interp, value, const_string(interp, "parseInt"),
1054                     "->P", &trans);
1055
1056             if (trans->vtable->base_type == dynpmc_WmlsInteger) {
1057                 INTVAL result = SELF.get_integer()
1058                               >> VTABLE_get_integer(INTERP, trans);
1059                 dest = pmc_new(INTERP, dynpmc_WmlsInteger);
1060                 VTABLE_set_integer_native(INTERP, dest, result);
1061                 return dest;
1062             }
1063             return pmc_new(INTERP, dynpmc_WmlsInvalid);
1064         }
1065 MMD_DEFAULT: {
1066             return pmc_new(INTERP, dynpmc_WmlsInvalid);
1067         }
1068     }
1069
1070     void i_bitwise_shr(PMC* value) {
1071 MMD_WmlsInteger: {
1072             INTVAL result = SELF.get_integer()
1073                           >> VTABLE_get_integer(INTERP, value);
1074             SELF.morph(dynpmc_WmlsInteger);
1075             SELF.set_integer_native(result);
1076         }
1077 MMD_WmlsBoolean: {
1078             INTVAL result = SELF.get_integer()
1079                           >> VTABLE_get_integer(INTERP, value);
1080             SELF.morph(dynpmc_WmlsInteger);
1081             SELF.set_integer_native(result);
1082         }
1083 MMD_WmlsString: {
1084             PMC *trans;
1085             Parrot_PCCINVOKE(interp, value, const_string(interp, "parseInt"),
1086                     "->P", &trans);
1087
1088             if (trans->vtable->base_type == dynpmc_WmlsInteger) {
1089                 INTVAL result = SELF.get_integer()
1090                               >> VTABLE_get_integer(INTERP, trans);
1091                 SELF.morph(dynpmc_WmlsInteger);
1092                 SELF.set_integer_native(result);
1093             }
1094             else {
1095                 SELF.morph(dynpmc_WmlsInvalid);
1096             }
1097         }
1098 MMD_DEFAULT: {
1099             SELF.morph(dynpmc_WmlsInvalid);
1100         }
1101     }
1102
1103 /*
1104
1105 =item C<PMC* bitwise_lsr(PMC *value, PMC *dest)>
1106
1107 =item C<void i_bitwise_lsr(PMC *value)>
1108
1109 =cut
1110
1111 */
1112     PMC* bitwise_lsr(PMC* value, PMC* dest) {
1113 MMD_WmlsInteger: {
1114             INTVAL result = SELF.get_integer()
1115                           >> VTABLE_get_integer(INTERP, value);
1116             dest = pmc_new(INTERP, dynpmc_WmlsInteger);
1117             VTABLE_set_integer_native(INTERP, dest, result);
1118             return dest;
1119         }
1120 MMD_WmlsBoolean: {
1121             INTVAL result = SELF.get_integer()
1122                           >> VTABLE_get_integer(INTERP, value);
1123             dest = pmc_new(INTERP, dynpmc_WmlsInteger);
1124             VTABLE_set_integer_native(INTERP, dest, result);
1125             return dest;
1126         }
1127 MMD_WmlsString: {
1128             PMC *trans;
1129             Parrot_PCCINVOKE(interp, value, const_string(interp, "parseInt"),
1130                     "->P", &trans);
1131
1132             if (trans->vtable->base_type == dynpmc_WmlsInteger) {
1133                 INTVAL result = SELF.get_integer()
1134                               >> VTABLE_get_integer(INTERP, trans);
1135                 dest = pmc_new(INTERP, dynpmc_WmlsInteger);
1136                 VTABLE_set_integer_native(INTERP, dest, result);
1137                 return dest;
1138             }
1139             return pmc_new(INTERP, dynpmc_WmlsInvalid);
1140         }
1141 MMD_DEFAULT: {
1142             return pmc_new(INTERP, dynpmc_WmlsInvalid);
1143         }
1144     }
1145
1146     void i_bitwise_lsr(PMC* value) {
1147 MMD_WmlsInteger: {
1148             INTVAL result = SELF.get_integer()
1149                           >> VTABLE_get_integer(INTERP, value);
1150             SELF.morph(dynpmc_WmlsInteger);
1151             SELF.set_integer_native(result);
1152         }
1153 MMD_WmlsBoolean: {
1154             INTVAL result = SELF.get_integer()
1155                           >> VTABLE_get_integer(INTERP, value);
1156             SELF.morph(dynpmc_WmlsInteger);
1157             SELF.set_integer_native(result);
1158         }
1159 MMD_WmlsString: {
1160             PMC *trans;
1161             Parrot_PCCINVOKE(interp, value, const_string(interp, "parseInt"),
1162                     "->P", &trans);
1163
1164             if (trans->vtable->base_type == dynpmc_WmlsInteger) {
1165                 INTVAL result = SELF.get_integer()
1166                               >> VTABLE_get_integer(INTERP, trans);
1167                 SELF.morph(dynpmc_WmlsInteger);
1168                 SELF.set_integer_native(result);
1169             }
1170             else {
1171                 SELF.morph(dynpmc_WmlsInvalid);
1172             }
1173         }
1174 MMD_DEFAULT: {
1175             SELF.morph(dynpmc_WmlsInvalid);
1176         }
1177     }
1178
1179 /*
1180
1181 =item C<PMC* bitwise_shl(PMC *value, PMC *dest)>
1182
1183 =item C<void i_bitwise_shl(PMC *value)>
1184
1185 =cut
1186
1187 */
1188     PMC* bitwise_shl(PMC* value, PMC* dest) {
1189 MMD_WmlsInteger: {
1190             INTVAL result = SELF.get_integer()
1191                           << VTABLE_get_integer(INTERP, value);
1192             dest = pmc_new(INTERP, dynpmc_WmlsInteger);
1193             VTABLE_set_integer_native(INTERP, dest, result);
1194             return dest;
1195         }
1196 MMD_WmlsBoolean: {
1197             INTVAL result = SELF.get_integer()
1198                           << VTABLE_get_integer(INTERP, value);
1199             dest = pmc_new(INTERP, dynpmc_WmlsInteger);
1200             VTABLE_set_integer_native(INTERP, dest, result);
1201             return dest;
1202         }
1203 MMD_WmlsString: {
1204             PMC *trans;
1205             Parrot_PCCINVOKE(interp, value, const_string(interp, "parseInt"),
1206                     "->P", &trans);
1207
1208             if (trans->vtable->base_type == dynpmc_WmlsInteger) {
1209                 INTVAL result = SELF.get_integer()
1210                               << VTABLE_get_integer(INTERP, trans);
1211                 dest = pmc_new(INTERP, dynpmc_WmlsInteger);
1212                 VTABLE_set_integer_native(INTERP, dest, result);
1213                 return dest;
1214             }
1215             return pmc_new(INTERP, dynpmc_WmlsInvalid);
1216         }
1217 MMD_DEFAULT: {
1218             return pmc_new(INTERP, dynpmc_WmlsInvalid);
1219         }
1220     }
1221
1222     void i_bitwise_shl(PMC* value) {
1223 MMD_WmlsInteger: {
1224             INTVAL result = SELF.get_integer()
1225                           << VTABLE_get_integer(INTERP, value);
1226             SELF.morph(dynpmc_WmlsInteger);
1227             SELF.set_integer_native(result);
1228         }
1229 MMD_WmlsBoolean: {
1230             INTVAL result = SELF.get_integer()
1231                           << VTABLE_get_integer(INTERP, value);
1232             SELF.morph(dynpmc_WmlsInteger);
1233             SELF.set_integer_native(result);
1234         }
1235 MMD_WmlsString: {
1236             PMC *trans;
1237             Parrot_PCCINVOKE(interp, value, const_string(interp, "parseInt"),
1238                     "->P", &trans);
1239
1240             if (trans->vtable->base_type == dynpmc_WmlsInteger) {
1241                 INTVAL result = SELF.get_integer()
1242                               << VTABLE_get_integer(INTERP, trans);
1243                 SELF.morph(dynpmc_WmlsInteger);
1244                 SELF.set_integer_native(result);
1245             }
1246             else {
1247                 SELF.morph(dynpmc_WmlsInvalid);
1248             }
1249         }
1250 MMD_DEFAULT: {
1251             SELF.morph(dynpmc_WmlsInvalid);
1252         }
1253     }
1254
1255 /*
1256
1257 =item C<PMC* is_equal(PMC* value)>
1258
1259 =cut
1260
1261 */
1262     INTVAL is_equal(PMC* value) {
1263 MMD_WmlsFloat: {
1264             return SELF.get_number() == VTABLE_get_number(INTERP, value);
1265         }
1266 MMD_WmlsInteger: {
1267             return SELF.get_integer() == VTABLE_get_integer(INTERP, value);
1268         }
1269 MMD_WmlsBoolean: {
1270             return SELF.get_integer() == VTABLE_get_integer(INTERP, value);
1271         }
1272 MMD_WmlsString: {
1273             return !string_equal(INTERP,
1274                 SELF.get_string(), VTABLE_get_string(INTERP, value));
1275         }
1276 MMD_DEFAULT: {
1277             return 4;
1278         }
1279     }
1280
1281 /*
1282
1283 =item C<PMC* cmp(PMC *value)>
1284
1285 =cut
1286
1287 */
1288     INTVAL cmp(PMC* value) {
1289 MMD_WmlsFloat: {
1290             return num_cmp(SELF.get_number(),
1291                            VTABLE_get_number(INTERP, value));
1292         }
1293 MMD_WmlsInteger: {
1294             return int_cmp(SELF.get_integer(),
1295                            VTABLE_get_integer(INTERP, value));
1296         }
1297 MMD_WmlsBoolean: {
1298             return int_cmp(SELF.get_integer(),
1299                            VTABLE_get_integer(INTERP, value));
1300         }
1301 MMD_WmlsString: {
1302             return string_compare(INTERP,
1303                 SELF.get_string(), VTABLE_get_string(INTERP, value));
1304         }
1305 MMD_DEFAULT: {
1306             return 4;
1307         }
1308     }
1309
1310 }
1311
1312 /*
1313
1314 =back
1315
1316 =head1 AUTHORS
1317
1318 Francois Perrad.
1319
1320 =cut
1321
1322 */
1323
1324
1325 /*
1326  * Local variables:
1327  *   c-file-style: "parrot"
1328  * End:
1329  * vim: expandtab shiftwidth=4:
1330  */