Branch data     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                 :       79520 : pgtypes_alloc(long size)
      11                 :             : {
      12                 :       79520 :     char       *new = (char *) calloc(1L, size);
      13                 :             : 
      14         [ -  + ]:       79520 :     if (!new)
      15                 :           0 :         errno = ENOMEM;
      16                 :       79520 :     return new;
      17                 :             : }
      18                 :             : 
      19                 :             : char *
      20                 :         782 : pgtypes_strdup(const char *str)
      21                 :             : {
      22                 :         782 :     char       *new = strdup(str);
      23                 :             : 
      24         [ -  + ]:         782 :     if (!new)
      25                 :           0 :         errno = ENOMEM;
      26                 :         782 :     return new;
      27                 :             : }
      28                 :             : 
      29                 :             : int
      30                 :          38 : 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                 :          38 :     int         i = 0;
      36                 :             : 
      37   [ +  +  +  +  :          38 :     switch (replace_type)
                      - ]
      38                 :             :     {
      39                 :           4 :         case PGTYPES_TYPE_NOTHING:
      40                 :           4 :             break;
      41                 :           8 :         case PGTYPES_TYPE_STRING_CONSTANT:
      42                 :             :         case PGTYPES_TYPE_STRING_MALLOCED:
      43                 :           8 :             i = strlen(replace_val.str_val);
      44         [ +  - ]:           8 :             if (i + 1 <= *pstr_len)
      45                 :             :             {
      46                 :             :                 /* include trailing terminator in what we copy */
      47                 :           8 :                 memcpy(*output, replace_val.str_val, i + 1);
      48                 :           8 :                 *pstr_len -= i;
      49                 :           8 :                 *output += i;
      50         [ -  + ]:           8 :                 if (replace_type == PGTYPES_TYPE_STRING_MALLOCED)
      51                 :           0 :                     free(replace_val.str_val);
      52                 :           8 :                 return 0;
      53                 :             :             }
      54                 :             :             else
      55                 :           0 :                 return -1;
      56                 :             :             break;
      57                 :           2 :         case PGTYPES_TYPE_CHAR:
      58         [ +  - ]:           2 :             if (*pstr_len >= 2)
      59                 :             :             {
      60                 :           2 :                 (*output)[0] = replace_val.char_val;
      61                 :           2 :                 (*output)[1] = '\0';
      62                 :           2 :                 (*pstr_len)--;
      63                 :           2 :                 (*output)++;
      64                 :           2 :                 return 0;
      65                 :             :             }
      66                 :             :             else
      67                 :           0 :                 return -1;
      68                 :             :             break;
      69                 :          24 :         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                 :          24 :                 char       *t = pgtypes_alloc(PGTYPES_FMT_NUM_MAX_DIGITS);
      78                 :             : 
      79         [ -  + ]:          24 :                 if (!t)
      80                 :           0 :                     return ENOMEM;
      81   [ -  -  +  +  :          24 :                 switch (replace_type)
             -  +  -  - ]
      82                 :             :                 {
      83                 :           0 :                     case PGTYPES_TYPE_DOUBLE_NF:
      84                 :           0 :                         i = snprintf(t, PGTYPES_FMT_NUM_MAX_DIGITS,
      85                 :             :                                      "%0.0g", replace_val.double_val);
      86                 :           0 :                         break;
      87                 :           0 :                     case PGTYPES_TYPE_INT64:
      88                 :           0 :                         i = snprintf(t, PGTYPES_FMT_NUM_MAX_DIGITS,
      89                 :             :                                      INT64_FORMAT, replace_val.int64_val);
      90                 :           0 :                         break;
      91                 :           6 :                     case PGTYPES_TYPE_UINT:
      92                 :           6 :                         i = snprintf(t, PGTYPES_FMT_NUM_MAX_DIGITS,
      93                 :             :                                      "%u", replace_val.uint_val);
      94                 :           6 :                         break;
      95                 :          16 :                     case PGTYPES_TYPE_UINT_2_LZ:
      96                 :          16 :                         i = snprintf(t, PGTYPES_FMT_NUM_MAX_DIGITS,
      97                 :             :                                      "%02u", replace_val.uint_val);
      98                 :          16 :                         break;
      99                 :           0 :                     case PGTYPES_TYPE_UINT_2_LS:
     100                 :           0 :                         i = snprintf(t, PGTYPES_FMT_NUM_MAX_DIGITS,
     101                 :             :                                      "%2u", replace_val.uint_val);
     102                 :           0 :                         break;
     103                 :           2 :                     case PGTYPES_TYPE_UINT_3_LZ:
     104                 :           2 :                         i = snprintf(t, PGTYPES_FMT_NUM_MAX_DIGITS,
     105                 :             :                                      "%03u", replace_val.uint_val);
     106                 :           2 :                         break;
     107                 :           0 :                     case PGTYPES_TYPE_UINT_4_LZ:
     108                 :           0 :                         i = snprintf(t, PGTYPES_FMT_NUM_MAX_DIGITS,
     109                 :             :                                      "%04u", replace_val.uint_val);
     110                 :           0 :                         break;
     111                 :             :                 }
     112                 :             : 
     113   [ +  -  -  + ]:          24 :                 if (i < 0 || i >= PGTYPES_FMT_NUM_MAX_DIGITS)
     114                 :             :                 {
     115                 :           0 :                     free(t);
     116                 :           0 :                     return -1;
     117                 :             :                 }
     118                 :          24 :                 i = strlen(t);
     119                 :          24 :                 *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         [ -  + ]:          24 :                 if (*pstr_len <= 0)
     126                 :             :                 {
     127                 :           0 :                     free(t);
     128                 :           0 :                     return -1;
     129                 :             :                 }
     130                 :          24 :                 strcpy(*output, t);
     131                 :          24 :                 *output += i;
     132                 :          24 :                 free(t);
     133                 :             :             }
     134                 :          24 :             break;
     135                 :           0 :         default:
     136                 :           0 :             break;
     137                 :             :     }
     138                 :          28 :     return 0;
     139                 :             : }
     140                 :             : 
     141                 :             : /* Functions declared in pgtypes.h. */
     142                 :             : 
     143                 :             : /* Just frees memory (mostly needed for Windows) */
     144                 :             : void
     145                 :        2380 : PGTYPESchar_free(char *ptr)
     146                 :             : {
     147                 :        2380 :     free(ptr);
     148                 :        2380 : }