windows-xp/Source/XPSP1/NT/sdktools/unicows/godot/util.c

/*++

Copyright (c) 2000-2001,  Microsoft Corporation  All rights reserved.

Module Name:

    util.c

Abstract:

    Several utility functions we need are thrown in here for kicks.

        MiniAtoI
        CpgFromLocale
        CbPerChOfCpg
        GetKernelHandle
        GetUserHandle
        GetAdvapiHandle
        GetRasHandle
        GetOtherRasHandle
        GetComDlgHandle
        cchUnicodeMultiSz
        cbAnsiMultiSz

Revision History:

    17 Mar 2001    v-michka    Created.

--*/

#include "precomp.h"

// forward declares
void LoadLibrarySafe(HMODULE * phMod, char * Library);

// our remembered handles for various DLLs we dynamically load from
// CONSIDER: Maybe we could free up the one handle we have for each
//           library? We cannot do this in DllMain according to PSDK
//           docs, but maybe it is worth doing if we are being 
//           unloaded anyway by the caller?
static HMODULE m_hModGB18030 = 0;
static HMODULE m_hModComDlg = 0;
static HMODULE m_hModOtherRas = 0;
static HMODULE m_hModRas = 0;
static HMODULE m_hModAdvapi = 0;
static HMODULE m_hModUser = 0;
static HMODULE m_hModKernel = 0;
static HMODULE m_hModSensapi = 0;
static HMODULE m_hModOleAcc = 0;

/*-------------------------------
    CpgFromLocale

    Given a locale, returns the appropriate codepage to use
    for conversions
-------------------------------*/
UINT CpgFromLocale(LCID Locale)
{
    char lpLCData[6];    // Max of this param, per PSDK docs
    
    if (GetLocaleInfoA(Locale, LOCALE_IDEFAULTANSICODEPAGE, lpLCData, 6))
        return(MiniAtoI(lpLCData));

    return(g_acp);
}

/*-------------------------------
    CpgOemFromLocale

    Given a locale, returns the appropriate OEM codepage to use
    for conversions
-------------------------------*/
UINT CpgOemFromLocale(LCID Locale)
{
    char lpLCData[6];    // Max of this param, per PSDK docs
    
    if (GetLocaleInfoA(Locale, LOCALE_IDEFAULTCODEPAGE, lpLCData, 6))
        return(MiniAtoI(lpLCData));

    return(g_oemcp);
}

#pragma intrinsic (strlen)

/*-------------------------------
    MiniAtoI

    Our baby version of the atoi function. Since we know that we always have
    full digits with no white space, we can be nicer about this than the
    VC runtime version is (since they have so many special cases).
-------------------------------*/
UINT MiniAtoI(const char * lpsz)
{
    size_t cch = (lpsz ? strlen(lpsz) : 0);
    UINT RetVal = 0;
    UINT mod = 1;
    UINT ich;
    char ch;

    for(ich = 1 ; ich <= cch ; ich++)
    {
        ch = lpsz[cch - ich];
        RetVal += ((ch - '0') * mod);
        mod *= 10;
    }
    return(RetVal);
}

/*-------------------------------
    CbPerChOfCpg

    Given a code page, returns the maximum number of bytes 
    that can be needed for a single character.
-------------------------------*/
UINT CbPerChOfCpg(UINT cpg)
{
    CPINFO cpi;

    if(GetCPInfo(cpg, &cpi))
        return(cpi.MaxCharSize);

    // We should not fail here, but if we do, default to requiring a big
    // buffer, just to be safe.
    return(2);
}

/*-------------------------------
    CpgFromHdc

    Given a device context handle, returns the code page to 
    use. This is something that a lot of GDI functions do.
-------------------------------*/
UINT CpgFromHdc(HDC hdc)
{
    int chs;
    CHARSETINFO csi;

    chs = GetTextCharset(hdc);
    if(TranslateCharsetInfo(&(DWORD)chs, &csi, TCI_SRCCHARSET))
        return(csi.ciACP);
    else
        return(g_acp);
}

/*-------------------------------
    GetUserHandle
-------------------------------*/
HMODULE GetUserHandle(void)
{
    if (!m_hModUser)
    {
        m_hModUser = GetModuleHandleA("user32");
        if (!m_hModUser)
            LoadLibrarySafe(&m_hModUser, "user32");
    }
    return(m_hModUser);
}

/*-------------------------------
    GetComDlgHandle
-------------------------------*/
HMODULE GetComDlgHandle(void)
{
    if (!m_hModComDlg)
        LoadLibrarySafe(&m_hModComDlg, "comdlg32.dll");

    return m_hModComDlg;
}

