ATL::CRegObject Class Reference

#include <statreg.h>

Inheritance diagram for ATL::CRegObject:

Collaboration diagram for ATL::CRegObject:

Classes
struct	rep_list_str
struct	strbuf

Public Types
typedef struct ATL::CRegObject::rep_list_str	rep_list
Public Types inherited from IUnknown
typedef IUnknown *	LPUNKNOWN

Public Member Functions
	CRegObject ()
	~CRegObject ()
HRESULT STDMETHODCALLTYPE	QueryInterface (const IID &, void **)
ULONG STDMETHODCALLTYPE	AddRef ()
ULONG STDMETHODCALLTYPE	Release ()
HRESULT STDMETHODCALLTYPE	AddReplacement (LPCOLESTR key, LPCOLESTR item)
HRESULT STDMETHODCALLTYPE	ClearReplacements ()
HRESULT STDMETHODCALLTYPE	ResourceRegisterSz (LPCOLESTR resFileName, LPCOLESTR szID, LPCOLESTR szType)
HRESULT STDMETHODCALLTYPE	ResourceUnregisterSz (LPCOLESTR resFileName, LPCOLESTR szID, LPCOLESTR szType)
HRESULT STDMETHODCALLTYPE	FileRegister (LPCOLESTR fileName)
HRESULT STDMETHODCALLTYPE	FileUnregister (LPCOLESTR fileName)
HRESULT STDMETHODCALLTYPE	StringRegister (LPCOLESTR data)
HRESULT STDMETHODCALLTYPE	StringUnregister (LPCOLESTR data)
HRESULT STDMETHODCALLTYPE	ResourceRegister (LPCOLESTR resFileName, UINT nID, LPCOLESTR szType)
HRESULT STDMETHODCALLTYPE	ResourceUnregister (LPCOLESTR resFileName, UINT nID, LPCOLESTR szType)
Public Member Functions inherited from IRegistrarBase
HRESULT	AddReplacement ([in] LPCOLESTR Key, [in] LPCOLESTR item)
HRESULT	ClearReplacements ()
virtual HRESULT STDMETHODCALLTYPE	AddReplacement (LPCOLESTR key, LPCOLESTR item)=0
virtual HRESULT STDMETHODCALLTYPE	ClearReplacements ()=0
Public Member Functions inherited from IUnknown
HRESULT	QueryInterface ([in] REFIID riid, [out, iid_is(riid)] void **ppvObject)
ULONG	AddRef ()
ULONG	Release ()

Public Attributes
rep_list *	m_rep

Protected Member Functions
HRESULT STDMETHODCALLTYPE	RegisterWithResource (LPCOLESTR resFileName, LPCOLESTR szID, LPCOLESTR szType, BOOL doRegister)
HRESULT STDMETHODCALLTYPE	RegisterWithFile (LPCOLESTR fileName, BOOL doRegister)
HRESULT STDMETHODCALLTYPE	RegisterWithString (LPCOLESTR data, BOOL doRegister)

Private Member Functions
LONG	RegDeleteTreeX (HKEY parentKey, LPCWSTR subKeyName)
HRESULT	strbuf_init (strbuf *buf)
HRESULT	strbuf_write (LPCOLESTR str, strbuf *buf, int len)
HRESULT	file_register (LPCOLESTR fileName, BOOL do_register)
HRESULT	resource_register (LPCOLESTR resFileName, LPCOLESTR szID, LPCOLESTR szType, BOOL do_register)
HRESULT	string_register (LPCOLESTR data, BOOL do_register)
HRESULT	do_preprocess (LPCOLESTR data, strbuf *buf)
HRESULT	get_word (LPCOLESTR *str, strbuf *buf)
unsigned int	HexToBin (OLECHAR a)
HRESULT	do_process_key (LPCOLESTR *pstr, HKEY parent_key, strbuf *buf, BOOL do_register)
HRESULT	do_process_root_key (LPCOLESTR data, BOOL do_register)

Detailed Description

Definition at line 34 of file statreg.h.

Member Typedef Documentation

rep_list

typedef struct ATL::CRegObject::rep_list_str ATL::CRegObject::rep_list

