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.1 by root, Thu Aug 31 18:05:03 2006 UTC vs.
Revision 1.6 by root, Tue Dec 26 08:54:59 2006 UTC

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

Diff Legend

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