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

Comparing deliantra/server/common/utils.C (file contents):
Revision 1.51 by root, Mon Apr 23 18:09:57 2007 UTC vs.
Revision 1.83 by root, Sun Dec 28 06:59:26 2008 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) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team	4	* Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (C) 2002 Mark Wedel & Crossfire Development Team	5	* Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
6	* Copyright (C) 1992 Frank Tore Johansen	6	* Copyright (©) 1992,2007 Frank Tore Johansen
7	*	7	*
8	* This program is free software; you can redistribute it and/or modify	8	* Deliantra is free software: you can redistribute it and/or modify
9	* it under the terms of the GNU General Public License as published by	9	* it under the terms of the GNU General Public License as published by
10	* the Free Software Foundation; either version 2 of the License, or	10	* the Free Software Foundation, either version 3 of the License, or
11	* (at your option) any later version.	11	* (at your option) any later version.
12	*	12	*
13	* This program is distributed in the hope that it will be useful,	13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.	16	* GNU General Public License for more details.
17	*	17	*
18	* You should have received a copy of the GNU General Public License	18	* You should have received a copy of the GNU General Public License
19	* along with this program; if not, write to the Free Software	19	* along with this program. If not, see <http://www.gnu.org/licenses/>.
20	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21	*	20	*
22	* The authors can be reached via e-mail at <crossfire@schmorp.de>	21	* The authors can be reached via e-mail to <support@deliantra.net>
23	*/	22	*/
24		23
25	/*	24	/*
26	* General convenience functions for crossfire.	25	* General convenience functions for crossfire.
27	*/	26	*/
32	#include <sys/time.h>	31	#include <sys/time.h>
33	#include <time.h>	32	#include <time.h>
34	#include <signal.h>	33	#include <signal.h>
35		34
36	#include <global.h>	35	#include <global.h>
37	#include <funcpoint.h>
38	#include <material.h>	36	#include <material.h>
39		37
		38	#include <sys/time.h>
		39	#include <sys/resource.h>
		40
40	#include <glib.h>	41	#include <glib.h>
41		42
42	rand_gen rndm;	43	refcnt_base::refcnt_t refcnt_dummy;
		44	ssize_t slice_alloc;
		45	rand_gen rndm, rmg_rndm;
