自学教程：C++ strcmpW函数代码示例

static HRESULT WINAPI HTMLBodyElement_get_scroll(IHTMLBodyElement *iface, BSTR *p){    HTMLBodyElement *This = impl_from_IHTMLBodyElement(iface);    const WCHAR *ret;    BSTR overflow;    HRESULT hres;    TRACE("(%p)->(%p)/n", This, p);    /* Emulate with CSS visibility attribute */    hres = get_elem_style(&This->textcont.element, STYLEID_OVERFLOW, &overflow);    if(FAILED(hres))        return hres;    if(!overflow || !*overflow) {        *p = NULL;        return S_OK;    }else if(!strcmpW(overflow, visibleW) || !strcmpW(overflow, autoW)) {        ret = autoW;    }else if(!strcmpW(overflow, scrollW)) {        ret = yesW;    }else if(!strcmpW(overflow, hiddenW)) {        ret = noW;    }else {        TRACE("Defaulting %s to NULL/n", debugstr_w(overflow));        *p = NULL;        return S_OK;    }    *p = SysAllocString(ret);    return *p ? S_OK : E_OUTOFMEMORY;}

static NTSTATUS key_import( BCRYPT_ALG_HANDLE algorithm, const WCHAR *type, BCRYPT_KEY_HANDLE *key, UCHAR *object,                            ULONG object_len, UCHAR *input, ULONG input_len ){    ULONG len;    if (!strcmpW( type, BCRYPT_KEY_DATA_BLOB ))    {        BCRYPT_KEY_DATA_BLOB_HEADER *header = (BCRYPT_KEY_DATA_BLOB_HEADER *)input;        if (input_len < sizeof(BCRYPT_KEY_DATA_BLOB_HEADER)) return STATUS_BUFFER_TOO_SMALL;        if (header->dwMagic != BCRYPT_KEY_DATA_BLOB_MAGIC) return STATUS_INVALID_PARAMETER;        if (header->dwVersion != BCRYPT_KEY_DATA_BLOB_VERSION1)        {            FIXME( "unknown key data blob version %u/n", header->dwVersion );            return STATUS_INVALID_PARAMETER;        }        len = header->cbKeyData;        if (len + sizeof(BCRYPT_KEY_DATA_BLOB_HEADER) > input_len) return STATUS_INVALID_PARAMETER;        return BCryptGenerateSymmetricKey( algorithm, key, object, object_len, (UCHAR *)&header[1], len, 0 );    }    else if (!strcmpW( type, BCRYPT_OPAQUE_KEY_BLOB ))    {        if (input_len < sizeof(len)) return STATUS_BUFFER_TOO_SMALL;        len = *(ULONG *)input;        if (len + sizeof(len) > input_len) return STATUS_INVALID_PARAMETER;        return BCryptGenerateSymmetricKey( algorithm, key, object, object_len, input + sizeof(len), len, 0 );    }    FIXME( "unsupported key type %s/n", debugstr_w(type) );    return STATUS_NOT_IMPLEMENTED;}

static HRESULT WINAPI IAssemblyNameImpl_IsEqual(IAssemblyName *iface,                                                IAssemblyName *pName,                                                DWORD flags){    IAssemblyNameImpl *name1 = impl_from_IAssemblyName(iface);    IAssemblyNameImpl *name2 = impl_from_IAssemblyName(pName);    TRACE("(%p, %p, 0x%08x)/n", iface, pName, flags);    if (!pName) return S_FALSE;    if (flags & ~ASM_CMPF_IL_ALL) FIXME("unsupported flags/n");    if ((flags & ASM_CMPF_NAME) && strcmpW(name1->name, name2->name)) return S_FALSE;    if (name1->versize && name2->versize)    {        if ((flags & ASM_CMPF_MAJOR_VERSION) &&            name1->version[0] != name2->version[0]) return S_FALSE;        if ((flags & ASM_CMPF_MINOR_VERSION) &&            name1->version[1] != name2->version[1]) return S_FALSE;        if ((flags & ASM_CMPF_BUILD_NUMBER) &&            name1->version[2] != name2->version[2]) return S_FALSE;        if ((flags & ASM_CMPF_REVISION_NUMBER) &&            name1->version[3] != name2->version[3]) return S_FALSE;    }    if ((flags & ASM_CMPF_PUBLIC_KEY_TOKEN) &&        name1->haspubkey && name2->haspubkey &&        memcmp(name1->pubkey, name2->pubkey, sizeof(name1->pubkey))) return S_FALSE;    if ((flags & ASM_CMPF_CULTURE) &&        name1->culture && name2->culture &&        strcmpW(name1->culture, name2->culture)) return S_FALSE;    return S_OK;}

