[ViewVC] Diff of: cvs/deliantra/server/common/utils.C

Comparing deliantra/server/common/utils.C (file contents):
Revision 1.13 by root, Tue Sep 12 21:10:31 2006 UTC vs.
Revision 1.97 by root, Fri Jul 2 02:00:47 2010 UTC

1	/*	1	/*
2	CrossFire, A Multiplayer game for X-windows	2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3		3	*
4	Copyright (C) 2002 Mark Wedel & Crossfire Development Team	4	* Copyright (©) 2005,2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	Copyright (C) 1992 Frank Tore Johansen	5	*
6		6	* Deliantra is free software: you can redistribute it and/or modify it under
7	This program is free software; you can redistribute it and/or modify
8	it under the terms of the GNU General Public License as published by	7	* the terms of the Affero GNU General Public License as published by the
9	the Free Software Foundation; either version 2 of the License, or	8	* Free Software Foundation, either version 3 of the License, or (at your
10	(at your option) any later version.	9	* option) any later version.
11		10	*
12	This program is distributed in the hope that it will be useful,	11	* This program is distributed in the hope that it will be useful,
13	but WITHOUT ANY WARRANTY; without even the implied warranty of	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	GNU General Public License for more details.	14	* GNU General Public License for more details.
16		15	*
17	You should have received a copy of the GNU General Public License	16	* You should have received a copy of the Affero GNU General Public License
18	along with this program; if not, write to the Free Software	17	* and the GNU General Public License along with this program. If not, see
19	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	18	* <http://www.gnu.org/licenses/>.
20		19	*
21	The authors can be reached via e-mail at crossfire-devel@real-time.com	20	* The authors can be reached via e-mail to <support@deliantra.net>
22	*/	21	*/
23		22
24	/*	23	/*
25	* General convenience functions for crossfire.	24	* General convenience functions for deliantra.
26	*/	25	*/
27		26
		27	#include <cstdlib>
		28	#include <sys/types.h>
		29	#include <unistd.h>
		30	#include <sys/time.h>
		31	#include <time.h>
		32	#include <signal.h>
		33
28	#include <global.h>	34	#include <global.h>
29	#include <funcpoint.h>
30	#include <material.h>	35	#include <material.h>
		36	#include <object.h>
		37
		38	#include <sys/time.h>
		39	#include <sys/resource.h>