/*-------------------------------
    GetGB18030Handle
-------------------------------*/
HMODULE GetGB18030Handle(void)
{
    if (!m_hModGB18030)
        LoadLibrarySafe(&m_hModGB18030, "c_gb18030.dll");

    return m_hModGB18030;
}

/*-------------------------------
    GetKernelProc
    
    We do not need to call LoadLibrary since we are sure it is 
    loaded (it is loaded into every process!)
-------------------------------*/
FARPROC GetKernelProc(LPCSTR Function)
{
    if (!m_hModKernel)
        m_hModKernel = GetModuleHandleA("kernel32");
    return(GetProcAddress(m_hModKernel, Function));
}

/*-------------------------------
    GetUserProc
-------------------------------*/
FARPROC GetUserProc(LPCSTR Function)
{
    return(GetProcAddress(GetUserHandle(), Function));
}

/*-------------------------------
    GetAdvapiProc
-------------------------------*/
FARPROC GetAdvapiProc(LPCSTR Function)
{
    if (!m_hModAdvapi)
    {
        m_hModAdvapi = GetModuleHandleA("advapi32");
        if (!m_hModAdvapi)
            LoadLibrarySafe(&m_hModAdvapi, "advapi32");
    }
    return(GetProcAddress(m_hModAdvapi, Function));
}

/*-------------------------------
    GetOleAccProc
-------------------------------*/
FARPROC GetOleAccProc(LPCSTR Function)
{
    if (!m_hModOleAcc)
        LoadLibrarySafe(&m_hModOleAcc, "oleacc.dll");
    return(GetProcAddress(m_hModOleAcc, Function));
}

/*-------------------------------
    GetSensApiProc
-------------------------------*/
FARPROC GetSensApiProc(LPCSTR Function)
{
    if (!m_hModSensapi)
        LoadLibrarySafe(&m_hModSensapi, "sensapi.dll");
    return(GetProcAddress(m_hModSensapi, Function));
}

/*-------------------------------
    GetRasProc

    All RAS procs are in some DLL but we do not know
    which one; therefore, we use this wrapper to get
    the procs
-------------------------------*/
FARPROC GetRasProc(LPCSTR Function)
{
    FARPROC RetVal;

    if (!m_hModRas)
        LoadLibrarySafe(&m_hModRas, "rasapi32.dll");
    RetVal = GetProcAddress(m_hModRas, Function);

    if(RetVal==0)
    {
        if (!m_hModOtherRas)
            LoadLibrarySafe(&m_hModOtherRas, "rnaph.dll");
        RetVal = GetProcAddress(m_hModOtherRas, Function);
    }

    return(RetVal);
}

/*-------------------------------
    LoadLibrarySafe

    Keeps us from ever LoadLibrarying more than one
    time in multithreaded scenarios.
-------------------------------*/
void LoadLibrarySafe(HMODULE * phMod, char * Library)
{
    HMODULE hModT = LoadLibraryA(Library);

    if(InterlockedExchange((LPLONG)&(*phMod), (LONG)hModT) != 0)
    {
        // Some other thread beat us to it, lets unload our instance
        FreeLibrary(hModT);
    }
}


//----------------------------------------------------------------------------
// There are strings which are blocks of strings end to end with a trailing '\0'
// to indicate the true end.  These strings are used with the REG_MULTI_SZ
// option of the Reg... routines and the lpstrFilter field of the OPENFILENAME
// structure used in the GetOpenFileName and GetSaveFileName routines.  To help
// in converting these strings here are two routines which calculate the size
// of the Unicode and ANSI versions (including all '\0's!):

// Stolen from VSANSI

//----------------------------------------------------------------
// Return size of WCHAR string list in WCHARs.
size_t cchUnicodeMultiSz(LPCWSTR lpsz)
{
    LPCWSTR pch = lpsz;
    for (;;)
    {
        if (*pch)
            pch++;
        else
        {
            pch++;
            if (!*pch)
                break;
        }
    }
    return 1 + (pch - lpsz);
}

//----------------------------------------------------------------
// Return size of ANSI string list in bytes.
size_t cbAnsiMultiSz(LPCSTR lpsz)
{
    LPCSTR pch = lpsz;
    for (;;)
    {
        if (*pch)
            pch++;
        else
        {
            pch++;
            // Break if we've reached the double Null
            if (!*pch)
                break;
        }
    }
    return 1 + (pch - lpsz);
}