← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/virtualbox-ose/gutsy

« back to all changes in this revision

Viewing changes to src/VBox/Main/idl/midl.xsl

  • Committer: Bazaar Package Importer
  • Author(s): Steve Kowalik
  • Date: 2007-09-08 16:44:58 UTC
  • Revision ID: james.westby@ubuntu.com-20070908164458-wao29470vqtr8ksy
Tags: upstream-1.5.0-dfsg2
Import upstream version 1.5.0-dfsg2

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/VBox/Main/idl/midl.xsl
 
1
<?xml version="1.0"?>
 
2
 
 
3
<!--
 
4
 *  A template to generate a MS IDL compatible interface definition file
 
5
 *  from the generic interface definition expressed in XML.
 
6
 
 
7
     Copyright (C) 2006-2007 innotek GmbH
 
8
    
 
9
     This file is part of VirtualBox Open Source Edition (OSE), as
 
10
     available from http://www.virtualbox.org. This file is free software;
 
11
     you can redistribute it and/or modify it under the terms of the GNU
 
12
     General Public License as published by the Free Software Foundation,
 
13
     in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
 
14
     distribution. VirtualBox OSE is distributed in the hope that it will
 
15
     be useful, but WITHOUT ANY WARRANTY of any kind.
 
16
-->
 
17
 
 
18
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
 
19
<xsl:output method="text"/>
 
20
 
 
21
<xsl:strip-space elements="*"/>
 
22
 
 
23
 
 
24
<!--
 
25
//  helper definitions
 
26
/////////////////////////////////////////////////////////////////////////////
 
27
-->
 
28
 
 
29
<!--
 
30
 *  capitalizes the first letter
 
31
-->
 
32
<xsl:template name="capitalize">
 
33
    <xsl:param name="str" select="."/>
 
34
    <xsl:value-of select="
 
35
        concat(
 
36
            translate(substring($str,1,1),'abcdefghijklmnopqrstuvwxyz','ABCDEFGHIJKLMNOPQRSTUVWXYZ'),
 
37
            substring($str,2)
 
38
        )
 
39
    "/>
 
40
</xsl:template>
 
41
 
 
42
<!--
 
43
 *  uncapitalizes the first letter only if the second one is not capital
 
44
 *  otherwise leaves the string unchanged
 
45
-->
 
46
<xsl:template name="uncapitalize">
 
47
    <xsl:param name="str" select="."/>
 
48
    <xsl:choose>
 
49
        <xsl:when test="not(contains('ABCDEFGHIJKLMNOPQRSTUVWXYZ', substring($str,2,1)))">
 
50
            <xsl:value-of select="
 
51
                concat(
 
52
                    translate(substring($str,1,1),'ABCDEFGHIJKLMNOPQRSTUVWXYZ','abcdefghijklmnopqrstuvwxyz'),
 
53
                    substring($str,2)
 
54
                )
 
55
            "/>
 
56
        </xsl:when>
 
57
        <xsl:otherwise>
 
58
            <xsl:value-of select="string($str)"/>
 
59
        </xsl:otherwise>
 
60
    </xsl:choose>
 
61
</xsl:template>
 
62
 
 
63
 
 
64
<!--
 
65
//  templates
 
66
/////////////////////////////////////////////////////////////////////////////
 
67
-->
 
68
 
 
69
 
 
70
<!--
 
71
 *  header
 
72
-->
 
73
<xsl:template match="/idl">
 
74
    <xsl:text>
 
75
/*
 
76
 *  DO NOT EDIT! This is a generated file.
 
77
 *
 
78
 *  MS IDL (MIDL) definition for VirualBox Main API (COM interfaces)
 
79
 *  generated from XIDL (XML interface definition).
 
80
 *
 
81
 *  Source    : src/VBox/Main/idl/VirtualBox.xidl
 
82
 *  Generator : src/VBox/Main/idl/midl.xsl
 
83
 */
 
84
    </xsl:text>
 
85
    <xsl:text>&#x0A;</xsl:text>
 
86
    <xsl:text>import "unknwn.idl";&#x0A;&#x0A;</xsl:text>
 
87
    <xsl:apply-templates/>
 
88
</xsl:template>
 