31		40
32	#include <glib.h>	41	#include <glib.h>
33		42
34	/*	43	refcnt_base::refcnt_t refcnt_dummy;
35	* The random functions here take luck into account when rolling random	44	ssize_t slice_alloc;
36	* dice or numbers. This function has less of an impact the larger the	45
37	* difference becomes in the random numbers. IE, the effect is lessened	46	#if !GCC_VERSION(3,4)
38	* on a 1-1000 roll, vs a 1-6 roll. This can be used by crafty programmers,	47	int least_significant_bit (uint32_t x)
39	* to specifically disable luck in certain rolls, simply by making the	48	{
40	* numbers larger (ie, 1d1000 > 500 vs 1d6 > 3)	49	x &= -x; // this isolates the lowest bit
		50
		51	int r = 0;
		52
		53	if (x & 0xaaaaaaaa) r += 1;
		54	if (x & 0xcccccccc) r += 2;
		55	if (x & 0xf0f0f0f0) r += 4;
		56	if (x & 0xff00ff00) r += 8;
		57	if (x & 0xffff0000) r += 16;
		58
		59	return r;
		60	}
		61	#endif
		62
		63	/******************************************************************************/
		64
		65	/* Checks a player-provided string which will become the msg property of
		66	* an object for dangerous input.
41	*/	67	*/
		68	bool
		69	msg_is_safe (const char *msg)
		70	{
		71	bool safe = true;
42		72
43	/*	73	/* Trying to cheat by getting data into the object */
44	* Roll a random number between min and max. Uses op to determine luck,	74	if (!strncmp (msg, "endmsg", sizeof ("endmsg") - 1)
45	* and if goodbad is non-zero, luck increases the roll, if zero, it decreases.	75	\|\| strstr (msg, "\nendmsg"))
46	* Generally, op should be the player/caster/hitter requesting the roll,	76	safe = false;
47	* not the recipient (ie, the poor slob getting hit). [garbled 20010916]	77
48	*/	78	/* Trying to make the object talk, and potentially access arbitrary code */
		79	if (object::msg_has_dialogue (msg))
		80	safe = false;
		81
		82	return safe;
		83	}
		84
		85	/////////////////////////////////////////////////////////////////////////////
		86
		87	void
		88	fork_abort (const char *msg)
		89	{
		90	if (!fork ())
		91	{
		92	signal (SIGINT , SIG_IGN);
		93	signal (SIGTERM, SIG_IGN);
		94	signal (SIGABRT, SIG_IGN);
		95
		96	signal (SIGSEGV, SIG_DFL);
		97	signal (SIGBUS , SIG_DFL);
		98	signal (SIGILL , SIG_DFL);
		99	signal (SIGTRAP, SIG_DFL);
		100
		101	// try to put corefiles into a subdirectory, if existing, to allow
		102	// an administrator to reduce the I/O load.
		103	chdir ("cores");
		104
		105	// try to detach us from as many external dependencies as possible
		106	// as coredumping can take time by closing all fd's.
		107	{
		108	struct rlimit lim;
		109
		110	if (getrlimit (RLIMIT_NOFILE, &lim))
		111	lim.rlim_cur = 1024;
		112
		113	for (int i = 0; i < lim.rlim_cur; ++i)
		114	close (i);
		115	}
		116
		117	{
		118	sigset_t empty;
		119	sigemptyset (&empty);
		120	sigprocmask (SIG_SETMASK, &empty, 0);
		121	}
		122
		123	// try to coredump with SIGTRAP
		124	kill (getpid (), SIGTRAP);
		125	abort ();
		126	}
		127
		128	LOG (llevError, "fork abort: %s\n", msg);
		129	}
		130
		131	void *salloc_ (int n) throw (std::bad_alloc)
		132	{
		133	void *ptr = g_slice_alloc (n);
		134
		135	if (!ptr)
		136	throw std::bad_alloc ();
		137
		138	slice_alloc += n;
		139	return ptr;
		140	}
		141
		142	void salloc_ (int n, void src) throw (std::bad_alloc)
		143	{
		144	void *ptr = salloc_ (n);
		145
		146	if (src)
		147	memcpy (ptr, src, n);
		148	else
		149	memset (ptr, 0, n);
		150
		151	return ptr;
		152	}
		153
		154	/******************************************************************************/
		155
		156	#if DEBUG_SALLOC
		157
		158	#define MAGIC 0xa1b2c35543deadLL
		159
		160	void *g_slice_alloc (unsigned long size)
		161	{
		162	unsigned long p = (unsigned long ) (g_slice_alloc)(size + sizeof (unsigned long));
		163	*p++ = size ^ MAGIC;
		164	//fprintf (stderr, "g_slice_alloc %ld %p\n", size, p);//D
		165	return (void *)p;
		166	}
		167
		168	void *g_slice_alloc0 (unsigned long size)
		169	{
		170	return memset (g_slice_alloc (size), 0, size);
		171	}
		172
		173	void g_slice_free1 (unsigned long size, void *ptr)
		174	{
		175	//fprintf (stderr, "g_slice_free %ld %p\n", size, ptr);//D
		176	if (expect_true (ptr))
		177	{
		178	unsigned long p = (unsigned long )ptr;
		179	unsigned long s = *--p ^ MAGIC;
		180
		181	if (size != (unsigned long)(*p ^ MAGIC))
		182	{
		183	LOG (logBacktrace \| llevError, "slice free size (%lx) doesn't match alloc size (%lx)\n", size, s);
		184	abort ();
		185	}
		186
		187	*p = MAGIC;
		188
		189	(g_slice_free1)(s + sizeof (unsigned long), p);
		190	}
		191	}
		192
		193	#endif
		194
		195	/******************************************************************************/
