server/common/shstr.C

/*
 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
 * 
 * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
 * 
 * Deliantra is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 * 
 * The authors can be reached via e-mail to <support@deliantra.net>
 */

/*
 * shstr.C
 */

#include <cstring>
#include <cstdlib>
#include <glib.h>
#include <tr1/unordered_set>

#include "global.h"

size_t shstr_alloc;

typedef std::tr1::unordered_set <const char *, str_hash, str_equal, slice_allocator<const char *> > HT;

static HT ht;
static int next_gc;

static const char *
makevec (const char *s)
{
  int len = strlen (s);

  shstr_alloc += sizeof (int) * 2 + len + 1;
  const char *v = (const char *) (2 + (int *)g_slice_alloc (sizeof (int) * 2 + len + 1));

  shstr::length (v) = len;
  shstr::refcnt (v) = 1;

  memcpy ((char *) v, s, len + 1);

  return v;
}

static const char *
makenull ()
{
  const char *s = makevec ("(null)");
  shstr::length (s) = 0;
  return s;
}

const char *shstr::null = makenull ();

const char *
shstr::find (const char *s)
{
  if (!s)
    return s;

  auto (i, ht.find (s));

  return i != ht.end ()? *i : 0;
}

const char *
shstr::intern (const char *s)
{
  if (!s)
    return null;

  if (const char *found = find (s))
    {
      ++refcnt (found);
      return found;
    }

  --next_gc;
  s = makevec (s);
  ht.insert (s);
  return s;
}

// periodically test refcounts == 0 for a few strings
// this is the ONLY thing that erases stuff from ht. keep it that way.
void
shstr::gc ()
{
  if (expect_true (next_gc > 0))
    return;

  static const char *curpos;

  auto (i, curpos ? ht.find (curpos) : ht.begin ());

  if (i == ht.end ())
    i = ht.begin ();

  int n = ht.size () / 256 + 16;
  next_gc += n >> 1;

  for (;;)
    {
      if (i == ht.end ())
        {
          curpos = 0;
          return;
        }
      else if (!--n)
        break;
      else if (!refcnt (*i))
        {
          auto (o, i++);
          const char *s = *o;

          ht.erase (o);

          //printf ("GC %4d %3d %d >%s<%d\n", (int)ht.size (), n, shstr::refcnt (s), s, shstr::length (s));
          shstr_alloc -= sizeof (int) * 2 + length (s) + 1;
          g_slice_free1 (sizeof (int) * 2 + length (s) + 1, -2 + (int *) s);
        }
      else
        ++i;
    }

  curpos = *i;
}

const shstr shstr_null;

// declare these here to get correct initialisation order
#define def(str) const shstr shstr_ ## str (# str);
# include "shstrinc.h"
#undef def

shstr skill_names[NUM_SKILLS];

//TODO: this should of course not be here

/* buf_overflow() - we don't want to exceed the buffer size of 
 * buf1 by adding on buf2! Returns true if overflow will occur.
 */