Constructor & Destructor Documentation

CRegObject()

ATL::CRegObject::CRegObject ( )

inline

Definition at line 55 of file statreg.h.

    {
        m_rep = NULL;
    }

~CRegObject()

ATL::CRegObject::~CRegObject ( )

inline

Definition at line 60 of file statreg.h.

    {
        HRESULT hResult;
 
        hResult = ClearReplacements();
        ATLASSERT(SUCCEEDED(hResult));
        (void)hResult;
    }

Member Function Documentation

AddRef()

ULONG STDMETHODCALLTYPE ATL::CRegObject::AddRef ( void  )

inline

Implements IUnknown.

Definition at line 75 of file statreg.h.

    {
        ATLASSERT(FALSE && TEXT("statically linked in CRegObject is not a com object. Do not call this function"));
        return 1;
    }

AddReplacement()

HRESULT STDMETHODCALLTYPE ATL::CRegObject::AddReplacement ( LPCOLESTR  key, LPCOLESTR  item  )

inlinevirtual

Implements IRegistrarBase.

Definition at line 87 of file statreg.h.

    {
        int len;
        rep_list *new_rep;
 
        new_rep = reinterpret_cast<rep_list *>(HeapAlloc(GetProcessHeap(), 0, sizeof(rep_list)));
        if (new_rep == NULL)
            return E_OUTOFMEMORY;
 
        new_rep->key_len  = lstrlenW(key);
        new_rep->key = reinterpret_cast<OLECHAR *>(HeapAlloc(GetProcessHeap(), 0, (new_rep->key_len + 1) * sizeof(OLECHAR)));
        if (new_rep->key == NULL)
        {
            HeapFree(GetProcessHeap(), 0, new_rep);
            return E_OUTOFMEMORY;
        }
        memcpy(new_rep->key, key, (new_rep->key_len + 1) * sizeof(OLECHAR));
 
        len = lstrlenW(item) + 1;
        new_rep->item = reinterpret_cast<OLECHAR *>(HeapAlloc(GetProcessHeap(), 0, len * sizeof(OLECHAR)));
        if (new_rep->item == NULL)
        {
            HeapFree(GetProcessHeap(), 0, new_rep->key);
            HeapFree(GetProcessHeap(), 0, new_rep);
            return E_OUTOFMEMORY;
        }
        memcpy(new_rep->item, item, len * sizeof(OLECHAR));
 
        new_rep->next = m_rep;
        m_rep = new_rep;
 
        return S_OK;
    }

Referenced by ATL::CAtlModule::CommonInitRegistrar().

ClearReplacements()

HRESULT STDMETHODCALLTYPE ATL::CRegObject::ClearReplacements ( )

inlinevirtual

Implements IRegistrarBase.

Definition at line 121 of file statreg.h.

    {
        rep_list *iter;
        rep_list *iter2;
 
        iter = m_rep;
        while (iter)
        {
            iter2 = iter->next;
            HeapFree(GetProcessHeap(), 0, iter->key);
            HeapFree(GetProcessHeap(), 0, iter->item);
            HeapFree(GetProcessHeap(), 0, iter);
            iter = iter2;
        }
 
        m_rep = NULL;
        return S_OK;
    }

Referenced by ~CRegObject().

do_preprocess()

HRESULT ATL::CRegObject::do_preprocess ( LPCOLESTR  data, strbuf *  buf  )

inlineprivate

Definition at line 366 of file statreg.h.

    {
        LPCOLESTR iter;
        LPCOLESTR iter2;
        rep_list *rep_iter;
        HRESULT hResult;
 
        iter2 = data;
        iter = wcschr(data, '%');
        while (iter)
        {
            hResult = strbuf_write(iter2, buf, static_cast<int>(iter - iter2));
            if (FAILED(hResult))
                return hResult;
 
            iter2 = ++iter;
            if (!*iter2)
                return DISP_E_EXCEPTION;
            iter = wcschr(iter2, '%');
            if (!iter)
                return DISP_E_EXCEPTION;
 
            if (iter == iter2)
            {
                hResult = strbuf_write(L"%", buf, 1);
                if (FAILED(hResult))
                    return hResult;
            }
            else
            {
                for (rep_iter = m_rep; rep_iter; rep_iter = rep_iter->next)
                {
                    if (rep_iter->key_len == iter - iter2 && !_memicmp(iter2, rep_iter->key, rep_iter->key_len * sizeof(wchar_t)))
                        break;
                }
                if (!rep_iter)
                    return DISP_E_EXCEPTION;
 
                hResult = strbuf_write(rep_iter->item, buf, -1);
                if (FAILED(hResult))
                    return hResult;
            }
 
            iter2 = ++iter;
            iter = wcschr(iter, '%');
        }
 
        hResult = strbuf_write(iter2, buf, -1);
        if (FAILED(hResult))
            return hResult;
 
        return S_OK;
    }

Referenced by string_register().

do_process_key()

HRESULT ATL::CRegObject::do_process_key ( LPCOLESTR *  pstr, HKEY  parent_key, strbuf *  buf, BOOL  do_register  )

inlineprivate

