zend_object_iterator *php_com_saproxy_iter_get(zend_class_entry *ce, zval *object, int by_ref) { php_com_saproxy *proxy = SA_FETCH(object); php_com_saproxy_iter *I; int i; if (by_ref) { zend_throw_error(NULL, "An iterator cannot be used with foreach by reference"); return NULL; } I = ecalloc(1, sizeof(*I)); I->iter.funcs = &saproxy_iter_funcs; Z_PTR(I->iter.data) = I; I->proxy = proxy; ZVAL_COPY(&I->proxy_obj, object); I->indices = safe_emalloc(proxy->dimensions + 1, sizeof(LONG), 0); for (i = 0; i < proxy->dimensions; i++) { convert_to_long(&proxy->indices[i]); I->indices[i] = (LONG)Z_LVAL(proxy->indices[i]); } SafeArrayGetLBound(V_ARRAY(&proxy->obj->v), proxy->dimensions, &I->imin); SafeArrayGetUBound(V_ARRAY(&proxy->obj->v), proxy->dimensions, &I->imax); I->key = I->imin; return &I->iter; }
HRESULT navigate_url(DocHost *This, LPCWSTR url, const VARIANT *Flags, const VARIANT *TargetFrameName, VARIANT *PostData, VARIANT *Headers) { PBYTE post_data = NULL; ULONG post_data_len = 0; LPWSTR headers = NULL; HRESULT hres = S_OK; TRACE("navigating to %s\n", debugstr_w(url)); if((Flags && V_VT(Flags) != VT_EMPTY) || (TargetFrameName && V_VT(TargetFrameName) != VT_EMPTY)) FIXME("Unsupported args (Flags %p:%d; TargetFrameName %p:%d)\n", Flags, Flags ? V_VT(Flags) : -1, TargetFrameName, TargetFrameName ? V_VT(TargetFrameName) : -1); if(PostData && V_VT(PostData) == (VT_ARRAY | VT_UI1) && V_ARRAY(PostData)) { SafeArrayAccessData(V_ARRAY(PostData), (void**)&post_data); post_data_len = V_ARRAY(PostData)->rgsabound[0].cElements; } if(Headers && V_VT(Headers) == VT_BSTR) { headers = V_BSTR(Headers); TRACE("Headers: %s\n", debugstr_w(headers)); } set_doc_state(This, READYSTATE_LOADING); This->ready_state = READYSTATE_LOADING; if(This->doc_navigate) { WCHAR new_url[INTERNET_MAX_URL_LENGTH]; if(PathIsURLW(url)) { new_url[0] = 0; }else { DWORD size; size = sizeof(new_url)/sizeof(WCHAR); hres = UrlApplySchemeW(url, new_url, &size, URL_APPLY_GUESSSCHEME); if(FAILED(hres)) { WARN("UrlApplyScheme failed: %08x\n", hres); new_url[0] = 0; } } hres = async_doc_navigate(This, *new_url ? new_url : url, headers, post_data, post_data_len, TRUE); }else { task_navigate_bsc_t *task; task = heap_alloc(sizeof(*task)); task->bsc = create_callback(This, url, post_data, post_data_len, headers); push_dochost_task(This, &task->header, navigate_bsc_proc, This->url == NULL); } if(post_data) SafeArrayUnaccessData(V_ARRAY(PostData)); return hres; }
HRESULT GetLPBYTEtoOctetString(VARIANT * pVar, LPBYTE * ppByte) { HRESULT hr = E_FAIL; void HUGEP *pArray; long lLBound, lUBound, cElements; if ((!pVar) || (!ppByte)) return E_INVALIDARG; if ((pVar->n1.n2.vt) != (VT_UI1 | VT_ARRAY)) return E_INVALIDARG; hr = SafeArrayGetLBound(V_ARRAY(pVar), 1, &lLBound); hr = SafeArrayGetUBound(V_ARRAY(pVar), 1, &lUBound); cElements = lUBound - lLBound + 1; hr = SafeArrayAccessData(V_ARRAY(pVar), &pArray); if (SUCCEEDED(hr)) { LPBYTE pTemp = (LPBYTE) pArray; *ppByte = (LPBYTE) CoTaskMemAlloc(cElements); if (*ppByte) memcpy(*ppByte, pTemp, cElements); else hr = E_OUTOFMEMORY; } SafeArrayUnaccessData(V_ARRAY(pVar)); return hr; }
//Function for handling Octet Strings returned by variants //It allocates memory for data, copies the data to the buffer, and returns a pointer to the buffer. //Caller must free the buffer with CoTaskMemFree. HRESULT GetLPBYTEtoOctetString(VARIANT *pVar, //IN. Pointer to variant containing the octetstring. LPBYTE *ppByte //OUT. Return LPBYTE to the data represented in octetstring. ) { HRESULT hr = E_FAIL; //Check args if ((!pVar)||(!ppByte)) return E_INVALIDARG; //Check the variant type for unsigned char array (octet string). if ((pVar->vt)!=(VT_UI1|VT_ARRAY)) return E_INVALIDARG; void HUGEP *pArray; long lLBound, lUBound; hr = SafeArrayGetLBound(V_ARRAY(pVar), 1, &lLBound); hr = SafeArrayGetUBound(V_ARRAY(pVar), 1, &lUBound); //Get the count of elements long cElements = lUBound-lLBound + 1; hr = SafeArrayAccessData( V_ARRAY(pVar), &pArray ); if (SUCCEEDED(hr)) { LPBYTE pTemp = (LPBYTE)pArray; *ppByte = (LPBYTE) CoTaskMemAlloc(cElements); if (*ppByte) memcpy(*ppByte, pTemp, cElements); else hr = E_OUTOFMEMORY; } SafeArrayUnaccessData( V_ARRAY(pVar) ); return hr; }
static void com_write_dimension(zval *object, zval *offset, zval *value) { php_com_dotnet_object *obj; zval args[2]; VARIANT v; HRESULT res; obj = CDNO_FETCH(object); if (V_VT(&obj->v) == VT_DISPATCH) { ZVAL_COPY_VALUE(&args[0], offset); ZVAL_COPY_VALUE(&args[1], value); VariantInit(&v); if (SUCCESS == php_com_do_invoke_by_id(obj, DISPID_VALUE, DISPATCH_METHOD|DISPATCH_PROPERTYPUT, &v, 2, args, 0, 0)) { VariantClear(&v); } } else if (V_ISARRAY(&obj->v)) { LONG indices = 0; VARTYPE vt; if (SafeArrayGetDim(V_ARRAY(&obj->v)) == 1) { if (FAILED(SafeArrayGetVartype(V_ARRAY(&obj->v), &vt)) || vt == VT_EMPTY) { vt = V_VT(&obj->v) & ~VT_ARRAY; } convert_to_long(offset); indices = (LONG)Z_LVAL_P(offset); VariantInit(&v); php_com_variant_from_zval(&v, value, obj->code_page); if (V_VT(&v) != vt) { VariantChangeType(&v, &v, 0, vt); } if (vt == VT_VARIANT) { res = SafeArrayPutElement(V_ARRAY(&obj->v), &indices, &v); } else { res = SafeArrayPutElement(V_ARRAY(&obj->v), &indices, &v.lVal); } VariantClear(&v); if (FAILED(res)) { php_com_throw_exception(res, NULL); } } else { php_com_throw_exception(DISP_E_BADINDEX, "this variant has multiple dimensions; you can't set a new value without specifying *all* dimensions"); } } else { php_com_throw_exception(E_INVALIDARG, "this variant is not an array type"); } }
unsigned vtSize(VARIANT &vt) { if (V_VT(&vt) != (VT_ARRAY | VT_UI1)) return 0; long lb,ub; if (FAILED(SafeArrayGetLBound(V_ARRAY(&vt),1,&lb)) || FAILED(SafeArrayGetUBound(V_ARRAY(&vt),1,&ub))) return 0; return ub - lb + 1; }
static HRESULT WINAPI DEVENUM_IPropertyBag_Write( LPPROPERTYBAG iface, LPCOLESTR pszPropName, VARIANT* pVar) { RegPropBagImpl *This = impl_from_IPropertyBag(iface); LPVOID lpData = NULL; DWORD cbData = 0; DWORD dwType = 0; HRESULT res = S_OK; TRACE("(%p)->(%s, %p)\n", This, debugstr_w(pszPropName), pVar); switch (V_VT(pVar)) { case VT_BSTR: case VT_LPWSTR: TRACE("writing %s\n", debugstr_w(V_BSTR(pVar))); lpData = V_BSTR(pVar); dwType = REG_SZ; cbData = (lstrlenW(V_BSTR(pVar)) + 1) * sizeof(WCHAR); break; case VT_I4: case VT_UI4: TRACE("writing %u\n", V_UI4(pVar)); lpData = &V_UI4(pVar); dwType = REG_DWORD; cbData = sizeof(DWORD); break; case VT_ARRAY | VT_UI1: { LONG lUbound = 0; LONG lLbound = 0; dwType = REG_BINARY; res = SafeArrayGetLBound(V_ARRAY(pVar), 1, &lLbound); res = SafeArrayGetUBound(V_ARRAY(pVar), 1, &lUbound); cbData = (lUbound - lLbound + 1) /* * sizeof(BYTE)*/; TRACE("cbData: %d\n", cbData); res = SafeArrayAccessData(V_ARRAY(pVar), &lpData); break; } default: FIXME("Variant type %d not handled\n", V_VT(pVar)); return E_FAIL; } if (RegSetValueExW(This->hkey, pszPropName, 0, dwType, lpData, cbData) != ERROR_SUCCESS) res = E_FAIL; if (V_VT(pVar) & VT_ARRAY) res = SafeArrayUnaccessData(V_ARRAY(pVar)); return res; }
void vtCopy(VARIANT& vt,void *dest) { unsigned sz = vtSize(vt); if (sz > 0) { void *vp; if (SUCCEEDED(SafeArrayAccessData(V_ARRAY(&vt),&vp))) { memcpy(dest,vp,sz); SafeArrayUnaccessData(V_ARRAY(&vt)); } } }
static HRESULT WINAPI WebBrowser_Navigate2(IWebBrowser2 *iface, VARIANT *URL, VARIANT *Flags, VARIANT *TargetFrameName, VARIANT *PostData, VARIANT *Headers) { WebBrowser *This = WEBBROWSER_THIS(iface); PBYTE post_data = NULL; ULONG post_data_len = 0; LPWSTR headers = NULL; HRESULT hres; TRACE("(%p)->(%p %p %p %p %p)\n", This, URL, Flags, TargetFrameName, PostData, Headers); if(!This->client) return E_FAIL; if((Flags && V_VT(Flags) != VT_EMPTY) || (TargetFrameName && V_VT(TargetFrameName) != VT_EMPTY)) FIXME("Unsupported arguments\n"); if(!URL) return S_OK; if(V_VT(URL) != VT_BSTR) return E_INVALIDARG; if(PostData && V_VT(PostData) != VT_EMPTY) { if(V_VT(PostData) != (VT_ARRAY | VT_UI1) || V_ARRAY(PostData)->cDims != 1) { WARN("Invalid PostData\n"); return E_INVALIDARG; } SafeArrayAccessData(V_ARRAY(PostData), (void**)&post_data); post_data_len = V_ARRAY(PostData)->rgsabound[0].cElements; } if(Headers && V_VT(Headers) != VT_EMPTY) { if(V_VT(Headers) != VT_BSTR) return E_INVALIDARG; headers = V_BSTR(Headers); TRACE("Headers: %s\n", debugstr_w(headers)); } hres = navigate_url(&This->doc_host, V_BSTR(URL), post_data, post_data_len, headers); if(post_data) SafeArrayUnaccessData(V_ARRAY(PostData)); return hres; }
/* * call-seq: * WIN32OLE_VARIANT.array(ary, vt) * * Returns Ruby object wrapping OLE variant whose variant type is VT_ARRAY. * The first argument should be Array object which specifies dimensions * and each size of dimensions of OLE array. * The second argument specifies variant type of the element of OLE array. * * The following create 2 dimensions OLE array. The first dimensions size * is 3, and the second is 4. * * ole_ary = WIN32OLE_VARIANT.array([3,4], VT_I4) * ruby_ary = ole_ary.value # => [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]] * */ static VALUE folevariant_s_array(VALUE klass, VALUE elems, VALUE vvt) { VALUE obj = Qnil; VARTYPE vt; struct olevariantdata *pvar; SAFEARRAYBOUND *psab = NULL; SAFEARRAY *psa = NULL; UINT dim = 0; UINT i = 0; ole_initialize(); vt = RB_NUM2UINT(vvt); vt = (vt | VT_ARRAY); Check_Type(elems, T_ARRAY); obj = folevariant_s_allocate(klass); TypedData_Get_Struct(obj, struct olevariantdata, &olevariant_datatype, pvar); dim = RARRAY_LEN(elems); psab = ALLOC_N(SAFEARRAYBOUND, dim); if(!psab) { rb_raise(rb_eRuntimeError, "memory allocation error"); } for (i = 0; i < dim; i++) { psab[i].cElements = RB_FIX2INT(rb_ary_entry(elems, i)); psab[i].lLbound = 0; } psa = SafeArrayCreate((VARTYPE)(vt & VT_TYPEMASK), dim, psab); if (psa == NULL) { if (psab) free(psab); rb_raise(rb_eRuntimeError, "memory allocation error(SafeArrayCreate)"); } V_VT(&(pvar->var)) = vt; if (vt & VT_BYREF) { V_VT(&(pvar->realvar)) = (vt & ~VT_BYREF); V_ARRAY(&(pvar->realvar)) = psa; V_ARRAYREF(&(pvar->var)) = &(V_ARRAY(&(pvar->realvar))); } else { V_ARRAY(&(pvar->var)) = psa; } if (psab) free(psab); return obj; }
static int saproxy_count_elements(zend_object *object, zend_long *count) { php_com_saproxy *proxy = (php_com_saproxy*) object; LONG ubound, lbound; if (!V_ISARRAY(&proxy->obj->v)) { return FAILURE; } SafeArrayGetLBound(V_ARRAY(&proxy->obj->v), proxy->dimensions, &lbound); SafeArrayGetUBound(V_ARRAY(&proxy->obj->v), proxy->dimensions, &ubound); *count = ubound - lbound + 1; return SUCCESS; }
STDMETHODIMP CComDigiDocLib::getSupportedFormats(VARIANT *ret) { const char** pArr = ::getSupportedFormats(); unsigned int nElems = 0; SAFEARRAY* pSArr; BSTR HUGEP* pData; // detect number of elements for(; *pArr != NULL; pArr++, nElems++); // initialize SAFEARRAY pSArr = SafeArrayCreateVector(VT_BSTR, 0, nElems); if (pSArr == NULL) { return E_OUTOFMEMORY; } // init variant V_ARRAY(ret) = pSArr; V_VT(ret) = (VT_ARRAY | VT_BSTR); // copy data to variant pArr = ::getSupportedFormats(); SafeArrayAccessData(pSArr, (void HUGEP**)&pData); long lArr[1]; USES_CONVERSION; ddocDebug(1, "getSupportedFormats", "num formats: %d", nElems); for(lArr[0] = 0; lArr[0] < (long)nElems; lArr[0]++) { ddocDebug(1, "getSupportedFormats", "format: %d - %s", lArr[0], pArr[lArr[0]]); pData[lArr[0]] = SysAllocString(A2OLE(pArr[lArr[0]])); } SafeArrayUnaccessData(pSArr); return S_OK; }
static zval *com_read_dimension(zval *object, zval *offset, int type, zval *rv) { php_com_dotnet_object *obj; VARIANT v; ZVAL_NULL(rv); obj = CDNO_FETCH(object); if (V_VT(&obj->v) == VT_DISPATCH) { VariantInit(&v); if (SUCCESS == php_com_do_invoke_by_id(obj, DISPID_VALUE, DISPATCH_METHOD|DISPATCH_PROPERTYGET, &v, 1, offset, 0, 0)) { php_com_zval_from_variant(rv, &v, obj->code_page); VariantClear(&v); } } else if (V_ISARRAY(&obj->v)) { convert_to_long(offset); if (SafeArrayGetDim(V_ARRAY(&obj->v)) == 1) { if (php_com_safearray_get_elem(&obj->v, &v, (LONG)Z_LVAL_P(offset))) { php_com_wrap_variant(rv, &v, obj->code_page); VariantClear(&v); } } else { php_com_saproxy_create(object, rv, offset); } } else { php_com_throw_exception(E_INVALIDARG, "this variant is not an array type"); } return rv; }
/** * this is a big cover method that returns TRUE if * the variant type is * VT_EMPTY, VT_NULL, VT_ERROR or VT_DISPATCH with no dispatch object * */ JNIEXPORT jboolean JNICALL Java_com_tangram_Variant_isVariantConsideredNull(JNIEnv *env, jobject _this) { VARIANT *v = extractVariant(env, _this); if (!v) return JNI_TRUE; if ((V_VT(v) & VT_ARRAY)) { // is it a null safearray // prior to 4 Dec 2005 the squiggle brackets were missing // so this did the wrong thing for the else statement if ((V_VT(v) & VT_BYREF)) { if (!V_ARRAYREF(v)) return JNI_TRUE; } else { if (!V_ARRAY(v)) return JNI_TRUE; } } switch (V_VT(v)) { case VT_EMPTY: case VT_NULL: case VT_ERROR: return JNI_TRUE; // is it a null dispatch (Nothing in VB) case VT_DISPATCH: if (!V_DISPATCH(v)) return JNI_TRUE; } return JNI_FALSE; }
/*---------------------------------------------------------------------------------------------- Generate the sort key as a "SAFEARRAY". ----------------------------------------------------------------------------------------------*/ STDMETHODIMP LgIcuCollator::get_SortKeyVariant(BSTR bstrValue, LgCollatingOptions colopt, VARIANT * psaKey) { BEGIN_COM_METHOD; ChkComBstrArgN(bstrValue); ChkComArgPtr(psaKey); psaKey->vt = VT_NULL; EnsureCollator(); int32_t cbKey = keySize; byte rgbKey[keySize+1]; Vector<byte> vbKey; byte * pbKey = GetSortKey(bstrValue, rgbKey, &cbKey, vbKey); // Allocate the safe array. SAFEARRAYBOUND rgsabound[1]; rgsabound[0].lLbound = 0; rgsabound[0].cElements = cbKey; SAFEARRAY FAR * psa = ::SafeArrayCreate(VT_UI1, 1, rgsabound); // Copy the key data to the safe array. byte * pbOut; CheckHr(::SafeArrayAccessData(psa, (void HUGEP **)&pbOut)); memcpy(pbOut, pbKey, cbKey); CheckHr(::SafeArrayUnaccessData(psa)); // Push the safe array to the output pointer. psaKey->vt = VT_UI1 | VT_ARRAY; V_ARRAY(psaKey) = psa; return S_OK; END_COM_METHOD(g_fact, IID_ILgCollatingEngine); }
STDMETHODIMP CLabInput::GetSingleValues(VARIANT* values) { AUTO_LOCK; // Should not be needed inserted on a whim if (!_isConfig) DAQ_CHECK(Configure(FORSINGLEVALUE)); // 3 SCANS IS THE MIN with scan_op SAFEARRAY *ps = SafeArrayCreateVector(VT_I2, 0, _nChannels*2); if (ps==NULL) return E_SAFEARRAY_ERR; // set the data type and values V_ARRAY(values)=ps; V_VT(values)=VT_ARRAY | VT_I2; TSafeArrayAccess <short > binarray(values); if (_nChannels<=2) { for (int i=0; i<_nChannels; i++) { DAQ_CHECK(AI_Read(_id, _chanList[i], _gainList[i], &binarray[i])); } } else { // setup the channels to read and scan them DAQ_TRACE(Set_DAQ_Device_Info(_id, ND_DATA_XFER_MODE_AI, ND_INTERRUPTS)); short *dummy=(short*)_alloca(_nChannels*sizeof(short)); DAQ_CHECK(Lab_ISCAN_Op(_id,static_cast<i16>(_nChannels),_gainList[0],&binarray[0], _nChannels, 1.0/_chanSkew,0,dummy)); } return S_OK; }
static zval* saproxy_iter_get_data(zend_object_iterator *iter) { php_com_saproxy_iter *I = (php_com_saproxy_iter*)Z_PTR(iter->data); VARIANT v; VARTYPE vt; SAFEARRAY *sa; I->indices[I->proxy->dimensions-1] = I->key; sa = V_ARRAY(&I->proxy->obj->v); if (FAILED(SafeArrayGetVartype(sa, &vt)) || vt == VT_EMPTY) { vt = V_VT(&I->proxy->obj->v) & ~VT_ARRAY; } VariantInit(&v); if (vt == VT_VARIANT) { SafeArrayGetElement(sa, I->indices, &v); } else { V_VT(&v) = vt; SafeArrayGetElement(sa, I->indices, &v.lVal); } ZVAL_NULL(&I->data); php_com_wrap_variant(&I->data, &v, I->proxy->obj->code_page); VariantClear(&v); return &I->data; }
static void html_window_navigate(DocHost *This, IHTMLPrivateWindow *window, BSTR url, BSTR headers, SAFEARRAY *post_data) { VARIANT headers_var, post_data_var; BSTR empty_str; HRESULT hres; hres = set_dochost_url(This, url); if(FAILED(hres)) return; empty_str = SysAllocStringLen(NULL, 0); if(headers) { V_VT(&headers_var) = VT_BSTR; V_BSTR(&headers_var) = headers; }else { V_VT(&headers_var) = VT_EMPTY; } if(post_data) { V_VT(&post_data_var) = VT_UI1|VT_ARRAY; V_ARRAY(&post_data_var) = post_data; }else { V_VT(&post_data_var) = VT_EMPTY; } set_doc_state(This, READYSTATE_LOADING); hres = IHTMLPrivateWindow_SuperNavigate(window, url, empty_str, NULL, NULL, &post_data_var, &headers_var, 0); SysFreeString(empty_str); if(FAILED(hres)) WARN("SuprtNavigate failed: %08x\n", hres); }
static void on_before_navigate2(DocHost *This, LPCWSTR url, SAFEARRAY *post_data, 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]; WCHAR file_path[MAX_PATH]; DWORD file_path_len = sizeof(file_path) / sizeof(*file_path); 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; 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) = 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; if(PathCreateFromUrlW(url, file_path, &file_path_len, 0) == S_OK) V_BSTR(&var_url) = SysAllocString(file_path); else V_BSTR(&var_url) = SysAllocString(url); V_VT(params+6) = (VT_DISPATCH); V_DISPATCH(params+6) = (IDispatch*)This->wb; call_sink(This->cps.wbe2, DISPID_BEFORENAVIGATE2, &dispparams); SysFreeString(V_BSTR(&var_url)); }
static unsigned long wire_extra_user_size(unsigned long *pFlags, unsigned long Start, VARIANT *pvar) { if (V_ISARRAY(pvar)) { if (V_ISBYREF(pvar)) return LPSAFEARRAY_UserSize(pFlags, Start, V_ARRAYREF(pvar)); else return LPSAFEARRAY_UserSize(pFlags, Start, &V_ARRAY(pvar)); } switch (V_VT(pvar)) { case VT_BSTR: return BSTR_UserSize(pFlags, Start, &V_BSTR(pvar)); case VT_BSTR | VT_BYREF: return BSTR_UserSize(pFlags, Start, V_BSTRREF(pvar)); case VT_VARIANT | VT_BYREF: return VARIANT_UserSize(pFlags, Start, V_VARIANTREF(pvar)); case VT_UNKNOWN: return Start + interface_variant_size(pFlags, &IID_IUnknown, pvar); case VT_DISPATCH: return Start + interface_variant_size(pFlags, &IID_IDispatch, pvar); case VT_RECORD: FIXME("wire-size record\n"); return Start; case VT_SAFEARRAY: case VT_SAFEARRAY | VT_BYREF: FIXME("wire-size safearray: shouldn't be marshaling this\n"); return Start; default: return Start; } }
HRESULT WINAPI InitVariantFromBuffer(const VOID *pv, UINT cb, VARIANT *pvar) { SAFEARRAY *arr; void *data; HRESULT hres; TRACE("(%p %u %p)\n", pv, cb, pvar); arr = SafeArrayCreateVector(VT_UI1, 0, cb); if(!arr) return E_OUTOFMEMORY; hres = SafeArrayAccessData(arr, &data); if(FAILED(hres)) { SafeArrayDestroy(arr); return hres; } memcpy(data, pv, cb); hres = SafeArrayUnaccessData(arr); if(FAILED(hres)) { SafeArrayDestroy(arr); return hres; } V_VT(pvar) = VT_ARRAY|VT_UI1; V_ARRAY(pvar) = arr; return S_OK; }
/** * Finds the associated Win32_NetworkAdapterConfiguration for Win32_NetworkAdapter adapterObj. * Iterates through the IP addresses associated with the adapter calling * stringToAdaptorIp() to choose the highest priority address (according to EnumIPSelectionPriority) * as the adapter address which is used to populate adapter->userData->ipAddr. * If two addresses have the same highest priority, then the first one seen is chosen. */ static void readIpAddressesWin32(IWbemServices *pNamespace, IWbemClassObject *adapterObj, SFLAdaptor *adaptor) { IEnumWbemClassObject *configEnum; HRESULT hr = associatorsOf(pNamespace, adapterObj, L"Win32_NetworkAdapterSetting", L"Win32_NetworkAdapterConfiguration", L"Setting", &configEnum); if (SUCCEEDED(hr)) { IWbemClassObject *configObj; ULONG configCount; hr = configEnum->Next(WBEM_INFINITE, 1, &configObj, &configCount); if (SUCCEEDED(hr) && configCount == 1) { VARIANT addresses; hr = configObj->Get(L"IPAddress", 0, &addresses, 0, 0); if (WBEM_S_NO_ERROR == hr && addresses.vt == (VT_ARRAY | VT_BSTR)) { SAFEARRAY *sa = V_ARRAY(&addresses); LONG lstart, lend; hr = SafeArrayGetLBound(sa, 1, &lstart); hr = SafeArrayGetUBound(sa, 1, &lend); BSTR *pbstr; hr = SafeArrayAccessData(sa, (void HUGEP **)&pbstr); if (SUCCEEDED(hr)) { for (LONG idx=lstart; idx <= lend; idx++) { PCWSTR addrStr = pbstr[idx]; stringToAdaptorIp(addrStr, adaptor); } SafeArrayUnaccessData(sa); } } VariantClear(&addresses); configObj->Release(); } configEnum->Release(); } }
/* * call-seq: * WIN32OLE_VARIANT.value #=> Ruby object. * * Returns Ruby object value from OLE variant. * obj = WIN32OLE_VARIANT.new(1, WIN32OLE::VARIANT::VT_BSTR) * obj.value # => "1" (not Integer object, but String object "1") * */ static VALUE folevariant_value(VALUE self) { struct olevariantdata *pvar; VALUE val = Qnil; VARTYPE vt; int dim; SAFEARRAY *psa; TypedData_Get_Struct(self, struct olevariantdata, &olevariant_datatype, pvar); val = ole_variant2val(&(pvar->var)); vt = V_VT(&(pvar->var)); if ((vt & ~VT_BYREF) == (VT_UI1|VT_ARRAY)) { if (vt & VT_BYREF) { psa = *V_ARRAYREF(&(pvar->var)); } else { psa = V_ARRAY(&(pvar->var)); } if (!psa) { return val; } dim = SafeArrayGetDim(psa); if (dim == 1) { val = rb_funcall(val, rb_intern("pack"), 1, rb_str_new2("C*")); } } return val; }
void goToURL (const String& url, const StringArray* headers, const MemoryBlock* postData) { if (browser != nullptr) { LPSAFEARRAY sa = nullptr; VARIANT flags, frame, postDataVar, headersVar; // (_variant_t isn't available in all compilers) VariantInit (&flags); VariantInit (&frame); VariantInit (&postDataVar); VariantInit (&headersVar); if (headers != nullptr) { V_VT (&headersVar) = VT_BSTR; V_BSTR (&headersVar) = SysAllocString ((const OLECHAR*) headers->joinIntoString ("\r\n").toWideCharPointer()); } if (postData != nullptr && postData->getSize() > 0) { LPSAFEARRAY sa = SafeArrayCreateVector (VT_UI1, 0, (ULONG) postData->getSize()); if (sa != 0) { void* data = nullptr; SafeArrayAccessData (sa, &data); jassert (data != nullptr); if (data != nullptr) { postData->copyTo (data, 0, postData->getSize()); SafeArrayUnaccessData (sa); VARIANT postDataVar2; VariantInit (&postDataVar2); V_VT (&postDataVar2) = VT_ARRAY | VT_UI1; V_ARRAY (&postDataVar2) = sa; postDataVar = postDataVar2; } } } browser->Navigate ((BSTR) (const OLECHAR*) url.toWideCharPointer(), &flags, &frame, &postDataVar, &headersVar); if (sa != 0) SafeArrayDestroy (sa); VariantClear (&flags); VariantClear (&frame); VariantClear (&postDataVar); VariantClear (&headersVar); } }
static int com_object_count(zval *object, zend_long *count) { php_com_dotnet_object *obj; LONG ubound = 0, lbound = 0; obj = CDNO_FETCH(object); if (!V_ISARRAY(&obj->v)) { return FAILURE; } SafeArrayGetLBound(V_ARRAY(&obj->v), 1, &lbound); SafeArrayGetUBound(V_ARRAY(&obj->v), 1, &ubound); *count = ubound - lbound + 1; return SUCCESS; }
HRESULT navigate_url(DocHost *This, LPCWSTR url, const VARIANT *Flags, const VARIANT *TargetFrameName, VARIANT *PostData, VARIANT *Headers) { task_navigate_bsc_t *task; PBYTE post_data = NULL; ULONG post_data_len = 0; LPWSTR headers = NULL; TRACE("navigating to %s\n", debugstr_w(url)); if((Flags && V_VT(Flags) != VT_EMPTY) || (TargetFrameName && V_VT(TargetFrameName) != VT_EMPTY)) FIXME("Unsupported args (Flags %p:%d; TargetFrameName %p:%d)\n", Flags, Flags ? V_VT(Flags) : -1, TargetFrameName, TargetFrameName ? V_VT(TargetFrameName) : -1); if(PostData) { TRACE("PostData vt=%d\n", V_VT(PostData)); if(V_VT(PostData) == (VT_ARRAY | VT_UI1)) { SafeArrayAccessData(V_ARRAY(PostData), (void**)&post_data); post_data_len = V_ARRAY(PostData)->rgsabound[0].cElements; } } if(Headers && V_VT(Headers) != VT_EMPTY && V_VT(Headers) != VT_ERROR) { if(V_VT(Headers) != VT_BSTR) return E_INVALIDARG; headers = V_BSTR(Headers); TRACE("Headers: %s\n", debugstr_w(headers)); } task = heap_alloc(sizeof(*task)); task->bsc = create_callback(This, url, post_data, post_data_len, headers); if(post_data) SafeArrayUnaccessData(V_ARRAY(PostData)); push_dochost_task(This, &task->header, navigate_bsc_proc, This->url == NULL); return S_OK; }
static void on_before_navigate2(DocHost *This, LPCWSTR url, SAFEARRAY *post_data, 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; 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) = 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)); }
HRESULT CDisk::GetFormat(VARIANT *buf, DSK_FORMAT **bufout, unsigned length) { long lBound, uBound; unsigned char HUGEP* FAR pData; SAFEARRAY *psa; HRESULT hr; unsigned n; DSK_FORMAT *fmt; if (V_VT(buf) != (VT_ARRAY | VT_UI1)) { return Error("Passed parameter must be an array of unsigned characters", IID_IDisk, E_INVALIDARG); } psa = V_ARRAY(buf); // Check dimensions of the array. if (SafeArrayGetDim(psa) != 1) { return Error("Passed parameter must be a 1-dimensional array", IID_IDisk, E_INVALIDARG); } // Get array bounds. hr = SafeArrayGetLBound(psa, 1, &lBound); if (FAILED(hr)) { return Error("Could not get array bounds", IID_IDisk, hr); } hr = SafeArrayGetUBound(psa, 1, &uBound); if (FAILED(hr)) { return Error("Could not get array bounds", IID_IDisk, hr); } if (uBound + 1 - lBound < (long)length*4) { return Error("Passed array is too short", IID_IDisk, E_INVALIDARG); } // Get a pointer to the elements of the array. hr = SafeArrayAccessData(psa, (void HUGEP * FAR *)&pData); if (FAILED(hr)) { return Error("Could not access array data", IID_IDisk, E_INVALIDARG); } *bufout = (DSK_FORMAT *)dsk_malloc(length * sizeof(DSK_FORMAT)); if (!bufout) return MapError(DSK_ERR_NOMEM); fmt = bufout[0]; for (n = 0; n < length; n++) { fmt->fmt_cylinder = *pData++; fmt->fmt_head = *pData++; fmt->fmt_sector = *pData++; fmt->fmt_secsize = 128 << (*pData++); ++fmt; } SafeArrayUnaccessData(psa); return S_OK; }
HRESULT STDMETHODCALLTYPE CBandProxy::NavigateToPIDL(LPCITEMIDLIST pidl) { CComPtr<IOleWindow> oleWindow; CComPtr<IServiceProvider> serviceProvider; CComPtr<IUnknown> webBrowserUnknown; CComPtr<IWebBrowser2> webBrowser; HWND browserWindow; CComVariant args; CComVariant emptyVariant; unsigned int arraySize; HRESULT hResult; hResult = FindBrowserWindow(&webBrowserUnknown); if (FAILED_UNEXPECTEDLY(hResult)) return hResult; hResult = webBrowserUnknown->QueryInterface(IID_PPV_ARG(IWebBrowser2, &webBrowser)); if (FAILED_UNEXPECTEDLY(hResult)) return hResult; hResult = webBrowser->put_Visible(TRUE); hResult = webBrowser->QueryInterface(IID_PPV_ARG(IServiceProvider, &serviceProvider)); if (SUCCEEDED(hResult)) { hResult = serviceProvider->QueryService(SID_STopLevelBrowser, IID_PPV_ARG(IOleWindow, &oleWindow)); if (SUCCEEDED(hResult)) { hResult = oleWindow->GetWindow(&browserWindow); if (IsIconic(browserWindow)) ShowWindow(browserWindow, SW_RESTORE); } } arraySize = ILGetSize(pidl); V_VT(&args) = VT_ARRAY | VT_UI1; V_ARRAY(&args) = SafeArrayCreateVector(VT_UI1, 0, arraySize); if (V_ARRAY(&args) == NULL) return E_OUTOFMEMORY; memcpy(V_ARRAY(&args)->pvData, pidl, arraySize); hResult = webBrowser->Navigate2(&args, &emptyVariant, &emptyVariant, &emptyVariant, &emptyVariant); if (FAILED_UNEXPECTEDLY(hResult)) return hResult; return S_OK; }
void SimpleBrowser::Print(LPCTSTR header,LPCTSTR footer) { if (m_pBrowser != NULL) { // construct two element SAFEARRAY; // first element is header string, second element is footer string HRESULT hr; VARIANT header_variant; VariantInit(&header_variant); V_VT(&header_variant) = VT_BSTR; V_BSTR(&header_variant) = CString(header).AllocSysString(); VARIANT footer_variant; VariantInit(&footer_variant); V_VT(&footer_variant) = VT_BSTR; V_BSTR(&footer_variant) = CString(footer).AllocSysString(); long index; SAFEARRAYBOUND parameter_array_bound[1]; SAFEARRAY *parameter_array = NULL; parameter_array_bound[0].cElements = 2; parameter_array_bound[0].lLbound = 0; parameter_array = SafeArrayCreate(VT_VARIANT,1,parameter_array_bound); index = 0; hr = SafeArrayPutElement(parameter_array,&index,&header_variant); index = 1; hr = SafeArrayPutElement(parameter_array,&index,&footer_variant); VARIANT parameter; VariantInit(¶meter); V_VT(¶meter) = VT_ARRAY | VT_BYREF; V_ARRAY(¶meter) = parameter_array; // start printing browser contents hr = m_pBrowser->ExecWB(OLECMDID_PRINT,OLECMDEXECOPT_DODEFAULT,¶meter,NULL); // Note: There is no simple way to determine that printing has completed. // In fact, if the browser is destroyed while printing is in progress, // only part of the contents will be printed. // release SAFEARRAY if (!SUCCEEDED(hr)) { VariantClear(&header_variant); VariantClear(&footer_variant); if (parameter_array != NULL) { SafeArrayDestroy(parameter_array); } } } }