languages/WMLScript/pmc/wmlsinteger.pmc

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