Fix harmless warning from g++ 4.8 in C11 mode.

[wxWidgets.git] / src / msw / ole / oleutils.cpp

diff --git a/src/msw/ole/oleutils.cpp b/src/msw/ole/oleutils.cpp
index 923504963233a7aa969236db9da7e5cf3ac01dca..421e6a9e69133687959ade8a51630537a9503da7 100644 (file)
--- a/src/msw/ole/oleutils.cpp
+++ b/src/msw/ole/oleutils.cpp
@@ -148,6 +148,19 @@ WXDLLEXPORT bool wxConvertVariantToOle(const wxVariant& variant, VARIANTARG& ole
         oleVariant.vt = VT_I4;
         oleVariant.lVal = variant.GetLong() ;
     }
+    // Original VC6 came with SDK too old to contain VARIANT::llVal declaration
+    // and there doesn't seem to be any way to test for it as Microsoft simply
+    // added it to the later version of oaidl.h without changing anything else.
+    // So assume it's not present for VC6, even though it might be if an
+    // updated SDK is used. In this case the user would need to disable this
+    // check himself.
+#if wxUSE_LONGLONG && !defined(__VISUALC6__)
+    else if (type == wxT("longlong"))
+    {
+        oleVariant.vt = VT_I8;
+        oleVariant.llVal = variant.GetLongLong().GetValue();
+    }
+#endif
     else if (type == wxT("char"))
     {
         oleVariant.vt=VT_I1;            // Signed Char
@@ -186,49 +199,62 @@ WXDLLEXPORT bool wxConvertVariantToOle(const wxVariant& variant, VARIANTARG& ole
         oleVariant.vt = VT_DISPATCH;
         oleVariant.pdispVal = (IDispatch*) variant.GetVoidPtr();
     }
-    else if (type == wxT("list") || type == wxT("stringlist"))
+    else if (type == wxT("list") || type == wxT("arrstring"))
     {
-        oleVariant.vt = VT_VARIANT | VT_ARRAY;
-
         SAFEARRAY *psa;
         SAFEARRAYBOUND saBound;
-        VARIANTARG *pvargBase;
-        VARIANTARG *pvarg;
-        int i, j;
+        bool isArrString = type == wxT("arrstring");
+        wxArrayString strings;
 
-        int iCount = variant.GetCount();
+        if (isArrString)
+            strings = variant.GetArrayString();
+        oleVariant.vt = (isArrString ? VT_BSTR : VT_VARIANT) | VT_ARRAY;
 
+        long lCount = isArrString ? strings.GetCount() : variant.GetCount();
         saBound.lLbound = 0;
-        saBound.cElements = iCount;
-
-        psa = SafeArrayCreate(VT_VARIANT, 1, &saBound);
+        saBound.cElements = lCount;
+        psa = SafeArrayCreate(isArrString ? VT_BSTR : VT_VARIANT, 1, &saBound);
         if (psa == NULL)
             return false;
 
-        SafeArrayAccessData(psa, (void**)&pvargBase);
-
-        pvarg = pvargBase;
-        for (i = 0; i < iCount; i++)
+        long i;
+        for (i = 0; i < lCount; i++)
         {
-            // copy each string in the list of strings
-            wxVariant eachVariant(variant[i]);
-            if (!wxConvertVariantToOle(eachVariant, * pvarg))
+            if (isArrString)
             {
-                // memory failure:  back out and free strings alloc'ed up to
-                // now, and then the array itself.
-                pvarg = pvargBase;
-                for (j = 0; j < i; j++)
+                wxBasicString bstr(strings[i]);
+                if ( !bstr && !strings[i].empty() )
                 {
-                    SysFreeString(pvarg->bstrVal);
-                    pvarg++;
+                    // BSTR can be NULL for empty strings but if the string was
+                    // not empty, it means we failed to allocate memory for it.
+                    break;
                 }
-                SafeArrayDestroy(psa);
-                return false;
+
+                if ( FAILED(SafeArrayPutElement(psa, &i, (BSTR)bstr)) )
+                    break;
+            }
+            else // list of wxVariants
+            {
+                VARIANT v;
+                if  ( !wxConvertVariantToOle(variant[i], v) )
+                    break;
+
+                HRESULT hr = SafeArrayPutElement(psa, &i, &v);
+
+                // SafeArrayPutElement makes a copy of an added element, so
+                // free this one.
+                VariantClear(&v);
+
+                if (FAILED(hr))
+                    break;
             }
-            pvarg++;
         }
 
-        SafeArrayUnaccessData(psa);
+        if (i < lCount) // the iteration was exited prematurely because of an error
+        {
+            SafeArrayDestroy(psa);
+            return false;
+        }
 
         oleVariant.parray = psa;
     }
@@ -350,6 +376,13 @@ wxConvertOleToVariant(const VARIANTARG& oleVariant, wxVariant& variant)
 #endif // wxUSE_DATETIME
                 break;
 
+                // See the comment before the __VISUALC6__ test above.
+#if wxUSE_LONGLONG && !defined(__VISUALC6__)
+            case VT_I8:
+                variant = wxLongLong(oleVariant.llVal);
+                break;
+#endif // wxUSE_LONGLONG
+
             case VT_I4:
                 variant = (long) oleVariant.lVal;
                 break;