Definition at line 486 of file statreg.h.

    {
        LPCOLESTR iter;
        HRESULT hres;
        LONG lres;
        HKEY hkey;
        strbuf name;
 
        enum {
            NORMAL,
            NO_REMOVE,
            IS_VAL,
            FORCE_REMOVE,
            DO_DELETE
        } key_type = NORMAL;
 
        static const wchar_t *wstrNoRemove = L"NoRemove";
        static const wchar_t *wstrForceRemove = L"ForceRemove";
        static const wchar_t *wstrDelete = L"Delete";
        static const wchar_t *wstrval = L"val";
 
        iter = *pstr;
        hkey = NULL;
        hres = get_word(&iter, buf);
        if (FAILED(hres))
            return hres;
        hres = strbuf_init(&name);
        if (FAILED(hres))
            return hres;
 
        while(buf->str[1] || buf->str[0] != '}')
        {
            key_type = NORMAL;
            if (!lstrcmpiW(buf->str, wstrNoRemove))
                key_type = NO_REMOVE;
            else if (!lstrcmpiW(buf->str, wstrForceRemove))
                key_type = FORCE_REMOVE;
            else if (!lstrcmpiW(buf->str, wstrval))
                key_type = IS_VAL;
            else if (!lstrcmpiW(buf->str, wstrDelete))
                key_type = DO_DELETE;
 
            if (key_type != NORMAL)
            {
                hres = get_word(&iter, buf);
                if (FAILED(hres))
                    break;
            }
 
            if (do_register)
            {
                if (key_type == IS_VAL)
                {
                    hkey = parent_key;
                    hres = strbuf_write(buf->str, &name, -1);
                    if (FAILED(hres))
                        return hres;
                }
                else if (key_type == DO_DELETE)
                {
                    RegDeleteTreeX(parent_key, buf->str);
                }
                else
                {
                    if (key_type == FORCE_REMOVE)
                        RegDeleteTreeX(parent_key, buf->str);
                    lres = RegCreateKeyW(parent_key, buf->str, &hkey);
                    if (lres != ERROR_SUCCESS)
                    {
                        hres = HRESULT_FROM_WIN32(lres);
                        break;
                    }
                }
            }
            else if (key_type != IS_VAL && key_type != DO_DELETE)
            {
                hres = strbuf_write(buf->str, &name, -1);
                if (FAILED(hres))
                    return hres;
                lres = RegOpenKeyW(parent_key, buf->str, &hkey);
                if (lres != ERROR_SUCCESS)
                {
                }
            }
 
            if (key_type != DO_DELETE && *iter == '=')
            {
                iter++;
                hres = get_word(&iter, buf);
                if (FAILED(hres))
                    break;
                if (buf->len != 1)
                {
                    hres = DISP_E_EXCEPTION;
                    break;
                }
                if (do_register)
                {
                    switch(buf->str[0])
                    {
                        case 's':
                            hres = get_word(&iter, buf);
                            if (FAILED(hres))
                                break;
                            lres = RegSetValueExW(hkey, name.len ? name.str :  NULL, 0, REG_SZ, (PBYTE)buf->str,
                                    (lstrlenW(buf->str) + 1) * sizeof(WCHAR));
                            if (lres != ERROR_SUCCESS)
                                hres = HRESULT_FROM_WIN32(lres);
                            break;
                        case 'e':
                            hres = get_word(&iter, buf);
                            if (FAILED(hres))
                                break;
                            lres = RegSetValueExW(hkey, name.len ? name.str :  NULL, 0, REG_EXPAND_SZ, (PBYTE)buf->str,
                                    (lstrlenW(buf->str) + 1) * sizeof(WCHAR));
                            if (lres != ERROR_SUCCESS)
                                hres = HRESULT_FROM_WIN32(lres);
                            break;
                        case 'd':
                            {
                                hres = get_word(&iter, buf);
                                if (FAILED(hres))
                                    break;
                                WCHAR *end;
                                DWORD dw;
                                if ((buf->str[0] == '0' && buf->str[1] == 'x') || (buf->str[0] == '&' && buf->str[1] == 'H'))
                                    dw = wcstoul(&buf->str[2], &end, 16);
                                else
                                    dw = wcstol(&buf->str[0], &end, 10);
                                lres = RegSetValueExW(hkey, name.len ? name.str :  NULL, 0, REG_DWORD, (PBYTE)&dw, sizeof(dw));
                                if (lres != ERROR_SUCCESS)
                                    hres = HRESULT_FROM_WIN32(lres);
                                break;
                            }
                        case 'b':
                            {
                                DWORD            count;
                                DWORD            curIndex;
 
                                hres = get_word(&iter, buf);
                                if (FAILED(hres))
                                    break;
                                count = buf->len;
                                if ((count & 1) != 0)
                                    return DISP_E_EXCEPTION;
                                count = count / 2;
                                for (curIndex = 0; curIndex < count; curIndex++)
                                    ((BYTE*)buf->str)[curIndex] = (HexToBin(buf->str[curIndex * 2]) << 4) | HexToBin(buf->str[curIndex * 2 + 1]);
                                lres = RegSetValueExW(hkey, name.len ? name.str :  NULL, 0, REG_BINARY, (PBYTE)buf->str, count);
                                if (lres != ERROR_SUCCESS)
                                    hres = HRESULT_FROM_WIN32(lres);
                                break;
                            }
                        default:
                            hres = DISP_E_EXCEPTION;
                    }
                    if (FAILED(hres))
                        break;
                }
                else
                {
                    if (*iter == '-')
                        iter++;
                    hres = get_word(&iter, buf);
                    if (FAILED(hres))
                        break;
                }
            }
            else if(key_type == IS_VAL)
            {
                hres = DISP_E_EXCEPTION;
                break;
            }
 
            if (key_type != IS_VAL && key_type != DO_DELETE && *iter == '{' && iswspace(iter[1]))
            {
                hres = get_word(&iter, buf);
                if (FAILED(hres))
                    break;
                hres = do_process_key(&iter, hkey, buf, do_register);
                if (FAILED(hres))
                    break;
            }
 
            if (!do_register && (key_type == NORMAL || key_type == FORCE_REMOVE))
            {
                RegDeleteKeyW(parent_key, name.str);
            }
 
            if (hkey && key_type != IS_VAL)
                RegCloseKey(hkey);
            hkey = 0;
            name.len = 0;
 
            hres = get_word(&iter, buf);
            if (FAILED(hres))
                break;
        }
 
        HeapFree(GetProcessHeap(), 0, name.str);
        if (hkey && key_type != IS_VAL)
            RegCloseKey(hkey);
        *pstr = iter;
        return hres;
    }

Referenced by do_process_key(), and do_process_root_key().

do_process_root_key()

HRESULT ATL::CRegObject::do_process_root_key ( LPCOLESTR  data, BOOL  do_register  )

inlineprivate

