VirtualBox

source: vbox/trunk/src/VBox/Frontends/VirtualBox/include/COMWrappers.xsl@ 18229

Last change on this file since 18229 was 17808, checked in by vboxsync, 16 years ago

FE/Qt4: not necessary
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 67.4 KB
Line 
1<?xml version="1.0"?>
2
3<!--
4/*
5 * A template to generate wrapper classes for [XP]COM interfaces (defined
6 * in XIDL) to use them in the main Qt-based GUI in platform-independent
7 * script-like manner.
8 *
9 * The generated header requires COMDefs.h and must be included from there.
10 */
11
12/*
13 Copyright (C) 2006-2008 Sun Microsystems, Inc.
14
15 This file is part of VirtualBox Open Source Edition (OSE), as
16 available from http://www.virtualbox.org. This file is free software;
17 you can redistribute it and/or modify it under the terms of the GNU
18 General Public License (GPL) as published by the Free Software
19 Foundation, in version 2 as it comes in the "COPYING" file of the
20 VirtualBox OSE distribution. VirtualBox OSE is distributed in the
21 hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
22
23 Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
24 Clara, CA 95054 USA or visit http://www.sun.com if you need
25 additional information or have any questions.
26 */
27-->
28
29<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
30<xsl:output method="text"/>
31
32<xsl:strip-space elements="*"/>
33
34
35<!--
36// helper definitions
37/////////////////////////////////////////////////////////////////////////////
38-->
39
40<!--
41 * capitalizes the first letter
42-->
43<xsl:template name="capitalize">
44 <xsl:param name="str" select="."/>
45 <xsl:value-of select="
46 concat(
47 translate(substring($str,1,1),'abcdefghijklmnopqrstuvwxyz','ABCDEFGHIJKLMNOPQRSTUVWXYZ'),
48 substring($str,2)
49 )
50 "/>
51</xsl:template>
52
53<!--
54 * uncapitalizes the first letter only if the second one is not capital
55 * otherwise leaves the string unchanged
56-->
57<xsl:template name="uncapitalize">
58 <xsl:param name="str" select="."/>
59 <xsl:choose>
60 <xsl:when test="not(contains('ABCDEFGHIJKLMNOPQRSTUVWXYZ', substring($str,2,1)))">
61 <xsl:value-of select="
62 concat(
63 translate(substring($str,1,1),'ABCDEFGHIJKLMNOPQRSTUVWXYZ','abcdefghijklmnopqrstuvwxyz'),
64 substring($str,2)
65 )
66 "/>
67 </xsl:when>
68 <xsl:otherwise>
69 <xsl:value-of select="string($str)"/>
70 </xsl:otherwise>
71 </xsl:choose>
72</xsl:template>
73
74<!--
75 * translates the string to uppercase
76-->
77<xsl:template name="uppercase">
78 <xsl:param name="str" select="."/>
79 <xsl:value-of select="
80 translate($str,'abcdefghijklmnopqrstuvwxyz','ABCDEFGHIJKLMNOPQRSTUVWXYZ')
81 "/>
82</xsl:template>
83
84
85<!--
86// templates
87/////////////////////////////////////////////////////////////////////////////
88-->
89
90
91<!--
92 * shut down all implicit templates
93-->
94<xsl:template match="*"/>
95<xsl:template match="*|/" mode="declare"/>
96<xsl:template match="*|/" mode="define"/>
97<xsl:template match="*|/" mode="end"/>
98<xsl:template match="*|/" mode="begin"/>
99
100
101<!--
102 * header
103-->
104<xsl:template match="/idl">
105
106<xsl:text>
107/*
108 * DO NOT EDIT! This is a generated file.
109 *
110 * Qt-based wrapper classes for VirtualBox Main API (COM interfaces)
111 * generated from XIDL (XML interface definition).
112 *
113 * Source : src/VBox/Main/idl/VirtualBox.xidl
114 * Generator : src/VBox/Frontends/VirtualBox/include/COMWrappers.xsl
115 *
116 * Note: this header must be included from COMDefs.h, never directly.
117 */
118</xsl:text>
119
120<!-- all enum declarations -->
121<xsl:text>
122// all enums
123
124</xsl:text>
125 <xsl:for-each select="*/enum">
126 <xsl:text>enum </xsl:text>
127 <xsl:value-of select="concat('K',@name)"/>
128 <xsl:text>&#x0A;{&#x0A;</xsl:text>
129 <xsl:for-each select="const">
130 <xsl:text> </xsl:text>
131 <xsl:value-of select="concat('K',../@name,'_',@name)"/>
132 <xsl:text> = ::</xsl:text>
133 <xsl:value-of select="concat(../@name,'_',@name)"/>
134 <xsl:text>,&#x0A;</xsl:text>
135 </xsl:for-each>
136 <xsl:text>};&#x0A;&#x0A;Q_DECLARE_METATYPE(</xsl:text>
137 <xsl:value-of select="concat('K',@name)"/>
138 <xsl:text>)&#x0A;&#x0A;</xsl:text>
139 </xsl:for-each>
140 <xsl:text>&#x0A;&#x0A;</xsl:text>
141
142 <xsl:apply-templates/>
143
144</xsl:template>
145
146
147<!--
148 * encloses |if| element's contents (unconditionally expanded by
149 * <apply-templates mode="define"/>) with #ifdef / #endif.
150 *
151 * @note this can produce an empty #if/#endif block if |if|'s children
152 * expand to nothing (such as |cpp|). I see no need to handle this situation
153 * specially.
154-->
155<xsl:template match="if" mode="define">
156 <xsl:if test="(@target='xpidl') or (@target='midl')">
157 <xsl:apply-templates select="." mode="begin"/>
158 <xsl:apply-templates mode="define"/>
159 <xsl:apply-templates select="." mode="end"/>
160 <xsl:text>&#x0A;</xsl:text>
161 </xsl:if>
162</xsl:template>
163
164
165<!--
166 * encloses |if| element's contents (unconditionally expanded by
167 * <apply-templates mode="declare"/>) with #ifdef / #endif.
168 *
169 * @note this can produce an empty #if/#endif block if |if|'s children
170 * expand to nothing (such as |cpp|). I see no need to handle this situation
171 * specially.
172-->
173<xsl:template match="if" mode="declare">
174 <xsl:if test="(@target='xpidl') or (@target='midl')">
175 <xsl:apply-templates select="." mode="begin"/>
176 <xsl:apply-templates mode="declare"/>
177 <xsl:apply-templates select="." mode="end"/>
178 <xsl:text>&#x0A;</xsl:text>
179 </xsl:if>
180</xsl:template>
181
182
183<!--
184 * |<if target="...">| element): begin and end.
185-->
186<xsl:template match="if" mode="begin">
187 <xsl:if test="@target='xpidl'">
188 <xsl:text>#if !defined (Q_WS_WIN32)&#x0A;</xsl:text>
189 </xsl:if>
190 <xsl:if test="@target='midl'">
191 <xsl:text>#if defined (Q_WS_WIN32)&#x0A;</xsl:text>
192 </xsl:if>
193</xsl:template>
194<xsl:template match="if" mode="end">
195 <xsl:if test="(@target='xpidl') or (@target='midl')">
196 <xsl:text>#endif&#x0A;</xsl:text>
197 </xsl:if>
198</xsl:template>
199
200
201<!--
202 * cpp_quote
203-->
204<xsl:template match="cpp"/>
205
206
207<!--
208 * #ifdef statement (@if attribute): begin and end
209-->
210<xsl:template match="@if" mode="begin">
211 <xsl:text>#if </xsl:text>
212 <xsl:value-of select="."/>
213 <xsl:text>&#x0A;</xsl:text>
214</xsl:template>
215<xsl:template match="@if" mode="end">
216 <xsl:text>#endif&#x0A;</xsl:text>
217</xsl:template>
218
219
220<!--
221 * libraries
222-->
223<xsl:template match="library">
224 <!-- forward declarations -->
225 <xsl:text>// forward declarations&#x0A;&#x0A;</xsl:text>
226 <xsl:for-each select="interface | collection | enumerator">
227 <xsl:text>class C</xsl:text>
228 <xsl:value-of select="substring(@name,2)"/>
229 <xsl:text>;&#x0A;</xsl:text>
230 </xsl:for-each>
231 <xsl:text>&#x0A;</xsl:text>
232 <!-- array typedefs -->
233 <xsl:text>// array typedefs&#x0A;&#x0A;</xsl:text>
234 <xsl:for-each select="interface[not(@internal='yes')]">
235 <xsl:if test="
236 (//attribute[@safearray='yes' and not(@internal='yes') and @type=current()/@name])
237 or
238 (//param[@safearray='yes' and not(../@internal='yes') and @type=current()/@name])
239 ">
240 <xsl:text>typedef QVector &lt;C</xsl:text>
241 <xsl:value-of select="substring(@name,2)"/>
242 <xsl:text>&gt; C</xsl:text>
243 <xsl:value-of select="substring(@name,2)"/>
244 <xsl:text>Vector;&#x0A;</xsl:text>
245 </xsl:if>
246 </xsl:for-each>
247 <xsl:text>&#x0A;</xsl:text>
248 <!-- wrapper declarations -->
249 <xsl:text>// wrapper declarations&#x0A;&#x0A;</xsl:text>
250 <xsl:apply-templates select="
251 if |
252 interface[not(@internal='yes')] |
253 collection[not(@internal='yes')] |
254 enumerator[not(@internal='yes')]
255 "
256 mode="declare"
257 />
258 <!-- wrapper definitions -->
259 <xsl:text>// wrapper definitions&#x0A;&#x0A;</xsl:text>
260 <xsl:apply-templates select="
261 if |
262 interface[not(@internal='yes')] |
263 collection[not(@internal='yes')] |
264 enumerator[not(@internal='yes')]
265 "
266 mode="define"
267 />
268</xsl:template>
269
270
271<!--
272 * interface declarations
273-->
274<xsl:template match="interface | collection | enumerator" mode="declare">
275
276 <xsl:text>// </xsl:text>
277 <xsl:value-of select="@name"/>
278 <xsl:text> wrapper&#x0A;&#x0A;class C</xsl:text>
279 <xsl:value-of select="substring(@name,2)"/>
280 <xsl:text> : public CInterface &lt;</xsl:text>
281 <xsl:value-of select="@name"/>
282 <!-- use the correct base if supportsErrorInfo -->
283 <xsl:call-template name="tryComposeFetchErrorInfo">
284 <xsl:with-param name="mode" select="'getBaseClassName'"/>
285 </xsl:call-template>
286 <xsl:text>&gt;&#x0A;{&#x0A;public:&#x0A;&#x0A;</xsl:text>
287
288 <!-- generate the Base typedef-->
289 <xsl:text> typedef CInterface &lt;</xsl:text>
290 <xsl:value-of select="@name"/>
291 <!-- Use the correct base if supportsErrorInfo -->
292 <xsl:call-template name="tryComposeFetchErrorInfo">
293 <xsl:with-param name="mode" select="'getBaseClassName'"/>
294 </xsl:call-template>
295 <xsl:text>&gt; Base;&#x0A;&#x0A;</xsl:text>
296
297 <xsl:if test="name()='collection'">
298 <xsl:text> // collection stuff&#x0A;&#x0A;</xsl:text>
299 <xsl:text> ULONG GetCount () const;&#x0A;</xsl:text>
300 <xsl:text> </xsl:text>
301 <xsl:apply-templates select="@type"/>
302 <xsl:text> GetItemAt (ULONG index) const;&#x0A;</xsl:text>
303 <xsl:text> </xsl:text>
304 <xsl:apply-templates select="@enumerator"/>
305 <xsl:text> Enumerate () const;&#x0A;&#x0A;</xsl:text>
306 </xsl:if>
307
308 <xsl:if test="name()='enumerator'">
309 <xsl:text> // enumerator stuff&#x0A;&#x0A;</xsl:text>
310 <xsl:text> BOOL HasMore () const;&#x0A;</xsl:text>
311 <xsl:text> </xsl:text>
312 <xsl:apply-templates select="@type"/>
313 <xsl:text> GetNext () const;&#x0A;&#x0A;</xsl:text>
314 <xsl:text> // friend wrappers&#x0A;&#x0A;</xsl:text>
315 <xsl:text> friend class CUnknown;&#x0A;</xsl:text>
316 <xsl:variable name="name" select="@name"/>
317 <xsl:variable name="parent" select=".."/>
318 <!-- for definitions inside <if> -->
319 <xsl:if test="name(..)='if'">
320 <xsl:for-each select="
321 preceding-sibling::collection | following-sibling::collection |
322 ../preceding-sibling::if[@target=$parent/@target]/collection |
323 ../following-sibling::if[@target=$parent/@target]/collection
324 ">
325 <xsl:if test="@enumerator=$name">
326 <xsl:text> friend class C</xsl:text>
327 <xsl:value-of select="substring(@name,2)"/>
328 <xsl:text>;&#x0A;</xsl:text>
329 </xsl:if>
330 </xsl:for-each>
331 </xsl:if>
332 <!-- for definitions outside <if> (i.e. inside <library>) -->
333 <xsl:if test="name(..)!='if'">
334 <xsl:for-each select="
335 preceding-sibling::collection | following-sibling::collection
336 ">
337 <xsl:if test="@enumerator=$name">
338 <xsl:text> friend class C</xsl:text>
339 <xsl:value-of select="substring(@name,2)"/>
340 <xsl:text>;&#x0A;</xsl:text>
341 </xsl:if>
342 </xsl:for-each>
343 </xsl:if>
344 </xsl:if>
345
346 <xsl:if test="name()='interface' or name()='collection'">
347 <xsl:call-template name="declareMembers"/>
348 </xsl:if>
349
350 <xsl:text>};&#x0A;&#x0A;</xsl:text>
351
352</xsl:template>
353
354<xsl:template name="declareAttributes">
355
356 <xsl:param name="iface"/>
357
358 <xsl:apply-templates select="$iface//attribute[not(@internal='yes')]" mode="declare"/>
359 <xsl:if test="$iface//attribute[not(@internal='yes')]">
360 <xsl:text>&#x0A;</xsl:text>
361 </xsl:if>
362 <!-- go to the base interface -->
363 <xsl:if test="$iface/@extends and $iface/@extends!='$unknown'">
364 <xsl:choose>
365 <!-- interfaces within library/if -->
366 <xsl:when test="name(..)='if'">
367 <xsl:call-template name="declareAttributes">
368 <xsl:with-param name="iface" select="
369 preceding-sibling::
370 *[(self::interface or self::collection) and @name=$iface/@extends] |
371 following-sibling::
372 *[(self::interface or self::collection) and @name=$iface/@extends] |
373 ../preceding-sibling::if[@target=../@target]/
374 *[(self::interface or self::collection) and @name=$iface/@extends] |
375 ../following-sibling::if[@target=../@target]/
376 *[(self::interface or self::collection) and @name=$iface/@extends]
377 "/>
378 </xsl:call-template>
379 </xsl:when>
380 <!-- interfaces within library -->
381 <xsl:otherwise>
382 <xsl:call-template name="declareAttributes">
383 <xsl:with-param name="iface" select="
384 preceding-sibling::
385 *[(self::interface or self::collection) and @name=$iface/@extends] |
386 following-sibling::
387 *[(self::interface or self::collection) and @name=$iface/@extends]
388 "/>
389 </xsl:call-template>
390 </xsl:otherwise>
391 </xsl:choose>
392 </xsl:if>
393
394</xsl:template>
395
396<xsl:template name="declareMethods">
397
398 <xsl:param name="iface"/>
399
400 <xsl:apply-templates select="$iface//method[not(@internal='yes')]" mode="declare"/>
401 <xsl:if test="$iface//method[not(@internal='yes')]">
402 <xsl:text>&#x0A;</xsl:text>
403 </xsl:if>
404 <!-- go to the base interface -->
405 <xsl:if test="$iface/@extends and $iface/@extends!='$unknown'">
406 <xsl:choose>
407 <!-- interfaces within library/if -->
408 <xsl:when test="name(..)='if'">
409 <xsl:call-template name="declareMethods">
410 <xsl:with-param name="iface" select="
411 preceding-sibling::
412 *[(self::interface or self::collection) and @name=$iface/@extends] |
413 following-sibling::
414 *[(self::interface or self::collection) and @name=$iface/@extends] |
415 ../preceding-sibling::if[@target=../@target]/
416 *[(self::interface or self::collection) and @name=$iface/@extends] |
417 ../following-sibling::if[@target=../@target]/
418 *[(self::interface or self::collection) and @name=$iface/@extends]
419 "/>
420 </xsl:call-template>
421 </xsl:when>
422 <!-- interfaces within library -->
423 <xsl:otherwise>
424 <xsl:call-template name="declareMethods">
425 <xsl:with-param name="iface" select="
426 preceding-sibling::
427 *[(self::interface or self::collection) and @name=$iface/@extends] |
428 following-sibling::
429 *[(self::interface or self::collection) and @name=$iface/@extends]
430 "/>
431 </xsl:call-template>
432 </xsl:otherwise>
433 </xsl:choose>
434 </xsl:if>
435
436</xsl:template>
437
438<xsl:template name="declareMembers">
439
440 <xsl:text> // constructors and assignments taking CUnknown and </xsl:text>
441 <xsl:text>raw iface pointer&#x0A;&#x0A;</xsl:text>
442 <!-- default constructor -->
443 <xsl:text> C</xsl:text>
444 <xsl:value-of select="substring(@name,2)"/>
445 <xsl:text> () {}&#x0A;&#x0A;</xsl:text>
446 <!-- constructor taking CWhatever -->
447 <xsl:text> template &lt;class OI, class OB&gt; explicit C</xsl:text>
448 <xsl:value-of select="substring(@name,2)"/>
449<xsl:text> (const CInterface &lt;OI, OB&gt; &amp; that)
450 {
451 attach (that.raw());
452 if (SUCCEEDED (mRC))
453 {
454 mRC = that.lastRC();
455 setErrorInfo (that.errorInfo());
456 }
457 }
458</xsl:text>
459 <xsl:text>&#x0A;</xsl:text>
460 <!-- specialization for ourselves (copy constructor) -->
461 <xsl:text> C</xsl:text>
462 <xsl:value-of select="substring(@name,2)"/>
463 <xsl:text> (const C</xsl:text>
464 <xsl:value-of select="substring(@name,2)"/>
465 <xsl:text> &amp; that) : Base (that) {}&#x0A;&#x0A;</xsl:text>
466 <!-- constructor taking a raw iface pointer -->
467 <xsl:text> template &lt;class OI&gt; explicit C</xsl:text>
468 <xsl:value-of select="substring(@name,2)"/>
469 <xsl:text> (OI * aIface) { attach (aIface); }&#x0A;&#x0A;</xsl:text>
470 <!-- specialization for ourselves -->
471 <xsl:text> explicit C</xsl:text>
472 <xsl:value-of select="substring(@name,2)"/>
473 <xsl:text> (</xsl:text>
474 <xsl:value-of select="@name"/>
475 <xsl:text> * aIface) : Base (aIface) {}&#x0A;&#x0A;</xsl:text>
476 <!-- assignment taking CWhatever -->
477 <xsl:text> template &lt;class OI, class OB&gt; C</xsl:text>
478 <xsl:value-of select="substring(@name,2)"/>
479<xsl:text> &amp; operator = (const CInterface &lt;OI, OB&gt; &amp; that)
480 {
481 attach (that.raw());
482 if (SUCCEEDED (mRC))
483 {
484 mRC = that.lastRC();
485 setErrorInfo (that.errorInfo());
486 }
487 return *this;
488 }
489</xsl:text>
490 <xsl:text>&#x0A;</xsl:text>
491 <!-- specialization for ourselves -->
492 <xsl:text> C</xsl:text>
493 <xsl:value-of select="substring(@name,2)"/>
494 <xsl:text> &amp; operator = (const C</xsl:text>
495 <xsl:value-of select="substring(@name,2)"/>
496<xsl:text> &amp; that)
497 {
498 Base::operator= (that);
499 return *this;
500 }
501</xsl:text>
502 <xsl:text>&#x0A;</xsl:text>
503 <!-- assignment taking a raw iface pointer -->
504 <xsl:text> template &lt;class OI&gt; C</xsl:text>
505 <xsl:value-of select="substring(@name,2)"/>
506<xsl:text> &amp; operator = (OI * aIface)
507 {
508 attach (aIface);
509 return *this;
510 }
511</xsl:text>
512 <xsl:text>&#x0A;</xsl:text>
513 <!-- specialization for ourselves -->
514 <xsl:text> C</xsl:text>
515 <xsl:value-of select="substring(@name,2)"/>
516 <xsl:text> &amp; operator = (</xsl:text>
517 <xsl:value-of select="@name"/>
518<xsl:text> * aIface)
519 {
520 Base::operator= (aIface);
521 return *this;
522 }
523</xsl:text>
524 <xsl:text>&#x0A;</xsl:text>
525
526 <xsl:text> // attributes (properties)&#x0A;&#x0A;</xsl:text>
527 <xsl:call-template name="declareAttributes">
528 <xsl:with-param name="iface" select="."/>
529 </xsl:call-template>
530
531 <xsl:text> // methods&#x0A;&#x0A;</xsl:text>
532 <xsl:call-template name="declareMethods">
533 <xsl:with-param name="iface" select="."/>
534 </xsl:call-template>
535
536 <xsl:text> // friend wrappers&#x0A;&#x0A;</xsl:text>
537 <xsl:text> friend class CUnknown;&#x0A;</xsl:text>
538 <xsl:variable name="name" select="@name"/>
539 <xsl:variable name="parent" select=".."/>
540 <!-- for definitions inside <if> -->
541 <xsl:if test="name(..)='if'">
542 <xsl:for-each select="
543 preceding-sibling::*[self::interface or self::collection or self::enumerator] |
544 following-sibling::*[self::interface or self::collection or self::enumerator] |
545 ../preceding-sibling::*[self::interface or self::collection or self::enumerator] |
546 ../following-sibling::*[self::interface or self::collection or self::enumerator] |
547 ../preceding-sibling::if[@target=$parent/@target]/*[self::interface or self::collection or self::enumerator] |
548 ../following-sibling::if[@target=$parent/@target]/*[self::interface or self::collection or self::enumerator]
549 ">
550 <xsl:if test="
551 ((name()='interface' or name()='collection')
552 and
553 ((name(..)!='if' and (if[@target=$parent/@target]/method/param[@type=$name]
554 or
555 if[@target=$parent/@target]/attribute[@type=$name]))
556 or
557 (.//method/param[@type=$name] or attribute[@type=$name])))
558 or
559 (name(..)='if' and (name()='collection' or name()='enumerator') and @type=$name)
560 ">
561 <xsl:text> friend class C</xsl:text>
562 <xsl:value-of select="substring(@name,2)"/>
563 <xsl:text>;&#x0A;</xsl:text>
564 </xsl:if>
565 </xsl:for-each>
566 </xsl:if>
567 <!-- for definitions outside <if> (i.e. inside <library>) -->
568 <xsl:if test="name(..)!='if'">
569 <xsl:for-each select="
570 preceding-sibling::*[self::interface or self::collection or self::enumerator] |
571 following-sibling::*[self::interface or self::collection or self::enumerator] |
572 preceding-sibling::if/*[self::interface or self::collection or self::enumerator] |
573 following-sibling::if/*[self::interface or self::collection or self::enumerator]
574 ">
575 <xsl:if test="
576 ((name()='interface' or name()='collection')
577 and
578 (.//method/param[@type=$name] or attribute[@type=$name]))
579 or
580 ((name()='collection' or name()='enumerator') and @type=$name)
581 ">
582 <xsl:text> friend class C</xsl:text>
583 <xsl:value-of select="substring(@name,2)"/>
584 <xsl:text>;&#x0A;</xsl:text>
585 </xsl:if>
586 </xsl:for-each>
587 </xsl:if>
588
589</xsl:template>
590
591<!-- attribute declarations -->
592<xsl:template match="interface//attribute | collection//attribute" mode="declare">
593 <xsl:if test="@array">
594 <xsl:message terminate="yes">
595 <xsl:value-of select="concat(../../@name,'::',../@name,'::',@name,': ')"/>
596 <xsl:text>'array' attributes are not supported, use 'safearray="yes"' instead.</xsl:text>
597 </xsl:message>
598 </xsl:if>
599 <xsl:apply-templates select="parent::node()" mode="begin"/>
600 <xsl:apply-templates select="@if" mode="begin"/>
601 <xsl:call-template name="composeMethod">
602 <xsl:with-param name="return" select="."/>
603 </xsl:call-template>
604 <xsl:if test="not(@readonly='yes')">
605 <xsl:call-template name="composeMethod">
606 <xsl:with-param name="return" select="''"/>
607 </xsl:call-template>
608 </xsl:if>
609 <xsl:apply-templates select="@if" mode="end"/>
610 <xsl:apply-templates select="parent::node()" mode="end"/>
611</xsl:template>
612
613<!-- method declarations -->
614<xsl:template match="interface//method | collection//method" mode="declare">
615 <xsl:apply-templates select="parent::node()" mode="begin"/>
616 <xsl:apply-templates select="@if" mode="begin"/>
617 <xsl:call-template name="composeMethod"/>
618 <xsl:apply-templates select="@if" mode="end"/>
619 <xsl:apply-templates select="parent::node()" mode="end"/>
620</xsl:template>
621
622
623<!--
624 * interface definitions
625-->
626<xsl:template match="interface | collection | enumerator" mode="define">
627
628 <xsl:text>// </xsl:text>
629 <xsl:value-of select="@name"/>
630 <xsl:text> wrapper&#x0A;&#x0A;</xsl:text>
631
632 <xsl:if test="name()='collection'">
633 <!-- GetCount -->
634 <xsl:text>inline ULONG C</xsl:text>
635 <xsl:value-of select="substring(@name,2)"/>
636 <xsl:text>::GetCount () const&#x0A;{&#x0A;</xsl:text>
637 <xsl:text> ULONG count = 0;&#x0A;</xsl:text>
638 <xsl:text> Assert (mIface);&#x0A;</xsl:text>
639 <xsl:text> if (!mIface)&#x0A; return count;&#x0A;</xsl:text>
640 <xsl:text> mRC = mIface->COMGETTER(Count) (&amp;count);&#x0A;</xsl:text>
641 <xsl:call-template name="tryComposeFetchErrorInfo"/>
642 <xsl:text> return count;&#x0A;</xsl:text>
643 <xsl:text>}&#x0A;&#x0A;</xsl:text>
644 <!-- GetItemAt -->
645 <xsl:text>inline </xsl:text>
646 <xsl:apply-templates select="@type"/>
647 <xsl:text> C</xsl:text>
648 <xsl:value-of select="substring(@name,2)"/>
649 <xsl:text>::GetItemAt (ULONG index) const&#x0A;{&#x0A;</xsl:text>
650 <xsl:text> </xsl:text><xsl:apply-templates select="@type"/>
651 <xsl:text> item;&#x0A;</xsl:text>
652 <xsl:text> Assert (mIface);&#x0A;</xsl:text>
653 <xsl:text> if (!mIface)&#x0A; return item;&#x0A;</xsl:text>
654 <xsl:text> mRC = mIface->GetItemAt (index, &amp;item.mIface);&#x0A;</xsl:text>
655 <xsl:call-template name="tryComposeFetchErrorInfo"/>
656 <xsl:text> return item;&#x0A;</xsl:text>
657 <xsl:text>}&#x0A;&#x0A;</xsl:text>
658 <!-- Enumerate -->
659 <xsl:text>inline </xsl:text>
660 <xsl:apply-templates select="@enumerator"/>
661 <xsl:text> C</xsl:text>
662 <xsl:value-of select="substring(@name,2)"/>
663 <xsl:text>::Enumerate () const&#x0A;{&#x0A;</xsl:text>
664 <xsl:text> </xsl:text><xsl:apply-templates select="@enumerator"/>
665 <xsl:text> enumerator;&#x0A;</xsl:text>
666 <xsl:text> Assert (mIface);&#x0A;</xsl:text>
667 <xsl:text> if (!mIface)&#x0A; return enumerator;&#x0A;</xsl:text>
668 <xsl:text> mRC = mIface->Enumerate (&amp;enumerator.mIface);&#x0A;</xsl:text>
669 <xsl:call-template name="tryComposeFetchErrorInfo"/>
670 <xsl:text> return enumerator;&#x0A;</xsl:text>
671 <xsl:text>}&#x0A;&#x0A;</xsl:text>
672 </xsl:if>
673
674 <xsl:if test="name()='enumerator'">
675 <!-- HasMore -->
676 <xsl:text>inline BOOL C</xsl:text>
677 <xsl:value-of select="substring(@name,2)"/>
678 <xsl:text>::HasMore () const&#x0A;{&#x0A;</xsl:text>
679 <xsl:text> BOOL more = FALSE;&#x0A;</xsl:text>
680 <xsl:text> Assert (mIface);&#x0A;</xsl:text>
681 <xsl:text> if (!mIface)&#x0A; return more;&#x0A;</xsl:text>
682 <xsl:text> mRC = mIface->HasMore (&amp;more);&#x0A;</xsl:text>
683 <xsl:call-template name="tryComposeFetchErrorInfo"/>
684 <xsl:text> return more;&#x0A;</xsl:text>
685 <xsl:text>}&#x0A;&#x0A;</xsl:text>
686 <!-- GetNext -->
687 <xsl:text>inline </xsl:text>
688 <xsl:apply-templates select="@type"/>
689 <xsl:text> C</xsl:text>
690 <xsl:value-of select="substring(@name,2)"/>
691 <xsl:text>::GetNext () const&#x0A;{&#x0A;</xsl:text>
692 <xsl:text> </xsl:text><xsl:apply-templates select="@type"/>
693 <xsl:text> next;&#x0A;</xsl:text>
694 <xsl:text> Assert (mIface);&#x0A;</xsl:text>
695 <xsl:text> if (!mIface)&#x0A; return next;&#x0A;</xsl:text>
696 <xsl:text> mRC = mIface->GetNext (&amp;next.mIface);&#x0A;</xsl:text>
697 <xsl:call-template name="tryComposeFetchErrorInfo"/>
698 <xsl:text> return next;&#x0A;</xsl:text>
699 <xsl:text>}&#x0A;&#x0A;</xsl:text>
700 </xsl:if>
701
702 <xsl:if test="name()='interface' or name()='collection'">
703 <xsl:call-template name="defineMembers"/>
704 </xsl:if>
705
706</xsl:template>
707
708<xsl:template name="defineAttributes">
709
710 <xsl:param name="iface"/>
711
712 <xsl:apply-templates select="$iface//attribute[not(@internal='yes')]" mode="define">
713 <xsl:with-param name="namespace" select="."/>
714 </xsl:apply-templates>
715
716 <!-- go to the base interface -->
717 <xsl:if test="$iface/@extends and $iface/@extends!='$unknown'">
718 <xsl:choose>
719 <!-- interfaces within library/if -->
720 <xsl:when test="name(..)='if'">
721 <xsl:call-template name="defineAttributes">
722 <xsl:with-param name="iface" select="
723 preceding-sibling::
724 *[(self::interface or self::collection) and @name=$iface/@extends] |
725 following-sibling::
726 *[(self::interface or self::collection) and @name=$iface/@extends] |
727 ../preceding-sibling::if[@target=../@target]/
728 *[(self::interface or self::collection) and @name=$iface/@extends] |
729 ../following-sibling::if[@target=../@target]/
730 *[(self::interface or self::collection) and @name=$iface/@extends]
731 "/>
732 </xsl:call-template>
733 </xsl:when>
734 <!-- interfaces within library -->
735 <xsl:otherwise>
736 <xsl:call-template name="defineAttributes">
737 <xsl:with-param name="iface" select="
738 preceding-sibling::
739 *[(self::interface or self::collection) and @name=$iface/@extends] |
740 following-sibling::
741 *[(self::interface or self::collection) and @name=$iface/@extends]
742 "/>
743 </xsl:call-template>
744 </xsl:otherwise>
745 </xsl:choose>
746 </xsl:if>
747
748</xsl:template>
749
750<xsl:template name="defineMethods">
751
752 <xsl:param name="iface"/>
753
754 <xsl:apply-templates select="$iface//method[not(@internal='yes')]" mode="define">
755 <xsl:with-param name="namespace" select="."/>
756 </xsl:apply-templates>
757
758 <!-- go to the base interface -->
759 <xsl:if test="$iface/@extends and $iface/@extends!='$unknown'">
760 <xsl:choose>
761 <!-- interfaces within library/if -->
762 <xsl:when test="name(..)='if'">
763 <xsl:call-template name="defineMethods">
764 <xsl:with-param name="iface" select="
765 preceding-sibling::
766 *[(self::interface or self::collection) and @name=$iface/@extends] |
767 following-sibling::
768 *[(self::interface or self::collection) and @name=$iface/@extends] |
769 ../preceding-sibling::if[@target=../@target]/
770 *[(self::interface or self::collection) and @name=$iface/@extends] |
771 ../following-sibling::if[@target=../@target]/
772 *[(self::interface or self::collection) and @name=$iface/@extends]
773 "/>
774 </xsl:call-template>
775 </xsl:when>
776 <!-- interfaces within library -->
777 <xsl:otherwise>
778 <xsl:call-template name="defineMethods">
779 <xsl:with-param name="iface" select="
780 preceding-sibling::
781 *[(self::interface or self::collection) and @name=$iface/@extends] |
782 following-sibling::
783 *[(self::interface or self::collection) and @name=$iface/@extends]
784 "/>
785 </xsl:call-template>
786 </xsl:otherwise>
787 </xsl:choose>
788 </xsl:if>
789
790</xsl:template>
791
792<xsl:template name="defineMembers">
793 <xsl:call-template name="defineAttributes">
794 <xsl:with-param name="iface" select="."/>
795 </xsl:call-template>
796 <xsl:call-template name="defineMethods">
797 <xsl:with-param name="iface" select="."/>
798 </xsl:call-template>
799</xsl:template>
800
801<!-- attribute definitions -->
802<xsl:template match="interface//attribute | collection//attribute" mode="define">
803
804 <xsl:param name="namespace" select="(ancestor::interface | ancestor::collection)[1]"/>
805
806 <xsl:apply-templates select="parent::node()" mode="begin"/>
807 <xsl:apply-templates select="@if" mode="begin"/>
808 <xsl:call-template name="composeMethod">
809 <xsl:with-param name="return" select="."/>
810 <xsl:with-param name="define" select="'yes'"/>
811 <xsl:with-param name="namespace" select="$namespace"/>
812 </xsl:call-template>
813 <xsl:if test="not(@readonly='yes')">
814 <xsl:call-template name="composeMethod">
815 <xsl:with-param name="return" select="''"/>
816 <xsl:with-param name="define" select="'yes'"/>
817 <xsl:with-param name="namespace" select="$namespace"/>
818 </xsl:call-template>
819 </xsl:if>
820 <xsl:apply-templates select="@if" mode="end"/>
821 <xsl:apply-templates select="parent::node()" mode="end"/>
822 <xsl:text>&#x0A;</xsl:text>
823
824</xsl:template>
825
826<!-- method definitions -->
827<xsl:template match="interface//method | collection//method" mode="define">
828
829 <xsl:param name="namespace" select="(ancestor::interface | ancestor::collection)[1]"/>
830
831 <xsl:apply-templates select="parent::node()" mode="begin"/>
832 <xsl:apply-templates select="@if" mode="begin"/>
833 <xsl:call-template name="composeMethod">
834 <xsl:with-param name="define" select="'yes'"/>
835 <xsl:with-param name="namespace" select="$namespace"/>
836 </xsl:call-template>
837 <xsl:apply-templates select="@if" mode="end"/>
838 <xsl:apply-templates select="parent::node()" mode="end"/>
839 <xsl:text>&#x0A;</xsl:text>
840
841</xsl:template>
842
843
844<!--
845 * co-classes
846-->
847<xsl:template match="module/class"/>
848
849
850<!--
851 * enums
852-->
853<xsl:template match="enum"/>
854
855
856<!--
857 * base template to produce interface methods
858 *
859 * @param return
860 * - in <attribute> context, must be '.' for getters and
861 * '' for setters
862 * - in <method> context, must not be specified (the default value
863 * will apply)
864 * @param define
865 * 'yes' to procuce inlined definition outside the class
866 * declaration, or
867 * empty string to produce method declaration only (w/o body)
868 * @param namespace
869 * actual interface node for which this method is being defined
870 * (necessary to properly set a class name for inherited methods).
871 * If not specified, will default to the parent interface/collection
872 * node of the method being defined.
873-->
874<xsl:template name="composeMethod">
875 <xsl:param name="return" select="param[@dir='return']"/>
876 <xsl:param name="define" select="''"/>
877 <xsl:param name="namespace" select="(ancestor::interface | ancestor::collection)[1]"/>
878 <xsl:choose>
879 <!-- no return value -->
880 <xsl:when test="not($return)">
881 <xsl:choose>
882 <xsl:when test="$define">
883 <xsl:text>inline </xsl:text>
884 </xsl:when>
885 <xsl:otherwise>
886 <xsl:text> </xsl:text>
887 </xsl:otherwise>
888 </xsl:choose>
889 <xsl:text>void </xsl:text>
890 <xsl:if test="$define">
891 <xsl:text>C</xsl:text>
892 <xsl:value-of select="substring($namespace/@name,2)"/>
893 <xsl:text>::</xsl:text>
894 </xsl:if>
895 <xsl:call-template name="composeMethodDecl">
896 <xsl:with-param name="isSetter" select="'yes'"/>
897 </xsl:call-template>
898 <xsl:if test="$define">
899 <xsl:text>&#x0A;{&#x0A;</xsl:text>
900 <!-- iface assertion -->
901 <xsl:text> Assert (mIface);&#x0A;</xsl:text>
902 <xsl:text> if (!mIface)&#x0A; return;&#x0A;</xsl:text>
903 <!-- method call -->
904 <xsl:call-template name="composeMethodCall">
905 <xsl:with-param name="isSetter" select="'yes'"/>
906 </xsl:call-template>
907 <xsl:text>}&#x0A;</xsl:text>
908 </xsl:if>
909 <xsl:if test="not($define)">
910 <xsl:text>;&#x0A;</xsl:text>
911 </xsl:if>
912 </xsl:when>
913 <!-- has a return value -->
914 <xsl:when test="count($return) = 1">
915 <xsl:choose>
916 <xsl:when test="$define">
917 <xsl:text>inline </xsl:text>
918 </xsl:when>
919 <xsl:otherwise>
920 <xsl:text> </xsl:text>
921 </xsl:otherwise>
922 </xsl:choose>
923 <xsl:apply-templates select="$return/@type"/>
924 <xsl:text> </xsl:text>
925 <xsl:if test="$define">
926 <xsl:text>C</xsl:text>
927 <xsl:value-of select="substring($namespace/@name,2)"/>
928 <xsl:text>::</xsl:text>
929 </xsl:if>
930 <xsl:call-template name="composeMethodDecl"/>
931 <xsl:if test="$define">
932 <xsl:text>&#x0A;{&#x0A; </xsl:text>
933 <xsl:apply-templates select="$return/@type"/>
934 <xsl:text> a</xsl:text>
935 <xsl:call-template name="capitalize">
936 <xsl:with-param name="str" select="$return/@name"/>
937 </xsl:call-template>
938 <xsl:apply-templates select="$return/@type" mode="initializer"/>
939 <xsl:text>;&#x0A;</xsl:text>
940 <!-- iface assertion -->
941 <xsl:text> Assert (mIface);&#x0A;</xsl:text>
942 <xsl:text> if (!mIface)&#x0A; return a</xsl:text>
943 <xsl:call-template name="capitalize">
944 <xsl:with-param name="str" select="$return/@name"/>
945 </xsl:call-template>
946 <xsl:text>;&#x0A;</xsl:text>
947 <!-- method call -->
948 <xsl:call-template name="composeMethodCall"/>
949 <!-- return statement -->
950 <xsl:text> return a</xsl:text>
951 <xsl:call-template name="capitalize">
952 <xsl:with-param name="str" select="$return/@name"/>
953 </xsl:call-template>
954 <xsl:text>;&#x0A;}&#x0A;</xsl:text>
955 </xsl:if>
956 <xsl:if test="not($define)">
957 <xsl:text>;&#x0A;</xsl:text>
958 </xsl:if>
959 </xsl:when>
960 <!-- otherwise error -->
961 <xsl:otherwise>
962 <xsl:message terminate="yes">
963 <xsl:text>More than one return value in method: </xsl:text>
964 <xsl:value-of select="$namespace/@name"/>
965 <xsl:text>::</xsl:text>
966 <xsl:value-of select="@name"/>
967 </xsl:message>
968 </xsl:otherwise>
969 </xsl:choose>
970</xsl:template>
971
972<xsl:template name="composeMethodDecl">
973 <xsl:param name="isSetter" select="''"/>
974 <xsl:choose>
975 <!-- attribute method call -->
976 <xsl:when test="name()='attribute'">
977 <xsl:choose>
978 <xsl:when test="$isSetter">
979 <!-- name -->
980 <xsl:text>Set</xsl:text>
981 <xsl:call-template name="capitalize">
982 <xsl:with-param name="str" select="@name"/>
983 </xsl:call-template>
984 <xsl:text> (</xsl:text>
985 <!-- parameter -->
986 <xsl:apply-templates select="@type" mode="param"/>
987 <xsl:text> a</xsl:text>
988 <xsl:call-template name="capitalize">
989 <xsl:with-param name="str" select="@name"/>
990 </xsl:call-template>
991 <xsl:text>)</xsl:text>
992 </xsl:when>
993 <xsl:otherwise>
994 <!-- name -->
995 <xsl:text>Get</xsl:text>
996 <xsl:call-template name="capitalize">
997 <xsl:with-param name="str" select="@name"/>
998 </xsl:call-template>
999 <xsl:text> (</xsl:text>
1000 <!-- const method -->
1001 <xsl:text>) const</xsl:text>
1002 </xsl:otherwise>
1003 </xsl:choose>
1004 </xsl:when>
1005 <!-- regular method call -->
1006 <xsl:when test="name()='method'">
1007 <!-- name -->
1008 <xsl:call-template name="capitalize">
1009 <xsl:with-param name="str" select="@name"/>
1010 </xsl:call-template>
1011 <xsl:text> (</xsl:text>
1012 <!-- parameters -->
1013 <xsl:for-each select="param[@dir!='return']">
1014 <xsl:apply-templates select="@type" mode="param"/>
1015 <xsl:text> a</xsl:text>
1016 <xsl:call-template name="capitalize">
1017 <xsl:with-param name="str" select="@name"/>
1018 </xsl:call-template>
1019 <xsl:if test="position() != last()">
1020 <xsl:text>, </xsl:text>
1021 </xsl:if>
1022 </xsl:for-each>
1023 <xsl:text>)</xsl:text>
1024 <!-- const method -->
1025 <xsl:if test="@const='yes'"> const</xsl:if>
1026 </xsl:when>
1027 </xsl:choose>
1028</xsl:template>
1029
1030<xsl:template name="composeMethodCall">
1031 <xsl:param name="isSetter" select="''"/>
1032 <!-- apply 'pre-call' hooks -->
1033 <xsl:choose>
1034 <xsl:when test="name()='attribute'">
1035 <xsl:call-template name="hooks">
1036 <xsl:with-param name="when" select="'pre-call'"/>
1037 <xsl:with-param name="isSetter" select="$isSetter"/>
1038 </xsl:call-template>
1039 </xsl:when>
1040 <xsl:when test="name()='method'">
1041 <xsl:for-each select="param">
1042 <xsl:call-template name="hooks">
1043 <xsl:with-param name="when" select="'pre-call'"/>
1044 </xsl:call-template>
1045 </xsl:for-each>
1046 </xsl:when>
1047 </xsl:choose>
1048 <!-- start the call -->
1049 <xsl:text> mRC = mIface-></xsl:text>
1050 <xsl:choose>
1051 <!-- attribute method call -->
1052 <xsl:when test="name()='attribute'">
1053 <!-- method name -->
1054 <xsl:choose>
1055 <xsl:when test="$isSetter">
1056 <xsl:text>COMSETTER(</xsl:text>
1057 </xsl:when>
1058 <xsl:otherwise>
1059 <xsl:text>COMGETTER(</xsl:text>
1060 </xsl:otherwise>
1061 </xsl:choose>
1062 <xsl:call-template name="capitalize">
1063 <xsl:with-param name="str" select="@name"/>
1064 </xsl:call-template>
1065 <xsl:text>) (</xsl:text>
1066 <!-- parameter -->
1067 <xsl:call-template name="composeMethodCallParam">
1068 <xsl:with-param name="isIn" select="$isSetter"/>
1069 <xsl:with-param name="isOut" select="not($isSetter)"/>
1070 </xsl:call-template>
1071 </xsl:when>
1072 <!-- regular method call -->
1073 <xsl:when test="name()='method'">
1074 <!-- method name -->
1075 <xsl:call-template name="capitalize">
1076 <xsl:with-param name="str" select="@name"/>
1077 </xsl:call-template>
1078 <xsl:text> (</xsl:text>
1079 <!-- parameters -->
1080 <xsl:for-each select="param">
1081 <xsl:call-template name="composeMethodCallParam"/>
1082 <xsl:if test="position() != last()">
1083 <xsl:text>, </xsl:text>
1084 </xsl:if>
1085 </xsl:for-each>
1086 </xsl:when>
1087 </xsl:choose>
1088 <xsl:text>);&#x0A;</xsl:text>
1089 <!-- apply 'post-call' hooks -->
1090 <xsl:choose>
1091 <xsl:when test="name()='attribute'">
1092 <xsl:call-template name="hooks">
1093 <xsl:with-param name="when" select="'post-call'"/>
1094 <xsl:with-param name="isSetter" select="$isSetter"/>
1095 </xsl:call-template>
1096 </xsl:when>
1097 <xsl:when test="name()='method'">
1098 <xsl:for-each select="param">
1099 <xsl:call-template name="hooks">
1100 <xsl:with-param name="when" select="'post-call'"/>
1101 </xsl:call-template>
1102 </xsl:for-each>
1103 </xsl:when>
1104 </xsl:choose>
1105 <!-- -->
1106 <xsl:call-template name="tryComposeFetchErrorInfo"/>
1107</xsl:template>
1108
1109<!--
1110 * Composes a 'fetch error info' call or returns the name of the
1111 * appropriate base class name that provides error info functionality
1112 * (depending on the mode parameter). Does nothing if the current
1113 * entity (interface, collection or enumerator) does not support error info.
1114 *
1115 * @param mode
1116 * - 'getBaseClassName': expands to the base class name
1117 * - any other value: composes a 'fetch error info' method call
1118-->
1119<xsl:template name="tryComposeFetchErrorInfo">
1120 <xsl:param name="mode" select="''"/>
1121 <xsl:variable name="ifaceSupportsErrorInfo" select="
1122 (ancestor-or-self::interface |
1123 ancestor-or-self::collection |
1124 ancestor-or-self::enumerator)[1]/@supportsErrorInfo
1125 "/>
1126 <xsl:variable name="librarySupportsErrorInfo" select="ancestor::library/@supportsErrorInfo"/>
1127 <xsl:choose>
1128 <xsl:when test="$ifaceSupportsErrorInfo">
1129 <xsl:call-template name="composeFetchErrorInfo">
1130 <xsl:with-param name="supports" select="string($ifaceSupportsErrorInfo)"/>
1131 <xsl:with-param name="mode" select="$mode"/>
1132 </xsl:call-template>
1133 </xsl:when>
1134 <xsl:when test="$librarySupportsErrorInfo">
1135 <xsl:call-template name="composeFetchErrorInfo">
1136 <xsl:with-param name="supports" select="string($librarySupportsErrorInfo)"/>
1137 <xsl:with-param name="mode" select="$mode"/>
1138 </xsl:call-template>
1139 </xsl:when>
1140 </xsl:choose>
1141</xsl:template>
1142
1143<xsl:template name="composeFetchErrorInfo">
1144 <xsl:param name="supports" select="''"/>
1145 <xsl:param name="mode" select="''"/>
1146 <xsl:choose>
1147 <xsl:when test="$mode='getBaseClassName'">
1148 <xsl:if test="$supports='strict' or $supports='yes'">
1149 <xsl:text>, COMBaseWithEI</xsl:text>
1150 </xsl:if>
1151 </xsl:when>
1152 <xsl:otherwise>
1153 <xsl:if test="$supports='strict' or $supports='yes'">
1154 <xsl:text> if (mRC != S_OK)&#x0A; {&#x0A;</xsl:text>
1155 <xsl:text> fetchErrorInfo (mIface, &amp;COM_IIDOF (Base::Iface));&#x0A;</xsl:text>
1156 <xsl:if test="$supports='strict'">
1157 <xsl:text> AssertMsg (errInfo.isFullAvailable(), </xsl:text>
1158 <xsl:text>("for RC=0x%08X\n", mRC));&#x0A;</xsl:text>
1159 </xsl:if>
1160 <xsl:text> }&#x0A;</xsl:text>
1161 </xsl:if>
1162 </xsl:otherwise>
1163 </xsl:choose>
1164</xsl:template>
1165
1166<xsl:template name="composeMethodCallParam">
1167
1168 <xsl:param name="isIn" select="@dir='in'"/>
1169 <xsl:param name="isOut" select="@dir='out' or @dir='return'"/>
1170
1171 <xsl:variable name="self_target" select="current()/ancestor::if/@target"/>
1172
1173 <xsl:choose>
1174 <!-- safearrays -->
1175 <xsl:when test="@safearray='yes'">
1176 <xsl:choose>
1177 <xsl:when test="$isIn">
1178 <xsl:text>ComSafeArrayAsInParam (</xsl:text>
1179 <xsl:value-of select="@name"/>
1180 <xsl:text>)</xsl:text>
1181 </xsl:when>
1182 <xsl:when test="$isOut">
1183 <xsl:text>ComSafeArrayAsOutParam (</xsl:text>
1184 <xsl:value-of select="@name"/>
1185 <xsl:text>)</xsl:text>
1186 </xsl:when>
1187 </xsl:choose>
1188 </xsl:when>
1189 <!-- string types -->
1190 <xsl:when test="@type = 'wstring'">
1191 <xsl:choose>
1192 <xsl:when test="$isIn">
1193 <xsl:text>BSTRIn (a</xsl:text>
1194 <xsl:call-template name="capitalize">
1195 <xsl:with-param name="str" select="@name"/>
1196 </xsl:call-template>
1197 <xsl:text>)</xsl:text>
1198 </xsl:when>
1199 <xsl:when test="$isOut">
1200 <xsl:text>BSTROut (a</xsl:text>
1201 <xsl:call-template name="capitalize">
1202 <xsl:with-param name="str" select="@name"/>
1203 </xsl:call-template>
1204 <xsl:text>)</xsl:text>
1205 </xsl:when>
1206 </xsl:choose>
1207 </xsl:when>
1208 <!-- uuid type -->
1209 <xsl:when test="@type = 'uuid'">
1210 <xsl:choose>
1211 <xsl:when test="$isIn">
1212 <xsl:text>GUIDIn (a</xsl:text>
1213 <xsl:call-template name="capitalize">
1214 <xsl:with-param name="str" select="@name"/>
1215 </xsl:call-template>
1216 <xsl:text>)</xsl:text>
1217 </xsl:when>
1218 <xsl:when test="$isOut">
1219 <xsl:text>GUIDOut (a</xsl:text>
1220 <xsl:call-template name="capitalize">
1221 <xsl:with-param name="str" select="@name"/>
1222 </xsl:call-template>
1223 <xsl:text>)</xsl:text>
1224 </xsl:when>
1225 </xsl:choose>
1226 </xsl:when>
1227 <!-- enum types -->
1228 <xsl:when test="
1229 (ancestor::library/enum[@name=current()/@type]) or
1230 (ancestor::library/if[@target=$self_target]/enum[@name=current()/@type])
1231 ">
1232 <xsl:choose>
1233 <xsl:when test="$isIn">
1234 <xsl:text>(</xsl:text>
1235 <xsl:value-of select="@type"/>
1236 <xsl:text>_T) a</xsl:text>
1237 <xsl:call-template name="capitalize">
1238 <xsl:with-param name="str" select="@name"/>
1239 </xsl:call-template>
1240 </xsl:when>
1241 <xsl:when test="$isOut">
1242 <xsl:text>ENUMOut &lt;K</xsl:text>
1243 <xsl:value-of select="@type"/>
1244 <xsl:text>, </xsl:text>
1245 <xsl:value-of select="@type"/>
1246 <xsl:text>_T&gt; (a</xsl:text>
1247 <xsl:call-template name="capitalize">
1248 <xsl:with-param name="str" select="@name"/>
1249 </xsl:call-template>
1250 <xsl:text>)</xsl:text>
1251 </xsl:when>
1252 </xsl:choose>
1253 </xsl:when>
1254 <!-- interface types -->
1255 <xsl:when test="
1256 @type='$unknown' or
1257 ((ancestor::library/enumerator[@name=current()/@type]) or
1258 (ancestor::library/if[@target=$self_target]/enumerator[@name=current()/@type])
1259 ) or
1260 ((ancestor::library/interface[@name=current()/@type]) or
1261 (ancestor::library/if[@target=$self_target]/interface[@name=current()/@type])
1262 ) or
1263 ((ancestor::library/collection[@name=current()/@type]) or
1264 (ancestor::library/if[@target=$self_target]/collection[@name=current()/@type])
1265 )
1266 ">
1267 <xsl:choose>
1268 <xsl:when test="$isIn">
1269 <xsl:text>a</xsl:text>
1270 <xsl:call-template name="capitalize">
1271 <xsl:with-param name="str" select="@name"/>
1272 </xsl:call-template>
1273 <xsl:choose>
1274 <xsl:when test="@type='$unknown'">
1275 <xsl:text>.raw()</xsl:text>
1276 </xsl:when>
1277 <xsl:otherwise>
1278 <xsl:text>.mIface</xsl:text>
1279 </xsl:otherwise>
1280 </xsl:choose>
1281 </xsl:when>
1282 <xsl:when test="$isOut">
1283 <xsl:text>&amp;a</xsl:text>
1284 <xsl:call-template name="capitalize">
1285 <xsl:with-param name="str" select="@name"/>
1286 </xsl:call-template>
1287 <xsl:choose>
1288 <xsl:when test="@type='$unknown'">
1289 <xsl:text>.rawRef()</xsl:text>
1290 </xsl:when>
1291 <xsl:otherwise>
1292 <xsl:text>.mIface</xsl:text>
1293 </xsl:otherwise>
1294 </xsl:choose>
1295 </xsl:when>
1296 </xsl:choose>
1297 </xsl:when>
1298 <!-- currently unsupported types -->
1299 <xsl:when test="@type = 'string'">
1300 <xsl:message terminate="yes">
1301 <xsl:text>Parameter type </xsl:text>
1302 <xsl:value-of select="@type"/>
1303 <xsl:text>is not currently supported</xsl:text>
1304 </xsl:message>
1305 </xsl:when>
1306 <!-- assuming scalar types -->
1307 <xsl:otherwise>
1308 <xsl:choose>
1309 <xsl:when test="$isIn">
1310 <xsl:text>a</xsl:text>
1311 <xsl:call-template name="capitalize">
1312 <xsl:with-param name="str" select="@name"/>
1313 </xsl:call-template>
1314 </xsl:when>
1315 <xsl:when test="$isOut">
1316 <xsl:text>&amp;a</xsl:text>
1317 <xsl:call-template name="capitalize">
1318 <xsl:with-param name="str" select="@name"/>
1319 </xsl:call-template>
1320 </xsl:when>
1321 </xsl:choose>
1322 </xsl:otherwise>
1323 </xsl:choose>
1324</xsl:template>
1325
1326
1327<!--
1328 * attribute/parameter type conversion (returns plain Qt type name)
1329-->
1330<xsl:template match="
1331 attribute/@type | param/@type |
1332 enumerator/@type | collection/@type | collection/@enumerator
1333">
1334 <xsl:variable name="self_target" select="current()/ancestor::if/@target"/>
1335
1336 <xsl:if test="../@array and ../@safearray='yes'">
1337 <xsl:message terminate="yes">
1338 <xsl:value-of select="concat(../../../@name,'::',../../@name,'::',../@name,': ')"/>
1339 <xsl:text>either 'array' or 'safearray="yes"' attribute is allowed, but not both!</xsl:text>
1340 </xsl:message>
1341 </xsl:if>
1342
1343 <xsl:if test="../@array and ((name(..)='param' and ../@dir='return') or (name(..)='attribute'))">
1344 <xsl:message terminate="yes">
1345 <xsl:value-of select="concat(../../../@name,'::',../../@name,'::',../@name,': ')"/>
1346 <xsl:text>return 'array' parameters and 'array' attributes are not supported, use 'safearray="yes"' instead.</xsl:text>
1347 </xsl:message>
1348 </xsl:if>
1349
1350 <xsl:choose>
1351 <!-- modifiers (ignored for 'enumeration' attributes)-->
1352 <xsl:when test="name(current())='type' and ../@mod">
1353 <xsl:if test="../@safearray">
1354 <xsl:message terminate="yes">
1355 <xsl:value-of select="concat(../../../@name,'::',../../@name,'::',../@name,': ')"/>
1356 <xsl:text>either 'safearray' or 'mod' attribute is allowed, but not both!</xsl:text>
1357 </xsl:message>
1358 </xsl:if>
1359 <xsl:if test="../@array">
1360 <xsl:message terminate="yes">
1361 <xsl:value-of select="concat(../../../@name,'::',../../@name,'::',../@name,': ')"/>
1362 <xsl:text>either 'array' or 'mod' attribute is allowed, but not both!</xsl:text>
1363 </xsl:message>
1364 </xsl:if>
1365 <xsl:choose>
1366 <xsl:when test="../@mod='ptr'">
1367 <xsl:choose>
1368 <!-- standard types -->
1369 <!--xsl:when test=".='result'">??</xsl:when-->
1370 <xsl:when test=".='boolean'">BOOL *</xsl:when>
1371 <xsl:when test=".='octet'">BYTE *</xsl:when>
1372 <xsl:when test=".='short'">SHORT *</xsl:when>
1373 <xsl:when test=".='unsigned short'">USHORT *</xsl:when>
1374 <xsl:when test=".='long'">LONG *</xsl:when>
1375 <xsl:when test=".='long long'">LONG64 *</xsl:when>
1376 <xsl:when test=".='unsigned long'">ULONG *</xsl:when>
1377 <xsl:when test=".='unsigned long long'">ULONG64 *</xsl:when>
1378 <xsl:when test=".='char'">CHAR *</xsl:when>
1379 <!--<xsl:when test=".='string'">??</xsl:when-->
1380 <xsl:when test=".='wchar'">OLECHAR *</xsl:when>
1381 <!--<xsl:when test=".='wstring'">??</xsl:when-->
1382 <xsl:otherwise>
1383 <xsl:message terminate="yes">
1384 <xsl:value-of select="concat(../../../@name,'::',../../@name,'::',../@name,': ')"/>
1385 <xsl:text>attribute 'mod=</xsl:text>
1386 <xsl:value-of select="concat('&quot;',../@mod,'&quot;')"/>
1387 <xsl:text>' cannot be used with type </xsl:text>
1388 <xsl:value-of select="concat('&quot;',current(),'&quot;!')"/>
1389 </xsl:message>
1390 </xsl:otherwise>
1391 </xsl:choose>
1392 </xsl:when>
1393 <xsl:otherwise>
1394 <xsl:message terminate="yes">
1395 <xsl:value-of select="concat(../../../@name,'::',../../@name,'::',../@name,': ')"/>
1396 <xsl:value-of select="concat('value &quot;',../@mod,'&quot; ')"/>
1397 <xsl:text>of attribute 'mod' is invalid!</xsl:text>
1398 </xsl:message>
1399 </xsl:otherwise>
1400 </xsl:choose>
1401 </xsl:when>
1402 <!-- no modifiers -->
1403 <xsl:otherwise>
1404 <xsl:if test="../@safearray">
1405 <xsl:text>QVector &lt;</xsl:text>
1406 </xsl:if>
1407 <xsl:choose>
1408 <!-- standard types -->
1409 <xsl:when test=".='result'">HRESULT</xsl:when>
1410 <xsl:when test=".='boolean'">BOOL</xsl:when>
1411 <xsl:when test=".='octet'">BYTE</xsl:when>
1412 <xsl:when test=".='short'">SHORT</xsl:when>
1413 <xsl:when test=".='unsigned short'">USHORT</xsl:when>
1414 <xsl:when test=".='long'">LONG</xsl:when>
1415 <xsl:when test=".='long long'">LONG64</xsl:when>
1416 <xsl:when test=".='unsigned long'">ULONG</xsl:when>
1417 <xsl:when test=".='unsigned long long'">ULONG64</xsl:when>
1418 <xsl:when test=".='char'">CHAR</xsl:when>
1419 <xsl:when test=".='string'">CHAR *</xsl:when>
1420 <xsl:when test=".='wchar'">OLECHAR</xsl:when>
1421 <xsl:when test=".='wstring'">QString</xsl:when>
1422 <!-- UUID type -->
1423 <xsl:when test=".='uuid'">QUuid</xsl:when>
1424 <!-- system interface types -->
1425 <xsl:when test=".='$unknown'">CUnknown</xsl:when>
1426 <xsl:otherwise>
1427 <xsl:choose>
1428 <!-- enum types -->
1429 <xsl:when test="
1430 (ancestor::library/enum[@name=current()]) or
1431 (ancestor::library/if[@target=$self_target]/enum[@name=current()])
1432 ">
1433 <xsl:value-of select="concat('K',string(.))"/>
1434 </xsl:when>
1435 <!-- custom interface types -->
1436 <xsl:when test="
1437 (name(current())='enumerator' and
1438 ((ancestor::library/enumerator[@name=current()]) or
1439 (ancestor::library/if[@target=$self_target]/enumerator[@name=current()]))
1440 ) or
1441 ((ancestor::library/interface[@name=current()]) or
1442 (ancestor::library/if[@target=$self_target]/interface[@name=current()])
1443 ) or
1444 ((ancestor::library/collection[@name=current()]) or
1445 (ancestor::library/if[@target=$self_target]/collection[@name=current()])
1446 )
1447 ">
1448 <xsl:value-of select="concat('C',substring(.,2))"/>
1449 </xsl:when>
1450 <!-- other types -->
1451 <xsl:otherwise>
1452 <xsl:message terminate="yes">
1453 <xsl:text>Unknown parameter type: </xsl:text>
1454 <xsl:value-of select="."/>
1455 </xsl:message>
1456 </xsl:otherwise>
1457 </xsl:choose>
1458 </xsl:otherwise>
1459 </xsl:choose>
1460 <xsl:if test="../@safearray">
1461 <xsl:text>&gt;</xsl:text>
1462 </xsl:if>
1463 </xsl:otherwise>
1464 </xsl:choose>
1465</xsl:template>
1466
1467
1468<!--
1469 * generates a null initializer for all scalar types (such as bool or long)
1470 * and enum types in the form of ' = <null_initializer>', or nothing for other
1471 * types.
1472-->
1473<xsl:template match="
1474 attribute/@type | param/@type |
1475 enumerator/@type | collection/@type | collection/@enumerator
1476" mode="initializer">
1477
1478 <xsl:variable name="self_target" select="current()/ancestor::if/@target"/>
1479
1480 <xsl:choose>
1481 <!-- safearrays don't need initializers -->
1482 <xsl:when test="../@safearray">
1483 </xsl:when>
1484 <!-- modifiers (ignored for 'enumeration' attributes)-->
1485 <xsl:when test="name(current())='type' and ../@mod">
1486 <xsl:choose>
1487 <xsl:when test="../@mod='ptr'">
1488 <xsl:choose>
1489 <!-- standard types -->
1490 <!--xsl:when test=".='result'">??</xsl:when-->
1491 <xsl:when test=".='boolean'"> = NULL</xsl:when>
1492 <xsl:when test=".='octet'"> = NULL</xsl:when>
1493 <xsl:when test=".='short'"> = NULL</xsl:when>
1494 <xsl:when test=".='unsigned short'"> = NULL</xsl:when>
1495 <xsl:when test=".='long'"> = NULL</xsl:when>
1496 <xsl:when test=".='long long'"> = NULL</xsl:when>
1497 <xsl:when test=".='unsigned long'"> = NULL</xsl:when>
1498 <xsl:when test=".='unsigned long long'"> = NULL</xsl:when>
1499 <xsl:when test=".='char'"> = NULL</xsl:when>
1500 <!--<xsl:when test=".='string'">??</xsl:when-->
1501 <xsl:when test=".='wchar'"> = NULL</xsl:when>
1502 <!--<xsl:when test=".='wstring'">??</xsl:when-->
1503 <xsl:otherwise>
1504 <xsl:message terminate="yes">
1505 <xsl:value-of select="concat(../../../@name,'::',../../@name,'::',../@name,': ')"/>
1506 <xsl:text>attribute 'mod=</xsl:text>
1507 <xsl:value-of select="concat('&quot;',../@mod,'&quot;')"/>
1508 <xsl:text>' cannot be used with type </xsl:text>
1509 <xsl:value-of select="concat('&quot;',current(),'&quot;!')"/>
1510 </xsl:message>
1511 </xsl:otherwise>
1512 </xsl:choose>
1513 </xsl:when>
1514 <xsl:otherwise>
1515 <xsl:message terminate="yes">
1516 <xsl:value-of select="concat(../../../@name,'::',../../@name,'::',../@name,': ')"/>
1517 <xsl:value-of select="concat('value &quot;',../@mod,'&quot; ')"/>
1518 <xsl:text>of attribute 'mod' is invalid!</xsl:text>
1519 </xsl:message>
1520 </xsl:otherwise>
1521 </xsl:choose>
1522 </xsl:when>
1523 <!-- no modifiers -->
1524 <xsl:otherwise>
1525 <xsl:choose>
1526 <!-- standard types that need a zero initializer -->
1527 <xsl:when test=".='result'"> = S_OK</xsl:when>
1528 <xsl:when test=".='boolean'"> = FALSE</xsl:when>
1529 <xsl:when test=".='octet'"> = 0</xsl:when>
1530 <xsl:when test=".='short'"> = 0</xsl:when>
1531 <xsl:when test=".='unsigned short'"> = 0</xsl:when>
1532 <xsl:when test=".='long'"> = 0</xsl:when>
1533 <xsl:when test=".='long long'"> = 0</xsl:when>
1534 <xsl:when test=".='unsigned long'"> = 0</xsl:when>
1535 <xsl:when test=".='unsigned long long'"> = 0</xsl:when>
1536 <xsl:when test=".='char'"> = 0</xsl:when>
1537 <xsl:when test=".='string'"> = NULL</xsl:when>
1538 <xsl:when test=".='wchar'"> = 0</xsl:when>
1539 <xsl:otherwise>
1540 <xsl:choose>
1541 <!-- enum types initialized with 0 -->
1542 <xsl:when test="
1543 (ancestor::library/enum[@name=current()]) or
1544 (ancestor::library/if[@target=$self_target]/enum[@name=current()])
1545 ">
1546 <xsl:value-of select="concat(' = (K',string(.),') 0')"/>
1547 </xsl:when>
1548 </xsl:choose>
1549 </xsl:otherwise>
1550 </xsl:choose>
1551 </xsl:otherwise>
1552 </xsl:choose>
1553</xsl:template>
1554
1555
1556<!--
1557 * attribute/parameter type conversion (for method declaration)
1558-->
1559<xsl:template match="attribute/@type | param/@type" mode="param">
1560
1561 <xsl:variable name="self_target" select="current()/ancestor::if/@target"/>
1562
1563 <xsl:choose>
1564 <!-- class types -->
1565 <xsl:when test="
1566 .='string' or
1567 .='wstring' or
1568 ../@safearray='yes' or
1569 ((ancestor::library/enum[@name=current()]) or
1570 (ancestor::library/if[@target=$self_target]/enum[@name=current()])
1571 ) or
1572 .='$unknown' or
1573 ((ancestor::library/enumerator[@name=current()]) or
1574 (ancestor::library/if[@target=$self_target]/enumerator[@name=current()])
1575 ) or
1576 ((ancestor::library/interface[@name=current()]) or
1577 (ancestor::library/if[@target=$self_target]/interface[@name=current()])
1578 ) or
1579 ((ancestor::library/collection[@name=current()]) or
1580 (ancestor::library/if[@target=$self_target]/collection[@name=current()])
1581 )
1582 ">
1583 <xsl:choose>
1584 <!-- <attribute> context -->
1585 <xsl:when test="name(..)='attribute'">
1586 <xsl:text>const </xsl:text>
1587 <xsl:apply-templates select="."/>
1588 <xsl:text> &amp;</xsl:text>
1589 </xsl:when>
1590 <!-- <param> context -->
1591 <xsl:when test="name(..)='param'">
1592 <xsl:choose>
1593 <xsl:when test="../@dir='in'">
1594 <xsl:text>const </xsl:text>
1595 <xsl:apply-templates select="."/>
1596 <xsl:text> &amp;</xsl:text>
1597 </xsl:when>
1598 <xsl:when test="../@dir='out'">
1599 <xsl:apply-templates select="."/>
1600 <xsl:text> &amp;</xsl:text>
1601 </xsl:when>
1602 <xsl:when test="../@dir='return'">
1603 <xsl:apply-templates select="."/>
1604 </xsl:when>
1605 </xsl:choose>
1606 </xsl:when>
1607 </xsl:choose>
1608 </xsl:when>
1609 <!-- assume scalar types -->
1610 <xsl:otherwise>
1611 <xsl:choose>
1612 <!-- <attribute> context -->
1613 <xsl:when test="name(..)='attribute'">
1614 <xsl:apply-templates select="."/>
1615 </xsl:when>
1616 <!-- <param> context -->
1617 <xsl:when test="name(..)='param'">
1618 <xsl:choose>
1619 <xsl:when test="../@array">
1620 <xsl:apply-templates select="."/>
1621 <xsl:text> *</xsl:text>
1622 <xsl:if test="../@dir='out'">
1623 <xsl:text> &amp;</xsl:text>
1624 </xsl:if>
1625 </xsl:when>
1626 <xsl:otherwise>
1627 <xsl:apply-templates select="."/>
1628 <xsl:if test="../@dir='out'">
1629 <xsl:text> &amp;</xsl:text>
1630 </xsl:if>
1631 </xsl:otherwise>
1632 </xsl:choose>
1633 </xsl:when>
1634 </xsl:choose>
1635 </xsl:otherwise>
1636 </xsl:choose>
1637</xsl:template>
1638
1639
1640<!--
1641 * attribute/parameter type conversion (returns plain COM type name)
1642 * (basically, copied from midl.xsl)
1643-->
1644<xsl:template match="
1645 attribute/@type | param/@type |
1646 enumerator/@type | collection/@type | collection/@enumerator
1647" mode="com">
1648
1649 <xsl:variable name="self_target" select="current()/ancestor::if/@target"/>
1650
1651 <xsl:choose>
1652 <!-- modifiers (ignored for 'enumeration' attributes)-->
1653 <xsl:when test="name(current())='type' and ../@mod">
1654 <xsl:choose>
1655 <xsl:when test="../@mod='ptr'">
1656 <xsl:choose>
1657 <!-- standard types -->
1658 <!--xsl:when test=".='result'">??</xsl:when-->
1659 <xsl:when test=".='boolean'">BOOL *</xsl:when>
1660 <xsl:when test=".='octet'">BYTE *</xsl:when>
1661 <xsl:when test=".='short'">SHORT *</xsl:when>
1662 <xsl:when test=".='unsigned short'">USHORT *</xsl:when>
1663 <xsl:when test=".='long'">LONG *</xsl:when>
1664 <xsl:when test=".='long long'">LONG64 *</xsl:when>
1665 <xsl:when test=".='unsigned long'">ULONG *</xsl:when>
1666 <xsl:when test=".='unsigned long long'">ULONG64 *</xsl:when>
1667 <xsl:when test=".='char'">CHAR *</xsl:when>
1668 <!--xsl:when test=".='string'">??</xsl:when-->
1669 <xsl:when test=".='wchar'">OLECHAR *</xsl:when>
1670 <!--xsl:when test=".='wstring'">??</xsl:when-->
1671 <xsl:otherwise>
1672 <xsl:message terminate="yes">
1673 <xsl:value-of select="concat(../../../@name,'::',../../@name,'::',../@name,': ')"/>
1674 <xsl:text>attribute 'mod=</xsl:text>
1675 <xsl:value-of select="concat('&quot;',../@mod,'&quot;')"/>
1676 <xsl:text>' cannot be used with type </xsl:text>
1677 <xsl:value-of select="concat('&quot;',current(),'&quot;!')"/>
1678 </xsl:message>
1679 </xsl:otherwise>
1680 </xsl:choose>
1681 </xsl:when>
1682 <xsl:otherwise>
1683 <xsl:message terminate="yes">
1684 <xsl:value-of select="concat(../../../@name,'::',../../@name,'::',../@name,': ')"/>
1685 <xsl:value-of select="concat('value &quot;',../@mod,'&quot; ')"/>
1686 <xsl:text>of attribute 'mod' is invalid!</xsl:text>
1687 </xsl:message>
1688 </xsl:otherwise>
1689 </xsl:choose>
1690 </xsl:when>
1691 <!-- no modifiers -->
1692 <xsl:otherwise>
1693 <xsl:choose>
1694 <!-- standard types -->
1695 <xsl:when test=".='result'">HRESULT</xsl:when>
1696 <xsl:when test=".='boolean'">BOOL</xsl:when>
1697 <xsl:when test=".='octet'">BYTE</xsl:when>
1698 <xsl:when test=".='short'">SHORT</xsl:when>
1699 <xsl:when test=".='unsigned short'">USHORT</xsl:when>
1700 <xsl:when test=".='long'">LONG</xsl:when>
1701 <xsl:when test=".='long long'">LONG64</xsl:when>
1702 <xsl:when test=".='unsigned long'">ULONG</xsl:when>
1703 <xsl:when test=".='unsigned long long'">ULONG64</xsl:when>
1704 <xsl:when test=".='char'">CHAR</xsl:when>
1705 <xsl:when test=".='string'">CHAR *</xsl:when>
1706 <xsl:when test=".='wchar'">OLECHAR</xsl:when>
1707 <xsl:when test=".='wstring'">BSTR</xsl:when>
1708 <!-- UUID type -->
1709 <xsl:when test=".='uuid'">GUID</xsl:when>
1710 <!-- system interface types -->
1711 <xsl:when test=".='$unknown'">IUnknown *</xsl:when>
1712 <xsl:otherwise>
1713 <xsl:choose>
1714 <!-- enum types -->
1715 <xsl:when test="
1716 (ancestor::library/enum[@name=current()]) or
1717 (ancestor::library/if[@target=$self_target]/enum[@name=current()])
1718 ">
1719 <xsl:value-of select="."/>
1720 </xsl:when>
1721 <!-- custom interface types -->
1722 <xsl:when test="
1723 (name(current())='enumerator' and
1724 ((ancestor::library/enumerator[@name=current()]) or
1725 (ancestor::library/if[@target=$self_target]/enumerator[@name=current()]))
1726 ) or
1727 ((ancestor::library/interface[@name=current()]) or
1728 (ancestor::library/if[@target=$self_target]/interface[@name=current()])
1729 ) or
1730 ((ancestor::library/collection[@name=current()]) or
1731 (ancestor::library/if[@target=$self_target]/collection[@name=current()])
1732 )
1733 ">
1734 <xsl:value-of select="."/><xsl:text> *</xsl:text>
1735 </xsl:when>
1736 <!-- other types -->
1737 <xsl:otherwise>
1738 <xsl:message terminate="yes">
1739 <xsl:text>Unknown parameter type: </xsl:text>
1740 <xsl:value-of select="."/>
1741 </xsl:message>
1742 </xsl:otherwise>
1743 </xsl:choose>
1744 </xsl:otherwise>
1745 </xsl:choose>
1746 </xsl:otherwise>
1747 </xsl:choose>
1748</xsl:template>
1749
1750
1751<!--
1752 * attribute/parameter type additional hooks.
1753 *
1754 * Called in the context of <attribute> or <param> elements.
1755 *
1756 * @param when When the hook is being called:
1757 * 'pre-call' - right before the method call
1758 * 'post-call' - right after the method call
1759 * @param isSetter Non-empty if called in the cotext of the attribute setter
1760 * call.
1761-->
1762<xsl:template name="hooks">
1763
1764 <xsl:param name="when" select="''"/>
1765 <xsl:param name="isSetter" select="''"/>
1766
1767 <xsl:variable name="self_target" select="current()/ancestor::if/@target"/>
1768
1769 <xsl:variable name="is_iface" select="(
1770 ((ancestor::library/enumerator[@name=current()/@type]) or
1771 (ancestor::library/if[@target=$self_target]/enumerator[@name=current()/@type])
1772 ) or
1773 ((ancestor::library/interface[@name=current()/@type]) or
1774 (ancestor::library/if[@target=$self_target]/interface[@name=current()/@type])
1775 ) or
1776 ((ancestor::library/collection[@name=current()/@type]) or
1777 (ancestor::library/if[@target=$self_target]/collection[@name=current()/@type])
1778 )
1779 )"/>
1780
1781 <xsl:variable name="is_enum" select="(
1782 (ancestor::library/enum[@name=current()/@type]) or
1783 (ancestor::library/if[@target=$self_target]/enum[@name=current()/@type])
1784 )"/>
1785
1786 <xsl:choose>
1787 <xsl:when test="$when='pre-call'">
1788 <xsl:choose>
1789 <xsl:when test="@safearray='yes'">
1790 <!-- declare a SafeArray variable -->
1791 <xsl:choose>
1792 <!-- interface types need special treatment here -->
1793 <xsl:when test="@type='$unknown'">
1794 <xsl:text> com::SafeIfaceArray &lt;IUnknown&gt; </xsl:text>
1795 </xsl:when>
1796 <xsl:when test="$is_iface">
1797 <xsl:text> com::SafeIfaceArray &lt;</xsl:text>
1798 <xsl:value-of select="@type"/>
1799 <xsl:text>&gt; </xsl:text>
1800 </xsl:when>
1801 <!-- enums need the _T prefix -->
1802 <xsl:when test="$is_enum">
1803 <xsl:text> com::SafeArray &lt;</xsl:text>
1804 <xsl:value-of select="@type"/>
1805 <xsl:text>_T&gt; </xsl:text>
1806 </xsl:when>
1807 <!-- GUID is special too -->
1808 <xsl:when test="@type='uuid'">
1809 <xsl:text> com::SafeGUIDArray </xsl:text>
1810 </xsl:when>
1811 <!-- everything else is not -->
1812 <xsl:otherwise>
1813 <xsl:text> com::SafeArray &lt;</xsl:text>
1814 <xsl:apply-templates select="@type" mode="com"/>
1815 <xsl:text>&gt; </xsl:text>
1816 </xsl:otherwise>
1817 </xsl:choose>
1818 <xsl:value-of select="@name"/>
1819 <xsl:text>;&#x0A;</xsl:text>
1820 <xsl:if test="(name()='attribute' and $isSetter) or
1821 (name()='param' and @dir='in')">
1822 <!-- convert QVector to SafeArray -->
1823 <xsl:choose>
1824 <!-- interface types need special treatment here -->
1825 <xsl:when test="@type='$unknown' or $is_iface">
1826 <xsl:text> ToSafeIfaceArray (</xsl:text>
1827 </xsl:when>
1828 <xsl:otherwise>
1829 <xsl:text> ToSafeArray (</xsl:text>
1830 </xsl:otherwise>
1831 </xsl:choose>
1832 <xsl:text>a</xsl:text>
1833 <xsl:call-template name="capitalize">
1834 <xsl:with-param name="str" select="@name"/>
1835 </xsl:call-template>
1836 <xsl:text>, </xsl:text>
1837 <xsl:value-of select="@name"/>
1838 <xsl:text>);&#x0A;</xsl:text>
1839 </xsl:if>
1840 </xsl:when>
1841 </xsl:choose>
1842 </xsl:when>
1843 <xsl:when test="$when='post-call'">
1844 <xsl:choose>
1845 <xsl:when test="@safearray='yes'">
1846 <xsl:if test="(name()='attribute' and not($isSetter)) or
1847 (name()='param' and (@dir='out' or @dir='return'))">
1848 <!-- convert SafeArray to QVector -->
1849 <xsl:choose>
1850 <!-- interface types need special treatment here -->
1851 <xsl:when test="@type='$unknown' or $is_iface">
1852 <xsl:text> FromSafeIfaceArray (</xsl:text>
1853 </xsl:when>
1854 <xsl:otherwise>
1855 <xsl:text> FromSafeArray (</xsl:text>
1856 </xsl:otherwise>
1857 </xsl:choose>
1858 <xsl:value-of select="@name"/>
1859 <xsl:text>, </xsl:text>
1860 <xsl:text>a</xsl:text>
1861 <xsl:call-template name="capitalize">
1862 <xsl:with-param name="str" select="@name"/>
1863 </xsl:call-template>
1864 <xsl:text>);&#x0A;</xsl:text>
1865 </xsl:if>
1866 </xsl:when>
1867 </xsl:choose>
1868 </xsl:when>
1869 <xsl:otherwise>
1870 <xsl:message terminate="yes">
1871 <xsl:text>Invalid when value: </xsl:text>
1872 <xsl:value-of select="$when"/>
1873 </xsl:message>
1874 </xsl:otherwise>
1875 </xsl:choose>
1876
1877</xsl:template>
1878
1879
1880</xsl:stylesheet>
1881
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette