Common.cpp

/*****************************************************************************/
/* CascCommon.cpp                         Copyright (c) Ladislav Zezula 2014 */
/*---------------------------------------------------------------------------*/
/* Common functions for CascLib                                              */
/*---------------------------------------------------------------------------*/
/*   Date    Ver   Who  Comment                                              */
/* --------  ----  ---  -------                                              */
/* 29.04.14  1.00  Lad  The first version of CascCommon.cpp                  */
/*****************************************************************************/

#define __CASCLIB_SELF__
#include "../CascLib.h"
#include "../CascCommon.h"

//-----------------------------------------------------------------------------
// Conversion to uppercase/lowercase

// Converts ASCII characters to lowercase
// Converts slash (0x2F) to backslash (0x5C)
unsigned char AsciiToLowerTable[256] = 
{
    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 
    0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 
    0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x5C, 
    0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, 
    0x40, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 
    0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 
    0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 
    0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F, 
    0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 
    0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, 
    0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 
    0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 
    0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 
    0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 
    0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF,
    0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF
};

// Converts ASCII characters to uppercase
// Converts slash (0x2F) to backslash (0x5C)
unsigned char AsciiToUpperTable[256] = 
{
    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 
    0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 
    0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x5C, 
    0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, 
    0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 
    0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 
    0x60, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 
    0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F, 
    0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 
    0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, 
    0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 
    0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 
    0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 
    0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 
    0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF,
    0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF
};

unsigned char IntToHexChar[] = "0123456789abcdef";
                        
//-----------------------------------------------------------------------------
// Support for memory reallocation

#if defined(_MSC_VER) && defined(_DEBUG)
void * DbgRealloc(void * ptr, size_t nSize)
{
    // HeapReAlloc does not support NULL as previous block
    if(ptr == NULL)
        return HeapAlloc(GetProcessHeap, 0, nSize);

    return HeapReAlloc(GetProcessHeap(), 0, ptr, nSize);
}
#endif

//-----------------------------------------------------------------------------
// GetLastError/SetLastError support for non-Windows platform

#ifndef PLATFORM_WINDOWS
static int nLastError = ERROR_SUCCESS;

int GetLastError()
{
    return nLastError;
}

void SetLastError(int nError)
{
    nLastError = nError;
}
#endif

//-----------------------------------------------------------------------------
// String manipulation

void CopyString(char * szTarget, const char * szSource, size_t cchLength)
{
    memcpy(szTarget, szSource, cchLength);
    szTarget[cchLength] = 0;
}

void CopyString(wchar_t * szTarget, const char * szSource, size_t cchLength)
{
    mbstowcs(szTarget, szSource, cchLength);
    szTarget[cchLength] = 0;
}

void CopyString(char * szTarget, const wchar_t * szSource, size_t cchLength)
{
    wcstombs(szTarget, szSource, cchLength);
    szTarget[cchLength] = 0;
}

char * NewStr(const char * szString, size_t nCharsToReserve)
{
    char * szNewString = NULL;
    size_t nLength;

    if(szString != NULL)
    {
        nLength = strlen(szString);
        szNewString = CASC_ALLOC(char, nLength + nCharsToReserve + 1);
        if(szNewString != NULL)
        {
            memcpy(szNewString, szString, nLength);
            szNewString[nLength] = 0;
        }
    }

    return szNewString;
}

wchar_t * NewStr(const wchar_t * szString, size_t nCharsToReserve)
{
    wchar_t * szNewString = NULL;
    size_t nLength;

    if(szString != NULL)
    {
        nLength = wcslen(szString);
        szNewString = CASC_ALLOC(wchar_t, nLength + nCharsToReserve + 1);
        if(szNewString != NULL)
        {
            memcpy(szNewString, szString, nLength * sizeof(wchar_t));
            szNewString[nLength] = 0;
        }
    }

    return szNewString;
}