Definition at line 692 of file statreg.h.

    {
        LPCOLESTR iter;
        strbuf buf;
        unsigned int i;
        HRESULT hResult;
        static const struct {
            const wchar_t *name;
            HKEY key;
        } root_keys[] = {
            {L"HKEY_CLASSES_ROOT", HKEY_CLASSES_ROOT},
            {L"HKEY_CURRENT_USER", HKEY_CURRENT_USER},
            {L"HKEY_LOCAL_MACHINE", HKEY_LOCAL_MACHINE},
            {L"HKEY_USERS", HKEY_USERS},
            {L"HKEY_PERFORMANCE_DATA", HKEY_PERFORMANCE_DATA},
            {L"HKEY_DYN_DATA", HKEY_DYN_DATA},
            {L"HKEY_CURRENT_CONFIG", HKEY_CURRENT_CONFIG},
            {L"HKCR", HKEY_CLASSES_ROOT},
            {L"HKCU", HKEY_CURRENT_USER},
            {L"HKLM", HKEY_LOCAL_MACHINE},
            {L"HKU", HKEY_USERS},
            {L"HKPD", HKEY_PERFORMANCE_DATA},
            {L"HKDD", HKEY_DYN_DATA},
            {L"HKCC", HKEY_CURRENT_CONFIG},
        };
 
        iter = data;
 
        hResult = strbuf_init(&buf);
        if (FAILED(hResult))
            return hResult;
        hResult = get_word(&iter, &buf);
        if (FAILED(hResult))
            return hResult;
 
        while (*iter)
        {
            if (!buf.len)
            {
                hResult = DISP_E_EXCEPTION;
                break;
            }
            for (i = 0; i < sizeof(root_keys) / sizeof(root_keys[0]); i++)
            {
                if (!lstrcmpiW(buf.str, root_keys[i].name))
                    break;
            }
            if (i == sizeof(root_keys) / sizeof(root_keys[0]))
            {
                hResult = DISP_E_EXCEPTION;
                break;
            }
            hResult = get_word(&iter, &buf);
            if (FAILED(hResult))
                break;
            if (buf.str[1] || buf.str[0] != '{')
            {
                hResult = DISP_E_EXCEPTION;
                break;
            }
            hResult = do_process_key(&iter, root_keys[i].key, &buf, do_register);
            if (FAILED(hResult))
                break;
            hResult = get_word(&iter, &buf);
            if (FAILED(hResult))
                break;
        }
        HeapFree(GetProcessHeap(), 0, buf.str);
        return hResult;
    }

Referenced by string_register().

file_register()

HRESULT ATL::CRegObject::file_register ( LPCOLESTR  fileName, BOOL  do_register  )

inlineprivate

Definition at line 253 of file statreg.h.

    {
        HANDLE file;
        DWORD filelen;
        DWORD len;
        LPWSTR regstrw;
        LPSTR regstra;
        LRESULT lres;
        HRESULT hResult;
 
        file = CreateFileW(fileName, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, NULL);
        if (file != INVALID_HANDLE_VALUE)
        {
            filelen = GetFileSize(file, NULL);
            regstra = reinterpret_cast<LPSTR>(HeapAlloc(GetProcessHeap(), 0, filelen));
            if (regstra == NULL)
                return E_OUTOFMEMORY;
            lres = ReadFile(file, regstra, filelen, NULL, NULL);
            if (lres == ERROR_SUCCESS)
            {
                len = MultiByteToWideChar(CP_ACP, 0, regstra, filelen, NULL, 0) + 1;
                regstrw = reinterpret_cast<LPWSTR>(HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len * sizeof(WCHAR)));
                if (regstrw == NULL)
                {
                    HeapFree(GetProcessHeap(), 0, regstra);
                    return E_OUTOFMEMORY;
                }
                MultiByteToWideChar(CP_ACP, 0, regstra, filelen, regstrw, len);
                regstrw[len - 1] = '\0';
 
                hResult = string_register(regstrw, do_register);
 
                HeapFree(GetProcessHeap(), 0, regstrw);
            }
            else
            {
                hResult = HRESULT_FROM_WIN32(lres);
            }
            HeapFree(GetProcessHeap(), 0, regstra);
            CloseHandle(file);
        }
        else
        {
            hResult = HRESULT_FROM_WIN32(GetLastError());
        }
 
        return hResult;
    }