int
buf_overflow (const char *buf1, const char *buf2, int bufsize)
{
  int len1 = 0, len2 = 0;

  if (buf1)
    len1 = strlen (buf1);

  if (buf2)
    len2 = strlen (buf2);

  if ((len1 + len2) >= bufsize)
    return 1;

  return 0;
}
Revision:	1.31
Committed:	Tue Jul 29 02:00:55 2008 UTC (15 years, 10 months ago) by root
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rel-2_7, rel-2_72, rel-2_73, rel-2_71, rel-2_74, rel-2_61
Changes since 1.30:	+1 -1 lines
Log Message:	4.3
#	Content
1	/*
2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	*
4	* Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	*
6	* Deliantra is free software: you can redistribute it and/or modify
7	* it under the terms of the GNU General Public License as published by
8	* the Free Software Foundation, either version 3 of the License, or
9	* (at your option) any later version.
10	*
11	* This program is distributed in the hope that it will be useful,
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	* GNU General Public License for more details.
15	*
16	* You should have received a copy of the GNU General Public License
17	* along with this program. If not, see <http://www.gnu.org/licenses/>.
18	*
19	* The authors can be reached via e-mail to <support@deliantra.net>
20	*/
21
22	/*
23	* shstr.C
24	*/
25
26	#include <cstring>
27	#include <cstdlib>
28	#include <glib.h>
29	#include <tr1/unordered_set>
30
31	#include "global.h"
32
33	size_t shstr_alloc;
34
35	typedef std::tr1::unordered_set <const char , str_hash, str_equal, slice_allocator<const char > > HT;
36
37	static HT ht;
38	static int next_gc;
39
40	static const char *
41	makevec (const char *s)
42	{
43	int len = strlen (s);
44
45	shstr_alloc += sizeof (int) * 2 + len + 1;
46	const char v = (const char ) (2 + (int )g_slice_alloc (sizeof (int) 2 + len + 1));
47
48	shstr::length (v) = len;
49	shstr::refcnt (v) = 1;
50
51	memcpy ((char *) v, s, len + 1);
52
53	return v;
54	}
55
56	static const char *
57	makenull ()
58	{
59	const char *s = makevec ("(null)");
60	shstr::length (s) = 0;
61	return s;
62	}
63
64	const char *shstr::null = makenull ();
65
66	const char *
67	shstr::find (const char *s)
68	{
69	if (!s)
70	return s;
71
72	auto (i, ht.find (s));
73
74	return i != ht.end ()? *i : 0;
75	}
76
77	const char *
78	shstr::intern (const char *s)
79	{
80	if (!s)
81	return null;
82
83	if (const char *found = find (s))
84	{
85	++refcnt (found);
86	return found;
87	}
88
89	--next_gc;
90	s = makevec (s);
91	ht.insert (s);
92	return s;
93	}
94
95	// periodically test refcounts == 0 for a few strings
96	// this is the ONLY thing that erases stuff from ht. keep it that way.
97	void
98	shstr::gc ()
99	{
100	if (expect_true (next_gc > 0))
101	return;
102
103	static const char *curpos;
104
105	auto (i, curpos ? ht.find (curpos) : ht.begin ());
106
107	if (i == ht.end ())
108	i = ht.begin ();
109
110	int n = ht.size () / 256 + 16;
111	next_gc += n >> 1;
112
113	for (;;)
114	{
115	if (i == ht.end ())
116	{
117	curpos = 0;
118	return;
119	}
120	else if (!--n)
121	break;
122	else if (!refcnt (*i))
123	{
124	auto (o, i++);
125	const char s = o;
126
127	ht.erase (o);
128
129	//printf ("GC %4d %3d %d >%s<%d\n", (int)ht.size (), n, shstr::refcnt (s), s, shstr::length (s));
130	shstr_alloc -= sizeof (int) * 2 + length (s) + 1;
131	g_slice_free1 (sizeof (int) * 2 + length (s) + 1, -2 + (int *) s);
132	}
133	else
134	++i;
135	}
136
137	curpos = *i;
138	}
139
140	const shstr shstr_null;
141
142	// declare these here to get correct initialisation order
143	#define def(str) const shstr shstr_ ## str (# str);
144	# include "shstrinc.h"
145	#undef def
146
147	shstr skill_names[NUM_SKILLS];
148
149	//TODO: this should of course not be here
150
151	/* buf_overflow() - we don't want to exceed the buffer size of
152	* buf1 by adding on buf2! Returns true if overflow will occur.
153	*/
154	int
155	buf_overflow (const char buf1, const char buf2, int bufsize)
156	{
157	int len1 = 0, len2 = 0;
158
159	if (buf1)
160	len1 = strlen (buf1);
161
162	if (buf2)
163	len2 = strlen (buf2);
164
165	if ((len1 + len2) >= bufsize)
166	return 1;
167
168	return 0;
169	}