49		196
50	int	197	int
51	random_roll (int min, int max, const object *op, int goodbad)	198	assign (char dst, const char src, int maxsize)
52	{	199	{
53	int omin, diff, luck, base, ran;	200	if (!src)
		201	src = "";
54		202
55	omin = min;	203	int len = strlen (src);
56	diff = max - min + 1;
57	((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */
58		204
59	if (max < 1 \|\| diff < 1)	205	if (len >= maxsize)
60	{	206	{
61	LOG (llevError, "Calling random_roll with min=%d max=%d\n", min, max);	207	if (maxsize <= 4)
62	return (min); /* avoids a float exception */
63	}
64
65	ran = RANDOM ();
66
67	if (op->type != PLAYER)
68	return ((ran % diff) + min);
69
70	luck = op->stats.luck;
71	if (RANDOM () % base < MIN (10, abs (luck)))
72	{
73	/* we have a winner */
74	((luck > 0) ? (luck = 1) : (luck = -1));
75	diff -= luck;
76	if (diff < 1)
77	return (omin); /check again /
78	((goodbad) ? (min += luck) : (diff));
79
80	return (MAX (omin, MIN (max, (ran % diff) + min)));
81	}
82	return ((ran % diff) + min);
83	}
84
85	/*
86	* This is a 64 bit version of random_roll above. This is needed
87	* for exp loss calculations for players changing religions.
88	*/
89
90	sint64
91	random_roll64 (sint64 min, sint64 max, const object *op, int goodbad)
92	{
93	sint64 omin, diff, luck, ran;
94	int base;
95
96	omin = min;
97	diff = max - min + 1;
98	((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */
99
100	if (max < 1 \|\| diff < 1)
101	{
102	#ifndef WIN32
103	LOG (llevError, "Calling random_roll with min=%lld max=%lld\n", min, max);
104	#else
105	LOG (llevError, "Calling random_roll with min=%I64d max=%I64d\n", min, max);
106	#endif
107	return (min); /* avoids a float exception */
108	}
109
110	/* Don't know of a portable call to get 64 bit random values.
111	* So make a call to get two 32 bit random numbers, and just to
112	* a little byteshifting. Do make sure the first one is only
113	* 32 bit, so we don't get skewed results
114	*/
115	ran = (RANDOM () & 0xffffffff) \| ((sint64) RANDOM () << 32);
116
117	if (op->type != PLAYER)
118	return ((ran % diff) + min);
119
120	luck = op->stats.luck;
121	if (RANDOM () % base < MIN (10, abs (luck)))
122	{
123	/* we have a winner */
124	((luck > 0) ? (luck = 1) : (luck = -1));
125	diff -= luck;
126	if (diff < 1)
127	return (omin); /check again /
128	((goodbad) ? (min += luck) : (diff));
129
130	return (MAX (omin, MIN (max, (ran % diff) + min)));
131	}
132	return ((ran % diff) + min);
133	}
134
135	/*
136	* Roll a number of dice (2d3, 4d6). Uses op to determine luck,
137	* If goodbad is non-zero, luck increases the roll, if zero, it decreases.
138	* Generally, op should be the player/caster/hitter requesting the roll,
139	* not the recipient (ie, the poor slob getting hit).
140	* The args are num D size (ie 4d6) [garbled 20010916]
141	*/
142
143	int
144	die_roll (int num, int size, const object *op, int goodbad)
145	{
146	int min, diff, luck, total, i, gotlucky, base, ran;
147
148	diff = size;
149	min = 1;
150	luck = total = gotlucky = 0;
151	((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */
152	if (size < 2 \|\| diff < 1)
153	{
154	LOG (llevError, "Calling die_roll with num=%d size=%d\n", num, size);
155	return (num); /* avoids a float exception */
156	}
157
158	if (op->type == PLAYER)
159	luck = op->stats.luck;
160
161	for (i = 0; i < num; i++)
162	{
163	if (RANDOM () % base < MIN (10, abs (luck)) && !gotlucky)
164	{	208	{
165	/* we have a winner */	209	memset (dst, '.', maxsize - 2);
166	gotlucky++;	210	dst [maxsize - 1] = 0;
167	((luck > 0) ? (luck = 1) : (luck = -1));
168	diff -= luck;
169	if (diff < 1)
170	return (num); /check again /
171	((goodbad) ? (min += luck) : (diff));
172	ran = RANDOM ();
173	total += MAX (1, MIN (size, (ran % diff) + min));
174	}	211	}
175	else	212	else
176	{	213	{
177	total += RANDOM () % size + 1;	214	memcpy (dst, src, maxsize - 4);
		215	memcpy (dst + maxsize - 4, "...", 4);
178	}	216	}
179	}
180	return (total);
181	}
182		217
183	/*	218	len = maxsize;
184	* Another convenience function. Returns a number between min and max.
185	* It is suggested one use these functions rather than RANDOM()%, as it
186	* would appear that a number of off-by-one-errors exist due to improper
187	* use of %. This should also prevent SIGFPE.
188	*/
189
190	int
191	rndm (int min, int max)
192	{
193	int diff;
194
195	diff = max - min + 1;
196	if (max < 1 \|\| diff < 1)
197	return (min);
198
199	return (RANDOM () % diff + min);
200	}
201
202	/* decay and destroy persihable items in a map */
203
204	void
205	decay_objects (mapstruct *m)
206	{
207	int x, y, destroy;
208	object op, otmp;
209
210	if (m->unique)
211	return;
212
213	for (x = 0; x < MAP_WIDTH (m); x++)
214	for (y = 0; y < MAP_HEIGHT (m); y++)
215	for (op = get_map_ob (m, x, y); op; op = otmp)
216	{
217	destroy = 0;
218	otmp = op->above;
219	if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE))
220	break;
221	if (QUERY_FLAG (op, FLAG_IS_FLOOR) \|\|
222	QUERY_FLAG (op, FLAG_OBJ_ORIGINAL) \|\|
223	QUERY_FLAG (op, FLAG_OBJ_SAVE_ON_OVL) \|\|
224	QUERY_FLAG (op, FLAG_UNIQUE) \|\| QUERY_FLAG (op, FLAG_OVERLAY_FLOOR) \|\| QUERY_FLAG (op, FLAG_UNPAID) \|\| IS_LIVE (op))
225	continue;
226	/* otherwise, we decay and destroy */
227	if (IS_WEAPON (op))
228	{
229	op->stats.dam--;
230	if (op->stats.dam < 0)
231	destroy = 1;
232	}
233	else if (IS_ARMOR (op))
234	{
235	op->stats.ac--;
236	if (op->stats.ac < 0)
237	destroy = 1;
238	}
239	else if (op->type == FOOD)
240	{
241	op->stats.food -= rndm (5, 20);
242	if (op->stats.food < 0)
243	destroy = 1;
244	}
245	else
246	{
247	if (op->material & M_PAPER \|\| op->material & M_LEATHER \|\|
248	op->material & M_WOOD \|\| op->material & M_ORGANIC \|\| op->material & M_CLOTH \|\| op->material & M_LIQUID)
249	destroy = 1;
250	if (op->material & M_IRON && rndm (1, 5) == 1)
251	destroy = 1;
252	if (op->material & M_GLASS && rndm (1, 2) == 1)
253	destroy = 1;
254	if ((op->material & M_STONE \|\| op->material & M_ADAMANT) && rndm (1, 10) == 1)
255	destroy = 1;
256	if ((op->material & M_SOFT_METAL \|\| op->material & M_BONE) && rndm (1, 3) == 1)
257	destroy = 1;
258	if (op->material & M_ICE && MAP_TEMP (m) > 32)
259	destroy = 1;
260	}
261	/* adjust overall chance below */
262	if (destroy && rndm (0, 1))
263	{
264	remove_ob (op);
265	free_object (op);
266	}
267	}
268	}
269
270	/* convert materialname to materialtype_t */
271
272	materialtype_t *
273	name_to_material (const char *name)
274	{
275	materialtype_t mt, nmt;
276
277	mt = NULL;
278	for (nmt = materialt; nmt != NULL && nmt->next != NULL; nmt = nmt->next)
279	{
280	if (strcmp (name, nmt->name) == 0)
281	{
282	mt = nmt;
283	break;
284	}
285	}
286	return mt;
287	}
288
289	/* when doing transmutation of objects, we have to recheck the resistances,
290	* as some that did not apply previously, may apply now.
291	*/
292
293	void
294	transmute_materialname (object op, const object change)
295	{
296	materialtype_t *mt;
297	int j;
298
299	if (op->materialname == NULL)
300	return;
301
302	if (change->materialname != NULL && strcmp (op->materialname, change->materialname))
303	return;
304
305	if (!IS_ARMOR (op))
306	return;
307
308	mt = name_to_material (op->materialname);
309	if (!mt)
310	{
311	LOG (llevError, "archetype '%s>%s' uses nonexistent material '%s'\n", &op->arch->name, &op->name, &op->materialname);
312	return;
313	}
314
315	for (j = 0; j < NROFATTACKS; j++)
316	if (op->resist[j] == 0 && change->resist[j] != 0)
317	{
318	op->resist[j] += mt->mod[j];
319	if (op->resist[j] > 100)
320	op->resist[j] = 100;
321	if (op->resist[j] < -100)
322	op->resist[j] = -100;
323	}
324	}
325
326	/* set the materialname and type for an item */
327	void
328	set_materialname (object op, int difficulty, materialtype_t nmt)
329	{
330	materialtype_t mt, lmt;
331
332	#ifdef NEW_MATERIAL_CODE
333	int j;
334	#endif
335
336	if (op->materialname != NULL)
337	return;
338
339
340
341	if (nmt == NULL)
342	{
343	lmt = NULL;
344	#ifndef NEW_MATERIAL_CODE
345	for (mt = materialt; mt != NULL && mt->next != NULL; mt = mt->next)
346	{
347	if (op->material & mt->material)
348	{
349	lmt = mt;
350	break;
351	}
352	}
353
354	#else
355	for (mt = materialt; mt != NULL && mt->next != NULL; mt = mt->next)
356	{
357	if (op->material & mt->material && rndm (1, 100) <= mt->chance &&
358	difficulty >= mt->difficulty && (op->magic >= mt->magic \|\| mt->magic == 0))
359	{
360	lmt = mt;
361	if (!(IS_WEAPON (op) \|\| IS_ARMOR (op)))
362	break;
363	}
364	}
365	#endif
366	}	219	}
367	else	220	else
368	{	221	memcpy (dst, src, ++len);
369	lmt = nmt;
370	}
371		222
372	if (lmt != NULL)	223	return len;
373	{	224	}
374	#ifndef NEW_MATERIAL_CODE	225
375	op->materialname = lmt->name;	226	char *
		227	vformat (const char *format, va_list ap)
		228	{
		229	static dynbuf_text bufs[8];
		230	static int bufidx;
		231
		232	dynbuf_text &buf = bufs [++bufidx & 7];
		233
		234	buf.clear ();
		235	buf.vprintf (format, ap);
		236	return buf;
		237	}
		238
		239	char *
		240	format (const char *format, ...)
		241	{
		242	va_list ap;
		243	va_start (ap, format);
		244	char *buf = vformat (format, ap);
		245	va_end (ap);
		246
		247	return buf;
		248	}
		249
		250	tstamp now ()
		251	{
		252	struct timeval tv;
		253
		254	gettimeofday (&tv, 0);
		255	return tstamp (tv.tv_sec) + tstamp (tv.tv_usec) * tstamp (1e-6);
		256	}
		257
		258	int
		259	similar_direction (int a, int b)
		260	{
		261	if (!a \|\| !b)
376	return;	262	return 0;
377	#else
378		263
379	if (op->stats.dam && IS_WEAPON (op))	264	int diff = (b - a) & 7;
380	{	265	return diff <= 1 \|\| diff >= 7;
381	op->stats.dam += lmt->damage;	266	}
382	if (op->stats.dam < 1)	267
383	op->stats.dam = 1;	268	/* crc32 0xdebb20e3 table and supplementary functions. */
384	}	269	extern const uint32_t crc_32_tab[256] =
385	if (op->stats.sp && op->type == BOW)	270	{
386	op->stats.sp += lmt->sp;	271	0x00000000UL, 0x77073096UL, 0xee0e612cUL, 0x990951baUL, 0x076dc419UL,
387	if (op->stats.wc && IS_WEAPON (op))	272	0x706af48fUL, 0xe963a535UL, 0x9e6495a3UL, 0x0edb8832UL, 0x79dcb8a4UL,
388	op->stats.wc += lmt->wc;	273	0xe0d5e91eUL, 0x97d2d988UL, 0x09b64c2bUL, 0x7eb17cbdUL, 0xe7b82d07UL,
389	if (IS_ARMOR (op))	274	0x90bf1d91UL, 0x1db71064UL, 0x6ab020f2UL, 0xf3b97148UL, 0x84be41deUL,
390	{	275	0x1adad47dUL, 0x6ddde4ebUL, 0xf4d4b551UL, 0x83d385c7UL, 0x136c9856UL,
391	if (op->stats.ac)	276	0x646ba8c0UL, 0xfd62f97aUL, 0x8a65c9ecUL, 0x14015c4fUL, 0x63066cd9UL,
392	op->stats.ac += lmt->ac;	277	0xfa0f3d63UL, 0x8d080df5UL, 0x3b6e20c8UL, 0x4c69105eUL, 0xd56041e4UL,
393	for (j = 0; j < NROFATTACKS; j++)	278	0xa2677172UL, 0x3c03e4d1UL, 0x4b04d447UL, 0xd20d85fdUL, 0xa50ab56bUL,
394	if (op->resist[j] != 0)	279	0x35b5a8faUL, 0x42b2986cUL, 0xdbbbc9d6UL, 0xacbcf940UL, 0x32d86ce3UL,
395	{	280	0x45df5c75UL, 0xdcd60dcfUL, 0xabd13d59UL, 0x26d930acUL, 0x51de003aUL,
396	op->resist[j] += lmt->mod[j];	281	0xc8d75180UL, 0xbfd06116UL, 0x21b4f4b5UL, 0x56b3c423UL, 0xcfba9599UL,
397	if (op->resist[j] > 100)	282	0xb8bda50fUL, 0x2802b89eUL, 0x5f058808UL, 0xc60cd9b2UL, 0xb10be924UL,
398	op->resist[j] = 100;	283	0x2f6f7c87UL, 0x58684c11UL, 0xc1611dabUL, 0xb6662d3dUL, 0x76dc4190UL,
399	if (op->resist[j] < -100)	284	0x01db7106UL, 0x98d220bcUL, 0xefd5102aUL, 0x71b18589UL, 0x06b6b51fUL,
400	op->resist[j] = -100;	285	0x9fbfe4a5UL, 0xe8b8d433UL, 0x7807c9a2UL, 0x0f00f934UL, 0x9609a88eUL,
401	}	286	0xe10e9818UL, 0x7f6a0dbbUL, 0x086d3d2dUL, 0x91646c97UL, 0xe6635c01UL,
402	}	287	0x6b6b51f4UL, 0x1c6c6162UL, 0x856530d8UL, 0xf262004eUL, 0x6c0695edUL,
403	op->materialname = add_string (lmt->name);	288	0x1b01a57bUL, 0x8208f4c1UL, 0xf50fc457UL, 0x65b0d9c6UL, 0x12b7e950UL,
404	/* dont make it unstackable if it doesn't need to be */	289	0x8bbeb8eaUL, 0xfcb9887cUL, 0x62dd1ddfUL, 0x15da2d49UL, 0x8cd37cf3UL,
405	if (IS_WEAPON (op) \|\| IS_ARMOR (op))	290	0xfbd44c65UL, 0x4db26158UL, 0x3ab551ceUL, 0xa3bc0074UL, 0xd4bb30e2UL,
406	{	291	0x4adfa541UL, 0x3dd895d7UL, 0xa4d1c46dUL, 0xd3d6f4fbUL, 0x4369e96aUL,
407	op->weight = (op->weight * lmt->weight) / 100;	292	0x346ed9fcUL, 0xad678846UL, 0xda60b8d0UL, 0x44042d73UL, 0x33031de5UL,
408	op->value = (op->value * lmt->value) / 100;	293	0xaa0a4c5fUL, 0xdd0d7cc9UL, 0x5005713cUL, 0x270241aaUL, 0xbe0b1010UL,
409	}	294	0xc90c2086UL, 0x5768b525UL, 0x206f85b3UL, 0xb966d409UL, 0xce61e49fUL,
		295	0x5edef90eUL, 0x29d9c998UL, 0xb0d09822UL, 0xc7d7a8b4UL, 0x59b33d17UL,
		296	0x2eb40d81UL, 0xb7bd5c3bUL, 0xc0ba6cadUL, 0xedb88320UL, 0x9abfb3b6UL,
		297	0x03b6e20cUL, 0x74b1d29aUL, 0xead54739UL, 0x9dd277afUL, 0x04db2615UL,
		298	0x73dc1683UL, 0xe3630b12UL, 0x94643b84UL, 0x0d6d6a3eUL, 0x7a6a5aa8UL,
		299	0xe40ecf0bUL, 0x9309ff9dUL, 0x0a00ae27UL, 0x7d079eb1UL, 0xf00f9344UL,
		300	0x8708a3d2UL, 0x1e01f268UL, 0x6906c2feUL, 0xf762575dUL, 0x806567cbUL,
		301	0x196c3671UL, 0x6e6b06e7UL, 0xfed41b76UL, 0x89d32be0UL, 0x10da7a5aUL,
		302	0x67dd4accUL, 0xf9b9df6fUL, 0x8ebeeff9UL, 0x17b7be43UL, 0x60b08ed5UL,
		303	0xd6d6a3e8UL, 0xa1d1937eUL, 0x38d8c2c4UL, 0x4fdff252UL, 0xd1bb67f1UL,
		304	0xa6bc5767UL, 0x3fb506ddUL, 0x48b2364bUL, 0xd80d2bdaUL, 0xaf0a1b4cUL,
		305	0x36034af6UL, 0x41047a60UL, 0xdf60efc3UL, 0xa867df55UL, 0x316e8eefUL,
		306	0x4669be79UL, 0xcb61b38cUL, 0xbc66831aUL, 0x256fd2a0UL, 0x5268e236UL,
		307	0xcc0c7795UL, 0xbb0b4703UL, 0x220216b9UL, 0x5505262fUL, 0xc5ba3bbeUL,
		308	0xb2bd0b28UL, 0x2bb45a92UL, 0x5cb36a04UL, 0xc2d7ffa7UL, 0xb5d0cf31UL,
		309	0x2cd99e8bUL, 0x5bdeae1dUL, 0x9b64c2b0UL, 0xec63f226UL, 0x756aa39cUL,
		310	0x026d930aUL, 0x9c0906a9UL, 0xeb0e363fUL, 0x72076785UL, 0x05005713UL,
		311	0x95bf4a82UL, 0xe2b87a14UL, 0x7bb12baeUL, 0x0cb61b38UL, 0x92d28e9bUL,
		312	0xe5d5be0dUL, 0x7cdcefb7UL, 0x0bdbdf21UL, 0x86d3d2d4UL, 0xf1d4e242UL,
		313	0x68ddb3f8UL, 0x1fda836eUL, 0x81be16cdUL, 0xf6b9265bUL, 0x6fb077e1UL,
		314	0x18b74777UL, 0x88085ae6UL, 0xff0f6a70UL, 0x66063bcaUL, 0x11010b5cUL,
		315	0x8f659effUL, 0xf862ae69UL, 0x616bffd3UL, 0x166ccf45UL, 0xa00ae278UL,
		316	0xd70dd2eeUL, 0x4e048354UL, 0x3903b3c2UL, 0xa7672661UL, 0xd06016f7UL,
		317	0x4969474dUL, 0x3e6e77dbUL, 0xaed16a4aUL, 0xd9d65adcUL, 0x40df0b66UL,
		318	0x37d83bf0UL, 0xa9bcae53UL, 0xdebb9ec5UL, 0x47b2cf7fUL, 0x30b5ffe9UL,
		319	0xbdbdf21cUL, 0xcabac28aUL, 0x53b39330UL, 0x24b4a3a6UL, 0xbad03605UL,
		320	0xcdd70693UL, 0x54de5729UL, 0x23d967bfUL, 0xb3667a2eUL, 0xc4614ab8UL,
		321	0x5d681b02UL, 0x2a6f2b94UL, 0xb40bbe37UL, 0xc30c8ea1UL, 0x5a05df1bUL,
		322	0x2d02ef8dL
		323	};
		324
		325	void thread::start (void (start_routine)(void ), void arg)
		326	{
		327	pthread_attr_t attr;
		328
		329	pthread_attr_init (&attr);
		330	pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
		331	pthread_attr_setstacksize (&attr, PTHREAD_STACK_MIN < sizeof (long) * 4096
		332	? sizeof (long) * 4096 : PTHREAD_STACK_MIN);
		333	#ifdef PTHREAD_SCOPE_PROCESS
		334	pthread_attr_setscope (&attr, PTHREAD_SCOPE_PROCESS);
410	#endif	335	#endif
411	}
412	}
413		336
414	/*	337	sigset_t fullsigset, oldsigset;
415	* Strip out the media tags from a String.	338	sigfillset (&fullsigset);
416	* Warning the input string will contain the result string
417	*/
418	void
419	strip_media_tag (char *message)
420	{
421	int in_tag = 0;
422	char *dest;
423	char *src;
424		339
425	src = dest = message;	340	pthread_sigmask (SIG_SETMASK, &fullsigset, &oldsigset);
426	while (*src != '\0')
427	{
428	if (*src == '[')
429	{
430	in_tag = 1;
431	}
432	else if (in_tag && (*src == ']'))
433	in_tag = 0;
434	else if (!in_tag)
435	{
436	dest = src;
437	dest++;
438	}
439	src++;
440	}
441	*dest = '\0';
442	}
443		341
444	const char *	342	if (pthread_create (&id, &attr, start_routine, arg))
445	strrstr (const char haystack, const char needle)	343	cleanup ("unable to create a new thread");
446	{
447	const char *lastneedle;
448		344
449	lastneedle = NULL;	345	pthread_sigmask (SIG_SETMASK, &oldsigset, 0);
450	while ((haystack = strstr (haystack, needle)) != NULL)
451	{
452	lastneedle = haystack;
453	haystack++;
454	}
455	return lastneedle;
456
457	}	346	}
458		347
459	#define EOL_SIZE (sizeof("\n")-1)
460	void
461	strip_endline (char *buf)
462	{
463	if (strlen (buf) < sizeof ("\n"))
464	{
465	return;
466	}
467	if (!strcmp (buf + strlen (buf) - EOL_SIZE, "\n"))
468	buf[strlen (buf) - EOL_SIZE] = '\0';
469	}
470
471	/**
472	* Replace in string src all occurrences of key by replacement. The resulting
473	* string is put into result; at most resultsize characters (including the
474	* terminating null character) will be written to result.
475	*/
476	void
477	replace (const char src, const char key, const char replacement, char result, size_t resultsize)
478	{
479	size_t resultlen;
480	size_t keylen;
481
482	/* special case to prevent infinite loop if key==replacement=="" */
483	if (strcmp (key, replacement) == 0)
484	{
485	snprintf (result, resultsize, "%s", src);
486	return;
487	}
488
489	keylen = strlen (key);
490
491	resultlen = 0;
492	while (*src != '\0' && resultlen + 1 < resultsize)
493	{
494	if (strncmp (src, key, keylen) == 0)
495	{
496	snprintf (result + resultlen, resultsize - resultlen, "%s", replacement);
497	resultlen += strlen (result + resultlen);
498	src += keylen;
499	}
500	else
501	{
502	result[resultlen++] = *src++;
503	}
504	}
505	result[resultlen] = '\0';
506	}
507
508	/**
509	* Taking a string as an argument, mutate it into a string that looks like a list.
510	* a 'list' for the purposes here, is a string of items, seperated by commas, except
511	* for the last entry, which has an 'and' before it, and a full stop (period) after it.
512	* This function will also strip all trailing non alphanumeric characters.
513	* It does not insert an oxford comma.
514	*/
515
516	void
517	make_list_like (char *input)
518	{
519	char *p, tmp[MAX_BUF];
520	int i;
521
522	if (!input \|\| strlen (input) > MAX_BUF - 5)
523	return;
524	/* bad stuff would happen if we continued here, the -5 is to make space for ' and ' */
525
526	strncpy (tmp, input, MAX_BUF - 5);
527	/trim all trailing commas, spaces etc. /
528	for (i = strlen (tmp); !isalnum (tmp[i]) && i >= 0; i--)
529	tmp[i] = '\0';
530
531	strcat (tmp, ".");
532
533	p = strrchr (tmp, ',');
534	if (p)
535	{
536	*p = '\0';
537	strcpy (input, tmp);
538	p++;
539	strcat (input, " and");
540	strcat (input, p);
541	}
542	else
543	strcpy (input, tmp);
544
545	return;
546	}
547
548	void *alloc (int s) throw (std::bad_alloc)
549	{
550	void *p = g_slice_alloc (s);
551
552	if (!p)
553	throw std::bad_alloc ();
554
555	return p;
556	}
557
558	void assign (char dst, const char src, int maxlen)
559	{
560	if (!src)
561	src = "";
562
563	int len = strlen (src);
564
565	if (len >= maxlen - 1)
566	{
567	if (maxlen <= 4)
568	{
569	memset (dst, '.', maxlen - 1);
570	dst [maxlen - 1] = 0;
571	}
572	else
573	{
574	memcpy (dst, src, maxlen - 4);
575	memcpy (dst + maxlen - 4, "...", 4);
576	}
577	}
578	else
579	memcpy (dst, src, len + 1);
580	}
581

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing deliantra/server/common/utils.C (file contents): Revision 1.13 by root, Tue Sep 12 21:10:31 2006 UTC vs. Revision 1.97 by root, Fri Jul 2 02:00:47 2010 UTC

Diff Legend

Comparing deliantra/server/common/utils.C (file contents):
Revision 1.13 by root, Tue Sep 12 21:10:31 2006 UTC vs.
Revision 1.97 by root, Fri Jul 2 02:00:47 2010 UTC