Referenced by RegisterWithFile().

FileRegister()

HRESULT STDMETHODCALLTYPE ATL::CRegObject::FileRegister ( LPCOLESTR  fileName )

inline

Definition at line 150 of file statreg.h.

    {
        return RegisterWithFile(fileName, TRUE);
    }

FileUnregister()

HRESULT STDMETHODCALLTYPE ATL::CRegObject::FileUnregister ( LPCOLESTR  fileName )

inline

Definition at line 155 of file statreg.h.

    {
        return RegisterWithFile(fileName, FALSE);
    }

get_word()

HRESULT ATL::CRegObject::get_word ( LPCOLESTR *  str, strbuf *  buf  )

inlineprivate

Definition at line 420 of file statreg.h.

    {
        LPCOLESTR iter;
        LPCOLESTR iter2;
        HRESULT hResult;
 
        iter2 = *str;
        buf->len = 0;
        buf->str[0] = '\0';
 
        while (iswspace (*iter2))
            iter2++;
        iter = iter2;
        if (!*iter)
        {
            *str = iter;
            return S_OK;
        }
 
        if (*iter == '}' || *iter == '=')
        {
            hResult = strbuf_write(iter++, buf, 1);
            if (FAILED(hResult))
                return hResult;
        }
        else if (*iter == '\'')
        {
            iter2 = ++iter;
            iter = wcschr(iter, '\'');
            if (!iter)
            {
                *str = iter;
                return DISP_E_EXCEPTION;
            }
            hResult = strbuf_write(iter2, buf, static_cast<int>(iter - iter2));
            if (FAILED(hResult))
                return hResult;
            iter++;
        }
        else
        {
            while (*iter && !iswspace(*iter))
                iter++;
            hResult = strbuf_write(iter2, buf, static_cast<int>(iter - iter2));
            if (FAILED(hResult))
                return hResult;
        }
 
        while (iswspace(*iter))
            iter++;
        *str = iter;
        return S_OK;
    }

HexToBin()

unsigned int ATL::CRegObject::HexToBin ( OLECHAR  a )

inlineprivate

Definition at line 474 of file statreg.h.

    {
        if (a >= '0' && a <= '9')
            return a - '0';
        if (a >= 'A' && a <= 'F')
            return a - 'A' + 10;
        if (a >= 'a' && a <= 'f')
            return a - 'a' + 10;
        ATLASSERT(false);
        return 0;
    }

Referenced by do_process_key().

QueryInterface()

HRESULT STDMETHODCALLTYPE ATL::CRegObject::QueryInterface ( const IID &  , void **    )

inline

Definition at line 69 of file statreg.h.

    {
        ATLASSERT(FALSE && TEXT("statically linked in CRegObject is not a com object. Do not call this function"));
        return E_NOTIMPL;
    }

RegDeleteTreeX()

LONG ATL::CRegObject::RegDeleteTreeX ( HKEY  parentKey, LPCWSTR  subKeyName  )

inlineprivate

Definition at line 197 of file statreg.h.

    {
        wchar_t szBuffer[256];
        DWORD dwSize;
        FILETIME time;
        HKEY childKey;
        LONG lRes;
 
        ATLASSERT(parentKey != NULL);
        lRes = RegOpenKeyExW(parentKey, subKeyName, 0, KEY_READ | KEY_WRITE, &childKey);
        if (lRes != ERROR_SUCCESS)
            return lRes;
 
        dwSize = sizeof(szBuffer) / sizeof(szBuffer[0]);
        while (RegEnumKeyExW(parentKey, 0, szBuffer, &dwSize, NULL, NULL, NULL, &time) == ERROR_SUCCESS)
        {
            lRes = RegDeleteTreeX(childKey, szBuffer);
            if (lRes != ERROR_SUCCESS)
                return lRes;
            dwSize = sizeof(szBuffer) / sizeof(szBuffer[0]);
        }
        RegCloseKey(childKey);
        return RegDeleteKeyW(parentKey, subKeyName);
    }

Referenced by do_process_key(), and RegDeleteTreeX().

