1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
// $Id$
#define ACE_BUILD_DLL
#include "ace/Obstack.h"
ACE_ALLOC_HOOK_DEFINE(ACE_Obstack)
void
ACE_Obstack::dump (void) const
{
ACE_TRACE ("ACE_Obstack::dump");
ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
ACE_DEBUG ((LM_DEBUG, "size_ = %d\n", this->size_));
ACE_DEBUG ((LM_DEBUG, "head_ = %x\n", this->head_));
ACE_DEBUG ((LM_DEBUG, "curr_ = %x\n", this->curr_));
ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
}
ACE_ALLOC_HOOK_DEFINE(ACE_Obchunk)
void
ACE_Obchunk::dump (void) const
{
ACE_TRACE ("ACE_Obchunk::dump");
ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
ACE_DEBUG ((LM_DEBUG, "end_ = %x\n", this->end_));
ACE_DEBUG ((LM_DEBUG, "cur_ = %x\n", this->cur_));
ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
}
ACE_Obchunk::ACE_Obchunk (size_t size)
: end_ (contents_ + size),
cur_ (contents_),
next_ (0)
{
}
class ACE_Obchunk *
ACE_Obstack::new_chunk (void)
{
ACE_TRACE ("ACE_Obstack::new_chunk");
char *temp;
ACE_ALLOCATOR_RETURN (temp,
(char *) this->allocator_strategy_->malloc (sizeof (class ACE_Obchunk) + this->size_),
0);
return new (temp) ACE_Obchunk (this->size_);
}
ACE_Obstack::ACE_Obstack (size_t size,
ACE_Allocator *allocator_strategy)
: allocator_strategy_ (allocator_strategy),
size_ (size)
{
ACE_TRACE ("ACE_Obstack::ACE_Obstack");
if (this->allocator_strategy_ == 0)
ACE_ALLOCATOR (this->allocator_strategy_,
ACE_Allocator::instance ());
this->head_ = this->new_chunk ();
this->curr_ = this->head_;
}
ACE_Obstack::~ACE_Obstack (void)
{
ACE_TRACE ("ACE_Obstack::~ACE_Obstack");
ACE_Obchunk *temp = this->head_;
while (temp != 0)
{
ACE_Obchunk *next = temp->next_;
temp->next_ = 0;
this->allocator_strategy_->free ((void *) temp);
temp = next;
}
}
char *
ACE_Obstack::copy (const char *s,
size_t len)
{
ACE_TRACE ("ACE_Obstack::copy");
char *result;
ACE_ASSERT (this->size_ >= len + 1);
// Check whether we need to grow our chunk...
if (this->curr_->cur_ + len + 1 >= this->curr_->end_)
{
if (this->curr_->next_ == 0)
{
// We must allocate new memory.
this->curr_->next_ = this->new_chunk ();
this->curr_ = this->curr_->next_;
}
else
{
// We can reuse previously allocated memory.
this->curr_ = this->curr_->next_;
this->curr_->cur_ = this->curr_->contents_;
}
}
result = this->curr_->cur_;
ACE_OS::memcpy (result, s, len);
result[len] = '\0';
this->curr_->cur_ += (len + 1);
return result;
}
void
ACE_Obstack::release (void)
{
ACE_TRACE ("ACE_Obstack::release");
this->curr_ = this->head_;
this->curr_->cur_ = this->curr_->contents_;
}
|
