Line data    Source code

       1              : /* src/interfaces/ecpg/pgtypeslib/common.c */
       2              : 
       3              : #include "postgres_fe.h"
       4              : 
       5              : #include "pgtypes.h"
       6              : #include "pgtypeslib_extern.h"
       7              : 
       8              : /* Return value is zero-filled. */
       9              : char *
      10            0 : pgtypes_alloc(long size)
      11              : {
      12            0 :         char       *new = (char *) calloc(1L, size);
      13              : 
      14            0 :         if (!new)
      15            0 :                 errno = ENOMEM;
      16            0 :         return new;
      17            0 : }
      18              : 
      19              : char *
      20            0 : pgtypes_strdup(const char *str)
      21              : {
      22            0 :         char       *new = strdup(str);
      23              : 
      24            0 :         if (!new)
      25            0 :                 errno = ENOMEM;
      26            0 :         return new;
      27            0 : }
      28              : 
      29              : int
      30            0 : pgtypes_fmt_replace(union un_fmt_comb replace_val, int replace_type, char **output, int *pstr_len)
      31              : {
      32              :         /*
      33              :          * general purpose variable, set to 0 in order to fix compiler warning
      34              :          */
      35            0 :         int                     i = 0;
      36              : 
      37            0 :         switch (replace_type)
      38              :         {
      39              :                 case PGTYPES_TYPE_NOTHING:
      40              :                         break;
      41              :                 case PGTYPES_TYPE_STRING_CONSTANT:
      42              :                 case PGTYPES_TYPE_STRING_MALLOCED:
      43            0 :                         i = strlen(replace_val.str_val);
      44            0 :                         if (i + 1 <= *pstr_len)
      45              :                         {
      46              :                                 /* include trailing terminator in what we copy */
      47            0 :                                 memcpy(*output, replace_val.str_val, i + 1);
      48            0 :                                 *pstr_len -= i;
      49            0 :                                 *output += i;
      50            0 :                                 if (replace_type == PGTYPES_TYPE_STRING_MALLOCED)
      51            0 :                                         free(replace_val.str_val);
      52            0 :                                 return 0;
      53              :                         }
      54              :                         else
      55            0 :                                 return -1;
      56              :                         break;
      57              :                 case PGTYPES_TYPE_CHAR:
      58            0 :                         if (*pstr_len >= 2)
      59              :                         {
      60            0 :                                 (*output)[0] = replace_val.char_val;
      61            0 :                                 (*output)[1] = '\0';
      62            0 :                                 (*pstr_len)--;
      63            0 :                                 (*output)++;
      64            0 :                                 return 0;
      65              :                         }
      66              :                         else
      67            0 :                                 return -1;
      68              :                         break;
      69              :                 case PGTYPES_TYPE_DOUBLE_NF:
      70              :                 case PGTYPES_TYPE_INT64:
      71              :                 case PGTYPES_TYPE_UINT:
      72              :                 case PGTYPES_TYPE_UINT_2_LZ:
      73              :                 case PGTYPES_TYPE_UINT_2_LS:
      74              :                 case PGTYPES_TYPE_UINT_3_LZ:
      75              :                 case PGTYPES_TYPE_UINT_4_LZ:
      76              :                         {
      77            0 :                                 char       *t = pgtypes_alloc(PGTYPES_FMT_NUM_MAX_DIGITS);
      78              : 
      79            0 :                                 if (!t)
      80            0 :                                         return ENOMEM;
      81            0 :                                 switch (replace_type)
      82              :                                 {
      83              :                                         case PGTYPES_TYPE_DOUBLE_NF:
      84            0 :                                                 i = snprintf(t, PGTYPES_FMT_NUM_MAX_DIGITS,
      85            0 :                                                                          "%0.0g", replace_val.double_val);
      86            0 :                                                 break;
      87              :                                         case PGTYPES_TYPE_INT64:
      88            0 :                                                 i = snprintf(t, PGTYPES_FMT_NUM_MAX_DIGITS,
      89            0 :                                                                          INT64_FORMAT, replace_val.int64_val);
      90            0 :                                                 break;
      91              :                                         case PGTYPES_TYPE_UINT:
      92            0 :                                                 i = snprintf(t, PGTYPES_FMT_NUM_MAX_DIGITS,
      93            0 :                                                                          "%u", replace_val.uint_val);
      94            0 :                                                 break;
      95              :                                         case PGTYPES_TYPE_UINT_2_LZ:
      96            0 :                                                 i = snprintf(t, PGTYPES_FMT_NUM_MAX_DIGITS,
      97            0 :                                                                          "%02u", replace_val.uint_val);
      98            0 :                                                 break;
      99              :                                         case PGTYPES_TYPE_UINT_2_LS:
     100            0 :                                                 i = snprintf(t, PGTYPES_FMT_NUM_MAX_DIGITS,
     101            0 :                                                                          "%2u", replace_val.uint_val);
     102            0 :                                                 break;
     103              :                                         case PGTYPES_TYPE_UINT_3_LZ:
     104            0 :                                                 i = snprintf(t, PGTYPES_FMT_NUM_MAX_DIGITS,
     105            0 :                                                                          "%03u", replace_val.uint_val);
     106            0 :                                                 break;
     107              :                                         case PGTYPES_TYPE_UINT_4_LZ:
     108            0 :                                                 i = snprintf(t, PGTYPES_FMT_NUM_MAX_DIGITS,
     109            0 :                                                                          "%04u", replace_val.uint_val);
     110            0 :                                                 break;
     111              :                                 }
     112              : 
     113            0 :                                 if (i < 0 || i >= PGTYPES_FMT_NUM_MAX_DIGITS)
     114              :                                 {
     115            0 :                                         free(t);
     116            0 :                                         return -1;
     117              :                                 }
     118            0 :                                 i = strlen(t);
     119            0 :                                 *pstr_len -= i;
     120              : 
     121              :                                 /*
     122              :                                  * if *pstr_len == 0, we don't have enough space for the
     123              :                                  * terminator and the conversion fails
     124              :                                  */
     125            0 :                                 if (*pstr_len <= 0)
     126              :                                 {
     127            0 :                                         free(t);
     128            0 :                                         return -1;
     129              :                                 }
     130            0 :                                 strcpy(*output, t);
     131            0 :                                 *output += i;
     132            0 :                                 free(t);
     133            0 :                         }
     134            0 :                         break;
     135              :                 default:
     136            0 :                         break;
     137              :         }
     138            0 :         return 0;
     139            0 : }
     140              : 
     141              : /* Functions declared in pgtypes.h. */
     142              : 
     143              : /* Just frees memory (mostly needed for Windows) */
     144              : void
     145            0 : PGTYPESchar_free(char *ptr)
     146              : {
     147            0 :         free(ptr);
     148            0 : }