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

static HRESULT WINAPI ClDispatch_Invoke(IDispatch *iface, DISPID dispIdMember, REFIID riid,                                        LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,                                        VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr){    DocHost *This = impl_from_IDispatch(iface);    TRACE("(%p)->(%s %s %d %04x %p %p %p %p)/n", This, debugstr_dispid(dispIdMember),          debugstr_guid(riid), lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);    switch(dispIdMember) {    case DISPID_AMBIENT_USERMODE:    case DISPID_AMBIENT_DLCONTROL:    case DISPID_AMBIENT_USERAGENT:    case DISPID_AMBIENT_PALETTE:        if(!This->client_disp)            return E_FAIL;        return IDispatch_Invoke(This->client_disp, dispIdMember, riid, lcid, wFlags,                                pDispParams, pVarResult, pExcepInfo, puArgErr);    case DISPID_AMBIENT_OFFLINEIFNOTCONNECTED:        V_VT(pVarResult) = VT_BOOL;        V_BOOL(pVarResult) = This->offline;        return S_OK;    case DISPID_AMBIENT_SILENT:        V_VT(pVarResult) = VT_BOOL;        V_BOOL(pVarResult) = This->offline;        return S_OK;    }    FIXME("unhandled dispid %d/n", dispIdMember);    return E_NOTIMPL;}

static void update_readystate(PluginHost *host){    DISPPARAMS params = {NULL,NULL,0,0};    IDispatchEx *dispex;    IDispatch *disp;    ULONG err = 0;    VARIANT v;    HRESULT hres;    hres = IUnknown_QueryInterface(host->plugin_unk, &IID_IDispatchEx, (void**)&dispex);    if(SUCCEEDED(hres)) {        FIXME("Use IDispatchEx/n");        IDispatchEx_Release(dispex);    }    hres = IUnknown_QueryInterface(host->plugin_unk, &IID_IDispatch, (void**)&disp);    if(FAILED(hres))        return;    hres = IDispatch_Invoke(disp, DISPID_READYSTATE, &IID_NULL, 0, DISPATCH_PROPERTYGET, &params, &v, NULL, &err);    IDispatch_Release(disp);    if(SUCCEEDED(hres)) {        /* FIXME: make plugin readystate affect document readystate */        TRACE("readystate = %s/n", debugstr_variant(&v));        VariantClear(&v);    }}

static BOOL check_script_safety(PluginHost *host){    DISPPARAMS params = {NULL,NULL,0,0};    DWORD policy_size, policy;    struct CONFIRMSAFETY cs;    BYTE *ppolicy;    ULONG err = 0;    VARIANT v;    HRESULT hres;    cs.clsid = host->clsid;    cs.pUnk = host->plugin_unk;    cs.dwFlags = 0;    hres = IInternetHostSecurityManager_QueryCustomPolicy(&host->doc->IInternetHostSecurityManager_iface,            &GUID_CUSTOM_CONFIRMOBJECTSAFETY, &ppolicy, &policy_size, (BYTE*)&cs, sizeof(cs), 0);    if(FAILED(hres))        return FALSE;    policy = *(DWORD*)ppolicy;    CoTaskMemFree(ppolicy);    if(policy != URLPOLICY_ALLOW)        return FALSE;    V_VT(&v) = VT_EMPTY;    hres = IDispatch_Invoke(host->disp, DISPID_SECURITYCTX, &IID_NULL, 0, DISPATCH_PROPERTYGET, &params, &v, NULL, &err);    if(SUCCEEDED(hres)) {        FIXME("Handle security ctx %s/n", debugstr_variant(&v));        return FALSE;    }    return TRUE;}

static HRESULT get_doc_ready_state(DocHost *This, READYSTATE *ret){    DISPPARAMS dp = {NULL,NULL,0,0};    IDispatch *disp;    EXCEPINFO ei;    VARIANT var;    HRESULT hres;    hres = IUnknown_QueryInterface(This->document, &IID_IDispatch, (void**)&disp);    if(FAILED(hres))        return hres;    hres = IDispatch_Invoke(disp, DISPID_READYSTATE, &IID_NULL, LOCALE_SYSTEM_DEFAULT, DISPATCH_PROPERTYGET,            &dp, &var, &ei, NULL);    IDispatch_Release(disp);    if(FAILED(hres)) {        WARN("Invoke(DISPID_READYSTATE failed: %08x/n", hres);        return hres;    }    if(V_VT(&var) != VT_I4) {        WARN("V_VT(var) = %d/n", V_VT(&var));        VariantClear(&var);        return E_FAIL;    }    *ret = V_I4(&var);    return S_OK;}

