/* ECMA-262 3rd Edition 9.1 */
HRESULT to_primitive(script_ctx_t *ctx, VARIANT *v, jsexcept_t *ei, VARIANT *ret)
{
switch(V_VT(v)) {
case VT_EMPTY:
case VT_NULL:
case VT_BOOL:
case VT_I4:
case VT_R8:
*ret = *v;
break;
case VT_BSTR:
V_VT(ret) = VT_BSTR;
V_BSTR(ret) = SysAllocString(V_BSTR(v));
break;
case VT_DISPATCH:
return disp_propget(V_DISPATCH(v), DISPID_VALUE, ctx->lcid, ret, ei, NULL /*FIXME*/);
default:
FIXME("Unimplemented for vt %d\n", V_VT(v));
return E_NOTIMPL;
}
return S_OK;
}
void php_com_object_enable_event_sink(php_com_dotnet_object *obj, int enable)
{
if (obj->sink_dispatch) {
IConnectionPointContainer *cont;
IConnectionPoint *point;
if (SUCCEEDED(IDispatch_QueryInterface(V_DISPATCH(&obj->v),
&IID_IConnectionPointContainer, (void**)&cont))) {
if (SUCCEEDED(IConnectionPointContainer_FindConnectionPoint(cont,
&obj->sink_id, &point))) {
if (enable) {
IConnectionPoint_Advise(point, (IUnknown*)obj->sink_dispatch, &obj->sink_cookie);
} else {
IConnectionPoint_Unadvise(point, obj->sink_cookie);
}
IConnectionPoint_Release(point);
}
IConnectionPointContainer_Release(cont);
}
}
}
static HRESULT WINAPI xslprocessor_put_input( IXSLProcessor *iface, VARIANT input )
{
xslprocessor *This = impl_from_IXSLProcessor( iface );
IXMLDOMNode *input_node;
HRESULT hr;
TRACE("(%p)->(%s)\n", This, debugstr_variant(&input));
/* try IXMLDOMNode directly first */
if (V_VT(&input) == VT_UNKNOWN)
hr = IUnknown_QueryInterface(V_UNKNOWN(&input), &IID_IXMLDOMNode, (void**)&input_node);
else if (V_VT(&input) == VT_DISPATCH)
hr = IDispatch_QueryInterface(V_DISPATCH(&input), &IID_IXMLDOMNode, (void**)&input_node);
else
{
IXMLDOMDocument *doc;
hr = DOMDocument_create(MSXML_DEFAULT, (void**)&doc);
if (hr == S_OK)
{
VARIANT_BOOL b;
hr = IXMLDOMDocument_load(doc, input, &b);
if (hr == S_OK)
hr = IXMLDOMDocument_QueryInterface(doc, &IID_IXMLDOMNode, (void**)&input_node);
IXMLDOMDocument_Release(doc);
}
}
if (hr == S_OK)
{
if (This->input) IXMLDOMNode_Release(This->input);
This->input = input_node;
}
return hr;
}
static HRESULT create_function(script_ctx_t *ctx, DWORD flags, BOOL funcprot, DispatchEx *prototype, FunctionInstance **ret)
{
FunctionInstance *function;
HRESULT hres;
function = heap_alloc_zero(sizeof(FunctionInstance));
if(!function)
return E_OUTOFMEMORY;
if(funcprot)
hres = init_dispex(&function->dispex, ctx, &Function_info, prototype);
else
hres = init_dispex_from_constr(&function->dispex, ctx, &Function_info, ctx->function_constr);
if(FAILED(hres))
return hres;
function->flags = flags;
function->length = flags & PROPF_ARGMASK;
if(prototype) {
jsexcept_t jsexcept;
VARIANT var;
V_VT(&var) = VT_DISPATCH;
V_DISPATCH(&var) = (IDispatch*)_IDispatchEx_(prototype);
memset(&jsexcept, 0, sizeof(jsexcept));
hres = jsdisp_propput_name(&function->dispex, prototypeW, ctx->lcid, &var, &jsexcept, NULL/*FIXME*/);
if(FAILED(hres)) {
IDispatchEx_Release(_IDispatchEx_(&function->dispex));
return hres;
}
}
*ret = function;
return S_OK;
}
static HRESULT WINAPI HTMLStyleSheetsCollection_item(IHTMLStyleSheetsCollection *iface,
VARIANT *pvarIndex, VARIANT *pvarResult)
{
HTMLStyleSheetsCollection *This = impl_from_IHTMLStyleSheetsCollection(iface);
TRACE("(%p)->(%s %p)\n", This, debugstr_variant(pvarIndex), pvarResult);
switch(V_VT(pvarIndex)) {
case VT_I4: {
nsIDOMStyleSheet *nsstylesheet;
nsresult nsres;
TRACE("index=%d\n", V_I4(pvarIndex));
nsres = nsIDOMStyleSheetList_Item(This->nslist, V_I4(pvarIndex), &nsstylesheet);
if(NS_FAILED(nsres) || !nsstylesheet) {
WARN("Item failed: %08x\n", nsres);
V_VT(pvarResult) = VT_EMPTY;
return E_INVALIDARG;
}
V_VT(pvarResult) = VT_DISPATCH;
V_DISPATCH(pvarResult) = (IDispatch*)HTMLStyleSheet_Create(nsstylesheet);
return S_OK;
}
case VT_BSTR:
FIXME("id=%s not implemented\n", debugstr_w(V_BSTR(pvarResult)));
return E_NOTIMPL;
default:
WARN("Invalid index %s\n", debugstr_variant(pvarIndex));
}
return E_INVALIDARG;
}
static HRESULT create_var_disp(FunctionInstance *function, LCID lcid, DISPPARAMS *dp, jsexcept_t *ei,
IServiceProvider *caller, DispatchEx **ret)
{
DispatchEx *var_disp, *arg_disp;
HRESULT hres;
static const WCHAR argumentsW[] = {'a','r','g','u','m','e','n','t','s',0};
hres = create_dispex(function->dispex.ctx, NULL, NULL, &var_disp);
if(FAILED(hres))
return hres;
hres = create_dispex(function->dispex.ctx, NULL, NULL, &arg_disp);
if(SUCCEEDED(hres)) {
hres = init_arguments(arg_disp, function, lcid, dp, ei, caller);
if(SUCCEEDED(hres)) {
VARIANT var;
V_VT(&var) = VT_DISPATCH;
V_DISPATCH(&var) = (IDispatch*)_IDispatchEx_(arg_disp);
hres = jsdisp_propput_name(var_disp, argumentsW, lcid, &var, ei, caller);
}
jsdisp_release(arg_disp);
}
if(SUCCEEDED(hres))
hres = init_parameters(var_disp, function, lcid, dp, ei, caller);
if(FAILED(hres)) {
jsdisp_release(var_disp);
return hres;
}
*ret = var_disp;
return S_OK;
}
const char *debugstr_variant(const VARIANT *v)
{
if(!v)
return "(null)";
switch(V_VT(v)) {
case VT_EMPTY:
return "{VT_EMPTY}";
case VT_NULL:
return "{VT_NULL}";
case VT_I4:
return wine_dbg_sprintf("{VT_I4: %d}", V_I4(v));
case VT_R8:
return wine_dbg_sprintf("{VT_R8: %lf}", V_R8(v));
case VT_BSTR:
return wine_dbg_sprintf("{VT_BSTR: %s}", debugstr_w(V_BSTR(v)));
case VT_DISPATCH:
return wine_dbg_sprintf("{VT_DISPATCH: %p}", V_DISPATCH(v));
case VT_BOOL:
return wine_dbg_sprintf("{VT_BOOL: %x}", V_BOOL(v));
default:
return wine_dbg_sprintf("{vt %d}", V_VT(v));
}
}
static HRESULT nodelist_get_item(IUnknown *iface, LONG index, VARIANT *item)
{
V_VT(item) = VT_DISPATCH;
return IXMLDOMNodeList_get_item((IXMLDOMNodeList*)iface, index, (IXMLDOMNode**)&V_DISPATCH(item));
}
static HRESULT xmlnodelist_invoke(IUnknown *iface, DISPID id, LCID lcid, WORD flags, DISPPARAMS *params,
VARIANT *res, EXCEPINFO *ei)
{
xmlnodelist *This = impl_from_IXMLDOMNodeList( (IXMLDOMNodeList*)iface );
TRACE("(%p)->(%x %x %x %p %p %p)\n", This, id, lcid, flags, params, res, ei);
if (id >= DISPID_DOM_COLLECTION_BASE && id <= DISPID_DOM_COLLECTION_MAX)
{
switch(flags)
{
case DISPATCH_PROPERTYGET:
{
IXMLDOMNode *disp = NULL;
V_VT(res) = VT_DISPATCH;
IXMLDOMNodeList_get_item(&This->IXMLDOMNodeList_iface, id - DISPID_DOM_COLLECTION_BASE, &disp);
V_DISPATCH(res) = (IDispatch*)disp;
break;
}
default:
{
FIXME("unimplemented flags %x\n", flags);
break;
}
}
}
else if (id == DISPID_VALUE)
{
switch(flags)
{
case DISPATCH_METHOD|DISPATCH_PROPERTYGET:
case DISPATCH_PROPERTYGET:
case DISPATCH_METHOD:
{
IXMLDOMNode *item;
VARIANT index;
HRESULT hr;
if (params->cArgs - params->cNamedArgs != 1) return DISP_E_BADPARAMCOUNT;
VariantInit(&index);
hr = VariantChangeType(&index, params->rgvarg, 0, VT_I4);
if(FAILED(hr))
{
FIXME("failed to convert arg, %s\n", debugstr_variant(params->rgvarg));
return hr;
}
IXMLDOMNodeList_get_item(&This->IXMLDOMNodeList_iface, V_I4(&index), &item);
V_VT(res) = VT_DISPATCH;
V_DISPATCH(res) = (IDispatch*)item;
break;
}
default:
{
FIXME("DISPID_VALUE: unimplemented flags %x\n", flags);
break;
}
}
}
else
return DISP_E_UNKNOWNNAME;
TRACE("ret %p\n", V_DISPATCH(res));
return S_OK;
}
static HRESULT WINAPI schema_cache_add(IXMLDOMSchemaCollection2* iface, BSTR uri, VARIANT var)
{
schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);
xmlChar* name = xmlChar_from_wchar(uri);
TRACE("(%p)->(%s, var(vt %x))\n", This, debugstr_w(uri), V_VT(&var));
switch (V_VT(&var))
{
case VT_NULL:
{
xmlHashRemoveEntry(This->cache, name, cache_free);
}
break;
case VT_BSTR:
{
xmlChar* url = xmlChar_from_wchar(V_BSTR(&var));
cache_entry* entry = cache_entry_from_url((char const*)url);
heap_free(url);
if (entry)
{
cache_entry_add_ref(entry);
}
else
{
heap_free(name);
return E_FAIL;
}
xmlHashRemoveEntry(This->cache, name, cache_free);
xmlHashAddEntry(This->cache, name, entry);
}
break;
case VT_DISPATCH:
{
xmlDocPtr doc = NULL;
cache_entry* entry;
SCHEMA_TYPE type;
IXMLDOMNode* domnode = NULL;
IDispatch_QueryInterface(V_DISPATCH(&var), &IID_IXMLDOMNode, (void**)&domnode);
if (domnode)
doc = xmlNodePtr_from_domnode(domnode, XML_DOCUMENT_NODE)->doc;
if (!doc)
{
IXMLDOMNode_Release(domnode);
heap_free(name);
return E_INVALIDARG;
}
type = schema_type_from_xmlDocPtr(doc);
if (type == SCHEMA_TYPE_XSD)
{
entry = cache_entry_from_xsd_doc(doc);
}
else if (type == SCHEMA_TYPE_XDR)
{
entry = cache_entry_from_xdr_doc(doc);
}
else
{
WARN("invalid schema!\n");
entry = NULL;
}
IXMLDOMNode_Release(domnode);
if (entry)
{
cache_entry_add_ref(entry);
}
else
{
heap_free(name);
return E_FAIL;
}
xmlHashRemoveEntry(This->cache, name, cache_free);
xmlHashAddEntry(This->cache, name, entry);
}
break;
default:
{
heap_free(name);
return E_INVALIDARG;
}
}
heap_free(name);
return S_OK;
}
bool CFirewallOpener::FindRule(const EFOCAction eAction, const CICSRuleInfo& riPortRule, const INetSharingConfigurationPtr pNSC, INetSharingPortMappingPropsPtr* outNSPMP){
INetSharingPortMappingCollectionPtr pNSPMC;
RETURN_ON_FAIL(pNSC->get_EnumPortMappings (ICSSC_DEFAULT, &pNSPMC));
INetSharingPortMappingPtr pNSPM;
IEnumVARIANTPtr varEnum;
IUnknownPtr pUnk;
RETURN_ON_FAIL(pNSPMC->get__NewEnum(&pUnk));
RETURN_ON_FAIL(pUnk->QueryInterface(__uuidof(IEnumVARIANT), (void**)&varEnum));
_variant_t var;
while (S_OK == varEnum->Next(1, &var, NULL)) {
INetSharingPortMappingPropsPtr pNSPMP;
if (V_VT(&var) == VT_DISPATCH
&& SUCCEEDED(V_DISPATCH(&var)->QueryInterface(__uuidof(INetSharingPortMapping),(void**)&pNSPM))
&& SUCCEEDED(pNSPM->get_Properties (&pNSPMP)))
{
UCHAR ucProt = 0;
long uExternal = 0;
CComBSTR bstrName;
pNSPMP->get_IPProtocol (&ucProt);
pNSPMP->get_ExternalPort (&uExternal);
pNSPMP->get_Name(&bstrName);
switch(eAction){
case FOC_FINDRULEBYPORT:
if (riPortRule.m_nPortNumber == uExternal && riPortRule.m_byProtocol == ucProt){
if (outNSPMP != NULL)
*outNSPMP = pNSPM;
return true;
}
break;
case FOC_FINDRULEBYNAME:
if (riPortRule.m_strRuleName == CString(bstrName)){
if (outNSPMP != NULL)
*outNSPMP = pNSPM;
return true;
}
break;
case FOC_DELETERULEEXCACT:
if (riPortRule.m_strRuleName == CString(bstrName)
&& riPortRule.m_nPortNumber == uExternal && riPortRule.m_byProtocol == ucProt)
{
RETURN_ON_FAIL(pNSC->RemovePortMapping(pNSPM));
theApp.QueueDebugLogLine(false,_T("Rule removed"));
}
break;
case FOC_DELETERULEBYNAME:
if (riPortRule.m_strRuleName == CString(bstrName)){
RETURN_ON_FAIL(pNSC->RemovePortMapping(pNSPM));
theApp.QueueDebugLogLine(false,_T("Rule removed"));
}
break;
default:
ASSERT( false );
}
}
var.Clear();
}
switch(eAction){
case FOC_DELETERULEBYNAME:
case FOC_DELETERULEEXCACT:
return true;
case FOC_FINDRULEBYPORT:
case FOC_FINDRULEBYNAME:
default:
return false;
}
}
/* Performs an Invoke on the given com object.
* returns a failure code and creates an exception if there was an error */
HRESULT php_com_invoke_helper(php_com_dotnet_object *obj, DISPID id_member,
WORD flags, DISPPARAMS *disp_params, VARIANT *v, int silent, int allow_noarg TSRMLS_DC)
{
HRESULT hr;
unsigned int arg_err;
EXCEPINFO e = {0};
hr = IDispatch_Invoke(V_DISPATCH(&obj->v), id_member,
&IID_NULL, LOCALE_SYSTEM_DEFAULT, flags, disp_params, v, &e, &arg_err);
if (silent == 0 && FAILED(hr)) {
char *source = NULL, *desc = NULL, *msg = NULL;
int source_len, desc_len;
switch (hr) {
case DISP_E_EXCEPTION:
if (e.bstrSource) {
source = php_com_olestring_to_string(e.bstrSource, &source_len, obj->code_page TSRMLS_CC);
SysFreeString(e.bstrSource);
}
if (e.bstrDescription) {
desc = php_com_olestring_to_string(e.bstrDescription, &desc_len, obj->code_page TSRMLS_CC);
SysFreeString(e.bstrDescription);
}
if (PG(html_errors)) {
spprintf(&msg, 0, "<b>Source:</b> %s<br/><b>Description:</b> %s",
source ? source : "Unknown",
desc ? desc : "Unknown");
} else {
spprintf(&msg, 0, "Source: %s\nDescription: %s",
source ? source : "Unknown",
desc ? desc : "Unknown");
}
if (desc) {
efree(desc);
}
if (source) {
efree(source);
}
if (e.bstrHelpFile) {
SysFreeString(e.bstrHelpFile);
}
break;
case DISP_E_PARAMNOTFOUND:
case DISP_E_TYPEMISMATCH:
desc = php_win_err(hr);
spprintf(&msg, 0, "Parameter %d: %s", arg_err, desc);
LocalFree(desc);
break;
case DISP_E_BADPARAMCOUNT:
if ((disp_params->cArgs + disp_params->cNamedArgs == 0) && (allow_noarg == 1)) {
/* if getting a property and they are missing all parameters,
* we want to create a proxy object for them; so lets not create an
* exception here */
msg = NULL;
break;
}
/* else fall through */
default:
desc = php_win_err(hr);
spprintf(&msg, 0, "Error [0x%08x] %s", hr, desc);
LocalFree(desc);
break;
}
if (msg) {
php_com_throw_exception(hr, msg TSRMLS_CC);
efree(msg);
}
}
return hr;
}
static HRESULT GetGCSearch(IDirectorySearch **ppDS)
{
HRESULT hr;
IEnumVARIANT *pEnum = NULL;
IADsContainer *pCont = NULL;
IDispatch *pDisp = NULL;
VARIANT var;
ULONG lFetch;
*ppDS = NULL;
/* Bind to the GC: namespace container object. The true GC DN
is a single immediate child of the GC: namespace, which must
be obtained using enumeration. */
hr = ADsOpenObject(L"GC:", NULL, NULL, ADS_SECURE_AUTHENTICATION, /* Use Secure Authentication. */
IID_IADsContainer,
(void**)&pCont);
if (FAILED(hr))
{
smpd_err_printf("ADsOpenObject failed: 0x%x\n", hr);
goto cleanup;
}
/* Get an enumeration interface for the GC container. */
hr = ADsBuildEnumerator(pCont, &pEnum);
if (FAILED(hr))
{
smpd_err_printf("ADsBuildEnumerator failed: 0x%x\n", hr);
goto cleanup;
}
/* Now enumerate. There is only one child of the GC: object. */
hr = ADsEnumerateNext(pEnum, 1, &var, &lFetch);
if (FAILED(hr))
{
smpd_err_printf("ADsEnumerateNext failed: 0x%x\n", hr);
goto cleanup;
}
if ((hr == S_OK) && (lFetch == 1))
{
pDisp = V_DISPATCH(&var);
hr = pDisp->QueryInterface(IID_IDirectorySearch, (void**)ppDS);
}
cleanup:
if (pEnum)
{
ADsFreeEnumerator(pEnum);
pEnum = NULL;
}
if (pCont)
{
pCont->Release();
pCont = NULL;
}
if (pDisp)
{
pDisp->Release();
pDisp = NULL;
}
return hr;
}
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;
}
}
return &I->iter;
fail:
if (I) {
VariantClear(&I->safe_array);
VariantClear(&I->v);
efree(I);
}
return NULL;
}
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(wFlags == (DISPATCH_PROPERTYPUT|DISPATCH_PROPERTYPUTREF))
wFlags = DISPATCH_PROPERTYPUT;
switch(get_dispid_type(id)) {
case DISPEXPROP_CUSTOM:
if(!This->data->vtbl || !This->data->vtbl->invoke)
return DISP_E_UNKNOWNNAME;
return This->data->vtbl->invoke(This, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
case DISPEXPROP_DYNAMIC: {
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:
if(V_VT(&prop->var) != VT_DISPATCH) {
FIXME("invoke %s\n", debugstr_variant(&prop->var));
return E_NOTIMPL;
}
return invoke_disp_value(This, V_DISPATCH(&prop->var), lcid, wFlags, pdp, pvarRes, pei, pspCaller);
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:
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;
}
}
case DISPEXPROP_BUILTIN:
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;
}
return invoke_builtin_prop(This, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
default:
assert(0);
return E_FAIL;
}
}
HRESULT remove_attribute(DispatchEx *This, DISPID id, VARIANT_BOOL *success)
{
switch(get_dispid_type(id)) {
case DISPEXPROP_CUSTOM:
FIXME("DISPEXPROP_CUSTOM not supported\n");
return E_NOTIMPL;
case DISPEXPROP_DYNAMIC: {
DWORD idx = id - DISPID_DYNPROP_0;
dynamic_prop_t *prop;
prop = This->dynamic_data->props+idx;
VariantClear(&prop->var);
prop->flags |= DYNPROP_DELETED;
*success = VARIANT_TRUE;
return S_OK;
}
case DISPEXPROP_BUILTIN: {
VARIANT var;
DISPPARAMS dp = {&var,NULL,1,0};
dispex_data_t *data;
func_info_t *func;
HRESULT hres;
data = get_dispex_data(This);
if(!data)
return E_FAIL;
hres = get_builtin_func(data, id, &func);
if(FAILED(hres))
return hres;
/* For builtin functions, we set their value to the original function. */
if(func->func_disp_idx != -1) {
func_obj_entry_t *entry;
if(!This->dynamic_data || !This->dynamic_data->func_disps
|| !This->dynamic_data->func_disps[func->func_disp_idx].func_obj) {
*success = VARIANT_FALSE;
return S_OK;
}
entry = This->dynamic_data->func_disps + func->func_disp_idx;
if(V_VT(&entry->val) == VT_DISPATCH
&& V_DISPATCH(&entry->val) == (IDispatch*)&entry->func_obj->dispex.IDispatchEx_iface) {
*success = VARIANT_FALSE;
return S_OK;
}
VariantClear(&entry->val);
V_VT(&entry->val) = VT_DISPATCH;
V_DISPATCH(&entry->val) = (IDispatch*)&entry->func_obj->dispex.IDispatchEx_iface;
IDispatch_AddRef(V_DISPATCH(&entry->val));
*success = VARIANT_TRUE;
return S_OK;
}
V_VT(&var) = VT_EMPTY;
hres = builtin_propput(This, func, &dp, NULL);
if(FAILED(hres))
return hres;
*success = VARIANT_TRUE;
return S_OK;
}
default:
assert(0);
return E_FAIL;
}
}
static HRESULT function_invoke(DispatchEx *This, func_info_t *func, WORD flags, DISPPARAMS *dp, VARIANT *res,
EXCEPINFO *ei, IServiceProvider *caller)
{
HRESULT hres;
switch(flags) {
case DISPATCH_METHOD|DISPATCH_PROPERTYGET:
if(!res)
return E_INVALIDARG;
/* fall through */
case DISPATCH_METHOD:
if(This->dynamic_data && This->dynamic_data->func_disps
&& This->dynamic_data->func_disps[func->func_disp_idx].func_obj) {
func_obj_entry_t *entry = This->dynamic_data->func_disps + func->func_disp_idx;
if(V_VT(&entry->val) != VT_DISPATCH) {
FIXME("calling %s not supported\n", debugstr_variant(&entry->val));
return E_NOTIMPL;
}
if((IDispatch*)&entry->func_obj->dispex.IDispatchEx_iface != V_DISPATCH(&entry->val)) {
if(!V_DISPATCH(&entry->val)) {
FIXME("Calling null\n");
return E_FAIL;
}
hres = invoke_disp_value(This, V_DISPATCH(&entry->val), 0, flags, dp, res, ei, NULL);
break;
}
}
if(func->call_vtbl_off)
hres = invoke_builtin_function(This, func, dp, res, caller);
else
hres = typeinfo_invoke(This, func, flags, dp, res, ei);
break;
case DISPATCH_PROPERTYGET: {
func_obj_entry_t *entry;
if(func->id == DISPID_VALUE) {
BSTR ret;
ret = SysAllocString(objectW);
if(!ret)
return E_OUTOFMEMORY;
V_VT(res) = VT_BSTR;
V_BSTR(res) = ret;
return S_OK;
}
hres = get_func_obj_entry(This, func, &entry);
if(FAILED(hres))
return hres;
V_VT(res) = VT_EMPTY;
return VariantCopy(res, &entry->val);
}
case DISPATCH_PROPERTYPUT: {
func_obj_entry_t *entry;
if(dp->cArgs != 1 || (dp->cNamedArgs == 1 && *dp->rgdispidNamedArgs != DISPID_PROPERTYPUT)
|| dp->cNamedArgs > 1) {
FIXME("invalid args\n");
return E_INVALIDARG;
}
/*
* NOTE: Although we have IDispatchEx tests showing, that it's not allowed to set
* function property using InvokeEx, it's possible to do that from jscript.
* Native probably uses some undocumented interface in this case, but it should
* be fine for us to allow IDispatchEx handle that.
*/
hres = get_func_obj_entry(This, func, &entry);
if(FAILED(hres))
return hres;
return VariantCopy(&entry->val, dp->rgvarg);
}
default:
FIXME("Unimplemented flags %x\n", flags);
hres = E_NOTIMPL;
}
return hres;
}
/* ECMA-262 3rd Edition 15.4.4.11 */
static HRESULT Array_sort(script_ctx_t *ctx, vdisp_t *vthis, WORD flags, DISPPARAMS *dp,
VARIANT *retv, jsexcept_t *ei)
{
jsdisp_t *jsthis, *cmp_func = NULL;
VARIANT *vtab, **sorttab = NULL;
DWORD length;
DWORD i;
HRESULT hres = S_OK;
TRACE("\n");
hres = get_length(ctx, vthis, ei, &jsthis, &length);
if(FAILED(hres))
return hres;
if(arg_cnt(dp) > 1) {
WARN("invalid arg_cnt %d\n", arg_cnt(dp));
return E_FAIL;
}
if(arg_cnt(dp) == 1) {
VARIANT *arg = get_arg(dp, 0);
if(V_VT(arg) != VT_DISPATCH) {
WARN("arg is not dispatch\n");
return E_FAIL;
}
cmp_func = iface_to_jsdisp((IUnknown*)V_DISPATCH(arg));
if(!cmp_func || !is_class(cmp_func, JSCLASS_FUNCTION)) {
WARN("cmp_func is not a function\n");
if(cmp_func)
jsdisp_release(cmp_func);
return E_FAIL;
}
}
if(!length) {
if(cmp_func)
jsdisp_release(cmp_func);
if(retv) {
jsdisp_addref(jsthis);
var_set_jsdisp(retv, jsthis);
}
return S_OK;
}
vtab = heap_alloc_zero(length * sizeof(VARIANT));
if(vtab) {
for(i=0; i<length; i++) {
hres = jsdisp_get_idx(jsthis, i, vtab+i, ei);
if(hres == DISP_E_UNKNOWNNAME) {
V_VT(vtab+i) = VT_EMPTY;
hres = S_OK;
} else if(FAILED(hres)) {
WARN("Could not get elem %d: %08x\n", i, hres);
break;
}
}
}else {
hres = E_OUTOFMEMORY;
}
if(SUCCEEDED(hres)) {
sorttab = heap_alloc(length*2*sizeof(VARIANT*));
if(!sorttab)
hres = E_OUTOFMEMORY;
}
/* merge-sort */
if(SUCCEEDED(hres)) {
VARIANT *tmpv, **tmpbuf;
INT cmp;
tmpbuf = sorttab + length;
for(i=0; i < length; i++)
sorttab[i] = vtab+i;
for(i=0; i < length/2; i++) {
hres = sort_cmp(ctx, cmp_func, sorttab[2*i+1], sorttab[2*i], ei, &cmp);
if(FAILED(hres))
break;
if(cmp < 0) {
tmpv = sorttab[2*i];
sorttab[2*i] = sorttab[2*i+1];
sorttab[2*i+1] = tmpv;
}
}
if(SUCCEEDED(hres)) {
DWORD k, a, b, bend;
for(k=2; k < length; k *= 2) {
for(i=0; i+k < length; i += 2*k) {
a = b = 0;
if(i+2*k <= length)
bend = k;
else
bend = length - (i+k);
memcpy(tmpbuf, sorttab+i, k*sizeof(VARIANT*));
while(a < k && b < bend) {
hres = sort_cmp(ctx, cmp_func, tmpbuf[a], sorttab[i+k+b], ei, &cmp);
if(FAILED(hres))
break;
if(cmp < 0) {
sorttab[i+a+b] = tmpbuf[a];
a++;
}else {
sorttab[i+a+b] = sorttab[i+k+b];
b++;
}
}
if(FAILED(hres))
break;
if(a < k)
memcpy(sorttab+i+a+b, tmpbuf+a, (k-a)*sizeof(VARIANT*));
}
if(FAILED(hres))
break;
}
}
for(i=0; SUCCEEDED(hres) && i < length; i++)
hres = jsdisp_propput_idx(jsthis, i, sorttab[i], ei);
}
if(vtab) {
for(i=0; i < length; i++)
VariantClear(vtab+i);
heap_free(vtab);
}
heap_free(sorttab);
if(cmp_func)
jsdisp_release(cmp_func);
if(FAILED(hres))
return hres;
if(retv) {
jsdisp_addref(jsthis);
var_set_jsdisp(retv, jsthis);
}
return S_OK;
}
static void test_async_xhr(IHTMLDocument2 *doc, const char *xml_url, const char *expect_text)
{
VARIANT vbool, vempty, var;
BSTR method, url;
BSTR text;
LONG val;
HRESULT hres;
static const struct HEADER_TYPE expect_headers[] = {
{"Content-Length", "51"},
{"Content-Type", "application/xml"}
};
create_xmlhttprequest(doc);
if(!xhr)
return;
V_VT(&var) = VT_DISPATCH;
V_DISPATCH(&var) = (IDispatch*)&xmlhttprequest_onreadystatechange_obj;
hres = IHTMLXMLHttpRequest_put_onreadystatechange(xhr, var);
ok(hres == S_OK, "put_onreadystatechange failed: %08x\n", hres);
V_VT(&var) = VT_EMPTY;
hres = IHTMLXMLHttpRequest_get_onreadystatechange(xhr, &var);
ok(hres == S_OK, "get_onreadystatechange failed: %08x\n", hres);
ok(V_VT(&var) == VT_DISPATCH, "V_VT(onreadystatechange) = %d\n", V_VT(&var));
ok(V_DISPATCH(&var) == (IDispatch*)&xmlhttprequest_onreadystatechange_obj, "unexpected onreadystatechange value\n");
hres = IHTMLXMLHttpRequest_getResponseHeader(xhr, NULL, &text);
ok(hres == E_INVALIDARG, "Expect E_INVALIDARG, got %08x\n", hres);
hres = IHTMLXMLHttpRequest_getResponseHeader(xhr, content_type, NULL);
ok(hres == E_POINTER, "Expect E_POINTER, got %08x\n", hres);
hres = IHTMLXMLHttpRequest_getResponseHeader(xhr, NULL, NULL);
ok(hres == E_POINTER || broken(hres == E_INVALIDARG), /* Vista and before */
"Expect E_POINTER, got %08x\n", hres);
text = (BSTR)0xdeadbeef;
hres = IHTMLXMLHttpRequest_getResponseHeader(xhr, content_type, &text);
ok(hres == E_FAIL, "got %08x\n", hres);
ok(text == NULL, "text = %p\n", text);
hres = IHTMLXMLHttpRequest_getAllResponseHeaders(xhr, NULL);
ok(hres == E_POINTER, "Expect E_POINTER, got %08x\n", hres);
text = (BSTR)0xdeadbeef;
hres = IHTMLXMLHttpRequest_getAllResponseHeaders(xhr, &text);
ok(hres == E_FAIL, "got %08x\n", hres);
ok(text == NULL, "text = %p\n", text);
val = 0xdeadbeef;
hres = IHTMLXMLHttpRequest_get_status(xhr, &val);
ok(hres == E_FAIL, "Expect E_FAIL, got: %08x\n", hres);
ok(val == 0, "Expect 0, got %d\n", val);
text = (BSTR)0xdeadbeef;
hres = IHTMLXMLHttpRequest_get_statusText(xhr, &text);
ok(hres == E_FAIL, "Expect E_FAIL, got: %08x\n", hres);
ok(text == NULL, "Expect NULL, got %p\n", text);
val = 0xdeadbeef;
hres = IHTMLXMLHttpRequest_get_readyState(xhr, &val);
ok(hres == S_OK, "get_readyState failed: %08x\n", hres);
ok(val == 0, "Expect UNSENT, got %d\n", val);
method = a2bstr("GET");
url = a2bstr(xml_url);
V_VT(&vbool) = VT_BOOL;
V_BOOL(&vbool) = VARIANT_TRUE;
V_VT(&vempty) = VT_EMPTY;
SET_EXPECT(xmlhttprequest_onreadystatechange_opened);
hres = IHTMLXMLHttpRequest_open(xhr, method, url, vbool, vempty, vempty);
ok(hres == S_OK, "open failed: %08x\n", hres);
CHECK_CALLED(xmlhttprequest_onreadystatechange_opened);
SysFreeString(method);
SysFreeString(url);
if(FAILED(hres)) {
IHTMLXMLHttpRequest_Release(xhr);
xhr = NULL;
return;
}
text = (BSTR)0xdeadbeef;
hres = IHTMLXMLHttpRequest_getAllResponseHeaders(xhr, &text);
ok(hres == E_FAIL, "got %08x\n", hres);
ok(text == NULL, "text = %p\n", text);
text = (BSTR)0xdeadbeef;
hres = IHTMLXMLHttpRequest_getResponseHeader(xhr, content_type, &text);
ok(hres == E_FAIL, "got %08x\n", hres);
ok(text == NULL, "text = %p\n", text);
val = 0xdeadbeef;
hres = IHTMLXMLHttpRequest_get_status(xhr, &val);
ok(hres == E_FAIL, "Expect E_FAIL, got: %08x\n", hres);
ok(val == 0, "Expect 0, got %d\n", val);
hres = IHTMLXMLHttpRequest_get_statusText(xhr, &text);
ok(hres == E_FAIL, "Expect E_FAIL, got: %08x\n", hres);
ok(text == NULL, "Expect NULL, got %p\n", text);
val = 0xdeadbeef;
hres = IHTMLXMLHttpRequest_get_readyState(xhr, &val);
ok(hres == S_OK, "get_readyState failed: %08x\n", hres);
ok(val == 1, "Expect OPENED, got %d\n", val);
SET_EXPECT(xmlhttprequest_onreadystatechange_opened);
SET_EXPECT(xmlhttprequest_onreadystatechange_headers_received);
SET_EXPECT(xmlhttprequest_onreadystatechange_loading);
SET_EXPECT(xmlhttprequest_onreadystatechange_done);
loading_cnt = 0;
hres = IHTMLXMLHttpRequest_send(xhr, vempty);
ok(hres == S_OK, "send failed: %08x\n", hres);
if(SUCCEEDED(hres))
pump_msgs(&called_xmlhttprequest_onreadystatechange_done);
todo_wine CHECK_CALLED(xmlhttprequest_onreadystatechange_opened);
CHECK_CALLED(xmlhttprequest_onreadystatechange_headers_received);
CHECK_CALLED(xmlhttprequest_onreadystatechange_loading);
CHECK_CALLED(xmlhttprequest_onreadystatechange_done);
/* Workaround for loading large files */
todo_wine_if(!expect_text)
ok(loading_cnt == 1, "loading_cnt = %d\n", loading_cnt);
if(FAILED(hres)) {
IHTMLXMLHttpRequest_Release(xhr);
xhr = NULL;
return;
}
text = NULL;
hres = IHTMLXMLHttpRequest_getAllResponseHeaders(xhr, &text);
ok(hres == S_OK, "getAllResponseHeader failed, got %08x\n", hres);
ok(text != NULL, "text == NULL\n");
SysFreeString(text);
if(expect_text)
test_header(expect_headers, sizeof(expect_headers)/sizeof(expect_headers[0]));
val = 0xdeadbeef;
hres = IHTMLXMLHttpRequest_get_status(xhr, &val);
ok(hres == S_OK, "get_status failed: %08x\n", hres);
ok(val == 200, "Expect 200, got %d\n", val);
text = NULL;
hres = IHTMLXMLHttpRequest_get_statusText(xhr, &text);
ok(hres == S_OK, "get_statusText failed: %08x\n", hres);
ok(text != NULL, "text == NULL\n");
ok(!strcmp_wa(text, "OK"), "Expected \"OK\", got %s\n", wine_dbgstr_w(text));
SysFreeString(text);
val = 0xdeadbeef;
hres = IHTMLXMLHttpRequest_get_readyState(xhr, &val);
ok(hres == S_OK, "get_readyState failed: %08x\n", hres);
ok(val == 4, "Expect DONE, got %d\n", val);
text = NULL;
hres = IHTMLXMLHttpRequest_get_responseText(xhr, &text);
ok(hres == S_OK, "get_responseText failed: %08x\n", hres);
ok(text != NULL, "test == NULL\n");
if(expect_text)
ok(!strcmp_wa(text, expect_text), "expect %s, got %s\n",
expect_text, wine_dbgstr_w(text));
SysFreeString(text);
test_responseXML(expect_text);
IHTMLXMLHttpRequest_Release(xhr);
xhr = NULL;
}
static void on_before_navigate2(DocHost *This, LPCWSTR url, const BYTE *post_data,
ULONG post_data_len, LPWSTR headers, VARIANT_BOOL *cancel)
{
VARIANT var_url, var_flags, var_frame_name, var_post_data, var_post_data2, var_headers;
DISPPARAMS dispparams;
VARIANTARG params[7];
dispparams.cArgs = 7;
dispparams.cNamedArgs = 0;
dispparams.rgdispidNamedArgs = NULL;
dispparams.rgvarg = params;
This->busy = VARIANT_TRUE;
V_VT(params) = VT_BOOL|VT_BYREF;
V_BOOLREF(params) = cancel;
V_VT(params+1) = (VT_BYREF|VT_VARIANT);
V_VARIANTREF(params+1) = &var_headers;
V_VT(&var_headers) = VT_BSTR;
V_BSTR(&var_headers) = headers;
V_VT(params+2) = (VT_BYREF|VT_VARIANT);
V_VARIANTREF(params+2) = &var_post_data2;
V_VT(&var_post_data2) = (VT_BYREF|VT_VARIANT);
V_VARIANTREF(&var_post_data2) = &var_post_data;
VariantInit(&var_post_data);
if(post_data_len) {
SAFEARRAYBOUND bound = {post_data_len, 0};
void *data;
V_VT(&var_post_data) = VT_UI1|VT_ARRAY;
V_ARRAY(&var_post_data) = SafeArrayCreate(VT_UI1, 1, &bound);
SafeArrayAccessData(V_ARRAY(&var_post_data), &data);
memcpy(data, post_data, post_data_len);
SafeArrayUnaccessData(V_ARRAY(&var_post_data));
}
V_VT(params+3) = (VT_BYREF|VT_VARIANT);
V_VARIANTREF(params+3) = &var_frame_name;
V_VT(&var_frame_name) = VT_BSTR;
V_BSTR(&var_frame_name) = NULL;
V_VT(params+4) = (VT_BYREF|VT_VARIANT);
V_VARIANTREF(params+4) = &var_flags;
V_VT(&var_flags) = VT_I4;
V_I4(&var_flags) = 0;
V_VT(params+5) = (VT_BYREF|VT_VARIANT);
V_VARIANTREF(params+5) = &var_url;
V_VT(&var_url) = VT_BSTR;
V_BSTR(&var_url) = SysAllocString(url);
V_VT(params+6) = (VT_DISPATCH);
V_DISPATCH(params+6) = This->disp;
call_sink(This->cps.wbe2, DISPID_BEFORENAVIGATE2, &dispparams);
SysFreeString(V_BSTR(&var_url));
if(post_data_len)
SafeArrayDestroy(V_ARRAY(&var_post_data));
}
static HRESULT WINAPI DocObjectService_FireBeforeNavigate2(
IDocObjectService* iface,
IDispatch *pDispatch,
LPCWSTR lpszUrl,
DWORD dwFlags,
LPCWSTR lpszFrameName,
BYTE *pPostData,
DWORD cbPostData,
LPCWSTR lpszHeaders,
BOOL fPlayNavSound,
BOOL *pfCancel)
{
ShellBrowser *This = impl_from_IDocObjectService(iface);
VARIANT var_url, var_flags, var_frame_name, var_post_data, var_post_data2, var_headers;
VARIANTARG params[7];
DISPPARAMS dp = {params, NULL, 7, 0};
VARIANT_BOOL cancel = VARIANT_FALSE;
SAFEARRAY *post_data;
TRACE("%p %p %s %x %s %p %d %s %d %p\n", This, pDispatch, debugstr_w(lpszUrl),
dwFlags, debugstr_w(lpszFrameName), pPostData, cbPostData,
debugstr_w(lpszHeaders), fPlayNavSound, pfCancel);
if(cbPostData) {
post_data = SafeArrayCreateVector(VT_UI1, 0, cbPostData);
if(!post_data)
return E_OUTOFMEMORY;
memcpy(post_data->pvData, pPostData, cbPostData);
}else {
post_data = NULL;
}
V_VT(params) = VT_BOOL|VT_BYREF;
V_BOOLREF(params) = &cancel;
V_VT(params+1) = (VT_BYREF|VT_VARIANT);
V_VARIANTREF(params+1) = &var_headers;
V_VT(&var_headers) = VT_BSTR;
V_BSTR(&var_headers) = lpszHeaders ? SysAllocString(lpszHeaders) : NULL;
V_VT(params+2) = (VT_BYREF|VT_VARIANT);
V_VARIANTREF(params+2) = &var_post_data2;
V_VT(&var_post_data2) = (VT_BYREF|VT_VARIANT);
V_VARIANTREF(&var_post_data2) = &var_post_data;
if(post_data) {
V_VT(&var_post_data) = VT_UI1|VT_ARRAY;
V_ARRAY(&var_post_data) = post_data;
}else {
V_VT(&var_post_data) = VT_EMPTY;
}
V_VT(params+3) = (VT_BYREF|VT_VARIANT);
V_VARIANTREF(params+3) = &var_frame_name;
V_VT(&var_frame_name) = VT_BSTR;
V_BSTR(&var_frame_name) = lpszFrameName ? SysAllocString(lpszFrameName) : NULL;
V_VT(params+4) = (VT_BYREF|VT_VARIANT);
V_VARIANTREF(params+4) = &var_flags;
V_VT(&var_flags) = VT_I4;
V_I4(&var_flags) = 0;
V_VT(params+5) = (VT_BYREF|VT_VARIANT);
V_VARIANTREF(params+5) = &var_url;
V_VT(&var_url) = VT_BSTR;
V_BSTR(&var_url) = SysAllocString(lpszUrl);
V_VT(params+6) = (VT_DISPATCH);
V_DISPATCH(params+6) = (IDispatch*)This->doc_host->wb;
/* Keep reference to This. It may be released in event handler. */
IShellBrowser_AddRef(&This->IShellBrowser_iface);
TRACE(">>>\n");
call_sink(This->doc_host->cps.wbe2, DISPID_BEFORENAVIGATE2, &dp);
TRACE("<<<\n");
IShellBrowser_Release(&This->IShellBrowser_iface);
SysFreeString(V_BSTR(&var_url));
SysFreeString(V_BSTR(&var_headers));
SysFreeString(V_BSTR(&var_frame_name));
SafeArrayDestroy(post_data);
*pfCancel = !!cancel;
return S_OK;
}
static void test_async_xhr_abort(IHTMLDocument2 *doc, const char *xml_url)
{
VARIANT vbool, vempty, var;
BSTR method, url;
LONG val;
HRESULT hres;
method = a2bstr("GET");
url = a2bstr(xml_url);
V_VT(&vbool) = VT_BOOL;
V_BOOL(&vbool) = VARIANT_TRUE;
V_VT(&vempty) = VT_EMPTY;
trace("abort before send() is fired\n");
create_xmlhttprequest(doc);
if(!xhr)
return;
V_VT(&var) = VT_DISPATCH;
V_DISPATCH(&var) = (IDispatch*)&xmlhttprequest_onreadystatechange_obj;
hres = IHTMLXMLHttpRequest_put_onreadystatechange(xhr, var);
SET_EXPECT(xmlhttprequest_onreadystatechange_opened);
hres = IHTMLXMLHttpRequest_open(xhr, method, url, vbool, vempty, vempty);
ok(hres == S_OK, "open failed: %08x\n", hres);
CHECK_CALLED(xmlhttprequest_onreadystatechange_opened);
hres = IHTMLXMLHttpRequest_abort(xhr);
ok(hres == S_OK, "abort failed: %08x\n", hres);
hres = IHTMLXMLHttpRequest_get_status(xhr, &val);
ok(hres == E_FAIL, "Expect E_FAIL, got: %08x\n", hres);
ok(val == 0, "Expect 0, got %d\n", val);
hres = IHTMLXMLHttpRequest_get_readyState(xhr, &val);
ok(hres == S_OK, "get_readyState failed: %08x\n", hres);
ok(val == 0, "Expect UNSENT, got %d\n", val);
IHTMLXMLHttpRequest_Release(xhr);
xhr = NULL;
trace("abort after send() is fired\n");
create_xmlhttprequest(doc);
V_VT(&var) = VT_DISPATCH;
V_DISPATCH(&var) = (IDispatch*)&xmlhttprequest_onreadystatechange_obj;
hres = IHTMLXMLHttpRequest_put_onreadystatechange(xhr, var);
SET_EXPECT(xmlhttprequest_onreadystatechange_opened);
hres = IHTMLXMLHttpRequest_open(xhr, method, url, vbool, vempty, vempty);
ok(hres == S_OK, "open failed: %08x\n", hres);
CHECK_CALLED(xmlhttprequest_onreadystatechange_opened);
loading_cnt = 0;
readystatechange_cnt = 0;
SET_EXPECT(xmlhttprequest_onreadystatechange_opened);
SET_EXPECT(xmlhttprequest_onreadystatechange_done);
hres = IHTMLXMLHttpRequest_send(xhr, vempty);
ok(hres == S_OK, "send failed: %08x\n", hres);
todo_wine CHECK_CALLED(xmlhttprequest_onreadystatechange_opened);
hres = IHTMLXMLHttpRequest_abort(xhr);
ok(hres == S_OK, "abort failed: %08x\n", hres);
CHECK_CALLED(xmlhttprequest_onreadystatechange_done);
hres = IHTMLXMLHttpRequest_get_readyState(xhr, &val);
ok(hres == S_OK, "get_readyState failed: %08x\n", hres);
ok(val == 0, "Expect UNSENT, got %d\n", val);
hres = IHTMLXMLHttpRequest_get_status(xhr, &val);
ok(hres == E_FAIL, "Expect E_FAIL, got: %08x\n", hres);
ok(val == 0, "Expect 0, got %d\n", val);
ok(loading_cnt == 0, "loading_cnt = %d, expect 0, loading_cnt\n", loading_cnt);
todo_wine ok(readystatechange_cnt == 2, "readystatechange_cnt = %d, expect 2\n", readystatechange_cnt);
IHTMLXMLHttpRequest_Release(xhr);
xhr = NULL;
SysFreeString(method);
SysFreeString(url);
}
static HRESULT WINAPI DispatchEx_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
{
DispatchEx *This = DISPATCHEX_THIS(iface);
IUnknown *unk;
ITypeInfo *ti;
dispex_data_t *data;
UINT argerr=0;
int min, max, n;
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->outer, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
if(wFlags == DISPATCH_CONSTRUCT) {
FIXME("DISPATCH_CONSTRUCT not implemented\n");
return E_NOTIMPL;
}
if(is_dynamic_dispid(id)) {
DWORD idx = id - DISPID_DYNPROP_0;
VARIANT *var;
if(!This->dynamic_data || This->dynamic_data->prop_cnt <= idx)
return DISP_E_UNKNOWNNAME;
var = &This->dynamic_data->props[idx].var;
switch(wFlags) {
case INVOKE_FUNC: {
DISPID named_arg = DISPID_THIS;
DISPPARAMS dp = {NULL, &named_arg, 0, 1};
IDispatchEx *dispex;
if(V_VT(var) != VT_DISPATCH) {
FIXME("invoke vt %d\n", V_VT(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*)DISPATCHEX(This);
hres = IDispatch_QueryInterface(V_DISPATCH(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(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 INVOKE_PROPERTYGET:
return VariantCopy(pvarRes, var);
case INVOKE_PROPERTYPUT:
VariantClear(var);
return VariantCopy(var, pdp->rgvarg);
default:
FIXME("unhandled wFlags %x\n", wFlags);
return E_NOTIMPL;
}
}
data = get_dispex_data(This);
if(!data)
return E_FAIL;
min = 0;
max = data->func_cnt-1;
while(min <= max) {
n = (min+max)/2;
if(data->funcs[n].id == id)
break;
if(data->funcs[n].id < id)
min = n+1;
else
max = n-1;
}
if(min > max) {
WARN("invalid id %x\n", id);
return DISP_E_UNKNOWNNAME;
}
hres = get_typeinfo(data->funcs[n].tid, &ti);
if(FAILED(hres)) {
ERR("Could not get type info: %08x\n", hres);
return hres;
}
hres = IUnknown_QueryInterface(This->outer, tid_ids[data->funcs[n].tid], (void**)&unk);
if(FAILED(hres)) {
ERR("Could not get iface %s: %08x\n", debugstr_guid(tid_ids[data->funcs[n].tid]), hres);
return E_FAIL;
}
hres = ITypeInfo_Invoke(ti, unk, id, wFlags, pdp, pvarRes, pei, &argerr);
IUnknown_Release(unk);
return hres;
}
static void test_AccessibleChildren(IAccessible *acc)
{
VARIANT children[3];
LONG count;
HRESULT hr;
count = -1;
hr = AccessibleChildren(NULL, 0, 0, children, &count);
ok(hr == E_INVALIDARG, "AccessibleChildren returned %x\n", hr);
ok(count == -1, "count = %d\n", count);
hr = AccessibleChildren(acc, 0, 0, NULL, &count);
ok(hr == E_INVALIDARG, "AccessibleChildren returned %x\n", hr);
ok(count == -1, "count = %d\n", count);
hr = AccessibleChildren(acc, 0, 0, children, NULL);
ok(hr == E_INVALIDARG, "AccessibleChildren returned %x\n", hr);
if(acc == &Accessible) {
SET_EXPECT(Accessible_QI_IEnumVARIANT);
SET_EXPECT(Accessible_get_accChildCount);
}
hr = AccessibleChildren(acc, 0, 0, children, &count);
ok(hr == S_OK, "AccessibleChildren returned %x\n", hr);
if(acc == &Accessible) {
CHECK_CALLED(Accessible_QI_IEnumVARIANT);
CHECK_CALLED(Accessible_get_accChildCount);
}
ok(!count, "count = %d\n", count);
count = -1;
if(acc == &Accessible) {
SET_EXPECT(Accessible_QI_IEnumVARIANT);
SET_EXPECT(Accessible_get_accChildCount);
}
hr = AccessibleChildren(acc, 5, 0, children, &count);
ok(hr == S_OK, "AccessibleChildren returned %x\n", hr);
if(acc == &Accessible) {
CHECK_CALLED(Accessible_QI_IEnumVARIANT);
CHECK_CALLED(Accessible_get_accChildCount);
}
ok(!count, "count = %d\n", count);
memset(children, 0xfe, sizeof(children));
V_VT(children) = VT_DISPATCH;
if(acc == &Accessible) {
SET_EXPECT(Accessible_QI_IEnumVARIANT);
SET_EXPECT(Accessible_get_accChildCount);
SET_EXPECT(Accessible_get_accChild);
}
hr = AccessibleChildren(acc, 0, 1, children, &count);
ok(hr == S_OK, "AccessibleChildren returned %x\n", hr);
if(acc == &Accessible) {
CHECK_CALLED(Accessible_QI_IEnumVARIANT);
CHECK_CALLED(Accessible_get_accChildCount);
CHECK_CALLED(Accessible_get_accChild);
ok(V_VT(children) == VT_I4, "V_VT(children) = %d\n", V_VT(children));
ok(V_I4(children) == 1, "V_I4(children) = %d\n", V_I4(children));
}else {
ok(V_VT(children) == VT_DISPATCH, "V_VT(children) = %d\n", V_VT(children));
IDispatch_Release(V_DISPATCH(children));
}
ok(count == 1, "count = %d\n", count);
if(acc == &Accessible) {
SET_EXPECT(Accessible_QI_IEnumVARIANT);
SET_EXPECT(Accessible_get_accChildCount);
SET_EXPECT(Accessible_get_accChild);
}
hr = AccessibleChildren(acc, 0, 3, children, &count);
ok(hr == S_FALSE, "AccessibleChildren returned %x\n", hr);
if(acc == &Accessible) {
CHECK_CALLED(Accessible_QI_IEnumVARIANT);
CHECK_CALLED(Accessible_get_accChildCount);
CHECK_CALLED(Accessible_get_accChild);
ok(V_VT(children) == VT_I4, "V_VT(children) = %d\n", V_VT(children));
ok(V_I4(children) == 1, "V_I4(children) = %d\n", V_I4(children));
}else {
ok(V_VT(children) == VT_DISPATCH, "V_VT(children) = %d\n", V_VT(children));
IDispatch_Release(V_DISPATCH(children));
}
ok(count == 1, "count = %d\n", count);
ok(V_VT(children+1) == VT_EMPTY, "V_VT(children+1) = %d\n", V_VT(children+1));
ok(V_VT(children+2) == VT_EMPTY, "V_VT(children+2) = %d\n", V_VT(children+2));
}
STDMETHODIMP CXMLDOMDocument::load(VARIANT xmlSource, VARIANT_BOOL *isSuccessful)
{
ATLTRACE(_T("CXMLDOMDocument::load\n"));
if (NULL == isSuccessful)
return E_POINTER;
*isSuccessful = VARIANT_FALSE;
if (V_VT(&xmlSource) != VT_BSTR &&
V_VT(&xmlSource) != VT_DISPATCH &&
V_VT(&xmlSource) != (VT_ARRAY | VT_VARIANT) &&
V_VT(&xmlSource) != (VT_ARRAY | VT_UI1) &&
V_VT(&xmlSource) != VT_UNKNOWN)
return E_INVALIDARG;
// do not start another thread if there is another active
if (NULL != m_hParseThread) {
DWORD exitCode = 0;
BOOL rc = ::GetExitCodeThread(m_hParseThread, &exitCode);
if (!rc || STILL_ACTIVE == exitCode)
return S_OK;
::CloseHandle(m_hParseThread);
m_hParseThread = NULL;
}
HRESULT hr = S_OK;
m_bAbort = false;
m_FileName = _T("");
m_xml = _T("");
m_TmpDocument = 0;
m_bThreadValidate = m_bValidate;
if (V_VT(&xmlSource) == VT_BSTR) {
m_FileName = V_BSTR(&xmlSource);
if (0 == m_FileName.length())
return E_INVALIDARG;
// see if the file is relative path
if (!PathIsURL(m_FileName) && PathIsRelative(m_FileName)) {
// try appending baseurl if exists
_bstr_t baseURL;
if (S_OK == GetBaseURL(baseURL)) {
TCHAR szCurFile[MAX_PATH];
_tcscpy(szCurFile, m_FileName);
// change any backslashes to slashes
LPTSTR loc = _tcschr(szCurFile,_T('\\'));
while (loc != NULL) {
*loc = _T('/');
loc = _tcschr(szCurFile,_T('\\'));
}
m_FileName = baseURL + _T("/") + szCurFile;
}
else {
TCHAR szCurDir[MAX_PATH];
GetCurrentDirectory(MAX_PATH,szCurDir);
m_FileName=_bstr_t(szCurDir) + _T("\\") + m_FileName;
}
}
}
else
if (V_VT(&xmlSource) == VT_UNKNOWN) {
CComQIPtr<IStream,&IID_IStream> pS(V_UNKNOWN(&xmlSource));
if (!pS)
return E_INVALIDARG;
CComBSTR b;
hr = b.ReadFromStream(pS);
if (S_OK != hr)
return hr;
m_xml = b;
if (0 == m_xml.length())
return E_INVALIDARG;
}
else
if (V_VT(&xmlSource) == VT_DISPATCH) {
CComQIPtr<IXMLDOMDocument,&IID_IXMLDOMDocument> pDoc(V_DISPATCH(&xmlSource));
if (!pDoc)
return E_INVALIDARG;
BSTR b = NULL;
hr = pDoc->get_xml(&b);
if (S_OK != hr)
return hr;
m_xml = b;
::SysFreeString(b);
if (0 == m_xml.length())
return E_INVALIDARG;
}
else
if (V_VT(&xmlSource) == (VT_ARRAY | VT_VARIANT)) {
SAFEARRAY *pArray = reinterpret_cast<SAFEARRAY *> (xmlSource.byref);
if (NULL == pArray)
return E_INVALIDARG;
long lLBoundVar = 0;
long lUBoundVar = 0;
UINT dims = ::SafeArrayGetDim(pArray);
if (dims == 0)
return E_INVALIDARG;
hr = ::SafeArrayGetLBound(pArray, dims, &lLBoundVar);
if (S_OK != hr)
return hr;
hr = ::SafeArrayGetUBound(pArray, dims, &lUBoundVar);
if (S_OK != hr)
return hr;
if (lUBoundVar >= lLBoundVar) {
VARIANT *pIndex = NULL;
hr = ::SafeArrayAccessData(pArray, reinterpret_cast<void **> (&pIndex));
if (S_OK != hr)
return hr;
int length = lUBoundVar-lLBoundVar+2;
BYTE *body = new BYTE[length];
for (long i = 0; i <= lUBoundVar-lLBoundVar; ++i) {
VARIANT var = pIndex[i];
if (V_VT(&var) != VT_UI1) {
hr = E_INVALIDARG;
break;
}
body[i] = V_UI1(&var);
}
body[length-1] = 0;
::SafeArrayUnaccessData(pArray);
if (S_OK != hr) {
delete [] body;
return hr;
}
m_xml = reinterpret_cast<char*> (body);
delete [] body;
if (0 == m_xml.length())
return E_INVALIDARG;
}
}
else
if (V_VT(&xmlSource) == (VT_ARRAY | VT_UI1)) {
SAFEARRAY *pArray = reinterpret_cast<SAFEARRAY *> (xmlSource.byref);
if (NULL == pArray)
return E_INVALIDARG;
long lLBoundVar = 0;
long lUBoundVar = 0;
UINT dims = ::SafeArrayGetDim(pArray);
if (dims == 0)
return E_INVALIDARG;
hr = ::SafeArrayGetLBound(pArray, dims, &lLBoundVar);
if (S_OK != hr)
return hr;
hr = ::SafeArrayGetUBound(pArray, dims, &lUBoundVar);
if (S_OK != hr)
return hr;
if (lUBoundVar >= lLBoundVar) {
BYTE *pIndex = NULL;
hr = ::SafeArrayAccessData(pArray, reinterpret_cast<void **> (&pIndex));
if (S_OK != hr)
return hr;
int length = lUBoundVar-lLBoundVar+2;
BYTE *body = new BYTE[length];
for (long i = 0; i <= lUBoundVar-lLBoundVar; ++i)
body[i] = pIndex[i];
body[length-1] = 0;
::SafeArrayUnaccessData(pArray);
m_xml = reinterpret_cast<char*> (body);
delete [] body;
if (0 == m_xml.length())
return E_INVALIDARG;
}
}
UINT nthreadID = 0;
m_hParseThread = reinterpret_cast<HANDLE> (_beginthreadex(NULL,
0,
CXMLDOMDocument::ParseThread,
(void *) this,
0,
&nthreadID));
if (NULL == m_hParseThread)
return S_OK;
if (m_bAsync) {
*isSuccessful = VARIANT_TRUE;
return S_OK;
}
bool bWait = true;
while (bWait) {
DWORD dwEvt = MsgWaitForMultipleObjects(1,&m_hParseThread,FALSE,INFINITE,QS_ALLINPUT);
switch(dwEvt) {
case WAIT_OBJECT_0:
bWait = false;
break;
case WAIT_OBJECT_0 + 1:
{
MSG msg;
while(::PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE)) {
if (WM_CLOSE == msg.message || WM_QUIT == msg.message) {
bWait = false;
m_bAbort = true;
break;
}
else {
PeekMessage(&msg, NULL, 0, 0, PM_REMOVE);
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
break;
}
default:
m_bAbort = true;
bWait = false;
break;
}
}
if (m_bAbort)
return S_OK;
if (m_bParseError)
return hr;
if(m_Document)
delete m_Document;
m_Document = m_TmpDocument;
m_TmpDocument = 0;
m_url = m_FileName;
*isSuccessful = VARIANT_TRUE;
return hr;
}
static void test_default_client_accessible_object(void)
{
static const WCHAR testW[] = {'t','e','s','t',' ','t',' ','&','j','u','n','k',0};
static const WCHAR shortcutW[] = {'A','l','t','+','t',0};
IAccessible *acc;
IDispatch *disp;
IOleWindow *ow;
IEnumVARIANT *ev;
HWND chld, hwnd, hwnd2;
HRESULT hr;
VARIANT vid, v;
BSTR str;
POINT pt;
RECT rect;
LONG l, left, top, width, height;
ULONG fetched;
hwnd = CreateWindowA("oleacc_test", "test &t &junk", WS_OVERLAPPEDWINDOW,
0, 0, 100, 100, NULL, NULL, NULL, NULL);
ok(hwnd != NULL, "CreateWindow failed\n");
chld = CreateWindowA("static", "message", WS_CHILD | WS_VISIBLE,
0, 0, 50, 50, hwnd, NULL, NULL, NULL);
ok(chld != NULL, "CreateWindow failed\n");
hr = CreateStdAccessibleObject(NULL, OBJID_CLIENT, &IID_IAccessible, (void**)&acc);
ok(hr == E_FAIL, "got %x\n", hr);
hr = CreateStdAccessibleObject(hwnd, OBJID_CLIENT, &IID_IAccessible, (void**)&acc);
ok(hr == S_OK, "got %x\n", hr);
hr = IAccessible_QueryInterface(acc, &IID_IOleWindow, (void**)&ow);
ok(hr == S_OK, "got %x\n", hr);
hr = IOleWindow_GetWindow(ow, &hwnd2);
ok(hr == S_OK, "got %x\n", hr);
ok(hwnd == hwnd2, "hwnd2 = %p, expected %p\n", hwnd2, hwnd);
hr = WindowFromAccessibleObject(acc, &hwnd2);
ok(hr == S_OK, "got %x\n", hr);
ok(hwnd == hwnd2, "hwnd2 = %p, expected %p\n", hwnd2, hwnd);
IOleWindow_Release(ow);
hr = IAccessible_get_accChildCount(acc, &l);
ok(hr == S_OK, "got %x\n", hr);
ok(l == 1, "l = %d\n", l);
V_VT(&vid) = VT_I4;
V_I4(&vid) = CHILDID_SELF;
disp = (void*)0xdeadbeef;
hr = IAccessible_get_accChild(acc, vid, &disp);
ok(hr == E_INVALIDARG, "get_accChild returned %x\n", hr);
ok(disp == NULL, "disp = %p\n", disp);
V_I4(&vid) = 1;
disp = (void*)0xdeadbeef;
hr = IAccessible_get_accChild(acc, vid, &disp);
ok(hr == E_INVALIDARG, "get_accChild returned %x\n", hr);
ok(disp == NULL, "disp = %p\n", disp);
hr = IAccessible_QueryInterface(acc, &IID_IEnumVARIANT, (void**)&ev);
ok(hr == S_OK, "got %x\n", hr);
hr = IEnumVARIANT_Skip(ev, 100);
ok(hr == S_FALSE, "Skip returned %x\n", hr);
V_VT(&v) = VT_I4;
fetched = 1;
hr = IEnumVARIANT_Next(ev, 1, &v, &fetched);
ok(hr == S_FALSE, "got %x\n", hr);
ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
ok(fetched == 0, "fetched = %d\n", fetched);
hr = IEnumVARIANT_Reset(ev);
ok(hr == S_OK, "got %x\n", hr);
V_VT(&v) = VT_I4;
fetched = 2;
hr = IEnumVARIANT_Next(ev, 1, &v, &fetched);
ok(hr == S_OK, "got %x\n", hr);
ok(V_VT(&v) == VT_DISPATCH, "V_VT(&v) = %d\n", V_VT(&v));
IDispatch_Release(V_DISPATCH(&v));
ok(fetched == 1, "fetched = %d\n", fetched);
IEnumVARIANT_Release(ev);
test_AccessibleChildren(acc);
V_VT(&vid) = VT_I4;
V_I4(&vid) = CHILDID_SELF;
hr = IAccessible_get_accName(acc, vid, &str);
ok(hr == S_OK, "got %x\n", hr);
ok(!lstrcmpW(str, testW), "name = %s\n", wine_dbgstr_w(str));
SysFreeString(str);
V_I4(&vid) = 1;
str = (void*)0xdeadbeef;
hr = IAccessible_get_accName(acc, vid, &str);
ok(hr == E_INVALIDARG, "got %x\n", hr);
ok(!str, "str != NULL\n");
V_I4(&vid) = CHILDID_SELF;
str = (void*)0xdeadbeef;
hr = IAccessible_get_accValue(acc, vid, &str);
ok(hr == S_FALSE, "got %x\n", hr);
ok(!str, "str != NULL\n");
str = (void*)0xdeadbeef;
hr = IAccessible_get_accDescription(acc, vid, &str);
ok(hr == S_FALSE, "got %x\n", hr);
ok(!str, "str != NULL\n");
V_VT(&v) = VT_DISPATCH;
V_DISPATCH(&v) = (void*)0xdeadbeef;
hr = IAccessible_get_accRole(acc, vid, &v);
ok(hr == S_OK, "got %x\n", hr);
ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
ok(V_I4(&v) == ROLE_SYSTEM_CLIENT, "V_I4(&v) = %d\n", V_I4(&v));
V_VT(&v) = VT_DISPATCH;
V_DISPATCH(&v) = (void*)0xdeadbeef;
hr = IAccessible_get_accState(acc, vid, &v);
ok(hr == S_OK, "got %x\n", hr);
ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
ok(V_I4(&v) == (STATE_SYSTEM_FOCUSABLE|STATE_SYSTEM_INVISIBLE),
"V_I4(&v) = %x\n", V_I4(&v));
str = (void*)0xdeadbeef;
hr = IAccessible_get_accHelp(acc, vid, &str);
ok(hr == S_FALSE, "got %x\n", hr);
ok(!str, "str != NULL\n");
hr = IAccessible_get_accKeyboardShortcut(acc, vid, &str);
ok(hr == S_OK, "got %x\n", hr);
ok(!lstrcmpW(str, shortcutW), "str = %s\n", wine_dbgstr_w(str));
SysFreeString(str);
str = (void*)0xdeadbeef;
hr = IAccessible_get_accDefaultAction(acc, vid, &str);
ok(hr == S_FALSE, "got %x\n", hr);
ok(!str, "str != NULL\n");
pt.x = pt.y = 60;
ok(ClientToScreen(hwnd, &pt), "ClientToScreen failed\n");
hr = IAccessible_accHitTest(acc, pt.x, pt.y, &v);
ok(hr == S_OK, "got %x\n", hr);
ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
ok(V_I4(&v) == 0, "V_I4(&v) = %d\n", V_I4(&v));
pt.x = pt.y = 25;
ok(ClientToScreen(hwnd, &pt), "ClientToScreen failed\n");
hr = IAccessible_accHitTest(acc, pt.x, pt.y, &v);
ok(hr == S_OK, "got %x\n", hr);
ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
ok(V_I4(&v) == 0, "V_I4(&v) = %d\n", V_I4(&v));
ShowWindow(hwnd, TRUE);
pt.x = pt.y = 60;
ok(ClientToScreen(hwnd, &pt), "ClientToScreen failed\n");
hr = IAccessible_accHitTest(acc, pt.x, pt.y, &v);
ok(hr == S_OK, "got %x\n", hr);
ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
ok(V_I4(&v) == 0, "V_I4(&v) = %d\n", V_I4(&v));
pt.x = pt.y = 25;
ok(ClientToScreen(hwnd, &pt), "ClientToScreen failed\n");
hr = IAccessible_accHitTest(acc, pt.x, pt.y, &v);
ok(hr == S_OK, "got %x\n", hr);
ok(V_VT(&v) == VT_DISPATCH, "V_VT(&v) = %d\n", V_VT(&v));
ok(V_DISPATCH(&v) != NULL, "V_DISPATCH(&v) = %p\n", V_DISPATCH(&v));
VariantClear(&v);
ShowWindow(chld, FALSE);
pt.x = pt.y = 25;
ok(ClientToScreen(hwnd, &pt), "ClientToScreen failed\n");
hr = IAccessible_accHitTest(acc, pt.x, pt.y, &v);
ok(hr == S_OK, "got %x\n", hr);
ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
ok(V_I4(&v) == 0, "V_I4(&v) = %d\n", V_I4(&v));
hr = IAccessible_get_accParent(acc, &disp);
ok(hr == S_OK, "got %x\n", hr);
ok(disp != NULL, "disp == NULL\n");
IDispatch_Release(disp);
ok(GetClientRect(hwnd, &rect), "GetClientRect failed\n");
pt.x = rect.left;
pt.y = rect.top;
MapWindowPoints(hwnd, NULL, &pt, 1);
rect.left = pt.x;
rect.top = pt.y;
pt.x = rect.right;
pt.y = rect.bottom;
MapWindowPoints(hwnd, NULL, &pt, 1);
hr = IAccessible_accLocation(acc, &left, &top, &width, &height, vid);
ok(hr == S_OK, "got %x\n", hr);
ok(left == rect.left, "left = %d, expected %d\n", left, rect.left);
ok(top == rect.top, "top = %d, expected %d\n", top, rect.top);
ok(width == pt.x-rect.left, "width = %d, expected %d\n", width, pt.x-rect.left);
ok(height == pt.y-rect.top, "height = %d, expected %d\n", height, pt.y-rect.top);
DestroyWindow(hwnd);
hr = IAccessible_get_accChildCount(acc, &l);
ok(hr == S_OK, "got %x\n", hr);
ok(l == 0, "l = %d\n", l);
hr = IAccessible_get_accName(acc, vid, &str);
ok(hr == E_INVALIDARG, "got %x\n", hr);
hr = IAccessible_get_accValue(acc, vid, &str);
ok(hr == S_FALSE, "got %x\n", hr);
hr = IAccessible_get_accRole(acc, vid, &v);
ok(hr == S_OK, "got %x\n", hr);
ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
ok(V_I4(&v) == ROLE_SYSTEM_CLIENT, "V_I4(&v) = %d\n", V_I4(&v));
hr = IAccessible_get_accState(acc, vid, &v);
ok(hr == S_OK, "got %x\n", hr);
ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
ok(V_I4(&v) == STATE_SYSTEM_INVISIBLE, "V_I4(&v) = %x\n", V_I4(&v));
hr = IAccessible_accHitTest(acc, 200, 200, &v);
ok(hr == S_OK, "got %x\n", hr);
ok(V_VT(&v) == VT_I4, "V_VT(&v) = %d\n", V_VT(&v));
ok(V_I4(&v) == 0, "V_I4(&v) = %d\n", V_I4(&v));
disp = (void*)0xdeadbeef;
hr = IAccessible_get_accParent(acc, &disp);
ok(hr == E_FAIL, "got %x\n", hr);
ok(disp == NULL, "disp = %p\n", disp);
hr = IAccessible_accLocation(acc, &left, &top, &width, &height, vid);
ok(hr == S_OK, "got %x\n", hr);
ok(left == 0, "left = %d\n", left);
ok(top == 0, "top = %d\n", top);
ok(width == 0, "width = %d\n", width);
ok(height == 0, "height = %d\n", height);
IAccessible_Release(acc);
}
static HRESULT WINAPI Global_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
{
switch(id) {
case DISPID_GLOBAL_OK: {
VARIANT *b;
ok(wFlags == INVOKE_FUNC || wFlags == (INVOKE_FUNC|INVOKE_PROPERTYGET), "wFlags = %x\n", wFlags);
ok(pdp != NULL, "pdp == NULL\n");
ok(pdp->rgvarg != NULL, "rgvarg == NULL\n");
ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
ok(pdp->cArgs == 2, "cArgs = %d\n", pdp->cArgs);
ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
if(wFlags & INVOKE_PROPERTYGET)
ok(pvarRes != NULL, "pvarRes == NULL\n");
else
ok(!pvarRes, "pvarRes != NULL\n");
ok(pei != NULL, "pei == NULL\n");
ok(V_VT(pdp->rgvarg) == VT_BSTR, "V_VT(psp->rgvargs) = %d\n", V_VT(pdp->rgvarg));
b = pdp->rgvarg+1;
if(V_VT(b) == (VT_BYREF|VT_VARIANT))
b = V_BYREF(b);
ok(V_VT(b) == VT_BOOL, "V_VT(b) = %d\n", V_VT(b));
ok(V_BOOL(b), "%s: %s\n", test_name, wine_dbgstr_w(V_BSTR(pdp->rgvarg)));
return S_OK;
}
case DISPID_GLOBAL_TRACE:
ok(wFlags == INVOKE_FUNC, "wFlags = %x\n", wFlags);
ok(pdp != NULL, "pdp == NULL\n");
ok(pdp->rgvarg != NULL, "rgvarg == NULL\n");
ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
ok(pdp->cArgs == 1, "cArgs = %d\n", pdp->cArgs);
ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
ok(!pvarRes, "pvarRes != NULL\n");
ok(pei != NULL, "pei == NULL\n");
ok(V_VT(pdp->rgvarg) == VT_BSTR, "V_VT(psp->rgvargs) = %d\n", V_VT(pdp->rgvarg));
if(V_VT(pdp->rgvarg) == VT_BSTR)
trace("%s: %s\n", test_name, wine_dbgstr_w(V_BSTR(pdp->rgvarg)));
return S_OK;
case DISPID_GLOBAL_REPORTSUCCESS:
CHECK_EXPECT(global_success_i);
ok(wFlags == INVOKE_FUNC, "wFlags = %x\n", wFlags);
ok(pdp != NULL, "pdp == NULL\n");
ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
ok(pdp->cArgs == 0, "cArgs = %d\n", pdp->cArgs);
ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
ok(!pvarRes, "pvarRes != NULL\n");
ok(pei != NULL, "pei == NULL\n");
return S_OK;
case DISPID_GLOBAL_GETVT:
ok(pdp != NULL, "pdp == NULL\n");
ok(pdp->rgvarg != NULL, "rgvarg == NULL\n");
ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
ok(pdp->cArgs == 1, "cArgs = %d\n", pdp->cArgs);
ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
ok(pvarRes != NULL, "pvarRes == NULL\n");
ok(V_VT(pvarRes) == VT_EMPTY, "V_VT(pvarRes) = %d\n", V_VT(pvarRes));
ok(pei != NULL, "pei == NULL\n");
V_VT(pvarRes) = VT_BSTR;
V_BSTR(pvarRes) = a2bstr(vt2a(pdp->rgvarg));
return S_OK;
case DISPID_GLOBAL_ISENGLANG:
ok(wFlags == (INVOKE_FUNC|INVOKE_PROPERTYGET), "wFlags = %x\n", wFlags);
ok(pdp != NULL, "pdp == NULL\n");
ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
ok(pdp->cArgs == 0, "cArgs = %d\n", pdp->cArgs);
ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
ok(pvarRes != NULL, "pvarRes == NULL\n");
ok(pei != NULL, "pei == NULL\n");
V_VT(pvarRes) = VT_BOOL;
if(is_lang_english()) {
V_BOOL(pvarRes) = VARIANT_TRUE;
}else {
skip("Skipping some tests in non-English UIs\n");
V_BOOL(pvarRes) = VARIANT_FALSE;
}
return S_OK;
case DISPID_GLOBAL_VBVAR:
CHECK_EXPECT(global_vbvar_i);
ok(wFlags == DISPATCH_PROPERTYPUT, "wFlags = %x\n", wFlags);
ok(pdp != NULL, "pdp == NULL\n");
ok(pdp->rgvarg != NULL, "rgvarg == NULL\n");
ok(pdp->rgdispidNamedArgs != NULL, "rgdispidNamedArgs == NULL\n");
ok(pdp->cArgs == 1, "cArgs = %d\n", pdp->cArgs);
ok(pdp->cNamedArgs == 1, "cNamedArgs = %d\n", pdp->cNamedArgs);
ok(pdp->rgdispidNamedArgs[0] == DISPID_PROPERTYPUT, "pdp->rgdispidNamedArgs[0] = %d\n", pdp->rgdispidNamedArgs[0]);
ok(!pvarRes, "pvarRes != NULL\n");
ok(pei != NULL, "pei == NULL\n");
ok(V_VT(pdp->rgvarg) == VT_I2, "V_VT(psp->rgvargs) = %d\n", V_VT(pdp->rgvarg));
ok(V_I2(pdp->rgvarg) == 3, "V_I2(psp->rgvargs) = %d\n", V_I2(pdp->rgvarg));
return S_OK;
case DISPID_GLOBAL_TESTOBJ:
ok(wFlags == (DISPATCH_PROPERTYGET|DISPATCH_METHOD), "wFlags = %x\n", wFlags);
ok(pdp != NULL, "pdp == NULL\n");
ok(!pdp->rgvarg, "rgvarg == NULL\n");
ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
ok(!pdp->cArgs, "cArgs = %d\n", pdp->cArgs);
ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
ok(pvarRes != NULL, "pvarRes == NULL\n");
ok(pei != NULL, "pei == NULL\n");
V_VT(pvarRes) = VT_DISPATCH;
V_DISPATCH(pvarRes) = (IDispatch*)&testObj;
return S_OK;
case DISPID_GLOBAL_ISNULLDISP: {
VARIANT *v;
ok(wFlags == (INVOKE_FUNC|INVOKE_PROPERTYGET), "wFlags = %x\n", wFlags);
ok(pdp != NULL, "pdp == NULL\n");
ok(pdp->rgvarg != NULL, "rgvarg == NULL\n");
ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
ok(pdp->cArgs == 1, "cArgs = %d\n", pdp->cArgs);
ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
ok(pvarRes != NULL, "pvarRes == NULL\n");
ok(pei != NULL, "pei == NULL\n");
v = pdp->rgvarg;
if(V_VT(v) == (VT_VARIANT|VT_BYREF))
v = V_VARIANTREF(v);
ok(V_VT(v) == VT_DISPATCH, "V_VT(psp->rgvargs) = %d\n", V_VT(pdp->rgvarg));
V_VT(pvarRes) = VT_BOOL;
V_BOOL(pvarRes) = V_DISPATCH(v) ? VARIANT_FALSE : VARIANT_TRUE;
return S_OK;
}
case DISPID_GLOBAL_TESTDISP:
ok(wFlags == INVOKE_FUNC, "wFlags = %x\n", wFlags);
ok(pdp != NULL, "pdp == NULL\n");
ok(pdp->rgvarg != NULL, "rgvarg == NULL\n");
ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
ok(pdp->cArgs == 1, "cArgs = %d\n", pdp->cArgs);
ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
ok(!pvarRes, "pvarRes != NULL\n");
ok(pei != NULL, "pei == NULL\n");
ok(V_VT(pdp->rgvarg) == VT_DISPATCH, "V_VT(psp->rgvargs) = %d\n", V_VT(pdp->rgvarg));
test_disp(V_DISPATCH(pdp->rgvarg));
return S_OK;
}
ok(0, "unexpected call %d\n", id);
return DISP_E_MEMBERNOTFOUND;
}
int main(int argc, char* argv[])
{
HRESULT hr;
IADsContainer *pCont=NULL;
CoInitialize(NULL);
///////////////////////////////////
// Bind to the object
/////////////////////////////////
hr = ADsGetObject(L"WinNT://INDEPENDENCE", IID_IADsContainer, (void**) &pCont );
if ( !SUCCEEDED(hr) )
{
return hr;
}
///////////////////////////////////
// Build variant filter
/////////////////////////////////
LPWSTR pszFilter[] = { L"user", L"group" };
DWORD dwNumber = sizeof( pszFilter ) /sizeof(LPWSTR);
VARIANT var;
hr = ADsBuildVarArrayStr( pszFilter, dwNumber, &var );
if ( !SUCCEEDED(hr) )
{
pCont->Release();
return hr;
}
///////////////////////////////////
// Set the filter
/////////////////////////////////
hr = pCont->put_Filter(var);
VariantClear(&var);
if (!SUCCEEDED(hr) )
{
pCont->Release();
return hr;
}
////////////////////////////////////////////
// Enumerate the result
///////////////////////////////////////////////
IEnumVARIANT *pEnum = NULL;
hr = ADsBuildEnumerator( pCont, &pEnum );
pCont->Release(); // no longer needed, since we have the enumerator already
if ( SUCCEEDED(hr) )
{
VARIANT var;
ULONG lFetch;
IADs *pChild=NULL;
VariantInit(&var);
while( SUCCEEDED(ADsEnumerateNext( pEnum, 1, &var, &lFetch )) && lFetch == 1 )
{
hr = V_DISPATCH(&var)->QueryInterface( IID_IADs, (void**) &pChild );
if ( SUCCEEDED(hr) )
{
BSTR bstrName;
BSTR bstrClass;
// Get more information on the child classes
pChild->get_Name(&bstrName);
pChild->get_Class(&bstrClass);
printf("%S\t\t(%S)\n", bstrName, bstrClass );
// Clean-up
SysFreeString(bstrName);
SysFreeString(bstrClass);
pChild->Release();
}
VariantClear(&var);
}
}
if ( pEnum )
{
ADsFreeEnumerator( pEnum );
}
CoUninitialize();
return 0;
}
static void call_event_handlers(HTMLDocumentNode *doc, HTMLEventObj *event_obj, event_target_t *event_target,
ConnectionPointContainer *cp_container, eventid_t eid, IDispatch *this_obj)
{
const BOOL cancelable = event_info[eid].flags & EVENT_CANCELABLE;
handler_vector_t *handler_vector = NULL;
VARIANT v;
HRESULT hres;
if(event_target)
handler_vector = event_target->event_table[eid];
if(handler_vector && handler_vector->handler_prop) {
DISPID named_arg = DISPID_THIS;
VARIANTARG arg;
DISPPARAMS dp = {&arg, &named_arg, 1, 1};
V_VT(&arg) = VT_DISPATCH;
V_DISPATCH(&arg) = this_obj;
V_VT(&v) = VT_EMPTY;
TRACE("%s >>>\n", debugstr_w(event_info[eid].name));
hres = call_disp_func(handler_vector->handler_prop, &dp, &v);
if(hres == S_OK) {
TRACE("%s <<< %s\n", debugstr_w(event_info[eid].name), debugstr_variant(&v));
if(cancelable) {
if(V_VT(&v) == VT_BOOL) {
if(!V_BOOL(&v))
event_obj->prevent_default = TRUE;
}else if(V_VT(&v) != VT_EMPTY) {
FIXME("unhandled result %s\n", debugstr_variant(&v));
}
}
VariantClear(&v);
}else {
WARN("%s <<< %08x\n", debugstr_w(event_info[eid].name), hres);
}
}
if(handler_vector && handler_vector->handler_cnt) {
VARIANTARG arg;
DISPPARAMS dp = {&arg, NULL, 1, 0};
int i;
V_VT(&arg) = VT_DISPATCH;
V_DISPATCH(&arg) = (IDispatch*)event_obj;
i = handler_vector->handler_cnt;
while(i--) {
if(handler_vector->handlers[i]) {
V_VT(&v) = VT_EMPTY;
TRACE("%s [%d] >>>\n", debugstr_w(event_info[eid].name), i);
hres = call_disp_func(handler_vector->handlers[i], &dp, &v);
if(hres == S_OK) {
TRACE("%s [%d] <<<\n", debugstr_w(event_info[eid].name), i);
if(cancelable) {
if(V_VT(&v) == VT_BOOL) {
if(!V_BOOL(&v))
event_obj->prevent_default = TRUE;
}else if(V_VT(&v) != VT_EMPTY) {
FIXME("unhandled result %s\n", debugstr_variant(&v));
}
}
VariantClear(&v);
}else {
WARN("%s [%d] <<< %08x\n", debugstr_w(event_info[eid].name), i, hres);
}
}
}
}
/*
* NOTE: CP events may require doc_obj reference, which we don't own. We make sure that
* it's safe to call event handler by checking nsevent_listener, which is NULL for
* detached documents.
*/
if(cp_container && cp_container->forward_container)
cp_container = cp_container->forward_container;
if(cp_container && cp_container->cps && doc->nsevent_listener) {
ConnectionPoint *cp;
unsigned i, j;
for(j=0; cp_container->cp_entries[j].riid; j++) {
cp = cp_container->cps + j;
if(!cp->sinks_size || !is_cp_event(cp->data, event_info[eid].dispid))
continue;
for(i=0; doc->nsevent_listener && i < cp->sinks_size; i++) {
if(!cp->sinks[i].disp)
continue;
V_VT(&v) = VT_EMPTY;
TRACE("cp %s [%u] >>>\n", debugstr_w(event_info[eid].name), i);
hres = call_cp_func(cp->sinks[i].disp, event_info[eid].dispid,
cp->data->pass_event_arg ? event_obj : NULL, &v);
if(hres == S_OK) {
TRACE("cp %s [%u] <<<\n", debugstr_w(event_info[eid].name), i);
if(cancelable) {
if(V_VT(&v) == VT_BOOL) {
if(!V_BOOL(&v))
event_obj->prevent_default = TRUE;
}else if(V_VT(&v) != VT_EMPTY) {
FIXME("unhandled result %s\n", debugstr_variant(&v));
}
}
VariantClear(&v);
}else {
WARN("cp %s [%u] <<< %08x\n", debugstr_w(event_info[eid].name), i, hres);
}
}
if(!doc->nsevent_listener)
break;
}
}
}
bool
variant_as_string( DEBUGHELPER *pH, const VARIANT &var, std::string *ret )
{
if (var.vt & VT_VECTOR) return false;
if (var.vt & VT_RESERVED) return false;
if (var.vt & VT_ARRAY)
return safearray_as_string( pH, reinterpret_cast<DWORDLONG>(var.parray), ret);
if (var.vt & VT_BYREF)
{
// Construct a fake variant with the byref-value in it.
VARTYPE vt = var.vt & ~VT_BYREF;
long size = vartype_len(vt);
VARIANT var2;
var2.vt = vt;
long source=reinterpret_cast<long>(var.byref);
void *dest;
if( vt == VT_VARIANT)
dest = &var2;
else
{
var2.vt=vt;
dest = &(var2.bVal);
}
if(!ReadMem(pH,source, size, dest)) return false;
std::string retval;
if( ! variant_as_string( pH, var2, &retval)) return false;
retval += "]";
*ret = "[" + retval;
return true;
}
std::ostringstream os;
switch (var.vt & VT_TYPEMASK )
{
case VT_I2: os << V_I2(&var); break;
case VT_I4: os << V_I4(&var); break;
//case VT_I8: os << V_I8(&var); break;
case VT_R4: os << V_R4(&var); break;
case VT_R8: os << V_R8(&var); break;
case VT_UNKNOWN:
case VT_DISPATCH: os << "0x" << std::hex << (long )V_DISPATCH(&var); break;
case VT_BOOL: os << (V_BOOL(&var)==VARIANT_FALSE?"False":"True"); break;
case VT_I1: os << "'" << V_I1(&var) << "'" ; break;
case VT_UI1: os << "'" << V_UI1(&var) << "'" ; break;
case VT_UI2: os << V_UI2(&var); break;
case VT_UI4: os << V_UI4(&var); break;
case VT_INT: os << V_INT(&var); break;
case VT_UINT: os << V_UINT(&var); break;
case VT_ERROR: os << "error"; break;
case VT_CY: os << (((double)(V_CY(&var).int64))/10000.); break;
case VT_DATE: return date_as_string(V_DATE(&var), ret); break;
case VT_BSTR:
{
long pBSTR = reinterpret_cast<long>( V_BSTR(&var) );
// if (!ReadMem(pH, reinterpret_cast<DWORDLONG>( V_BSTR(&var) ), &pBSTR)) return false;
std::string ret;
if (!bstr_as_string( pH, pBSTR , &ret )) return false;
os << ret;
}break;
case VT_EMPTY: os << '@'; break;
case VT_NULL: os << "null"; break;
break;
default:
return false;
}
*ret = os.str();
return true;
}
