/*****************************************************************************/
/* 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 backslash (0x5C) to normal slash (0x2F)
unsigned char AsciiToLowerTable_Slash[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, 0x2F,
    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, 0x2F, 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_BkSlash[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";

//-----------------------------------------------------------------------------
// 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 * CascNewStr(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 * CascNewStr(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 * CascNewStrFromAnsi(const char * szBegin, const char * szEnd)
{
    TCHAR * szNewString = NULL;

    // Only if the entry is valid
    if(szBegin != NULL && szEnd > szBegin)
    {
        // Allocate and copy the string
        szNewString = CASC_ALLOC(TCHAR, (szEnd - szBegin + 1));
        if(szNewString != NULL)
            CopyString(szNewString, szBegin, (szEnd - szBegin));
    }

    // Return the string
    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('\\') || szDirectory[nLength1 - 1] == _T('/')))
            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;
}

TCHAR * CombinePathAndString(const TCHAR * szPath, const char * szString, size_t nLength)
{
    TCHAR * szFullPath = NULL;
    TCHAR * szSubDir;

    // Create the subdir string
    szSubDir = CASC_ALLOC(TCHAR, nLength + 1);
    if(szSubDir != NULL)
    {
        CopyString(szSubDir, szString, nLength);
        szFullPath = CombinePath(szPath, szSubDir);
        CASC_FREE(szSubDir);
    }

    return szFullPath;
}

size_t NormalizeFileName(const unsigned char * NormTable, char * szNormName, const char * szFileName, size_t cchMaxChars)
{
    char * szNormNameEnd = szNormName + cchMaxChars;
    size_t i;

    // Normalize the file name: ToLower + BackSlashToSlash
    for(i = 0; szFileName[0] != 0 && szNormName < szNormNameEnd; i++)
        *szNormName++ = NormTable[*szFileName++];

    // Terminate the string
    szNormName[0] = 0;
    return i;
}

size_t NormalizeFileName_UpperBkSlash(char * szNormName, const char * szFileName, size_t cchMaxChars)
{
    return NormalizeFileName(AsciiToUpperTable_BkSlash, szNormName, szFileName, cchMaxChars);
}

size_t NormalizeFileName_LowerSlash(char * szNormName, const char * szFileName, size_t cchMaxChars)
{
    return NormalizeFileName(AsciiToLowerTable_Slash, szNormName, szFileName, cchMaxChars);
}

ULONGLONG CalcFileNameHash(const char * szFileName)
{
    char szNormName[MAX_PATH+1];
    uint32_t dwHashHigh = 0;
    uint32_t dwHashLow = 0;
    size_t nLength;

    // Normalize the file name - convert to uppercase, slashes to backslashes
    nLength = NormalizeFileName_UpperBkSlash(szNormName, szFileName, MAX_PATH);

    // Calculate the HASH value of the normalized file name
    hashlittle2(szNormName, nLength, &dwHashHigh, &dwHashLow);
    return ((ULONGLONG)dwHashHigh << 0x20) | dwHashLow;
}

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

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

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

int ConvertStringToInt08(const char * szString, PDWORD PtrValue)
{
    BYTE DigitOne = AsciiToUpperTable_BkSlash[szString[0]] - '0';
    BYTE DigitTwo = AsciiToUpperTable_BkSlash[szString[1]] - '0';

    // Fix the digits
    if(DigitOne > 9)
        DigitOne -= 'A' - '9' - 1;
    if(DigitTwo > 9)
        DigitTwo -= 'A' - '9' - 1;

    // Combine them into a value
    PtrValue[0] = (DigitOne << 0x04) | DigitTwo;
    return (DigitOne <= 0x0F && DigitTwo <= 0x0F) ? ERROR_SUCCESS : ERROR_BAD_FORMAT;
}

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_BkSlash[szString[0]] - _T('0'));
        if(DigitOne > 9)
            DigitOne -= 'A' - '9' - 1;

        DigitTwo = (BYTE)(AsciiToUpperTable_BkSlash[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;
}

// Converts string blob to binary blob.
int ConvertStringToBinary(
    const char * szString,
    size_t nMaxDigits,
    LPBYTE pbBinary)
{
    const char * szStringEnd = szString + nMaxDigits;
    DWORD dwCounter = 0;
    BYTE DigitValue;
    BYTE ByteValue = 0;

    // Convert the string
    while(szString < szStringEnd)
    {
        // Retrieve the digit converted to hexa
        DigitValue = (BYTE)(AsciiToUpperTable_BkSlash[szString[0]] - '0');
        if(DigitValue > 9)
            DigitValue -= 'A' - '9' - 1;
        if(DigitValue > 0x0F)
            return ERROR_BAD_FORMAT;

        // Insert the digit to the binary buffer
        ByteValue = (ByteValue << 0x04) | DigitValue;
        dwCounter++;

        // If we reached the second digit, it means that we need
        // to flush the byte value and move on
        if((dwCounter & 0x01) == 0)
            *pbBinary++ = ByteValue;
        szString++;
    }

    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++ = IntToHexChar[pbBinary[0] >> 0x04];
        *szBuffer++ = IntToHexChar[pbBinary[0] & 0x0F];
        pbBinary++;
    }

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

char * StringFromMD5(LPBYTE md5, char * szBuffer)
{
    return StringFromBinary(md5, MD5_HASH_SIZE, szBuffer);
}

//-----------------------------------------------------------------------------
// 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 * szWildCardPtr;

    for(;;)
    {
        // If there is '?' in the wildcard, we skip one char
        while(szWildCard[0] == '?')
        {
            if(szString[0] == 0)
                return false;

            szWildCard++;
            szString++;
        }

        // Handle '*'
        szWildCardPtr = szWildCard;
        if(szWildCardPtr[0] != 0)
        {
            if(szWildCardPtr[0] == '*')
            {
                szWildCardPtr++;

                if(szWildCardPtr[0] == '*')
                    continue;

                if(szWildCardPtr[0] == 0)
                    return true;

                if(AsciiToUpperTable_BkSlash[szWildCardPtr[0]] == AsciiToUpperTable_BkSlash[szString[0]])
                {
                    if(CheckWildCard(szString, szWildCardPtr))
                        return true;
                }
            }
            else
            {
                if(AsciiToUpperTable_BkSlash[szWildCardPtr[0]] != AsciiToUpperTable_BkSlash[szString[0]])
                    return false;

                szWildCard = szWildCardPtr + 1;
            }

            if(szString[0] == 0)
                return false;
            szString++;
        }
        else
        {
            return (szString[0] == 0) ? true : false;
        }
    }
}

//-----------------------------------------------------------------------------
// 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 */
}
