void CSlotConnect::ApplyRangeLink2Slot(CSlot & S, COleVariant &V)
{
// Apply Range COMING into Link
if (S.m_Range.m_bValid)
{
// Apply Range before going to Link
if (IsFloatDataVT(V.vt))
{
HRESULT hr=VariantChangeType(&V, &V, 0, VT_R8);
if (FAILED(hr))
S.SetError(SErr_ApplyRangeLink2Slot, hr, "");
V.dblVal=(V.dblVal-S.m_Range.m_dMin)/(S.m_Range.m_dMax-S.m_Range.m_dMin);
}
else if (IsSignedDataVT(V.vt))
{
HRESULT hr=VariantChangeType(&V, &V, 0, VT_I4);
if (FAILED(hr))
S.SetError(SErr_ApplyRangeLink2Slot, hr, "");
V.lVal=(V.lVal-(long)S.m_Range.m_dMin)/(long)(S.m_Range.m_dMax-S.m_Range.m_dMin);
}
else if (IsUnsignedDataVT(V.vt))
{
HRESULT hr=VariantChangeType(&V, &V, 0, VT_UI4);
if (FAILED(hr))
S.SetError(SErr_ApplyRangeLink2Slot, hr, "");
V.ulVal=(V.ulVal-(unsigned long)S.m_Range.m_dMin)/(unsigned long)(S.m_Range.m_dMax-S.m_Range.m_dMin);
}
}
}
long CStringCollect::Remove(const VARIANT FAR& removeValue)
{
int nIndex = -1;
VARIANT varTemp;
VariantInit(&varTemp);
const VARIANT* pvar = &removeValue;
if (removeValue.vt != VT_BSTR)
{
if (VariantChangeType(&varTemp, (VARIANT*)&removeValue, 0, VT_I4) == NOERROR)
pvar = &varTemp;
else if (VariantChangeType(&varTemp, (VARIANT*)&removeValue, 0, VT_BSTR) == NOERROR)
pvar = &varTemp;
else
AfxThrowOleException(DISP_E_TYPEMISMATCH);
}
if (pvar->vt == VT_BSTR)
nIndex = (int)Find(CString(pvar->bstrVal));
else if (pvar->vt == VT_I4)
nIndex = (int)pvar->lVal;
VariantClear(&varTemp);
CheckIndex(nIndex);
m_strArray.RemoveAt(nIndex);
return (long)m_strArray.GetSize();
}
static HRESULT WINAPI WshShell3_Run(IWshShell3 *iface, BSTR cmd, VARIANT *style, VARIANT *WaitOnReturn, int *exit_code)
{
SHELLEXECUTEINFOW info;
int waitforprocess;
VARIANT s, w;
HRESULT hr;
TRACE("(%s %s %s %p)\n", debugstr_w(cmd), debugstr_variant(style), debugstr_variant(WaitOnReturn), exit_code);
VariantInit(&s);
hr = VariantChangeType(&s, style, 0, VT_I4);
if (FAILED(hr))
{
ERR("failed to convert style argument, 0x%08x\n", hr);
return hr;
}
VariantInit(&w);
hr = VariantChangeType(&w, WaitOnReturn, 0, VT_I4);
if (FAILED(hr))
{
ERR("failed to convert wait argument, 0x%08x\n", hr);
return hr;
}
memset(&info, 0, sizeof(info));
info.cbSize = sizeof(info);
waitforprocess = V_I4(&w);
info.fMask = waitforprocess ? SEE_MASK_NOASYNC | SEE_MASK_NOCLOSEPROCESS : SEE_MASK_DEFAULT;
info.lpFile = cmd;
info.nShow = V_I4(&s);
if (!ShellExecuteExW(&info))
{
TRACE("ShellExecute failed, %d\n", GetLastError());
return HRESULT_FROM_WIN32(GetLastError());
}
else
{
if (waitforprocess)
{
if (exit_code)
{
DWORD code;
GetExitCodeProcess(info.hProcess, &code);
*exit_code = code;
}
CloseHandle(info.hProcess);
}
else
if (exit_code) *exit_code = 0;
return S_OK;
}
}
static HRESULT WINAPI httprequest_open(IXMLHTTPRequest *iface, BSTR method, BSTR url,
VARIANT async, VARIANT user, VARIANT password)
{
httprequest *This = impl_from_IXMLHTTPRequest( iface );
HRESULT hr;
VARIANT str, is_async;
TRACE("(%p)->(%s %s %s)\n", This, debugstr_w(method), debugstr_w(url),
debugstr_variant(&async));
if (!method || !url) return E_INVALIDARG;
/* free previously set data */
SysFreeString(This->url);
SysFreeString(This->user);
SysFreeString(This->password);
This->url = This->user = This->password = NULL;
if (lstrcmpiW(method, MethodGetW) == 0)
{
This->verb = BINDVERB_GET;
}
else if (lstrcmpiW(method, MethodPutW) == 0)
{
This->verb = BINDVERB_PUT;
}
else if (lstrcmpiW(method, MethodPostW) == 0)
{
This->verb = BINDVERB_POST;
}
else
{
FIXME("unsupported request type %s\n", debugstr_w(method));
This->verb = -1;
return E_FAIL;
}
This->url = SysAllocString(url);
VariantInit(&is_async);
hr = VariantChangeType(&is_async, &async, 0, VT_BOOL);
This->async = hr == S_OK && V_BOOL(&is_async) == VARIANT_TRUE;
VariantInit(&str);
hr = VariantChangeType(&str, &user, 0, VT_BSTR);
if (hr == S_OK)
This->user = V_BSTR(&str);
hr = VariantChangeType(&str, &password, 0, VT_BSTR);
if (hr == S_OK)
This->password = V_BSTR(&str);
httprequest_setreadystate(This, READYSTATE_LOADING);
return S_OK;
}
STDMETHODIMP CDrawMenu::Popup(/*[in, optional] */VARIANT X, /*[in, optional] */VARIANT Y)
{
USES_CONVERSION;
int nCount = m_arrItems.GetSize();
if (nCount == 0)
return S_FALSE;
HMENU hMenu = CreatePopupMenu();
if (hMenu == NULL)
return E_FAIL;
int nIndex = 0;
AddMenuItems(hMenu, nIndex, 0);
HWND hWndParent = GetClientWindow();
POINT pt;
GetCursorPos(&pt);
ScreenToClient(hWndParent, &pt);
if (X.vt != VT_ERROR)
{
VariantChangeType(&X, &X, 0, VT_I4);
pt.x = X.intVal;
}
if (Y.vt != VT_ERROR)
{
VariantChangeType(&Y, &Y, 0, VT_I4);
pt.y = Y.intVal;
}
ClientToScreen(hWndParent, &pt);
Fire_Event(2);
// 2011.4.25: 鼠标按下时弹出菜单时，释放鼠标捕获
SetCapture(FALSE);
int nRet = TrackPopupMenu(hMenu, TPM_LEFTALIGN | TPM_TOPALIGN | TPM_NONOTIFY | TPM_RETURNCMD,
pt.x, pt.y, 0, hWndParent, 0);
if (nRet > 0 && nRet <= m_arrItems.GetSize())
{
CMenuItem& item = m_arrItems[nRet - 1];
Fire_MenuClick(nRet, item.m_bstrID);
}
DestroyMenu(hMenu);
Fire_Event(3);
return S_OK;
}
STDMETHODIMP CPoint::SetCoords2(/*[in]*/ VARIANT x, /*[in]*/ VARIANT y) {
VARIANT vx, vy;
VariantInit(&vx);
VariantInit(&vy);
VariantChangeType(&vx, &x, 0, VT_I4);
VariantChangeType(&vy, &y, 0, VT_I4);
m_x = vx.lVal;
m_y = vy.lVal;
VariantClear(&vx);
VariantClear(&vy);
return S_OK;
}
STDMETHODIMP CZ80Assembler::AddDefine(BSTR bstrName, VARIANT varValue)
{
if (V_VT(&varValue) == VT_EMPTY || V_VT(&varValue) == VT_ERROR)
{
V_VT(&varValue) = VT_UI4;
V_UI4(&varValue) = 1;
}
VARIANT varDefine;
VariantInit(&varDefine);
V_VT(&varDefine) = VT_BSTR;
V_BSTR(&varDefine) = SysAllocString(L"");
HRESULT hr = VariantChangeType(&varDefine, &varValue, 0, VT_BSTR);
if (FAILED(hr))
{
return hr;
}
CW2A szName(bstrName);
bool fRedefined = false;
define_t *define = add_define(strdup(szName), &fRedefined);
if (define != NULL)
{
CW2A szContents(V_BSTR(&varDefine));
define->contents = strdup(szContents);
return S_OK;
}
else
{
return E_FAIL;
}
}
/**
* Converts the data to a Enum Variant object and then returns it as a Dispatch
*/
JNIEXPORT jobject JNICALL Java_com_tangram_Variant_toEnumVariant(JNIEnv *env, jobject _this)
{
VARIANT *v = extractVariant(env, _this);
if (v)
{
HRESULT hr;
if (FAILED(hr = VariantChangeType(v, v, 0, VT_UNKNOWN))) {
ThrowComFail(env, "VariantChangeType failed", hr);
return NULL;
}
jclass autoClass = env->FindClass("com/tangram/EnumVariant");
jmethodID autoCons =
env->GetMethodID(autoClass, "<init>", "(J)V");
// construct an Unknown object to return
IUnknown *unk = V_UNKNOWN(v);
IEnumVARIANT *ie;
hr = unk->QueryInterface(IID_IEnumVARIANT, (void **)&ie);
if (FAILED(hr)) {
ThrowComFail(env, "[toEnumVariant]: Object does not implement IEnumVariant", hr);
return NULL;
}
// I am copying the pointer to java
// SF-1674179 fix EnumVariants memory leak
// AJ: yes, but the QueryInterface call above already incremented the reference
//if (ie) ie->AddRef();
jobject newAuto = env->NewObject(autoClass, autoCons, ie);
return newAuto;
}
return NULL;
}
BOOL AFXAPI _AfxCoerceNumber(void* pvDst, VARTYPE vtDst, void* pvSrc, VARTYPE vtSrc)
{
// Check size of source.
size_t cbSrc = _AfxGetSizeOfVarType(vtSrc);
if (cbSrc == 0)
return FALSE;
// If source and destination are same type, just copy.
if (vtSrc == vtDst)
{
memcpy(pvDst, pvSrc, cbSrc);
return TRUE;
}
// Check size of destination.
size_t cbDst = _AfxGetSizeOfVarType(vtDst);
if (cbDst == 0)
return FALSE;
// Initialize variant for coercion.
VARIANTARG var;
V_VT(&var) = vtSrc;
memcpy((void*)&V_NONE(&var), pvSrc, cbSrc);
// Do the coercion.
if (FAILED(VariantChangeType(&var, &var, 0, vtDst)))
return FALSE;
// Copy result to destination.
memcpy(pvDst, (void*)&V_NONE(&var), cbDst);
return TRUE;
}
HRESULT CModuleConfiguration::GetDWORD(IAppHostElement* section, LPCWSTR propertyName, DWORD* value)
{
HRESULT hr = S_OK;
BSTR sysPropertyName = NULL;
IAppHostProperty* prop = NULL;
VARIANT var;
CheckNull(value);
*value = 0;
VariantInit(&var);
ErrorIf(NULL == (sysPropertyName = SysAllocString(propertyName)), ERROR_NOT_ENOUGH_MEMORY);
CheckError(section->GetPropertyByName(sysPropertyName, &prop));
CheckError(prop->get_Value(&var));
CheckError(VariantChangeType(&var, &var, 0, VT_UI4));
*value = var.ulVal;
Error:
VariantClear(&var);
if ( sysPropertyName )
{
SysFreeString(sysPropertyName);
sysPropertyName = NULL;
}
if (prop)
{
prop->Release();
prop = NULL;
}
return hr;
}
//------------------------------------------------------------------------//
BOOL CBCGPGlobalUtils::CyFromString(CY& cy, LPCTSTR psz)
{
USES_CONVERSION;
if (psz == NULL || _tcslen (psz) == 0)
{
psz = _T("0");
}
VARIANTARG varBstr;
VARIANTARG varCy;
AfxVariantInit(&varBstr);
AfxVariantInit(&varCy);
V_VT(&varBstr) = VT_BSTR;
V_BSTR(&varBstr) = SysAllocString(T2COLE(psz));
if (FAILED(VariantChangeType(&varCy, &varBstr, 0, VT_CY)))
{
VariantClear(&varBstr);
VariantClear(&varCy);
return FALSE;
}
cy = V_CY(&varCy);
VariantClear(&varBstr);
VariantClear(&varCy);
return TRUE;
}
STDMETHODIMP CPmcDB::readArchiveValue(
BSTR tagName,
VARIANT date,
VARIANT * tagValue
)
{
SYSTEMTIME st;
FILETIME ft;
TAG_NAME tn;
hislog_item_t value;
VARIANT dd;
HRESULT hr;
if(date.vt != VT_DATE){
// BUGBUG: not tested
hr = VariantChangeType(&dd, &date, 0, VT_DATE);
if(FAILED(hr)){
return hr;
}
date = dd;
}
VariantTimeToSystemTime(date.date, &st);
SystemTimeToFileTime(&st, &ft);
tagname_by_textW(&tn, tagName);
queryHisData(&tn, &ft, 1, 1);
getHisData(&value);
pmc_value_to_variant(&value, tagValue);
return S_OK;
}
/**
* changes the type of the underlying variant data
* */
JNIEXPORT void JNICALL Java_com_tangram_Variant_changeVariantType(JNIEnv *env, jobject _this, jshort t)
{
VARIANT *v = extractVariant(env, _this);
if (v) {
VariantChangeType(v, v, 0, t);
}
}
HRESULT dhEnumNextObject(IEnumVARIANT * pEnum, IDispatch ** ppDisp)
{
VARIANT vtResult;
HRESULT hr;
DH_ENTER(L"EnumNextObject");
if (!pEnum || !ppDisp) return DH_EXIT(E_INVALIDARG, L"Enumerator");
hr = pEnum->lpVtbl->Next(pEnum, 1, &vtResult, NULL);
if (hr == S_OK)
{
if (vtResult.vt == VT_DISPATCH)
{
*ppDisp = vtResult.pdispVal;
}
else
{
hr = VariantChangeType(&vtResult, &vtResult, 0, VT_DISPATCH);
if (SUCCEEDED(hr)) *ppDisp = vtResult.pdispVal;
else VariantClear(&vtResult);
}
}
return DH_EXIT(hr, L"Enumerator");
}
/******************************************************************************
* DispGetParam (OLEAUT32.28)
*
* Retrieve a parameter from a DISPPARAMS structure and coerce it to the
* specified variant type.
*
* NOTES
* Coercion is done using system (0) locale.
*
* RETURNS
* Success: S_OK.
* Failure: DISP_E_PARAMNOTFOUND, if position is invalid. or
* DISP_E_TYPEMISMATCH, if the coercion failed. puArgErr is
* set to the index of the argument in pdispparams.
*/
HRESULT WINAPI DispGetParam(
DISPPARAMS *pdispparams, /* [in] Parameter list */
UINT position, /* [in] Position of parameter to coerce in pdispparams */
VARTYPE vtTarg, /* [in] Type of value to coerce to */
VARIANT *pvarResult, /* [out] Destination for resulting variant */
UINT *puArgErr) /* [out] Destination for error code */
{
/* position is counted backwards */
UINT pos;
HRESULT hr;
TRACE("position=%d, cArgs=%d, cNamedArgs=%d\n",
position, pdispparams->cArgs, pdispparams->cNamedArgs);
if (position < pdispparams->cArgs) {
/* positional arg? */
pos = pdispparams->cArgs - position - 1;
} else {
/* FIXME: is this how to handle named args? */
for (pos=0; pos<pdispparams->cNamedArgs; pos++)
if (pdispparams->rgdispidNamedArgs[pos] == position) break;
if (pos==pdispparams->cNamedArgs)
return DISP_E_PARAMNOTFOUND;
}
hr = VariantChangeType(pvarResult,
&pdispparams->rgvarg[pos],
0, vtTarg);
if (hr == DISP_E_TYPEMISMATCH) *puArgErr = pos;
return hr;
}
/******************************************************************************
* *
* Function: zbx_wmi_get *
* *
* Purpose: wrapper function for zbx_wmi_get_variant(), stores the retrieved *
* WMI value as UTF-8 encoded string *
* *
* Parameters: wmi_namespace [IN] - object path of the WMI namespace (UTF-8) *
* wmi_query [IN] - WQL query (UTF-8) *
* utf8_value [OUT] - address of the pointer to the retrieved *
* value (dynamically allocated) *
* *
* Comments: if either retrieval or type conversion failed then *utf8_value *
* remains unchanged (set it to NULL before calling this function *
* to check for this condition). Callers must free *utf8_value. *
* *
******************************************************************************/
extern "C" void zbx_wmi_get(const char *wmi_namespace, const char *wmi_query, char **utf8_value)
{
VARIANT vtProp;
HRESULT hres;
VariantInit(&vtProp);
if (SUCCEED != zbx_co_initialize())
{
zabbix_log(LOG_LEVEL_DEBUG, "cannot initialize COM library for querying WMI");
goto out;
}
if (SYSINFO_RET_FAIL == zbx_wmi_get_variant(wmi_namespace, wmi_query, &vtProp))
{
zabbix_log(LOG_LEVEL_DEBUG, "cannot get WMI result");
goto out;
}
hres = VariantChangeType(&vtProp, &vtProp, VARIANT_ALPHABOOL, VT_BSTR);
if (FAILED(hres))
{
zabbix_log(LOG_LEVEL_DEBUG, "cannot convert WMI result of type %d to VT_BSTR", vtProp.vt);
goto out;
}
*utf8_value = zbx_unicode_to_utf8((wchar_t *)_bstr_t(vtProp.bstrVal));
out:
VariantClear(&vtProp);
}
static void getStyleAttribute (IDispatch *object, std::string &style)
{
VARIANT v;
VariantInit(&v);
HRESULT hr = getDispatchProperty(object, "style", v);
if ( FAILED (hr))
return;
if (! v.vt == VT_DISPATCH)
{
VariantClear(&v);
return;
}
VARIANT v2;
VariantInit (&v2);
hr = getDispatchProperty(v.pdispVal, "cssText", v2);
if ( !FAILED(hr))
{
VARIANT result2;
VariantInit(&result2);
if ( S_OK == VariantChangeType (&result2, &v2, 0, VT_BSTR))
{
Utils::bstr2str (style, result2.bstrVal);
VariantClear (&result2);
} else {
}
VariantClear (&v2);
}
v.pdispVal->Release();
VariantClear(&v);
}
CString PropVariantToString(const PROPVARIANT& propVar)
{
USES_CONVERSION;
CString sPropValue;
variant_t varPropValue;
CStdString val;
if (SUCCEEDED(VariantChangeType(&varPropValue, (VARIANTARG*)&propVar, VARIANT_LOCALBOOL, VT_BSTR)))
sPropValue = varPropValue.bstrVal;
else
{
//VT_BLOB and VT_LPSTR are uncommon co-ercions
switch(propVar.vt)
{
case VT_BLOB:
sPropValue.Format(_T("%s"), CW2T((LPCWSTR)propVar.blob.pBlobData).operator LPWSTR());
break;
case VT_LPSTR:
val = MultiByteSupport::ACPToWide(propVar.pszVal);
sPropValue = val;
break;
case VT_LPWSTR:
sPropValue.Format(_T("%s"), CW2T(propVar.pwszVal).operator LPWSTR());
break;
case VT_FILETIME:
sPropValue = FiletimeAsString(propVar.filetime);
break;
}
}
return sPropValue;
}
static HRESULT InternalInvokeV(int invokeType, VARTYPE returnType, VARIANT * pvResult,
IDispatch * pDisp, LPOLESTR szMember, va_list * marker)
{
VARIANT vtArgs[DH_MAX_ARGS];
BOOL bFreeList[DH_MAX_ARGS];
HRESULT hr;
UINT cArgs, iArg;
DH_ENTER(L"InternalInvokeV");
hr = CreateArgumentArray(szMember, vtArgs, bFreeList, &cArgs, marker);
if (SUCCEEDED(hr))
{
hr = dhInvokeArray(invokeType, pvResult, cArgs, pDisp, szMember, &vtArgs[DH_MAX_ARGS - cArgs]);
for (iArg = DH_MAX_ARGS - cArgs;iArg < DH_MAX_ARGS;iArg++)
{
if (bFreeList[iArg]) VariantClear(&vtArgs[iArg]);
}
if (SUCCEEDED(hr) && pvResult != NULL &&
pvResult->vt != returnType && returnType != VT_EMPTY)
{
hr = VariantChangeType(pvResult, pvResult, 16 , returnType);
if (FAILED(hr)) VariantClear(pvResult);
}
}
return DH_EXIT(hr, szMember);
}
//------------------------------------------------------------------------//
BOOL CBCGPGlobalUtils::DecimalFromString(DECIMAL& decimal, LPCTSTR psz)
{
USES_CONVERSION;
if (psz == NULL || _tcslen (psz) == 0)
{
psz = _T("0");
}
VARIANTARG varBstr;
VARIANTARG varDecimal;
AfxVariantInit(&varBstr);
AfxVariantInit(&varDecimal);
V_VT(&varBstr) = VT_BSTR;
V_BSTR(&varBstr) = SysAllocString(T2COLE(psz));
if (FAILED(VariantChangeType(&varDecimal, &varBstr, 0, VT_DECIMAL)))
{
VariantClear(&varBstr);
VariantClear(&varDecimal);
return FALSE;
}
decimal = V_DECIMAL(&varDecimal);
VariantClear(&varBstr);
VariantClear(&varDecimal);
return TRUE;
}
STDMETHODIMP FbPlaylistMangerTemplate::ProcessLocationsAsync( VARIANT urls )
{
TRACK_FUNCTION();
helpers::com_array_reader helper;
if (!helper.convert(&urls))return E_INVALIDARG;
pfc::list_t<pfc::string8> url8s;
for (long i = 0; i < static_cast<long>(helper.get_count()); ++i)
{
_variant_t varUrl;
helper.get_item(i, varUrl);
if (FAILED(VariantChangeType(&varUrl, &varUrl, 0, VT_BSTR))) return E_INVALIDARG;
url8s.add_item(pfc::string8(pfc::stringcvt::string_utf8_from_wide(varUrl.bstrVal)));
}
pfc::list_const_array_t<const char*,pfc::list_t<pfc::string8> > url_list(url8s,url8s.get_count());
static_api_ptr_t<playlist_incoming_item_filter_v2>()->process_locations_async(
url_list,
playlist_incoming_item_filter_v2::op_flag_delay_ui,
NULL,
NULL,
core_api::get_main_window(),
new service_impl_t<wsh_process_locations_notify>());
return S_OK;
}
STDMETHODIMP FbPlaylistManager::AddLocations(UINT playlistIndex, VARIANT locations, VARIANT_BOOL select)
{
TRACK_FUNCTION();
bool toSelect = (select == VARIANT_TRUE);
helpers::com_array_reader helper;
if (!helper.convert(&locations)) return E_INVALIDARG;
pfc::list_t<pfc::string8> locations2;
for (long i = 0; i < static_cast<long>(helper.get_count()); ++i)
{
_variant_t varUrl;
helper.get_item(i, varUrl);
if (FAILED(VariantChangeType(&varUrl, &varUrl, 0, VT_BSTR))) return E_INVALIDARG;
locations2.add_item(pfc::string8(pfc::stringcvt::string_utf8_from_wide(varUrl.bstrVal)));
}
pfc::list_const_array_t<const char*, pfc::list_t<pfc::string8> > locations3(locations2, locations2.get_count());
static_api_ptr_t<playlist_incoming_item_filter_v2>()->process_locations_async(
locations3,
playlist_incoming_item_filter_v2::op_flag_background,
NULL,
NULL,
NULL,
new service_impl_t<js_process_locations>(playlistIndex, toSelect));
return S_OK;
}
CStdString ComConvertUtils::PropVariantToString(const PROPVARIANT& propVar)
{
CStdString sPropValue;
variant_t varPropValue;
if (SUCCEEDED(VariantChangeType(&varPropValue, (VARIANTARG*)&propVar, VARIANT_LOCALBOOL, VT_BSTR)))
sPropValue = varPropValue.bstrVal;
else
{
//VT_BLOB and VT_LPSTR are uncommon co-ercions
switch(propVar.vt)
{
case VT_BLOB:
sPropValue.Format(_T("%s"), CStdString((LPCWSTR)propVar.blob.pBlobData).c_str());
break;
case VT_LPSTR:
sPropValue.Format(_T("%hs"), propVar.pszVal);
break;
case VT_LPWSTR:
sPropValue = propVar.pwszVal;
break;
case VT_FILETIME:
sPropValue = FiletimeAsString(propVar.filetime);
break;
}
}
return sPropValue;
}
static HRESULT change_type(VARIANT *dst, VARIANT *src, VARTYPE vt, IServiceProvider *caller)
{
V_VT(dst) = VT_EMPTY;
if(caller) {
IVariantChangeType *change_type = NULL;
HRESULT hres;
hres = IServiceProvider_QueryService(caller, &SID_VariantConversion, &IID_IVariantChangeType, (void**)&change_type);
if(SUCCEEDED(hres)) {
hres = IVariantChangeType_ChangeType(change_type, dst, src, LOCALE_NEUTRAL, vt);
IVariantChangeType_Release(change_type);
return hres;
}
}
switch(vt) {
case VT_BOOL:
if(V_VT(src) == VT_BSTR) {
V_VT(dst) = VT_BOOL;
V_BOOL(dst) = V_BSTR(src) && *V_BSTR(src) ? VARIANT_TRUE : VARIANT_FALSE;
return S_OK;
}
break;
}
return VariantChangeType(dst, src, 0, vt);
}
std::string stringifyVarDesc(VARDESC* varDesc, ITypeInfo* pti)
{
CComPtr<ITypeInfo> pTypeInfo(pti);
std::ostringstream oss;
if(varDesc->varkind == VAR_CONST)
oss<< "const ";
oss<< stringifyTypeDesc(&varDesc->elemdescVar.tdesc, pTypeInfo);
CComBSTR bstrName;
HRESULT hr(pTypeInfo->GetDocumentation(varDesc->memid, &bstrName, 0, 0, 0));
if(hr)
return "UnknownName";
char ansiName[MAX_PATH];
WideCharToMultiByte(CP_ACP, 0, bstrName, bstrName.Length() + 1, ansiName, MAX_PATH, 0, 0);
oss<< ' '<< ansiName;
if(varDesc->varkind != VAR_CONST)
return oss.str();
oss<< " = ";
CComVariant variant;
hr = VariantChangeType(&variant, varDesc->lpvarValue, 0, VT_BSTR);
if(hr)
oss<< "???";
else
{
WideCharToMultiByte(CP_ACP, 0, variant.bstrVal, SysStringLen(variant.bstrVal) + 1, ansiName, MAX_PATH, 0, 0);
oss<< ansiName;
}
return oss.str();
}
static HRESULT
Async(
TkWinSendCom *obj,
VARIANT Cmd,
EXCEPINFO *pExcepInfo,
UINT *puArgErr)
{
HRESULT hr = S_OK;
VARIANT vCmd;
VariantInit(&vCmd);
hr = VariantChangeType(&vCmd, &Cmd, 0, VT_BSTR);
if (FAILED(hr)) {
Tcl_SetObjResult(obj->interp, Tcl_NewStringObj(
"invalid args: Async(command)", -1));
TkWinSend_SetExcepInfo(obj->interp, pExcepInfo);
hr = DISP_E_EXCEPTION;
}
if (SUCCEEDED(hr) && obj->interp) {
Tcl_Obj *scriptPtr = Tcl_NewUnicodeObj(vCmd.bstrVal,
(int) SysStringLen(vCmd.bstrVal));
TkWinSend_QueueCommand(obj->interp, scriptPtr);
}
VariantClear(&vCmd);
return hr;
}
static void rio_cache_write(loService *se, loUpdList *upl)
{
HRESULT *errors = upl->errors;
VARIANT *variant = upl->variant;
loTagPair *tpl = upl->tagpair;
loTagEntry *tags = se->tags;
unsigned ii, items_fail = 0, items_clamp = 0;
FILETIME ft;
VARIANT var; VARIANTINIT(&var);
loTagValue *ts;
se->driver.ldCurrentTime(&se->cactx, &ft);
// UL_INFO((LOGID, "rio_cache_write() in %d", upl->master_err));
if (!(ts = loCacheLock(se))) return;
for(ii = upl->used; ii--; tpl++, errors++, variant++)
if (tpl->tpTi)
{
loTagValue *tv = &ts[tpl->tpTi];
VARTYPE cvt = taVTYPE(&tags[tpl->tpTi].attr);
HRESULT hr;
if (V_VT(variant) != VT_EMPTY &&
V_VT(variant) != cvt &&
S_OK != (hr =
#if 0
VARIANTCHANGEt(variant, variant, upl->rctx.cta, cvt)
#else
VariantChangeType(variant, variant, 0, cvt)
#endif
))
{
*errors = LO_E_BADTYPE(hr);
items_fail = 1;
}
else if (tv->tvTi)
{
*errors = OPC_S_CLAMP;
items_fail = 1;
}
else
{
VARIANT tvmp;
tv->tvTi = tpl->tpTi;
tvmp = tv->tvValue;
tv->tvValue = *variant;
*variant = tvmp;
tv->tvState.tsTime = ft;
tv->tvState.tsError = *errors = loOPC_S_CLAMP;
tv->tvState.tsQuality = OPC_QUALITY_LOCAL_OVERRIDE;
items_clamp = 1;
}
}
loCacheUnlock(se, 0);
if (items_fail || items_clamp && loOPC_S_CLAMP != S_OK)
upl->master_err = S_FALSE;
}
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");
}
}
STDMETHODIMP CBasic::inDouble(double val)
{
m_double = val;
CComVariant varDest;
CComVariant varSource(val);
HRESULT hr = VariantChangeType(&varDest, &varSource, 0, VT_BSTR);
return S_OK;
}
STDMETHODIMP CXRecord::put_Item(VARIANT key, VARIANT newVal)
{
int i = m_pFields->FindField(key);
if(i < 0 || i >= (int)m_pFields->GetCount())
return DISP_E_BADINDEX;
return VariantChangeType(&m_arrayVariant[i], &newVal, VARIANT_ALPHABOOL, m_pFields->GetValue(i)->m_nType);
}