ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/common/utils.C
(Generate patch)

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

Diff Legend

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