ACE/ace/Obstack_T.cpp

   1 #ifndef ACE_OBSTACK_T_CPP
   2 #define ACE_OBSTACK_T_CPP
   3
   4 #include "ace/Obstack_T.h"
   5 #include "ace/Malloc_Base.h"
   6 #include "ace/OS_NS_string.h"
   7
   8 #if !defined (ACE_LACKS_PRAGMA_ONCE)
   9 # pragma once
  10 #endif /* ACE_LACKS_PRAGMA_ONCE */
  11
  12 #if !defined (__ACE_INLINE__)
  13 #include "ace/Obstack_T.inl"
  14 #endif /* __ACE_INLINE__ */
  15
  16 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  17
  18 ACE_ALLOC_HOOK_DEFINE_Tc(ACE_Obstack_T)
  19
  20 template <class ACE_CHAR_T> void
  21 ACE_Obstack_T<ACE_CHAR_T>::dump (void) const
  22 {
  23 #if defined (ACE_HAS_DUMP)
  24   ACE_TRACE ("ACE_Obstack_T<ACE_CHAR_T>::dump");
  25
  26   ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
  27   ACELIB_DEBUG ((LM_DEBUG,  ACE_TEXT ("size_ = %d\n"), this->size_));
  28   ACELIB_DEBUG ((LM_DEBUG,  ACE_TEXT ("head_ = %x\n"), this->head_));
  29   ACELIB_DEBUG ((LM_DEBUG,  ACE_TEXT ("curr_ = %x\n"), this->curr_));
  30   ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP));
  31 #endif /* ACE_HAS_DUMP */
  32 }
  33
  34 template <class ACE_CHAR_T> int
  35 ACE_Obstack_T<ACE_CHAR_T>::request (size_t len)
  36 {
  37   ACE_TRACE ("ACE_Obstack_T<ACE_CHAR_T>::request");
  38
  39   // normalize the length.
  40   len *= sizeof (ACE_CHAR_T);
  41
  42   // Check to see if there's room for the requested length, including
  43   // any part of an existing string, if any.
  44   size_t resulting_len = (this->curr_->cur_ - this->curr_->block_) + len;
  45
  46   // Increase the length of the underlying chunks if the request made is
  47   // for bigger sized chunks.
  48   if (this->size_ < resulting_len)
  49     this->size_ = this->size_ << 1;
  50
  51   // We now know the request will fit; see if it can fit in the current
  52   // chunk or will need a new one.
  53   if (this->curr_->cur_ + len >= this->curr_->end_)
  54     {
  55       // Need a new chunk. Save the current one so the current string
  56       // can be copied to the new chunk.
  57       ACE_Obchunk *temp = this->curr_;
  58       if (this->curr_->next_ == 0)
  59         {
  60           // We must allocate new memory.
  61           ACE_Obchunk* tmp = this->new_chunk();
  62           if (!tmp)
  63             return -1;
  64           this->curr_->next_ = tmp;
  65           this->curr_ = this->curr_->next_;
  66         }
  67       else
  68         {
  69           // We can reuse previously allocated memory.
  70           this->curr_ = this->curr_->next_;
  71           this->curr_->block_ = this->curr_->cur_ = this->curr_->contents_;
  72         }
  73
  74       // Copy any initial characters to the new chunk.
  75       if (temp->cur_ != temp->block_)
  76         {
  77           size_t datasize = temp->cur_ - temp->block_;
  78           ACE_OS::memcpy (this->curr_->block_,
  79                           temp->block_,
  80                           datasize);
  81           this->curr_->cur_ = this->curr_->block_ + datasize;
  82           // Reset the old chunk.
  83           temp->cur_ = temp->block_;
  84         }
  85     }
  86
  87   return 0;
  88 }
  89
  90 template <class ACE_CHAR_T> ACE_CHAR_T *
  91 ACE_Obstack_T<ACE_CHAR_T>::grow (ACE_CHAR_T c)
  92 {
  93   ACE_TRACE ("ACE_Obstack_T<ACE_CHAR_T>::grow");
  94
  95   if (this->request (1) == 0)
  96     {
  97       ACE_CHAR_T *retv = reinterpret_cast<ACE_CHAR_T *> (this->curr_->cur_);
  98       this->curr_->cur_ += sizeof (ACE_CHAR_T);
  99       *retv = c;
 100       return retv;
 101     }
 102   else
 103     return 0;
 104 }
 105
 106 template <class ACE_CHAR_T> ACE_Obchunk *
 107 ACE_Obstack_T<ACE_CHAR_T>::new_chunk (void)
 108 {
 109   ACE_TRACE ("ACE_Obstack_T<ACE_CHAR_T>::new_chunk");
 110
 111   ACE_Obchunk *temp = 0;
 112
 113   ACE_NEW_MALLOC_RETURN (temp,
 114                          static_cast<ACE_Obchunk *> (this->allocator_strategy_->malloc
 115                              (sizeof (class ACE_Obchunk) + this->size_)),
 116                          ACE_Obchunk (this->size_),
 117                          0);
 118   return temp;
 119 }
 120
 121 template <class ACE_CHAR_T>
 122 ACE_Obstack_T<ACE_CHAR_T>::ACE_Obstack_T (size_t size,
 123                                           ACE_Allocator *allocator_strategy)
 124   : allocator_strategy_ (allocator_strategy),
 125     size_ (size),
 126     head_ (0),
 127     curr_ (0)
 128 {
 129   ACE_TRACE ("ACE_Obstack_T<ACE_CHAR_T>::ACE_Obstack");
 130
 131   if (this->allocator_strategy_ == 0)
 132     ACE_ALLOCATOR (this->allocator_strategy_,
 133                    ACE_Allocator::instance ());
 134
 135   this->head_ = this->new_chunk ();
 136   this->curr_ = this->head_;
 137 }
 138
 139 template <class ACE_CHAR_T>
 140 ACE_Obstack_T<ACE_CHAR_T>::~ACE_Obstack_T (void)
 141 {
 142   ACE_TRACE ("ACE_Obstack_T<ACE_CHAR_T>::~ACE_Obstack_T");
 143
 144   ACE_Obchunk *temp = this->head_;
 145
 146   while (temp != 0)
 147     {
 148       ACE_Obchunk *next = temp->next_;
 149       temp->next_  = 0;
 150       this->allocator_strategy_->free (temp);
 151       temp = next;
 152     }
 153 }
 154
 155 template <class ACE_CHAR_T> ACE_CHAR_T *
 156 ACE_Obstack_T<ACE_CHAR_T>::copy (const ACE_CHAR_T *s,
 157                                  size_t len)
 158 {
 159   ACE_TRACE ("ACE_Obstack_T<ACE_CHAR_T>::copy");
 160
 161   if (this->request (len) != 0)
 162     return 0;
 163
 164   size_t tsize = len * sizeof (ACE_CHAR_T);
 165   ACE_OS::memcpy (this->curr_->cur_, s, tsize);
 166   this->curr_->cur_ += tsize ;
 167   return this->freeze ();
 168 }
 169
 170 template <class ACE_CHAR_T> void
 171 ACE_Obstack_T<ACE_CHAR_T>::unwind (void* obj)
 172 {
 173   if (obj >= this->curr_->contents_ && obj < this->curr_->end_)
 174     this->curr_->block_ = this->curr_->cur_ = reinterpret_cast<char*> (obj);
 175   else
 176     this->unwind_i (obj);
 177 }
 178
 179 template <class ACE_CHAR_T> void
 180 ACE_Obstack_T<ACE_CHAR_T>::unwind_i (void* obj)
 181 {
 182   ACE_Obchunk* curr = this->head_;
 183   while (curr != 0 && (curr->contents_ > obj || curr->end_ < obj))
 184       curr = curr->next_;
 185   if (curr)
 186     {
 187       this->curr_ = curr;
 188       this->curr_->block_ = this->curr_->cur_ = reinterpret_cast<char*> (obj);
 189     }
 190   else if (obj != 0)
 191     ACELIB_ERROR ((LM_ERROR,
 192                 ACE_TEXT ("Deletion of non-existent object.\n%a")));
 193 }
 194
 195 template <class ACE_CHAR_T> void
 196 ACE_Obstack_T<ACE_CHAR_T>::release (void)
 197 {
 198   ACE_TRACE ("ACE_Obstack_T<ACE_CHAR_T>::release");
 199
 200   this->curr_ = this->head_;
 201   this->curr_->block_ = this->curr_->cur_ = this->curr_->contents_;
 202 }
 203
 204 template <class ACE_CHAR_T> void
 205 ACE_Obstack_T<ACE_CHAR_T>::grow_fast (ACE_CHAR_T c)
 206 {
 207   * (reinterpret_cast<ACE_CHAR_T *> (this->curr_->cur_)) = c;
 208   this->curr_->cur_ += sizeof (ACE_CHAR_T);
 209 }
 210
 211 template <class ACE_CHAR_T> ACE_CHAR_T *
 212 ACE_Obstack_T<ACE_CHAR_T>::freeze (void)
 213 {
 214   ACE_CHAR_T *retv = reinterpret_cast<ACE_CHAR_T *> (this->curr_->block_);
 215   * (reinterpret_cast<ACE_CHAR_T *> (this->curr_->cur_)) = 0;
 216
 217   this->curr_->cur_ += sizeof (ACE_CHAR_T);
 218   this->curr_->block_ = this->curr_->cur_;
 219   return retv;
 220 }
 221
 222 ACE_END_VERSIONED_NAMESPACE_DECL
 223
 224 #endif /* ACE_OBSTACK_T_CPP */