server/server/dynbuf.C

#include "global.h"

#include <cstdio>

dynbuf::dynbuf (int initial, int extend)
{
  _size = 0;
  ext   = extend;
  first = last = (chunk *)new char [sizeof (chunk) + initial];
  first->next = 0;
  room  = initial;
  ptr   = first->data;
}

dynbuf::~dynbuf ()
{
  clear ();
}

void dynbuf::clear ()
{
  while (first)
    {
      chunk *next = first->next;
      delete [] (char *)first;
      first = next;
    }
} 

void dynbuf::finish ()
{
  // finalise current chunk
  _size += last->size = ptr - last->data;
}

void dynbuf::_reserve (int size)
{
  finish ();

  do
    {
      ext += ext >> 1;
      ext = (ext + 15) & ~15;
    }
  while (ext < size);

  chunk *add = (chunk *)new char [sizeof (chunk) + ext];
  add->next = 0;

  last->next = add;
  last = add;

  room = ext;
  ptr  = last->data;
}

void dynbuf::linearise (void *data)
{
  char *p = (char *)data;

  last->size = ptr - last->data;

  for (chunk *c = first; c; c = c->next)
    {
      memcpy (p, c->data, c->size);
      p += c->size;
    }
}

char *dynbuf::linearise ()
{
  if (first->next)
    {
      finish ();

      chunk *add = (chunk *)new char [sizeof (chunk) + _size];

      add->next = 0;
      linearise ((void *)add->data);
      clear ();

      first = last = add;
      ptr   = last->data + _size;
      _size = 0;
      room  = 0;
    }

  return first->data;
}

void dynbuf::add (sint32 i)
{
  char buf [max_sint32_size];
  char *p = buf + sizeof (buf);
  char neg;

  if (i < 0)
    {
      neg = '-';
      i = -i;
    }
  else
    neg = 0;

  uint32 val = i;

  do
    {
      uint32 div = val / 10;
      *--p = '0' + char (val - div * 10);
      val = div;
    }
  while (val);

  if (neg)
    *--p = neg;

  add ((void *)p, buf + sizeof (buf) - p);
}

void dynbuf::add (sint64 i)
{
  if (i > -10000000 && i < 10000000)
    {
      add (sint32 (i));
      return;
    }

  if (i < 0)
    {
      add ('-');
      i = -i;
    }

  if (i > 1000000000000000)
    {
      add (sint32 (i / 1000000000000000));
      i %= 1000000000000000;
    }

  if (i > 10000000)
    {
      add (sint32 (i / 10000000));
      i %= 10000000;
    }

  add (sint32 (i));
}

Revision:	1.1
Committed:	Thu Aug 31 18:05:03 2006 UTC (17 years, 9 months ago) by root
Content type:	text/plain
Branch:	MAIN
Log Message:	* empty log message *
#	User	Rev	Content
1	root	1.1	#include "global.h"
2
3			#include <cstdio>
4
5			dynbuf::dynbuf (int initial, int extend)
6			{
7			_size = 0;
8			ext = extend;
9			first = last = (chunk *)new char [sizeof (chunk) + initial];
10			first->next = 0;
11			room = initial;
12			ptr = first->data;
13			}
14
15			dynbuf::~dynbuf ()
16			{
17			clear ();
18			}
19
20			void dynbuf::clear ()
21			{
22			while (first)
23			{
24			chunk *next = first->next;
25			delete [] (char *)first;
26			first = next;
27			}
28			}
29
30			void dynbuf::finish ()
31			{
32			// finalise current chunk
33			_size += last->size = ptr - last->data;
34			}
35
36			void dynbuf::_reserve (int size)
37			{
38			finish ();
39
40			do
41			{
42			ext += ext >> 1;
43			ext = (ext + 15) & ~15;
44			}
45			while (ext < size);
46
47			chunk add = (chunk )new char [sizeof (chunk) + ext];
48			add->next = 0;
49
50			last->next = add;
51			last = add;
52
53			room = ext;
54			ptr = last->data;
55			}
56
57			void dynbuf::linearise (void *data)
58			{
59			char p = (char )data;
60
61			last->size = ptr - last->data;
62
63			for (chunk *c = first; c; c = c->next)
64			{
65			memcpy (p, c->data, c->size);
66			p += c->size;
67			}
68			}
69
70			char *dynbuf::linearise ()
71			{
72			if (first->next)
73			{
74			finish ();
75
76			chunk add = (chunk )new char [sizeof (chunk) + _size];
77
78			add->next = 0;
79			linearise ((void *)add->data);
80			clear ();
81
82			first = last = add;
83			ptr = last->data + _size;
84			_size = 0;
85			room = 0;
86			}
87
88			return first->data;
89			}
90
91			void dynbuf::add (sint32 i)
92			{
93			char buf [max_sint32_size];
94			char *p = buf + sizeof (buf);
95			char neg;
96
97			if (i < 0)
98			{
99			neg = '-';
100			i = -i;
101			}
102			else
103			neg = 0;
104
105			uint32 val = i;
106
107			do
108			{
109			uint32 div = val / 10;
110			--p = '0' + char (val - div 10);
111			val = div;
112			}
113			while (val);
114
115			if (neg)
116			*--p = neg;
117
118			add ((void *)p, buf + sizeof (buf) - p);
119			}
120
121			void dynbuf::add (sint64 i)
122			{
123			if (i > -10000000 && i < 10000000)
124			{
125			add (sint32 (i));
126			return;
127			}
128
129			if (i < 0)
130			{
131			add ('-');
132			i = -i;
133			}
134
135			if (i > 1000000000000000)
136			{
137			add (sint32 (i / 1000000000000000));
138			i %= 1000000000000000;
139			}
140
141			if (i > 10000000)
142			{
143			add (sint32 (i / 10000000));
144			i %= 10000000;
145			}
146
147			add (sint32 (i));
148			}
149