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.2 by root, Fri Sep 1 13:58:07 2006 UTC vs.
Revision 1.6 by root, Tue Dec 26 08:54:59 2006 UTC

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

Diff Legend

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