Common.cpp

Go to the documentation of this file.

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Project: uLib - User mode library.
// Module: Common. Small "ubiquitous" utities, et c.
// Author: Copyright (c) Love Nystrom
// License: NNOSL (BSD descendant, see NNOSL.txt in the base directory).
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

#include <uLib\Common.h>

HINSTANCE hInstance = NULL;

HWND    hMainWnd = NULL;
HWND    hCurrDlg = NULL;
HACCEL  hMainAcc = NULL;
HWND    hMdiClient = NULL;

#if !USE_STATIC_SECDESC_INIT

PISECURITY_DESCRIPTOR pis;
SECURITY_ATTRIBUTES DefSec = { sizeof(DefSec), NULL, TRUE }; // Use default sec.desc. of calling process.
SECURITY_DESCRIPTOR DefSecDesc = { 0,0,0,NULL,NULL,NULL,NULL }; // All yours.

#else
// Setup sec desc with a NULL DACL (gives full Access to Everyone)
// (This is what the descriptor would look like after InitializeSecDesc.)

SECURITY_DESCRIPTOR DefSecDesc = {
    SECURITY_DESCRIPTOR_REVISION, 0,
    SE_DACL_PRESENT, // NULL DACL present
    (PSID)NULL,      // Owner
    (PSID)NULL,      // Group
    (PACL)NULL,      // Sacl
    (PACL)NULL       // Dacl
    };
SECURITY_ATTRIBUTES DefSec = { sizeof(DefSec), &DefSecDesc, TRUE };

#endif

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Windows version check
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

BEGIN_ANONYMOUS
#if 0 //defined(_MSC_VER) && (_WIN32_WINNT >= telephone_crap)
// Agh... The millennial airheads /deprecated/ GetVersion() in the Win10 SDK !!
// Well eff that... "See figure 1" (of an (in)famous VMS memo).
// Good programmers know how to handle their nibbles!
static DWORD _GetVersion(void)
{
    static DWORD (WINAPI *__GetVersion)(void) = NULL;
    DWORD version = 0;
    if (!__GetVersion) // We know where you live..
    {
        HMODULE hMod = GetModuleHandle( "kernel32" );
        if (hMod) (FARPROC&)__GetVersion = GetProcAddress( hMod, "GetVersion" );
    }
    if (__GetVersion) version = __GetVersion();
    else // Let's make this bullet proof.
    {
        OSVERSIONINFO vi; memset( &vi, 0, sizeof(vi) );
        vi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
        if (GetVersionEx( &vi ))
        {
            version = (vi.dwMajorVersion & 0xFF) | ((vi.dwMinorVersion  & 0xFF) << 8)
                | (vi.dwBuildNumber << 16);
            if (vi.dwPlatformId != VER_PLATFORM_WIN32_NT) version |= 0x80000000;
        }
    }
    return version;
}
#else
#define _GetVersion GetVersion
#endif
END_ANONYMOUS

bool IsWinVer( BYTE vMajor, BYTE vMinor, bool winNt )
{
    // Return true if Windows version is *greater or equal* than argument.

    #define DW_HIGH_BIT 0x80000000L
    DWORD platform = winNt ? 0 : DW_HIGH_BIT; // High bit zero is NT
    DWORD version = _GetVersion();

    bool isOk = ((version & DW_HIGH_BIT) == platform);
    if (isOk) isOk = (LOBYTE( LOWORD( version )) >= vMajor);
    if (isOk) isOk = (HIBYTE( LOWORD( version )) >= vMinor);
    return isOk;
}

bool IsWin7()       { return IsWinVer( 6,1, true ); }
bool IsWinVista()   { return IsWinVer( 6,0, true ); }
bool IsWinXP()      { return IsWinVer( 5,1, true ); }
bool IsWin2000()    { return IsWinVer( 5,0, true ); }
bool IsWinNT()      { return IsWinVer( 4,0, true ); }
bool IsWin98()      { return IsWinVer( 4,1, false ); }
bool IsWin95()      { return IsWinVer( 4,0, false ); }

bool IsWin64Bit() // Check if running on Windows x64 version
{
  #if defined(_WIN64)
    return true; // This is a 64 bit proc, and running (duh), so Windows is x64.
  #elif defined(_WIN32)
    return IsWow64(); // If we're running under WoW64, the OS is x64
  #else
  #error [uLib/Common] Please define IsWin64Bit for your platform.
  #endif
}

bool IsWow64()
{
  #if defined(_WIN64)
    return false; // This is a 64 bit proc, so we're not on WoW64.
  #else
    BOOL isWow64 = FALSE;
    static BOOL (WINAPI *_IsWow64Process)( HANDLE hProc, PBOOL pWow64Proc );
    // (IsWow64Process is not available on all versions of Windows.)

    SetLastError( 0 );
    if (!_IsWow64Process)
    {
        HMODULE hKernel = GetModuleHandle(_T("KERNEL32"));
        (FARPROC&)_IsWow64Process = GetProcAddress( hKernel, "IsWow64Process" );
    }
    if (_IsWow64Process) // If API is available
        if (!_IsWow64Process( GetCurrentProcess(), &isWow64 ))
        {
            isWow64 = FALSE; // API call failed
        }
    return bool_cast( isWow64 ); // True if we're running under WoW64
  #endif
}

