Home | History | Annotate | Download | only in Common 
      1 // MyWindows.cpp
      2 
      3 #include "StdAfx.h"
      4 
      5 #ifndef _WIN32
      6 
      7 #include <stdlib.h>
      8 
      9 #include "MyWindows.h"
     10 
     11 static inline void *AllocateForBSTR(size_t cb) { return ::malloc(cb); }
     12 static inline void FreeForBSTR(void *pv) { ::free(pv);}
     13 
     14 /* Win32 uses DWORD (32-bit) type to store size of string before (OLECHAR *) string.
     15   We must select CBstrSizeType for another systems (not Win32):
     16 
     17     if (CBstrSizeType is UINT32),
     18           then we support only strings smaller than 4 GB.
     19           Win32 version always has that limitation.
     20 
     21     if (CBstrSizeType is UINT),
     22           (UINT can be 16/32/64-bit)
     23           We can support strings larger than 4 GB (if UINT is 64-bit),
     24           but sizeof(UINT) can be different in parts compiled by
     25           different compilers/settings,
     26           and we can't send such BSTR strings between such parts.
     27 */
     28 
     29 typedef UINT32 CBstrSizeType;
     30 // typedef UINT CBstrSizeType;
     31 
     32 #define k_BstrSize_Max 0xFFFFFFFF
     33 // #define k_BstrSize_Max UINT_MAX
     34 // #define k_BstrSize_Max ((UINT)(INT)-1)
     35 
     36 BSTR SysAllocStringByteLen(LPCSTR s, UINT len)
     37 {
     38   /* Original SysAllocStringByteLen in Win32 maybe fills only unaligned null OLECHAR at the end.
     39      We provide also aligned null OLECHAR at the end. */
     40 
     41   if (len >= (k_BstrSize_Max - sizeof(OLECHAR) - sizeof(OLECHAR) - sizeof(CBstrSizeType)))
     42     return NULL;
     43 
     44   UINT size = (len + sizeof(OLECHAR) + sizeof(OLECHAR) - 1) & ~(sizeof(OLECHAR) - 1);
     45   void *p = AllocateForBSTR(size + sizeof(CBstrSizeType));
     46   if (!p)
     47     return NULL;
     48   *(CBstrSizeType *)p = (CBstrSizeType)len;
     49   BSTR bstr = (BSTR)((CBstrSizeType *)p + 1);
     50   if (s)
     51     memcpy(bstr, s, len);
     52   for (; len < size; len++)
     53     ((Byte *)bstr)[len] = 0;
     54   return bstr;
     55 }
     56 
     57 BSTR SysAllocStringLen(const OLECHAR *s, UINT len)
     58 {
     59   if (len >= (k_BstrSize_Max - sizeof(OLECHAR) - sizeof(CBstrSizeType)) / sizeof(OLECHAR))
     60     return NULL;
     61 
     62   UINT size = len * sizeof(OLECHAR);
     63   void *p = AllocateForBSTR(size + sizeof(CBstrSizeType) + sizeof(OLECHAR));
     64   if (!p)
     65     return NULL;
     66   *(CBstrSizeType *)p = (CBstrSizeType)size;
     67   BSTR bstr = (BSTR)((CBstrSizeType *)p + 1);
     68   if (s)
     69     memcpy(bstr, s, size);
     70   bstr[len] = 0;
     71   return bstr;
     72 }
     73 
     74 BSTR SysAllocString(const OLECHAR *s)
     75 {
     76   if (!s)
     77     return 0;
     78   const OLECHAR *s2 = s;
     79   while (*s2 != 0)
     80     s2++;
     81   return SysAllocStringLen(s, (UINT)(s2 - s));
     82 }
     83 
     84 void SysFreeString(BSTR bstr)
     85 {
     86   if (bstr)
     87     FreeForBSTR((CBstrSizeType *)bstr - 1);
     88 }
     89 
     90 UINT SysStringByteLen(BSTR bstr)
     91 {
     92   if (!bstr)
     93     return 0;
     94   return *((CBstrSizeType *)bstr - 1);
     95 }
     96 
     97 UINT SysStringLen(BSTR bstr)
     98 {
     99   if (!bstr)
    100     return 0;
    101   return *((CBstrSizeType *)bstr - 1) / sizeof(OLECHAR);
    102 }
    103 
    104 
    105 HRESULT VariantClear(VARIANTARG *prop)
    106 {
    107   if (prop->vt == VT_BSTR)
    108     SysFreeString(prop->bstrVal);
    109   prop->vt = VT_EMPTY;
    110   return S_OK;
    111 }
    112 
    113 HRESULT VariantCopy(VARIANTARG *dest, const VARIANTARG *src)
    114 {
    115   HRESULT res = ::VariantClear(dest);
    116   if (res != S_OK)
    117     return res;
    118   if (src->vt == VT_BSTR)
    119   {
    120     dest->bstrVal = SysAllocStringByteLen((LPCSTR)src->bstrVal,
    121         SysStringByteLen(src->bstrVal));
    122     if (!dest->bstrVal)
    123       return E_OUTOFMEMORY;
    124     dest->vt = VT_BSTR;
    125   }
    126   else
    127     *dest = *src;
    128   return S_OK;
    129 }
    130 
    131 LONG CompareFileTime(const FILETIME* ft1, const FILETIME* ft2)
    132 {
    133   if (ft1->dwHighDateTime < ft2->dwHighDateTime) return -1;
    134   if (ft1->dwHighDateTime > ft2->dwHighDateTime) return 1;
    135   if (ft1->dwLowDateTime < ft2->dwLowDateTime) return -1;
    136   if (ft1->dwLowDateTime > ft2->dwLowDateTime) return 1;
    137   return 0;
    138 }
    139 
    140 DWORD GetLastError()
    141 {
    142   return 0;
    143 }
    144 
    145 #endif
    146