msvcrt: Replace inline static with static inline.
[wine] / dlls / oleaut32 / ole2disp.c
1 /*
2  *      OLE2DISP library
3  *
4  *      Copyright 1995  Martin von Loewis
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include "config.h"
22
23 #include <stdarg.h>
24 #include <string.h>
25
26 #include "wine/windef16.h"
27 #include "windef.h"
28 #include "winbase.h"
29 #include "wingdi.h"
30 #include "winuser.h"
31 #include "ole2.h"
32 #include "oleauto.h"
33 #include "winerror.h"
34
35 #include "ole2disp.h"
36
37 #include "wine/debug.h"
38
39 WINE_DEFAULT_DEBUG_CHANNEL(ole);
40
41 /* This implementation of the BSTR API is 16-bit only. It
42    represents BSTR as a 16:16 far pointer, and the strings
43    as ISO-8859 */
44
45 /******************************************************************************
46  *              BSTR_AllocBytes [Internal]
47  */
48 static BSTR16 BSTR_AllocBytes(int n)
49 {
50     void *ptr = HeapAlloc( GetProcessHeap(), 0, n );
51     return (BSTR16)MapLS(ptr);
52 }
53
54 /******************************************************************************
55  * BSTR_Free [INTERNAL]
56  */
57 static void BSTR_Free(BSTR16 in)
58 {
59     void *ptr = MapSL( (SEGPTR)in );
60     UnMapLS( (SEGPTR)in );
61     HeapFree( GetProcessHeap(), 0, ptr );
62 }
63
64 /******************************************************************************
65  * BSTR_GetAddr [INTERNAL]
66  */
67 static void* BSTR_GetAddr(BSTR16 in)
68 {
69     return in ? MapSL((SEGPTR)in) : 0;
70 }
71
72 /******************************************************************************
73  *              SysAllocString  [OLE2DISP.2]
74  *
75  * Create a BSTR16 from an OLESTR16 (16 Bit).
76  *
77  * PARAMS
78  *  oleStr [I] Source to create BSTR16 from
79  *
80  * RETURNS
81  *  Success: A BSTR16 allocated with SysAllocStringLen16().
82  *  Failure: NULL, if oleStr is NULL.
83  */
84 BSTR16 WINAPI SysAllocString16(LPCOLESTR16 oleStr)
85 {
86         BSTR16 out;
87
88         if (!oleStr) return 0;
89
90         out = BSTR_AllocBytes(strlen(oleStr)+1);
91         if (!out) return 0;
92         strcpy(BSTR_GetAddr(out),oleStr);
93         return out;
94 }
95
96 /******************************************************************************
97  *              SysReallocString        [OLE2DISP.3]
98  *
99  * Change the length of a previously created BSTR16 (16 Bit).
100  *
101  * PARAMS
102  *  pbstr  [I] BSTR16 to change the length of
103  *  oleStr [I] New source for pbstr
104  *
105  * RETURNS
106  *  Success: 1
107  *  Failure: 0.
108  *
109  * NOTES
110  *  SysAllocStringStringLen16().
111  */
112 INT16 WINAPI SysReAllocString16(LPBSTR16 pbstr,LPCOLESTR16 oleStr)
113 {
114         BSTR16 new=SysAllocString16(oleStr);
115         BSTR_Free(*pbstr);
116         *pbstr=new;
117         return 1;
118 }
119
120 /******************************************************************************
121  *              SysAllocStringLen       [OLE2DISP.4]
122  *
123  * Create a BSTR16 from an OLESTR16 of a given character length (16 Bit).
124  *
125  * PARAMS
126  *  oleStr [I] Source to create BSTR16 from
127  *  len    [I] Length of oleStr in wide characters
128  *
129  * RETURNS
130  *  Success: A newly allocated BSTR16 from SysAllocStringByteLen16()
131  *  Failure: NULL, if len is >= 0x80000000, or memory allocation fails.
132  *
133  * NOTES
134  *  See SysAllocStringByteLen16().
135  */
136 BSTR16 WINAPI SysAllocStringLen16(const char *oleStr, int len)
137 {
138         BSTR16 out=BSTR_AllocBytes(len+1);
139
140         if (!out)
141                 return 0;
142
143     /*
144      * Copy the information in the buffer.
145      * Since it is valid to pass a NULL pointer here, we'll initialize the
146      * buffer to nul if it is the case.
147      */
148     if (oleStr != 0)
149         strcpy(BSTR_GetAddr(out),oleStr);
150     else
151       memset(BSTR_GetAddr(out), 0, len+1);
152
153         return out;
154 }
155
156 /******************************************************************************
157  *              SysReAllocStringLen     [OLE2DISP.5]
158  *
159  * Change the length of a previously created BSTR16 (16 Bit).
160  *
161  * PARAMS
162  *  pbstr  [I] BSTR16 to change the length of
163  *  oleStr [I] New source for pbstr
164  *  len    [I] Length of oleStr in characters
165  *
166  * RETURNS
167  *  Success: 1. The size of pbstr is updated.
168  *  Failure: 0, if len >= 0x8000 or memory allocation fails.
169  *
170  * NOTES
171  *  See SysAllocStringByteLen16().
172  *  *pbstr may be changed by this function.
173  */
174 int WINAPI SysReAllocStringLen16(BSTR16 *old,const char *in,int len)
175 {
176         /* FIXME: Check input length */
177         BSTR16 new=SysAllocStringLen16(in,len);
178         BSTR_Free(*old);
179         *old=new;
180         return 1;
181 }
182
183 /******************************************************************************
184  *              SysFreeString   [OLE2DISP.6]
185  *
186  * Free a BSTR16 (16 Bit).
187  *
188  * PARAMS
189  *  str [I] String to free.
190  *
191  * RETURNS
192  *  Nothing.
193  */
194 void WINAPI SysFreeString16(BSTR16 str)
195 {
196         BSTR_Free(str);
197 }
198
199 /******************************************************************************
200  *              SysStringLen    [OLE2DISP.7]
201  *
202  * Get the allocated length of a BSTR16 in characters (16 Bit).
203  *
204  * PARAMS
205  *  str [I] BSTR16 to find the length of
206  *
207  * RETURNS
208  *  The allocated length of str, or 0 if str is NULL.
209  */
210 int WINAPI SysStringLen16(BSTR16 str)
211 {
212         return strlen(BSTR_GetAddr(str));
213 }
214
215 /******************************************************************************
216  * CreateDispTypeInfo [OLE2DISP.31]
217  */
218 HRESULT WINAPI CreateDispTypeInfo16(
219         INTERFACEDATA *pidata,
220         LCID lcid,
221         ITypeInfo **pptinfo)
222 {
223         FIXME("(%p,%d,%p),stub\n",pidata,lcid,pptinfo);
224         return E_NOTIMPL;
225 }
226
227 /******************************************************************************
228  * CreateStdDispatch [OLE2DISP.32]
229  */
230 HRESULT WINAPI CreateStdDispatch16(
231         IUnknown* punkOuter,
232         void* pvThis,
233         ITypeInfo* ptinfo,
234         IUnknown** ppunkStdDisp)
235 {
236         FIXME("(%p,%p,%p,%p),stub\n",punkOuter, pvThis, ptinfo,
237                ppunkStdDisp);
238         return 0;
239 }
240
241 /******************************************************************************
242  * RegisterActiveObject [OLE2DISP.35]
243  */
244 HRESULT WINAPI RegisterActiveObject16(
245         IUnknown *punk, REFCLSID rclsid, DWORD dwFlags, unsigned long *pdwRegister
246 ) {
247         FIXME("(%p,%s,0x%08x,%p):stub\n",punk,debugstr_guid(rclsid),dwFlags,pdwRegister);
248         return E_NOTIMPL;
249 }