git.m6w6.name Git - awesomized/libmemcached/blob - lib/memcached_string.c

   1 #include "common.h"
   2
   3 memcached_return memcached_string_check(memcached_string_st *string, size_t need)
   4 {
   5   if (need && need > (size_t)(string->current_size - (size_t)(string->end - string->string)))
   6   {
   7     size_t current_offset= string->end - string->string;
   8     char *new_value;
   9     size_t adjust;
  10     size_t new_size;
  11
  12     /* This is the block multiplier. To keep it larger and surive division errors we must round it up */
  13     adjust= (need - (size_t)(string->current_size - (size_t)(string->end - string->string))) / string->block_size;
  14     adjust++;
  15
  16     new_size= sizeof(char) * (size_t)((adjust * string->block_size) + string->current_size);
  17     /* Test for overflow */
  18     if (new_size < need)
  19       return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
  20
  21     new_value= (char *)realloc(string->string, new_size);
  22
  23     if (new_value == NULL)
  24       return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
  25
  26     string->string= new_value;
  27     string->end= string->string + current_offset;
  28
  29     string->current_size+= (string->block_size * adjust);
  30   }
  31
  32   return MEMCACHED_SUCCESS;
  33 }
  34
  35 memcached_string_st *memcached_string_create(memcached_st *ptr, memcached_string_st *string, size_t initial_size)
  36 {
  37   memcached_return rc;
  38
  39   /* Saving malloc calls :) */
  40   if (string)
  41   {
  42     memset(string, 0, sizeof(memcached_string_st));
  43     string->is_allocated= MEMCACHED_NOT_ALLOCATED;
  44   }
  45   else
  46   {
  47     string= (memcached_string_st *)malloc(sizeof(memcached_string_st));
  48     if (!string)
  49       return NULL;
  50     memset(string, 0, sizeof(memcached_string_st));
  51     string->is_allocated= MEMCACHED_ALLOCATED;
  52   }
  53   string->block_size= MEMCACHED_BLOCK_SIZE;
  54   string->root= ptr;
  55
  56   rc=  memcached_string_check(string, initial_size);
  57   if (rc != MEMCACHED_SUCCESS)
  58   {
  59     free(string);
  60     return NULL;
  61   }
  62
  63   WATCHPOINT_ASSERT(string->string == string->end);
  64
  65   return string;
  66 }
  67
  68 memcached_return memcached_string_append_character(memcached_string_st *string,
  69                                                    char character)
  70 {
  71   memcached_return rc;
  72
  73   WATCHPOINT_ASSERT(string->is_allocated != MEMCACHED_USED);
  74
  75   rc=  memcached_string_check(string, 1);
  76
  77   if (rc != MEMCACHED_SUCCESS)
  78     return rc;
  79
  80   *string->end= ' ';
  81   string->end++;
  82
  83   return MEMCACHED_SUCCESS;
  84 }
  85
  86 memcached_return memcached_string_append(memcached_string_st *string,
  87                                          char *value, size_t length)
  88 {
  89   memcached_return rc;
  90
  91   WATCHPOINT_ASSERT(string->is_allocated != MEMCACHED_USED);
  92
  93   rc= memcached_string_check(string, length);
  94
  95   if (rc != MEMCACHED_SUCCESS)
  96     return rc;
  97
  98   WATCHPOINT_ASSERT(length <= string->current_size);
  99   WATCHPOINT_ASSERT(string->string);
 100   WATCHPOINT_ASSERT(string->end >= string->string);
 101
 102   memcpy(string->end, value, length);
 103   string->end+= length;
 104
 105   return MEMCACHED_SUCCESS;
 106 }
 107
 108 size_t memcached_string_backspace(memcached_string_st *string, size_t remove)
 109 {
 110   WATCHPOINT_ASSERT(string->is_allocated != MEMCACHED_USED);
 111
 112   if (string->end - string->string  > remove)
 113   {
 114     size_t difference;
 115
 116     difference= string->end - string->string;
 117     string->end= string->string;
 118
 119     return difference;
 120   }
 121   string->end-= remove;
 122
 123   return remove;
 124 }
 125
 126 char *memcached_string_c_copy(memcached_string_st *string)
 127 {
 128   char *c_ptr;
 129
 130   WATCHPOINT_ASSERT(string->is_allocated != MEMCACHED_USED);
 131
 132   c_ptr= (char *)malloc(memcached_string_length(string) * sizeof(char));
 133   if (!c_ptr)
 134     return NULL;
 135
 136   memcpy(c_ptr, memcached_string_value(string), memcached_string_length(string));
 137
 138   return c_ptr;
 139 }
 140
 141 memcached_return memcached_string_reset(memcached_string_st *string)
 142 {
 143   WATCHPOINT_ASSERT(string->is_allocated != MEMCACHED_USED);
 144   string->end= string->string;
 145
 146   return MEMCACHED_SUCCESS;
 147 }
 148
 149 void memcached_string_free(memcached_string_st *ptr)
 150 {
 151   if (ptr == NULL)
 152     return;
 153
 154   if (ptr->string)
 155     free(ptr->string);
 156
 157   if (ptr->is_allocated == MEMCACHED_ALLOCATED)
 158     free(ptr);
 159   else
 160     ptr->is_allocated= MEMCACHED_USED;
 161 }