quickcpplib::_xxx::algorithm::bitwise_trie::detail Namespace Reference

Classes
struct	nobble_function_implementation
struct	nobble_function_implementation< 1 >
struct	nobble_function_implementation<-1 >
struct	trie_sibling
struct	trie_sibling< T, ItemType, decltype((void) ItemType::trie_sibling, 0)>

Functions
unsigned	bitscanr (size_t value)

Function Documentation

bitscanr()

unsigned quickcpplib::_xxx::algorithm::bitwise_trie::detail::bitscanr ( size_t  value )

inline

      {
        if(!value)
          return 0;
#if defined(_MSC_VER) && !defined(__cplusplus_cli)
        {
          unsigned long bitpos;
#if defined(_M_IA64) || defined(_M_X64) || defined(WIN64) || defined(_WIN64)
          assert(8 == sizeof(size_t));
          _BitScanReverse64(&bitpos, value);
#else
          assert(4 == sizeof(size_t));
          _BitScanReverse(&bitpos, (unsigned) value);
#endif
          return (unsigned) bitpos;
        }
#elif defined(__GNUC__)
        return sizeof(value) * 8 /*CHAR_BIT*/ - 1 - (unsigned) __builtin_clzl(value);
#else
          /* The following code is illegal C, but it almost certainly will work.
          If not use the legal implementation below */
#if !defined(__cplusplus_cli)
        union
        {
          unsigned asInt[2];
          double asDouble;
        };
        int n;
 
        asDouble = (double) value + 0.5;
        n = (asInt[0 /*Use 1 if your CPU is big endian!*/] >> 20) - 1023;
#ifdef _MSC_VER
#pragma message(__FILE__ ": WARNING: Make sure you change the line above me if your CPU is big endian!")
#else
#warning Make sure you change the line above me if your CPU is big endian!
#endif
        return (unsigned) n;
#else
#if CHAR_BIT != 8
#error CHAR_BIT is not eight, and therefore this generic bitscan routine will need adjusting!
#endif
        /* This is a generic 32 and 64 bit compatible branch free bitscan right */
        size_t x = value;
        x = x | (x >> 1);
        x = x | (x >> 2);
        x = x | (x >> 4);
        x = x | (x >> 8);
        if(16 < sizeof(x) * CHAR_BIT)
          x = x | (x >> 16);
        if(32 < sizeof(x) * CHAR_BIT)
          x = x | (x >> 32);
        x = ~x;
        x = x - ((x >> 1) & (SIZE_MAX / 3));
        x = (x & (SIZE_MAX / 15 * 3)) + ((x >> 2) & (SIZE_MAX / 15 * 3));
        x = ((x + (x >> 4)) & (SIZE_MAX / UCHAR_MAX * 15)) * (SIZE_MAX / UCHAR_MAX);
        x = (CHAR_BIT * sizeof(x) - 1) - (x >> (CHAR_BIT * (sizeof(x) - 1)));
        return (unsigned) x;
#endif
#endif
      }