RegisterWithFile()

HRESULT STDMETHODCALLTYPE ATL::CRegObject::RegisterWithFile ( LPCOLESTR  fileName, BOOL  doRegister  )

inlineprotected

Definition at line 186 of file statreg.h.

    {
        return file_register(fileName, doRegister);
    }

Referenced by FileRegister(), and FileUnregister().

RegisterWithResource()

HRESULT STDMETHODCALLTYPE ATL::CRegObject::RegisterWithResource ( LPCOLESTR  resFileName, LPCOLESTR  szID, LPCOLESTR  szType, BOOL  doRegister  )

inlineprotected

Definition at line 181 of file statreg.h.

    {
        return resource_register(resFileName, szID, szType, doRegister);
    }

Referenced by ResourceRegisterSz(), and ResourceUnregisterSz().

RegisterWithString()

HRESULT STDMETHODCALLTYPE ATL::CRegObject::RegisterWithString ( LPCOLESTR  data, BOOL  doRegister  )

inlineprotected

Definition at line 191 of file statreg.h.

    {
        return string_register(data, doRegister);
    }

Referenced by StringRegister(), and StringUnregister().

Release()

ULONG STDMETHODCALLTYPE ATL::CRegObject::Release ( void  )

inline

Implements IUnknown.

Definition at line 81 of file statreg.h.

    {
        ATLASSERT(FALSE && TEXT("statically linked in CRegObject is not a com object. Do not call this function"));
        return 0;
    }

resource_register()

HRESULT ATL::CRegObject::resource_register ( LPCOLESTR  resFileName, LPCOLESTR  szID, LPCOLESTR  szType, BOOL  do_register  )

inlineprivate

Definition at line 302 of file statreg.h.

    {
        HINSTANCE hins;
        HRSRC src;
        HGLOBAL regstra;
        LPWSTR regstrw;
        DWORD len;
        DWORD reslen;
        HRESULT hResult;
 
        hins = LoadLibraryExW(resFileName, NULL, LOAD_LIBRARY_AS_DATAFILE);
        if (hins)
        {
            src = FindResourceW(hins, szID, szType);
            if (src)
            {
                regstra = LoadResource(hins, src);
                reslen = SizeofResource(hins, src);
                if (regstra)
                {
                    len = MultiByteToWideChar(CP_ACP, 0, reinterpret_cast<LPCSTR>(regstra), reslen, NULL, 0) + 1;
                    regstrw = reinterpret_cast<LPWSTR>(HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len * sizeof(WCHAR)));
                    if (regstrw == NULL)
                        return E_OUTOFMEMORY;
                    MultiByteToWideChar(CP_ACP, 0, reinterpret_cast<LPCSTR>(regstra), reslen, regstrw, len);
                    regstrw[len - 1] = '\0';
 
                    hResult = string_register(regstrw, do_register);
 
                    HeapFree(GetProcessHeap(), 0, regstrw);
                }
                else
                    hResult = HRESULT_FROM_WIN32(GetLastError());
            }
            else
                hResult = HRESULT_FROM_WIN32(GetLastError());
            FreeLibrary(hins);
        }
        else
            hResult = HRESULT_FROM_WIN32(GetLastError());
 
        return hResult;
    }

Referenced by RegisterWithResource().

ResourceRegister()

HRESULT STDMETHODCALLTYPE ATL::CRegObject::ResourceRegister ( LPCOLESTR  resFileName, UINT  nID, LPCOLESTR  szType  )

inline

Definition at line 170 of file statreg.h.

    {
        return ResourceRegisterSz(resFileName, MAKEINTRESOURCEW(nID), szType);
    }

Referenced by ATL::CAtlModule::UpdateRegistryFromResource().

ResourceRegisterSz()

HRESULT STDMETHODCALLTYPE ATL::CRegObject::ResourceRegisterSz ( LPCOLESTR  resFileName, LPCOLESTR  szID, LPCOLESTR  szType  )

inline

Definition at line 140 of file statreg.h.

    {
        return RegisterWithResource(resFileName, szID, szType, TRUE);
    }