TCHAR * NewStrFromAnsi(LPBYTE pbStringBegin, LPBYTE pbStringEnd)
{
    TCHAR * szNewString = NULL;
    TCHAR * szStringPtr = NULL;
    size_t nLength = (size_t)(pbStringEnd - pbStringBegin);

    if(pbStringEnd > pbStringBegin)
    {
        szNewString = szStringPtr = CASC_ALLOC(TCHAR, nLength + 1);
        if(szNewString != NULL)
        {
            CopyString(szStringPtr, (const char *)pbStringBegin, nLength);
            szStringPtr[nLength] = 0;
        }
    }

    return szNewString;
}

TCHAR * CombinePath(const TCHAR * szDirectory, const TCHAR * szSubDir)
{
    TCHAR * szFullPath = NULL;
    TCHAR * szPathPtr;
    size_t nLength1 = 0;
    size_t nLength2 = 0;

    // Calculate lengths of each part
    if(szDirectory != NULL)
    {
        // Get the length of the directory
        nLength1 = _tcslen(szDirectory);

        // Cut all ending backslashes
        while(nLength1 > 0 && szDirectory[nLength1 - 1] == _T(PATH_SEPARATOR))
            nLength1--;
    }
    
    if(szSubDir != NULL)
    {
        // Cut all leading backslashes
        while(szSubDir[0] == _T(PATH_SEPARATOR))
            szSubDir++;

        // Get the length of the subdir
        nLength2 = _tcslen(szSubDir);

        // Cut all ending backslashes
        while(nLength2 > 0 && szSubDir[nLength2 - 1] == _T(PATH_SEPARATOR))
            nLength2--;
    }

    // Allocate space for the full path
    szFullPath = szPathPtr = CASC_ALLOC(TCHAR, nLength1 + nLength2 + 2);
    if(szFullPath != NULL)
    {
        // Copy the directory
        if(szDirectory != NULL && nLength1 != 0)
        {
            memcpy(szPathPtr, szDirectory, (nLength1 * sizeof(TCHAR)));
            szPathPtr += nLength1;
        }

        // Copy the sub-directory
        if(szSubDir != NULL && nLength2 != 0)
        {
            // Append backslash to the previous one
            if(szPathPtr > szFullPath)
                *szPathPtr++ = _T(PATH_SEPARATOR);

            // Copy the string
            memcpy(szPathPtr, szSubDir, (nLength2 * sizeof(TCHAR)));
            szPathPtr += nLength2;
        }

        // Terminate the string
        szPathPtr[0] = 0;
    }

    return szFullPath;
}

void NormalizeFileName_UpperBkSlash(char * szFileName)
{
    // Normalize the file name: ToLower + BackSlashToSlash
    for(size_t i = 0; szFileName[i] != 0; i++)
        szFileName[i] = (char)(AsciiToUpperTable[szFileName[i]]);
}

void NormalizeFileName_LowerSlash(char * szFileName)
{
    // Normalize the file name: ToLower + BackSlashToSlash
    for(size_t i = 0; szFileName[i] != 0; i++)
    {
        szFileName[i] = (char)(AsciiToLowerTable[szFileName[i]]);
        szFileName[i] = (szFileName[i] != '\\') ? szFileName[i] : '/';
    }
}

int ConvertDigitToInt32(const TCHAR * szString, PDWORD PtrValue)
{
    BYTE Digit;

    Digit = (BYTE)(AsciiToUpperTable[szString[0]] - _T('0'));
    if(Digit > 9)
        Digit -= 'A' - '9' - 1;

    PtrValue[0] = Digit;
    return (Digit > 0x0F) ? ERROR_BAD_FORMAT : ERROR_SUCCESS;
}

int ConvertStringToInt32(const TCHAR * szString, size_t nMaxDigits, PDWORD PtrValue)
{
    // The number of digits must be even
    assert((nMaxDigits & 0x01) == 0);
    assert(nMaxDigits <= 8);

    // Prepare the variables
    PtrValue[0] = 0;
    nMaxDigits >>= 1;

    // Convert the string up to the number of digits
    for(size_t i = 0; i < nMaxDigits; i++)
    {
        BYTE DigitOne;
        BYTE DigitTwo;

        DigitOne = (BYTE)(AsciiToUpperTable[szString[0]] - _T('0'));
        if(DigitOne > 9)
            DigitOne -= 'A' - '9' - 1;

        DigitTwo = (BYTE)(AsciiToUpperTable[szString[1]] - _T('0'));
        if(DigitTwo > 9)
            DigitTwo -= 'A' - '9' - 1;

        if(DigitOne > 0x0F || DigitTwo > 0x0F)
            return ERROR_BAD_FORMAT;

        PtrValue[0] = (PtrValue[0] << 0x08) | (DigitOne << 0x04) | DigitTwo;
        szString += 2;
    }

    return ERROR_SUCCESS;
}