89
 
 
90
 
 
91
<!--
 
92
 *  ignore all |if|s except those for MIDL target
 
93
-->
 
94
<xsl:template match="if">
 
95
    <xsl:if test="@target='midl'">
 
96
        <xsl:apply-templates/>
 
97
    </xsl:if>
 
98
</xsl:template>
 
99
<xsl:template match="if" mode="forward">
 
100
    <xsl:if test="@target='midl'">
 
101
        <xsl:apply-templates mode="forward"/>
 
102
    </xsl:if>
 
103
</xsl:template>
 
104
 
 
105
 
 
106
<!--
 
107
 *  cpp_quote
 
108
-->
 
109
<xsl:template match="cpp">
 
110
    <xsl:text>cpp_quote("</xsl:text>
 
111
    <xsl:value-of select="@line"/>
 
112
    <xsl:text>")&#x0A;&#x0A;</xsl:text>
 
113
</xsl:template>
 
114
 
 
115
 
 
116
<!--
 
117
 *  #if statement (@if attribute)
 
118
-->
 
119
<xsl:template match="@if" mode="begin">
 
120
    <xsl:text>#if </xsl:text>
 
121
    <xsl:value-of select="."/>
 
122
    <xsl:text>&#x0A;</xsl:text>
 
123
</xsl:template>
 
124
<xsl:template match="@if" mode="end">
 
125
    <xsl:text>#endif&#x0A;</xsl:text>
 
126
</xsl:template>
 
127
 
 
128
 
 
129
<!--
 
130
 *  libraries
 
131
-->
 
132
<xsl:template match="library">[
 
133
    uuid(<xsl:value-of select="@uuid"/>),
 
134
    version(<xsl:value-of select="@version"/>),
 
135
    helpstring("<xsl:value-of select="@desc"/>")
 
136
]
 
137
<xsl:text>library </xsl:text>
 
138
    <xsl:value-of select="@name"/>
 
139
    <xsl:text>&#x0A;{&#x0A;</xsl:text>
 
140
    <xsl:text>&#x0A;importlib("stdole2.tlb");&#x0A;&#x0A;</xsl:text>
 
141
    <!-- forward declarations -->
 
142
    <xsl:apply-templates select="if | interface | collection | enumerator" mode="forward"/>
 
143
    <xsl:text>&#x0A;</xsl:text>
 
144
    <!-- all enums go first -->
 
145
    <xsl:apply-templates select="enum | if/enum"/>
 
146
    <!-- everything else but enums -->
 
147
    <xsl:apply-templates select="*[not(self::enum) and not(self::if[enum])]"/>
 
148
    <!-- -->
 
149
    <xsl:text>}; /* library </xsl:text>
 
150
    <xsl:value-of select="@name"/>
 
151
    <xsl:text> */&#x0A;&#x0A;</xsl:text>
 
152
</xsl:template>
 
153
 
 
154
 
 
155
<!--
 
156
 *  forward declarations
 
157
-->
 
158
<xsl:template match="interface | collection | enumerator" mode="forward">
 
159
    <xsl:text>interface </xsl:text>
 
160
    <xsl:value-of select="@name"/>
 
161
    <xsl:text>;&#x0A;</xsl:text>
 
162
</xsl:template>
 
163
 
 
164
 
 
165
<!--
 
166
 *  interfaces
 
167
-->
 
168
<xsl:template match="interface">[
 
169
    uuid(<xsl:value-of select="@uuid"/>),
 
170
    object,
 
171
    dual
 
172
]
 
173
<xsl:text>interface </xsl:text>
 
174
    <xsl:value-of select="@name"/>
 
175
    <xsl:text> : </xsl:text>
 
176
    <xsl:choose>
 
177
        <xsl:when test="@extends='$unknown'">IUnknown</xsl:when>
 
178
        <xsl:when test="@extends='$dispatched'">IDispatch</xsl:when>
 
179
        <xsl:when test="@extends='$errorinfo'">IErrorInfo</xsl:when>
 
180
        <xsl:otherwise><xsl:value-of select="@extends"/></xsl:otherwise>
 
181
    </xsl:choose>
 
