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.7 1997/08/12 20:39:16 momjian 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 charin(char *ch)
  33 {
  34     if (ch == NULL)
  35         return((int32) NULL);
  36     return((int32) *ch);
  37 }
  38
  39 /*
  40  *      charout         - converts 'x' to "x"
  41  */
  42 char *charout(int32 ch)
  43 {
  44     char        *result = (char *) palloc(2);
  45
  46     result[0] = (char) ch;
  47     result[1] = '\0';
  48     return(result);
  49 }
  50
  51 /*
  52  *      cidin   - converts "..." to internal representation.
  53  *
  54  *      NOTE: we must not use 'charin' because cid might be a non
  55  *      printable character...
  56  */
  57 int32 cidin(char *s)
  58 {
  59     CommandId c;
  60
  61     if (s==NULL)
  62         c = 0;
  63     else
  64         c = atoi(s);
  65
  66     return((int32)c);
  67 }
  68
  69 /*
  70  *      cidout  - converts a cid to "..."
  71  *
  72  *      NOTE: we must no use 'charout' because cid might be a non
  73  *      printable character...
  74  */
  75 char *cidout(int32 c)
  76 {
  77     char *result;
  78     CommandId c2;
  79
  80     /*
  81      * cid is a number between 0 .. 2^16-1, therefore we need at most
  82      * 6 chars for the string (5 digits + '\0')
  83      * NOTE: print it as an UNSIGNED int!
  84      */
  85     result = palloc(6);
  86     c2 = (CommandId)c;
  87     sprintf(result, "%u", (unsigned)(c2));
  88     return(result);
  89 }
  90
  91 /*
  92  *      char16in        - converts "..." to internal reprsentation
  93  *
  94  *      Note:
  95  *              Currently if strlen(s) < 14, the extra chars are nulls
  96  */
  97 char *char16in(char *s)
  98 {
  99     char        *result;
 100
 101     if (s == NULL)
 102         return(NULL);
 103     result = (char *) palloc(16);
 104     strncpy(result, s, 16);
 105     return(result);
 106 }
 107
 108 /*
 109  *      char16out       - converts internal reprsentation to "..."
 110  */
 111 char *char16out(char *s)
 112 {
 113     char        *result = (char *) palloc(17);
 114
 115     if (s == NULL) {
 116         result[0] = '-';
 117         result[1] = '\0';
 118     } else
 119         strNcpy(result, s, 16);
 120     return(result);
 121 }
 122
 123
 124 /*****************************************************************************
 125  *   PUBLIC ROUTINES                                                         *
 126  *****************************************************************************/
 127
 128 bool chareq(int8 arg1, int8 arg2)       { return(arg1 == arg2); }
 129 bool charne(int8 arg1, int8 arg2)       { return(arg1 != arg2); }
 130 bool charlt(int8 arg1, int8 arg2)    { return((uint8)arg1 <  (uint8)arg2); }
 131 bool charle(int8 arg1, int8 arg2)    { return((uint8)arg1 <= (uint8)arg2); }
 132 bool chargt(int8 arg1, int8 arg2)    { return((uint8)arg1 >  (uint8)arg2); }
 133 bool charge(int8 arg1, int8 arg2)    { return((uint8)arg1 >= (uint8)arg2); }
 134 int8 charpl(int8 arg1, int8 arg2)       { return(arg1 + arg2); }
 135 int8 charmi(int8 arg1, int8 arg2)       { return(arg1 - arg2); }
 136 int8 charmul(int8 arg1, int8 arg2)      { return(arg1 * arg2); }
 137 int8 chardiv(int8 arg1, int8 arg2)      { return(arg1 / arg2); }
 138
 139 bool cideq(int8 arg1, int8 arg2)        { return(arg1 == arg2); }
 140
 141 /*
 142  *      char16eq        - returns 1 iff arguments are equal
 143  *      char16ne        - returns 1 iff arguments are not equal
 144  *
 145  *      BUGS:
 146  *              Assumes that "xy\0\0a" should be equal to "xy\0b".
 147  *              If not, can do the comparison backwards for efficiency.
 148  *
 149  *      char16lt        - returns 1 iff a < b
 150  *      char16le        - returns 1 iff a <= b
 151  *      char16gt        - returns 1 iff a < b
 152  *      char16ge        - returns 1 iff a <= b
 153  *
 154  */
 155 bool char16eq(char *arg1, char *arg2)
 156 {
 157     if (arg1 == NULL || arg2 == NULL)
 158         return((bool) 0);
 159     return(strncmp(arg1, arg2, 16) == 0);
 160 }
 161
 162 bool char16ne(char *arg1, char *arg2)
 163 {
 164     if (arg1 == NULL || arg2 == NULL)
 165         return((bool) 0);
 166     return(strncmp(arg1, arg2, 16) != 0);
 167 }
 168
 169 bool char16lt(char *arg1, char *arg2)
 170 {
 171     if (arg1 == NULL || arg2 == NULL)
 172         return((bool) 0);
 173     return(strncmp(arg1, arg2, 16) < 0);
 174 }
 175
 176 bool char16le(char *arg1, char *arg2)
 177 {
 178     if (arg1 == NULL || arg2 == NULL)
 179         return((bool) 0);
 180     return(strncmp(arg1, arg2, 16) <= 0);
 181 }
 182
 183 bool char16gt(char *arg1, char *arg2)
 184 {
 185     if (arg1 == NULL || arg2 == NULL)
 186         return((bool) 0);
 187
 188     return(strncmp(arg1, arg2, 16) > 0);
 189 }
 190
 191 bool char16ge(char *arg1, char *arg2)
 192 {
 193     if (arg1 == NULL || arg2 == NULL)
 194         return((bool) 0);
 195
 196     return(strncmp(arg1, arg2, 16) >= 0);
 197 }
 198
 199
 200 /* ============================== char2 ============================== */
 201 uint16 char2in(char *s)
 202 {
 203     uint16      res;
 204
 205     if (s == NULL)
 206         return(0);
 207
 208     strncpy((char *) &res, s, 2);
 209     return(res);
 210 }
 211
 212 char *char2out(uint16 s)
 213 {
 214     char        *result = (char *) palloc(3);
 215
 216     strNcpy(result, (char *) &s, 2);
 217
 218     return(result);
 219 }
 220
 221 bool char2eq(uint16 a, uint16 b)
 222 {
 223     return(strncmp((char *) &a, (char *) &b, 2) == 0);
 224 }
 225
 226 bool char2ne(uint16 a, uint16 b)
 227 {
 228     return(strncmp((char *) &a, (char *) &b, 2) != 0);
 229 }
 230
 231 bool char2lt(uint16 a, uint16 b)
 232 {
 233     return(strncmp((char *) &a, (char *) &b, 2) < 0);
 234 }
 235
 236 bool char2le(uint16 a, uint16 b)
 237 {
 238     return(strncmp((char *) &a, (char *) &b, 2) <= 0);
 239 }
 240
 241 bool char2gt(uint16 a, uint16 b)
 242 {
 243     return(strncmp((char *) &a, (char *) &b, 2) > 0);
 244 }
 245
 246 bool char2ge(uint16 a, uint16 b)
 247 {
 248     return(strncmp((char *) &a, (char *) &b, 2) >= 0);
 249 }
 250
 251 int32 char2cmp(uint16 a, uint16 b)
 252 {
 253     return (strncmp((char *) &a, (char *) &b, 2));
 254 }
 255
 256 /* ============================== char4 ============================== */
 257 uint32 char4in(char *s)
 258 {
 259     uint32      res;
 260
 261     if (s == NULL)
 262         return(0);
 263
 264     strncpy((char *) &res, s, 4);
 265
 266     return(res);
 267 }
 268
 269 char *char4out(s)
 270      uint32 s;
 271 {
 272     char        *result = (char *) palloc(5);
 273
 274     strNcpy(result, (char *) &s, 4);
 275
 276     return(result);
 277 }
 278
 279 bool char4eq(uint32 a, uint32 b)
 280 {
 281     return(strncmp((char *) &a, (char *) &b, 4) == 0);
 282 }
 283
 284 bool char4ne(uint32 a, uint32 b)
 285 {
 286     return(strncmp((char *) &a, (char *) &b, 4) != 0);
 287 }
 288
 289 bool char4lt(uint32 a, uint32 b)
 290 {
 291     return(strncmp((char *) &a, (char *) &b, 4) < 0);
 292 }
 293
 294 bool char4le(uint32 a, uint32 b)
 295 {
 296     return(strncmp((char *) &a, (char *) &b, 4) <= 0);
 297 }
 298
 299 bool char4gt(uint32 a, uint32 b)
 300 {
 301     return(strncmp((char *) &a, (char *) &b, 4) > 0);
 302 }
 303
 304 bool char4ge(uint32 a, uint32 b)
 305 {
 306     return(strncmp((char *) &a, (char *) &b, 4) >= 0);
 307 }
 308
 309 int32 char4cmp(uint32 a, uint32 b)
 310 {
 311     return(strncmp((char *) &a, (char *) &b, 4));
 312 }
 313
 314 /* ============================== char8 ============================== */
 315 char *char8in(char *s)
 316 {
 317     char        *result;
 318
 319     if (s == NULL)
 320         return((char *) NULL);
 321
 322     result = (char *) palloc(8);
 323     strncpy(result, s, 8);
 324     return(result);
 325 }
 326
 327 char *char8out(char *s)
 328 {
 329     char        *result = (char *) palloc(9);
 330
 331     if (s == NULL) {
 332         result[0] = '-';
 333         result[1] = '\0';
 334     } else
 335         strNcpy(result, s, 8);
 336     return(result);
 337 }
 338
 339 bool char8eq(char *arg1, char *arg2)
 340 {
 341     if (arg1 == NULL || arg2 == NULL)
 342         return((bool) 0);
 343     return(strncmp(arg1, arg2, 8) == 0);
 344 }
 345
 346 bool char8ne(char *arg1, char *arg2)
 347 {
 348     if (arg1 == NULL || arg2 == NULL)
 349         return((bool) 0);
 350     return(strncmp(arg1, arg2, 8) != 0);
 351 }
 352
 353 bool char8lt(char *arg1, char *arg2)
 354 {
 355     if (arg1 == NULL || arg2 == NULL)
 356         return((bool) 0);
 357     return(strncmp(arg1, arg2, 8) < 0);
 358 }
 359
 360 bool char8le(char *arg1, char *arg2)
 361 {
 362     if (arg1 == NULL || arg2 == NULL)
 363         return((bool) 0);
 364     return(strncmp(arg1, arg2, 8) <= 0);
 365 }
 366
 367 bool char8gt(char *arg1, char *arg2)
 368 {
 369     if (arg1 == NULL || arg2 == NULL)
 370         return((bool) 0);
 371     return(strncmp(arg1, arg2, 8) > 0);
 372 }
 373
 374 bool char8ge(char *arg1, char *arg2)
 375 {
 376     if (arg1 == NULL || arg2 == NULL)
 377         return((bool) 0);
 378     return(strncmp(arg1, arg2, 8) >= 0);
 379 }
 380
 381 int32 char8cmp(char *arg1, char *arg2)
 382 {
 383     return(strncmp(arg1, arg2, 8));
 384 }