static NTSTATUS key_export( struct key *key, const WCHAR *type, UCHAR *output, ULONG output_len, ULONG *size ){    if (!strcmpW( type, BCRYPT_KEY_DATA_BLOB ))    {        BCRYPT_KEY_DATA_BLOB_HEADER *header = (BCRYPT_KEY_DATA_BLOB_HEADER *)output;        ULONG req_size = sizeof(BCRYPT_KEY_DATA_BLOB_HEADER) + key->u.s.secret_len;        *size = req_size;        if (output_len < req_size) return STATUS_BUFFER_TOO_SMALL;        header->dwMagic   = BCRYPT_KEY_DATA_BLOB_MAGIC;        header->dwVersion = BCRYPT_KEY_DATA_BLOB_VERSION1;        header->cbKeyData = key->u.s.secret_len;        memcpy( &header[1], key->u.s.secret, key->u.s.secret_len );        return STATUS_SUCCESS;    }    else if (!strcmpW( type, BCRYPT_OPAQUE_KEY_BLOB ))    {        ULONG len, req_size = sizeof(len) + key->u.s.secret_len;        *size = req_size;        if (output_len < req_size) return STATUS_BUFFER_TOO_SMALL;        *(ULONG *)output = key->u.s.secret_len;        memcpy( output + sizeof(len), key->u.s.secret, key->u.s.secret_len );        return STATUS_SUCCESS;    }    FIXME( "unsupported key type %s/n", debugstr_w(type) );    return STATUS_NOT_IMPLEMENTED;}

/************************************************************************** *  CreateFolderEnumList() */BOOL CreateFolderEnumList(IEnumIDListImpl *list, LPCWSTR lpszPath, DWORD dwFlags){    LPITEMIDLIST pidl=NULL;    WIN32_FIND_DATAW stffile;    HANDLE hFile;    WCHAR  szPath[MAX_PATH];    BOOL succeeded = TRUE;    static const WCHAR stars[] = { '*','.','*',0 };    static const WCHAR dot[] = { '.',0 };    static const WCHAR dotdot[] = { '.','.',0 };    TRACE("(%p)->(path=%s flags=0x%08x)/n", list, debugstr_w(lpszPath), dwFlags);    if(!lpszPath || !lpszPath[0]) return FALSE;    strcpyW(szPath, lpszPath);    PathAddBackslashW(szPath);    strcatW(szPath,stars);    hFile = FindFirstFileW(szPath,&stffile);    if ( hFile != INVALID_HANDLE_VALUE )    {        BOOL findFinished = FALSE;        do        {            if ( !(stffile.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN)              || (dwFlags & SHCONTF_INCLUDEHIDDEN) )            {                if ( (stffile.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) &&                 dwFlags & SHCONTF_FOLDERS &&                 strcmpW(stffile.cFileName, dot) && strcmpW(stffile.cFileName, dotdot))                {                    pidl = _ILCreateFromFindDataW(&stffile);                    succeeded = succeeded && AddToEnumList(list, pidl);                }                else if (!(stffile.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)                 && dwFlags & SHCONTF_NONFOLDERS)                {                    pidl = _ILCreateFromFindDataW(&stffile);                    succeeded = succeeded && AddToEnumList(list, pidl);                }            }            if (succeeded)            {                if (!FindNextFileW(hFile, &stffile))                {                    if (GetLastError() == ERROR_NO_MORE_FILES)                        findFinished = TRUE;                    else                        succeeded = FALSE;                }            }        } while (succeeded && !findFinished);        FindClose(hFile);    }    return succeeded;}