182
    <xsl:text>&#x0A;{&#x0A;</xsl:text>
 
183
    <!-- attributes (properties) -->
 
184
    <xsl:apply-templates select="attribute"/>
 
185
    <!-- methods -->
 
186
    <xsl:apply-templates select="method"/>
 
187
    <!-- 'if' enclosed elements, unsorted -->
 
188
    <xsl:apply-templates select="if"/>
 
189
    <!-- -->
 
190
    <xsl:text>}; /* interface </xsl:text>
 
191
    <xsl:value-of select="@name"/>
 
192
    <xsl:text> */&#x0A;&#x0A;</xsl:text>
 
193
</xsl:template>
 
194
 
 
195
 
 
196
<!--
 
197
 *  attributes
 
198
-->
 
199
<xsl:template match="interface//attribute | collection//attribute">
 
200
    <xsl:apply-templates select="@if" mode="begin"/>
 
201
    <xsl:text>    [propget] HRESULT </xsl:text>
 
202
    <xsl:call-template name="capitalize">
 
203
        <xsl:with-param name="str" select="@name"/>
 
204
    </xsl:call-template>
 
205
    <xsl:text> ([out, retval] </xsl:text>
 
206
    <xsl:apply-templates select="@type"/>
 
207
    <xsl:text> * a</xsl:text>
 
208
    <xsl:call-template name="capitalize">
 
209
        <xsl:with-param name="str" select="@name"/>
 
210
    </xsl:call-template>
 
211
    <xsl:text>);&#x0A;</xsl:text>
 
212
    <xsl:if test="not(@readonly='yes')">
 
213
        <xsl:text>    [propput] HRESULT </xsl:text>
 
214
        <xsl:call-template name="capitalize">
 
215
            <xsl:with-param name="str" select="@name"/>
 
216
        </xsl:call-template>
 
217
        <xsl:text> ([in] </xsl:text>
 
218
        <xsl:apply-templates select="@type"/>
 
219
        <xsl:text> a</xsl:text>
 
220
        <xsl:call-template name="capitalize">
 
221
            <xsl:with-param name="str" select="@name"/>
 
222
        </xsl:call-template>
 
223
        <xsl:text>);&#x0A;</xsl:text>
 
224
    </xsl:if>
 
225
    <xsl:apply-templates select="@if" mode="end"/>
 
226
    <xsl:text>&#x0A;</xsl:text>
 
227
</xsl:template>
 
228
 
 
229
 
 
230
<!--
 
231
 *  methods
 
232
-->
 
233
<xsl:template match="interface//method | collection//method">
 
234
    <xsl:apply-templates select="@if" mode="begin"/>
 
235
    <xsl:text>    HRESULT </xsl:text>
 
236
    <xsl:call-template name="capitalize">
 
237
        <xsl:with-param name="str" select="@name"/>
 
238
    </xsl:call-template>
 
239
    <xsl:if test="param">
 
