Line data    Source code

       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * fe_memutils.c
       4             :  *    memory management support for frontend code
       5             :  *
       6             :  * Portions Copyright (c) 1996-2017, PostgreSQL Global Development Group
       7             :  * Portions Copyright (c) 1994, Regents of the University of California
       8             :  *
       9             :  *
      10             :  * IDENTIFICATION
      11             :  *    src/common/fe_memutils.c
      12             :  *
      13             :  *-------------------------------------------------------------------------
      14             :  */
      15             : 
      16             : #ifndef FRONTEND
      17             : #error "This file is not expected to be compiled for backend code"
      18             : #endif
      19             : 
      20             : #include "postgres_fe.h"
      21             : 
      22             : static inline void *
      23      235804 : pg_malloc_internal(size_t size, int flags)
      24             : {
      25             :     void       *tmp;
      26             : 
      27             :     /* Avoid unportable behavior of malloc(0) */
      28      235804 :     if (size == 0)
      29           2 :         size = 1;
      30      235804 :     tmp = malloc(size);
      31      235804 :     if (tmp == NULL)
      32             :     {
      33           0 :         if ((flags & MCXT_ALLOC_NO_OOM) == 0)
      34             :         {
      35           0 :             fprintf(stderr, _("out of memory\n"));
      36           0 :             exit(EXIT_FAILURE);
      37             :         }
      38           0 :         return NULL;
      39             :     }
      40             : 
      41      235804 :     if ((flags & MCXT_ALLOC_ZERO) != 0)
      42      158574 :         MemSet(tmp, 0, size);
      43      235804 :     return tmp;
      44             : }
      45             : 
      46             : void *
      47       76428 : pg_malloc(size_t size)
      48             : {
      49       76428 :     return pg_malloc_internal(size, 0);
      50             : }
      51             : 
      52             : void *
      53      158574 : pg_malloc0(size_t size)
      54             : {
      55      158574 :     return pg_malloc_internal(size, MCXT_ALLOC_ZERO);
      56             : }
      57             : 
      58             : void *
      59           0 : pg_malloc_extended(size_t size, int flags)
      60             : {
      61           0 :     return pg_malloc_internal(size, flags);
      62             : }
      63             : 
      64             : void *
      65           6 : pg_realloc(void *ptr, size_t size)
      66             : {
      67             :     void       *tmp;
      68             : 
      69             :     /* Avoid unportable behavior of realloc(NULL, 0) */
      70           6 :     if (ptr == NULL && size == 0)
      71           0 :         size = 1;
      72           6 :     tmp = realloc(ptr, size);
      73           6 :     if (!tmp)
      74             :     {
      75           0 :         fprintf(stderr, _("out of memory\n"));
      76           0 :         exit(EXIT_FAILURE);
      77             :     }
      78           6 :     return tmp;
      79             : }
      80             : 
      81             : /*
      82             :  * "Safe" wrapper around strdup().
      83             :  */
      84             : char *
      85       99669 : pg_strdup(const char *in)
      86             : {
      87             :     char       *tmp;
      88             : 
      89       99669 :     if (!in)
      90             :     {
      91           0 :         fprintf(stderr,
      92             :                 _("cannot duplicate null pointer (internal error)\n"));
      93           0 :         exit(EXIT_FAILURE);
      94             :     }
      95       99669 :     tmp = strdup(in);
      96       99669 :     if (!tmp)
      97             :     {
      98           0 :         fprintf(stderr, _("out of memory\n"));
      99           0 :         exit(EXIT_FAILURE);
     100             :     }
     101       99669 :     return tmp;
     102             : }
     103             : 
     104             : void
     105      116325 : pg_free(void *ptr)
     106             : {
     107      116325 :     if (ptr != NULL)
     108       19291 :         free(ptr);
     109      116325 : }
     110             : 
     111             : /*
     112             :  * Frontend emulation of backend memory management functions.  Useful for
     113             :  * programs that compile backend files.
     114             :  */
     115             : void *
     116         802 : palloc(Size size)
     117             : {
     118         802 :     return pg_malloc_internal(size, 0);
     119             : }
     120             : 
     121             : void *
     122           0 : palloc0(Size size)
     123             : {
     124           0 :     return pg_malloc_internal(size, MCXT_ALLOC_ZERO);
     125             : }
     126             : 
     127             : void *
     128           0 : palloc_extended(Size size, int flags)
     129             : {
     130           0 :     return pg_malloc_internal(size, flags);
     131             : }
     132             : 
     133             : void
     134        3107 : pfree(void *pointer)
     135             : {
     136        3107 :     pg_free(pointer);
     137        3107 : }
     138             : 
     139             : char *
     140        2886 : pstrdup(const char *in)
     141             : {
     142        2886 :     return pg_strdup(in);
     143             : }
     144             : 
     145             : void *
     146           6 : repalloc(void *pointer, Size size)
     147             : {
     148           6 :     return pg_realloc(pointer, size);
     149             : }