static NTSTATUS get_hash_property( enum alg_id id, const WCHAR *prop, UCHAR *buf, ULONG size, ULONG *ret_size ){    ULONG value;    switch (id)    {    case ALG_ID_SHA1:        if (!strcmpW( prop, BCRYPT_HASH_LENGTH ))        {            value = HASH_DIGEST_LENGTH_SHA1;            break;        }        FIXME( "unsupported sha1 hash property %s/n", debugstr_w(prop) );        return STATUS_NOT_IMPLEMENTED;    case ALG_ID_SHA256:        if (!strcmpW( prop, BCRYPT_HASH_LENGTH ))        {            value = HASH_DIGEST_LENGTH_SHA256;            break;        }        FIXME( "unsupported sha256 hash property %s/n", debugstr_w(prop) );        return STATUS_NOT_IMPLEMENTED;    case ALG_ID_SHA384:        if (!strcmpW( prop, BCRYPT_HASH_LENGTH ))        {            value = HASH_DIGEST_LENGTH_SHA384;            break;        }        FIXME( "unsupported sha384 hash property %s/n", debugstr_w(prop) );        return STATUS_NOT_IMPLEMENTED;    case ALG_ID_SHA512:        if (!strcmpW( prop, BCRYPT_HASH_LENGTH ))        {            value = HASH_DIGEST_LENGTH_SHA512;            break;        }        FIXME( "unsupported sha512 hash property %s/n", debugstr_w(prop) );        return STATUS_NOT_IMPLEMENTED;    default:        FIXME( "unsupported hash %u/n", id );        return STATUS_NOT_IMPLEMENTED;    }    if (size < sizeof(ULONG))    {        *ret_size = sizeof(ULONG);        return STATUS_BUFFER_TOO_SMALL;    }    if (buf) *(ULONG *)buf = value;    *ret_size = sizeof(ULONG);    return STATUS_SUCCESS;}

static NTSTATUS get_aes_property( enum mode_id mode, const WCHAR *prop, UCHAR *buf, ULONG size, ULONG *ret_size ){    if (!strcmpW( prop, BCRYPT_BLOCK_LENGTH ))    {        *ret_size = sizeof(ULONG);        if (size < sizeof(ULONG)) return STATUS_BUFFER_TOO_SMALL;        if (buf) *(ULONG *)buf = BLOCK_LENGTH_AES;        return STATUS_SUCCESS;    }    if (!strcmpW( prop, BCRYPT_CHAINING_MODE ))    {        const WCHAR *str;        switch (mode)        {        case MODE_ID_ECB: str = BCRYPT_CHAIN_MODE_ECB; break;        case MODE_ID_CBC: str = BCRYPT_CHAIN_MODE_CBC; break;        case MODE_ID_GCM: str = BCRYPT_CHAIN_MODE_GCM; break;        default: return STATUS_NOT_IMPLEMENTED;        }        *ret_size = 64;        if (size < *ret_size) return STATUS_BUFFER_TOO_SMALL;        memcpy( buf, str, (strlenW(str) + 1) * sizeof(WCHAR) );        return STATUS_SUCCESS;    }    if (!strcmpW( prop, BCRYPT_KEY_LENGTHS ))    {        BCRYPT_KEY_LENGTHS_STRUCT *key_lengths = (void *)buf;        *ret_size = sizeof(*key_lengths);        if (key_lengths && size < *ret_size) return STATUS_BUFFER_TOO_SMALL;        if (key_lengths)        {            key_lengths->dwMinLength = 128;            key_lengths->dwMaxLength = 256;            key_lengths->dwIncrement = 64;        }        return STATUS_SUCCESS;    }    if (!strcmpW( prop, BCRYPT_AUTH_TAG_LENGTH ))    {        BCRYPT_AUTH_TAG_LENGTHS_STRUCT *tag_length = (void *)buf;        if (mode != MODE_ID_GCM) return STATUS_NOT_SUPPORTED;        *ret_size = sizeof(*tag_length);        if (tag_length && size < *ret_size) return STATUS_BUFFER_TOO_SMALL;        if (tag_length)        {            tag_length->dwMinLength = 12;            tag_length->dwMaxLength = 16;            tag_length->dwIncrement =  1;        }        return STATUS_SUCCESS;    }    FIXME( "unsupported property %s/n", debugstr_w(prop) );    return STATUS_NOT_IMPLEMENTED;}

