ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/include/util.h
(Generate patch)

Comparing deliantra/server/include/util.h (file contents):
Revision 1.124 by root, Fri Nov 18 20:20:05 2016 UTC vs.
Revision 1.128 by root, Tue Nov 27 18:47:35 2018 UTC

1/* 1/*
2 * This file is part of Deliantra, the Roguelike Realtime MMORPG. 2 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
3 * 3 *
4 * Copyright (©) 2017,2018 Marc Alexander Lehmann / the Deliantra team
4 * Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2016 Marc Alexander Lehmann / Robin Redeker / the Deliantra team 5 * Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2016 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 * 6 *
6 * Deliantra is free software: you can redistribute it and/or modify it under 7 * Deliantra is free software: you can redistribute it and/or modify it under
7 * the terms of the Affero GNU General Public License as published by the 8 * the terms of the Affero GNU General Public License as published by the
8 * Free Software Foundation, either version 3 of the License, or (at your 9 * Free Software Foundation, either version 3 of the License, or (at your
… …
36#include <new> 37#include <new>
37#include <vector> 38#include <vector>
38 39
39#include <glib.h> 40#include <glib.h>
40 41
42#include <flat_hash_map.hpp>
43
41#include <shstr.h> 44#include <shstr.h>
42#include <traits.h> 45#include <traits.h>
43 46
44#if DEBUG_SALLOC 47#if DEBUG_SALLOC
45# define g_slice_alloc0(s) debug_slice_alloc0(s) 48# define g_slice_alloc0(s) debug_slice_alloc0(s)
… …
81 84
82// in range excluding end 85// in range excluding end
83#define IN_RANGE_EXC(val,beg,end) \ 86#define IN_RANGE_EXC(val,beg,end) \
84 ((unsigned int)(val) - (unsigned int)(beg) < (unsigned int)(end) - (unsigned int)(beg)) 87 ((unsigned int)(val) - (unsigned int)(beg) < (unsigned int)(end) - (unsigned int)(beg))
85 88
86void cleanup (const char *cause, bool make_core = false); 89ecb_cold void cleanup (const char *cause, bool make_core = false);
87void fork_abort (const char *msg); 90ecb_cold void fork_abort (const char *msg);
88 91
89// rationale for using (U) not (T) is to reduce signed/unsigned issues, 92// rationale for using (U) not (T) is to reduce signed/unsigned issues,
90// as a is often a constant while b is the variable. it is still a bug, though. 93// as a is often a constant while b is the variable. it is still a bug, though.
91template<typename T, typename U> static inline T min (T a, U b) { return a < (T)b ? a : (T)b; } 94template<typename T, typename U> static inline T min (T a, U b) { return a < (T)b ? a : (T)b; }
92template<typename T, typename U> static inline T max (T a, U b) { return a > (T)b ? a : (T)b; } 95template<typename T, typename U> static inline T max (T a, U b) { return a > (T)b ? a : (T)b; }
… …
283absdir (int d) 286absdir (int d)
284{ 287{
285 return ((d - 1) & 7) + 1; 288 return ((d - 1) & 7) + 1;
286} 289}
287 290
288// avoid ctz name because netbsd or freebsd spams it's namespace with it
289#if GCC_VERSION(3,4)
290static inline int least_significant_bit (uint32_t x)
291{
292 return __builtin_ctz (x);
293}
294#else
295int least_significant_bit (uint32_t x);
296#endif
297
298#define for_all_bits_sparse_32(mask, idxvar) \ 291#define for_all_bits_sparse_32(mask, idxvar) \
299 for (uint32_t idxvar, mask_ = mask; \ 292 for (uint32_t idxvar, mask_ = mask; \
300 mask_ && ((idxvar = least_significant_bit (mask_)), mask_ &= ~(1 << idxvar), 1);) 293 mask_ && ((idxvar = ecb_ctz32 (mask_)), mask_ &= ~(1 << idxvar), 1);)
301 294
302extern ssize_t slice_alloc; // statistics 295extern ssize_t slice_alloc; // statistics
303 296
304void *salloc_ (int n) throw (std::bad_alloc); 297void *salloc_ (int n);
305void *salloc_ (int n, void *src) throw (std::bad_alloc); 298void *salloc_ (int n, void *src);
306 299
307// strictly the same as g_slice_alloc, but never returns 0 300// strictly the same as g_slice_alloc, but never returns 0
308template<typename T> 301template<typename T>
309inline T *salloc (int n = 1) throw (std::bad_alloc) { return (T *)salloc_ (n * sizeof (T)); } 302inline T *salloc (int n = 1) { return (T *)salloc_ (n * sizeof (T)); }
310 303
311// also copies src into the new area, like "memdup" 304// also copies src into the new area, like "memdup"
312// if src is 0, clears the memory 305// if src is 0, clears the memory
313template<typename T> 306template<typename T>
314inline T *salloc (int n, T *src) throw (std::bad_alloc) { return (T *)salloc_ (n * sizeof (T), (void *)src); } 307inline T *salloc (int n, T *src) { return (T *)salloc_ (n * sizeof (T), (void *)src); }
315 308
316// clears the memory 309// clears the memory
317template<typename T> 310template<typename T>
318inline T *salloc0(int n = 1) throw (std::bad_alloc) { return (T *)salloc_ (n * sizeof (T), 0); } 311inline T *salloc0(int n = 1) { return (T *)salloc_ (n * sizeof (T), 0); }
319 312
320// for symmetry 313// for symmetry
321template<typename T> 314template<typename T>
322inline void sfree (T *ptr, int n = 1) throw () 315inline void sfree (T *ptr, int n = 1) noexcept
323{ 316{
324 if (expect_true (ptr)) 317 if (expect_true (ptr))
325 { 318 {
326 slice_alloc -= n * sizeof (T); 319 slice_alloc -= n * sizeof (T);
327 if (DEBUG_POISON) memset (ptr, DEBUG_POISON, n * sizeof (T)); 320 if (DEBUG_POISON) memset (ptr, DEBUG_POISON, n * sizeof (T));
… …
329 } 322 }
330} 323}
331 324
332// nulls the pointer 325// nulls the pointer
333template<typename T> 326template<typename T>
334inline void sfree0 (T *&ptr, int n = 1) throw () 327inline void sfree0 (T *&ptr, int n = 1) noexcept
335{ 328{
336 sfree<T> (ptr, n); 329 sfree<T> (ptr, n);
337 ptr = 0; 330 ptr = 0;
338} 331}
339 332
… …
413 struct rebind 406 struct rebind
414 { 407 {
415 typedef slice_allocator<U> other; 408 typedef slice_allocator<U> other;
416 }; 409 };
417 410
418 slice_allocator () throw () { } 411 slice_allocator () noexcept { }
419 slice_allocator (const slice_allocator &) throw () { } 412 slice_allocator (const slice_allocator &) noexcept { }
420 template<typename Tp2> 413 template<typename Tp2>
421 slice_allocator (const slice_allocator<Tp2> &) throw () { } 414 slice_allocator (const slice_allocator<Tp2> &) noexcept { }
422 415
423 ~slice_allocator () { } 416 ~slice_allocator () { }
424 417
425 pointer address (reference x) const { return &x; } 418 pointer address (reference x) const { return &x; }
426 const_pointer address (const_reference x) const { return &x; } 419 const_pointer address (const_reference x) const { return &x; }
… …
433 void deallocate (pointer p, size_type n) 426 void deallocate (pointer p, size_type n)
434 { 427 {
435 sfree<Tp> (p, n); 428 sfree<Tp> (p, n);
436 } 429 }
437 430
438 size_type max_size () const throw () 431 size_type max_size () const noexcept
439 { 432 {
440 return size_t (-1) / sizeof (Tp); 433 return size_t (-1) / sizeof (Tp);
441 } 434 }
442 435
443 void construct (pointer p, const Tp &val) 436 void construct (pointer p, const Tp &val)
… …
536 // p if not null 529 // p if not null
537 refcnt_base::refcnt_t *refcnt_ref () { return p ? &p->refcnt : &refcnt_dummy; } 530 refcnt_base::refcnt_t *refcnt_ref () { return p ? &p->refcnt : &refcnt_dummy; }
538 531
539 void refcnt_dec () 532 void refcnt_dec ()
540 { 533 {
541 if (!is_constant (p)) 534 if (!ecb_is_constant (p))
542 --*refcnt_ref (); 535 --*refcnt_ref ();
543 else if (p) 536 else if (p)
544 --p->refcnt; 537 --p->refcnt;
545 } 538 }
546 539
547 void refcnt_inc () 540 void refcnt_inc ()
548 { 541 {
549 if (!is_constant (p)) 542 if (!ecb_is_constant (p))
550 ++*refcnt_ref (); 543 ++*refcnt_ref ();
551 else if (p) 544 else if (p)
552 ++p->refcnt; 545 ++p->refcnt;
553 } 546 }
554 547
… …
626 619
627 std::size_t operator ()(const shstr &s) const 620 std::size_t operator ()(const shstr &s) const
628 { 621 {
629 return strhsh (s); 622 return strhsh (s);
630 } 623 }
624
625 typedef ska::power_of_two_hash_policy hash_policy;
631}; 626};
632 627
633struct str_equal 628struct str_equal
634{ 629{
635 bool operator ()(const char *a, const char *b) const 630 bool operator ()(const char *a, const char *b) const
… …
814 809
815int similar_direction (int a, int b); 810int similar_direction (int a, int b);
816 811
817// like v?sprintf, but returns a "static" buffer 812// like v?sprintf, but returns a "static" buffer
818char *vformat (const char *format, va_list ap); 813char *vformat (const char *format, va_list ap);
819char *format (const char *format, ...) attribute ((format (printf, 1, 2))); 814char *format (const char *format, ...) ecb_attribute ((format (printf, 1, 2)));
820 815
821// safety-check player input which will become object->msg 816// safety-check player input which will become object->msg
822bool msg_is_safe (const char *msg); 817bool msg_is_safe (const char *msg);
823 818
824///////////////////////////////////////////////////////////////////////////// 819/////////////////////////////////////////////////////////////////////////////

Diff Legend

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