240
        <xsl:text> (&#x0A;</xsl:text>
 
241
        <xsl:for-each select="param [position() != last()]">
 
242
            <xsl:text>        </xsl:text>
 
243
            <xsl:apply-templates select="."/>
 
244
            <xsl:text>,&#x0A;</xsl:text>
 
245
        </xsl:for-each>
 
246
        <xsl:text>        </xsl:text>
 
247
        <xsl:apply-templates select="param [last()]"/>
 
248
        <xsl:text>&#x0A;    );&#x0A;</xsl:text>
 
249
    </xsl:if>
 
250
    <xsl:if test="not(param)">
 
251
        <xsl:text>();&#x0A;</xsl:text>
 
252
    </xsl:if>
 
253
    <xsl:apply-templates select="@if" mode="end"/>
 
254
    <xsl:text>&#x0A;</xsl:text>
 
255
</xsl:template>
 
256
 
 
257
 
 
258
<!--
 
259
 *  co-classes
 
260
-->
 
261
<xsl:template match="module/class">[
 
262
    uuid(<xsl:value-of select="@uuid"/>)
 
263
]
 
264
<xsl:text>coclass </xsl:text>
 
265
    <xsl:value-of select="@name"/>
 
266
    <xsl:text>&#x0A;{&#x0A;</xsl:text>
 
267
    <xsl:for-each select="interface">
 
268
        <xsl:text>    </xsl:text>
 
269
        <xsl:if test="@default='yes'">
 
270
            <xsl:text>[default] </xsl:text>
 
271
        </xsl:if>
 
272
        <xsl:text>interface </xsl:text>
 
273
        <xsl:value-of select="@name"/>
 
274
        <xsl:text>;&#x0A;</xsl:text>
 
275
    </xsl:for-each>
 
276
    <xsl:text>&#x0A;}; /* coclass </xsl:text>
 
277
    <xsl:value-of select="@name"/>
 
278
    <xsl:text> */&#x0A;&#x0A;</xsl:text>
 
279
</xsl:template>
 
280
 
 
281
 
 
282
<!--
 
283
 *  enumerators
 
284
-->
 
285
<xsl:template match="enumerator">[
 
286
    uuid(<xsl:value-of select="@uuid"/>),
 
287
    object,
 
288
    dual
 
289
]
 
290
<xsl:text>interface </xsl:text>
 
291
    <xsl:value-of select="@name"/>
 
292
    <xsl:text> : IUnknown&#x0A;{&#x0A;</xsl:text>
 
293
    <!-- HasMore -->
 
294
    <xsl:text>    HRESULT HasMore ([out, retval] BOOL * more);&#x0A;&#x0A;</xsl:text>
 
295
    <!-- GetNext -->
 
296
    <xsl:text>    HRESULT GetNext ([out, retval] </xsl:text>
 
297
    <xsl:apply-templates select="@type"/>
 
298
    <xsl:text> * next);&#x0A;&#x0A;</xsl:text>
 
299
    <!-- -->
 
300
    <xsl:text>&#x0A;}; /* interface </xsl:text>
 
301
    <xsl:value-of select="@name"/>
 
302
    <xsl:text> */&#x0A;&#x0A;</xsl:text>
 
303
</xsl:template>
 
304
 
 
305
 
 
306
<!--
 
307
 *  collections
 
308
-->
 
309
<xsl:template match="collection">
 
310
    <xsl:if test="not(@readonly='yes')">
 
311
        <xsl:message terminate="yes">
 
312
            <xsl:value-of select="concat(@name,': ')"/>
 
313
            <xsl:text>non-readonly collections are not currently supported</xsl:text>
 
314
        </xsl:message>
 
315
    </xsl:if>[
 
316
    uuid(<xsl:value-of select="@uuid"/>),
 
317
    object,
 
318
    dual
 
319
]
 
320
<xsl:text>interface </xsl:text>
 
321
    <xsl:value-of select="@name"/>
 
322
    <xsl:text> : IUnknown&#x0A;{&#x0A;</xsl:text>
 
323
    <!-- Count -->
 
324
    <xsl:text>    [propget] HRESULT Count ([out, retval] ULONG * count);&#x0A;&#x0A;</xsl:text>
 
325
    <!-- GetItemAt -->
 
326
    <xsl:text>    HRESULT GetItemAt ([in] ULONG index, [out, retval] </xsl:text>
 
327
    <xsl:apply-templates select="@type"/>
 
328
    <xsl:text> * item);&#x0A;&#x0A;</xsl:text>
 
329
    <!-- Enumerate -->
 
330
    <xsl:text>    HRESULT Enumerate ([out, retval] </xsl:text>
 
331
    <xsl:apply-templates select="@enumerator"/>
 
332
    <xsl:text> * enumerator);&#x0A;&#x0A;</xsl:text>
 
333
    <!-- other extra attributes (properties) -->
 
334
    <xsl:apply-templates select="attribute"/>
 
335
    <!-- other extra methods -->
 
336
    <xsl:apply-templates select="method"/>
 
337
    <!-- 'if' enclosed elements, unsorted -->
 
338
    <xsl:apply-templates select="if"/>
 
339
    <!-- -->
 
340
    <xsl:text>&#x0A;}; /* interface </xsl:text>
 
341
    <xsl:value-of select="@name"/>
 
342
    <xsl:text> */&#x0A;&#x0A;</xsl:text>
 
343
</xsl:template>
 
344
 
 
345
 
 
346
<!--
 
347
 *  enums
 
348
-->
 
349
<xsl:template match="enum">[
 
350
    uuid(<xsl:value-of select="@uuid"/>),
 
351
    v1_enum
 
352
]
 
353
<xsl:text>typedef enum &#x0A;{&#x0A;</xsl:text>
 
354
    <xsl:for-each select="const">
 
355
        <xsl:text>    </xsl:text>
 
356
        <xsl:value-of select="@name"/> = <xsl:value-of select="@value"/>
 
357
        <xsl:choose>
 
358
            <xsl:when test="position()!=last()"><xsl:text>,&#x0A;</xsl:text></xsl:when>
 
359
            <xsl:otherwise><xsl:text>&#x0A;</xsl:text></xsl:otherwise>
 
360
        </xsl:choose>
 
361
    </xsl:for-each>
 
362
    <xsl:text>} </xsl:text>
 