static void test_VarFormatNumber(void){  static const WCHAR szSrc1[] = { '1','/0' };  static const WCHAR szResult1[] = { '1','.','0','0','/0' };  static const WCHAR szSrc2[] = { '-','1','/0' };  static const WCHAR szResult2[] = { '(','1','.','0','0',')','/0' };  char buff[8];  HRESULT hres;  VARIANT v;  BSTR str = NULL;  CHECKPTR(VarFormatNumber);  GetLocaleInfoA(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, buff, sizeof(buff)/sizeof(char));  if (buff[0] != '.' || buff[1])  {    trace("Skipping VarFormatNumber tests as decimal separator is '%s'/n", buff);    return;  }  FMT_NUMBER(VT_I1, V_I1);  FMT_NUMBER(VT_UI1, V_UI1);  FMT_NUMBER(VT_I2, V_I2);  FMT_NUMBER(VT_UI2, V_UI2);  FMT_NUMBER(VT_I4, V_I4);  FMT_NUMBER(VT_UI4, V_UI4);  if (HAVE_OLEAUT32_I8)  {    FMT_NUMBER(VT_I8, V_I8);    FMT_NUMBER(VT_UI8, V_UI8);  }  FMT_NUMBER(VT_R4, V_R4);  FMT_NUMBER(VT_R8, V_R8);  FMT_NUMBER(VT_BOOL, V_BOOL);  V_VT(&v) = VT_BSTR;  V_BSTR(&v) = SysAllocString(szSrc1);  hres = pVarFormatNumber(&v,2,0,0,0,0,&str);  ok(hres == S_OK, "VarFormatNumber (bstr): returned %8lx/n", hres);  if (hres == S_OK)    ok(str && strcmpW(str, szResult1) == 0, "VarFormatNumber (bstr): string different/n");  SysFreeString(V_BSTR(&v));  SysFreeString(str);  V_BSTR(&v) = SysAllocString(szSrc2);  hres = pVarFormatNumber(&v,2,0,-1,0,0,&str);  ok(hres == S_OK, "VarFormatNumber (bstr): returned %8lx/n", hres);  if (hres == S_OK)    ok(str && strcmpW(str, szResult2) == 0, "VarFormatNumber (-bstr): string different/n");  SysFreeString(V_BSTR(&v));  SysFreeString(str);}

static HRESULT bind_to_object(DocHost *This, IMoniker *mon, LPCWSTR url, IBindCtx *bindctx,                              IBindStatusCallback *callback){    WCHAR schema[30];    DWORD schema_len;    HRESULT hres;    static const WCHAR httpW[] = {'h','t','t','p',0};    static const WCHAR httpsW[] = {'h','t','t','p','s',0};    static const WCHAR ftpW[]= {'f','t','p',0};    if(mon) {        IMoniker_AddRef(mon);    }else {        hres = create_moniker(url, &mon);        if(FAILED(hres))            return hres;    }    CoTaskMemFree(This->url);    hres = IMoniker_GetDisplayName(mon, 0, NULL, &This->url);    if(FAILED(hres))        FIXME("GetDisplayName failed: %08x/n", hres);    IBindCtx_RegisterObjectParam(bindctx, (LPOLESTR)SZ_HTML_CLIENTSITE_OBJECTPARAM,                                 (IUnknown*)CLIENTSITE(This));    hres = CoInternetParseUrl(This->url, PARSE_SCHEMA, 0, schema, sizeof(schema)/sizeof(schema[0]),            &schema_len, 0);    if(SUCCEEDED(hres) &&       (!strcmpW(schema, httpW) || !strcmpW(schema, httpsW) || !strcmpW(schema, ftpW))) {        hres = http_load_hack(This, mon, callback, bindctx);    }else {        IUnknown *unk = NULL;        hres = IMoniker_BindToObject(mon, bindctx, NULL, &IID_IUnknown, (void**)&unk);        if(SUCCEEDED(hres)) {            hres = S_OK;            if(unk)                IUnknown_Release(unk);        }else if(try_application_url(url)) {            hres = S_OK;        }else {            FIXME("BindToObject failed: %08x/n", hres);        }    }    IMoniker_Release(mon);    return S_OK;}