Referenced by ResourceRegister(), and ATL::CAtlModule::UpdateRegistryFromResource().

ResourceUnregister()

HRESULT STDMETHODCALLTYPE ATL::CRegObject::ResourceUnregister ( LPCOLESTR  resFileName, UINT  nID, LPCOLESTR  szType  )

inline

Definition at line 175 of file statreg.h.

    {
        return ResourceUnregisterSz(resFileName, MAKEINTRESOURCEW(nID), szType);
    }

Referenced by ATL::CAtlModule::UpdateRegistryFromResource().

ResourceUnregisterSz()

HRESULT STDMETHODCALLTYPE ATL::CRegObject::ResourceUnregisterSz ( LPCOLESTR  resFileName, LPCOLESTR  szID, LPCOLESTR  szType  )

inline

Definition at line 145 of file statreg.h.

    {
        return RegisterWithResource(resFileName, szID, szType, FALSE);
    }

Referenced by ResourceUnregister(), and ATL::CAtlModule::UpdateRegistryFromResource().

strbuf_init()

HRESULT ATL::CRegObject::strbuf_init ( strbuf *  buf )

inlineprivate

Definition at line 222 of file statreg.h.

    {
        buf->str = reinterpret_cast<LPOLESTR>(HeapAlloc(GetProcessHeap(), 0, 128 * sizeof(WCHAR)));
        if (buf->str == NULL)
            return E_OUTOFMEMORY;
        buf->alloc = 128;
        buf->len = 0;
        return S_OK;
    }

Referenced by do_process_key(), do_process_root_key(), and string_register().

strbuf_write()

HRESULT ATL::CRegObject::strbuf_write ( LPCOLESTR  str, strbuf *  buf, int  len  )

inlineprivate

Definition at line 232 of file statreg.h.

    {
        LPOLESTR newBuffer;
 
        if (len == -1)
            len = lstrlenW(str);
        if (buf->len + len + 1 >= buf->alloc)
        {
            buf->alloc = (buf->len + len) * 2;
            newBuffer = reinterpret_cast<LPOLESTR>(HeapReAlloc(GetProcessHeap(), 0, buf->str, buf->alloc * sizeof(WCHAR)));
            if (newBuffer == NULL)
                return E_OUTOFMEMORY;
            buf->str = newBuffer;
        }
        memcpy(buf->str + buf->len, str, len * sizeof(OLECHAR));
        buf->len += len;
        buf->str[buf->len] = '\0';
        return S_OK;
    }

Referenced by do_preprocess(), do_process_key(), and get_word().

string_register()

HRESULT ATL::CRegObject::string_register ( LPCOLESTR  data, BOOL  do_register  )

inlineprivate

Definition at line 346 of file statreg.h.

    {
        strbuf buf;
        HRESULT hResult;
 
        hResult = strbuf_init(&buf);
        if (FAILED(hResult))
            return hResult;
        hResult = do_preprocess(data, &buf);
        if (SUCCEEDED(hResult))
        {
            hResult = do_process_root_key(buf.str, do_register);
            if (FAILED(hResult) && do_register)
                do_process_root_key(buf.str, FALSE);
        }
 
        HeapFree(GetProcessHeap(), 0, buf.str);
        return hResult;
    }

Referenced by file_register(), RegisterWithString(), and resource_register().

StringRegister()

HRESULT STDMETHODCALLTYPE ATL::CRegObject::StringRegister ( LPCOLESTR  data )

inline

Definition at line 160 of file statreg.h.

    {
        return RegisterWithString(data, TRUE);
    }

StringUnregister()

HRESULT STDMETHODCALLTYPE ATL::CRegObject::StringUnregister ( LPCOLESTR  data )

inline

Definition at line 165 of file statreg.h.

    {
        return RegisterWithString(data, FALSE);
    }

Member Data Documentation

m_rep

rep_list* ATL::CRegObject::m_rep

Definition at line 52 of file statreg.h.

Referenced by AddReplacement(), ClearReplacements(), CRegObject(), and do_preprocess().

---

The documentation for this class was generated from the following file:

• sdk/lib/atl/statreg.h