granicus.if.org Git - postgresql/blob - src/backend/utils/adt/int.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * int.c
   4  *        Functions for the built-in integer types (except int8).
   5  *
   6  * Portions Copyright (c) 1996-2000, PostgreSQL, Inc
   7  * Portions Copyright (c) 1994, Regents of the University of California
   8  *
   9  *
  10  * IDENTIFICATION
  11  *        $Header: /cvsroot/pgsql/src/backend/utils/adt/int.c,v 1.44 2000/12/03 20:45:36 tgl Exp $
  12  *
  13  *-------------------------------------------------------------------------
  14  */
  15 /*
  16  * OLD COMMENTS
  17  *              I/O routines:
  18  *               int2in, int2out, int2vectorin, int2vectorout, int4in, int4out
  19  *              Conversion routines:
  20  *               itoi, int2_text, int4_text
  21  *              Boolean operators:
  22  *               inteq, intne, intlt, intle, intgt, intge
  23  *              Arithmetic operators:
  24  *               intpl, intmi, int4mul, intdiv
  25  *
  26  *              Arithmetic operators:
  27  *               intmod, int4fac
  28  */
  29
  30 #include "postgres.h"
  31
  32 #include <ctype.h>
  33 #include <limits.h>
  34
  35 #include "utils/builtins.h"
  36
  37 #ifndef SHRT_MAX
  38 #define SHRT_MAX (0x7FFF)
  39 #endif
  40 #ifndef SHRT_MIN
  41 #define SHRT_MIN (-0x8000)
  42 #endif
  43
  44 /*****************************************************************************
  45  *       USER I/O ROUTINES                                                                                                               *
  46  *****************************************************************************/
  47
  48 /*
  49  *              int2in                  - converts "num" to short
  50  */
  51 Datum
  52 int2in(PG_FUNCTION_ARGS)
  53 {
  54         char       *num = PG_GETARG_CSTRING(0);
  55
  56         PG_RETURN_INT16(pg_atoi(num, sizeof(int16), '\0'));
  57 }
  58
  59 /*
  60  *              int2out                 - converts short to "num"
  61  */
  62 Datum
  63 int2out(PG_FUNCTION_ARGS)
  64 {
  65         int16           arg1 = PG_GETARG_INT16(0);
  66         char       *result = (char *) palloc(7); /* sign, 5 digits, '\0' */
  67
  68         pg_itoa(arg1, result);
  69         PG_RETURN_CSTRING(result);
  70 }
  71
  72 /*
  73  *              int2vectorin                    - converts "num num ..." to internal form
  74  *
  75  *              Note: Fills any missing slots with zeroes.
  76  */
  77 Datum
  78 int2vectorin(PG_FUNCTION_ARGS)
  79 {
  80         char       *intString = PG_GETARG_CSTRING(0);
  81         int16      *result = (int16 *) palloc(sizeof(int16[INDEX_MAX_KEYS]));
  82         int                     slot;
  83
  84         for (slot = 0; *intString && slot < INDEX_MAX_KEYS; slot++)
  85         {
  86                 if (sscanf(intString, "%hd", &result[slot]) != 1)
  87                         break;
  88                 while (*intString && isspace((unsigned char) *intString))
  89                         intString++;
  90                 while (*intString && !isspace((unsigned char) *intString))
  91                         intString++;
  92         }
  93         while (*intString && isspace((unsigned char) *intString))
  94                 intString++;
  95         if (*intString)
  96                 elog(ERROR, "int2vector value has too many values");
  97         while (slot < INDEX_MAX_KEYS)
  98                 result[slot++] = 0;
  99
 100         PG_RETURN_POINTER(result);
 101 }
 102
 103 /*
 104  *              int2vectorout           - converts internal form to "num num ..."
 105  */
 106 Datum
 107 int2vectorout(PG_FUNCTION_ARGS)
 108 {
 109         int16      *int2Array = (int16 *) PG_GETARG_POINTER(0);
 110         int                     num,
 111                                 maxnum;
 112         char       *rp;
 113         char       *result;
 114
 115         /* find last non-zero value in vector */
 116         for (maxnum = INDEX_MAX_KEYS - 1; maxnum >= 0; maxnum--)
 117                 if (int2Array[maxnum] != 0)
 118                         break;
 119
 120         /* assumes sign, 5 digits, ' ' */
 121         rp = result = (char *) palloc((maxnum + 1) * 7 + 1);
 122         for (num = 0; num <= maxnum; num++)
 123         {
 124                 if (num != 0)
 125                         *rp++ = ' ';
 126                 pg_itoa(int2Array[num], rp);
 127                 while (*++rp != '\0')
 128                         ;
 129         }
 130         *rp = '\0';
 131         PG_RETURN_CSTRING(result);
 132 }
 133
 134 /*
 135  * We don't have a complete set of int2vector support routines,
 136  * but we need int2vectoreq for catcache indexing.
 137  */
 138 Datum
 139 int2vectoreq(PG_FUNCTION_ARGS)
 140 {
 141         int16      *arg1 = (int16 *) PG_GETARG_POINTER(0);
 142         int16      *arg2 = (int16 *) PG_GETARG_POINTER(1);
 143
 144         PG_RETURN_BOOL(memcmp(arg1, arg2, INDEX_MAX_KEYS * sizeof(int16)) == 0);
 145 }
 146
 147 /*
 148  * Type int44 has no real-world use, but the regression tests use it.
 149  * It's a four-element vector of int4's.
 150  */
 151
 152 /*
 153  *              int44in                 - converts "num num ..." to internal form
 154  *
 155  *              Note: Fills any missing positions with zeroes.
 156  */
 157 Datum
 158 int44in(PG_FUNCTION_ARGS)
 159 {
 160         char       *input_string = PG_GETARG_CSTRING(0);
 161         int32      *result = (int32 *) palloc(4 * sizeof(int32));
 162         int                     i;
 163
 164         i = sscanf(input_string,
 165                            "%d, %d, %d, %d",
 166                            &result[0],
 167                            &result[1],
 168                            &result[2],
 169                            &result[3]);
 170         while (i < 4)
 171                 result[i++] = 0;
 172
 173         PG_RETURN_POINTER(result);
 174 }
 175
 176 /*
 177  *              int44out                - converts internal form to "num num ..."
 178  */
 179 Datum
 180 int44out(PG_FUNCTION_ARGS)
 181 {
 182         int32      *an_array = (int32 *) PG_GETARG_POINTER(0);
 183         char       *result = (char *) palloc(16 * 4); /* Allow 14 digits + sign */
 184         int                     i;
 185         char       *walk;
 186
 187         walk = result;
 188         for (i = 0; i < 4; i++)
 189         {
 190                 pg_ltoa(an_array[i], walk);
 191                 while (*++walk != '\0')
 192                         ;
 193                 *walk++ = ' ';
 194         }
 195         *--walk = '\0';
 196         PG_RETURN_CSTRING(result);
 197 }
 198
 199
 200 /*****************************************************************************
 201  *       PUBLIC ROUTINES                                                                                                                 *
 202  *****************************************************************************/
 203
 204 /*
 205  *              int4in                  - converts "num" to int4
 206  */
 207 Datum
 208 int4in(PG_FUNCTION_ARGS)
 209 {
 210         char       *num = PG_GETARG_CSTRING(0);
 211
 212         PG_RETURN_INT32(pg_atoi(num, sizeof(int32), '\0'));
 213 }
 214
 215 /*
 216  *              int4out                 - converts int4 to "num"
 217  */
 218 Datum
 219 int4out(PG_FUNCTION_ARGS)
 220 {
 221         int32           arg1 = PG_GETARG_INT32(0);
 222         char       *result = (char *) palloc(12); /* sign, 10 digits, '\0' */
 223
 224         pg_ltoa(arg1, result);
 225         PG_RETURN_CSTRING(result);
 226 }
 227
 228
 229 /*
 230  *              ===================
 231  *              CONVERSION ROUTINES
 232  *              ===================
 233  */
 234
 235 Datum
 236 i2toi4(PG_FUNCTION_ARGS)
 237 {
 238         int16           arg1 = PG_GETARG_INT16(0);
 239
 240         PG_RETURN_INT32((int32) arg1);
 241 }
 242
 243 Datum
 244 i4toi2(PG_FUNCTION_ARGS)
 245 {
 246         int32           arg1 = PG_GETARG_INT32(0);
 247
 248         if (arg1 < SHRT_MIN)
 249                 elog(ERROR, "i4toi2: '%d' causes int2 underflow", arg1);
 250         if (arg1 > SHRT_MAX)
 251                 elog(ERROR, "i4toi2: '%d' causes int2 overflow", arg1);
 252
 253         PG_RETURN_INT16((int16) arg1);
 254 }
 255
 256 Datum
 257 int2_text(PG_FUNCTION_ARGS)
 258 {
 259         int16           arg1 = PG_GETARG_INT16(0);
 260         text       *result = (text *) palloc(7+VARHDRSZ); /* sign,5 digits, '\0' */
 261
 262         pg_itoa(arg1, VARDATA(result));
 263         VARATT_SIZEP(result) = strlen(VARDATA(result)) + VARHDRSZ;
 264         PG_RETURN_TEXT_P(result);
 265 }
 266
 267 Datum
 268 text_int2(PG_FUNCTION_ARGS)
 269 {
 270         text       *string = PG_GETARG_TEXT_P(0);
 271         Datum           result;
 272         int                     len;
 273         char       *str;
 274
 275         len = VARSIZE(string) - VARHDRSZ;
 276
 277         str = palloc(len + 1);
 278         memcpy(str, VARDATA(string), len);
 279         *(str + len) = '\0';
 280
 281         result = DirectFunctionCall1(int2in, CStringGetDatum(str));
 282         pfree(str);
 283
 284         return result;
 285 }
 286
 287 Datum
 288 int4_text(PG_FUNCTION_ARGS)
 289 {
 290         int32           arg1 = PG_GETARG_INT32(0);
 291         text       *result = (text *) palloc(12+VARHDRSZ); /* sign,10 digits,'\0' */
 292
 293         pg_ltoa(arg1, VARDATA(result));
 294         VARATT_SIZEP(result) = strlen(VARDATA(result)) + VARHDRSZ;
 295         PG_RETURN_TEXT_P(result);
 296 }
 297
 298 Datum
 299 text_int4(PG_FUNCTION_ARGS)
 300 {
 301         text       *string = PG_GETARG_TEXT_P(0);
 302         Datum           result;
 303         int                     len;
 304         char       *str;
 305
 306         len = VARSIZE(string) - VARHDRSZ;
 307
 308         str = palloc(len + 1);
 309         memcpy(str, VARDATA(string), len);
 310         *(str + len) = '\0';
 311
 312         result = DirectFunctionCall1(int4in, CStringGetDatum(str));
 313         pfree(str);
 314
 315         return result;
 316 }
 317
 318
 319 /*
 320  *              ============================
 321  *              COMPARISON OPERATOR ROUTINES
 322  *              ============================
 323  */
 324
 325 /*
 326  *              inteq                   - returns 1 iff arg1 == arg2
 327  *              intne                   - returns 1 iff arg1 != arg2
 328  *              intlt                   - returns 1 iff arg1 < arg2
 329  *              intle                   - returns 1 iff arg1 <= arg2
 330  *              intgt                   - returns 1 iff arg1 > arg2
 331  *              intge                   - returns 1 iff arg1 >= arg2
 332  */
 333
 334 Datum
 335 int4eq(PG_FUNCTION_ARGS)
 336 {
 337         int32           arg1 = PG_GETARG_INT32(0);
 338         int32           arg2 = PG_GETARG_INT32(1);
 339
 340         PG_RETURN_BOOL(arg1 == arg2);
 341 }
 342
 343 Datum
 344 int4ne(PG_FUNCTION_ARGS)
 345 {
 346         int32           arg1 = PG_GETARG_INT32(0);
 347         int32           arg2 = PG_GETARG_INT32(1);
 348
 349         PG_RETURN_BOOL(arg1 != arg2);
 350 }
 351
 352 Datum
 353 int4lt(PG_FUNCTION_ARGS)
 354 {
 355         int32           arg1 = PG_GETARG_INT32(0);
 356         int32           arg2 = PG_GETARG_INT32(1);
 357
 358         PG_RETURN_BOOL(arg1 < arg2);
 359 }
 360
 361 Datum
 362 int4le(PG_FUNCTION_ARGS)
 363 {
 364         int32           arg1 = PG_GETARG_INT32(0);
 365         int32           arg2 = PG_GETARG_INT32(1);
 366
 367         PG_RETURN_BOOL(arg1 <= arg2);
 368 }
 369
 370 Datum
 371 int4gt(PG_FUNCTION_ARGS)
 372 {
 373         int32           arg1 = PG_GETARG_INT32(0);
 374         int32           arg2 = PG_GETARG_INT32(1);
 375
 376         PG_RETURN_BOOL(arg1 > arg2);
 377 }
 378
 379 Datum
 380 int4ge(PG_FUNCTION_ARGS)
 381 {
 382         int32           arg1 = PG_GETARG_INT32(0);
 383         int32           arg2 = PG_GETARG_INT32(1);
 384
 385         PG_RETURN_BOOL(arg1 >= arg2);
 386 }
 387
 388 Datum
 389 int2eq(PG_FUNCTION_ARGS)
 390 {
 391         int16           arg1 = PG_GETARG_INT16(0);
 392         int16           arg2 = PG_GETARG_INT16(1);
 393
 394         PG_RETURN_BOOL(arg1 == arg2);
 395 }
 396
 397 Datum
 398 int2ne(PG_FUNCTION_ARGS)
 399 {
 400         int16           arg1 = PG_GETARG_INT16(0);
 401         int16           arg2 = PG_GETARG_INT16(1);
 402
 403         PG_RETURN_BOOL(arg1 != arg2);
 404 }
 405
 406 Datum
 407 int2lt(PG_FUNCTION_ARGS)
 408 {
 409         int16           arg1 = PG_GETARG_INT16(0);
 410         int16           arg2 = PG_GETARG_INT16(1);
 411
 412         PG_RETURN_BOOL(arg1 < arg2);
 413 }
 414
 415 Datum
 416 int2le(PG_FUNCTION_ARGS)
 417 {
 418         int16           arg1 = PG_GETARG_INT16(0);
 419         int16           arg2 = PG_GETARG_INT16(1);
 420
 421         PG_RETURN_BOOL(arg1 <= arg2);
 422 }
 423
 424 Datum
 425 int2gt(PG_FUNCTION_ARGS)
 426 {
 427         int16           arg1 = PG_GETARG_INT16(0);
 428         int16           arg2 = PG_GETARG_INT16(1);
 429
 430         PG_RETURN_BOOL(arg1 > arg2);
 431 }
 432
 433 Datum
 434 int2ge(PG_FUNCTION_ARGS)
 435 {
 436         int16           arg1 = PG_GETARG_INT16(0);
 437         int16           arg2 = PG_GETARG_INT16(1);
 438
 439         PG_RETURN_BOOL(arg1 >= arg2);
 440 }
 441
 442 Datum
 443 int24eq(PG_FUNCTION_ARGS)
 444 {
 445         int16           arg1 = PG_GETARG_INT16(0);
 446         int32           arg2 = PG_GETARG_INT32(1);
 447
 448         PG_RETURN_BOOL(arg1 == arg2);
 449 }
 450
 451 Datum
 452 int24ne(PG_FUNCTION_ARGS)
 453 {
 454         int16           arg1 = PG_GETARG_INT16(0);
 455         int32           arg2 = PG_GETARG_INT32(1);
 456
 457         PG_RETURN_BOOL(arg1 != arg2);
 458 }
 459
 460 Datum
 461 int24lt(PG_FUNCTION_ARGS)
 462 {
 463         int16           arg1 = PG_GETARG_INT16(0);
 464         int32           arg2 = PG_GETARG_INT32(1);
 465
 466         PG_RETURN_BOOL(arg1 < arg2);
 467 }
 468
 469 Datum
 470 int24le(PG_FUNCTION_ARGS)
 471 {
 472         int16           arg1 = PG_GETARG_INT16(0);
 473         int32           arg2 = PG_GETARG_INT32(1);
 474
 475         PG_RETURN_BOOL(arg1 <= arg2);
 476 }
 477
 478 Datum
 479 int24gt(PG_FUNCTION_ARGS)
 480 {
 481         int16           arg1 = PG_GETARG_INT16(0);
 482         int32           arg2 = PG_GETARG_INT32(1);
 483
 484         PG_RETURN_BOOL(arg1 > arg2);
 485 }
 486
 487 Datum
 488 int24ge(PG_FUNCTION_ARGS)
 489 {
 490         int16           arg1 = PG_GETARG_INT16(0);
 491         int32           arg2 = PG_GETARG_INT32(1);
 492
 493         PG_RETURN_BOOL(arg1 >= arg2);
 494 }
 495
 496 Datum
 497 int42eq(PG_FUNCTION_ARGS)
 498 {
 499         int32           arg1 = PG_GETARG_INT32(0);
 500         int16           arg2 = PG_GETARG_INT16(1);
 501
 502         PG_RETURN_BOOL(arg1 == arg2);
 503 }
 504
 505 Datum
 506 int42ne(PG_FUNCTION_ARGS)
 507 {
 508         int32           arg1 = PG_GETARG_INT32(0);
 509         int16           arg2 = PG_GETARG_INT16(1);
 510
 511         PG_RETURN_BOOL(arg1 != arg2);
 512 }
 513
 514 Datum
 515 int42lt(PG_FUNCTION_ARGS)
 516 {
 517         int32           arg1 = PG_GETARG_INT32(0);
 518         int16           arg2 = PG_GETARG_INT16(1);
 519
 520         PG_RETURN_BOOL(arg1 < arg2);
 521 }
 522
 523 Datum
 524 int42le(PG_FUNCTION_ARGS)
 525 {
 526         int32           arg1 = PG_GETARG_INT32(0);
 527         int16           arg2 = PG_GETARG_INT16(1);
 528
 529         PG_RETURN_BOOL(arg1 <= arg2);
 530 }
 531
 532 Datum
 533 int42gt(PG_FUNCTION_ARGS)
 534 {
 535         int32           arg1 = PG_GETARG_INT32(0);
 536         int16           arg2 = PG_GETARG_INT16(1);
 537
 538         PG_RETURN_BOOL(arg1 > arg2);
 539 }
 540
 541 Datum
 542 int42ge(PG_FUNCTION_ARGS)
 543 {
 544         int32           arg1 = PG_GETARG_INT32(0);
 545         int16           arg2 = PG_GETARG_INT16(1);
 546
 547         PG_RETURN_BOOL(arg1 >= arg2);
 548 }
 549
 550 /*
 551  *              int[24]pl               - returns arg1 + arg2
 552  *              int[24]mi               - returns arg1 - arg2
 553  *              int[24]mul              - returns arg1 * arg2
 554  *              int[24]div              - returns arg1 / arg2
 555  */
 556
 557 Datum
 558 int4um(PG_FUNCTION_ARGS)
 559 {
 560         int32           arg = PG_GETARG_INT32(0);
 561
 562         PG_RETURN_INT32(-arg);
 563 }
 564
 565 Datum
 566 int4pl(PG_FUNCTION_ARGS)
 567 {
 568         int32           arg1 = PG_GETARG_INT32(0);
 569         int32           arg2 = PG_GETARG_INT32(1);
 570
 571         PG_RETURN_INT32(arg1 + arg2);
 572 }
 573
 574 Datum
 575 int4mi(PG_FUNCTION_ARGS)
 576 {
 577         int32           arg1 = PG_GETARG_INT32(0);
 578         int32           arg2 = PG_GETARG_INT32(1);
 579
 580         PG_RETURN_INT32(arg1 - arg2);
 581 }
 582
 583 Datum
 584 int4mul(PG_FUNCTION_ARGS)
 585 {
 586         int32           arg1 = PG_GETARG_INT32(0);
 587         int32           arg2 = PG_GETARG_INT32(1);
 588
 589         PG_RETURN_INT32(arg1 * arg2);
 590 }
 591
 592 Datum
 593 int4div(PG_FUNCTION_ARGS)
 594 {
 595         int32           arg1 = PG_GETARG_INT32(0);
 596         int32           arg2 = PG_GETARG_INT32(1);
 597
 598         PG_RETURN_INT32(arg1 / arg2);
 599 }
 600
 601 Datum
 602 int4inc(PG_FUNCTION_ARGS)
 603 {
 604         int32           arg = PG_GETARG_INT32(0);
 605
 606         PG_RETURN_INT32(arg + 1);
 607 }
 608
 609 Datum
 610 int2um(PG_FUNCTION_ARGS)
 611 {
 612         int16           arg = PG_GETARG_INT16(0);
 613
 614         PG_RETURN_INT16(-arg);
 615 }
 616
 617 Datum
 618 int2pl(PG_FUNCTION_ARGS)
 619 {
 620         int16           arg1 = PG_GETARG_INT16(0);
 621         int16           arg2 = PG_GETARG_INT16(1);
 622
 623         PG_RETURN_INT16(arg1 + arg2);
 624 }
 625
 626 Datum
 627 int2mi(PG_FUNCTION_ARGS)
 628 {
 629         int16           arg1 = PG_GETARG_INT16(0);
 630         int16           arg2 = PG_GETARG_INT16(1);
 631
 632         PG_RETURN_INT16(arg1 - arg2);
 633 }
 634
 635 Datum
 636 int2mul(PG_FUNCTION_ARGS)
 637 {
 638         int16           arg1 = PG_GETARG_INT16(0);
 639         int16           arg2 = PG_GETARG_INT16(1);
 640
 641         PG_RETURN_INT16(arg1 * arg2);
 642 }
 643
 644 Datum
 645 int2div(PG_FUNCTION_ARGS)
 646 {
 647         int16           arg1 = PG_GETARG_INT16(0);
 648         int16           arg2 = PG_GETARG_INT16(1);
 649
 650         PG_RETURN_INT16(arg1 / arg2);
 651 }
 652
 653 Datum
 654 int24pl(PG_FUNCTION_ARGS)
 655 {
 656         int16           arg1 = PG_GETARG_INT16(0);
 657         int32           arg2 = PG_GETARG_INT32(1);
 658
 659         PG_RETURN_INT32(arg1 + arg2);
 660 }
 661
 662 Datum
 663 int24mi(PG_FUNCTION_ARGS)
 664 {
 665         int16           arg1 = PG_GETARG_INT16(0);
 666         int32           arg2 = PG_GETARG_INT32(1);
 667
 668         PG_RETURN_INT32(arg1 - arg2);
 669 }
 670
 671 Datum
 672 int24mul(PG_FUNCTION_ARGS)
 673 {
 674         int16           arg1 = PG_GETARG_INT16(0);
 675         int32           arg2 = PG_GETARG_INT32(1);
 676
 677         PG_RETURN_INT32(arg1 * arg2);
 678 }
 679
 680 Datum
 681 int24div(PG_FUNCTION_ARGS)
 682 {
 683         int16           arg1 = PG_GETARG_INT16(0);
 684         int32           arg2 = PG_GETARG_INT32(1);
 685
 686         PG_RETURN_INT32(arg1 / arg2);
 687 }
 688
 689 Datum
 690 int42pl(PG_FUNCTION_ARGS)
 691 {
 692         int32           arg1 = PG_GETARG_INT32(0);
 693         int16           arg2 = PG_GETARG_INT16(1);
 694
 695         PG_RETURN_INT32(arg1 + arg2);
 696 }
 697
 698 Datum
 699 int42mi(PG_FUNCTION_ARGS)
 700 {
 701         int32           arg1 = PG_GETARG_INT32(0);
 702         int16           arg2 = PG_GETARG_INT16(1);
 703
 704         PG_RETURN_INT32(arg1 - arg2);
 705 }
 706
 707 Datum
 708 int42mul(PG_FUNCTION_ARGS)
 709 {
 710         int32           arg1 = PG_GETARG_INT32(0);
 711         int16           arg2 = PG_GETARG_INT16(1);
 712
 713         PG_RETURN_INT32(arg1 * arg2);
 714 }
 715
 716 Datum
 717 int42div(PG_FUNCTION_ARGS)
 718 {
 719         int32           arg1 = PG_GETARG_INT32(0);
 720         int16           arg2 = PG_GETARG_INT16(1);
 721
 722         PG_RETURN_INT32(arg1 / arg2);
 723 }
 724
 725 Datum
 726 int4mod(PG_FUNCTION_ARGS)
 727 {
 728         int32           arg1 = PG_GETARG_INT32(0);
 729         int32           arg2 = PG_GETARG_INT32(1);
 730
 731         PG_RETURN_INT32(arg1 % arg2);
 732 }
 733
 734 Datum
 735 int2mod(PG_FUNCTION_ARGS)
 736 {
 737         int16           arg1 = PG_GETARG_INT16(0);
 738         int16           arg2 = PG_GETARG_INT16(1);
 739
 740         PG_RETURN_INT16(arg1 % arg2);
 741 }
 742
 743 Datum
 744 int24mod(PG_FUNCTION_ARGS)
 745 {
 746         int16           arg1 = PG_GETARG_INT16(0);
 747         int32           arg2 = PG_GETARG_INT32(1);
 748
 749         PG_RETURN_INT32(arg1 % arg2);
 750 }
 751
 752 Datum
 753 int42mod(PG_FUNCTION_ARGS)
 754 {
 755         int32           arg1 = PG_GETARG_INT32(0);
 756         int16           arg2 = PG_GETARG_INT16(1);
 757
 758         PG_RETURN_INT32(arg1 % arg2);
 759 }
 760
 761 /* int[24]fac()
 762  * Factorial
 763  */
 764 Datum
 765 int4fac(PG_FUNCTION_ARGS)
 766 {
 767         int32           arg1 = PG_GETARG_INT32(0);
 768         int32           result;
 769
 770         if (arg1 < 1)
 771                 result = 0;
 772         else
 773                 for (result = 1; arg1 > 0; --arg1)
 774                         result *= arg1;
 775         PG_RETURN_INT32(result);
 776 }
 777
 778 Datum
 779 int2fac(PG_FUNCTION_ARGS)
 780 {
 781         int16           arg1 = PG_GETARG_INT16(0);
 782         int32           result;
 783
 784         if (arg1 < 1)
 785                 result = 0;
 786         else
 787                 for (result = 1; arg1 > 0; --arg1)
 788                         result *= arg1;
 789         PG_RETURN_INT32(result);
 790 }
 791
 792 /* int[24]abs()
 793  * Absolute value
 794  */
 795 Datum
 796 int4abs(PG_FUNCTION_ARGS)
 797 {
 798         int32           arg1 = PG_GETARG_INT32(0);
 799
 800         PG_RETURN_INT32((arg1 < 0) ? -arg1 : arg1);
 801 }
 802
 803 Datum
 804 int2abs(PG_FUNCTION_ARGS)
 805 {
 806         int16           arg1 = PG_GETARG_INT16(0);
 807
 808         PG_RETURN_INT16((arg1 < 0) ? -arg1 : arg1);
 809 }
 810
 811 Datum
 812 int2larger(PG_FUNCTION_ARGS)
 813 {
 814         int16           arg1 = PG_GETARG_INT16(0);
 815         int16           arg2 = PG_GETARG_INT16(1);
 816
 817         PG_RETURN_INT16((arg1 > arg2) ? arg1 : arg2);
 818 }
 819
 820 Datum
 821 int2smaller(PG_FUNCTION_ARGS)
 822 {
 823         int16           arg1 = PG_GETARG_INT16(0);
 824         int16           arg2 = PG_GETARG_INT16(1);
 825
 826         PG_RETURN_INT16((arg1 < arg2) ? arg1 : arg2);
 827 }
 828
 829 Datum
 830 int4larger(PG_FUNCTION_ARGS)
 831 {
 832         int32           arg1 = PG_GETARG_INT32(0);
 833         int32           arg2 = PG_GETARG_INT32(1);
 834
 835         PG_RETURN_INT32((arg1 > arg2) ? arg1 : arg2);
 836 }
 837
 838 Datum
 839 int4smaller(PG_FUNCTION_ARGS)
 840 {
 841         int32           arg1 = PG_GETARG_INT32(0);
 842         int32           arg2 = PG_GETARG_INT32(1);
 843
 844         PG_RETURN_INT32((arg1 < arg2) ? arg1 : arg2);
 845 }
 846
 847 /* Binary arithmetics
 848  *
 849  *              int[24]and              - returns arg1 & arg2
 850  *              int[24]or               - returns arg1 | arg2
 851  *              int[24]xor              - returns arg1 # arg2
 852  *              int[24]not              - returns ~arg1
 853  *              int[24]shl              - returns arg1 << arg2
 854  *              int[24]shr              - returns arg1 >> arg2
 855  */
 856
 857 Datum
 858 int4and(PG_FUNCTION_ARGS)
 859 {
 860         int32           arg1 = PG_GETARG_INT32(0);
 861         int32           arg2 = PG_GETARG_INT32(1);
 862
 863         PG_RETURN_INT32(arg1 & arg2);
 864 }
 865
 866 Datum
 867 int4or(PG_FUNCTION_ARGS)
 868 {
 869         int32           arg1 = PG_GETARG_INT32(0);
 870         int32           arg2 = PG_GETARG_INT32(1);
 871
 872         PG_RETURN_INT32(arg1 | arg2);
 873 }
 874
 875 Datum
 876 int4xor(PG_FUNCTION_ARGS)
 877 {
 878         int32           arg1 = PG_GETARG_INT32(0);
 879         int32           arg2 = PG_GETARG_INT32(1);
 880
 881         PG_RETURN_INT32(arg1 ^ arg2);
 882 }
 883
 884 Datum
 885 int4shl(PG_FUNCTION_ARGS)
 886 {
 887         int32           arg1 = PG_GETARG_INT32(0);
 888         int32           arg2 = PG_GETARG_INT32(1);
 889
 890         PG_RETURN_INT32(arg1 << arg2);
 891 }
 892
 893 Datum
 894 int4shr(PG_FUNCTION_ARGS)
 895 {
 896         int32           arg1 = PG_GETARG_INT32(0);
 897         int32           arg2 = PG_GETARG_INT32(1);
 898
 899         PG_RETURN_INT32(arg1 >> arg2);
 900 }
 901
 902 Datum
 903 int4not(PG_FUNCTION_ARGS)
 904 {
 905         int32           arg1 = PG_GETARG_INT32(0);
 906
 907         PG_RETURN_INT32(~arg1);
 908 }
 909
 910 Datum
 911 int2and(PG_FUNCTION_ARGS)
 912 {
 913         int16           arg1 = PG_GETARG_INT16(0);
 914         int16           arg2 = PG_GETARG_INT16(1);
 915
 916         PG_RETURN_INT16(arg1 & arg2);
 917 }
 918
 919 Datum
 920 int2or(PG_FUNCTION_ARGS)
 921 {
 922         int16           arg1 = PG_GETARG_INT16(0);
 923         int16           arg2 = PG_GETARG_INT16(1);
 924
 925         PG_RETURN_INT16(arg1 | arg2);
 926 }
 927
 928 Datum
 929 int2xor(PG_FUNCTION_ARGS)
 930 {
 931         int16           arg1 = PG_GETARG_INT16(0);
 932         int16           arg2 = PG_GETARG_INT16(1);
 933
 934         PG_RETURN_INT16(arg1 ^ arg2);
 935 }
 936
 937 Datum
 938 int2not(PG_FUNCTION_ARGS)
 939 {
 940         int16           arg1 = PG_GETARG_INT16(0);
 941
 942         PG_RETURN_INT16(~arg1);
 943 }
 944
 945
 946 Datum
 947 int2shl(PG_FUNCTION_ARGS)
 948 {
 949         int16           arg1 = PG_GETARG_INT16(0);
 950         int32           arg2 = PG_GETARG_INT32(1);
 951
 952         PG_RETURN_INT16(arg1 << arg2);
 953 }
 954
 955 Datum
 956 int2shr(PG_FUNCTION_ARGS)
 957 {
 958         int16           arg1 = PG_GETARG_INT16(0);
 959         int32           arg2 = PG_GETARG_INT32(1);
 960
 961         PG_RETURN_INT16(arg1 >> arg2);
 962 }
 963