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.
   5  *
   6  * Copyright (c) 1994, Regents of the University of California
   7  *
   8  *
   9  * IDENTIFICATION
  10  *        $Header: /cvsroot/pgsql/src/backend/utils/adt/int.c,v 1.16 1998/09/01 03:26:03 momjian Exp $
  11  *
  12  *-------------------------------------------------------------------------
  13  */
  14 /*
  15  * OLD COMMENTS
  16  *              I/O routines:
  17  *               int2in, int2out, int28in, int28out, int4in, int4out
  18  *              Conversion routines:
  19  *               itoi, int2_text, int4_text
  20  *              Boolean operators:
  21  *               inteq, intne, intlt, intle, intgt, intge
  22  *              Arithmetic operators:
  23  *               intpl, intmi, int4mul, intdiv
  24  *
  25  *              Arithmetic operators:
  26  *               intmod, int4fac
  27  *
  28  * XXX makes massive and possibly unwarranted type promotion assumptions.
  29  * fix me when we figure out what we want to do about ANSIfication...
  30  */
  31 #include <stdio.h>
  32 #include <string.h>
  33 #ifdef HAVE_LIMITS
  34 #include <limits.h>
  35 #endif
  36
  37 #include "postgres.h"
  38 #include "fmgr.h"
  39 #include "utils/builtins.h"             /* where the declarations go */
  40
  41 #ifndef SHRT_MAX
  42 #define SHRT_MAX (0x7FFF)
  43 #endif
  44 #ifndef SHRT_MIN
  45 #define SHRT_MIN (-0x8000)
  46 #endif
  47
  48 /*****************************************************************************
  49  *       USER I/O ROUTINES                                                                                                               *
  50  *****************************************************************************/
  51
  52 /*
  53  *              int2in                  - converts "num" to short
  54  */
  55 int32
  56 int2in(char *num)
  57 {
  58         return (int32) pg_atoi(num, sizeof(int16), '\0');
  59 }
  60
  61 /*
  62  *              int2out                 - converts short to "num"
  63  */
  64 char *
  65 int2out(int16 sh)
  66 {
  67         char       *result;
  68
  69         result = (char *) palloc(7);/* assumes sign, 5 digits, '\0' */
  70         itoa((int) sh, result);
  71         return result;
  72 }
  73
  74 /*
  75  *              int28in                 - converts "num num ..." to internal form
  76  *
  77  *              Note:
  78  *                              Fills any nonexistent digits with NULLs.
  79  */
  80 int16 *
  81 int28in(char *shs)
  82 {
  83         int16           **result;
  84         int                     nums;
  85
  86         if (shs == NULL)
  87                 return NULL;
  88         result = (int16 **) palloc(sizeof(int16[8]));
  89         if ((nums = sscanf(shs, "%hd%hd%hd%hd%hd%hd%hd%hd",
  90                                            *result,
  91                                            *result + 1,
  92                                            *result + 2,
  93                                            *result + 3,
  94                                            *result + 4,
  95                                            *result + 5,
  96                                            *result + 6,
  97                                            *result + 7)) != 8)
  98         {
  99                 do
 100                         (*result)[nums++] = 0;
 101                 while (nums < 8);
 102         }
 103         return (int16 *) result;
 104 }
 105
 106 /*
 107  *              int28out                - converts internal form to "num num ..."
 108  */
 109 char *
 110 int28out(int16 **shs)
 111 {
 112         int                     num;
 113         int16      *sp;
 114         char       *rp;
 115         char       *result;
 116
 117         if (shs == NULL)
 118         {
 119                 result = (char *) palloc(2);
 120                 result[0] = '-';
 121                 result[1] = '\0';
 122                 return result;
 123         }
 124         rp = result = (char *) palloc(8 * 7);           /* assumes sign, 5 digits,
 125                                                                                                  * ' ' */
 126         sp = *shs;
 127         for (num = 8; num != 0; num--)
 128         {
 129                 itoa(*sp++, rp);
 130                 while (*++rp != '\0')
 131                         ;
 132                 *rp++ = ' ';
 133         }
 134         *--rp = '\0';
 135         return result;
 136 }
 137
 138 /*
 139  *              int28in                 - converts "num num ..." to internal form
 140  *
 141  *              Note:
 142  *                              Fills any nonexistent digits with NULLs.
 143  */
 144 int32 *
 145 int44in(char *input_string)
 146 {
 147         int32      *foo = (int32 *) palloc(4 * sizeof(int32));
 148         int                     i = 0;
 149
 150         i = sscanf(input_string,
 151                            "%d, %d, %d, %d",
 152                            &foo[0],
 153                            &foo[1],
 154                            &foo[2],
 155                            &foo[3]);
 156         while (i < 4)
 157                 foo[i++] = 0;
 158
 159         return foo;
 160 }
 161
 162 /*
 163  *              int28out                - converts internal form to "num num ..."
 164  */
 165 char *
 166 int44out(int32 *an_array)
 167 {
 168         int                     temp = 4;
 169         char       *output_string = NULL;
 170         int                     i;
 171
 172         if (temp > 0)
 173         {
 174                 char       *walk;
 175
 176                 output_string = (char *) palloc(16 * temp);             /* assume 15 digits +
 177                                                                                                                  * sign */
 178                 walk = output_string;
 179                 for (i = 0; i < temp; i++)
 180                 {
 181                         itoa(an_array[i], walk);
 182                         while (*++walk != '\0')
 183                                 ;
 184                         *walk++ = ' ';
 185                 }
 186                 *--walk = '\0';
 187         }
 188         return output_string;
 189 }
 190
 191
 192 /*****************************************************************************
 193  *       PUBLIC ROUTINES                                                                                                                 *
 194  *****************************************************************************/
 195
 196 /*
 197  *              int4in                  - converts "num" to int4
 198  */
 199 int32
 200 int4in(char *num)
 201 {
 202         return pg_atoi(num, sizeof(int32), '\0');
 203 }
 204
 205 /*
 206  *              int4out                 - converts int4 to "num"
 207  */
 208 char *
 209 int4out(int32 l)
 210 {
 211         char       *result;
 212
 213         result = (char *) palloc(12);           /* assumes sign, 10 digits, '\0' */
 214         ltoa(l, result);
 215         return result;
 216 }
 217
 218
 219 /*
 220  *              ===================
 221  *              CONVERSION ROUTINES
 222  *              ===================
 223  */
 224
 225 int32
 226 i2toi4(int16 arg1)
 227 {
 228         return (int32) arg1;
 229 }
 230
 231 int16
 232 i4toi2(int32 arg1)
 233 {
 234         if (arg1 < SHRT_MIN)
 235                 elog(ERROR, "i4toi2: '%d' causes int2 underflow", arg1);
 236         if (arg1 > SHRT_MAX)
 237                 elog(ERROR, "i4toi2: '%d' causes int2 overflow", arg1);
 238
 239         return (int16) arg1;
 240 }
 241
 242 text *
 243 int2_text(int16 arg1)
 244 {
 245         text       *result;
 246
 247         int                     len;
 248         char       *str;
 249
 250         str = int2out(arg1);
 251         len = (strlen(str) + VARHDRSZ);
 252
 253         result = palloc(len);
 254
 255         VARSIZE(result) = len;
 256         memmove(VARDATA(result), str, (len - VARHDRSZ));
 257
 258         pfree(str);
 259
 260         return result;
 261 }       /* int2_text() */
 262
 263 int16
 264 text_int2(text *string)
 265 {
 266         int16           result;
 267
 268         int                     len;
 269         char       *str;
 270
 271         len = (VARSIZE(string) - VARHDRSZ);
 272
 273         str = palloc(len + 1);
 274         memmove(str, VARDATA(string), len);
 275         *(str + len) = '\0';
 276
 277         result = int2in(str);
 278         pfree(str);
 279
 280         return result;
 281 }       /* text_int2() */
 282
 283 text *
 284 int4_text(int32 arg1)
 285 {
 286         text       *result;
 287
 288         int                     len;
 289         char       *str;
 290
 291         str = int4out(arg1);
 292         len = (strlen(str) + VARHDRSZ);
 293
 294         result = palloc(len);
 295
 296         VARSIZE(result) = len;
 297         memmove(VARDATA(result), str, (len - VARHDRSZ));
 298
 299         pfree(str);
 300
 301         return result;
 302 }       /* int4_text() */
 303
 304 int32
 305 text_int4(text *string)
 306 {
 307         int32           result;
 308
 309         int                     len;
 310         char       *str;
 311
 312         len = (VARSIZE(string) - VARHDRSZ);
 313
 314         str = palloc(len + 1);
 315         memmove(str, VARDATA(string), len);
 316         *(str + len) = '\0';
 317
 318         result = int4in(str);
 319         pfree(str);
 320
 321         return result;
 322 }       /* text_int4() */
 323
 324
 325 /*
 326  *              =========================
 327  *              BOOLEAN OPERATOR ROUTINES
 328  *              =========================
 329  */
 330
 331 /*
 332  *              inteq                   - returns 1 iff arg1 == arg2
 333  *              intne                   - returns 1 iff arg1 != arg2
 334  *              intlt                   - returns 1 iff arg1 < arg2
 335  *              intle                   - returns 1 iff arg1 <= arg2
 336  *              intgt                   - returns 1 iff arg1 > arg2
 337  *              intge                   - returns 1 iff arg1 >= arg2
 338  */
 339 bool
 340 int4eq(int32 arg1, int32 arg2)
 341 {
 342         return arg1 == arg2;
 343 }
 344
 345 bool
 346 int4ne(int32 arg1, int32 arg2)
 347 {
 348         return arg1 != arg2;
 349 }
 350
 351 bool
 352 int4lt(int32 arg1, int32 arg2)
 353 {
 354         return arg1 < arg2;
 355 }
 356
 357 bool
 358 int4le(int32 arg1, int32 arg2)
 359 {
 360         return arg1 <= arg2;
 361 }
 362
 363 bool
 364 int4gt(int32 arg1, int32 arg2)
 365 {
 366         return arg1 > arg2;
 367 }
 368
 369 bool
 370 int4ge(int32 arg1, int32 arg2)
 371 {
 372         return arg1 >= arg2;
 373 }
 374
 375 bool
 376 int2eq(int16 arg1, int16 arg2)
 377 {
 378         return arg1 == arg2;
 379 }
 380
 381 bool
 382 int2ne(int16 arg1, int16 arg2)
 383 {
 384         return arg1 != arg2;
 385 }
 386
 387 bool
 388 int2lt(int16 arg1, int16 arg2)
 389 {
 390         return arg1 < arg2;
 391 }
 392
 393 bool
 394 int2le(int16 arg1, int16 arg2)
 395 {
 396         return arg1 <= arg2;
 397 }
 398
 399 bool
 400 int2gt(int16 arg1, int16 arg2)
 401 {
 402         return arg1 > arg2;
 403 }
 404
 405 bool
 406 int2ge(int16 arg1, int16 arg2)
 407 {
 408         return arg1 >= arg2;
 409 }
 410
 411 bool
 412 int24eq(int32 arg1, int32 arg2)
 413 {
 414         return arg1 == arg2;
 415 }
 416
 417 bool
 418 int24ne(int32 arg1, int32 arg2)
 419 {
 420         return arg1 != arg2;
 421 }
 422
 423 bool
 424 int24lt(int32 arg1, int32 arg2)
 425 {
 426         return arg1 < arg2;
 427 }
 428
 429 bool
 430 int24le(int32 arg1, int32 arg2)
 431 {
 432         return arg1 <= arg2;
 433 }
 434
 435 bool
 436 int24gt(int32 arg1, int32 arg2)
 437 {
 438         return arg1 > arg2;
 439 }
 440
 441 bool
 442 int24ge(int32 arg1, int32 arg2)
 443 {
 444         return arg1 >= arg2;
 445 }
 446
 447 bool
 448 int42eq(int32 arg1, int32 arg2)
 449 {
 450         return arg1 == arg2;
 451 }
 452
 453 bool
 454 int42ne(int32 arg1, int32 arg2)
 455 {
 456         return arg1 != arg2;
 457 }
 458
 459 bool
 460 int42lt(int32 arg1, int32 arg2)
 461 {
 462         return arg1 < arg2;
 463 }
 464
 465 bool
 466 int42le(int32 arg1, int32 arg2)
 467 {
 468         return arg1 <= arg2;
 469 }
 470
 471 bool
 472 int42gt(int32 arg1, int32 arg2)
 473 {
 474         return arg1 > arg2;
 475 }
 476
 477 bool
 478 int42ge(int32 arg1, int32 arg2)
 479 {
 480         return arg1 >= arg2;
 481 }
 482
 483
 484 bool
 485 keyfirsteq(int16 *arg1, int16 arg2)
 486 {
 487         return *arg1 == arg2;
 488 }
 489
 490 /*
 491  *              int[24]pl               - returns arg1 + arg2
 492  *              int[24]mi               - returns arg1 - arg2
 493  *              int[24]mul              - returns arg1 * arg2
 494  *              int[24]div              - returns arg1 / arg2
 495  */
 496 int32
 497 int4um(int32 arg)
 498 {
 499         return -arg;
 500 }
 501
 502 int32
 503 int4pl(int32 arg1, int32 arg2)
 504 {
 505         return arg1 + arg2;
 506 }
 507
 508 int32
 509 int4mi(int32 arg1, int32 arg2)
 510 {
 511         return arg1 - arg2;
 512 }
 513
 514 int32
 515 int4mul(int32 arg1, int32 arg2)
 516 {
 517         return arg1 * arg2;
 518 }
 519
 520 int32
 521 int4div(int32 arg1, int32 arg2)
 522 {
 523         return arg1 / arg2;
 524 }
 525
 526 int32
 527 int4inc(int32 arg)
 528 {
 529         return arg + (int32) 1;
 530 }
 531
 532 int16
 533 int2um(int16 arg)
 534 {
 535         return -arg;
 536 }
 537
 538 int16
 539 int2pl(int16 arg1, int16 arg2)
 540 {
 541         return arg1 + arg2;
 542 }
 543
 544 int16
 545 int2mi(int16 arg1, int16 arg2)
 546 {
 547         return arg1 - arg2;
 548 }
 549
 550 int16
 551 int2mul(int16 arg1, int16 arg2)
 552 {
 553         return arg1 * arg2;
 554 }
 555
 556 int16
 557 int2div(int16 arg1, int16 arg2)
 558 {
 559         return arg1 / arg2;
 560 }
 561
 562 int16
 563 int2inc(int16 arg)
 564 {
 565         return arg + (int16) 1;
 566 }
 567
 568 int32
 569 int24pl(int32 arg1, int32 arg2)
 570 {
 571         return arg1 + arg2;
 572 }
 573
 574 int32
 575 int24mi(int32 arg1, int32 arg2)
 576 {
 577         return arg1 - arg2;
 578 }
 579
 580 int32
 581 int24mul(int32 arg1, int32 arg2)
 582 {
 583         return arg1 * arg2;
 584 }
 585
 586 int32
 587 int24div(int32 arg1, int32 arg2)
 588 {
 589         return arg1 / arg2;
 590 }
 591
 592 int32
 593 int42pl(int32 arg1, int32 arg2)
 594 {
 595         return arg1 + arg2;
 596 }
 597
 598 int32
 599 int42mi(int32 arg1, int32 arg2)
 600 {
 601         return arg1 - arg2;
 602 }
 603
 604 int32
 605 int42mul(int32 arg1, int32 arg2)
 606 {
 607         return arg1 * arg2;
 608 }
 609
 610 int32
 611 int42div(int32 arg1, int32 arg2)
 612 {
 613         return arg1 / arg2;
 614 }
 615
 616 /*
 617  *              int[24]mod              - returns arg1 mod arg2
 618  */
 619 int32
 620 int4mod(int32 arg1, int32 arg2)
 621 {
 622         return arg1 % arg2;
 623 }
 624
 625 int32
 626 int2mod(int16 arg1, int16 arg2)
 627 {
 628         return arg1 % arg2;
 629 }
 630
 631 int32
 632 int24mod(int32 arg1, int32 arg2)
 633 {
 634         return arg1 % arg2;
 635 }
 636
 637 int32
 638 int42mod(int32 arg1, int32 arg2)
 639 {
 640         return arg1 % arg2;
 641 }
 642
 643 /*
 644  *              int[24]fac              - returns arg1!
 645  */
 646 int32
 647 int4fac(int32 arg1)
 648 {
 649         int32           result;
 650
 651         if (arg1 < 1)
 652                 result = 0;
 653         else
 654                 for (result = 1; arg1 > 0; --arg1)
 655                         result *= arg1;
 656         return result;
 657 }
 658
 659 int32
 660 int2fac(int16 arg1)
 661 {
 662         int16           result;
 663
 664         if (arg1 < 1)
 665                 result = 0;
 666         else
 667                 for (result = 1; arg1 > 0; --arg1)
 668                         result *= arg1;
 669         return result;
 670 }
 671
 672 int16
 673 int2larger(int16 arg1, int16 arg2)
 674 {
 675         return (arg1 > arg2) ? arg1 : arg2;
 676 }
 677
 678 int16
 679 int2smaller(int16 arg1, int16 arg2)
 680 {
 681         return (arg1 < arg2) ? arg1 : arg2;
 682 }
 683
 684 int32
 685 int4larger(int32 arg1, int32 arg2)
 686 {
 687         return (arg1 > arg2) ? arg1 : arg2;
 688 }
 689
 690 int32
 691 int4smaller(int32 arg1, int32 arg2)
 692 {
 693         return (arg1 < arg2) ? arg1 : arg2;
 694 }