363
    <xsl:value-of select="@name"/>
 
364
    <xsl:text>;&#x0A;&#x0A;</xsl:text>
 
365
    <!-- -->
 
366
    <xsl:value-of select="concat('/* cross-platform type name for ', @name, ' */&#x0A;')"/>
 
367
    <xsl:value-of select="concat('cpp_quote(&quot;#define ', @name, '_T', ' ',
 
368
                                 @name, '&quot;)&#x0A;&#x0A;')"/>
 
369
    <xsl:text>cpp_quote("")&#x0A;</xsl:text>
 
370
    <!-- -->
 
371
    <xsl:value-of select="concat('/* cross-platform constants for ', @name, ' */&#x0A;')"/>
 
372
    <xsl:for-each select="const">
 
373
        <xsl:value-of select="concat('cpp_quote(&quot;#define ', ../@name, '_', @name, ' ',
 
374
                                     @name, '&quot;)&#x0A;')"/>
 
375
        <xsl:choose>
 
376
            <xsl:when test="position()=last()"><xsl:text>cpp_quote("")&#x0A;</xsl:text></xsl:when>
 
377
        </xsl:choose>
 
378
    </xsl:for-each>
 
379
    <xsl:text>&#x0A;&#x0A;</xsl:text>
 
380
</xsl:template>
 
381
 
 
382
 
 
383
<!--
 
384
 *  method parameters
 
385
-->
 
386
<xsl:template match="method/param">
 
387
    <xsl:text>[</xsl:text>
 
388
    <xsl:choose>
 
389
        <xsl:when test="@dir='in'">in</xsl:when>
 
390
        <xsl:when test="@dir='out'">out</xsl:when>
 
391
        <xsl:when test="@dir='return'">out, retval</xsl:when>
 
392
        <xsl:otherwise>in</xsl:otherwise>
 
393
    </xsl:choose>
 
394
    <xsl:if test="@array">
 
395
        <xsl:if test="@dir='return'">
 
396
            <xsl:message terminate="yes">
 
397
                <xsl:value-of select="concat(../../@name,'::',../@name,'::',@name,': ')"/>
 
398
                <xsl:text>return array parameters are not currently supported</xsl:text>
 
399
            </xsl:message>
 
400
        </xsl:if>
 
401
        <xsl:choose>
 
402
            <xsl:when test="../param[@name=current()/@array]">
 
403
                <xsl:if test="../param[@name=current()/@array]/@dir != @dir">
 
404
                    <xsl:message terminate="yes">
 
405
                        <xsl:value-of select="concat(../../@name,'::',../@name,': ')"/>
 
406
                        <xsl:value-of select="concat(@name,' and ',../param[@name=current()/@array]/@name)"/>
 
407
                        <xsl:text> must have the same direction</xsl:text>
 
408
                    </xsl:message>
 
409
                </xsl:if>
 
410
                <xsl:text>, size_is(</xsl:text>
 
411
                    <xsl:if test="@dir='out'">
 
412
                        <xsl:text>, </xsl:text>
 
413
                    </xsl:if>
 
414
                    <xsl:if test="../param[@name=current()/@array]/@dir='out'">
 
415
                        <xsl:text>*</xsl:text>
 
416
                    </xsl:if>
 
417
                    <!--xsl:value-of select="@array"/-->
 
418
                    <xsl:text>a</xsl:text>
 
419
                    <xsl:call-template name="capitalize">
 
420
                        <xsl:with-param name="str" select="@array"/>
 
421
                    </xsl:call-template>
 
422
                <xsl:text>)</xsl:text>
 
423
            </xsl:when>
 
424
            <xsl:otherwise>
 
425
                <xsl:message terminate="yes">
 
426
                    <xsl:value-of select="concat(../../@name,'::',../@name,'::',@name,': ')"/>
 
427
                    <xsl:text>array attribute refers to non-existent param: </xsl:text>
 
428
                    <xsl:value-of select="@array"/>
 
429
                </xsl:message>
 
430
            </xsl:otherwise>
 
431
        </xsl:choose>
 
432
    </xsl:if>
 
433
    <xsl:text>] </xsl:text>
 