void call_sink(ConnectionPoint *This, DISPID dispid, DISPPARAMS *dispparams){    DWORD i;    for(i=0; i<This->sinks_size; i++) {        if(This->sinks[i])            IDispatch_Invoke(This->sinks[i], dispid, &IID_NULL, LOCALE_SYSTEM_DEFAULT,                             DISPATCH_METHOD, dispparams, NULL, NULL, NULL);    }}

static HRESULT WINAPIIMediaPosition_fnInvoke(IMediaPosition* iface,DISPID DispId, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarRes, EXCEPINFO* pExcepInfo, UINT* puArgErr){	CFilterGraph_THIS(iface,mediaposition);	TRACE("(%p)->()/n",This);	return IDispatch_Invoke(		CFilterGraph_IDispatch(This),		DispId,riid,lcid,wFlags,pDispParams,pVarRes,pExcepInfo,puArgErr);}

static void httprequest_setreadystate(httprequest *This, READYSTATE state){    READYSTATE last = This->state;    This->state = state;    if (This->sink && last != state)    {        DISPPARAMS params;        memset(&params, 0, sizeof(params));        IDispatch_Invoke(This->sink, 0, &IID_NULL, LOCALE_SYSTEM_DEFAULT, DISPATCH_METHOD, &params, 0, 0, 0);    }}

static HRESULT call_cp_func(IDispatch *disp, DISPID dispid, HTMLEventObj *event_obj, VARIANT *retv){    DISPPARAMS dp = {NULL,NULL,0,0};    VARIANT event_arg;    ULONG argerr;    EXCEPINFO ei;    if(event_obj) {        V_VT(&event_arg) = VT_DISPATCH;        V_DISPATCH(&event_arg) = (IDispatch*)&event_obj->IHTMLEventObj_iface;        dp.rgvarg = &event_arg;        dp.cArgs = 1;    }    memset(&ei, 0, sizeof(ei));    return IDispatch_Invoke(disp, dispid, &IID_NULL, 0, DISPATCH_METHOD, &dp, retv, &ei, &argerr);}

static HRESULT call_cp_func(IDispatch *disp, DISPID dispid){    DISPPARAMS dp = {NULL,NULL,0,0};    ULONG argerr;    EXCEPINFO ei;    VARIANT vres;    HRESULT hres;    V_VT(&vres) = VT_EMPTY;    memset(&ei, 0, sizeof(ei));    hres = IDispatch_Invoke(disp, dispid, &IID_NULL, 0, DISPATCH_METHOD, &dp, &vres, &ei, &argerr);    if(SUCCEEDED(hres) && V_VT(&vres) != VT_EMPTY) {        FIXME("handle result %s/n", debugstr_variant(&vres));        VariantClear(&vres);    }    return hres;}

HRESULT disp_propput(script_ctx_t *ctx, IDispatch *disp, DISPID id, WORD flags, DISPPARAMS *dp){    IDispatchEx *dispex;    EXCEPINFO ei = {0};    HRESULT hres;    hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);    if(SUCCEEDED(hres)) {        hres = IDispatchEx_InvokeEx(dispex, id, ctx->lcid, flags, dp, NULL, &ei, NULL /* FIXME! */);        IDispatchEx_Release(dispex);    }else {        ULONG err = 0;        TRACE("using IDispatch/n");        hres = IDispatch_Invoke(disp, id, &IID_NULL, ctx->lcid, flags, dp, NULL, &ei, &err);    }    return hres;}

static HRESULT call_disp_func(IDispatch *disp, DISPPARAMS *dp, VARIANT *retv){    IDispatchEx *dispex;    EXCEPINFO ei;    HRESULT hres;    memset(&ei, 0, sizeof(ei));    hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);    if(SUCCEEDED(hres)) {        hres = IDispatchEx_InvokeEx(dispex, 0, GetUserDefaultLCID(), DISPATCH_METHOD, dp, retv, &ei, NULL);        IDispatchEx_Release(dispex);    }else {        TRACE("Could not get IDispatchEx interface: %08x/n", hres);        hres = IDispatch_Invoke(disp, 0, &IID_NULL, GetUserDefaultLCID(), DISPATCH_METHOD,                dp, retv, &ei, NULL);    }    return hres;}