char * StringFromBinary(LPBYTE pbBinary, size_t cbBinary, char * szBuffer)
{
    char * szSaveBuffer = szBuffer;

    // Convert the string to the array of MD5
    // Copy the blob data as text
    for(size_t i = 0; i < cbBinary; i++)
    {
        *szBuffer++ = (char)(IntToHexChar[pbBinary[0] >> 0x04]);
        *szBuffer++ = (char)(IntToHexChar[pbBinary[0] & 0x0F]);
        pbBinary++;
    }

    // Terminate the string
    *szBuffer = 0;
    return szSaveBuffer;
}

//-----------------------------------------------------------------------------
// File name utilities

const wchar_t * GetPlainFileName(const wchar_t * szFileName)
{
    const wchar_t * szPlainName = szFileName;

    while(*szFileName != 0)
    {
        if(*szFileName == '\\' || *szFileName == '/')
            szPlainName = szFileName + 1;
        szFileName++;
    }

    return szPlainName;
}

const char * GetPlainFileName(const char * szFileName)
{
    const char * szPlainName = szFileName;

    while(*szFileName != 0)
    {
        if(*szFileName == '\\' || *szFileName == '/')
            szPlainName = szFileName + 1;
        szFileName++;
    }

    return szPlainName;
}

bool CheckWildCard(const char * szString, const char * szWildCard)
{
    const char * szSubString;
    int nSubStringLength;
    int nMatchCount = 0;

    // When the mask is empty, it never matches
    if(szWildCard == NULL || *szWildCard == 0)
        return false;

    // If the wildcard contains just "*", then it always matches
    if(szWildCard[0] == '*' && szWildCard[1] == 0)
        return true;

    // Do normal test
    for(;;)
    {
        // If there is '?' in the wildcard, we skip one char
        while(*szWildCard == '?')
        {
            szWildCard++;
            szString++;
        }

        // If there is '*', means zero or more chars. We have to 
        // find the sequence after '*'
        if(*szWildCard == '*')
        {
            // More stars is equal to one star
            while(*szWildCard == '*' || *szWildCard == '?')
                szWildCard++;

            // If we found end of the wildcard, it's a match
            if(*szWildCard == 0)
                return true;

            // Determine the length of the substring in szWildCard
            szSubString = szWildCard;
            while(*szSubString != 0 && *szSubString != '?' && *szSubString != '*')
                szSubString++;
            nSubStringLength = (int)(szSubString - szWildCard);
            nMatchCount = 0;

            // Now we have to find a substring in szString,
            // that matches the substring in szWildCard
            while(*szString != 0)
            {
                // Calculate match count
                while(nMatchCount < nSubStringLength)
                {
                    if(AsciiToUpperTable[(BYTE)szString[nMatchCount]] != AsciiToUpperTable[(BYTE)szWildCard[nMatchCount]])
                        break;
                    if(szString[nMatchCount] == 0)
                        break;
                    nMatchCount++;
                }

                // If the match count has reached substring length, we found a match
                if(nMatchCount == nSubStringLength)
                {
                    szWildCard += nMatchCount;
                    szString += nMatchCount;
                    break;
                }

                // No match, move to the next char in szString
                nMatchCount = 0;
                szString++;
            }
        }
        else
        {
            // If we came to the end of the string, compare it to the wildcard
            if(AsciiToUpperTable[(BYTE)*szString] != AsciiToUpperTable[(BYTE)*szWildCard])
                return false;

            // If we arrived to the end of the string, it's a match
            if(*szString == 0)
                return true;

            // Otherwise, continue in comparing
            szWildCard++;
            szString++;
        }
    }
}

//-----------------------------------------------------------------------------
// Hashing functions

