void QtWMI::DisplayVariantValues(CString& strName, variant_t& var) { switch (var.vt) { case VT_BSTR: dprintf(L"%s=%s", strName, var.pbstrVal ); break; case VT_UI1: case VT_UI2: case VT_UI4: case VT_UINT: dprintf(L"%s=%lu", strName, var.uiVal); break; case VT_I1: case VT_I2: case VT_I4: case VT_INT: dprintf(L"%s=%d",strName, var.iVal); break; case VT_BOOL: dprintf(L"%s=%s",strName, (var.boolVal==VARIANT_TRUE)? L"True": L"False" ); break; case VT_ARRAY|VT_BSTR: { SAFEARRAY* pAray=var.parray; LONG nLower=0, nUpper=0; SafeArrayGetLBound(pAray, 1, &nLower); SafeArrayGetUBound(pAray, 1, &nUpper); _bstr_t str; for(long n=nLower; n<nUpper;n++) { SafeArrayGetElement(pAray, &n, &str); dprintf(L"%s=%s",strName , str ); } } break; case VT_I4|VT_ARRAY: { SAFEARRAY* pAray=var.parray; long nLower=0, nUpper=0; SafeArrayGetLBound(pAray, 1, &nLower); SafeArrayGetUBound(pAray, 1, &nUpper); int nVal=0; for(long n=nLower; n<nUpper;n++) { SafeArrayGetElement(pAray, &n, &nVal); dprintf(L"%s=%d",strName, nVal ); } } break; } }
//============================================================================== // 1D array of ints, dim unspecified, allow Nx1 or 1xN arrays int g_CheckVariantArray( int * pnDim1, VARIANT vMtx, int ** ppiMtx ){ SAFEARRAY * psaMtx; int nDims; long iDim1, iDim2; VARTYPE tSaType; psaMtx = vMtx.parray; *pnDim1 = 0; if( vMtx.vt != (VT_ARRAY|VT_I4)){ CP_printf("\ng_CheckVariantArray(): wrong VARIANT type, expecting array of ints!\n"); return 1; } SafeArrayGetVartype( psaMtx, &tSaType ); if( tSaType != VT_I4 ){ CP_printf("\ng_CheckVariantArray(): wrong array type, expecting array of ints!\n"); return 1; } nDims = SafeArrayGetDim( psaMtx ); if( nDims !=2 && nDims !=1 ) { // Allow Nx1 or 1xN arrays CP_printf("\ng_CheckVariantArray(): wrong array dimensions, expecting 1xN, or Nx1 array!\n"); return 1; } SafeArrayGetLBound( psaMtx, 1, &iDim1 ); if( iDim1 != 0) { CP_printf("\ng_CheckVariantArray(): wrong array dimensions, expecting 1xN, or Nx1 array!\n"); return 1; } SafeArrayGetUBound( psaMtx, 1, &iDim1 ); if( nDims == 2 ) { SafeArrayGetLBound( psaMtx, 2, &iDim2 ); if( iDim2 != 0) { CP_printf("\ng_CheckVariantArray(): wrong array dimensions, expecting 1xN, or Nx1 array!\n"); return 1; } SafeArrayGetUBound( psaMtx, 2, &iDim2 ); } else iDim2 = 0; // stupid Matlab hack allowing any 2D array with one redundant dim if( (iDim2 != 0) && (iDim1 != 0)) { CP_printf("\ng_CheckVariantArray(): wrong array dimensions, expecting 1xN, or Nx1 array!\n"); return 1; } *pnDim1 = iDim1 + iDim2 + 1; // if we get here, one size is always zero SafeArrayAccessData(psaMtx, (void **) ppiMtx); // Get data pointer return 0; }
//============================================================================== // 2D array of doubles int g_CheckVariantArray( int nDim1, int nDim2, VARIANT vMtx, double ** ppdMtx ){ SAFEARRAY * psaMtx; int nDims; long iDim; VARTYPE tSaType; psaMtx = vMtx.parray; if( vMtx.vt != (VT_ARRAY|VT_R8)){ CP_printf("\ng_CheckVariantArray(): wrong VARIANT type, expecting array of doubles!\n"); return 1; } SafeArrayGetVartype( psaMtx, &tSaType ); if( tSaType != VT_R8 ){ CP_printf("\ng_CheckVariantArray(): wrong array type, expecting array of doubles!\n"); return 1; } nDims = SafeArrayGetDim( psaMtx ); if( nDims !=2 ) { CP_printf("\ng_CheckVariantArray(): wrong array dimensions, expecting %dx%d array!\n", nDim1, nDim2 ); return 1; } SafeArrayGetLBound( psaMtx, 1, &iDim ); if( iDim != 0) { CP_printf("\ng_CheckVariantArray(): wrong array dimensions, expecting %dx%d array!\n", nDim1, nDim2 ); return 1; } SafeArrayGetUBound( psaMtx, 1, &iDim ); if( iDim+1 != nDim1) { CP_printf("\ng_CheckVariantArray(): wrong array dimensions, expecting %dx%d array!\n", nDim1, nDim2 ); return 1; } SafeArrayGetLBound( psaMtx, 2, &iDim ); if( iDim != 0) { CP_printf("\ng_CheckVariantArray(): wrong array dimensions, expecting %dx%d array!\n", nDim1, nDim2 ); return 1; } SafeArrayGetUBound( psaMtx, 2, &iDim ); if( iDim+1 != nDim2) { CP_printf("\ng_CheckVariantArray(): wrong array dimensions, expecting %dx%d array!\n", nDim1, nDim2 ); return 1; } SafeArrayAccessData(psaMtx, (void **) ppdMtx); // Get data pointer return 0; }
void ExcelWorksheet::GetValues(ExcelData& excelData, const char* cell/* = "A1"*/) { RangePtr usedRange = _worksheet->UsedRange; _variant_t values = usedRange->Value2; if (values.vt == (VT_ARRAY | VT_VARIANT) && ::SafeArrayGetDim(values.parray) == 2) { LONG rowLBound = 0, rowUBound = 0; LONG colLBound = 0, colUBound = 0; SafeArrayGetLBound(values.parray, 1, &rowLBound); SafeArrayGetUBound(values.parray, 1, &rowUBound); SafeArrayGetLBound(values.parray, 2, &colLBound); SafeArrayGetUBound(values.parray, 2, &colUBound); excelData.Create(rowUBound - rowLBound + 1, colUBound - colLBound + 1); for (int row = rowLBound; row <= rowUBound; ++row) { for (int col = colLBound; col <= colUBound; ++col) { LONG indices[] = { row, col }; _variant_t value; SafeArrayGetElement(values.parray, indices, &value); excelData.SetValue(row - rowLBound + 1, col - colLBound + 1, value); } } //VARIANT* pData = NULL; //HRESULT hr = SafeArrayAccessData(values.parray, (void **)&pData); //if (SUCCEEDED(hr)) //{ // int rowNum = rowUBound - rowLBound + 1; // int colNum = colUBound - colLBound + 1; // for (int row = rowLBound; row <= rowUBound; ++row) // { // for (int col = colLBound; col <= colUBound; ++col) // { // _variant_t v = pData[(col - colLBound)*rowNum + (row - rowLBound)]; // printf("%d\t", (int)(V_R8(&v))); // } // printf("\n"); // } // SafeArrayUnaccessData(values.parray); //} } }
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; }
safearray_t( SAFEARRAY *& p ) : psa_( p ), pdata_(0), size_(0) { SafeArrayAccessData( psa_, reinterpret_cast<void **>(&pdata_) ); LONG lBound, uBound; SafeArrayGetLBound( psa_, 1, &lBound ); SafeArrayGetUBound( psa_, 1, &uBound ); size_ = uBound - lBound + 1; }
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; }
//vrati pocet zkopirovanych stringu int CWordManager::LoadSafeArrayToStringTable(SAFEARRAY *sarray, CStringTableImpl &str_table) { LONG l_bound = 0; LONG u_bound = -1; SafeArrayGetLBound(sarray, 1, & l_bound); SafeArrayGetUBound(sarray, 1, & u_bound); str_table.Clear(); for (LONG a = l_bound; a <= u_bound; a++) { BSTR arg; SafeArrayGetElement(sarray, &a, & arg); _bstr_t s; s.Assign(arg); str_table.Add(s); } SafeArrayDestroy(sarray); return u_bound - l_bound +1; }
static HRESULT VBArray_lbound(script_ctx_t *ctx, vdisp_t *vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r) { VBArrayInstance *vbarray; int dim; HRESULT hres; TRACE("\n"); vbarray = vbarray_this(vthis); if(!vbarray) return throw_type_error(ctx, JS_E_VBARRAY_EXPECTED, NULL); if(argc) { hres = to_int32(ctx, argv[0], &dim); if(FAILED(hres)) return hres; } else dim = 1; hres = SafeArrayGetLBound(vbarray->safearray, dim, &dim); if(hres == DISP_E_BADINDEX) return throw_range_error(ctx, JS_E_SUBSCRIPT_OUT_OF_RANGE, NULL); else if(FAILED(hres)) return hres; if(r) *r = jsval_number(dim); return S_OK; }
HRESULT CKhParser::GetNextHomonym( SAFEARRAY** lpHomonym ) { if (currHom == -1) return S_OK; std::wstring str; if (currHom < homonyms.size()) str = homonyms[currHom].khak; else str = homonyms[currHom % homonyms.size()].rus; long idx, len, start; len = (long)str.length(); SafeArrayLock(*lpHomonym); SafeArrayGetUBound(*lpHomonym, 1, &len); SafeArrayGetLBound(*lpHomonym, 1, &start); short asterisk = L'*'; for (idx = start; idx < len; idx ++) { if (idx == str.length()) { // if (str[idx] == 0x0) { SafeArrayPutElement(*lpHomonym, &idx, &asterisk); break; } SafeArrayPutElement(*lpHomonym, &idx, &str[ idx ]); } SafeArrayUnlock(*lpHomonym); currHom++; return S_OK; }
RobotPoint DensoRobot::GetCurrentPos() { CComVariant varValue; long i, longlBound, longUBound; float *positionArray = new float[6]; hr = this->currentPosition->get_Value(&varValue); if(FAILED(hr)) throw exception ("Could not get the current position!"); SAFEARRAY *psa = varValue.parray; SafeArrayGetLBound(psa, 1, &longlBound); SafeArrayGetUBound(psa, 1, &longUBound); int n = 0; for(i = longlBound; i <= longUBound; i++) { float fltResult; SafeArrayGetElement(psa, &i, &fltResult); positionArray[n] = fltResult; n++; } RobotPoint robotPoint((float)positionArray[0], (float)positionArray[1], (float)positionArray[2], (float)positionArray[3], (float)positionArray[4], (float)positionArray[5], (float)positionArray[6]); return robotPoint; }
/** * 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(); } }
STDMETHODIMP CPoint::Length(/* in */ VARIANT var, /*[out, retval]*/ double *pSum) { assert(pSum); assert(var.vt == (VT_ARRAY | VT_UNKNOWN)); SAFEARRAY *psa = var.parray; assert(SafeArrayGetDim(psa) == 1); long ubound, lbound; HRESULT hr = SafeArrayGetUBound(psa, 1, &ubound); if(!SUCCEEDED(hr)) return hr; hr = SafeArrayGetLBound(psa, 1, &lbound); if(!SUCCEEDED(hr)) return hr; IUnknown **prgn; hr = SafeArrayAccessData(psa, (void**)&prgn); if(!SUCCEEDED(hr)) return hr; *pSum = 0; for (long i = lbound + 1; i <= ubound; i++) { IPoint *p1, *p2; hr = prgn[i-1]->QueryInterface(IID_IPoint, (void**)&p1); if(!SUCCEEDED(hr)) return hr; hr = prgn[i]->QueryInterface(IID_IPoint, (void**)&p2); if(!SUCCEEDED(hr)) return hr; long x1, x2, y1, y2; hr = p1->GetCoords(&x1, &y1); if(!SUCCEEDED(hr)) return hr; hr = p2->GetCoords(&x2, &y2); if(!SUCCEEDED(hr)) return hr; *pSum += sqrt(pow((double)(x2-x1), 2.0) + pow((double)(y2-y1), 2.0)); p1->Release(); p2->Release(); } SafeArrayUnaccessData(psa); return S_OK; }
void BOSSamp::BuildObject(LPDISPATCH commArea) { // TODO: Add your dispatch handler code here // // Map commArea onto a CICS OLE Buffer object // CclBuffer pBuffer = CclBuffer(commArea); // // Extract the variant from the CICS OLE buffer object, and calculate // the bounding information // COleVariant variant = COleVariant(pBuffer.Data()); unsigned long i,saSize=0; long uBound, lBound; void * saData; for ( i = 1; i<= SafeArrayGetDim (variant.parray ); i++ ); { SafeArrayGetLBound ( variant.parray, i , &lBound ); SafeArrayGetUBound ( variant.parray, i, &uBound ); saSize = saSize + uBound - lBound + 1; } SafeArrayAccessData ( variant.parray, &saData ); // // Create a new CICS C++ Buffer object, prime it with the contents of the // safe array // CclBuf* buffer = new CclBuf(saSize,saData); SafeArrayUnlock(variant.parray); // // Extract the business objects from the buffer // int dataLength = buffer->dataLength(); name = CString((char *)buffer->dataArea()); if (name.GetLength() > dataLength) { name = name.Left(dataLength); } int nameLen = name.GetLength() + 1; if (nameLen < dataLength) { yearsService = *(short *)buffer->dataArea(nameLen); if (nameLen + sizeof(yearsService) < dataLength ) { doB = *(CTime *)buffer->dataArea(nameLen + sizeof(yearsService)); } else { doB = CTime::GetCurrentTime(); } } else { yearsService = 0; doB = CTime::GetCurrentTime(); } // // Detach and release the 'mapped' buffer object // pBuffer.DetachDispatch(); pBuffer.ReleaseDispatch(); }
long CSafeArray::GetLBound(UINT nDim) { ASSERT(m_pArray!=NULL); long lRetv=-1; HRESULT hr=SafeArrayGetLBound(m_pArray, nDim, &lRetv); ASSERT(SUCCEEDED(hr)); return lRetv; }
//============================================================================== // 2D array of ints, both dims unspecified int g_CheckVariantArray( int * pnDim1, int * pnDim2, VARIANT vMtx, int ** ppiMtx ){ SAFEARRAY * psaMtx; int nDims; long iDim; VARTYPE tSaType; psaMtx = vMtx.parray; *pnDim1 = 0; *pnDim2 = 0; if( vMtx.vt != (VT_ARRAY|VT_I4)){ CP_printf("\ng_CheckVariantArray(): wrong VARIANT type, expecting array of ints!\n"); return 1; } SafeArrayGetVartype( psaMtx, &tSaType ); if( tSaType != VT_I4 ){ CP_printf("\ng_CheckVariantArray(): wrong array type, expecting array of 4-byte integers!\n"); return 1; } nDims = SafeArrayGetDim( psaMtx ); if( nDims !=2 ) { CP_printf("\ng_CheckVariantArray(): wrong array dimensions\n" ); return 1; } SafeArrayGetLBound( psaMtx, 1, &iDim ); if( iDim != 0) { CP_printf("\ng_CheckVariantArray(): wrong array dimensions!\n" ); return 1; } SafeArrayGetLBound( psaMtx, 2, &iDim ); if( iDim != 0) { CP_printf("\ng_CheckVariantArray(): wrong array dimensions\n" ); return 1; } SafeArrayGetUBound( psaMtx, 1, &iDim ); iDim++; // we return the size, which is upperbound +1 * pnDim1 = iDim; SafeArrayGetUBound( psaMtx, 2, &iDim ); iDim++; // we return the size, which is upperbound +1 * pnDim2 = iDim; SafeArrayAccessData(psaMtx, (void **) ppiMtx); // Get data pointer return 0; }
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_UNION(pVar, bstrVal))); lpData = V_UNION(pVar, bstrVal); dwType = REG_SZ; cbData = (lstrlenW(V_UNION(pVar, bstrVal)) + 1) * sizeof(WCHAR); break; case VT_I4: case VT_UI4: TRACE("writing %u\n", V_UNION(pVar, ulVal)); lpData = &V_UNION(pVar, ulVal); dwType = REG_DWORD; cbData = sizeof(DWORD); break; case VT_ARRAY | VT_UI1: { LONG lUbound = 0; LONG lLbound = 0; dwType = REG_BINARY; res = SafeArrayGetLBound(V_UNION(pVar, parray), 1, &lLbound); res = SafeArrayGetUBound(V_UNION(pVar, parray), 1, &lUbound); cbData = (lUbound - lLbound + 1) /* * sizeof(BYTE)*/; TRACE("cbData: %d\n", cbData); res = SafeArrayAccessData(V_UNION(pVar, parray), &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_UNION(pVar, parray)); return res; }
HRESULT CSoftHIDInputKbdMapper::ProcessKbdOutput(SAFEARRAY* psa) /*++ Routine Description: Processes keyboard output report. Synchronization: None Arguments: psa - pointer to safearray containing Output Report data Return Value: S_OK Success E_UNEXPECTED Unxpected size of Output Report data buffer E_FAIL Could not report indicator status to keyboard object. --*/ { BYTE HUGEP* pArrayData = NULL; LONG lLBound = 0; LONG lUBound = 0; HRESULT hr = S_OK; KEYBOARD_INDICATOR_PARAMETERS Indicator; ZeroMemory(&Indicator, sizeof(Indicator)); IfFalseHrGo(NULL != m_piSoftKeyboard, E_FAIL); // Get SAFEARRAY size IfFailHrGo(SafeArrayGetLBound(psa, 1, &lLBound)); IfFailHrGo(SafeArrayGetUBound(psa, 1, &lUBound)); // Check the size of Output Report data IfFalseHrGo(1 == (lUBound - lLBound + 1), E_UNEXPECTED); IfFailHrGo(::SafeArrayAccessData(psa, (void HUGEP**)&pArrayData)); // Only 5 least significant bits are valid in output report byte. // TODO: this would be controlled by OutputReportMask property later. Indicator.usLedFlags = pArrayData[0] & 0xE0; IfFailHrGo(::SafeArrayUnaccessData(psa)); IfFailHrGo(m_piSoftKeyboard->put_Indicators(&Indicator)); Exit: // the safe array was allocated by the call to // m_piSoftProtXlator->ReadOutputPort in CSoftHID::Run. // Now we are done with it so we should free it here. if (NULL != psa) { (void)::SafeArrayDestroy(psa); } return hr; } // CSoftHIDInputKbdMapper::ProcessKbdOutput
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; }
//============================================================================== // 2D array of doubles, second dim unspecified int g_CheckVariantArray( int nDim1, int * pnDim2, VARIANT vMtx, double ** ppdMtx ){ SAFEARRAY * psaMtx; int nDims; long iDim; VARTYPE tSaType; psaMtx = vMtx.parray; *pnDim2 = 0; SafeArrayGetVartype( psaMtx, &tSaType ); if( tSaType != VT_R8 ){ CP_printf("\ng_CheckVariantArray(): wrong array type, expecting array of doubles!\n"); return 1; } nDims = SafeArrayGetDim( psaMtx ); if( nDims !=2 ) { CP_printf("\ng_CheckVariantArray(): wrong number of dimensions, expecting 2D array!\n" ); return 1; } SafeArrayGetLBound( psaMtx, 1, &iDim ); if( iDim != 0) { CP_printf("\ng_CheckVariantArray(): wrong array dimensions, expecting %dxN array!\n", nDim1 ); return 1; } SafeArrayGetUBound( psaMtx, 1, &iDim ); if( iDim+1 != nDim1) { CP_printf("\ng_CheckVariantArray(): wrong array dimensions, expecting %dxN array!\n", nDim1 ); return 1; } SafeArrayGetLBound( psaMtx, 2, &iDim ); if( iDim != 0) { CP_printf("\ng_CheckVariantArray(): wrong array dimensions, expecting %dxN array!\n", nDim1 ); return 1; } SafeArrayGetUBound( psaMtx, 2, &iDim ); iDim++; // we return the size, which is upperbound +1 * pnDim2 = iDim; SafeArrayAccessData(psaMtx, (void **) ppdMtx); // Get data pointer return 0; }
static HRESULT VBArray_toArray(script_ctx_t *ctx, vdisp_t *vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r) { VBArrayInstance *vbarray; jsdisp_t *array; jsval_t val; VARIANT *v; int i, size = 1, ubound, lbound; HRESULT hres; TRACE("\n"); vbarray = vbarray_this(vthis); if(!vbarray) return throw_type_error(ctx, JS_E_VBARRAY_EXPECTED, NULL); for(i=1; i<=SafeArrayGetDim(vbarray->safearray); i++) { SafeArrayGetLBound(vbarray->safearray, i, &lbound); SafeArrayGetUBound(vbarray->safearray, i, &ubound); size *= ubound-lbound+1; } hres = SafeArrayAccessData(vbarray->safearray, (void**)&v); if(FAILED(hres)) return hres; hres = create_array(ctx, 0, &array); if(FAILED(hres)) { SafeArrayUnaccessData(vbarray->safearray); return hres; } for(i=0; i<size; i++) { hres = variant_to_jsval(v, &val); if(SUCCEEDED(hres)) { hres = jsdisp_propput_idx(array, i, val); jsval_release(val); } if(FAILED(hres)) { SafeArrayUnaccessData(vbarray->safearray); jsdisp_release(array); return hres; } v++; } SafeArrayUnaccessData(vbarray->safearray); if(r) *r = jsval_obj(array); else jsdisp_release(array); return S_OK; }
static void fillSafeArray ( Tcl_Obj *pList, SAFEARRAY *psa, unsigned dim, long *pIndices, Tcl_Interp *interp, bool addRef) { HRESULT hr; // Get index range. long lowerBound; hr = SafeArrayGetLBound(psa, dim, &lowerBound); if (FAILED(hr)) { _com_issue_error(hr); } long upperBound; hr = SafeArrayGetUBound(psa, dim, &upperBound); if (FAILED(hr)) { _com_issue_error(hr); } int numElements; Tcl_Obj **pElements; if (Tcl_ListObjGetElements(interp, pList, &numElements, &pElements) != TCL_OK) { _com_issue_error(E_INVALIDARG); } unsigned dim1 = dim - 1; if (dim < SafeArrayGetDim(psa)) { // Create list of list for multi-dimensional array. for (int i = 0; i < numElements; ++i) { pIndices[dim1] = i; fillSafeArray(pElements[i], psa, dim + 1, pIndices, interp, addRef); } } else { for (int i = 0; i < numElements; ++i) { TclObject element(pElements[i]); NativeValue elementVar; element.toNativeValue(&elementVar, Type::variant(), interp, addRef); pIndices[dim1] = i; hr = SafeArrayPutElement(psa, pIndices, &elementVar); if (FAILED(hr)) { _com_issue_error(hr); } } } }
PyObject *PyObject_FromSAFEARRAYRecordInfo(SAFEARRAY *psa) { PyObject *ret = NULL, *ret_tuple = NULL; IRecordInfo *info = NULL; BYTE *source_data = NULL, *this_dest_data = NULL; long lbound, ubound, nelems, i; ULONG cb_elem; PyRecordBuffer *owner = NULL; HRESULT hr = SafeArrayGetRecordInfo(psa, &info); if (FAILED(hr)) goto exit; hr = SafeArrayAccessData(psa, (void **)&source_data); if (FAILED(hr)) goto exit; // Allocate a new chunk of memory hr = SafeArrayGetUBound(psa, 1, &ubound); if (FAILED(hr)) goto exit; hr = SafeArrayGetLBound(psa, 1, &lbound); if (FAILED(hr)) goto exit; nelems = ubound-lbound; hr = info->GetSize(&cb_elem); if (FAILED(hr)) goto exit; owner = new PyRecordBuffer(nelems * cb_elem); if (PyErr_Occurred()) goto exit; owner->AddRef(); // unref'd at end - for successful failure cleanup ret_tuple = PyTuple_New(nelems); if (ret_tuple==NULL) goto exit; this_dest_data = (BYTE *)owner->data; for (i=0;i<nelems;i++) { hr = info->RecordInit(this_dest_data); if (FAILED(hr)) goto exit; hr = info->RecordCopy(source_data, this_dest_data); if (FAILED(hr)) goto exit; PyTuple_SET_ITEM(ret_tuple, i, new PyRecord(info, this_dest_data, owner)); this_dest_data += cb_elem; source_data += cb_elem; } ret = ret_tuple; Py_INCREF(ret); // for decref on cleanup. exit: if (FAILED(hr)) { if (info) PyCom_BuildPyException(hr, info, IID_IRecordInfo); else PyCom_BuildPyException(hr); Py_XDECREF(ret); ret = NULL; } if (owner != NULL) owner->Release(); Py_XDECREF(ret_tuple); if (info) info->Release(); if (source_data!=NULL) SafeArrayUnaccessData(psa); return ret; }
bool wxSafeArrayBase::GetLBound(size_t dim, long& bound) const { wxCHECK_MSG( m_array, false, wxS("Uninitialized safe array") ); wxCHECK_MSG( dim > 0, false, wxS("Invalid dimension index") ); HRESULT hr = SafeArrayGetLBound(m_array, dim, &bound); if ( FAILED(hr) ) { wxLogApiError(wxS("SafeArrayGetLBound()"), hr); return false; } return true; }
/* this is a convenience function for fetching a particular * element from a (possibly multi-dimensional) safe array */ PHP_COM_DOTNET_API int php_com_safearray_get_elem(VARIANT *array, VARIANT *dest, LONG dim1) { UINT dims; LONG lbound, ubound; LONG indices[1]; VARTYPE vt; if (!V_ISARRAY(array)) { return 0; } dims = SafeArrayGetDim(V_ARRAY(array)); if (dims != 1) { php_error_docref(NULL, E_WARNING, "Can only handle single dimension variant arrays (this array has %d)", dims); return 0; } if (FAILED(SafeArrayGetVartype(V_ARRAY(array), &vt)) || vt == VT_EMPTY) { vt = V_VT(array) & ~VT_ARRAY; } /* determine the bounds */ SafeArrayGetLBound(V_ARRAY(array), 1, &lbound); SafeArrayGetUBound(V_ARRAY(array), 1, &ubound); /* check bounds */ if (dim1 < lbound || dim1 > ubound) { php_com_throw_exception(DISP_E_BADINDEX, "index out of bounds"); return 0; } /* now fetch that element */ VariantInit(dest); indices[0] = dim1; if (vt == VT_VARIANT) { SafeArrayGetElement(V_ARRAY(array), indices, dest); } else { V_VT(dest) = vt; /* store the value into "lVal" member of the variant. * This works because it is a union; since we know the variant * type, we end up with a working variant */ SafeArrayGetElement(V_ARRAY(array), indices, &dest->lVal); } return 1; }
void com_array_reader::calc_bound() { if (FAILED(SafeArrayGetLBound(m_psa, 1, &m_lbound))) goto error_get_bound; if (FAILED(SafeArrayGetUBound(m_psa, 1, &m_ubound))) goto error_get_bound; return; error_get_bound: m_ubound = -1; m_lbound = 0; }
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 CPoint::Sum(SAFEARRAY **ppsa, /*[out, retval]*/ long *pSum) { assert(ppsa && *ppsa && pSum); assert(SafeArrayGetDim(*ppsa) == 1); long ubound, lbound; HRESULT hr = SafeArrayGetUBound(*ppsa, 1, &ubound); assert(SUCCEEDED(hr)); hr = SafeArrayGetLBound(*ppsa, 1, &lbound); assert(SUCCEEDED(hr)); long *prgn; hr = SafeArrayAccessData(*ppsa, (void**)&prgn); assert(SUCCEEDED(hr)); *pSum = 0; for (long i = lbound; i <= ubound; i++) *pSum += prgn[i]; SafeArrayUnaccessData(*ppsa); return S_OK; }