server/common/shstr.C


/*
 * shstr.C
 */

#include <cstring>
#include <cstdlib>

#include <glib.h>

#include <tr1/unordered_set>

#include "shstr.h"
#include "util.h"

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

static HT
  ht;

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

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

const char *
  shstr::null = makevec ("<nil>");

// what weird misoptimisation is this again?
const shstr undead_name ("undead");

shstr skill_names[NUM_SKILLS];

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

  HT::iterator 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;
    }

  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 ()
{
return; //D
//D currently disabled: some datastructures might still store them
//D but their pointers will become invalidated
  static const char *curpos;

  HT::iterator i = curpos ? ht.find (curpos) : ht.begin ();

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

  // go through all strings roughly once every 4 minutes
  int n = ht.size () / 256 + 16;

  for (;;)
    {
      if (i == ht.end ())
        {
          curpos = 0;
          return;
        }
      else if (!--n)
        break;
      else if (!refcnt (*i))
        {
          HT::iterator 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));
          g_slice_free1 (sizeof (int) * 2 + length (s) + 1, -2 + (int *) s);
        }
      else
        ++i;
    }

  curpos = *i;
}

//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.15
Committed:	Tue Sep 12 00:26:16 2006 UTC (17 years, 9 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.14:	+2 -0 lines
Log Message:	* empty log message *
#	User	Rev	Content
1	root	1.13
2	elmex	1.1	/*
3	root	1.3	* shstr.C
4	elmex	1.1	*/
5
6	root	1.3	#include <cstring>
7			#include <cstdlib>
8
9	root	1.10	#include <glib.h>
10
11	root	1.3	#include <tr1/unordered_set>
12	elmex	1.1
13			#include "shstr.h"
14	root	1.9	#include "util.h"
15	elmex	1.1
16	root	1.13	typedef
17			std::tr1::unordered_set < const char *,
18			str_hash,
19			str_equal >
20			HT;
21	elmex	1.1
22	root	1.13	static HT
23			ht;
24	elmex	1.1
25	root	1.13	static const char *
26			makevec (const char *s)
27	root	1.7	{
28	root	1.13	int
29			len = strlen (s);
30	root	1.7
31	root	1.13	const char *
32			v = (const char ) (2 + (int ) g_slice_alloc (sizeof (int) * 2 + len + 1));
33	root	1.7
34			shstr::length (v) = len;
35			shstr::refcnt (v) = 1;
36
37	root	1.13	memcpy ((char *) v, s, len + 1);
38	root	1.7
39	root	1.8	return v;
40	root	1.7	}
41
42	root	1.13	const char *
43			shstr::null = makevec ("<nil>");
44	root	1.7
45	root	1.8	// what weird misoptimisation is this again?
46			const shstr undead_name ("undead");
47
48	root	1.15	shstr skill_names[NUM_SKILLS];
49
50	elmex	1.1	const char *
51	root	1.3	shstr::find (const char *s)
52			{
53	root	1.4	if (!s)
54			return s;
55
56	root	1.3	HT::iterator i = ht.find (s);
57	elmex	1.1
58	root	1.13	return i != ht.end ()? *i : 0;
59	elmex	1.1	}
60
61			const char *
62	root	1.3	shstr::intern (const char *s)
63			{
64	root	1.4	if (!s)
65	root	1.7	return null;
66	elmex	1.1
67	root	1.4	if (const char *found = find (s))
68	root	1.5	{
69			++refcnt (found);
70			return found;
71			}
72	elmex	1.1
73	root	1.7	s = makevec (s);
74			ht.insert (s);
75			return s;
76	elmex	1.1	}
77
78	root	1.5	// periodically test refcounts == 0 for a few strings
79			// this is the ONLY thing that erases stuff from ht. keep it that way.
80	elmex	1.1	void
81	root	1.3	shstr::gc ()
82			{
83	root	1.14	return; //D
84			//D currently disabled: some datastructures might still store them
85			//D but their pointers will become invalidated
86	root	1.5	static const char *curpos;
87
88			HT::iterator i = curpos ? ht.find (curpos) : ht.begin ();
89
90			if (i == ht.end ())
91			i = ht.begin ();
92
93			// go through all strings roughly once every 4 minutes
94	root	1.11	int n = ht.size () / 256 + 16;
95	root	1.6
96			for (;;)
97	root	1.5	{
98			if (i == ht.end ())
99			{
100			curpos = 0;
101			return;
102			}
103	root	1.6	else if (!--n)
104			break;
105			else if (!refcnt (*i))
106	root	1.5	{
107			HT::iterator o = i++;
108			const char s = o;
109	root	1.13
110	root	1.5	ht.erase (o);
111
112			//printf ("GC %4d %3d %d >%s<%d\n", (int)ht.size (), n, shstr::refcnt (s), s, shstr::length (s));
113	root	1.13	g_slice_free1 (sizeof (int) * 2 + length (s) + 1, -2 + (int *) s);
114	root	1.5	}
115			else
116			++i;
117			}
118
119			curpos = *i;
120	elmex	1.1	}
121
122	root	1.5	//TODO: this should of course not be here
123	root	1.13
124	elmex	1.1	/* buf_overflow() - we don't want to exceed the buffer size of
125			* buf1 by adding on buf2! Returns true if overflow will occur.
126			*/
127
128	root	1.13	int
129	elmex	1.1	buf_overflow (const char buf1, const char buf2, int bufsize)
130			{
131	root	1.13	int len1 = 0, len2 = 0;
132	elmex	1.1
133	root	1.13	if (buf1)
134			len1 = strlen (buf1);
135			if (buf2)
136			len2 = strlen (buf2);
137			if ((len1 + len2) >= bufsize)
138			return 1;
139			return 0;
140	elmex	1.1	}