43		46
44	void	47	void
45	tausworthe_random_generator::seed (uint32_t seed)	48	tausworthe_random_generator::seed (uint32_t seed)
46	{	49	{
47	state [0] = seed * 69069U; if (state [0] < 2U) state [0] += 2U;	50	state [0] = seed * 69069U; if (state [0] < 2U) state [0] += 2U;
48	state [1] = state [0] * 69069U; if (state [0] < 8U) state [0] += 8U;	51	state [1] = state [0] * 69069U; if (state [0] < 8U) state [0] += 8U;
49	state [2] = state [1] * 69069U; if (state [0] < 16U) state [0] += 16U;	52	state [2] = state [1] * 69069U; if (state [0] < 16U) state [0] += 16U;
50	state [3] = state [2] * 69069U; if (state [0] < 128) state [0] += 128U;	53	state [3] = state [2] * 69069U; if (state [0] < 128U) state [0] += 128U;
51		54
52	for (int i = 11; --i; )	55	for (int i = 11; --i; )
53	operator ()();	56	operator ()();
54	}	57	}
55		58
…		…
93	* not the recipient (ie, the poor slob getting hit). [garbled 20010916]	96	* not the recipient (ie, the poor slob getting hit). [garbled 20010916]
94	*/	97	*/
95	int	98	int
96	random_roll (int r_min, int r_max, const object *op, int goodbad)	99	random_roll (int r_min, int r_max, const object *op, int goodbad)
97	{	100	{
		101	r_max = max (r_min, r_max);
		102
98	int base = r_max - r_min > 1 ? 20 : 50; /* d2 and d3 are corner cases */	103	int base = r_max - r_min > 1 ? 20 : 50; /* d2 and d3 are corner cases */
99
100	if (r_max < 1 \|\| r_max < r_min)
101	{
102	LOG (llevError, "Calling random_roll with min=%d max=%d\n", r_min, r_max);
103	return r_min;
104	}
105		104
106	if (op->type == PLAYER)	105	if (op->type == PLAYER)
107	{	106	{
108	int luck = op->stats.luck;	107	int luck = op->stats.luck;
109		108
…		…
119	/*	118	/*
120	* This is a 64 bit version of random_roll above. This is needed	119	* This is a 64 bit version of random_roll above. This is needed
121	* for exp loss calculations for players changing religions.	120	* for exp loss calculations for players changing religions.
122	*/	121	*/
123	sint64	122	sint64
124	random_roll64 (sint64 min, sint64 max, const object *op, int goodbad)	123	random_roll64 (sint64 r_min, sint64 r_max, const object *op, int goodbad)
125	{	124	{
126	sint64 omin, diff, luck, ran;	125	sint64 omin = r_min;
127	int base;	126	sint64 range = max (0, r_max - r_min + 1);
128		127	int base = range > 2 ? 20 : 50; /* d2 and d3 are corner cases */
129	omin = min;
130	diff = max - min + 1;
131	((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */
132
133	if (max < 1 \|\| diff < 1)
134	{
135	LOG (llevError, "Calling random_roll with min=%" PRId64 " max=%" PRId64 "\n", min, max);
136	return (min); /* avoids a float exception */
137	}
138		128
139	/*	129	/*
140	* Make a call to get two 32 bit unsigned random numbers, and just to	130	* Make a call to get two 32 bit unsigned random numbers, and just to
141	* a little bitshifting.	131	* a little bitshifting.
142	*/	132	*/
143	ran = (sint64) rndm.next () ^ ((sint64) rndm.next () << 31);	133	sint64 ran = (sint64) rndm.next () ^ ((sint64) rndm.next () << 31);
144		134
145	if (op->type != PLAYER)	135	if (op->type != PLAYER)
146	return ((ran % diff) + min);	136	return ((ran % range) + r_min);
147		137
148	luck = op->stats.luck;	138	int luck = op->stats.luck;
		139
149	if (rndm (base) < MIN (10, abs (luck)))	140	if (rndm (base) < min (10, abs (luck)))
150	{	141	{
151	/* we have a winner */	142	/* we have a winner */
152	((luck > 0) ? (luck = 1) : (luck = -1));	143	((luck > 0) ? (luck = 1) : (luck = -1));
153	diff -= luck;	144	range -= luck;
154	if (diff < 1)	145	if (range < 1)
155	return (omin); /check again /	146	return (omin); /check again /
		147
156	((goodbad) ? (min += luck) : (diff));	148	((goodbad) ? (r_min += luck) : (range));
157		149
158	return (MAX (omin, MIN (max, (ran % diff) + min)));	150	return (max (omin, min (r_max, (ran % range) + r_min)));
159	}	151	}
160		152
161	return ((ran % diff) + min);	153	return ran % range + r_min;
162	}	154	}
163		155
164	/*	156	/*
165	* Roll a number of dice (2d3, 4d6). Uses op to determine luck,	157	* Roll a number of dice (2d3, 4d6). Uses op to determine luck,
166	* If goodbad is non-zero, luck increases the roll, if zero, it decreases.	158	* If goodbad is non-zero, luck increases the roll, if zero, it decreases.
167	* Generally, op should be the player/caster/hitter requesting the roll,	159	* Generally, op should be the player/caster/hitter requesting the roll,
168	* not the recipient (ie, the poor slob getting hit).	160	* not the recipient (ie, the poor slob getting hit).
169	* The args are num D size (ie 4d6) [garbled 20010916]	161	* The args are num D size (ie 4d6) [garbled 20010916]
170	*/	162	*/
171
172	int	163	int
173	die_roll (int num, int size, const object *op, int goodbad)	164	die_roll (int num, int size, const object *op, int goodbad)
174	{	165	{
175	int min, diff, luck, total, i, gotlucky, base;	166	int min, luck, total, i, gotlucky;
176		167
177	diff = size;	168	int diff = size;
178	min = 1;	169	min = 1;
179	luck = total = gotlucky = 0;	170	luck = total = gotlucky = 0;
180	((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */	171	int base = diff > 2 ? 20 : 50; /* d2 and d3 are corner cases */
		172
181	if (size < 2 \|\| diff < 1)	173	if (size < 2 \|\| diff < 1)
182	{	174	{
183	LOG (llevError, "Calling die_roll with num=%d size=%d\n", num, size);	175	LOG (llevError, "Calling die_roll with num=%d size=%d\n", num, size);
184	return (num); /* avoids a float exception */	176	return num; /* avoids a float exception */
185	}	177	}
186		178
187	if (op->type == PLAYER)	179	if (op->type == PLAYER)
188	luck = op->stats.luck;	180	luck = op->stats.luck;
189		181
…		…
205	}	197	}
206		198
207	return total;	199	return total;
208	}	200	}
209		201
210	/* decay and destroy perishable items in a map */
211	void
212	maptile::decay_objects ()
213	{
214	if (!spaces)
215	return;
216
217	for (mapspace *ms = spaces + size (); ms-- > spaces; )
218	for (object above, op = ms->bot; op; op = above)
219	{
220	above = op->above;
221
222	bool destroy = 0;
223
224	// do not decay anything above unique floor tiles (yet :)
225	if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE))
226	break;
227
228	if (QUERY_FLAG (op, FLAG_IS_FLOOR)
229	\|\| QUERY_FLAG (op, FLAG_OBJ_ORIGINAL)
230	\|\| QUERY_FLAG (op, FLAG_OBJ_SAVE_ON_OVL)
231	\|\| QUERY_FLAG (op, FLAG_UNIQUE)
232	\|\| QUERY_FLAG (op, FLAG_OVERLAY_FLOOR)
233	\|\| QUERY_FLAG (op, FLAG_UNPAID)
234	\|\| op->is_alive ())
235	; // do not decay
236	else if (op->is_weapon ())
237	{
238	op->stats.dam--;
239	if (op->stats.dam < 0)
240	destroy = 1;
241	}
242	else if (op->is_armor ())
243	{
244	op->stats.ac--;
245	if (op->stats.ac < 0)
246	destroy = 1;
247	}
248	else if (op->type == FOOD)
249	{
250	op->stats.food -= rndm (5, 20);
251	if (op->stats.food < 0)
252	destroy = 1;
253	}
254	else
255	{
256	int mat = op->materials;
257
258	if (mat & M_PAPER
259	\|\| mat & M_LEATHER
260	\|\| mat & M_WOOD
261	\|\| mat & M_ORGANIC
262	\|\| mat & M_CLOTH
263	\|\| mat & M_LIQUID
264	\|\| (mat & M_IRON && rndm (1, 5) == 1)
265	\|\| (mat & M_GLASS && rndm (1, 2) == 1)
266	\|\| ((mat & M_STONE \|\| mat & M_ADAMANT) && rndm (1, 10) == 1)
267	\|\| ((mat & M_SOFT_METAL \|\| mat & M_BONE) && rndm (1, 3) == 1)
268	\|\| (mat & M_ICE && temp > 32))
269	destroy = 1;
270	}
271
272	/* adjust overall chance below */
273	if (destroy && rndm (0, 1))
274	op->destroy ();
275	}
276	}
277
278	/* convert materialname to materialtype_t */	202	/* convert materialname to materialtype_t */
279		203
280	materialtype_t *	204	materialtype_t *
281	name_to_material (const shstr &name)	205	name_to_material (const shstr_cmp name)
282	{	206	{
283	for (materialtype_t *mt = materialt; mt && mt->next; mt = mt->next)	207	for (materialtype_t *mt = materialt; mt; mt = mt->next)
284	if (name == mt->name)	208	if (name == mt->name)
285	return mt;	209	return mt;
286		210
287	return materialt;	211	return 0;
288	}	212	}
289		213
290	/* when doing transmutation of objects, we have to recheck the resistances,	214	/* when doing transmutation of objects, we have to recheck the resistances,
291	* as some that did not apply previously, may apply now.	215	* as some that did not apply previously, may apply now.
292	*/	216	*/
293
294	void	217	void
295	transmute_materialname (object op, const object change)	218	transmute_materialname (object op, const object change)
296	{	219	{
297	materialtype_t *mt;	220	materialtype_t *mt;
298	int j;	221	int j;
299		222
300	if (op->materialname == NULL)	223	if (!op->materialname)
301	return;	224	return;
302		225
303	if (change->materialname != NULL && strcmp (op->materialname, change->materialname))	226	if (change->materialname && strcmp (op->materialname, change->materialname))
304	return;	227	return;
305		228
306	if (!op->is_armor ())	229	if (!op->is_armor ())
307	return;	230	return;
308		231
309	mt = name_to_material (op->materialname);	232	mt = name_to_material (op->materialname);
310	if (!mt)	233	if (!mt)
311	{	234	{
312	LOG (llevError, "archetype '%s>%s' uses nonexistent material '%s'\n", &op->arch->name, &op->name, &op->materialname);	235	LOG (llevError, "archetype '%s>%s' uses nonexistent material '%s'\n", &op->arch->archname, &op->name, &op->materialname);
313	return;	236	return;
314	}	237	}
315		238
316	for (j = 0; j < NROFATTACKS; j++)	239	for (j = 0; j < NROFATTACKS; j++)
317	if (op->resist[j] == 0 && change->resist[j] != 0)	240	if (op->resist[j] == 0 && change->resist[j] != 0)
…		…
328	void	251	void
329	set_materialname (object op, int difficulty, materialtype_t nmt)	252	set_materialname (object op, int difficulty, materialtype_t nmt)
330	{	253	{
331	materialtype_t mt, lmt;	254	materialtype_t mt, lmt;
332		255
333	#ifdef NEW_MATERIAL_CODE
334	int j;
335	#endif
336
337	if (op->materialname != NULL)	256	if (!op->materialname)
338	return;	257	return;
339		258
340		259	if (nmt)
341		260	lmt = nmt;
342	if (nmt == NULL)	261	else
343	{	262	{
344	lmt = NULL;	263	lmt = 0;
345	#ifndef NEW_MATERIAL_CODE	264
346	for (mt = materialt; mt && mt->next; mt = mt->next)	265	for (mt = materialt; mt; mt = mt->next)
347	{	266	if (op->materials & mt->material && rndm (1, 100) <= mt->chance &&
348	if (op->materials & mt->material)	267	difficulty >= mt->difficulty && (op->magic >= mt->magic \|\| mt->magic == 0))
349	{	268	{
350	lmt = mt;	269	lmt = mt;
		270	if (!(op->is_weapon () \|\| op->is_armor ()))
351	break;	271	break;
352	}	272	}
353	}
354
355	#else
356	for (mt = materialt; mt && mt->next; mt = mt->next)
357	{
358	if (op->materials & mt->material && rndm (1, 100) <= mt->chance &&
359	difficulty >= mt->difficulty && (op->magic >= mt->magic \|\| mt->magic == 0))
360	{
361	lmt = mt;
362	if (!(op->is_weapon () \|\| op->is_armor ()))
363	break;
364	}
365	}
366	#endif
367	}
368	else
369	{	273	}
370	lmt = nmt;	274
		275	if (lmt)
371	}	276	{
372
373	if (lmt != NULL)
374	{
375	#ifndef NEW_MATERIAL_CODE
376	op->materialname = lmt->name;
377	return;
378	#else
379
380	if (op->stats.dam && op->is_weapon ())	277	if (op->stats.dam && op->is_weapon ())
381	{	278	{
382	op->stats.dam += lmt->damage;	279	op->stats.dam += lmt->damage;
383	if (op->stats.dam < 1)	280	if (op->stats.dam < 1)
384	op->stats.dam = 1;	281	op->stats.dam = 1;
…		…
390	op->stats.wc += lmt->wc;	287	op->stats.wc += lmt->wc;
391	if (op->is_armor ())	288	if (op->is_armor ())
392	{	289	{
393	if (op->stats.ac)	290	if (op->stats.ac)
394	op->stats.ac += lmt->ac;	291	op->stats.ac += lmt->ac;
		292
395	for (j = 0; j < NROFATTACKS; j++)	293	for (int j = 0; j < NROFATTACKS; j++)
396	if (op->resist[j] != 0)	294	if (op->resist[j] != 0)
397	{	295	{
398	op->resist[j] += lmt->mod[j];	296	op->resist[j] += lmt->mod[j];
399	if (op->resist[j] > 100)	297	if (op->resist[j] > 100)
400	op->resist[j] = 100;	298	op->resist[j] = 100;
401	if (op->resist[j] < -100)	299	if (op->resist[j] < -100)
402	op->resist[j] = -100;	300	op->resist[j] = -100;
403	}	301	}
404	}	302	}
		303
405	op->materialname = lmt->name;	304	op->materialname = lmt->name;
406	/* dont make it unstackable if it doesn't need to be */	305	/* dont make it unstackable if it doesn't need to be */
407	if (op->is_weapon () \|\| op->is_armor ())	306	if (op->is_weapon () \|\| op->is_armor ())
408	{	307	{
409	op->weight = (op->weight * lmt->weight) / 100;	308	op->weight = (op->weight * lmt->weight) / 100;
410	op->value = (op->value * lmt->value) / 100;	309	op->value = (op->value * lmt->value) / 100;
411	}	310	}
412	#endif
413	}	311	}
414	}	312	}
415		313
416	/*	314	/*
417	* Strip out the media tags from a String.	315	* Strip out the media tags from a String.
…		…
512	* a 'list' for the purposes here, is a string of items, seperated by commas, except	410	* a 'list' for the purposes here, is a string of items, seperated by commas, except
513	* for the last entry, which has an 'and' before it, and a full stop (period) after it.	411	* for the last entry, which has an 'and' before it, and a full stop (period) after it.
514	* This function will also strip all trailing non alphanumeric characters.	412	* This function will also strip all trailing non alphanumeric characters.
515	* It does not insert an oxford comma.	413	* It does not insert an oxford comma.
516	*/	414	*/
517
518	void	415	void
519	make_list_like (char *input)	416	make_list_like (char *input)
520	{	417	{
521	char *p, tmp[MAX_BUF];	418	char *p, tmp[MAX_BUF];
522	int i;	419	int i;
…		…
552	void	449	void
553	fork_abort (const char *msg)	450	fork_abort (const char *msg)
554	{	451	{
555	if (!fork ())	452	if (!fork ())
556	{	453	{
		454	signal (SIGINT , SIG_IGN);
		455	signal (SIGTERM, SIG_IGN);
557	signal (SIGABRT, SIG_DFL);	456	signal (SIGABRT, SIG_IGN);
		457
		458	signal (SIGSEGV, SIG_DFL);
		459	signal (SIGBUS , SIG_DFL);
		460	signal (SIGILL , SIG_DFL);
		461	signal (SIGTRAP, SIG_DFL);
		462
		463	// try to put corefiles into a subdirectory, if existing, to allow
		464	// an administrator to reduce the I/O load.
		465	chdir ("cores");
		466
		467	// try to detach us from as many external dependencies as possible
		468	// as coredumping can take time by closing all fd's.
		469	{
		470	struct rlimit lim;
		471
		472	if (getrlimit (RLIMIT_NOFILE, &lim))
		473	lim.rlim_cur = 1024;
		474
		475	for (int i = 0; i < lim.rlim_cur; ++i)
		476	close (i);
		477	}
		478
		479	{
		480	sigset_t empty;
		481	sigemptyset (&empty);
		482	sigprocmask (SIG_SETMASK, &empty, 0);
		483	}
		484
		485	// try to coredump with SIGTRAP
		486	kill (getpid (), SIGTRAP);
558	abort ();	487	abort ();
559	}	488	}
560		489
561	LOG (llevError, "fork abort: %s\n", msg);	490	LOG (llevError, "fork abort: %s\n", msg);
562	}	491	}
563		492
564	void *salloc_ (int n) throw (std::bad_alloc)	493	void *salloc_ (int n) throw (std::bad_alloc)
565	{	494	{
566	#ifdef PREFER_MALLOC
567	void *ptr = malloc (n);
568	#else
569	void *ptr = g_slice_alloc (n);	495	void *ptr = g_slice_alloc (n);
570	#endif
571		496
572	if (!ptr)	497	if (!ptr)
573	throw std::bad_alloc ();	498	throw std::bad_alloc ();
574		499
		500	slice_alloc += n;
575	return ptr;	501	return ptr;
576	}	502	}
577		503
578	void salloc_ (int n, void src) throw (std::bad_alloc)	504	void salloc_ (int n, void src) throw (std::bad_alloc)
579	{	505	{
…		…
585	memset (ptr, 0, n);	511	memset (ptr, 0, n);
586		512
587	return ptr;	513	return ptr;
588	}	514	}
589		515
		516	/******************************************************************************/
		517
		518	#if DEBUG_SALLOC
		519
		520	#define MAGIC 0xa1b2c35543deadLL
		521
		522	void *g_slice_alloc (unsigned long size)
		523	{
		524	unsigned long p = (unsigned long ) (g_slice_alloc)(size + sizeof (unsigned long));
		525	*p++ = size ^ MAGIC;
		526	//fprintf (stderr, "g_slice_alloc %ld %p\n", size, p);//D
		527	return (void *)p;
		528	}
		529
		530	void *g_slice_alloc0 (unsigned long size)
		531	{
		532	return memset (g_slice_alloc (size), 0, size);
		533	}
		534
		535	void g_slice_free1 (unsigned long size, void *ptr)
		536	{
		537	//fprintf (stderr, "g_slice_free %ld %p\n", size, ptr);//D
		538	if (expect_true (ptr))
		539	{
		540	unsigned long p = (unsigned long )ptr;
		541	unsigned long s = *--p ^ MAGIC;
		542
		543	if (size != (unsigned long)(*p ^ MAGIC))
		544	{
		545	LOG (logBacktrace \| llevError, "slice free size (%lx) doesn't match alloc size (%lx)\n", size, s);
		546	abort ();
		547	}
		548
		549	*p = MAGIC;
		550
		551	(g_slice_free1)(s + sizeof (unsigned long), p);
		552	}
		553	}
		554
		555	#endif
		556
		557	/******************************************************************************/
		558
590	void assign (char dst, const char src, int maxlen)	559	void assign (char dst, const char src, int maxlen)
591	{	560	{
592	if (!src)	561	if (!src)
593	src = "";	562	src = "";
594		563
…		…
609	}	578	}
610	else	579	else
611	memcpy (dst, src, len + 1);	580	memcpy (dst, src, len + 1);
612	}	581	}
613		582
614	const std::string	583	const char *
615	format (const char *format, ...)	584	format (const char *format, ...)
616	{	585	{
617	int len;	586	static dynbuf_text buf;
618		587
619	{	588	buf.clear ();
620	char buf[128];
621		589
622	va_list ap;	590	va_list ap;
623	va_start (ap, format);	591	va_start (ap, format);
624	len = vsnprintf (buf, sizeof (buf), format, ap);	592	buf.vprintf (format, ap);
625	va_end (ap);	593	va_end (ap);
626		594
627	assert (len >= 0); // shield againstz broken vsnprintf's
628
629	// was our static buffer short enough?
630	if (len < sizeof (buf))
631	return std::string (buf, len);
632	}
633
634	{
635	// longer, try harder
636	char *buf = salloc<char> (len + 1);
637
638	va_list ap;
639	va_start (ap, format);
640	vsnprintf (buf, len + 1, format, ap);
641	va_end (ap);
642
643	const std::string s (buf, len);
644	sfree<char> (buf, len + 1);
645
646	return buf;	595	return buf;
647	}
648	}	596	}
649		597
650	tstamp now ()	598	tstamp now ()
651	{	599	{
652	struct timeval tv;	600	struct timeval tv;
…		…
720	0xcdd70693UL, 0x54de5729UL, 0x23d967bfUL, 0xb3667a2eUL, 0xc4614ab8UL,	668	0xcdd70693UL, 0x54de5729UL, 0x23d967bfUL, 0xb3667a2eUL, 0xc4614ab8UL,
721	0x5d681b02UL, 0x2a6f2b94UL, 0xb40bbe37UL, 0xc30c8ea1UL, 0x5a05df1bUL,	669	0x5d681b02UL, 0x2a6f2b94UL, 0xb40bbe37UL, 0xc30c8ea1UL, 0x5a05df1bUL,
722	0x2d02ef8dL	670	0x2d02ef8dL
723	};	671	};
724		672
		673	void thread::start (void (start_routine)(void ), void arg)
		674	{
		675	pthread_attr_t attr;
725		676
		677	pthread_attr_init (&attr);
		678	pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
		679	pthread_attr_setstacksize (&attr, PTHREAD_STACK_MIN < sizeof (long) * 4096
		680	? sizeof (long) * 4096 : PTHREAD_STACK_MIN);
		681	#ifdef PTHREAD_SCOPE_PROCESS
		682	pthread_attr_setscope (&attr, PTHREAD_SCOPE_PROCESS);
		683	#endif
		684
		685	sigset_t fullsigset, oldsigset;
		686	sigfillset (&fullsigset);
		687
		688	pthread_sigmask (SIG_SETMASK, &fullsigset, &oldsigset);
		689
		690	if (pthread_create (&id, &attr, start_routine, arg))
		691	cleanup ("unable to create a new thread");
		692
		693	pthread_sigmask (SIG_SETMASK, &oldsigset, 0);
		694	}
		695

Diff Legend

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

Comparing deliantra/server/common/utils.C (file contents): Revision 1.51 by root, Mon Apr 23 18:09:57 2007 UTC vs. Revision 1.83 by root, Sun Dec 28 06:59:26 2008 UTC

Diff Legend

Comparing deliantra/server/common/utils.C (file contents):
Revision 1.51 by root, Mon Apr 23 18:09:57 2007 UTC vs.
Revision 1.83 by root, Sun Dec 28 06:59:26 2008 UTC