434
    <xsl:apply-templates select="@type"/>
 
435
    <xsl:text> </xsl:text>
 
436
    <xsl:if test="@array">
 
437
        <xsl:text>* </xsl:text>
 
438
    </xsl:if>
 
439
    <xsl:if test="@dir='out' or @dir='return'">
 
440
        <xsl:text>* </xsl:text>
 
441
    </xsl:if>
 
442
    <!--xsl:value-of select="@name"/-->
 
443
    <xsl:text>a</xsl:text>
 
444
    <xsl:call-template name="capitalize">
 
445
        <xsl:with-param name="str" select="@name"/>
 
446
    </xsl:call-template>
 
447
</xsl:template>
 
448
 
 
449
 
 
450
<!--
 
451
 *  attribute/parameter type conversion
 
452
-->
 
453
<xsl:template match="
 
454
    attribute/@type | param/@type |
 
455
    enumerator/@type | collection/@type | collection/@enumerator
 
456
">
 
457
    <xsl:variable name="self_target" select="current()/ancestor::if/@target"/>
 
458
 
 
459
    <xsl:choose>
 
460
        <!-- modifiers (ignored for 'enumeration' attributes)-->
 
461
        <xsl:when test="name(current())='type' and ../@mod">
 
462
            <xsl:if test="../@array">
 
463
                <xsl:message terminate="yes">
 
464
                        <xsl:value-of select="concat(../../../@name,'::',../../@name,'::',../@name,': ')"/>
 
465
                    <xsl:text>either 'array' or 'mod' attribute is allowed, but not both!</xsl:text>
 
466
                </xsl:message>
 
467
            </xsl:if>
 
468
            <xsl:choose>
 
469
                <xsl:when test="../@mod='ptr'">
 
470
                    <xsl:choose>
 
471
                        <!-- standard types -->
 
472
                        <!--xsl:when test=".='result'">??</xsl:when-->
 
473
                        <xsl:when test=".='boolean'">BOOL *</xsl:when>
 
474
                        <xsl:when test=".='octet'">BYTE *</xsl:when>
 
475
                        <xsl:when test=".='short'">SHORT *</xsl:when>
 
476
                        <xsl:when test=".='unsigned short'">USHORT *</xsl:when>
 
477
                        <xsl:when test=".='long'">LONG *</xsl:when>
 
478
                        <xsl:when test=".='long long'">LONG64 *</xsl:when>
 
479
                        <xsl:when test=".='unsigned long'">ULONG *</xsl:when>
 
480
                        <xsl:when test=".='unsigned long long'">ULONG64 *</xsl:when>
 
481
                        <xsl:when test=".='char'">CHAR *</xsl:when>
 
482
                        <!--xsl:when test=".='string'">??</xsl:when-->
 
483
                        <xsl:when test=".='wchar'">OLECHAR *</xsl:when>
 
484
                        <!--xsl:when test=".='wstring'">??</xsl:when-->
 
485
                        <xsl:otherwise>
 
486
                            <xsl:message terminate="yes">
 
487
                                <xsl:value-of select="concat(../../../@name,'::',../../@name,'::',../@name,': ')"/>
 
488
                                <xsl:text>attribute 'mod=</xsl:text>
 
489
                                <xsl:value-of select="concat('&quot;',../@mod,'&quot;')"/>
 
