ole/ole2disp.c

   1 /*
   2  *      OLE2DISP library
   3  *
   4  *      Copyright 1995  Martin von Loewis
   5  */
   6
   7 #include <string.h>
   8 #include "windows.h"
   9 #include "ole.h"
  10 #include "ole2.h"
  11 #include "oleauto.h"
  12 #include "wtypes.h"
  13 #include "wine/obj_base.h"
  14 #include "objbase.h"
  15 #include "heap.h"
  16 #include "ldt.h"
  17 #include "debug.h"
  18
  19 /* This implementation of the BSTR API is 16-bit only. It
  20    represents BSTR as a 16:16 far pointer, and the strings
  21    as ISO-8859 */
  22
  23 /******************************************************************************
  24  *              BSTR_AllocBytes [Internal]
  25  */
  26 static BSTR16 BSTR_AllocBytes(int n)
  27 {
  28     void *ptr = SEGPTR_ALLOC(n);
  29     return (BSTR16)SEGPTR_GET(ptr);
  30 }
  31
  32 /******************************************************************************
  33  * BSTR_Free [INTERNAL]
  34  */
  35 static void BSTR_Free(BSTR16 in)
  36 {
  37     SEGPTR_FREE( PTR_SEG_TO_LIN(in) );
  38 }
  39
  40 /******************************************************************************
  41  * BSTR_GetAddr [INTERNAL]
  42  */
  43 static void* BSTR_GetAddr(BSTR16 in)
  44 {
  45     return in ? PTR_SEG_TO_LIN(in) : 0;
  46 }
  47
  48 /******************************************************************************
  49  *              SysAllocString16        [OLE2DISP.2]
  50  */
  51 BSTR16 WINAPI SysAllocString16(LPOLESTR16 in)
  52 {
  53         BSTR16 out=BSTR_AllocBytes(strlen(in)+1);
  54         if(!out)return 0;
  55         strcpy(BSTR_GetAddr(out),in);
  56         return out;
  57 }
  58
  59 /******************************************************************************
  60  *              SysAllocString32        [OLEAUT32.2]
  61  */
  62 BSTR32 WINAPI SysAllocString32(LPOLESTR32 in)
  63 {
  64     /* Delegate this to the SysAllocStringLen32 method. */
  65     return SysAllocStringLen32(in, lstrlen32W(in));
  66 }
  67
  68 /******************************************************************************
  69  *              SysReAllocString16      [OLE2DISP.3]
  70  */
  71 INT16 WINAPI SysReAllocString16(LPBSTR16 old,LPOLESTR16 in)
  72 {
  73         BSTR16 new=SysAllocString16(in);
  74         BSTR_Free(*old);
  75         *old=new;
  76         return 1;
  77 }
  78
  79 /******************************************************************************
  80  *              SysReAllocString32      [OLEAUT32.3]
  81  */
  82 INT32 WINAPI SysReAllocString32(LPBSTR32 old,LPOLESTR32 in)
  83 {
  84     /*
  85      * Sanity check
  86      */
  87     if (old==NULL)
  88       return 0;
  89
  90     /*
  91      * Make sure we free the old string.
  92      */
  93     if (*old!=NULL)
  94       SysFreeString32(*old);
  95
  96     /*
  97      * Allocate the new string
  98      */
  99     *old = SysAllocString32(in);
 100
 101      return 1;
 102 }
 103
 104 /******************************************************************************
 105  *              SysAllocStringLen16     [OLE2DISP.4]
 106  */
 107 BSTR16 WINAPI SysAllocStringLen16(char *in, int len)
 108 {
 109         BSTR16 out=BSTR_AllocBytes(len+1);
 110         if(!out)return 0;
 111         strcpy(BSTR_GetAddr(out),in);
 112         return out;
 113 }
 114
 115 /******************************************************************************
 116  *             SysAllocStringLen32     [OLEAUT32.4]
 117  *
 118  * In "Inside OLE, second edition" by Kraig Brockshmidt. In the Automation
 119  * section, he describes the DWORD value placed before the BSTR data type.
 120  * he describes it as a "DWORD count of characters". By experimenting with
 121  * a windows application, this count seems to be a DWORD count of bytes in
 122  * the string. Meaning that the count is double the number of wide
 123  * characters in the string.
 124  */
 125 BSTR32 WINAPI SysAllocStringLen32(WCHAR *in, int len)
 126 {
 127     DWORD  bufferSize;
 128     DWORD* newBuffer;
 129     WCHAR* stringBuffer;
 130
 131     /*
 132      * Find the lenth of the buffer passed-in in bytes.
 133      */
 134     bufferSize = len * sizeof (WCHAR);
 135
 136     /*
 137      * Allocate a new buffer to hold the string.
 138      * dont't forget to keep an empty spot at the begining of the
 139      * buffer for the character count and an extra character at the
 140      * end for the NULL.
 141      */
 142     newBuffer = (DWORD*)HeapAlloc(GetProcessHeap(),
 143                                  0,
 144                                  bufferSize + sizeof(WCHAR) + sizeof(DWORD));
 145
 146     /*
 147      * If the memory allocation failed, return a null pointer.
 148      */
 149     if (newBuffer==0)
 150       return 0;
 151
 152     /*
 153      * Copy the length of the string in the placeholder.
 154      */
 155     *newBuffer = bufferSize;
 156
 157     /*
 158      * Skip the byte count.
 159      */
 160     newBuffer++;
 161
 162     /*
 163      * Copy the information in the buffer.
 164      * Since it is valid to pass a NULL pointer here, we'll initialize the
 165      * buffer to nul if it is the case.
 166      */
 167     if (in != 0)
 168       memcpy(newBuffer, in, bufferSize);
 169     else
 170       memset(newBuffer, 0, bufferSize);
 171
 172     /*
 173      * Make sure that there is a nul character at the end of the
 174      * string.
 175      */
 176     stringBuffer = (WCHAR*)newBuffer;
 177     stringBuffer[len] = L'\0';
 178
 179     return (LPWSTR)stringBuffer;
 180 }
 181
 182 /******************************************************************************
 183  *              SysReAllocStringLen16   [OLE2DISP.5]
 184  */
 185 int WINAPI SysReAllocStringLen16(BSTR16 *old,char *in,int len)
 186 {
 187         BSTR16 new=SysAllocStringLen16(in,len);
 188         BSTR_Free(*old);
 189         *old=new;
 190         return 1;
 191 }
 192
 193
 194 /******************************************************************************
 195  *             SysReAllocStringLen32   [OLEAUT32.5]
 196  */
 197 int WINAPI SysReAllocStringLen32(BSTR32* old, WCHAR* in, int len)
 198 {
 199     /*
 200      * Sanity check
 201      */
 202     if (old==NULL)
 203       return 0;
 204
 205     /*
 206      * Make sure we free the old string.
 207      */
 208     if (*old!=NULL)
 209       SysFreeString32(*old);
 210
 211     /*
 212      * Allocate the new string
 213      */
 214     *old = SysAllocStringLen32(in, len);
 215
 216     return 1;
 217 }
 218
 219 /******************************************************************************
 220  *              SysFreeString16 [OLE2DISP.6]
 221  */
 222 void WINAPI SysFreeString16(BSTR16 in)
 223 {
 224         BSTR_Free(in);
 225 }
 226
 227 /******************************************************************************
 228  *              SysFreeString32 [OLEAUT32.6]
 229  */
 230 void WINAPI SysFreeString32(BSTR32 in)
 231 {
 232     DWORD* bufferPointer;
 233
 234     /*
 235      * We have to be careful when we free a BSTR pointer, it points to
 236      * the beginning of the string but it skips the byte count contained
 237      * before the string.
 238      */
 239     bufferPointer = (DWORD*)in;
 240
 241     bufferPointer--;
 242
 243     /*
 244      * Free the memory from it's "real" origin.
 245      */
 246     HeapFree(GetProcessHeap(), 0, bufferPointer);
 247 }
 248
 249 /******************************************************************************
 250  *              SysStringLen16  [OLE2DISP.7]
 251  */
 252 int WINAPI SysStringLen16(BSTR16 str)
 253 {
 254         return strlen(BSTR_GetAddr(str));
 255 }
 256
 257 /******************************************************************************
 258  *             SysStringLen32  [OLEAUT32.7]
 259  *
 260  * The Windows documentation states that the length returned by this function
 261  * is not necessarely the same as the length returned by the _lstrlenW method.
 262  * It is the same number that was passed in as the "len" parameter if the
 263  * string was allocated with a SysAllocStringLen method call.
 264  */
 265 int WINAPI SysStringLen32(BSTR32 str)
 266 {
 267     DWORD* bufferPointer;
 268
 269     /*
 270      * The length of the string (in bytes) is contained in a DWORD placed
 271      * just before the BSTR pointer
 272      */
 273     bufferPointer = (DWORD*)str;
 274
 275     bufferPointer--;
 276
 277     return (int)(*bufferPointer/sizeof(WCHAR));
 278 }
 279
 280 /******************************************************************************
 281  * CreateDispTypeInfo [OLE2DISP.31]
 282  */
 283 OLESTATUS WINAPI CreateDispTypeInfo(
 284         INTERFACEDATA *pidata,
 285         LCID lcid,
 286         LPVOID **pptinfo /*ITypeInfo*/
 287 ) {
 288         FIXME(ole,"(%p,%ld,%p),stub\n",pidata,lcid,pptinfo);
 289         return 0;
 290 }
 291
 292 /******************************************************************************
 293  * RegisterActiveObject [OLE2DISP.35]
 294  */
 295 OLESTATUS WINAPI RegisterActiveObject(
 296         IUnknown * punk,REFCLSID rclsid,DWORD dwFlags, DWORD * pdwRegister
 297 ) {
 298         char    buf[80];
 299         WINE_StringFromCLSID(rclsid,buf);
 300         FIXME(ole,"(%p,%s,0x%08lx,%p):stub\n",punk,buf,dwFlags,pdwRegister);
 301         return 0;
 302 }