bool IsValidMD5(LPBYTE pbMd5)
{
    BYTE BitSummary = 0;
    
    // The MD5 is considered invalid of it is zeroed
    BitSummary |= pbMd5[0x00] | pbMd5[0x01] | pbMd5[0x02] | pbMd5[0x03] | pbMd5[0x04] | pbMd5[0x05] | pbMd5[0x06] | pbMd5[0x07];
    BitSummary |= pbMd5[0x08] | pbMd5[0x09] | pbMd5[0x0A] | pbMd5[0x0B] | pbMd5[0x0C] | pbMd5[0x0D] | pbMd5[0x0E] | pbMd5[0x0F];
    return (BitSummary != 0);
}

bool VerifyDataBlockHash(void * pvDataBlock, DWORD cbDataBlock, LPBYTE expected_md5)
{
    hash_state md5_state;
    BYTE md5_digest[MD5_HASH_SIZE];

    // Don't verify the block if the MD5 is not valid.
    if(!IsValidMD5(expected_md5))
        return true;

    // Calculate the MD5 of the data block
    md5_init(&md5_state);
    md5_process(&md5_state, (unsigned char *)pvDataBlock, cbDataBlock);
    md5_done(&md5_state, md5_digest);

    // Does the MD5's match?
    return (memcmp(md5_digest, expected_md5, MD5_HASH_SIZE) == 0);
}

void CalculateDataBlockHash(void * pvDataBlock, DWORD cbDataBlock, LPBYTE md5_hash)
{
    hash_state md5_state;

    md5_init(&md5_state);
    md5_process(&md5_state, (unsigned char *)pvDataBlock, cbDataBlock);
    md5_done(&md5_state, md5_hash);
}

//-----------------------------------------------------------------------------
// We have our own qsort implementation, optimized for using array of pointers

#define STKSIZ (8*sizeof(void*) - 2)

#define SWAP_ENTRIES(index1, index2)        \
{                                           \
    temp = base[index1];                    \
    base[index1] = base[index2];            \
    base[index2] = temp;                    \
}