static HRESULT WINAPI dom_pi_get_attributes(    IXMLDOMProcessingInstruction *iface,    IXMLDOMNamedNodeMap** map){    dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );    static const WCHAR xmlW[] = {'x','m','l',0};    HRESULT hr;    BSTR name;    TRACE("(%p)->(%p)/n", This, map);    if (!map) return E_INVALIDARG;    *map = NULL;    hr = node_get_nodeName(&This->node, &name);    if (hr != S_OK) return hr;    if (!strcmpW(name, xmlW))    {        FIXME("created dummy map for <?xml ?>/n");        *map = create_nodemap(This->node.node, &dom_pi_attr_map);        SysFreeString(name);        return S_OK;    }    SysFreeString(name);    return S_FALSE;}

static HRESULT WINAPI dom_pi_put_nodeValue(    IXMLDOMProcessingInstruction *iface,    VARIANT value){    dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );    BSTR target;    HRESULT hr;    TRACE("(%p)->(%s)/n", This, debugstr_variant(&value));    /* Cannot set data to a PI node whose target is 'xml' */    hr = IXMLDOMProcessingInstruction_get_nodeName(iface, &target);    if(hr == S_OK)    {        static const WCHAR xmlW[] = {'x','m','l',0};        if(!strcmpW(target, xmlW))        {            SysFreeString(target);            return E_FAIL;        }        SysFreeString(target);    }    return node_put_value(&This->node, &value);}

static HRESULT get_dynamic_prop(DispatchEx *This, const WCHAR *name, DWORD flags, dynamic_prop_t **ret){    const BOOL alloc = flags & fdexNameEnsure;    dispex_dynamic_data_t *data;    dynamic_prop_t *prop;    data = get_dynamic_data(This, alloc);    if(!data) {        if(alloc)            return E_OUTOFMEMORY;        TRACE("not found %s/n", debugstr_w(name));        return DISP_E_UNKNOWNNAME;    }    for(prop = data->props; prop < data->props+data->prop_cnt; prop++) {        if(flags & fdexNameCaseInsensitive ? !strcmpiW(prop->name, name) : !strcmpW(prop->name, name)) {            if(prop->flags & DYNPROP_DELETED) {                if(!alloc)                    return DISP_E_UNKNOWNNAME;                prop->flags &= ~DYNPROP_DELETED;            }            *ret = prop;            return S_OK;        }    }    if(!alloc)        return DISP_E_UNKNOWNNAME;    TRACE("creating dynamic prop %s/n", debugstr_w(name));    if(!data->buf_size) {        data->props = heap_alloc(sizeof(dynamic_prop_t)*4);        if(!data->props)            return E_OUTOFMEMORY;        data->buf_size = 4;    }else if(data->buf_size == data->prop_cnt) {        dynamic_prop_t *new_props;        new_props = heap_realloc(data->props, sizeof(dynamic_prop_t)*(data->buf_size<<1));        if(!new_props)            return E_OUTOFMEMORY;        data->props = new_props;        data->buf_size <<= 1;    }    prop = data->props + data->prop_cnt;    prop->name = heap_strdupW(name);    if(!prop->name)        return E_OUTOFMEMORY;    VariantInit(&prop->var);    prop->flags = 0;    data->prop_cnt++;    *ret = prop;    return S_OK;}

static UINT ITERATE_AppSearch(MSIRECORD *row, LPVOID param){    MSIPACKAGE *package = param;    LPCWSTR propName, sigName;    LPWSTR value = NULL;    MSISIGNATURE sig;    MSIRECORD *uirow;    UINT r;    /* get property and signature */    propName = MSI_RecordGetString(row, 1);    sigName = MSI_RecordGetString(row, 2);    TRACE("%s %s/n", debugstr_w(propName), debugstr_w(sigName));    r = search_sig_name( package, sigName, &sig, &value );    if (value)    {        r = msi_set_property( package->db, propName, value, -1 );        if (r == ERROR_SUCCESS && !strcmpW( propName, szSourceDir ))            msi_reset_source_folders( package );        msi_free(value);    }    free_signature( &sig );    uirow = MSI_CreateRecord( 2 );    MSI_RecordSetStringW( uirow, 1, propName );    MSI_RecordSetStringW( uirow, 2, sigName );    MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);    msiobj_release( &uirow->hdr );    return r;}