void GetWinSystemInfo( SYSTEM_INFO* si )
{
    if (IsWow64()) GetNativeSystemInfo( si );
    else GetSystemInfo( si );
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Arithmetic
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

long map( long x, long xMin, long xMax, long toMin, long toMax )
{
    // Promoting the numerator size solves the intermediate overflow problem
    return toMin + (INT64( x - xMin ) * INT64( toMax - toMin )) / (xMax - xMin);
}

long constrain( long x, long lo, long hi )
{
    return (x > hi ? hi : (x < lo ? lo : x));
}

short random( short iMin, short iMax )
{
  #if 0 // map can be used, but is overkill in ths case.
    return map( rand(), 0, RAND_MAX, iMin, iMax );
  #else
    int range = iMax - iMin; // I want *inclusive* iMin, iMax.
    return short( iMin + rand() * range / RAND_MAX );
    //return short( iMin + MulDiv( rand(), range, RAND_MAX ));
  #endif
}

void randomize()
{
    LARGE_INTEGER li;
    QueryPerformanceCounter( &li );
    srand( li.LowPart );
}

// Return the new running Avg..

long runningAvg( long Avg, long X, unsigned int Period )
{
    return (X + ((Period-1)*Avg)) / Period;
}

// Integer power of 2, by left shift.

ulong ipow2( ushort X )
{
    //X &= 0x1F; // Enforce max 31 bit shift
    return (1L << X);
}

uint64 ipow2x( ushort X )
{
    //X &= 0x3F; // Enforce max 63 bit shift
    return (1ULL << X);
}

// Integer log2 of x, by right shift.

#if 0 // Original loop, gets slowish for large X.
ushort ilog2( ulong X )
{
    ushort y = 0;
    while( X >>= 1 ) y++; // Naive brute force loop..
    return y;
}
#else // This algorithm is up to 3.7 times faster for large X :)

// [REF] http://graphics.stanford.edu/~seander/bithacks.html#IntegerLogLookup

ushort ilog2( ulong X )
{
    #define LT(n) n, n, n, n, n, n, n, n, n, n, n, n, n, n, n, n
    #pragma pack( push, 1 )
    static const int8 Logs[256] =
    {
      #if 1 // Standard norm -- ilog2(0) == -1.
        -1, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
      #else // As old one -- Non-standard -- ilog(0) == 0.
        0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
      #endif
        LT(4), LT(5), LT(5), LT(6), LT(6), LT(6), LT(6),
        LT(7), LT(7), LT(7), LT(7), LT(7), LT(7), LT(7), LT(7)
    };
    #pragma pack( pop )
    #undef LT
    register ulong tmp, t2;
    ushort ilog;

    // Operationally monotonic - Always 2 shifts.

    if (tmp = X >> 16)
    {
        ilog = (t2 = tmp >> 8) ? 24 + Logs[ t2 ] : 16 + Logs[ tmp ];
    }
    else
    {
        ilog = (t2 = X >> 8) ? 8 + Logs[ t2 ] : Logs[ X ];
    }
    return ilog;
}
#endif

ushort ilog2x( uint64 X )
{
    ulong temp = ulong( X >> 32 );
    return temp ? 32 + ilog2( temp ) : ilog2( (ulong)X );
}

ushort ilog10( ulong X ) //Find integer log base 10 of an integer
{
    ushort ilog;

    // The integer log base 10 is computed by first using one of the techniques above
    // for finding the log base 2. By the relationship log10(v) = log2(v) / log2(10),
    // we need to multiply it by 1/log2(10), which is approximately 1233/4096, or 1233
    // followed by a right shift of 12. Adding one is needed because the ilog2 rounds down.
    // Finally, since the value t is only an approximation that may be off by one, the
    // exact value is found by subtracting the result of X < PowersOf10[est].

    static ulong const Pwr10[] =
    {
        1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000
    };

    // PONDER: Find a higher rational for 1/log2(10)..?

    ulong est = ((ulong(ilog2( X )) + 1) * 1233) >> 12;
    _ASSERTE( est < dimof(Pwr10) );
    ilog = ushort( est - (X < Pwr10[ est ]) );
    return ilog;
}

ushort ilog10x( uint64 X ) //Find integer log base 10 of an integer
{
    ushort ilog;

    // See ilog10( ulong X )

    static uint64 const Pwr10[] =
    {
        1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000,
        10000000000, 100000000000, 1000000000000, 10000000000000, 100000000000000,
        1000000000000000, 10000000000000000, 100000000000000000, 1000000000000000000,
        10000000000000000000ul
    };

    // PONDER: Find a higher rational for 1/log2(10)..?

    ulong est = (ulong(ilog2x( X )) + 1) * 1233 >> 12;
    _ASSERTE( est < dimof(Pwr10) );
    ilog = ushort( est - (X < Pwr10[ est ]) );
    return ilog;
}

// Nth root of x, e.g root( 2,x ) == sqrt( x ).
// Uses the inverse power method, nVx <=> x^(1/n)

long double _root( long double base, long double x )
{
     return powl( x, (long double)1.0L / base );
}

// Base n logartithm of x.

long double _log( long double base, long double x )
{
    return logl( x ) / logl( base );
}

// Round a floating point number to arbitrary precision (<= 14).
// Alphatest: double x = M_PI;
// for( int nd=0; nd < 15; ++nd )
// {
//    double y = _round( x, nd );
//    printf( "_round( %.15f, %i ) = %.*f\n", x, nd, nd+1, y );
// }

#if 0 // Use pow() -- expensive.
#define _HIGH_PRECISION 0 // Didn't alleviate LSB error :(
double _round( double x, unsigned char ndecimals )
{
    if (x != 0.0)
    {
      #if _HIGH_PRECISION
        unsigned int _pc = _control87( 0,0 ) & _MCW_PC; // 53 bit mantissa :(
        _control87( _PC_64, _MCW_PC ); // 64 bit mantissa - No cure :(
      #endif
      #if 0
        if (ndecimals > 15) ndecimals = 15; // Theoretic limit (<= 2^53 [mantissa])
        if (ndecimals > 13) ndecimals = 13; // Empiric limit
      #endif

        static const double _half = 0.5L;
        double k = pow( 10.0, ndecimals );
        x = (double) ceil( x * k - _half) / k; // LSB aberration :(

      #if _HIGH_PRECISION
        _control87( _pc, _MCW_PC );
      #endif
    }
    return x;
}
#undef _HIGH_PRECISION
#else
double _round( double x, unsigned char ndeci )
{
    static const double _half = 0.5L;
    // Eliminate expensive pow() calculation with a 120 B lookup table.
    static const double _pwr[] = { // pow( 10, ndecimals )
        10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, 10000000.0, // 7
        100000000.0, 1000000000.0, 10000000000.0, 100000000000.0, // 11
        1000000000000.0, 10000000000000.0, 100000000000000.0 // 14
        };
    if (x != 0.0)
    {
        //if (!ndeci) x = ceil( x - _half); // Zero decimals (round mathic'ly)
        if (!ndeci) x = (int) x; // Zero decimals (truncate)
        else
        {
            if (ndeci > dimof(_pwr)) ndeci = dimof(_pwr);
            double k = _pwr[ ndeci-1 ];
            x = ceil( x * k - _half) / k;
        }
    }
    return x;
}
#endif


bool _isprime( unsigned long x )
{
    // PONDER: Rewrite this to have a single return point ?
    if (x < 2) return false;
    if ((x % 2) == 0) return (x == 2);
    if ((x % 3) == 0) return (x == 3);
    if ((x % 5) == 0) return (x == 5);

    unsigned long n, limit = (unsigned long) sqrt( double( x ));
    for( n = 7; n <= limit; n++ )
        if ((x % n) == 0)
        return false; // Divisible by 7..sqrt(x).

    return true; // Prime.. Passed the exclusion loop.
}

// FYI, The following two where originally implemented to select
// delay line lengths for DSP reverb algorithms. Primes matter!


unsigned long _prime( unsigned long x )
{
    unsigned long i = 0;
    if (_isprime( x )) return x;
    while( ++i ) if (_isprime( x+i )) return x+i;
    return 0;
}


unsigned long _nearprime( unsigned long x )
{
    unsigned long i = 0;
    if (_isprime( x )) return x;
    while( ++i )
    {
        unsigned long j = x + i;
        if (_isprime( j )) return j;
        else {
            j = x - i;
            if ((j > 2) && _isprime( j )) return j;
        }
    }
    return 0;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Fallback C implementations for byte swapping.
// NOT preferred. However, the ASM code is currently only for ML/ML64.
// Lucky enough, there are intrinsic bswaps in most cases.
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

#if !HAVE_BSWAP16_INTRINSIC
    #if !HAVE_ASM_BSWAP
    UINT16 __cdecl _bswap16( UINT16 W )
    {
        // C fallback if no assembler available.
        return (W << 8) | (W >> 8);
    }
    #endif
#endif

#if !HAVE_BSWAP32_INTRINSIC
    #if !HAVE_ASM_BSWAP
    UINT32 __cdecl _bswap32( UINT32 DW )
    {
        // C fallback if no assembler available.
        return (DW << 24) | (DW >> 24)
            | ((DW & 0x00FF0000) >> 8) | ((DW & 0x0000FF00) << 8);
    }
    #endif
#endif

#if !HAVE_BSWAP64_INTRINSIC
    #if !HAVE_ASM_BSWAP
    UINT64 __cdecl _bswap64( UINT64 Val )
    {
        // C fallback if no assembler available.
        union uSwap {
            UINT64  u64;
            BYTE    b[8];
        } u;

        u.u64 = Val;
        for( BYTE i=0, j=7; i < 4; ++i, --j )
        {
            BYTE _b = u.b[i]; u.b[i] = u.b[j]; u.b[j] = _b;
        }
        return u.u64;
    }
    #endif
#endif

// EOF