![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to disphelp.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / ole20 / samples / dispdemo|
Return to disphelp.cpp CVS log | Up to [WindowsNT SDKs] / mstools / ole20 / samples / dispdemo |
1.1 root 1: /***
2: *disphelp.cpp - IDispatch helpers
3: *
4: * Copyright (C) 1992, Microsoft Corporation. All Rights Reserved.
5: * Information Contained Herein Is Proprietary and Confidential.
6: *
7: *Purpose:
8: * This file contains several useful IDispatch related utilities.
9: *
10: *****************************************************************************/
11:
12: #include <windows.h>
13: #include <ole2.h>
14: #include <dispatch.h>
15:
16: #include <stdarg.h>
17:
18: #include "disphelp.h"
19:
20: // Adjust for WIN16/WIN32 synchronization
21: #if defined(WIN32) && !defined(OLE2FINAL)
22: #define E_FAIL E_UNSPEC
23: #endif
24:
25: /* helper for DispBuildParams */
26: HRESULT PASCAL
27: CArgsOfFmt(DISPPARAMS FAR* pdispparams, char FAR* szFmt)
28: {
29: char FAR* sz;
30:
31: pdispparams->cArgs = 0;
32: pdispparams->cNamedArgs = 0;
33:
34: if(szFmt == NULL)
35: return NOERROR;
36:
37: for(sz = szFmt; *sz != '\0'; ++sz){
38: if(*sz == '&')
39: ++sz;
40:
41: switch(*sz){
42: case 'e':
43: case 'n':
44: case 'f':
45: case 'i': case 'I':
46: case 'r': case 'R':
47: case 'c':
48: case 'b':
49: case 's':
50: case 'd':
51: case 'v':
52: case 'D':
53: ++pdispparams->cArgs;
54: break;
55:
56: default:
57: return ResultFromScode(E_INVALIDARG);
58: }
59: }
60:
61: return NOERROR;
62: }
63:
64:
65: /* helper for DispBuildParams */
66: VARTYPE PASCAL
67: VtOfFmtChar(char ch)
68: {
69: switch(ch){
70: case 'e': return VT_EMPTY;
71: case 'n': return VT_NULL;
72: case 'f': return VT_BOOL;
73: case 'i': return VT_I2;
74: case 'I': return VT_I4;
75: case 'r': return VT_R4;
76: case 'R': return VT_R8;
77: case 'c': return VT_CY;
78: case 'b': return VT_BSTR;
79: case 's': return VT_ERROR;
80: case 'd': return VT_DATE;
81: case 'v': return VT_VARIANT;
82: case 'U': return VT_UNKNOWN;
83: case 'D': return VT_DISPATCH;
84: }
85:
86: // REVIEW: this is really an error
87: return VT_EMPTY;
88: }
89:
90:
91: /***
92: *PUBLIC DispBuildParams(DISPPARAMS**, UINT, DISPID*, char*, ...)
93: *Purpose:
94: * Construct a DISPPARAMS struct based on the given format string.
95: *
96: * '&' = mark the following record VT_BYREF
97: *
98: * 'e' = VT_EMPTY
99: * 'n' = VT_NULL
100: * 'f' = VT_BOOL 'f' as in flag
101: * 'i' = VT_I2
102: * 'I' = VT_I4
103: * 'r' = VT_R4
104: * 'R' = VT_R8
105: * 'c' = VT_CY
106: * 'b' = VT_BSTR
107: * 's' = VT_ERROR 's' as in scode
108: * 'd' = VT_DATE
109: * 'v' = VT_VARIANT
110: * 'D' = VT_DISPATCH
111: * 'U' = VT_UNKNOWN
112: *
113: #
114: *Entry:
115: * UNDONE
116: *
117: *Exit:
118: * UNDONE
119: *
120: ***********************************************************************/
121: extern "C" HRESULT FAR CDECL
122: DispBuildParams(
123: DISPPARAMS FAR* FAR* ppdispparams,
124: UINT cNamedArgs,
125: DISPID FAR* rgdispid,
126: char FAR* szFmt, ...)
127: {
128: int ix;
129: va_list args;
130: char FAR* sz;
131: HRESULT hresult;
132: VARIANTARG FAR* pvarg;
133:
134: VARTYPE vt, vtMode;
135: DISPPARAMS FAR* pdispparams;
136:
137:
138: pdispparams = new DISPPARAMS;
139: if(pdispparams == NULL)
140: return ResultFromScode(E_OUTOFMEMORY);
141:
142: // compute the total number of arguments represented by the format
143: // string, *and* validate the contents of the format string.
144: //
145: if((hresult = CArgsOfFmt(pdispparams, szFmt)) != NOERROR)
146: goto LFreeDispParams;
147:
148: // the total number of arguments numst be >= the number of named args.
149: //
150: if(pdispparams->cArgs < cNamedArgs){
151: hresult = ResultFromScode(E_INVALIDARG);
152: goto LFreeDispParams;
153: }
154: pdispparams->cNamedArgs = cNamedArgs;
155:
156: pdispparams->rgvarg = new VARIANTARG[pdispparams->cArgs];
157: if((pdispparams->rgvarg) == NULL){
158: hresult = ResultFromScode(E_OUTOFMEMORY);
159: goto LFreeDispParams;
160: }
161:
162: if(pdispparams->cNamedArgs == 0){
163: pdispparams->rgdispidNamedArgs = NULL;
164: }else{
165: pdispparams->rgdispidNamedArgs = new DISPID[pdispparams->cNamedArgs];
166: if((pdispparams->rgdispidNamedArgs) == NULL){
167: hresult = ResultFromScode(E_OUTOFMEMORY);
168: goto LFreeRgVarg;
169: }
170: for(UINT i = 0; i < cNamedArgs; ++i)
171: pdispparams->rgdispidNamedArgs[i] = rgdispid[cNamedArgs - i - 1];
172: }
173:
174: va_start(args, szFmt);
175: ix = pdispparams->cArgs;
176:
177: for(sz = szFmt; *sz != '\0'; ++sz){
178: --ix;
179:
180: vtMode = 0;
181: pvarg = &pdispparams->rgvarg[ix];
182:
183: if(*sz == '&'){
184: ++sz;
185: vtMode |= VT_BYREF;
186: }
187:
188: vt = VtOfFmtChar(*sz);
189:
190: if(vtMode & VT_BYREF){
191:
192: V_BYREF(pvarg) = va_arg(args, void FAR*);
193:
194: }else{
195:
196: switch(*sz){
197: case 'e': // VT_EMPTY
198: break;
199:
200: case 'n': // VT_NULL
201: V_I4(pvarg) = 0;
202: break;
203:
204: case 'I': // VT_I4
205: case 's': // VT_ERROR
206: V_I4(pvarg) = va_arg(args, long);
207: break;
208:
209: case 'f': // VT_BOOL
210: case 'i': // VT_I2
211: V_I2(pvarg) = va_arg(args, short);
212: break;
213:
214: case 'r': // VT_R4
215: V_R4(pvarg) = (float)va_arg(args, double);
216: break;
217:
218: case 'd': // VT_DATE
219: case 'R': // VT_R8
220: V_R8(pvarg) = va_arg(args, double);
221: break;
222:
223: case 'c': // VT_CY
224: V_CY(pvarg) = va_arg(args, CY);
225: break;
226:
227: case 'b': // VT_BSTR
228: //REVIEW: do we need to make a copy of this?
229: V_BSTR(pvarg) = va_arg(args, BSTR);
230: break;
231:
232: case 'v': // VT_VARIANT
233: V_VARIANTREF(pvarg) = va_arg(args, VARIANT FAR*);
234: break;
235:
236: case 'U': // VT_UNKNOWN
237: vt = VT_DISPATCH;
238: V_UNKNOWN(pvarg) = va_arg(args, IUnknown FAR*);
239: break;
240:
241: case 'D': // VT_DISPATCH
242: vt = VT_DISPATCH;
243: V_DISPATCH(pvarg) = va_arg(args, IDispatch FAR*);
244: break;
245:
246: default:
247: hresult = ResultFromScode(E_FAIL);
248: goto LFreeRgVarg;
249: }
250: }
251:
252: V_VT(pvarg) = vtMode | vt;
253: }
254:
255: *ppdispparams = pdispparams;
256:
257: return NOERROR;
258:
259:
260: LFreeRgVarg:;
261: delete pdispparams->rgvarg;
262:
263: LFreeDispParams:;
264: delete pdispparams;
265:
266: return hresult;
267: }
268:
269:
270: /***
271: *PUBLIC HRESULT DispFreeParams(DISPPARAMS*)
272: *Purpose:
273: * Free the given DISPPARAMS struct, and its contents.
274: *
275: *Entry:
276: * pdispparams = the DISPPARAMS structure to free
277: *
278: *Exit:
279: * return value = HRESULT
280: *
281: ***********************************************************************/
282: STDAPI
283: DispFreeParams(DISPPARAMS FAR* pdispparams)
284: {
285: UINT i;
286: HRESULT hresult;
287:
288: for(i = 0; i < pdispparams->cArgs; ++i){
289: if ((hresult = VariantClear(&pdispparams->rgvarg[i])) != NOERROR)
290: return hresult;
291: }
292:
293: delete pdispparams->rgvarg;
294: delete pdispparams->rgdispidNamedArgs;
295: delete pdispparams;
296:
297: return NOERROR;
298: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.