ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/common/utils.C
Revision: 1.79
Committed: Sat Aug 30 05:19:03 2008 UTC (15 years, 8 months ago) by root
Content type: text/plain
Branch: MAIN
CVS Tags: rel-2_7
Changes since 1.78: +17 -0 lines
Log Message:
*** empty log message ***

File Contents

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