src/common/fe_memutils.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * fe_memutils.c
   4  *        memory management support for frontend code
   5  *
   6  * Portions Copyright (c) 1996-2025, 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 pg_malloc_internal(size_t size, int flags)
  24 {
  25         void       *tmp;
  26
  27         /* Avoid unportable behavior of malloc(0) */
  28         if (size == 0)
  29                 size = 1;
  30         tmp = malloc(size);
  31         if (tmp == NULL)
  32         {
  33                 if ((flags & MCXT_ALLOC_NO_OOM) == 0)
  34                 {
  35                         fprintf(stderr, _("out of memory\n"));
  36                         exit(EXIT_FAILURE);
  37                 }
  38                 return NULL;
  39         }
  40
  41         if ((flags & MCXT_ALLOC_ZERO) != 0)
  42                 MemSet(tmp, 0, size);
  43         return tmp;
  44 }
  45
  46 void *
  47 pg_malloc(size_t size)
  48 {
  49         return pg_malloc_internal(size, 0);
  50 }
  51
  52 void *
  53 pg_malloc0(size_t size)
  54 {
  55         return pg_malloc_internal(size, MCXT_ALLOC_ZERO);
  56 }
  57
  58 void *
  59 pg_malloc_extended(size_t size, int flags)
  60 {
  61         return pg_malloc_internal(size, flags);
  62 }
  63
  64 void *
  65 pg_realloc(void *ptr, size_t size)
  66 {
  67         void       *tmp;
  68
  69         /* Avoid unportable behavior of realloc(NULL, 0) */
  70         if (ptr == NULL && size == 0)
  71                 size = 1;
  72         tmp = realloc(ptr, size);
  73         if (!tmp)
  74         {
  75                 fprintf(stderr, _("out of memory\n"));
  76                 exit(EXIT_FAILURE);
  77         }
  78         return tmp;
  79 }
  80
  81 /*
  82  * "Safe" wrapper around strdup().
  83  */
  84 char *
  85 pg_strdup(const char *in)
  86 {
  87         char       *tmp;
  88
  89         if (!in)
  90         {
  91                 fprintf(stderr,
  92                                 _("cannot duplicate null pointer (internal error)\n"));
  93                 exit(EXIT_FAILURE);
  94         }
  95         tmp = strdup(in);
  96         if (!tmp)
  97         {
  98                 fprintf(stderr, _("out of memory\n"));
  99                 exit(EXIT_FAILURE);
 100         }
 101         return tmp;
 102 }
 103
 104 void
 105 pg_free(void *ptr)
 106 {
 107         free(ptr);
 108 }
 109
 110 /*
 111  * Frontend emulation of backend memory management functions.  Useful for
 112  * programs that compile backend files.
 113  */
 114 void *
 115 palloc(Size size)
 116 {
 117         return pg_malloc_internal(size, 0);
 118 }
 119
 120 void *
 121 palloc0(Size size)
 122 {
 123         return pg_malloc_internal(size, MCXT_ALLOC_ZERO);
 124 }
 125
 126 void *
 127 palloc_extended(Size size, int flags)
 128 {
 129         return pg_malloc_internal(size, flags);
 130 }
 131
 132 void
 133 pfree(void *pointer)
 134 {
 135         pg_free(pointer);
 136 }
 137
 138 char *
 139 pstrdup(const char *in)
 140 {
 141         return pg_strdup(in);
 142 }
 143
 144 char *
 145 pnstrdup(const char *in, Size size)
 146 {
 147         char       *tmp;
 148         int                     len;
 149
 150         if (!in)
 151         {
 152                 fprintf(stderr,
 153                                 _("cannot duplicate null pointer (internal error)\n"));
 154                 exit(EXIT_FAILURE);
 155         }
 156
 157         len = strnlen(in, size);
 158         tmp = malloc(len + 1);
 159         if (tmp == NULL)
 160         {
 161                 fprintf(stderr, _("out of memory\n"));
 162                 exit(EXIT_FAILURE);
 163         }
 164
 165         memcpy(tmp, in, len);
 166         tmp[len] = '\0';
 167
 168         return tmp;
 169 }
 170
 171 void *
 172 repalloc(void *pointer, Size size)
 173 {
 174         return pg_realloc(pointer, size);
 175 }