src/pmc/integer.pmc

   1 /*
   2 Copyright (C) 2003-2008, The Perl Foundation.
   3 $Id$
   4
   5 =head1 NAME
   6
   7 src/pmc/integer.pmc - Integer PMC class
   8
   9 =head1 DESCRIPTION
  10
  11 C<Integer> provides an integer for languages that want a value-restricted
  12 integer type without going to an I register.
  13
  14 =head2 Functions
  15
  16 =over 4
  17
  18 =cut
  19
  20 */
  21
  22 #include "parrot/parrot.h"
  23
  24 #include "pmc_bigint.h"
  25 /* RT#46619 create MMD headers to in Pmc2c.pm */
  26 /*
  27 extern INTVAL Parrot_BigInt_is_equal_BigInt(PARROT_INTERP, PMC*, PMC*);
  28 extern PMC *Parrot_BigInt_multiply_int(PARROT_INTERP,
  29         PMC *pmc, INTVAL value, PMC *dest) ;
  30 */
  31
  32 static PMC*
  33 overflow(PARROT_INTERP, PMC *self, INTVAL b, PMC *dest, int mmd) {
  34     const INTVAL a = VTABLE_get_integer(interp, self);
  35
  36     if (PARROT_ERRORS_test(interp, PARROT_ERRORS_OVERFLOW_FLAG))
  37     Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_ERR_OVERFLOW,
  38         "Integer overflow");
  39
  40 if (self == dest) {
  41     /* RT #46621 preserve type system */
  42     VTABLE_morph(interp, self, enum_class_BigInt);
  43     VTABLE_set_integer_native(interp, self, a);
  44     return mmd_dispatch_p_pip(interp, self, b, dest, mmd);
  45 }
  46 else {
  47     PMC * const temp = VTABLE_get_bignum(interp, self);
  48     return mmd_dispatch_p_pip(interp, temp, b, dest, mmd);
  49 }
  50 }
  51
  52 static PMC*
  53 overflow_p(PARROT_INTERP, PMC *self, PMC *val, PMC *dest, int mmd) {
  54 const INTVAL a = VTABLE_get_integer(interp, self);
  55
  56 if (PARROT_ERRORS_test(interp, PARROT_ERRORS_OVERFLOW_FLAG))
  57     Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_ERR_OVERFLOW,
  58         "Integer overflow");
  59
  60 if (self == dest) {
  61     VTABLE_morph(interp, self, enum_class_BigInt);
  62     VTABLE_set_integer_native(interp, self, a);
  63     return mmd_dispatch_p_ppp(interp, self, val, dest, mmd);
  64 }
  65 else {
  66     PMC * const temp = VTABLE_get_bignum(interp, self);
  67     return mmd_dispatch_p_ppp(interp, temp, val, dest, mmd);
  68 }
  69 }
  70
  71 pmclass Integer extends scalar provides integer provides scalar {
  72
  73 /*
  74 =item C<PMC instantiate(PMC *sig)>
  75
  76 Create a new Integer with arguments passed according to pdd03.
  77
  78 =item C<void init()>
  79
  80 Initializes the integer with a default value of C<0>.
  81
  82 =cut
  83
  84 */
  85 VTABLE PMC *instantiate(PMC *sig) {
  86     PMC * const ret    = new_pmc_header(INTERP, 0);
  87     opcode_t   *arg_op = interp->current_args;
  88     INTVAL      init   = 0;
  89
  90     ret->vtable        = interp->vtables[SELF->vtable->base_type];
  91
  92     if (SIG_ELEMS(sig) == 2) {
  93         switch (SIG_ITEM(sig, 1)) {
  94             case PARROT_ARG_I:
  95                 init = REG_INT(interp, arg_op[3]);
  96                 break;
  97             case PARROT_ARG_IC:
  98                 init = arg_op[3];
  99                 break;
 100             default:
 101                 Parrot_ex_throw_from_c_args(INTERP, NULL, 1,
 102                         "Integer.instantiate: unhandled initializer");
 103                 break;
 104         }
 105     }
 106
 107     PMC_int_val(ret) = init;
 108     return ret;
 109 }
 110
 111 VTABLE void init() {
 112     PMC_int_val(SELF) = 0;
 113 }
 114
 115 /*
 116
 117 =item C<PMC new_from_string(STRING *rep)>
 118
 119 Class method to construct an Integer from the string representation C<rep>.
 120
 121 =cut
 122
 123 */
 124 VTABLE PMC *new_from_string(STRING *rep, INTVAL flags) {
 125     const INTVAL type = SELF->vtable->base_type;
 126     PMC * const res =
 127         (flags & PObj_constant_FLAG)
 128             ? constant_pmc_new(INTERP, type)
 129             : pmc_new(INTERP, type);
 130
 131     /* RT #46623 bigint overflow */
 132     PMC_int_val(res) = string_to_int(INTERP, rep);
 133     return res;
 134 }
 135
 136 /*
 137
 138 =item C<void set_pmc(PMC *value)>
 139
 140 Sets the value of the integer to the value in C<*value>.
 141
 142 =cut
 143
 144 */
 145
 146 VTABLE void set_pmc(PMC *value) {
 147     PMC_int_val(SELF) = VTABLE_get_integer(INTERP, value);
 148 }
 149
 150 /*
 151
 152 =item C<void share()>
 153
 154 Sets this PMC as shared and read-only.
 155
 156 =cut
 157
 158 */
 159 VTABLE void share() {
 160     /*
 161      * assume that the access to a long is atomic.
 162      * integers are most often (1) equal to C longs,
 163      * not C ints, and this makes a difference in 64-bit
 164      * platforms where longs are 64-bit but ints are 32-bit.
 165      * (1) Not equal when integers have been configured
 166      *     to be software-emulated long longs.
 167      */
 168     if (sizeof (INTVAL) != sizeof (long))
 169         SUPER();
 170 }
 171
 172 /*
 173
 174 =item C<INTVAL get_integer()>
 175
 176 Returns the integer value of the Integer.
 177
 178 =cut
 179
 180 */
 181 VTABLE INTVAL get_integer() {
 182     return PMC_int_val(SELF);
 183 }
 184
 185 /*
 186
 187 =item C<INTVAL get_bool()>
 188
 189 Returns the boolean value of the Integer.
 190
 191 =cut
 192
 193 */
 194     VTABLE INTVAL get_bool() {
 195         return SELF.get_integer() ? 1 : 0;
 196     }
 197
 198 /*
 199
 200 =item C<FLOATVAL get_number()>
 201
 202 Returns the floating-point value of the integer.
 203
 204 =cut
 205
 206 */
 207     VTABLE FLOATVAL get_number() {
 208         return SELF.get_integer();
 209     }
 210
 211 /*
 212
 213 =item C<PMC *get_bignum()>
 214
 215 Return a new BigInt PMC with the value of C<SELF>.
 216
 217 =cut
 218
 219 */
 220 VTABLE PMC *get_bignum() {
 221     const INTVAL val = SELF.get_integer();
 222     PMC * const  ret = pmc_new(INTERP, enum_class_BigInt);
 223     VTABLE_set_integer_native(INTERP, ret, val);
 224     return ret;
 225 }
 226
 227 /*
 228
 229 =item C<STRING *get_string()>
 230
 231 Returns the string value of the integer.
 232
 233 =cut
 234
 235 */
 236     VTABLE STRING *get_string() {
 237         return string_from_int(INTERP, SELF.get_integer());
 238     }
 239
 240     VTABLE STRING *get_repr() {
 241         return string_from_int(INTERP, SELF.get_integer());
 242     }
 243
 244 /*
 245
 246 =item C<void set_integer_same(PMC *value)>
 247
 248 =item C<void set_integer_native(INTVAL value)>
 249
 250 Sets the value of the integer to the value of the C<Integer> C<*value>.
 251
 252 =cut
 253
 254 */
 255 VTABLE void set_integer_same(PMC *value) {
 256     PMC_int_val(SELF) = PMC_int_val(value);
 257 }
 258
 259 VTABLE void set_integer_native(INTVAL value) {
 260     PMC_int_val(SELF) = value;
 261 }
 262
 263 /*
 264
 265 =item C<void set_number_native(FLOATVAL value)>
 266
 267 Morphs the integer to a C<Float> and sets the value from C<value>.
 268
 269 =item C<void set_bool(INTVAL value)>
 270
 271 Morphs the integer to a C<Boolean> and sets the value from C<value>.
 272
 273 =item C<void set_bigint_int(INTVAL value)>
 274
 275 Morphs the integer to a C<BigInt> and sets the value from C<value>.
 276
 277 =item C<void set_string_native(STRING *value)>
 278
 279 Morphs the integer to a C<String> and sets the value from C<value>.
 280
 281 =cut
 282
 283 */
 284 VTABLE void set_number_native(FLOATVAL value) {
 285     SELF.morph(enum_class_Float);
 286     SELF.set_number_native(value);
 287 }
 288
 289 VTABLE void set_bool(INTVAL value) {
 290     SELF.morph(enum_class_Boolean);
 291     SELF.set_bool(value);
 292 }
 293
 294 VTABLE void set_bignum_int(INTVAL value) {
 295     SELF.morph(enum_class_BigInt);
 296     SELF.set_integer_native(value);
 297 }
 298
 299 VTABLE void set_string_native(STRING *value) {
 300     SELF.morph(enum_class_String);
 301     SELF.set_string_native(value);
 302 }
 303
 304 /*
 305
 306 =item C<PMC *add(PMC *value, PMC *dest)>
 307
 308 =item C<PMC *add_int(INTVAL value, PMC *dest)>
 309
 310 Adds C<value> to the integer and returns the result in C<*dest>.
 311
 312 Please note: the label syntax I<MMD_type:> denote the behavior, if
 313 the right hand value is of that type. The part inside the braces is
 314 converted to a distinct function and gets I<mmd_register>ed for these
 315 two types.
 316
 317 =cut
 318
 319 */
 320 VTABLE PMC *add(PMC *value, PMC *dest) {
 321 MMD_Integer: {
 322         /*
 323          * SELF and value can both be PMCs that inherit
 324          * from Integer:
 325          *   cl = subclass "Integer", "MyInt"
 326          * so we can't used PMC_int_val(SELF) in any of these
 327          * Integer methods
 328          *
 329          * RT #46627
 330          *   check for exact Integer type
 331          *   e.g. MMD_Integer_EXACT
 332          */
 333
 334         const INTVAL a = SELF.get_integer();
 335         const INTVAL b = VTABLE_get_integer(INTERP, value);
 336         const INTVAL c = a + b;
 337
 338         if ((c^a) >= 0 || (c^b) >= 0) {
 339             if (!dest)
 340                 dest = pmc_new(INTERP, VTABLE_type(interp, SELF));
 341
 342             /* need this for e.g. Undef PMC */
 343             VTABLE_set_integer_native(INTERP, dest, c);
 344             return dest;
 345         }
 346         else
 347             return overflow(INTERP, SELF, b, dest, MMD_ADD);
 348     }
 349 MMD_Complex: {
 350         const INTVAL a = SELF.get_integer();
 351         if (dest)
 352             VTABLE_morph(INTERP, dest, VTABLE_type(interp, value));
 353         else
 354             dest = pmc_new(INTERP, VTABLE_type(interp, value));
 355
 356         VTABLE_set_number_native(INTERP, dest,
 357                 a + VTABLE_get_number_keyed_int(INTERP, value, 0));
 358         VTABLE_set_number_keyed_int(INTERP, dest, 1,
 359                 VTABLE_get_number_keyed_int(INTERP, value, 1));
 360
 361         return dest;
 362     }
 363 MMD_BigInt: {
 364         return overflow_p(INTERP, SELF, value, dest, MMD_ADD);
 365     }
 366 MMD_DEFAULT: {
 367         if (!dest)
 368             dest = pmc_new(INTERP, VTABLE_type(interp, value));
 369
 370         VTABLE_set_number_native(INTERP, dest,
 371             SELF.get_integer() + VTABLE_get_number(INTERP, value));
 372         return dest;
 373     }
 374 }
 375
 376 VTABLE PMC *add_int(INTVAL b, PMC *dest) {
 377     const INTVAL a = VTABLE_get_integer(INTERP, SELF);
 378     const INTVAL c = a + b;
 379
 380     if ((c^a) >= 0 || (c^b) >= 0) {
 381         if (!dest)
 382             dest = pmc_new(INTERP, VTABLE_type(INTERP, SELF));
 383
 384         VTABLE_set_integer_native(INTERP, dest, c);
 385         return dest;
 386     }
 387     else
 388         return overflow(INTERP, SELF, b, dest, MMD_ADD);
 389 }
 390
 391 /*
 392
 393 =item C<void i_add(PMC *value)>
 394
 395 =item C<void i_add(INTVAL value)>
 396
 397 =item C<void i_add(FLOATVAL value)>
 398
 399 Adds C<value> to C<SELF> inplace.
 400
 401 =cut
 402
 403 */
 404
 405 VTABLE void i_add(PMC *value) {
 406 MMD_Integer: {
 407         STATICSELF.i_add_int(VTABLE_get_integer(INTERP, value));
 408     }
 409 MMD_Complex: {
 410         const INTVAL a = SELF.get_integer();
 411
 412         VTABLE_morph(INTERP, SELF, value->vtable->base_type);
 413         VTABLE_set_number_native(INTERP, SELF,
 414             SELF.get_integer() + VTABLE_get_number(INTERP, value));
 415     }
 416 MMD_DEFAULT: {
 417     VTABLE_set_number_native(INTERP, SELF,
 418         PMC_int_val(SELF) + VTABLE_get_number(INTERP, value));
 419     }
 420 }
 421
 422 VTABLE void i_add_int(INTVAL b) {
 423     const INTVAL a = SELF.get_integer();
 424     const INTVAL c = a + b;
 425
 426     if ((c^a) >= 0 || (c^b) >= 0)
 427         VTABLE_set_integer_native(INTERP, SELF, c);
 428     else
 429         overflow(INTERP, SELF, b, SELF, MMD_SUBTRACT);
 430 }
 431
 432 VTABLE void i_add_float(FLOATVAL value) {
 433     const INTVAL a = SELF.get_integer();
 434     VTABLE_set_number_native(INTERP, SELF, a + value);
 435 }
 436 /*
 437
 438 =item C<PMC *subtract(PMC *value, PMC *dest)>
 439
 440 Subtracts C<*value> from the integer and returns the result in C<*dest>.
 441 If C<dest> is NULL, a new int PMC is created.
 442
 443 Please note: as C<SELF> or C<value> maybe be subclassed, we have to
 444 call C<get_integer> and C<set_integer_native> always.
 445
 446 =cut
 447
 448 */
 449 VTABLE PMC *subtract(PMC *value, PMC *dest) {
 450 MMD_Integer: {
 451         const INTVAL a = SELF.get_integer();
 452         const INTVAL b = VTABLE_get_integer(INTERP, value);
 453         const INTVAL c = a - b;
 454
 455         if ((c^a) >= 0 || (c^~b) >= 0) {
 456             if (!dest)
 457                 dest = pmc_new(INTERP, VTABLE_type(INTERP, SELF));
 458
 459             VTABLE_set_integer_native(INTERP, dest, c);
 460             return dest;
 461         }
 462         else
 463             return overflow(INTERP, SELF, b, dest, MMD_SUBTRACT);
 464     }
 465 MMD_Complex: {
 466         const INTVAL a = SELF.get_integer();
 467         if (dest)
 468             VTABLE_morph(INTERP, dest, value->vtable->base_type);
 469         else
 470             dest = pmc_new(INTERP, VTABLE_type(INTERP, value));
 471
 472         VTABLE_set_number_native(INTERP, dest,
 473                 a - VTABLE_get_number_keyed_int(INTERP, value, 0));
 474         VTABLE_set_number_keyed_int(INTERP, dest, 1,
 475                 -VTABLE_get_number_keyed_int(INTERP, value, 1));
 476
 477         return dest;
 478     }
 479 MMD_BigInt: {
 480         return overflow_p(INTERP, SELF, value, dest, MMD_SUBTRACT);
 481     }
 482 MMD_DEFAULT: {
 483         if (!dest)
 484             dest = pmc_new(INTERP, VTABLE_type(INTERP, value));
 485
 486         VTABLE_set_number_native(INTERP, dest,
 487             SELF.get_integer() - VTABLE_get_number(INTERP, value));
 488         return dest;
 489     }
 490 }
 491
 492 /*
 493
 494 =item C<PMC *subtract_int(INTVAL value, PMC *dest)>
 495
 496 Subtracts C<value> from the integer and returns the result in C<*dest>.
 497
 498 =cut
 499
 500 */
 501 VTABLE PMC *subtract_int(INTVAL b, PMC *dest) {
 502     const INTVAL a = SELF.get_integer();
 503     const INTVAL c = a - b;
 504
 505     if ((c^a) >= 0 || (c^~b) >= 0) {
 506         if (!dest)
 507             dest = pmc_new(INTERP, VTABLE_type(INTERP, SELF));
 508
 509         VTABLE_set_integer_native(INTERP, dest, c);
 510         return dest;
 511     }
 512     else
 513         return overflow(INTERP, SELF, b, dest, MMD_SUBTRACT);
 514 }
 515
 516 /*
 517
 518 =item C<void i_subtract(PMC *value)>
 519
 520 =item C<void i_subtract_int(INTVAL value)>
 521
 522 =item C<void i_subtract_float(FLOATVAL value)>
 523
 524 Subtracts C<value> from C<SELF> inplace.
 525
 526 =cut
 527
 528 */
 529
 530 VTABLE void i_subtract(PMC *value) {
 531 MMD_Integer: {
 532         const INTVAL a = SELF.get_integer();
 533         const INTVAL b = VTABLE_get_integer(INTERP, value);
 534         const INTVAL c = a - b;
 535
 536         if ((c^a) >= 0 || (c^~b) >= 0)
 537             VTABLE_set_integer_native(INTERP, SELF, c);
 538         else
 539             overflow(INTERP, SELF, b, SELF, MMD_SUBTRACT);
 540     }
 541 MMD_Complex: {
 542         const INTVAL a = SELF.get_integer();
 543
 544         VTABLE_morph(INTERP, SELF, value->vtable->base_type);
 545         VTABLE_set_number_native(INTERP, SELF,
 546                 (FLOATVAL)a -
 547                 VTABLE_get_number_keyed_int(INTERP, value, 0));
 548         VTABLE_set_number_keyed_int(INTERP, SELF, 1,
 549                 -VTABLE_get_number_keyed_int(INTERP, value, 1));
 550     }
 551 MMD_DEFAULT: {
 552     VTABLE_set_number_native(INTERP, SELF,
 553         SELF.get_integer() - VTABLE_get_number(INTERP, value));
 554     }
 555 }
 556
 557 VTABLE void i_subtract_int(INTVAL b) {
 558     const INTVAL a = SELF.get_integer();
 559     const INTVAL c = a - b;
 560
 561     if ((c^a) >= 0 || (c^~b) >= 0)
 562         VTABLE_set_integer_native(INTERP, SELF, c);
 563     else
 564         overflow(INTERP, SELF, b, SELF, MMD_SUBTRACT);
 565 }
 566
 567 VTABLE void i_subtract_float(FLOATVAL value) {
 568     const INTVAL a = SELF.get_integer();
 569     VTABLE_set_number_native(INTERP, SELF, a - value);
 570 }
 571
 572 /*
 573
 574 =item C<PMC *multiply(PMC *value, PMC *dest)>
 575
 576 =item C<PMC *multiply_int(INTVAL value, PMC *dest)>
 577
 578 Multiplies the integer by C<*value> and returns the result in C<*dest>.
 579
 580 =cut
 581
 582 */
 583 VTABLE PMC *multiply(PMC *value, PMC *dest) {
 584 MMD_Integer: {
 585         const INTVAL a  = VTABLE_get_integer(INTERP, SELF);
 586         const INTVAL b  = VTABLE_get_integer(INTERP, value);
 587         const double cf = (double)a * (double)b;
 588         const INTVAL c  = a * b;
 589
 590         if ((double) c == cf) {
 591             if (!dest)
 592                 dest = pmc_new(INTERP, VTABLE_type(interp, SELF));
 593
 594             VTABLE_set_integer_native(INTERP, dest, c);
 595             return dest;
 596         }
 597         else
 598             return overflow(INTERP, SELF, b, dest, MMD_MULTIPLY);
 599     }
 600 MMD_Complex: {
 601             Parrot_ex_throw_from_c_args(INTERP, NULL,
 602                 EXCEPTION_INTERNAL_NOT_IMPLEMENTED,
 603                 "RT #46629 mul<Integer, Complex>");
 604         }
 605 MMD_BigInt:     {
 606         return Parrot_BigInt_multiply_int(INTERP, value,
 607                 SELF.get_integer(), dest);
 608     }
 609 MMD_String: {
 610         return Parrot_Integer_multiply_Integer(INTERP, SELF, value, dest);
 611     }
 612 MMD_DEFAULT: {
 613         const FLOATVAL valf = VTABLE_get_number(INTERP, value);
 614         if (!dest)
 615             dest = pmc_new(INTERP, VTABLE_type(INTERP, SELF));
 616
 617         VTABLE_set_number_native(INTERP, dest, SELF.get_number() * valf);
 618         return dest;
 619     }
 620 }
 621
 622 VTABLE PMC *multiply_int(INTVAL b, PMC *dest) {
 623     const INTVAL a  = SELF.get_integer();
 624     const double cf = (double)a * (double)b;
 625     const INTVAL c  = a * b;
 626
 627     if ((double) c == cf) {
 628         if (!dest)
 629             dest = pmc_new(INTERP, VTABLE_type(INTERP, SELF));
 630
 631         VTABLE_set_integer_native(INTERP, dest, c);
 632         return dest;
 633     }
 634     else
 635         return overflow(INTERP, SELF, b, dest, MMD_MULTIPLY);
 636 }
 637
 638 /*
 639
 640 =item C<void i_multiply(PMC *value)>
 641
 642 =item C<void i_multiply_int(INTVAL value)>
 643
 644 =item C<void i_multiply_float(FLOATVAL value)>
 645
 646 Multiply C<value> with C<SELF> inplace.
 647
 648 =cut
 649
 650 */
 651
 652 VTABLE void i_multiply(PMC *value) {
 653 MMD_Integer: {
 654         STATICSELF.i_multiply_int(VTABLE_get_integer(INTERP, value));
 655     }
 656 MMD_BigInt: {
 657         Parrot_BigInt_multiply_int(INTERP, value,
 658                 SELF.get_integer(), SELF);
 659     }
 660 MMD_Complex: {
 661             Parrot_ex_throw_from_c_args(INTERP, NULL,
 662                 EXCEPTION_INTERNAL_NOT_IMPLEMENTED,
 663                 "RT #46629 i_mul<Integer, Complex>");
 664     }
 665 MMD_DEFAULT: {
 666         VTABLE_set_number_native(INTERP, SELF,
 667             SELF.get_integer() * VTABLE_get_number(INTERP, value));
 668     }
 669 }
 670
 671 VTABLE void i_multiply_int(INTVAL b) {
 672     const INTVAL a  = SELF.get_integer();
 673     const double cf = (double)a * (double)b;
 674     const INTVAL c  = a * b;
 675
 676     if ((double) c == cf)
 677         SELF.set_integer_native(c);
 678     else
 679         overflow(INTERP, SELF, b, SELF, MMD_MULTIPLY);
 680 }
 681
 682 VTABLE void i_multiply_float(FLOATVAL value) {
 683     const INTVAL a = SELF.get_integer();
 684     VTABLE_set_number_native(INTERP, SELF, a * value);
 685 }
 686
 687 /*
 688
 689 =item C<PMC *divide(PMC *value, PMC *dest)>
 690
 691 =item C<PMC *divide_int(INTVAL value, PMC *dest)>
 692
 693 =item C<PMC *divide_float(FLOATVAL value, PMC *dest)>
 694
 695 Divides the number by C<value> and returns the result in C<*dest>.
 696
 697 =item C<void i_divide(PMC *value)>
 698
 699 =item C<void i_divide_int(INTVAL value)>
 700
 701 =item C<void i_divide_float(FLOATVAL value)>
 702
 703 Divides C<SELF> by C<value> inplace.
 704
 705 =cut
 706
 707 */
 708
 709 VTABLE PMC *divide(PMC *value, PMC *dest) {
 710 MMD_BigInt:     {
 711         return overflow_p(INTERP, SELF, value, dest, MMD_DIVIDE);
 712     }
 713 MMD_DEFAULT: {
 714         FLOATVAL d = VTABLE_get_number(INTERP, value);
 715
 716         if (FLOAT_IS_ZERO(d))
 717             Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_DIV_BY_ZERO,
 718                 "float division by zero");
 719
 720         if (!dest)
 721             dest = pmc_new(INTERP, VTABLE_type(INTERP, SELF));
 722         VTABLE_set_number_native(INTERP, dest, SELF.get_number() / d);
 723         return dest;
 724     }
 725 }
 726
 727 VTABLE void i_divide(PMC *value) {
 728 MMD_BigInt:     {
 729          overflow_p(INTERP, SELF, value, SELF, MMD_DIVIDE);
 730     }
 731 MMD_DEFAULT: {
 732         FLOATVAL d = VTABLE_get_number(INTERP, value);
 733
 734         if (FLOAT_IS_ZERO(d))
 735             Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_DIV_BY_ZERO,
 736                     "float division by zero");
 737
 738         VTABLE_set_number_native(INTERP, SELF, SELF.get_number() / d);
 739     }
 740 }
 741
 742 /*
 743
 744 =item C<PMC *floor_divide(PMC *value, PMC *dest)>
 745
 746 =item C<PMC *floor_divide_int(INTVAL value, PMC *dest)>
 747
 748 =item C<PMC *floor_divide_float(FLOATVAL value, PMC *dest)>
 749
 750 Divides the number by C<value> and returns the result in C<*dest>.
 751
 752 =item C<void i_floor_divide(PMC *value)>
 753
 754 =item C<void i_floor_divide_int(INTVAL value)>
 755
 756 =item C<void i_floor_divide_float(FLOATVAL value)>
 757
 758 Divides C<SELF> by C<value> inplace.
 759
 760 =cut
 761
 762 */
 763
 764 VTABLE PMC *floor_divide(PMC *value, PMC *dest) {
 765 MMD_BigInt:     {
 766         return overflow_p(INTERP, SELF, value, dest, MMD_FLOOR_DIVIDE);
 767     }
 768 MMD_DEFAULT: {
 769         FLOATVAL d = VTABLE_get_number(INTERP, value);
 770         FLOATVAL f;
 771
 772         if (FLOAT_IS_ZERO(d))
 773             Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_DIV_BY_ZERO,
 774                     "float division by zero");
 775
 776         if (!dest)
 777             dest = pmc_new(INTERP, VTABLE_type(INTERP, SELF));
 778
 779         f = floor(SELF.get_number() / d);
 780         VTABLE_set_integer_native(INTERP, dest, (INTVAL)f);
 781         return dest;
 782     }
 783 }
 784
 785 VTABLE PMC *floor_divide_int(INTVAL value, PMC *dest) {
 786     FLOATVAL f;
 787
 788     if (value == 0)
 789         Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_DIV_BY_ZERO,
 790             "float division by zero");
 791
 792     if (!dest)
 793         dest = pmc_new(INTERP, VTABLE_type(INTERP, SELF));
 794
 795     f = floor(SELF.get_number() / value);
 796     VTABLE_set_integer_native(INTERP, dest, (INTVAL)f);
 797
 798     return dest;
 799 }
 800
 801 VTABLE PMC *floor_divide_float(FLOATVAL value, PMC *dest) {
 802     FLOATVAL f;
 803
 804     if (FLOAT_IS_ZERO(value))
 805         Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_DIV_BY_ZERO,
 806             "float division by zero");
 807
 808     if (!dest)
 809         dest = pmc_new(INTERP, VTABLE_type(INTERP, SELF));
 810
 811     f = floor(SELF.get_number() / value);
 812     VTABLE_set_integer_native(INTERP, dest, (INTVAL)f);
 813
 814     return dest;
 815 }
 816
 817 VTABLE void i_floor_divide(PMC *value) {
 818 MMD_BigInt:     {
 819         overflow_p(INTERP, SELF, value, SELF, MMD_FLOOR_DIVIDE);
 820     }
 821 MMD_DEFAULT: {
 822         FLOATVAL d = VTABLE_get_number(INTERP, value);
 823         FLOATVAL f;
 824
 825         if (FLOAT_IS_ZERO(d))
 826             Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_DIV_BY_ZERO,
 827                 "float division by zero");
 828
 829         f = floor(SELF.get_number() / d);
 830         VTABLE_set_integer_native(INTERP, SELF, (INTVAL)f);
 831     }
 832 }
 833
 834 VTABLE void i_floor_divide_int(INTVAL value) {
 835     FLOATVAL f;
 836
 837     if (value == 0)
 838         Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_DIV_BY_ZERO,
 839             "float division by zero");
 840
 841     f = floor(SELF.get_number() / value);
 842     VTABLE_set_integer_native(INTERP, SELF, (INTVAL)f);
 843 }
 844
 845 VTABLE void i_floor_divide_float(FLOATVAL value) {
 846     FLOATVAL f;
 847
 848     if (FLOAT_IS_ZERO(value))
 849         Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_DIV_BY_ZERO,
 850             "float division by zero");
 851
 852     f = floor(SELF.get_number() / value);
 853     VTABLE_set_integer_native(INTERP, SELF, (INTVAL)f);
 854 }
 855
 856 /*
 857
 858 =item C<PMC *cmodulus(PMC *value, PMC *dest)>
 859
 860 =item C<PMC *cmodulus(INTVAL value, PMC *dest)>
 861
 862 =item C<PMC *cmodulus(FLOATVAL value, PMC *dest)>
 863
 864 Calculates the value of the number C-style C<mod> C<value> and returns
 865 the result in C<dest>.
 866
 867 =item C<void i_cmodulus(PMC *value)>
 868
 869 =item C<void i_cmodulus(INTVAL value)>
 870
 871 =item C<void i_cmodulus(FLOATVAL value)>
 872
 873 Calculates the value of the number C-style C<mod> C<value> and returns
 874 the result in C<dest>.
 875
 876 =cut
 877
 878 */
 879
 880 VTABLE PMC *cmodulus(PMC *value, PMC *dest) {
 881 MMD_BigInt: {
 882         return overflow_p(INTERP, SELF, value, dest, MMD_CMOD);
 883     }
 884 MMD_DEFAULT: {
 885         INTVAL d = VTABLE_get_integer(INTERP, value);
 886
 887         if (d == 0)
 888             Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_DIV_BY_ZERO,
 889                 "int cmodulus by zero");
 890
 891         if (!dest)
 892             dest = pmc_new(INTERP, VTABLE_type(INTERP, SELF));
 893
 894         VTABLE_set_integer_native(INTERP, dest,
 895                 SELF.get_integer() % d);
 896         return dest;
 897     }
 898 }
 899
 900 VTABLE PMC *cmodulus_float(FLOATVAL value, PMC *dest) {
 901     FLOATVAL f;
 902
 903     if (FLOAT_IS_ZERO(value))
 904         Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_DIV_BY_ZERO,
 905             "int cmodulus by zero");
 906
 907     if (!dest)
 908         dest = pmc_new(INTERP, VTABLE_type(INTERP, SELF));
 909
 910     f = fmod(SELF.get_integer(), value);
 911     VTABLE_set_integer_native(INTERP, dest, (INTVAL)f);
 912
 913     return dest;
 914 }
 915
 916 VTABLE PMC *cmodulus_int(INTVAL value, PMC *dest) {
 917     if (value == 0)
 918         Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_DIV_BY_ZERO,
 919             "int cmodulus by zero");
 920
 921     if (!dest)
 922         dest = pmc_new(INTERP, VTABLE_type(INTERP, SELF));
 923     VTABLE_set_integer_native(INTERP, dest,
 924             SELF.get_integer() % value);
 925     return dest;
 926 }
 927
 928 VTABLE void i_cmodulus(PMC *value) {
 929 MMD_BigInt: {
 930          overflow_p(INTERP, SELF, value, SELF, MMD_CMOD);
 931     }
 932 MMD_DEFAULT: {
 933         const INTVAL d = VTABLE_get_integer(INTERP, value);
 934
 935         if (d == 0)
 936             Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_DIV_BY_ZERO,
 937                 "int cmodulus by zero");
 938
 939         VTABLE_set_integer_native(INTERP, SELF,
 940                 SELF.get_integer() % d);
 941     }
 942 }
 943
 944 VTABLE void i_cmodulus_int(INTVAL value) {
 945     if (value == 0)
 946         Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_DIV_BY_ZERO,
 947             "int cmodulus by zero");
 948
 949     VTABLE_set_integer_native(INTERP, SELF,
 950             SELF.get_integer() % value);
 951 }
 952
 953 VTABLE void i_cmodulus_float(FLOATVAL value) {
 954     FLOATVAL f;
 955
 956     if (FLOAT_IS_ZERO(value))
 957         Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_DIV_BY_ZERO,
 958             "int cmodulus by zero");
 959
 960     f = fmod(SELF.get_integer(), value);
 961     VTABLE_set_integer_native(INTERP, SELF, (INTVAL)f);
 962 }
 963
 964 /*
 965
 966 =item C<PMC *modulus(PMC *value, PMC *dest)>
 967
 968 =item C<PMC *modulus(INTVAL value, PMC *dest)>
 969
 970 =item C<PMC *modulus(FLOATVAL value, PMC *dest)>
 971
 972 Calculates the value of corrected C<mod> C<value> and returns
 973 the result in C<dest>. See also ops/math.ops.
 974
 975 =item C<void i_modulus(PMC *value)>
 976
 977 =item C<void i_modulus(INTVAL value)>
 978
 979 =item C<void i_modulus(FLOATVAL value)>
 980
 981 Calculates modulus inplace
 982
 983 =cut
 984
 985 */
 986
 987 VTABLE PMC *modulus(PMC *value, PMC *dest) {
 988 MMD_BigInt: {
 989         return overflow_p(INTERP, SELF, value, dest, MMD_MOD);
 990     }
 991 MMD_DEFAULT: {
 992         const INTVAL d = VTABLE_get_integer(INTERP, value);
 993
 994         if (d == 0)
 995             Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_DIV_BY_ZERO,
 996                 "int modulus by zero");
 997
 998         if (!dest)
 999             dest = pmc_new(INTERP, VTABLE_type(INTERP, SELF));
1000
1001         VTABLE_set_integer_native(INTERP, dest,
1002                 intval_mod(SELF.get_integer(), d));
1003         return dest;
1004     }
1005 }
1006
1007 VTABLE PMC *modulus_int(INTVAL value, PMC *dest) {
1008     if (value == 0)
1009         Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_DIV_BY_ZERO,
1010             "int modulus by zero");
1011
1012     if (!dest)
1013         dest = pmc_new(INTERP, VTABLE_type(INTERP, SELF));
1014
1015     VTABLE_set_integer_native(INTERP, dest,
1016             intval_mod(SELF.get_integer(), value));
1017     return dest;
1018 }
1019
1020 VTABLE PMC *modulus_float(FLOATVAL value, PMC *dest) {
1021     if (FLOAT_IS_ZERO(value))
1022         Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_DIV_BY_ZERO,
1023             "int modulus by zero");
1024
1025     if (!dest)
1026         dest = pmc_new(INTERP, VTABLE_type(INTERP, SELF));
1027
1028     VTABLE_set_integer_native(INTERP, dest,
1029             intval_mod(SELF.get_integer(), (INTVAL)value));
1030     return dest;
1031 }
1032 VTABLE void i_modulus(PMC *value) {
1033 MMD_BigInt: {
1034          overflow_p(INTERP, SELF, value, SELF, MMD_MOD);
1035     }
1036 MMD_DEFAULT: {
1037         const INTVAL d = VTABLE_get_integer(INTERP, value);
1038
1039         if (d == 0)
1040             Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_DIV_BY_ZERO,
1041                 "int modulus by zero");
1042
1043         VTABLE_set_integer_native(INTERP, SELF,
1044                 intval_mod(SELF.get_integer(), d));
1045     }
1046 }
1047
1048 VTABLE void i_modulus_int(INTVAL value) {
1049     if (value == 0)
1050         Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_DIV_BY_ZERO,
1051             "int modulus by zero");
1052
1053     VTABLE_set_integer_native(INTERP, SELF,
1054             intval_mod(SELF.get_integer() , value));
1055 }
1056
1057 VTABLE void i_modulus_float(FLOATVAL value) {
1058     if (FLOAT_IS_ZERO(value))
1059         Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_DIV_BY_ZERO,
1060             "int modulus by zero");
1061
1062     VTABLE_set_integer_native(INTERP, SELF,
1063             intval_mod(SELF.get_integer() , (INTVAL)value));
1064 }
1065
1066 /*
1067
1068 =item C<PMC *pow(PMC *value, PMC *dest)>
1069
1070 =item C<PMC *pow_int(INTVAL value, PMC *dest)>
1071
1072 Return SELF to the C<value>th power and return result in C<dest>.
1073
1074 =item C<void i_pow(PMC *value)>
1075
1076 =item C<void i_pow_int(INTVAL value)>
1077
1078 Raise SELF to the C<value>th power.
1079
1080 RT #46631 Complex and BigInt rhs.
1081
1082 =cut
1083
1084 */
1085 VTABLE PMC *pow(PMC *value, PMC *dest) {
1086     const INTVAL v = VTABLE_get_integer(INTERP, value);
1087     return STATICSELF.pow_int(v, dest);
1088 }
1089
1090 VTABLE PMC *pow_int(INTVAL b, PMC *dest) {
1091     const INTVAL a      = SELF.get_integer();
1092     const INTVAL orig_b = b;
1093     INTVAL       r;
1094
1095     if (b < 0)
1096         return SUPER(b, dest);
1097
1098     r = 1;
1099
1100     if (a) {
1101         INTVAL temp = a;
1102         while (b > 0) {
1103             INTVAL prev = r;
1104             if (b & 1) {
1105                 r *= temp;
1106                 if (r / temp != prev)
1107                     return overflow(INTERP, SELF, orig_b, dest, MMD_POW);
1108             }
1109
1110             b >>= 1;
1111             if (!b)
1112                 break;
1113
1114             prev  = temp;
1115             temp *= temp;
1116
1117             if (prev != 0 && temp / prev != prev)
1118                 return overflow(INTERP, SELF, orig_b, dest, MMD_POW);
1119         }
1120     }
1121
1122     if (!dest)
1123         dest = pmc_new(INTERP, VTABLE_type(INTERP, SELF));
1124
1125     VTABLE_set_integer_native(INTERP, dest, r);
1126     return dest;
1127
1128 }
1129
1130 VTABLE void i_pow(PMC *value) {
1131     STATICSELF.pow(value, SELF);
1132 }
1133
1134 VTABLE void i_pow_int(INTVAL value) {
1135     STATICSELF.pow_int(value, SELF);
1136 }
1137
1138 /*
1139
1140 =item C<INTVAL is_equal(PMC *value)>
1141
1142 The C<==> operation.
1143
1144 =cut
1145
1146 */
1147 VTABLE INTVAL is_equal(PMC *value) {
1148 MMD_BigInt: {
1149         PMC * const temp = pmc_new(INTERP, enum_class_BigInt);
1150         VTABLE_set_integer_native(INTERP, temp, SELF.get_integer());
1151         return Parrot_BigInt_is_equal_BigInt(INTERP, temp, value);
1152     }
1153 MMD_DEFAULT: {
1154     return (VTABLE_get_integer(INTERP, SELF) ==
1155         VTABLE_get_integer(INTERP, value));
1156     }
1157 }
1158
1159 /*
1160
1161 =item C<INTVAL cmp(PMC *value)>
1162
1163 Returns the result of comparing the integer with C<*value>.
1164
1165 =cut
1166
1167 */
1168 VTABLE INTVAL cmp(PMC *value) {
1169 MMD_String: {
1170             FLOATVAL fdiff =
1171                 SELF.get_number() - VTABLE_get_number(INTERP, value);
1172             if (FLOAT_IS_ZERO(fdiff)) {
1173                 const INTVAL idiff =
1174                     SELF.get_integer() - VTABLE_get_integer(INTERP, value);
1175                 return idiff > 0 ? 1 : idiff < 0 ? -1 : 0;
1176             }
1177             else {
1178                 return fdiff > 0 ? 1 : -1;
1179             }
1180     }
1181 MMD_Float: {
1182             const FLOATVAL diff =
1183                 SELF.get_number() - VTABLE_get_number(INTERP, value);
1184             return diff > 0 ? 1 : diff < 0 ? -1 : 0;
1185         }
1186 MMD_DEFAULT: {
1187             /* int or undef */
1188             const INTVAL diff = SELF.get_integer()
1189                 - VTABLE_get_integer(INTERP, value);
1190             return diff > 0 ? 1 : diff < 0 ? -1 : 0;
1191         }
1192 }
1193
1194 /*
1195
1196 =item C<INTVAL cmp_num(PMC *value)>
1197
1198 Returns the result of numerically comparing the integer with C<*value>.
1199
1200 =cut
1201
1202 */
1203 VTABLE INTVAL cmp_num(PMC *value) {
1204 MMD_String: {
1205             FLOATVAL fdiff =
1206                 SELF.get_number() - VTABLE_get_number(INTERP, value);
1207
1208             if (FLOAT_IS_ZERO(fdiff)) {
1209                 const INTVAL idiff =
1210                     SELF.get_integer() - VTABLE_get_integer(INTERP, value);
1211                 return idiff > 0 ? 1 : idiff < 0 ? -1 : 0;
1212             }
1213             else {
1214                 return fdiff > 0 ? 1 : -1;
1215             }
1216         }
1217 MMD_Float: {
1218             const FLOATVAL diff =
1219                 SELF.get_number() - VTABLE_get_number(INTERP, value);
1220             return diff > 0 ? 1 : diff < 0 ? -1 : 0;
1221         }
1222 MMD_DEFAULT: {
1223             /* int or undef */
1224             const INTVAL diff =
1225                 SELF.get_integer() - VTABLE_get_integer(INTERP, value);
1226             return diff > 0 ? 1 : diff < 0 ? -1 : 0;
1227         }
1228 }
1229
1230 /*
1231
1232 =item C<void increment()>
1233
1234 Increments the integer.
1235
1236 =cut
1237
1238 */
1239 VTABLE void increment() {
1240     /* RT #46633 overflow */
1241     PMC_int_val(SELF) ++;
1242 }
1243
1244 /*
1245
1246 =item C<void decrement()>
1247
1248 Decrements the integer.
1249
1250 =cut
1251
1252 */
1253 VTABLE void decrement() {
1254     /* RT #46633 overflow */
1255     PMC_int_val(SELF) --;
1256 }
1257 /*
1258
1259 =item C<PMC *absolute(PMC *dest)>
1260
1261 =item C<void absolute()>
1262
1263 Sets C<dest> to the absolute value of SELF.
1264
1265 =cut
1266
1267 */
1268
1269 VTABLE PMC *absolute(PMC *dest) {
1270     const INTVAL a = abs(SELF.get_integer());
1271
1272     /* RT #46635 overlflow for -maxint */
1273     if (!dest)
1274         dest = pmc_new(INTERP, VTABLE_type(INTERP, SELF));
1275
1276     VTABLE_set_integer_native(INTERP, dest, a);
1277     return dest;
1278
1279 }
1280
1281 VTABLE void i_absolute() {
1282     const INTVAL a = abs(SELF.get_integer());
1283     VTABLE_set_integer_native(INTERP, SELF, a);
1284 }
1285
1286 /*
1287
1288 =item C<STRING *get_as_base(INTVAL base)>
1289
1290 Converts and returns the integer in base C<base>.
1291 C<base> must be between 2 and 36, inclusive.
1292
1293 =cut
1294
1295 */
1296
1297 METHOD get_as_base(INTVAL base) {
1298     char buf[128];
1299     STRING *result;
1300
1301     if ((base < 2) || (base > 36))
1302         Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_OUT_OF_BOUNDS,
1303             "get_as_base: base out of bounds");
1304
1305         result = int_to_str(interp, buf,
1306                 (HUGEINTVAL)VTABLE_get_integer(INTERP, SELF), (char)base);
1307         RETURN(STRING *result);
1308     }
1309
1310 /*
1311
1312 =item C<void freeze(visit_info *info)>
1313
1314 Used to archive the integer.
1315
1316 =cut
1317
1318 */
1319     VTABLE void freeze(visit_info *info) {
1320         IMAGE_IO * const io = info->image_io;
1321         SUPER(info);
1322         VTABLE_push_integer(INTERP, io, PMC_int_val(SELF));
1323     }
1324
1325 /*
1326
1327 =item C<void thaw(visit_info *info)>
1328
1329 Used to unarchive the integer.
1330
1331 =cut
1332
1333 */
1334     VTABLE void thaw(visit_info *info) {
1335         IMAGE_IO * const io = info->image_io;
1336         SUPER(info);
1337         if (info->extra_flags == EXTRA_IS_NULL)
1338             PMC_int_val(SELF) = VTABLE_shift_integer(INTERP, io);
1339     }
1340 }
1341
1342 /*
1343
1344 =back
1345
1346 =cut
1347
1348 */
1349
1350 /*
1351  * Local variables:
1352  *   c-file-style: "parrot"
1353  * End:
1354  * vim: expandtab shiftwidth=4:
1355  */