server/server/dynbuf.C

#define __STDC_CONSTANT_MACROS
#include <stdint.h>

#ifndef UINT64_C
# error missing c99 support, define UINT64_C yourself
# define UINT64_C(c) c ## LL
#endif

#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;

  uint32 val;

  if (i < 0)
    {
      neg = '-';
      val = -i;
    }
  else
    {
      neg = 0;
      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;
    }

  char buf[max_sint64_size];
  char *p = buf + sizeof (buf);
  char neg;

  uint64 val;

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

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

      val = div;
    }
  while (val);

  if (neg)
    *--p = neg;

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