ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/server/dynbuf.C
(Generate patch)

Comparing deliantra/server/server/dynbuf.C (file contents):
Revision 1.4 by root, Sat Sep 2 16:37:58 2006 UTC vs.
Revision 1.5 by root, Sun Sep 10 15:59:57 2006 UTC

… …
11#include <cstdio> 11#include <cstdio>
12 12
13dynbuf::dynbuf (int initial, int extend) 13dynbuf::dynbuf (int initial, int extend)
14{ 14{
15 _size = 0; 15 _size = 0;
16 ext = extend; 16 ext = extend;
17 first = last = (chunk *)new char [sizeof (chunk) + initial]; 17 first = last = (chunk *) new char[sizeof (chunk) + initial];
18
18 first->next = 0; 19 first->next = 0;
19 room = initial; 20 room = initial;
20 ptr = first->data; 21 ptr = first->data;
21} 22}
22 23
23dynbuf::~dynbuf () 24dynbuf::~dynbuf ()
24{ 25{
25 clear (); 26 clear ();
26} 27}
27 28
29void
28void dynbuf::clear () 30dynbuf::clear ()
29{ 31{
30 while (first) 32 while (first)
31 { 33 {
32 chunk *next = first->next; 34 chunk *next = first->next;
35
33 delete [] (char *)first; 36 delete[](char *) first;
34 first = next; 37 first = next;
35 } 38 }
36} 39}
37 40
41void
38void dynbuf::finish () 42dynbuf::finish ()
39{ 43{
40 // finalise current chunk 44 // finalise current chunk
41 _size += last->size = ptr - last->data; 45 _size += last->size = ptr - last->data;
42} 46}
43 47
48void
44void dynbuf::_reserve (int size) 49dynbuf::_reserve (int size)
45{ 50{
46 finish (); 51 finish ();
47 52
48 do 53 do
49 { 54 {
50 ext += ext >> 1; 55 ext += ext >> 1;
51 ext = (ext + 15) & ~15; 56 ext = (ext + 15) & ~15;
52 } 57 }
53 while (ext < size); 58 while (ext < size);
54 59
55 chunk *add = (chunk *)new char [sizeof (chunk) + ext]; 60 chunk *add = (chunk *) new char[sizeof (chunk) + ext];
61
56 add->next = 0; 62 add->next = 0;
57 63
58 last->next = add; 64 last->next = add;
59 last = add; 65 last = add;
60 66
61 room = ext; 67 room = ext;
62 ptr = last->data; 68 ptr = last->data;
63} 69}
64 70
71void
65void dynbuf::linearise (void *data) 72dynbuf::linearise (void *data)
66{ 73{
67 char *p = (char *)data; 74 char *p = (char *) data;
68 75
69 last->size = ptr - last->data; 76 last->size = ptr - last->data;
70 77
71 for (chunk *c = first; c; c = c->next) 78 for (chunk * c = first; c; c = c->next)
72 { 79 {
73 memcpy (p, c->data, c->size); 80 memcpy (p, c->data, c->size);
74 p += c->size; 81 p += c->size;
75 } 82 }
76} 83}
77 84
85char *
78char *dynbuf::linearise () 86dynbuf::linearise ()
79{ 87{
80 if (first->next) 88 if (first->next)
81 { 89 {
82 finish (); 90 finish ();
83 91
84 chunk *add = (chunk *)new char [sizeof (chunk) + _size]; 92 chunk *add = (chunk *) new char[sizeof (chunk) + _size];
85 93
86 add->next = 0; 94 add->next = 0;
87 linearise ((void *)add->data); 95 linearise ((void *) add->data);
88 clear (); 96 clear ();
89 97
90 first = last = add; 98 first = last = add;
91 ptr = last->data + _size; 99 ptr = last->data + _size;
92 _size = 0; 100 _size = 0;
93 room = 0; 101 room = 0;
94 } 102 }
95 103
96 return first->data; 104 return first->data;
97} 105}
98 106
107void
99void dynbuf::add (sint32 i) 108dynbuf::add (sint32 i)
100{ 109{
101 char buf [max_sint32_size]; 110 char buf[max_sint32_size];
102 char *p = buf + sizeof (buf); 111 char *p = buf + sizeof (buf);
103 char neg; 112 char neg;
104 113
105 uint32 val; 114 uint32 val;
106 115
… …
117 126
118 do 127 do
119 { 128 {
120 uint32 div = val / 10; 129 uint32 div = val / 10;
121 *--p = '0' + char (val - div * 10); 130 *--p = '0' + char (val - div * 10);
131
122 val = div; 132 val = div;
123 } 133 }
124 while (val); 134 while (val);
125 135
126 if (neg) 136 if (neg)
127 *--p = neg; 137 *--p = neg;
128 138
129 add ((void *)p, buf + sizeof (buf) - p); 139 add ((void *) p, buf + sizeof (buf) - p);
130} 140}
131 141
142void
132void dynbuf::add (sint64 i) 143dynbuf::add (sint64 i)
133{ 144{
134 if (i > -10000000 && i < 10000000) 145 if (i > -10000000 && i < 10000000)
135 { 146 {
136 add (sint32 (i)); 147 add (sint32 (i));
137 return; 148 return;
138 } 149 }
139 150
140 char buf [max_sint64_size]; 151 char buf[max_sint64_size];
141 char *p = buf + sizeof (buf); 152 char *p = buf + sizeof (buf);
142 char neg; 153 char neg;
143 154
144 uint64 val; 155 uint64 val;
145 156
… …
156 167
157 do 168 do
158 { 169 {
159 uint64 div = val / 10; 170 uint64 div = val / 10;
160 *--p = '0' + char (val - div * 10); 171 *--p = '0' + char (val - div * 10);
172
161 val = div; 173 val = div;
162 } 174 }
163 while (val); 175 while (val);
164 176
165 if (neg) 177 if (neg)
166 *--p = neg; 178 *--p = neg;
167 179
168 add ((void *)p, buf + sizeof (buf) - p); 180 add ((void *) p, buf + sizeof (buf) - p);
169} 181}
170

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines