w2k_lib.c

Undocumented Windows 2000 Secrets简体中文版.+源码光盘

                    }
                case '-':
                    {
                    fRight = TRUE;
                    break;
                    }
                case '0':
                    {
                    fZero = TRUE;
                    break;
                    }
                case '#':
                    {
                    fPrefix = TRUE;
                    break;
                    }
// output width
                default:
                    {
                    if (fPrecision = (pwFormat [dFormat] == '.'))
                        {
                        dFormat++;
                        dPrecision = 0;

                        fSkip = FALSE;
                        }
                    if ((pwFormat [dFormat] >= '0') &&
                        (pwFormat [dFormat] <= '9'))
                        {
                        dNumber = 0;

                        while ((pwFormat [dFormat] >= '0') &&
                               (pwFormat [dFormat] <= '9'))
                            {
                            dNumber *= 10;
                            dNumber += (pwFormat [dFormat++] - '0');
                            }
                        if (fPrecision)
                            {
                            dPrecision = dNumber;
                            }
                        else
                            {
                            dWidth = dNumber;
                            }
                        fSkip = FALSE;
                        }
                    break;
                    }
                }
            if (fSkip) dFormat++;
            }
        }
    if (pwBuffer != NULL) pwBuffer [dOffset+n] = 0;

    if (pdFormat != NULL) *pdFormat = dFormat;
    if (ppData   != NULL) *ppData   = pData;
    return n;
    }

// -----------------------------------------------------------------

DWORD WINAPI w2kFormatMulti (PWORD pwBuffer,
                             DWORD dOffset,
                             PWORD pwFormat,
                             PVOID pArguments,
                             WORD  wFill,
                             BOOL  fUnicode)
    {
    PVOID pData;
    DWORD i, j;
    DWORD n = 0;

    if (pwFormat != NULL)
        {
        if ((pData = pArguments) != NULL)
            {
            for (i = 0; pwFormat [i]; i = j)
                {
                for (j = i; pwFormat [j] && (pwFormat [j] != '%');
                     j++);

                n += w2kFormatUnicode (pwBuffer, dOffset+n,
                                       pwFormat+i, j-i,
                                       0, -1, wFill,
                                       TRUE, FALSE);

                if (pwFormat [j] == '%')
                    {
                    j++;

                    n += w2kFormatSingle (pwBuffer, dOffset+n,
                                          pwFormat, &j, &pData,
                                          wFill, fUnicode);
                    }
                }
            }
        else
            {
            n = w2kFormatUnicode (pwBuffer, dOffset,
                                  pwFormat, -1,
                                  0, -1, wFill,
                                  TRUE, FALSE);
            }
        }
    if (pwBuffer != NULL) pwBuffer [dOffset+n] = 0;
    return n;
    }

// -----------------------------------------------------------------

PBYTE WINAPI w2kFormatW2A (PWORD pwFrom,
                           PBYTE pbTo)
    {
    DWORD n;
    PBYTE pbTo1 = NULL;

    if (pwFrom != NULL)
        {
        for (n = 0; pwFrom [n]; n++);

        if ((pbTo1 = (pbTo != NULL ? pbTo : w2kMemoryAnsi (n+1)))
            != NULL)
            {
            if (!WideCharToMultiByte
                     (CP_ACP, WC_COMPOSITECHECK | WC_DISCARDNS,
                      pwFrom, -1, pbTo1, n+1, NULL, NULL))
                {
                do  {
                    pbTo1 [n] = (pwFrom [n] < 0x0100
                                 ? (BYTE) pwFrom [n]
                                 : INVALID_UNICODE);
                    }
                while (n--);
                }
            }
        }
    return pbTo1;
    }

// =================================================================
// vprintf() FAMILY
// =================================================================

DWORD WINAPI _vsprintf (PWORD pwBuffer,
                        PWORD pwFormat,
                        PVOID pArguments)
    {
    return w2kFormatMulti (pwBuffer, 0, pwFormat, pArguments,
                           gwFill, TRUE);
    }

// -----------------------------------------------------------------

INT WINAPI _vmprintf (HWND  hWnd,
                      UINT  uiType,
                      PWORD pwCaption,
                      PWORD pwFormat,
                      PVOID pArguments)
    {
    PWORD pwBuffer;
    DWORD dBuffer;
    INT   iId = IDABORT;

    dBuffer = _vsprintf (NULL, pwFormat, pArguments);

    if ((pwBuffer = w2kMemoryUnicode (dBuffer+1)) != NULL)
        {
        _vsprintf (pwBuffer, pwFormat, pArguments);

        iId = MessageBox (hWnd, pwBuffer,
                          (pwCaption != NULL ? pwCaption
                                             : awCaption),
                          uiType);

        w2kMemoryDestroy (pwBuffer);
        }
    return iId;
    }

// -----------------------------------------------------------------

DWORD WINAPI _vfprintf (HANDLE hFile,
                        PWORD  pwFormat,
                        PVOID  pArguments)
    {
    PWORD pwBuffer;
    PBYTE pbBuffer;
    DWORD dBuffer, n1, n2;
    DWORD n = 0;

    dBuffer = _vsprintf (NULL, pwFormat, pArguments);

    if ((pwBuffer = w2kMemoryUnicode (dBuffer+1)) != NULL)
        {
        _vsprintf (pwBuffer, pwFormat, pArguments);

        if ((pbBuffer = w2kFormatW2A (pwBuffer, NULL)) != NULL)
            {
            while (dBuffer > n)
                {
                n1 = min (dBuffer-n, N_WRITE);
                n2 = 0;

                if (WriteFile (hFile, pbBuffer+n, n1, &n2, NULL)
                    && n2)
                    {
                    n += n2;
                    }
                else break;
                }
            w2kMemoryDestroy (pbBuffer);
            }
        w2kMemoryDestroy (pwBuffer);
        }
    return n;
    }

// -----------------------------------------------------------------

DWORD WINAPI _veprintf (PWORD pwFormat,
                        PVOID pArguments)
    {
    w2kConsoleOpen ();
    return _vfprintf (ghStdError, pwFormat, pArguments);
    }

// -----------------------------------------------------------------

DWORD WINAPI _vprintf (PWORD pwFormat,
                       PVOID pArguments)
    {
    w2kConsoleOpen ();
    return _vfprintf (ghStdOutput, pwFormat, pArguments);
    }

// =================================================================
// printf() FAMILY
// =================================================================

DWORD WINAPI _sprintf (PWORD pwBuffer,
                       PWORD pwFormat,
                       ...)
    {
    return _vsprintf (pwBuffer, pwFormat, (&pwFormat)+1);
    }

// -----------------------------------------------------------------

INT WINAPI _mprintf (HWND  hWnd,
                     UINT  uiType,
                     PWORD pwCaption,
                     PWORD pwFormat,
                     ...)
    {
    return _vmprintf (hWnd, uiType, pwCaption, pwFormat,
                      (&pwFormat)+1);
    }

// -----------------------------------------------------------------

DWORD WINAPI _fprintf (HANDLE hFile,
                       PWORD  pwFormat,
                       ...)
    {
    return _vfprintf (hFile, pwFormat, (&pwFormat)+1);
    }

// -----------------------------------------------------------------

DWORD WINAPI _eprintf (PWORD pwFormat,
                      ...)
    {
    return _veprintf (pwFormat, (&pwFormat)+1);
    }

// -----------------------------------------------------------------

DWORD WINAPI _printf (PWORD pwFormat,
                      ...)
    {
    return _vprintf (pwFormat, (&pwFormat)+1);
    }

// =================================================================
// STRING PROCESSING
// =================================================================

PWORD WINAPI _strcpy (PWORD pwTo,
                      PWORD pwFrom,
                      PWORD pwDefault)
    {
    return (pwTo != NULL

            ? lstrcpy (pwTo,
                       (pwFrom != NULL
                        ? pwFrom
                        : (pwDefault != NULL
                           ? pwDefault
                           : awNull)))
            : NULL);
    }

// -----------------------------------------------------------------

PWORD WINAPI _strcpyn (PWORD pwTo,
                       PWORD pwFrom,
                       PWORD pwDefault,
                       DWORD dTo)
    {
    return ((pwTo != NULL) && dTo

            ? lstrcpyn (pwTo,
                        (pwFrom != NULL
                         ? pwFrom
                         : (pwDefault != NULL
                            ? pwDefault
                            : awNull)),
                        dTo)
            : NULL);
    }

// =================================================================
// CRC32 COMPUTATION
// =================================================================

DWORD WINAPI w2kCrc32Start (PDWORD pdCrc32)
    {
    *pdCrc32 = 0xFFFFFFFF;
    return *pdCrc32;
    }

// -----------------------------------------------------------------

BOOL WINAPI w2kCrc32Stop (PDWORD pdCrc32)
    {
    *pdCrc32 = ~*pdCrc32;
    return (*pdCrc32 == 0xDEBB20E3);
    }

// -----------------------------------------------------------------

DWORD WINAPI w2kCrc32Byte (PDWORD pdCrc32,
                           BYTE   bData)
    {
    *pdCrc32 = (*pdCrc32 >> 8) ^ adCrc32 [(BYTE) *pdCrc32 ^ bData];
    return *pdCrc32;
    }

// -----------------------------------------------------------------

DWORD WINAPI w2kCrc32Word (PDWORD pdCrc32,
                           WORD   wData)
    {
    w2kCrc32Byte (pdCrc32, LOBYTE (wData));
    return w2kCrc32Byte (pdCrc32, HIBYTE (wData));
    }

// -----------------------------------------------------------------

DWORD WINAPI w2kCrc32Dword (PDWORD pdCrc32,
                            DWORD  dData)
    {
    w2kCrc32Word (pdCrc32, LOWORD (dData));
    return w2kCrc32Word (pdCrc32, HIWORD (dData));
    }

// -----------------------------------------------------------------

DWORD WINAPI w2kCrc32Multi (PDWORD pdCrc32,
                            PVOID  pData,
                            DWORD  dData)
    {
    DWORD dCrc32, i;

    if (pdCrc32 != NULL) dCrc32 = *pdCrc32;
    else w2kCrc32Start (&dCrc32);

    if (pData != NULL)
        {
        for (i = 0; i < dData; i++)
            {
            w2kCrc32Byte (&dCrc32, ((PBYTE) pData) [i]);
            }
        }
    if (pdCrc32 != NULL) *pdCrc32 = dCrc32;
    else w2kCrc32Stop (&dCrc32);

    return dCrc32;
    }

// -----------------------------------------------------------------

DWORD WINAPI w2kCrc32Text (PDWORD pdCrc32,
                           PWORD  pwData,
                           DWORD  dData)
    {
    DWORD dCrc32, i, n;

    if (pdCrc32 != NULL) dCrc32 = *pdCrc32;
    else w2kCrc32Start (&dCrc32);

    if (pwData != NULL)
        {
        n = (dData != -1 ? dData : lstrlen (pwData));

        for (i = 0; i < n; i++)
            {
            w2kCrc32Word (&dCrc32, pwData [i]);
            }
        }
    if (pdCrc32 != NULL) *pdCrc32 = dCrc32;
    else w2kCrc32Stop (&dCrc32);

    return dCrc32;
    }

// =================================================================
// PSEUDO-RANDOM NUMBER GENERATOR
// =================================================================

DWORD WINAPI w2kRandomInitialize (PDWORD pdData,
                                  PDWORD pdAddress,
                                  DWORD  dSeed)
    {
    *pdData = *pdAddress = (dSeed ? dSeed : GetTickCount ());

    w2kRandomByte (pdData, pdAddress);
    w2kRandomByte (pdData, pdAddress);
    w2kRandomByte (pdData, pdAddress);
    w2kRandomByte (pdData, pdAddress);

    return *pdData;
    }