static HRESULT WINAPI MsiActiveScriptSite_GetItemInfo(IActiveScriptSite* iface, LPCOLESTR pstrName, DWORD dwReturnMask, IUnknown** ppiunkItem, ITypeInfo** ppti){    MsiActiveScriptSite *This = impl_from_IActiveScriptSite(iface);    TRACE("(%p)->(%p, %d, %p, %p)/n", This, pstrName, dwReturnMask, ppiunkItem, ppti);    /* Determine the kind of pointer that is requested, and make sure placeholder is valid */    if (dwReturnMask & SCRIPTINFO_ITYPEINFO) {        if (!ppti) return E_INVALIDARG;        *ppti = NULL;    }    if (dwReturnMask & SCRIPTINFO_IUNKNOWN) {        if (!ppiunkItem) return E_INVALIDARG;        *ppiunkItem = NULL;    }    /* Are we looking for the session object? */    if (!strcmpW(szSession, pstrName)) {        if (dwReturnMask & SCRIPTINFO_ITYPEINFO) {            HRESULT hr = get_typeinfo(Session_tid, ppti);            if (SUCCEEDED(hr))                ITypeInfo_AddRef(*ppti);            return hr;        }        else if (dwReturnMask & SCRIPTINFO_IUNKNOWN) {            IDispatch_QueryInterface(This->session, &IID_IUnknown, (void **)ppiunkItem);            return S_OK;        }    }    return TYPE_E_ELEMENTNOTFOUND;}

BOOL MSI_RecordsAreEqual(MSIRECORD *a, MSIRECORD *b){    UINT i;    if (a->count != b->count)        return FALSE;    for (i = 0; i <= a->count; i++)    {        if (a->fields[i].type != b->fields[i].type)            return FALSE;        switch (a->fields[i].type)        {            case MSIFIELD_NULL:                break;            case MSIFIELD_INT:                if (a->fields[i].u.iVal != b->fields[i].u.iVal)                    return FALSE;                break;            case MSIFIELD_WSTR:                if (strcmpW(a->fields[i].u.szwVal, b->fields[i].u.szwVal))                    return FALSE;                break;            case MSIFIELD_STREAM:            default:                return FALSE;        }    }    return TRUE;}

static BOOL is_known_mime_type(const WCHAR *mime){    unsigned i;    for(i=0; i < sizeof(mime_filters_any_pos)/sizeof(*mime_filters_any_pos); i++) {        if(!strcmpW(mime, mime_filters_any_pos[i].mime))            return TRUE;    }    for(i=0; i < sizeof(mime_filters)/sizeof(*mime_filters); i++) {        if(!strcmpW(mime, mime_filters[i].mime))            return TRUE;    }    return FALSE;}

static UINT iterate_appsearch(MSIRECORD *row, LPVOID param){    MSIPACKAGE *package = param;    LPCWSTR propName, sigName;    LPWSTR value = NULL;    MSISIGNATURE sig;    MSIRECORD *uirow;    UINT r;    /* get property and signature */    propName = MSI_RecordGetString(row, 1);    sigName = MSI_RecordGetString(row, 2);    TRACE("%s %s/n", debugstr_w(propName), debugstr_w(sigName));    r = ACTION_AppSearchSigName(package, sigName, &sig, &value);    if (value)    {        r = msi_set_property( package->db, propName, value );        if (r == ERROR_SUCCESS && !strcmpW( propName, cszSourceDir ))            msi_reset_folders( package, TRUE );        msi_free(value);    }    ACTION_FreeSignature(&sig);    uirow = MSI_CreateRecord( 2 );    MSI_RecordSetStringW( uirow, 1, propName );    MSI_RecordSetStringW( uirow, 2, sigName );    ui_actiondata( package, szAppSearch, uirow );    msiobj_release( &uirow->hdr );    return r;}

