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

   1 /*-------------------------------------------------------------------------
   2  *
   3  * char.c--
   4  *        Functions for the built-in type "char".
   5  *        Functions for the built-in type "cid".
   6  *        Functions for the built-in type "char2".
   7  *        Functions for the built-in type "char4".
   8  *        Functions for the built-in type "char8".
   9  *        Functions for the built-in type "char16".
  10  *
  11  * Copyright (c) 1994, Regents of the University of California
  12  *
  13  *
  14  * IDENTIFICATION
  15  *        $Header: /cvsroot/pgsql/src/backend/utils/adt/char.c,v 1.13 1997/10/25 05:12:38 thomas Exp $
  16  *
  17  *-------------------------------------------------------------------------
  18  */
  19 #include <stdio.h>                              /* for sprintf() */
  20 #include <string.h>
  21 #include "postgres.h"
  22 #include "utils/palloc.h"
  23 #include "utils/builtins.h"             /* where the declarations go */
  24
  25 /*****************************************************************************
  26  *       USER I/O ROUTINES                                                                                                               *
  27  *****************************************************************************/
  28
  29 /*
  30  *              charin                  - converts "x" to 'x'
  31  */
  32 int32
  33 charin(char *ch)
  34 {
  35         if (ch == NULL)
  36                 return ((int32) NULL);
  37         return ((int32) *ch);
  38 }
  39
  40 /*
  41  *              charout                 - converts 'x' to "x"
  42  */
  43 char       *
  44 charout(int32 ch)
  45 {
  46         char       *result = (char *) palloc(2);
  47
  48         result[0] = (char) ch;
  49         result[1] = '\0';
  50         return (result);
  51 }
  52
  53 /*
  54  *              cidin   - converts "..." to internal representation.
  55  *
  56  *              NOTE: we must not use 'charin' because cid might be a non
  57  *              printable character...
  58  */
  59 int32
  60 cidin(char *s)
  61 {
  62         CommandId       c;
  63
  64         if (s == NULL)
  65                 c = 0;
  66         else
  67                 c = atoi(s);
  68
  69         return ((int32) c);
  70 }
  71
  72 /*
  73  *              cidout  - converts a cid to "..."
  74  *
  75  *              NOTE: we must no use 'charout' because cid might be a non
  76  *              printable character...
  77  */
  78 char       *
  79 cidout(int32 c)
  80 {
  81         char       *result;
  82         CommandId       c2;
  83
  84         /*
  85          * cid is a number between 0 .. 2^16-1, therefore we need at most 6
  86          * chars for the string (5 digits + '\0') NOTE: print it as an
  87          * UNSIGNED int!
  88          */
  89         result = palloc(6);
  90         c2 = (CommandId) c;
  91         sprintf(result, "%u", (unsigned) (c2));
  92         return (result);
  93 }
  94
  95 /*
  96  *              char16in                - converts "..." to internal reprsentation
  97  *
  98  *              Note:
  99  *                              Currently if strlen(s) < 14, the extra chars are nulls
 100  */
 101 char       *
 102 char16in(char *s)
 103 {
 104         char       *result;
 105
 106         if (s == NULL)
 107                 return (NULL);
 108         result = (char *) palloc(16);
 109         strncpy(result, s, 16);
 110         return (result);
 111 }
 112
 113 /*
 114  *              char16out               - converts internal reprsentation to "..."
 115  */
 116 char       *
 117 char16out(char *s)
 118 {
 119         char       *result = (char *) palloc(17);
 120
 121         if (s == NULL)
 122         {
 123                 result[0] = '-';
 124                 result[1] = '\0';
 125         }
 126         else
 127                 StrNCpy(result, s, 17);
 128         return (result);
 129 }
 130
 131
 132 /*****************************************************************************
 133  *       PUBLIC ROUTINES                                                                                                                 *
 134  *****************************************************************************/
 135
 136 bool
 137 chareq(int8 arg1, int8 arg2)
 138 {
 139         return (arg1 == arg2);
 140 }
 141
 142 bool
 143 charne(int8 arg1, int8 arg2)
 144 {
 145         return (arg1 != arg2);
 146 }
 147
 148 bool
 149 charlt(int8 arg1, int8 arg2)
 150 {
 151         return ((uint8) arg1 < (uint8) arg2);
 152 }
 153
 154 bool
 155 charle(int8 arg1, int8 arg2)
 156 {
 157         return ((uint8) arg1 <= (uint8) arg2);
 158 }
 159
 160 bool
 161 chargt(int8 arg1, int8 arg2)
 162 {
 163         return ((uint8) arg1 > (uint8) arg2);
 164 }
 165
 166 bool
 167 charge(int8 arg1, int8 arg2)
 168 {
 169         return ((uint8) arg1 >= (uint8) arg2);
 170 }
 171
 172 int8
 173 charpl(int8 arg1, int8 arg2)
 174 {
 175         return (arg1 + arg2);
 176 }
 177
 178 int8
 179 charmi(int8 arg1, int8 arg2)
 180 {
 181         return (arg1 - arg2);
 182 }
 183
 184 int8
 185 charmul(int8 arg1, int8 arg2)
 186 {
 187         return (arg1 * arg2);
 188 }
 189
 190 int8
 191 chardiv(int8 arg1, int8 arg2)
 192 {
 193         return (arg1 / arg2);
 194 }
 195
 196 bool
 197 cideq(int8 arg1, int8 arg2)
 198 {
 199         return (arg1 == arg2);
 200 }
 201
 202 /*
 203  *              char16eq                - returns 1 iff arguments are equal
 204  *              char16ne                - returns 1 iff arguments are not equal
 205  *
 206  *              BUGS:
 207  *                              Assumes that "xy\0\0a" should be equal to "xy\0b".
 208  *                              If not, can do the comparison backwards for efficiency.
 209  *
 210  *              char16lt                - returns 1 iff a < b
 211  *              char16le                - returns 1 iff a <= b
 212  *              char16gt                - returns 1 iff a < b
 213  *              char16ge                - returns 1 iff a <= b
 214  *
 215  */
 216 bool
 217 char16eq(char *arg1, char *arg2)
 218 {
 219         if (arg1 == NULL || arg2 == NULL)
 220                 return ((bool) 0);
 221         return (strncmp(arg1, arg2, 16) == 0);
 222 }
 223
 224 bool
 225 char16ne(char *arg1, char *arg2)
 226 {
 227         if (arg1 == NULL || arg2 == NULL)
 228                 return ((bool) 0);
 229         return (strncmp(arg1, arg2, 16) != 0);
 230 }
 231
 232 bool
 233 char16lt(char *arg1, char *arg2)
 234 {
 235         if (arg1 == NULL || arg2 == NULL)
 236                 return ((bool) 0);
 237         return (strncmp(arg1, arg2, 16) < 0);
 238 }
 239
 240 bool
 241 char16le(char *arg1, char *arg2)
 242 {
 243         if (arg1 == NULL || arg2 == NULL)
 244                 return ((bool) 0);
 245         return (strncmp(arg1, arg2, 16) <= 0);
 246 }
 247
 248 bool
 249 char16gt(char *arg1, char *arg2)
 250 {
 251         if (arg1 == NULL || arg2 == NULL)
 252                 return ((bool) 0);
 253
 254         return (strncmp(arg1, arg2, 16) > 0);
 255 }
 256
 257 bool
 258 char16ge(char *arg1, char *arg2)
 259 {
 260         if (arg1 == NULL || arg2 == NULL)
 261                 return ((bool) 0);
 262
 263         return (strncmp(arg1, arg2, 16) >= 0);
 264 }
 265
 266
 267 /* ============================== char2 ============================== */
 268 uint16
 269 char2in(char *s)
 270 {
 271         uint16          res;
 272
 273         if (s == NULL)
 274                 return (0);
 275
 276         strncpy((char *) &res, s, 2);
 277         return (res);
 278 }
 279
 280 char       *
 281 char2out(uint16 s)
 282 {
 283         char       *result = (char *) palloc(3);
 284
 285         StrNCpy(result, (char *) &s, 3);
 286
 287         return (result);
 288 }
 289
 290 bool
 291 char2eq(uint16 a, uint16 b)
 292 {
 293         return (strncmp((char *) &a, (char *) &b, 2) == 0);
 294 }
 295
 296 bool
 297 char2ne(uint16 a, uint16 b)
 298 {
 299         return (strncmp((char *) &a, (char *) &b, 2) != 0);
 300 }
 301
 302 bool
 303 char2lt(uint16 a, uint16 b)
 304 {
 305         return (strncmp((char *) &a, (char *) &b, 2) < 0);
 306 }
 307
 308 bool
 309 char2le(uint16 a, uint16 b)
 310 {
 311         return (strncmp((char *) &a, (char *) &b, 2) <= 0);
 312 }
 313
 314 bool
 315 char2gt(uint16 a, uint16 b)
 316 {
 317         return (strncmp((char *) &a, (char *) &b, 2) > 0);
 318 }
 319
 320 bool
 321 char2ge(uint16 a, uint16 b)
 322 {
 323         return (strncmp((char *) &a, (char *) &b, 2) >= 0);
 324 }
 325
 326 int32
 327 char2cmp(uint16 a, uint16 b)
 328 {
 329         return (strncmp((char *) &a, (char *) &b, 2));
 330 }
 331
 332 /* ============================== char4 ============================== */
 333 uint32
 334 char4in(char *s)
 335 {
 336         uint32          res;
 337
 338         if (s == NULL)
 339                 return (0);
 340
 341         strncpy((char *) &res, s, 4);
 342
 343         return (res);
 344 }
 345
 346 char       *
 347 char4out(s)
 348 uint32          s;
 349 {
 350         char       *result = (char *) palloc(5);
 351
 352         StrNCpy(result, (char *) &s, 5);
 353
 354         return (result);
 355 }
 356
 357 bool
 358 char4eq(uint32 a, uint32 b)
 359 {
 360         return (strncmp((char *) &a, (char *) &b, 4) == 0);
 361 }
 362
 363 bool
 364 char4ne(uint32 a, uint32 b)
 365 {
 366         return (strncmp((char *) &a, (char *) &b, 4) != 0);
 367 }
 368
 369 bool
 370 char4lt(uint32 a, uint32 b)
 371 {
 372         return (strncmp((char *) &a, (char *) &b, 4) < 0);
 373 }
 374
 375 bool
 376 char4le(uint32 a, uint32 b)
 377 {
 378         return (strncmp((char *) &a, (char *) &b, 4) <= 0);
 379 }
 380
 381 bool
 382 char4gt(uint32 a, uint32 b)
 383 {
 384         return (strncmp((char *) &a, (char *) &b, 4) > 0);
 385 }
 386
 387 bool
 388 char4ge(uint32 a, uint32 b)
 389 {
 390         return (strncmp((char *) &a, (char *) &b, 4) >= 0);
 391 }
 392
 393 int32
 394 char4cmp(uint32 a, uint32 b)
 395 {
 396         return (strncmp((char *) &a, (char *) &b, 4));
 397 }
 398
 399 /* ============================== char8 ============================== */
 400 char       *
 401 char8in(char *s)
 402 {
 403         char       *result;
 404
 405         if (s == NULL)
 406                 return ((char *) NULL);
 407
 408         result = (char *) palloc(8);
 409         strncpy(result, s, 8);
 410         return (result);
 411 }
 412
 413 char       *
 414 char8out(char *s)
 415 {
 416         char       *result = (char *) palloc(9);
 417
 418         if (s == NULL)
 419         {
 420                 result[0] = '-';
 421                 result[1] = '\0';
 422         }
 423         else
 424                 StrNCpy(result, s, 9);
 425         return (result);
 426 }
 427
 428 bool
 429 char8eq(char *arg1, char *arg2)
 430 {
 431         if (arg1 == NULL || arg2 == NULL)
 432                 return ((bool) 0);
 433         return (strncmp(arg1, arg2, 8) == 0);
 434 }
 435
 436 bool
 437 char8ne(char *arg1, char *arg2)
 438 {
 439         if (arg1 == NULL || arg2 == NULL)
 440                 return ((bool) 0);
 441         return (strncmp(arg1, arg2, 8) != 0);
 442 }
 443
 444 bool
 445 char8lt(char *arg1, char *arg2)
 446 {
 447         if (arg1 == NULL || arg2 == NULL)
 448                 return ((bool) 0);
 449         return (strncmp(arg1, arg2, 8) < 0);
 450 }
 451
 452 bool
 453 char8le(char *arg1, char *arg2)
 454 {
 455         if (arg1 == NULL || arg2 == NULL)
 456                 return ((bool) 0);
 457         return (strncmp(arg1, arg2, 8) <= 0);
 458 }
 459
 460 bool
 461 char8gt(char *arg1, char *arg2)
 462 {
 463         if (arg1 == NULL || arg2 == NULL)
 464                 return ((bool) 0);
 465         return (strncmp(arg1, arg2, 8) > 0);
 466 }
 467
 468 bool
 469 char8ge(char *arg1, char *arg2)
 470 {
 471         if (arg1 == NULL || arg2 == NULL)
 472                 return ((bool) 0);
 473         return (strncmp(arg1, arg2, 8) >= 0);
 474 }
 475
 476 int32
 477 char8cmp(char *arg1, char *arg2)
 478 {
 479         return (strncmp(arg1, arg2, 8));
 480 }