static HRESULT invoke_disp_value(DispatchEx *This, IDispatch *func_disp, LCID lcid, WORD flags, DISPPARAMS *dp,        VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller){    DISPID named_arg = DISPID_THIS;    DISPPARAMS new_dp = {NULL, &named_arg, 0, 1};    IDispatchEx *dispex;    HRESULT hres;    if(dp->cNamedArgs) {        FIXME("named args not supported/n");        return E_NOTIMPL;    }    new_dp.rgvarg = heap_alloc((dp->cArgs+1)*sizeof(VARIANTARG));    if(!new_dp.rgvarg)        return E_OUTOFMEMORY;    new_dp.cArgs = dp->cArgs+1;    memcpy(new_dp.rgvarg+1, dp->rgvarg, dp->cArgs*sizeof(VARIANTARG));    V_VT(new_dp.rgvarg) = VT_DISPATCH;    V_DISPATCH(new_dp.rgvarg) = (IDispatch*)&This->IDispatchEx_iface;    hres = IDispatch_QueryInterface(func_disp, &IID_IDispatchEx, (void**)&dispex);    TRACE(">>>/n");    if(SUCCEEDED(hres)) {        hres = IDispatchEx_InvokeEx(dispex, DISPID_VALUE, lcid, flags, &new_dp, res, ei, caller);        IDispatchEx_Release(dispex);    }else {        ULONG err = 0;        hres = IDispatch_Invoke(func_disp, DISPID_VALUE, &IID_NULL, lcid, flags, &new_dp, res, ei, &err);    }    if(SUCCEEDED(hres))        TRACE("<<< %s/n", debugstr_variant(res));    else        WARN("<<< %08x/n", hres);    heap_free(new_dp.rgvarg);    return hres;}

static void notif_enabled(PluginHost *plugin_host){    DISPPARAMS args = {NULL, NULL, 0, 0};    IDispatch *disp;    ULONG err = 0;    VARIANT res;    HRESULT hres;    hres = IUnknown_QueryInterface(plugin_host->plugin_unk, &IID_IDispatch, (void**)&disp);    if(FAILED(hres)) {        FIXME("Could not get IDispatch iface: %08x/n", hres);        return;    }    V_VT(&res) = VT_EMPTY;    hres = IDispatch_Invoke(disp, DISPID_ENABLED, &IID_NULL, 0/*FIXME*/, DISPATCH_PROPERTYGET, &args, &res, NULL, &err);    IDispatch_Release(disp);    if(SUCCEEDED(hres)) {        FIXME("Got enabled %s/n", debugstr_variant(&res));        VariantClear(&res);    }}

HRESULT get_client_disp_property(IOleClientSite *client, DISPID dispid, VARIANT *res){    IDispatch *disp = NULL;    DISPPARAMS dispparams = {NULL, 0};    UINT err;    HRESULT hres;    hres = IOleClientSite_QueryInterface(client, &IID_IDispatch, (void**)&disp);    if(FAILED(hres)) {        TRACE("Could not get IDispatch/n");        return hres;    }    VariantInit(res);    hres = IDispatch_Invoke(disp, dispid, &IID_NULL, LOCALE_SYSTEM_DEFAULT,            DISPATCH_PROPERTYGET, &dispparams, res, NULL, &err);    IDispatch_Release(disp);    return hres;}

HRESULT disp_call(script_ctx_t *ctx, IDispatch *disp, DISPID id, DISPPARAMS *dp, VARIANT *retv){    const WORD flags = DISPATCH_METHOD|(retv ? DISPATCH_PROPERTYGET : 0);    IDispatchEx *dispex;    EXCEPINFO ei;    HRESULT hres;    memset(&ei, 0, sizeof(ei));    if(retv)        V_VT(retv) = VT_EMPTY;    hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);    if(FAILED(hres)) {        UINT err = 0;        TRACE("using IDispatch/n");        return IDispatch_Invoke(disp, id, &IID_NULL, ctx->lcid, flags, dp, retv, &ei, &err);    }    hres = IDispatchEx_InvokeEx(dispex, id, ctx->lcid, flags, dp, retv, &ei, NULL /* CALLER_FIXME */);    IDispatchEx_Release(dispex);    return hres;}

HRESULT invoke_plugin_prop(HTMLPluginContainer *plugin_container, DISPID id, LCID lcid, WORD flags, DISPPARAMS *params,        VARIANT *res, EXCEPINFO *ei){    PluginHost *host;    host = plugin_container->plugin_host;    if(!host || !host->disp) {        FIXME("Called with no disp/n");        return E_UNEXPECTED;    }    if(!check_script_safety(host)) {        FIXME("Insecure object/n");        return E_FAIL;    }    if(id < MSHTML_DISPID_CUSTOM_MIN || id > MSHTML_DISPID_CUSTOM_MIN + plugin_container->props_len) {        ERR("Invalid id/n");        return E_FAIL;    }    return IDispatch_Invoke(host->disp, plugin_container->props[id-MSHTML_DISPID_CUSTOM_MIN], &IID_NULL,            lcid, flags, params, res, ei, NULL);}