static HRESULT WINAPI MsiActiveScriptSite_GetItemInfo(IActiveScriptSite* iface, LPCOLESTR pstrName, DWORD dwReturnMask, IUnknown** ppiunkItem, ITypeInfo** ppti){    MsiActiveScriptSite *This = (MsiActiveScriptSite *)iface;    TRACE("(%p/%p)->(%p,%d,%p,%p)/n", This, iface, pstrName, dwReturnMask, ppiunkItem, ppti);    /* Determine the kind of pointer that is requested, and make sure placeholder is valid */    if (dwReturnMask & SCRIPTINFO_ITYPEINFO) {        if (!ppti) return E_INVALIDARG;        *ppti = NULL;    }    if (dwReturnMask & SCRIPTINFO_IUNKNOWN) {        if (!ppiunkItem) return E_INVALIDARG;        *ppiunkItem = NULL;    }    /* Are we looking for the session object? */    if (!strcmpW(szSession, pstrName)) {        if (dwReturnMask & SCRIPTINFO_ITYPEINFO)            return load_type_info(This->pSession, ppti, &DIID_Session, 0);        else if (dwReturnMask & SCRIPTINFO_IUNKNOWN) {            IDispatch_QueryInterface(This->pSession, &IID_IUnknown, (void **)ppiunkItem);            return S_OK;        }    }    return TYPE_E_ELEMENTNOTFOUND;}

static HRESULT WINAPI InternetSession_UnregisterMimeFilter(IInternetSession *iface,        IClassFactory *pCF, LPCWSTR pwzType){    mime_filter *iter, *prev = NULL;    TRACE("(%p %s)/n", pCF, debugstr_w(pwzType));    EnterCriticalSection(&session_cs);    for(iter = mime_filter_list; iter; iter = iter->next) {        if(iter->cf == pCF && !strcmpW(iter->mime, pwzType))            break;        prev = iter;    }    if(iter) {        if(prev)            prev->next = iter->next;        else            mime_filter_list = iter->next;    }    LeaveCriticalSection(&session_cs);    if(iter) {        IClassFactory_Release(iter->cf);        heap_free(iter->mime);        heap_free(iter);    }    return S_OK;}

IInternetProtocol *get_mime_filter(LPCWSTR mime){    IClassFactory *cf = NULL;    IInternetProtocol *ret;    mime_filter *iter;    HRESULT hres;    EnterCriticalSection(&session_cs);    for(iter = mime_filter_list; iter; iter = iter->next) {        if(!strcmpW(iter->mime, mime)) {            cf = iter->cf;            break;        }    }    LeaveCriticalSection(&session_cs);    if(!cf)        return NULL;    hres = IClassFactory_CreateInstance(cf, NULL, &IID_IInternetProtocol, (void**)&ret);    if(FAILED(hres)) {        WARN("CreateInstance failed: %08x/n", hres);        return NULL;    }    return ret;}

static HRESULT unregister_namespace(IClassFactory *cf, LPCWSTR protocol){    name_space *iter, *last = NULL;    EnterCriticalSection(&session_cs);    for(iter = name_space_list; iter; iter = iter->next) {        if(iter->cf == cf && !strcmpW(iter->protocol, protocol))            break;        last = iter;    }    if(iter) {        if(last)            last->next = iter->next;        else            name_space_list = iter->next;    }    LeaveCriticalSection(&session_cs);    if(iter) {        if(!iter->urlmon)            IClassFactory_Release(iter->cf);        heap_free(iter->protocol);        heap_free(iter);    }    return S_OK;}