void qsort_pointer_array(void ** base, size_t num, int (*compare)(const void *, const void *, const void *), const void * context)
{
    size_t lo, hi;                  /* ends of sub-array currently sorting */
    size_t mid;                     /* points to middle of subarray */
    size_t loguy, higuy;            /* traveling pointers for partition step */
    size_t size;                    /* size of the sub-array */
    size_t lostk[STKSIZ], histk[STKSIZ];
    void * temp;
    int stkptr;                     /* stack for saving sub-array to be processed */

    /* validation section */
    assert(base != NULL);
    assert(compare != NULL);

    if (num < 2)
        return;                 /* nothing to do */

    stkptr = 0;                 /* initialize stack */

    lo = 0;
    hi = (num-1);               /* initialize limits */

    /* this entry point is for pseudo-recursion calling: setting
       lo and hi and jumping to here is like recursion, but stkptr is
       preserved, locals aren't, so we preserve stuff on the stack */
recurse:

    size = (hi - lo) + 1;       /* number of el's to sort */

    /* First we pick a partitioning element.  The efficiency of the
       algorithm demands that we find one that is approximately the median
       of the values, but also that we select one fast.  We choose the
       median of the first, middle, and last elements, to avoid bad
       performance in the face of already sorted data, or data that is made
       up of multiple sorted runs appended together.  Testing shows that a
       median-of-three algorithm provides better performance than simply
       picking the middle element for the latter case. */

    mid = lo + (size / 2);      /* find middle element */

    /* Sort the first, middle, last elements into order */
    if (compare(context, base[lo], base[mid]) > 0) {
        SWAP_ENTRIES(lo, mid);
    }
    if (compare(context, base[lo], base[hi]) > 0) {
        SWAP_ENTRIES(lo, hi);
    }
    if (compare(context, base[mid], base[hi]) > 0) {
        SWAP_ENTRIES(mid, hi);
    }

    /* We now wish to partition the array into three pieces, one consisting
       of elements <= partition element, one of elements equal to the
       partition element, and one of elements > than it.  This is done
       below; comments indicate conditions established at every step. */

    loguy = lo;
    higuy = hi;

    /* Note that higuy decreases and loguy increases on every iteration,
       so loop must terminate. */
    for (;;) {
        /* lo <= loguy < hi, lo < higuy <= hi,
           A[i] <= A[mid] for lo <= i <= loguy,
           A[i] > A[mid] for higuy <= i < hi,
           A[hi] >= A[mid] */

        /* The doubled loop is to avoid calling comp(mid,mid), since some
           existing comparison funcs don't work when passed the same
           value for both pointers. */

        if (mid > loguy) {
            do  {
                loguy ++;
            } while (loguy < mid && compare(context, base[loguy], base[mid]) <= 0);
        }
        if (mid <= loguy) {
            do  {
                loguy ++;
            } while (loguy <= hi && compare(context, base[loguy], base[mid]) <= 0);
        }

        /* lo < loguy <= hi+1, A[i] <= A[mid] for lo <= i < loguy,
           either loguy > hi or A[loguy] > A[mid] */

        do  {
            higuy --;
        } while (higuy > mid && compare(context, base[higuy], base[mid]) > 0);

        /* lo <= higuy < hi, A[i] > A[mid] for higuy < i < hi,
           either higuy == lo or A[higuy] <= A[mid] */

        if (higuy < loguy)
            break;

        /* if loguy > hi or higuy == lo, then we would have exited, so
           A[loguy] > A[mid], A[higuy] <= A[mid],
           loguy <= hi, higuy > lo */

        SWAP_ENTRIES(loguy, higuy);

        /* If the partition element was moved, follow it.  Only need
           to check for mid == higuy, since before the swap,
           A[loguy] > A[mid] implies loguy != mid. */

        if (mid == higuy)
            mid = loguy;

        /* A[loguy] <= A[mid], A[higuy] > A[mid]; so condition at top
           of loop is re-established */
    }

    /*     A[i] <= A[mid] for lo <= i < loguy,
           A[i] > A[mid] for higuy < i < hi,
           A[hi] >= A[mid]
           higuy < loguy
       implying:
           higuy == loguy-1
           or higuy == hi - 1, loguy == hi + 1, A[hi] == A[mid] */

    /* Find adjacent elements equal to the partition element.  The
       doubled loop is to avoid calling comp(mid,mid), since some
       existing comparison funcs don't work when passed the same value
       for both pointers. */

    higuy ++;
    if (mid < higuy) {
        do  {
            higuy --;
        } while (higuy > mid && compare(context, base[higuy], base[mid]) == 0);
    }
    if (mid >= higuy) {
        do  {
            higuy --;
        } while (higuy > lo && compare(context, base[higuy], base[mid]) == 0);
    }

    /* OK, now we have the following:
          higuy < loguy
          lo <= higuy <= hi
          A[i]  <= A[mid] for lo <= i <= higuy
          A[i]  == A[mid] for higuy < i < loguy
          A[i]  >  A[mid] for loguy <= i < hi
          A[hi] >= A[mid] */

    /* We've finished the partition, now we want to sort the subarrays
       [lo, higuy] and [loguy, hi].
       We do the smaller one first to minimize stack usage.
       We only sort arrays of length 2 or more.*/

    if ( higuy - lo >= hi - loguy ) {
        if (lo < higuy) {
            lostk[stkptr] = lo;
            histk[stkptr] = higuy;
            ++stkptr;
        }                           /* save big recursion for later */

        if (loguy < hi) {
            lo = loguy;
            goto recurse;           /* do small recursion */
        }
    }
    else {
        if (loguy < hi) {
            lostk[stkptr] = loguy;
            histk[stkptr] = hi;
            ++stkptr;               /* save big recursion for later */
        }

        if (lo < higuy) {
            hi = higuy;
            goto recurse;           /* do small recursion */
        }
    }

    /* We have sorted the array, except for any pending sorts on the stack.
       Check if there are any, and do them. */

    --stkptr;
    if (stkptr >= 0) {
        lo = lostk[stkptr];
        hi = histk[stkptr];
        goto recurse;           /* pop subarray from stack */
    }
    else
        return;                 /* all subarrays done */
}