static HRESULT create_enumerator(script_ctx_t *ctx, jsval_t *argv, jsdisp_t **ret){    EnumeratorInstance *enumerator;    HRESULT hres;    IDispatch *obj;    DISPPARAMS dispparams = {NULL, NULL, 0, 0};    IEnumVARIANT *enumvar = NULL;    if (argv)    {        VARIANT varresult;        if (!is_object_instance(*argv))        {            FIXME("I don't know how to handle this type!/n");            return E_NOTIMPL;        }        obj = get_object(*argv);        /* Try to get a IEnumVARIANT by _NewEnum */        VariantInit(&varresult);        hres = IDispatch_Invoke(obj, DISPID_NEWENUM, &IID_NULL, LOCALE_NEUTRAL,                DISPATCH_METHOD, &dispparams, &varresult, NULL, NULL);        if (FAILED(hres))        {            WARN("Enumerator: no DISPID_NEWENUM./n");            return E_INVALIDARG;        }        if ((V_VT(&varresult) == VT_DISPATCH) || (V_VT(&varresult) == VT_UNKNOWN))        {            hres = IUnknown_QueryInterface(V_UNKNOWN(&varresult),                &IID_IEnumVARIANT, (void**)&enumvar);        }        else        {            FIXME("Enumerator: NewEnum unexpected type of varresult (%d)./n", V_VT(&varresult));            hres = E_INVALIDARG;        }        VariantClear(&varresult);        if (FAILED(hres))            return hres;    }    hres = alloc_enumerator(ctx, NULL, &enumerator);    if (FAILED(hres))    {        if (enumvar)            IEnumVARIANT_Release(enumvar);        return hres;    }    enumerator->enumvar = enumvar;    enumerator->atend = !enumvar;    hres = enumvar_get_next_item(enumerator);    if (FAILED(hres))    {        jsdisp_release(&enumerator->dispex);        return hres;    }    *ret = &enumerator->dispex;    return S_OK;}

HRESULT __RPC_STUB IDispatch_Invoke_Stub(    IDispatch* This,    DISPID dispIdMember,    REFIID riid,    LCID lcid,    DWORD dwFlags,    DISPPARAMS* pDispParams,    VARIANT* pVarResult,    EXCEPINFO* pExcepInfo,    UINT* pArgErr,    UINT cVarRef,    UINT* rgVarRefIdx,    VARIANTARG* rgVarRef){  HRESULT hr = S_OK;  VARIANTARG *rgvarg, *arg;  UINT u;  /* initialize out parameters, so that they can be marshalled   * in case the real Invoke doesn't initialize them */  VariantInit(pVarResult);  memset(pExcepInfo, 0, sizeof(*pExcepInfo));  *pArgErr = 0;  /* let the real Invoke operate on a copy of the in parameters,   * so we don't risk losing pointers to allocated memory */  rgvarg = pDispParams->rgvarg;  arg = CoTaskMemAlloc(sizeof(VARIANTARG)*pDispParams->cArgs);  if (!arg) return E_OUTOFMEMORY;  /* init all args so we can call VariantClear on all the args if the copy   * below fails */  for (u = 0; u < pDispParams->cArgs; u++)    VariantInit(&arg[u]);  for (u = 0; u < pDispParams->cArgs; u++) {    hr = VariantCopy(&arg[u], &rgvarg[u]);    if (FAILED(hr))        break;  }  if (SUCCEEDED(hr)) {    pDispParams->rgvarg = arg;    hr = IDispatch_Invoke(This,			  dispIdMember,			  riid,			  lcid,			  dwFlags,			  pDispParams,			  pVarResult,			  pExcepInfo,			  pArgErr);    /* copy ref args to out list */    for (u=0; u<cVarRef; u++) {      unsigned i = rgVarRefIdx[u];      VariantInit(&rgVarRef[u]);      VariantCopy(&rgVarRef[u], &arg[i]);      /* clear original if equal, to avoid double-free */      if (V_BYREF(&rgVarRef[u]) == V_BYREF(&rgvarg[i]))        VariantClear(&rgvarg[i]);    }  }  /* clear the duplicate argument list */  for (u=0; u<pDispParams->cArgs; u++)    VariantClear(&arg[u]);  pDispParams->rgvarg = rgvarg;  CoTaskMemFree(arg);  return hr;}

/* * Call a script. */DWORD call_script(MSIHANDLE hPackage, INT type, LPCWSTR script, LPCWSTR function, LPCWSTR action){    HRESULT hr;    IActiveScript *pActiveScript = NULL;    IActiveScriptParse *pActiveScriptParse = NULL;    MsiActiveScriptSite *pActiveScriptSite = NULL;    IDispatch *pDispatch = NULL;    DISPPARAMS dispparamsNoArgs = {NULL, NULL, 0, 0};    DISPID dispid;    CLSID clsid;    VARIANT var;    /* Return success by default (if Windows Script not installed) - not native behavior. This     * should be here until we implement wine scripting. */    DWORD ret = ERROR_SUCCESS;    CoInitialize(NULL);    /* Create MsiActiveScriptSite object */    hr = create_ActiveScriptSite(NULL, (void **)&pActiveScriptSite);    if (hr != S_OK) goto done;    /* Create an installer object */    hr = create_msiserver(NULL, (LPVOID *)&pActiveScriptSite->pInstaller);    if (hr != S_OK) goto done;    /* Create a session object */    hr = create_session(hPackage, pActiveScriptSite->pInstaller, &pActiveScriptSite->pSession);    if (hr != S_OK) goto done;    /* Create the scripting engine */    if ((type & 7) == msidbCustomActionTypeJScript)        hr = CLSIDFromProgID(szJScript, &clsid);    else if ((type & 7) == msidbCustomActionTypeVBScript)        hr = CLSIDFromProgID(szVBScript, &clsid);    else {        ERR("Unknown script type %d/n", type);        goto done;    }    if (FAILED(hr)) {        ERR("Could not find CLSID for Windows Script/n");        goto done;    }    hr = CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IActiveScript, (void **)&pActiveScript);    if (FAILED(hr)) {        ERR("Could not instantiate class for Windows Script/n");        goto done;    }    /* If we got this far, Windows Script is installed, so don't return success by default anymore */    ret = ERROR_INSTALL_FAILURE;    /* Get the IActiveScriptParse engine interface */    hr = IActiveScript_QueryInterface(pActiveScript, &IID_IActiveScriptParse, (void **)&pActiveScriptParse);    if (FAILED(hr)) goto done;    /* Give our host to the engine */    hr = IActiveScript_SetScriptSite(pActiveScript, (IActiveScriptSite *)pActiveScriptSite);    if (FAILED(hr)) goto done;    /* Initialize the script engine */    hr = IActiveScriptParse64_InitNew(pActiveScriptParse);    if (FAILED(hr)) goto done;    /* Add the session object */    hr = IActiveScript_AddNamedItem(pActiveScript, szSession, SCRIPTITEM_ISVISIBLE);    /* Pass the script to the engine */    hr = IActiveScriptParse64_ParseScriptText(pActiveScriptParse, script, NULL, NULL, NULL, 0, 0, 0L, NULL, NULL);    if (FAILED(hr)) goto done;    /* Start processing the script */    hr = IActiveScript_SetScriptState(pActiveScript, SCRIPTSTATE_CONNECTED);    if (FAILED(hr)) goto done;    /* Call a function if necessary through the IDispatch interface */    if (function != NULL && strlenW(function) > 0) {        TRACE("Calling function %s/n", debugstr_w(function));        hr = IActiveScript_GetScriptDispatch(pActiveScript, NULL, &pDispatch);        if (FAILED(hr)) goto done;        hr = IDispatch_GetIDsOfNames(pDispatch, &IID_NULL, (WCHAR **)&function, 1,LOCALE_USER_DEFAULT, &dispid);        if (FAILED(hr)) goto done;        hr = IDispatch_Invoke(pDispatch, dispid, &IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &dispparamsNoArgs, &var, NULL, NULL);        if (FAILED(hr)) goto done;        /* Check return value, if it's not IDOK we failed */        hr = VariantChangeType(&var, &var, 0, VT_I4);        if (FAILED(hr)) goto done;        if (V_I4(&var) == IDOK)            ret = ERROR_SUCCESS;        else ret = ERROR_INSTALL_FAILURE;        VariantClear(&var);//.........这里部分代码省略.........

zend_object_iterator *php_com_iter_get(zend_class_entry *ce, zval *object, int by_ref){	php_com_dotnet_object *obj;	struct php_com_iterator *I;	IEnumVARIANT *iev = NULL;	DISPPARAMS dp;	VARIANT v;	unsigned long n_fetched;	zval ptr;	if (by_ref) {		zend_throw_error(NULL, "An iterator cannot be used with foreach by reference");		return NULL;	}	obj = CDNO_FETCH(object);	if (V_VT(&obj->v) != VT_DISPATCH && !V_ISARRAY(&obj->v)) {		php_error_docref(NULL, E_WARNING, "variant is not an object or array VT=%d", V_VT(&obj->v));		return NULL;	}	memset(&dp, 0, sizeof(dp));	VariantInit(&v);	I = (struct php_com_iterator*)ecalloc(1, sizeof(*I));	zend_iterator_init(&I->iter);	I->iter.funcs = &com_iter_funcs;	Z_PTR(I->iter.data) = I;	I->code_page = obj->code_page;	ZVAL_UNDEF(&I->zdata);	VariantInit(&I->safe_array);	VariantInit(&I->v);	if (V_ISARRAY(&obj->v)) {		LONG bound;		UINT dims;		dims = SafeArrayGetDim(V_ARRAY(&obj->v));		if (dims != 1) {			php_error_docref(NULL, E_WARNING,				   "Can only handle single dimension variant arrays (this array has %d)", dims);			goto fail;		}		/* same semantics as foreach on a PHP array;		 * make a copy and enumerate that copy */		VariantCopy(&I->safe_array, &obj->v);		/* determine the key value for the array */		SafeArrayGetLBound(V_ARRAY(&I->safe_array), 1, &bound);		SafeArrayGetUBound(V_ARRAY(&I->safe_array), 1, &I->sa_max);		/* pre-fetch the element */		if (php_com_safearray_get_elem(&I->safe_array, &I->v, bound)) {			I->key = bound;			ZVAL_NULL(&ptr);			php_com_zval_from_variant(&ptr, &I->v, I->code_page);			ZVAL_COPY_VALUE(&I->zdata, &ptr);		} else {			I->key = (ulong)-1;		}	} else {		/* can we enumerate it? */		if (FAILED(IDispatch_Invoke(V_DISPATCH(&obj->v), DISPID_NEWENUM,						&IID_NULL, LOCALE_SYSTEM_DEFAULT, DISPATCH_METHOD|DISPATCH_PROPERTYGET,						&dp, &v, NULL, NULL))) {			goto fail;		}		/* get something useful out of it */		if (V_VT(&v) == VT_UNKNOWN) {			IUnknown_QueryInterface(V_UNKNOWN(&v), &IID_IEnumVARIANT, (void**)&iev);		} else if (V_VT(&v) == VT_DISPATCH) {			IDispatch_QueryInterface(V_DISPATCH(&v), &IID_IEnumVARIANT, (void**)&iev);		}		VariantClear(&v);		if (iev == NULL) {			goto fail;		}		I->ev = iev;		/* Get the first element now */		if (SUCCEEDED(IEnumVARIANT_Next(I->ev, 1, &I->v, &n_fetched)) && n_fetched > 0) {			/* indicate that we have element 0 */			I->key = 0;			ZVAL_NULL(&ptr);			php_com_zval_from_variant(&ptr, &I->v, I->code_page);			ZVAL_COPY_VALUE(&I->zdata, &ptr);		} else {			/* indicate that there are no more items */			I->key = (ulong)-1;		}	}//.........这里部分代码省略.........

static void test_wshshell(void){    static const WCHAR desktopW[] = {'D','e','s','k','t','o','p',0};    static const WCHAR lnk1W[] = {'f','i','l','e','.','l','n','k',0};    IWshShell3 *sh3;    IDispatchEx *dispex;    IWshCollection *coll;    IDispatch *disp, *shortcut;    IUnknown *shell, *unk;    IFolderCollection *folders;    ITypeInfo *ti;    HRESULT hr;    TYPEATTR *tattr;    DISPPARAMS dp;    EXCEPINFO ei;    VARIANT arg, res;    BSTR str;    UINT err;    hr = CoCreateInstance(&CLSID_WshShell, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,            &IID_IDispatch, (void**)&disp);    if(FAILED(hr)) {        win_skip("Could not create WshShell object: %08x/n", hr);        return;    }    hr = IDispatch_QueryInterface(disp, &IID_IWshShell3, (void**)&shell);    EXPECT_HR(hr, S_OK);    IDispatch_Release(disp);    hr = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);    EXPECT_HR(hr, E_NOINTERFACE);    hr = IUnknown_QueryInterface(shell, &IID_IWshShell3, (void**)&sh3);    EXPECT_HR(hr, S_OK);    hr = IWshShell3_get_SpecialFolders(sh3, &coll);    EXPECT_HR(hr, S_OK);    hr = IWshCollection_QueryInterface(coll, &IID_IFolderCollection, (void**)&folders);    EXPECT_HR(hr, E_NOINTERFACE);    hr = IWshCollection_QueryInterface(coll, &IID_IDispatch, (void**)&disp);    EXPECT_HR(hr, S_OK);    hr = IDispatch_GetTypeInfo(disp, 0, 0, &ti);    EXPECT_HR(hr, S_OK);    hr = ITypeInfo_GetTypeAttr(ti, &tattr);    EXPECT_HR(hr, S_OK);    ok(IsEqualIID(&tattr->guid, &IID_IWshCollection), "got wrong type guid/n");    ITypeInfo_ReleaseTypeAttr(ti, tattr);    /* try to call Item() with normal IDispatch procedure */    str = SysAllocString(desktopW);    V_VT(&arg) = VT_BSTR;    V_BSTR(&arg) = str;    dp.rgvarg = &arg;    dp.rgdispidNamedArgs = NULL;    dp.cArgs = 1;    dp.cNamedArgs = 0;    hr = IDispatch_Invoke(disp, DISPID_VALUE, &IID_NULL, 1033, DISPATCH_PROPERTYGET, &dp, &res, &ei, &err);    EXPECT_HR(hr, DISP_E_MEMBERNOTFOUND);    /* try Item() directly, it returns directory path apparently */    V_VT(&res) = VT_EMPTY;    hr = IWshCollection_Item(coll, &arg, &res);    EXPECT_HR(hr, S_OK);    ok(V_VT(&res) == VT_BSTR, "got res type %d/n", V_VT(&res));    SysFreeString(str);    VariantClear(&res);    /* CreateShortcut() */    str = SysAllocString(lnk1W);    hr = IWshShell3_CreateShortcut(sh3, str, &shortcut);    EXPECT_HR(hr, S_OK);    SysFreeString(str);    hr = IDispatch_QueryInterface(shortcut, &IID_IWshShortcut, (void**)&unk);    EXPECT_HR(hr, S_OK);    IUnknown_Release(unk);    IDispatch_Release(shortcut);    IWshCollection_Release(coll);    IDispatch_Release(disp);    IWshShell3_Release(sh3);    IUnknown_Release(shell);}

static void test_wshshell(void){    static const WCHAR notepadW[] = {'n','o','t','e','p','a','d','.','e','x','e',0};    static const WCHAR desktopW[] = {'D','e','s','k','t','o','p',0};    static const WCHAR lnk1W[] = {'f','i','l','e','.','l','n','k',0};    static const WCHAR pathW[] = {'%','P','A','T','H','%',0};    static const WCHAR sysW[] = {'S','Y','S','T','E','M',0};    static const WCHAR path2W[] = {'P','A','T','H',0};    static const WCHAR dummydirW[] = {'d','e','a','d','p','a','r','r','o','t',0};    static const WCHAR emptyW[] = {'e','m','p','t','y',0};    IWshEnvironment *env;    IWshExec *shexec;    IWshShell3 *sh3;    IDispatchEx *dispex;    IWshCollection *coll;    IDispatch *disp, *shortcut;    IUnknown *shell, *unk;    IFolderCollection *folders;    IWshShortcut *shcut;    ITypeInfo *ti;    HRESULT hr;    TYPEATTR *tattr;    DISPPARAMS dp;    EXCEPINFO ei;    VARIANT arg, res, arg2;    BSTR str, ret;    DWORD retval;    UINT err;    hr = CoCreateInstance(&CLSID_WshShell, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,            &IID_IDispatch, (void**)&disp);    ok(hr == S_OK, "got 0x%08x/n", hr);    hr = IDispatch_QueryInterface(disp, &IID_IWshShell3, (void**)&shell);    EXPECT_HR(hr, S_OK);    IDispatch_Release(disp);    hr = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);    EXPECT_HR(hr, E_NOINTERFACE);    hr = IUnknown_QueryInterface(shell, &IID_IWshShell3, (void**)&sh3);    EXPECT_HR(hr, S_OK);    hr = IWshShell3_QueryInterface(sh3, &IID_IObjectWithSite, (void**)&unk);    ok(hr == E_NOINTERFACE, "got 0x%08x/n", hr);    hr = IWshShell3_QueryInterface(sh3, &IID_IWshShell, (void**)&unk);    ok(hr == S_OK, "got 0x%08x/n", hr);    IUnknown_Release(unk);    hr = IWshShell3_QueryInterface(sh3, &IID_IWshShell2, (void**)&unk);    ok(hr == S_OK, "got 0x%08x/n", hr);    IUnknown_Release(unk);    hr = IWshShell3_get_SpecialFolders(sh3, &coll);    EXPECT_HR(hr, S_OK);    hr = IWshCollection_QueryInterface(coll, &IID_IFolderCollection, (void**)&folders);    EXPECT_HR(hr, E_NOINTERFACE);    hr = IWshCollection_QueryInterface(coll, &IID_IDispatch, (void**)&disp);    EXPECT_HR(hr, S_OK);    hr = IDispatch_GetTypeInfo(disp, 0, 0, &ti);    EXPECT_HR(hr, S_OK);    hr = ITypeInfo_GetTypeAttr(ti, &tattr);    EXPECT_HR(hr, S_OK);    ok(IsEqualIID(&tattr->guid, &IID_IWshCollection), "got wrong type guid/n");    ITypeInfo_ReleaseTypeAttr(ti, tattr);    /* try to call Item() with normal IDispatch procedure */    str = SysAllocString(desktopW);    V_VT(&arg) = VT_BSTR;    V_BSTR(&arg) = str;    dp.rgvarg = &arg;    dp.rgdispidNamedArgs = NULL;    dp.cArgs = 1;    dp.cNamedArgs = 0;    hr = IDispatch_Invoke(disp, DISPID_VALUE, &IID_NULL, 1033, DISPATCH_PROPERTYGET, &dp, &res, &ei, &err);    EXPECT_HR(hr, DISP_E_MEMBERNOTFOUND);    /* try Item() directly, it returns directory path apparently */    V_VT(&res) = VT_EMPTY;    hr = IWshCollection_Item(coll, &arg, &res);    EXPECT_HR(hr, S_OK);    ok(V_VT(&res) == VT_BSTR, "got res type %d/n", V_VT(&res));    SysFreeString(str);    VariantClear(&res);    /* CreateShortcut() */    str = SysAllocString(lnk1W);    hr = IWshShell3_CreateShortcut(sh3, str, &shortcut);    EXPECT_HR(hr, S_OK);    SysFreeString(str);    hr = IDispatch_QueryInterface(shortcut, &IID_IWshShortcut, (void**)&shcut);    EXPECT_HR(hr, S_OK);    hr = IWshShortcut_get_Arguments(shcut, NULL);    ok(hr == E_POINTER, "got 0x%08x/n", hr);//.........这里部分代码省略.........

static HRESULT WINAPI DispatchEx_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,        VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller){    DispatchEx *This = impl_from_IDispatchEx(iface);    HRESULT hres;    TRACE("(%p)->(%x %x %x %p %p %p %p)/n", This, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);    if(is_custom_dispid(id) && This->data->vtbl && This->data->vtbl->invoke)        return This->data->vtbl->invoke(This, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);    if(wFlags == DISPATCH_CONSTRUCT) {        if(id == DISPID_VALUE) {            if(This->data->vtbl && This->data->vtbl->value) {                return This->data->vtbl->value(This, lcid, wFlags, pdp, pvarRes, pei, pspCaller);            }            FIXME("DISPATCH_CONSTRUCT flag but missing value function/n");            return E_FAIL;        }        FIXME("DISPATCH_CONSTRUCT flag without DISPID_VALUE/n");        return E_FAIL;    }    if(is_dynamic_dispid(id)) {        DWORD idx = id - DISPID_DYNPROP_0;        dynamic_prop_t *prop;        if(!get_dynamic_data(This) || This->dynamic_data->prop_cnt <= idx)            return DISP_E_UNKNOWNNAME;        prop = This->dynamic_data->props+idx;        switch(wFlags) {        case DISPATCH_METHOD|DISPATCH_PROPERTYGET:            if(!pvarRes)                return E_INVALIDARG;            /* fall through */        case DISPATCH_METHOD: {            DISPID named_arg = DISPID_THIS;            DISPPARAMS dp = {NULL, &named_arg, 0, 1};            IDispatchEx *dispex;            if(V_VT(&prop->var) != VT_DISPATCH) {                FIXME("invoke %s/n", debugstr_variant(&prop->var));                return E_NOTIMPL;            }            if(pdp->cNamedArgs) {                FIXME("named args not supported/n");                return E_NOTIMPL;            }            dp.rgvarg = heap_alloc((pdp->cArgs+1)*sizeof(VARIANTARG));            if(!dp.rgvarg)                return E_OUTOFMEMORY;            dp.cArgs = pdp->cArgs+1;            memcpy(dp.rgvarg+1, pdp->rgvarg, pdp->cArgs*sizeof(VARIANTARG));            V_VT(dp.rgvarg) = VT_DISPATCH;            V_DISPATCH(dp.rgvarg) = (IDispatch*)&This->IDispatchEx_iface;            hres = IDispatch_QueryInterface(V_DISPATCH(&prop->var), &IID_IDispatchEx, (void**)&dispex);            TRACE("%s call/n", debugstr_w(This->dynamic_data->props[idx].name));            if(SUCCEEDED(hres)) {                hres = IDispatchEx_InvokeEx(dispex, DISPID_VALUE, lcid, wFlags, &dp, pvarRes, pei, pspCaller);                IDispatchEx_Release(dispex);            }else {                ULONG err = 0;                hres = IDispatch_Invoke(V_DISPATCH(&prop->var), DISPID_VALUE, &IID_NULL, lcid, wFlags, pdp, pvarRes, pei, &err);            }            TRACE("%s ret %08x/n", debugstr_w(This->dynamic_data->props[idx].name), hres);            heap_free(dp.rgvarg);            return hres;        }        case DISPATCH_PROPERTYGET:            if(prop->flags & DYNPROP_DELETED)                return DISP_E_UNKNOWNNAME;            V_VT(pvarRes) = VT_EMPTY;            return variant_copy(pvarRes, &prop->var);        case DISPATCH_PROPERTYPUT|DISPATCH_PROPERTYPUTREF:        case DISPATCH_PROPERTYPUT:            if(pdp->cArgs != 1 || (pdp->cNamedArgs == 1 && *pdp->rgdispidNamedArgs != DISPID_PROPERTYPUT)               || pdp->cNamedArgs > 1) {                FIXME("invalid args/n");                return E_INVALIDARG;            }            TRACE("put %s/n", debugstr_variant(pdp->rgvarg));            VariantClear(&prop->var);            hres = variant_copy(&prop->var, pdp->rgvarg);            if(FAILED(hres))                return hres;            prop->flags &= ~DYNPROP_DELETED;            return S_OK;        default:            FIXME("unhandled wFlags %x/n", wFlags);            return E_NOTIMPL;//.........这里部分代码省略.........