490
                                <xsl:text>' cannot be used with type </xsl:text>
 
491
                                <xsl:value-of select="concat('&quot;',current(),'&quot;!')"/>
 
492
                            </xsl:message>
 
493
                        </xsl:otherwise>
 
494
                    </xsl:choose>
 
495
                </xsl:when>
 
496
                <xsl:otherwise>
 
497
                    <xsl:message terminate="yes">
 
498
                        <xsl:value-of select="concat(../../../@name,'::',../../@name,'::',../@name,': ')"/>
 
499
                        <xsl:value-of select="concat('value &quot;',../@mod,'&quot; ')"/>
 
500
                        <xsl:text>of attibute 'mod' is invalid!</xsl:text>
 
501
                    </xsl:message>
 
502
                </xsl:otherwise>
 
503
            </xsl:choose>
 
504
        </xsl:when>
 
505
        <!-- no modifiers -->
 
506
        <xsl:otherwise>
 
507
            <xsl:choose>
 
508
                <!-- standard types -->
 
509
                <xsl:when test=".='result'">HRESULT</xsl:when>
 
510
                <xsl:when test=".='boolean'">BOOL</xsl:when>
 
511
                <xsl:when test=".='octet'">BYTE</xsl:when>
 
512
                <xsl:when test=".='short'">SHORT</xsl:when>
 
513
                <xsl:when test=".='unsigned short'">USHORT</xsl:when>
 
514
                <xsl:when test=".='long'">LONG</xsl:when>
 
515
                <xsl:when test=".='long long'">LONG64</xsl:when>
 
516
                <xsl:when test=".='unsigned long'">ULONG</xsl:when>
 
517
                <xsl:when test=".='unsigned long long'">ULONG64</xsl:when>
 
518
                <xsl:when test=".='char'">CHAR</xsl:when>
 
519
                <xsl:when test=".='string'">CHAR *</xsl:when>
 
520
                <xsl:when test=".='wchar'">OLECHAR</xsl:when>
 
521
                <xsl:when test=".='wstring'">BSTR</xsl:when>
 
522
                <!-- UUID type -->
 
523
                <xsl:when test=".='uuid'">GUID</xsl:when>
 
524
                <!-- system interface types -->
 
525
                <xsl:when test=".='$unknown'">IUnknown *</xsl:when>
 
526
                <xsl:otherwise>
 
527
                    <xsl:choose>
 
528
                        <!-- enum types -->
 
529
                        <xsl:when test="
 
530
                            (ancestor::library/enum[@name=current()]) or
 
531
                            (ancestor::library/if[@target=$self_target]/enum[@name=current()])
 
532
                        ">
 
533
                            <xsl:value-of select="."/>
 
534
                        </xsl:when>
 
535
                        <!-- custom interface types -->
 
536
                        <xsl:when test="
 
537
                            (name(current())='enumerator' and
 
538
                             ((ancestor::library/enumerator[@name=current()]) or
 
539
                              (ancestor::library/if[@target=$self_target]/enumerator[@name=current()]))
 
540
                            ) or
 
541
                            ((ancestor::library/interface[@name=current()]) or
 
542
                             (ancestor::library/if[@target=$self_target]/interface[@name=current()])
 
543
                            ) or
 
544
                            ((ancestor::library/collection[@name=current()]) or
 
545
                             (ancestor::library/if[@target=$self_target]/collection[@name=current()])
 
546
                            )
 
547
                        ">
 
548
                            <xsl:value-of select="."/><xsl:text> *</xsl:text>
 
549
                        </xsl:when>
 
550
                        <!-- other types -->
 
551
                        <xsl:otherwise>
 
552
                            <xsl:message terminate="yes">
 
553
                                <xsl:text>Unknown parameter type: </xsl:text>
 
554
                                <xsl:value-of select="."/>
 
555
                            </xsl:message>
 
556
                        </xsl:otherwise>
 
557
                    </xsl:choose>
 
558
                </xsl:otherwise>
 
559
            </xsl:choose>
 
560
        </xsl:otherwise>
 
561
    </xsl:choose>
 
562
</xsl:template>
 
563
 
 
564
</xsl:stylesheet>
 
565