server/common/shstr.C

/*
 * This file is part of Crossfire TRT, the Roguelike Realtime MORPG.
 * 
 * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
 * 
 * Crossfire TRT 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 <crossfire@schmorp.de>
 */

/*
 * shstr.C
 */

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

#include "global.h"

typedef std::tr1::unordered_set <const char *, str_hash, str_equal, slice_allocator<const char *>, true> 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;
}

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

  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 ()
{
  static const char *curpos;

  auto (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))
        {
          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));
          g_slice_free1 (sizeof (int) * 2 + length (s) + 1, -2 + (int *) s);
        }
      else
        ++i;
    }

  curpos = *i;
}

shstr skill_names[NUM_SKILLS];

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

//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.24
Committed:	Sun Jul 1 05:00:18 2007 UTC (16 years, 11 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.23:	+11 -12 lines
Log Message:	- upgrade crossfire trt to the GPL version 3 (hopefully correctly). - add a single file covered by the GNU Affero General Public License (which is not yet released, so I used the current draft, which is legally a bit wavy, but its likely better than nothing as it expresses direct intent by the authors, and we can upgrade as soon as it has been released). * this should ensure availability of source code for the server at least and hopefully also archetypes and maps even when modified versions are not being distributed, in accordance of section 13 of the agplv3.
#	User	Rev	Content
1	elmex	1.1	/*
2	root	1.24	* This file is part of Crossfire TRT, the Roguelike Realtime MORPG.
3	root	1.23	*
4			* Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
5			*
6	root	1.24	* Crossfire TRT 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	root	1.23	*
11	root	1.24	* 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	root	1.23	*
16	root	1.24	* 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	root	1.23	*
19			* The authors can be reached via e-mail to <crossfire@schmorp.de>
20	root	1.22	*/
21
22			/*
23	root	1.3	* shstr.C
24	elmex	1.1	*/
25
26	root	1.3	#include <cstring>
27			#include <cstdlib>
28	root	1.10	#include <glib.h>
29	root	1.3	#include <tr1/unordered_set>
30	elmex	1.1
31	root	1.16	#include "global.h"
32	elmex	1.1
33	root	1.18	typedef std::tr1::unordered_set <const char , str_hash, str_equal, slice_allocator<const char >, true> HT;
34	elmex	1.1
35	root	1.16	static HT ht;
36	elmex	1.1
37	root	1.13	static const char *
38			makevec (const char *s)
39	root	1.7	{
40	root	1.17	int len = strlen (s);
41	root	1.7
42	root	1.18	const char v = (const char ) (2 + (int )g_slice_alloc (sizeof (int) 2 + len + 1));
43	root	1.7
44			shstr::length (v) = len;
45			shstr::refcnt (v) = 1;
46
47	root	1.13	memcpy ((char *) v, s, len + 1);
48	root	1.7
49	root	1.8	return v;
50	root	1.7	}
51
52	root	1.17	static const char *
53			makenull ()
54			{
55			const char *s = makevec ("(null)");
56			shstr::length (s) = 0;
57			return s;
58			}
59
60			const char *shstr::null = makenull ();
61	root	1.15
62	elmex	1.1	const char *
63	root	1.3	shstr::find (const char *s)
64			{
65	root	1.4	if (!s)
66			return s;
67
68	root	1.21	auto (i, ht.find (s));
69	elmex	1.1
70	root	1.13	return i != ht.end ()? *i : 0;
71	elmex	1.1	}
72
73			const char *
74	root	1.3	shstr::intern (const char *s)
75			{
76	root	1.4	if (!s)
77	root	1.7	return null;
78	elmex	1.1
79	root	1.4	if (const char *found = find (s))
80	root	1.5	{
81			++refcnt (found);
82			return found;
83			}
84	elmex	1.1
85	root	1.7	s = makevec (s);
86			ht.insert (s);
87			return s;
88	elmex	1.1	}
89
90	root	1.5	// periodically test refcounts == 0 for a few strings
91			// this is the ONLY thing that erases stuff from ht. keep it that way.
92	elmex	1.1	void
93	root	1.3	shstr::gc ()
94			{
95	root	1.5	static const char *curpos;
96
97	root	1.21	auto (i, curpos ? ht.find (curpos) : ht.begin ());
98	root	1.5
99			if (i == ht.end ())
100			i = ht.begin ();
101
102			// go through all strings roughly once every 4 minutes
103	root	1.11	int n = ht.size () / 256 + 16;
104	root	1.6
105			for (;;)
106	root	1.5	{
107			if (i == ht.end ())
108			{
109			curpos = 0;
110			return;
111			}
112	root	1.6	else if (!--n)
113			break;
114			else if (!refcnt (*i))
115	root	1.5	{
116	root	1.21	auto (o, i++);
117	root	1.5	const char s = o;
118	root	1.13
119	root	1.5	ht.erase (o);
120
121			//printf ("GC %4d %3d %d >%s<%d\n", (int)ht.size (), n, shstr::refcnt (s), s, shstr::length (s));
122	root	1.13	g_slice_free1 (sizeof (int) * 2 + length (s) + 1, -2 + (int *) s);
123	root	1.5	}
124			else
125			++i;
126			}
127
128			curpos = *i;
129	elmex	1.1	}
130
131	root	1.16	shstr skill_names[NUM_SKILLS];
132
133			// what weird misoptimisation is this again?
134			const shstr undead_name ("undead");
135
136	root	1.5	//TODO: this should of course not be here
137	root	1.13
138	elmex	1.1	/* buf_overflow() - we don't want to exceed the buffer size of
139			* buf1 by adding on buf2! Returns true if overflow will occur.
140			*/
141	root	1.13	int
142	elmex	1.1	buf_overflow (const char buf1, const char buf2, int bufsize)
143			{
144	root	1.13	int len1 = 0, len2 = 0;
145	elmex	1.1
146	root	1.13	if (buf1)
147			len1 = strlen (buf1);
148			if (buf2)
149			len2 = strlen (buf2);
150			if ((len1 + len2) >= bufsize)
151			return 1;
152	root	1.22
153	root	1.13	return 0;
154	elmex	1.1	}