static HRESULT WINAPI AboutProtocol_Start(IInternetProtocol *iface, LPCWSTR szUrl,        IInternetProtocolSink* pOIProtSink, IInternetBindInfo* pOIBindInfo,        DWORD grfPI, HANDLE_PTR dwReserved){    AboutProtocol *This = PROTOCOL_THIS(iface);    BINDINFO bindinfo;    DWORD grfBINDF = 0;    LPCWSTR text = NULL;    static const WCHAR html_begin[] = {0xfeff,'<','H','T','M','L','>',0};    static const WCHAR html_end[] = {'<','/','H','T','M','L','>',0};    static const WCHAR wszBlank[] = {'b','l','a','n','k',0};    static const WCHAR wszAbout[] = {'a','b','o','u','t',':'};    static const WCHAR wszTextHtml[] = {'t','e','x','t','/','h','t','m','l',0};    /* NOTE:     * the about protocol seems not to work as I would expect. It creates html document     * for a given url, eg. about:some_text -> <HTML>some_text</HTML> except for the case when     * some_text = "blank", when document is blank (<HTML></HMTL>). The same happens     * when the url does not have "about:" in the beginning.     */    TRACE("(%p)->(%s %p %p %08x %lx)/n", This, debugstr_w(szUrl), pOIProtSink,            pOIBindInfo, grfPI, dwReserved);    memset(&bindinfo, 0, sizeof(bindinfo));    bindinfo.cbSize = sizeof(BINDINFO);    IInternetBindInfo_GetBindInfo(pOIBindInfo, &grfBINDF, &bindinfo);    ReleaseBindInfo(&bindinfo);    TRACE("bindf %x/n", grfBINDF);    if(strlenW(szUrl)>=sizeof(wszAbout)/sizeof(WCHAR) && !memcmp(wszAbout, szUrl, sizeof(wszAbout))) {        text = szUrl + sizeof(wszAbout)/sizeof(WCHAR);        if(!strcmpW(wszBlank, text))            text = NULL;    }    This->data_len = sizeof(html_begin)+sizeof(html_end)-sizeof(WCHAR)         + (text ? strlenW(text)*sizeof(WCHAR) : 0);    This->data = heap_alloc(This->data_len);    memcpy(This->data, html_begin, sizeof(html_begin));    if(text)        strcatW((LPWSTR)This->data, text);    strcatW((LPWSTR)This->data, html_end);        This->cur = 0;    IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_MIMETYPEAVAILABLE, wszTextHtml);    IInternetProtocolSink_ReportData(pOIProtSink,            BSCF_FIRSTDATANOTIFICATION | BSCF_LASTDATANOTIFICATION | BSCF_DATAFULLYAVAILABLE,            This->data_len, This->data_len);    IInternetProtocolSink_ReportResult(pOIProtSink, S_OK, 0, NULL);    return S_OK;}

/* should be used only when both keys are of string type, it's not checked */static inline int strcmp_key(const dictionary *dict, const VARIANT *key1, const VARIANT *key2){    const WCHAR *str1, *str2;    str1 = get_key_strptr(key1);    str2 = get_key_strptr(key2);    return dict->method == BinaryCompare ? strcmpW(str1, str2) : strcmpiW(str1, str2);}

static BOOL is_local_machine( const WCHAR *server ){    static const WCHAR dotW[] = {'.',0};    WCHAR buffer[MAX_COMPUTERNAME_LENGTH + 1];    DWORD len = sizeof(buffer) / sizeof(buffer[0]);    if (!server || !strcmpW( server, dotW )) return TRUE;    if (GetComputerNameW( buffer, &len ) && !strcmpiW( server, buffer )) return TRUE;    return FALSE;}

static HRESULT WINAPI dispex_GetDispID(    IDispatchEx *iface, BSTR name, DWORD flags, DISPID *id ){    if (!strcmpW( name, dns_resolveW ))    {        *id = DISPID_GLOBAL_DNSRESOLVE;        return S_OK;    }    return DISP_E_UNKNOWNNAME;}

/* compare two unicode strings/ids */static int cmp_string( const struct string_id *str1, const struct string_id *str2 ){    if (!str1->str)    {        if (!str2->str) return str1->id - str2->id;        return 1;  /* an id compares larger than a string */    }    if (!str2->str) return -1;    return strcmpW( str1->str, str2->str );}

static eventid_t attr_to_eid(LPCWSTR str){    int i;    for(i=0; i < sizeof(event_info)/sizeof(event_info[0]); i++) {        if(!strcmpW(event_info[i].attr_name, str))            return i;    }    return EVENTID_LAST;}