VirtualBox

source: vbox/trunk/src/VBox/Main/glue/glue-java.xsl@ 47850

Last change on this file since 47850 was 47850, checked in by vboxsync, 12 years ago

Main: attempt to fix xpcom build.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 147.9 KB
Line 
1<xsl:stylesheet version = '1.0'
2 xmlns:xsl='http://www.w3.org/1999/XSL/Transform'
3 xmlns:vbox="http://www.215389.xyz/"
4 xmlns:exsl="http://exslt.org/common"
5 extension-element-prefixes="exsl">
6
7<!--
8
9 glue-java.xsl:
10 XSLT stylesheet that generates Java glue code for XPCOM, MSCOM and JAX-WS from
11 VirtualBox.xidl.
12
13 Copyright (C) 2010-2013 Oracle Corporation
14
15 This file is part of VirtualBox Open Source Edition (OSE), as
16 available from http://www.215389.xyz. 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
24<xsl:output
25 method="text"
26 version="1.0"
27 encoding="utf-8"
28 indent="no"/>
29
30<!-- - - - - - - - - - - - - - - - - - - - - - -
31 global XSLT variables
32 - - - - - - - - - - - - - - - - - - - - - - -->
33
34<xsl:variable name="G_xsltFilename" select="'glue-java.xsl'" />
35<xsl:variable name="G_virtualBoxPackage" select="concat('org.virtualbox', $G_vboxApiSuffix)" />
36<xsl:variable name="G_virtualBoxPackageCom" select="concat('org.virtualbox', $G_vboxApiSuffix, '.', $G_vboxGlueStyle)" />
37<xsl:variable name="G_virtualBoxWsdl" select="concat('&quot;vboxwebService', $G_vboxApiSuffix, '.wsdl&quot;')" />
38<!-- collect all interfaces with "wsmap='suppress'" in a global variable for quick lookup -->
39<xsl:variable name="G_setSuppressedInterfaces"
40 select="//interface[@wsmap='suppress']" />
41
42<xsl:include href="../idl/typemap-shared.inc.xsl" />
43
44<xsl:strip-space elements="*"/>
45
46<xsl:template name="fileheader">
47 <xsl:param name="name" />
48 <xsl:text>/*
49 * Copyright (C) 2010-2013 Oracle Corporation
50 *
51 * This file is part of the VirtualBox SDK, as available from
52 * http://www.215389.xyz. This library is free software; you can
53 * redistribute it and/or modify it under the terms of the GNU Lesser General
54 * Public License as published by the Free Software Foundation, in version 2.1
55 * as it comes in the "COPYING.LIB" file of the VirtualBox SDK distribution.
56 * This library is distributed in the hope that it will be useful, but WITHOUT
57 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
58 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
59 * License for more details.
60 *
61</xsl:text>
62 <xsl:value-of select="concat(' * ', $name)"/>
63<xsl:text>
64 *
65 * DO NOT EDIT! This is a generated file.
66 * Generated from: src/VBox/Main/idl/VirtualBox.xidl (VirtualBox's interface definitions in XML)
67 * Generator: src/VBox/Main/glue/glue-java.xsl
68 */
69
70</xsl:text>
71</xsl:template>
72
73<xsl:template name="startFile">
74 <xsl:param name="file" />
75 <xsl:param name="package" />
76
77 <xsl:choose>
78 <xsl:when test="$filelistonly=''">
79 <xsl:value-of select="concat('&#10;// ##### BEGINFILE &quot;', $G_vboxDirPrefix, $file, '&quot;&#10;&#10;')" />
80 <xsl:call-template name="fileheader">
81 <xsl:with-param name="name" select="$file" />
82 </xsl:call-template>
83
84 <xsl:value-of select="concat('package ', $package, ';&#10;&#10;')" />
85 <xsl:value-of select="concat('import ', $G_virtualBoxPackageCom, '.*;&#10;')" />
86
87 <xsl:choose>
88 <xsl:when test="$G_vboxGlueStyle='xpcom'">
89 <xsl:text>import org.mozilla.interfaces.*;&#10;</xsl:text>
90 </xsl:when>
91
92 <xsl:when test="$G_vboxGlueStyle='mscom'">
93 <xsl:text>import com.jacob.com.*;&#10;</xsl:text>
94 <xsl:text>import com.jacob.activeX.ActiveXComponent;&#10;</xsl:text>
95 </xsl:when>
96
97 <xsl:when test="$G_vboxGlueStyle='jaxws'">
98 <xsl:text>import javax.xml.ws.*;&#10;</xsl:text>
99 </xsl:when>
100
101 <xsl:otherwise>
102 <xsl:call-template name="fatalError">
103 <xsl:with-param name="msg" select="'no header rule (startFile)'" />
104 </xsl:call-template>
105 </xsl:otherwise>
106 </xsl:choose>
107 </xsl:when>
108 <xsl:otherwise>
109 <xsl:value-of select="concat('&#9;', $G_vboxDirPrefix, $file, ' \&#10;')"/>
110 </xsl:otherwise>
111 </xsl:choose>
112</xsl:template>
113
114<xsl:template name="endFile">
115 <xsl:param name="file" />
116 <xsl:if test="$filelistonly=''">
117 <xsl:value-of select="concat('&#10;// ##### ENDFILE &quot;', $file, '&quot;&#10;&#10;')" />
118 </xsl:if>
119</xsl:template>
120
121
122<xsl:template name="string-replace">
123 <xsl:param name="haystack"/>
124 <xsl:param name="needle"/>
125 <xsl:param name="replacement"/>
126 <xsl:param name="onlyfirst" select="false"/>
127 <xsl:choose>
128 <xsl:when test="contains($haystack, $needle)">
129 <xsl:value-of select="substring-before($haystack, $needle)"/>
130 <xsl:value-of select="$replacement"/>
131 <xsl:choose>
132 <xsl:when test="$onlyfirst = 'true'">
133 <xsl:value-of select="substring-after($haystack, $needle)"/>
134 </xsl:when>
135 <xsl:otherwise>
136 <xsl:call-template name="string-replace">
137 <xsl:with-param name="haystack" select="substring-after($haystack, $needle)"/>
138 <xsl:with-param name="needle" select="$needle"/>
139 <xsl:with-param name="replacement" select="$replacement"/>
140 </xsl:call-template>
141 </xsl:otherwise>
142 </xsl:choose>
143 </xsl:when>
144 <xsl:otherwise>
145 <xsl:value-of select="$haystack"/>
146 </xsl:otherwise>
147 </xsl:choose>
148</xsl:template>
149
150<xsl:template name="string-trim">
151 <xsl:param name="text"/>
152
153 <xsl:variable name="begin" select="substring($text, 1, 1)"/>
154 <xsl:choose>
155 <xsl:when test="$begin = ' ' or $begin = '&#10;' or $begin = '&#13;'">
156 <xsl:call-template name="string-trim">
157 <xsl:with-param name="text" select="substring($text, 2)"/>
158 </xsl:call-template>
159 </xsl:when>
160 <xsl:otherwise>
161 <xsl:variable name="end" select="substring($text, string-length($text) - 1, 1)"/>
162 <xsl:choose>
163 <xsl:when test="$end = ' ' or $end = '&#10;' or $end = '&#13;'">
164 <xsl:call-template name="string-trim">
165 <xsl:with-param name="text" select="substring($text, 1, string-length($text) - 1)"/>
166 </xsl:call-template>
167 </xsl:when>
168 <xsl:otherwise>
169 <xsl:choose>
170 <xsl:when test="contains($text, '&#10; ')">
171 <xsl:variable name="tmptext">
172 <xsl:call-template name="string-replace">
173 <xsl:with-param name="haystack" select="$text"/>
174 <xsl:with-param name="needle" select="'&#10; '"/>
175 <xsl:with-param name="replacement" select="'&#10;'"/>
176 </xsl:call-template>
177 </xsl:variable>
178 <xsl:call-template name="string-trim">
179 <xsl:with-param name="text" select="$tmptext"/>
180 </xsl:call-template>
181 </xsl:when>
182 <xsl:otherwise>
183 <xsl:value-of select="$text"/>
184 </xsl:otherwise>
185 </xsl:choose>
186 </xsl:otherwise>
187 </xsl:choose>
188 </xsl:otherwise>
189 </xsl:choose>
190</xsl:template>
191
192<!-- descriptions -->
193
194<xsl:template match="*/text()">
195 <!-- TODO: strip out @c/@a for now. long term solution is changing that to a
196 tag in the xidl file, and translate it when generating doxygen etc. -->
197 <xsl:variable name="rep1">
198 <xsl:call-template name="string-replace">
199 <xsl:with-param name="haystack" select="."/>
200 <xsl:with-param name="needle" select="'@c'"/>
201 <xsl:with-param name="replacement" select="''"/>
202 </xsl:call-template>
203 </xsl:variable>
204
205 <xsl:variable name="rep2">
206 <xsl:call-template name="string-replace">
207 <xsl:with-param name="haystack" select="$rep1"/>
208 <xsl:with-param name="needle" select="'@a'"/>
209 <xsl:with-param name="replacement" select="''"/>
210 </xsl:call-template>
211 </xsl:variable>
212
213 <xsl:variable name="rep3">
214 <xsl:call-template name="string-replace">
215 <xsl:with-param name="haystack" select="$rep2"/>
216 <xsl:with-param name="needle" select="'@todo'"/>
217 <xsl:with-param name="replacement" select="'TODO'"/>
218 </xsl:call-template>
219 </xsl:variable>
220
221 <xsl:variable name="rep4">
222 <xsl:call-template name="string-trim">
223 <xsl:with-param name="text" select="$rep3"/>
224 </xsl:call-template>
225 </xsl:variable>
226
227 <xsl:value-of select="$rep4"/>
228</xsl:template>
229
230<!--
231 * all sub-elements that are not explicitly matched are considered to be
232 * html tags and copied w/o modifications
233-->
234<xsl:template match="desc//*">
235 <xsl:variable name="tagname" select="local-name()"/>
236 <xsl:value-of select="concat('&lt;', $tagname, '&gt;')"/>
237 <xsl:apply-templates/>
238 <xsl:value-of select="concat('&lt;/', $tagname, '&gt;')"/>
239</xsl:template>
240
241<xsl:template name="emit_refsig">
242 <xsl:param name="context"/>
243 <xsl:param name="identifier"/>
244
245 <xsl:choose>
246 <xsl:when test="//enum[@name=$context]/const[@name=$identifier]">
247 <xsl:value-of select="$identifier"/>
248 </xsl:when>
249 <xsl:when test="//interface[@name=$context]/method[@name=$identifier]">
250 <xsl:value-of select="$identifier"/>
251 <xsl:text>(</xsl:text>
252 <xsl:for-each select="//interface[@name=$context]/method[@name=$identifier]/param">
253 <xsl:if test="@dir!='return'">
254 <xsl:if test="position() > 1">
255 <xsl:text>,</xsl:text>
256 </xsl:if>
257 <xsl:choose>
258 <xsl:when test="@dir='out'">
259 <xsl:text>Holder</xsl:text>
260 </xsl:when>
261 <xsl:otherwise>
262 <xsl:call-template name="typeIdl2Glue">
263 <xsl:with-param name="type" select="@type"/>
264 <xsl:with-param name="safearray" select="@safearray"/>
265 <xsl:with-param name="skiplisttype" select="'yes'"/>
266 </xsl:call-template>
267 </xsl:otherwise>
268 </xsl:choose>
269 </xsl:if>
270 </xsl:for-each>
271 <xsl:text>)</xsl:text>
272 </xsl:when>
273 <xsl:when test="//interface[@name=$context]/attribute[@name=$identifier]">
274 <xsl:call-template name="makeGetterName">
275 <xsl:with-param name="attrname" select="$identifier" />
276 </xsl:call-template>
277 <xsl:text>()</xsl:text>
278 </xsl:when>
279 <xsl:otherwise>
280 <xsl:call-template name="fatalError">
281 <xsl:with-param name="msg" select="concat('unknown reference destination in @see/@link: context=', $context, ' identifier=', $identifier)" />
282 </xsl:call-template>
283 </xsl:otherwise>
284 </xsl:choose>
285</xsl:template>
286
287<!--
288 * link
289-->
290<xsl:template match="desc//link">
291 <xsl:text>{@link </xsl:text>
292 <xsl:apply-templates select="." mode="middle"/>
293 <xsl:text>}</xsl:text>
294</xsl:template>
295
296<xsl:template match="link" mode="middle">
297 <xsl:variable name="linktext">
298 <xsl:call-template name="string-replace">
299 <xsl:with-param name="haystack" select="@to"/>
300 <xsl:with-param name="needle" select="'_'"/>
301 <xsl:with-param name="replacement" select="'#'"/>
302 <xsl:with-param name="onlyfirst" select="'true'"/>
303 </xsl:call-template>
304 </xsl:variable>
305 <xsl:choose>
306 <xsl:when test="substring($linktext, 1, 1)='#'">
307 <xsl:variable name="context">
308 <xsl:choose>
309 <xsl:when test="local-name(../..)='interface' or local-name(../..)='enum'">
310 <xsl:value-of select="../../@name"/>
311 </xsl:when>
312 <xsl:when test="local-name(../../..)='interface' or local-name(../../..)='enum'">
313 <xsl:value-of select="../../../@name"/>
314 </xsl:when>
315 <xsl:when test="local-name(../../../..)='interface' or local-name(../../../..)='enum'">
316 <xsl:value-of select="../../../../@name"/>
317 </xsl:when>
318 <xsl:when test="local-name(../../../../..)='interface' or local-name(../../../../..)='enum'">
319 <xsl:value-of select="../../../../../@name"/>
320 </xsl:when>
321 <xsl:when test="local-name(../../../../../..)='interface' or local-name(../../../../../..)='enum'">
322 <xsl:value-of select="../../../../../../@name"/>
323 </xsl:when>
324 <xsl:otherwise>
325 <xsl:call-template name="fatalError">
326 <xsl:with-param name="msg" select="concat('cannot determine context for identifier ', $linktext)" />
327 </xsl:call-template>
328 </xsl:otherwise>
329 </xsl:choose>
330 </xsl:variable>
331 <xsl:variable name="linkname">
332 <xsl:value-of select="substring($linktext, 2)"/>
333 </xsl:variable>
334 <xsl:text>#</xsl:text>
335 <xsl:call-template name="emit_refsig">
336 <xsl:with-param name="context" select="$context"/>
337 <xsl:with-param name="identifier" select="$linkname"/>
338 </xsl:call-template>
339 </xsl:when>
340 <xsl:when test="contains($linktext, '::')">
341 <xsl:variable name="context">
342 <xsl:value-of select="substring-before($linktext, '::')"/>
343 </xsl:variable>
344 <xsl:variable name="linkname">
345 <xsl:value-of select="substring-after($linktext, '::')"/>
346 </xsl:variable>
347 <xsl:value-of select="concat($G_virtualBoxPackage, '.', $context, '#')"/>
348 <xsl:call-template name="emit_refsig">
349 <xsl:with-param name="context" select="$context"/>
350 <xsl:with-param name="identifier" select="$linkname"/>
351 </xsl:call-template>
352 </xsl:when>
353 <xsl:otherwise>
354 <xsl:value-of select="concat($G_virtualBoxPackage, '.', $linktext)"/>
355 </xsl:otherwise>
356 </xsl:choose>
357</xsl:template>
358<!--
359 * note
360-->
361<xsl:template match="desc/note">
362 <xsl:if test="not(@internal='yes')">
363 <xsl:text>&#10;NOTE: </xsl:text>
364 <xsl:apply-templates/>
365 <xsl:text>&#10;</xsl:text>
366 </xsl:if>
367</xsl:template>
368
369<!--
370 * see
371-->
372<xsl:template match="desc/see">
373 <!-- TODO: quirk in our xidl file: only one <see> tag with <link> nested
374 into it, translate this to multiple @see lines and strip the rest.
375 Should be replaced in the xidl by multiple <see> without nested tag -->
376 <xsl:text>&#10;</xsl:text>
377 <xsl:apply-templates match="link"/>
378</xsl:template>
379
380<xsl:template match="desc/see/text()"/>
381
382<xsl:template match="desc/see/link">
383 <xsl:text>@see </xsl:text>
384 <xsl:apply-templates select="." mode="middle"/>
385 <xsl:text>&#10;</xsl:text>
386</xsl:template>
387
388<!--
389 * common comment prologue (handles group IDs)
390-->
391<xsl:template match="desc" mode="begin">
392 <xsl:param name="id" select="@group | preceding::descGroup[1]/@id"/>
393 <xsl:text>&#10;/**&#10;</xsl:text>
394 <xsl:if test="$id">
395 <xsl:value-of select="concat(' @ingroup ', $id, '&#10;')"/>
396 </xsl:if>
397</xsl:template>
398
399<!--
400 * common middle part of the comment block
401-->
402<xsl:template match="desc" mode="middle">
403 <xsl:apply-templates select="text() | *[not(self::note or self::see)]"/>
404 <xsl:apply-templates select="note"/>
405 <xsl:apply-templates select="see"/>
406</xsl:template>
407
408<!--
409 * result part of the comment block
410-->
411<xsl:template match="desc" mode="results">
412 <xsl:if test="result">
413 <xsl:text>&#10;Expected result codes:&#10;</xsl:text>
414 <xsl:text>&lt;table&gt;&#10;</xsl:text>
415 <xsl:for-each select="result">
416 <xsl:text>&lt;tr&gt;</xsl:text>
417 <xsl:choose>
418 <xsl:when test="ancestor::library/result[@name=current()/@name]">
419 <xsl:value-of select="concat('&lt;td&gt;@link ::', @name, ' ', @name, '&lt;/td&gt;')"/>
420 </xsl:when>
421 <xsl:otherwise>
422 <xsl:value-of select="concat('&lt;td&gt;', @name, '&lt;/td&gt;')"/>
423 </xsl:otherwise>
424 </xsl:choose>
425 <xsl:text>&lt;td&gt;</xsl:text>
426 <xsl:apply-templates select="text() | *[not(self::note or self::see or
427 self::result)]"/>
428 <xsl:text>&lt;/td&gt;&lt;tr&gt;&#10;</xsl:text>
429 </xsl:for-each>
430 <xsl:text>&lt;/table&gt;&#10;</xsl:text>
431 </xsl:if>
432</xsl:template>
433
434<!--
435 * translates the string to uppercase
436-->
437<xsl:template name="uppercase">
438 <xsl:param name="str" select="."/>
439 <xsl:value-of select="translate($str, $G_lowerCase, $G_upperCase)"/>
440</xsl:template>
441
442<!--
443 * comment for interfaces
444-->
445<xsl:template match="desc" mode="interface">
446 <xsl:apply-templates select="." mode="begin"/>
447 <xsl:apply-templates select="." mode="middle"/>
448 <xsl:text>&#10;Interface ID: &lt;tt&gt;{</xsl:text>
449 <xsl:call-template name="uppercase">
450 <xsl:with-param name="str" select="../@uuid"/>
451 </xsl:call-template>
452 <xsl:text>}&lt;/tt&gt;&#10;*/&#10;</xsl:text>
453</xsl:template>
454
455<!--
456 * comment for attribute getters
457-->
458<xsl:template match="desc" mode="attribute_get">
459 <xsl:apply-templates select="." mode="begin"/>
460 <xsl:apply-templates select="text() | *[not(self::note or self::see or self::result)]"/>
461 <xsl:apply-templates select="." mode="results"/>
462 <xsl:apply-templates select="note"/>
463 <xsl:text>&#10;@return </xsl:text>
464 <xsl:call-template name="typeIdl2Glue">
465 <xsl:with-param name="type" select="../@type"/>
466 <xsl:with-param name="safearray" select="../@safearray"/>
467 </xsl:call-template>
468 <xsl:text>&#10;</xsl:text>
469 <xsl:apply-templates select="see"/>
470 <xsl:text>*/&#10;</xsl:text>
471</xsl:template>
472
473<!--
474 * comment for attribute setters
475-->
476<xsl:template match="desc" mode="attribute_set">
477 <xsl:apply-templates select="." mode="begin"/>
478 <xsl:apply-templates select="text() | *[not(self::note or self::see or self::result)]"/>
479 <xsl:apply-templates select="." mode="results"/>
480 <xsl:apply-templates select="note"/>
481 <xsl:text>&#10;@param value </xsl:text>
482 <xsl:call-template name="typeIdl2Glue">
483 <xsl:with-param name="type" select="../@type"/>
484 <xsl:with-param name="safearray" select="../@safearray"/>
485 </xsl:call-template>
486 <xsl:text>&#10;</xsl:text>
487 <xsl:apply-templates select="see"/>
488 <xsl:text>&#10;*/&#10;</xsl:text>
489</xsl:template>
490
491<!--
492 * comment for methods
493-->
494<xsl:template match="desc" mode="method">
495 <xsl:apply-templates select="." mode="begin"/>
496 <xsl:apply-templates select="text() | *[not(self::note or self::see or self::result)]"/>
497 <xsl:for-each select="../param">
498 <xsl:apply-templates select="desc"/>
499 </xsl:for-each>
500 <xsl:apply-templates select="." mode="results"/>
501 <xsl:apply-templates select="note"/>
502 <xsl:apply-templates select="../param/desc/note"/>
503 <xsl:apply-templates select="see"/>
504 <xsl:text>&#10;*/&#10;</xsl:text>
505</xsl:template>
506
507<!--
508 * comment for method parameters
509-->
510<xsl:template match="method/param/desc">
511 <xsl:if test="text() | *[not(self::note or self::see)]">
512 <xsl:choose>
513 <xsl:when test="../@dir='return'">
514 <xsl:text>&#10;@return </xsl:text>
515 </xsl:when>
516 <xsl:otherwise>
517 <xsl:text>&#10;@param </xsl:text>
518 <xsl:value-of select="../@name"/>
519 <xsl:text> </xsl:text>
520 </xsl:otherwise>
521 </xsl:choose>
522 <xsl:apply-templates select="text() | *[not(self::note or self::see)]"/>
523 <xsl:text>&#10;</xsl:text>
524 </xsl:if>
525</xsl:template>
526
527<!--
528 * comment for enums
529-->
530<xsl:template match="desc" mode="enum">
531 <xsl:apply-templates select="." mode="begin"/>
532 <xsl:apply-templates select="." mode="middle"/>
533 <xsl:text>&#10;Interface ID: &lt;tt&gt;{</xsl:text>
534 <xsl:call-template name="uppercase">
535 <xsl:with-param name="str" select="../@uuid"/>
536 </xsl:call-template>
537 <xsl:text>}&lt;/tt&gt;&#10;*/&#10;</xsl:text>
538</xsl:template>
539
540<!--
541 * comment for enum values
542-->
543<xsl:template match="desc" mode="enum_const">
544 <xsl:apply-templates select="." mode="begin"/>
545 <xsl:apply-templates select="." mode="middle"/>
546 <xsl:text>&#10;*/&#10;</xsl:text>
547</xsl:template>
548
549<!--
550 * ignore descGroups by default (processed in /idl)
551-->
552<xsl:template match="descGroup"/>
553
554
555
556<!-- actual code generation -->
557
558<xsl:template name="genEnum">
559 <xsl:param name="enumname" />
560 <xsl:param name="filename" />
561
562 <xsl:call-template name="startFile">
563 <xsl:with-param name="file" select="$filename" />
564 <xsl:with-param name="package" select="$G_virtualBoxPackage" />
565 </xsl:call-template>
566
567 <xsl:if test="$filelistonly=''">
568 <xsl:apply-templates select="desc" mode="enum"/>
569 <xsl:value-of select="concat('public enum ', $enumname, '&#10;')" />
570 <xsl:text>{&#10;</xsl:text>
571 <xsl:for-each select="const">
572 <xsl:apply-templates select="desc" mode="enum_const"/>
573 <xsl:variable name="enumconst" select="@name" />
574 <xsl:value-of select="concat(' ', $enumconst, '(', @value, ')')" />
575 <xsl:choose>
576 <xsl:when test="not(position()=last())">
577 <xsl:text>,&#10;</xsl:text>
578 </xsl:when>
579 <xsl:otherwise>
580 <xsl:text>;&#10;</xsl:text>
581 </xsl:otherwise>
582 </xsl:choose>
583 </xsl:for-each>
584
585 <xsl:text>&#10;</xsl:text>
586 <xsl:text> private final int value;&#10;&#10;</xsl:text>
587
588 <xsl:value-of select="concat(' ', $enumname, '(int v)&#10;')" />
589 <xsl:text> {&#10;</xsl:text>
590 <xsl:text> value = v;&#10;</xsl:text>
591 <xsl:text> }&#10;&#10;</xsl:text>
592
593 <xsl:text> public int value()&#10;</xsl:text>
594 <xsl:text> {&#10;</xsl:text>
595 <xsl:text> return value;&#10;</xsl:text>
596 <xsl:text> }&#10;&#10;</xsl:text>
597
598 <xsl:value-of select="concat(' public static ', $enumname, ' fromValue(long v)&#10;')" />
599 <xsl:text> {&#10;</xsl:text>
600 <xsl:value-of select="concat(' for (', $enumname, ' c: ', $enumname, '.values())&#10;')" />
601 <xsl:text> {&#10;</xsl:text>
602 <xsl:text> if (c.value == (int)v)&#10;</xsl:text>
603 <xsl:text> {&#10;</xsl:text>
604 <xsl:text> return c;&#10;</xsl:text>
605 <xsl:text> }&#10;</xsl:text>
606 <xsl:text> }&#10;</xsl:text>
607 <xsl:text> throw new IllegalArgumentException(Long.toString(v));&#10;</xsl:text>
608 <xsl:text> }&#10;&#10;</xsl:text>
609
610 <xsl:value-of select="concat(' public static ', $enumname, ' fromValue(String v)&#10;')" />
611 <xsl:text> {&#10;</xsl:text>
612 <xsl:value-of select="concat(' return valueOf(', $enumname, '.class, v);&#10;')" />
613 <xsl:text> }&#10;</xsl:text>
614 <xsl:text>}&#10;&#10;</xsl:text>
615 </xsl:if>
616
617 <xsl:call-template name="endFile">
618 <xsl:with-param name="file" select="$filename" />
619 </xsl:call-template>
620
621</xsl:template>
622
623<xsl:template name="startExcWrapper">
624 <xsl:text> try&#10;</xsl:text>
625 <xsl:text> {&#10;</xsl:text>
626</xsl:template>
627
628<xsl:template name="endExcWrapper">
629
630 <xsl:choose>
631 <xsl:when test="$G_vboxGlueStyle='xpcom'">
632 <xsl:text> }&#10;</xsl:text>
633 <xsl:text> catch (org.mozilla.xpcom.XPCOMException e)&#10;</xsl:text>
634 <xsl:text> {&#10;</xsl:text>
635 <xsl:text> throw new VBoxException(e.getMessage(), e);&#10;</xsl:text>
636 <xsl:text> }&#10;</xsl:text>
637 </xsl:when>
638
639 <xsl:when test="$G_vboxGlueStyle='mscom'">
640 <xsl:text> }&#10;</xsl:text>
641 <xsl:text> catch (com.jacob.com.ComException e)&#10;</xsl:text>
642 <xsl:text> {&#10;</xsl:text>
643 <xsl:text> throw new VBoxException(e.getMessage(), e);&#10;</xsl:text>
644 <xsl:text> }&#10;</xsl:text>
645 </xsl:when>
646
647 <xsl:when test="$G_vboxGlueStyle='jaxws'">
648 <xsl:text> }&#10;</xsl:text>
649 <xsl:text> catch (InvalidObjectFaultMsg e)&#10;</xsl:text>
650 <xsl:text> {&#10;</xsl:text>
651 <xsl:text> throw new VBoxException(e.getMessage(), e, this.port);&#10;</xsl:text>
652 <xsl:text> }&#10;</xsl:text>
653 <xsl:text> catch (RuntimeFaultMsg e)&#10;</xsl:text>
654 <xsl:text> {&#10;</xsl:text>
655 <xsl:text> throw new VBoxException(e.getMessage(), e, this.port);&#10;</xsl:text>
656 <xsl:text> }&#10;</xsl:text>
657 </xsl:when>
658
659 <xsl:otherwise>
660 <xsl:call-template name="fatalError">
661 <xsl:with-param name="msg" select="'no header rule (startFile)'" />
662 </xsl:call-template>
663 </xsl:otherwise>
664 </xsl:choose>
665</xsl:template>
666
667<xsl:template name="wrappedName">
668 <xsl:param name="ifname" />
669
670 <xsl:choose>
671 <xsl:when test="$G_vboxGlueStyle='xpcom'">
672 <xsl:value-of select="concat('org.mozilla.interfaces.', $ifname)" />
673 </xsl:when>
674
675 <xsl:when test="$G_vboxGlueStyle='mscom'">
676 <xsl:text>com.jacob.com.Dispatch</xsl:text>
677 </xsl:when>
678
679 <xsl:when test="$G_vboxGlueStyle='jaxws'">
680 <xsl:text>String</xsl:text>
681 </xsl:when>
682
683 <xsl:otherwise>
684 <xsl:call-template name="fatalError">
685 <xsl:with-param name="msg" select="'no wrapper naming rule defined (wrappedName)'" />
686 </xsl:call-template>
687 </xsl:otherwise>
688
689 </xsl:choose>
690</xsl:template>
691
692<xsl:template name="fullClassName">
693 <xsl:param name="name" />
694 <xsl:param name="origname" />
695 <xsl:param name="collPrefix" />
696
697 <xsl:choose>
698 <xsl:when test="//enum[@name=$name] or //enum[@name=$origname]">
699 <xsl:value-of select="concat($G_virtualBoxPackage, concat('.', $name))" />
700 </xsl:when>
701 <xsl:when test="//interface[@name=$name]">
702 <xsl:value-of select="concat($G_virtualBoxPackage, concat('.', $name))" />
703 </xsl:when>
704 <xsl:otherwise>
705 <xsl:call-template name="fatalError">
706 <xsl:with-param name="msg" select="concat('fullClassName: Type &quot;', $name, '&quot; is not supported.')" />
707 </xsl:call-template>
708 </xsl:otherwise>
709 </xsl:choose>
710</xsl:template>
711
712<xsl:template name="typeIdl2Glue">
713 <xsl:param name="type" />
714 <xsl:param name="safearray" />
715 <xsl:param name="forceelem" />
716 <xsl:param name="skiplisttype" />
717
718 <xsl:variable name="needarray" select="($safearray='yes') and not($forceelem='yes')" />
719 <xsl:variable name="needlist" select="($needarray) and not($type='octet')" />
720
721 <xsl:if test="($needlist)">
722 <xsl:text>List</xsl:text>
723 <xsl:if test="not($skiplisttype='yes')">
724 <xsl:text>&lt;</xsl:text>
725 </xsl:if>
726 </xsl:if>
727
728 <xsl:if test="not($needlist) or not($skiplisttype='yes')">
729 <!-- look up Java type from IDL type from table array in typemap-shared.inc.xsl -->
730 <xsl:variable name="javatypefield" select="exsl:node-set($G_aSharedTypes)/type[@idlname=$type]/@javaname" />
731
732 <xsl:choose>
733 <xsl:when test="string-length($javatypefield)">
734 <xsl:value-of select="$javatypefield" />
735 </xsl:when>
736 <!-- not a standard type: then it better be one of the types defined in the XIDL -->
737 <xsl:when test="$type='$unknown'">IUnknown</xsl:when>
738 <xsl:otherwise>
739 <xsl:call-template name="fullClassName">
740 <xsl:with-param name="name" select="$type" />
741 <xsl:with-param name="collPrefix" select="''"/>
742 </xsl:call-template>
743 </xsl:otherwise>
744 </xsl:choose>
745 </xsl:if>
746
747 <xsl:choose>
748 <xsl:when test="($needlist)">
749 <xsl:if test="not($skiplisttype='yes')">
750 <xsl:text>&gt;</xsl:text>
751 </xsl:if>
752 </xsl:when>
753 <xsl:when test="($needarray)">
754 <xsl:text>[]</xsl:text>
755 </xsl:when>
756 </xsl:choose>
757</xsl:template>
758
759<!--
760 typeIdl2Back: converts $type into a type as used by the backend.
761 -->
762<xsl:template name="typeIdl2Back">
763 <xsl:param name="type" />
764 <xsl:param name="safearray" />
765 <xsl:param name="forceelem" />
766
767 <xsl:choose>
768 <xsl:when test="($G_vboxGlueStyle='xpcom')">
769 <xsl:variable name="needarray" select="($safearray='yes') and not($forceelem='yes')" />
770
771 <xsl:choose>
772 <xsl:when test="$type='long long'">
773 <xsl:text>long</xsl:text>
774 </xsl:when>
775
776 <xsl:when test="$type='unsigned long'">
777 <xsl:text>long</xsl:text>
778 </xsl:when>
779
780 <xsl:when test="$type='long'">
781 <xsl:text>int</xsl:text>
782 </xsl:when>
783
784 <xsl:when test="$type='unsigned short'">
785 <xsl:text>int</xsl:text>
786 </xsl:when>
787
788 <xsl:when test="$type='short'">
789 <xsl:text>short</xsl:text>
790 </xsl:when>
791
792 <xsl:when test="$type='octet'">
793 <xsl:text>byte</xsl:text>
794 </xsl:when>
795
796 <xsl:when test="$type='boolean'">
797 <xsl:text>boolean</xsl:text>
798 </xsl:when>
799
800 <xsl:when test="$type='$unknown'">
801 <xsl:text>nsISupports</xsl:text>
802 </xsl:when>
803
804 <xsl:when test="$type='wstring'">
805 <xsl:text>String</xsl:text>
806 </xsl:when>
807
808 <xsl:when test="$type='uuid'">
809 <xsl:text>String</xsl:text>
810 </xsl:when>
811
812 <xsl:when test="//interface[@name=$type]/@wsmap='struct'">
813 <xsl:call-template name="wrappedName">
814 <xsl:with-param name="ifname" select="$type" />
815 </xsl:call-template>
816 </xsl:when>
817
818 <xsl:when test="//interface[@name=$type]">
819 <xsl:call-template name="wrappedName">
820 <xsl:with-param name="ifname" select="$type" />
821 </xsl:call-template>
822 </xsl:when>
823
824 <xsl:when test="//enum[@name=$type]">
825 <xsl:text>long</xsl:text>
826 </xsl:when>
827
828 <xsl:otherwise>
829 <xsl:call-template name="fullClassName">
830 <xsl:with-param name="name" select="$type" />
831 </xsl:call-template>
832 </xsl:otherwise>
833
834 </xsl:choose>
835 <xsl:if test="$needarray">
836 <xsl:text>[]</xsl:text>
837 </xsl:if>
838 </xsl:when>
839
840 <xsl:when test="($G_vboxGlueStyle='mscom')">
841 <xsl:text>Variant</xsl:text>
842 </xsl:when>
843
844 <xsl:when test="($G_vboxGlueStyle='jaxws')">
845 <xsl:variable name="needarray" select="($safearray='yes' and not($type='octet')) and not($forceelem='yes')" />
846
847 <xsl:if test="$needarray">
848 <xsl:text>List&lt;</xsl:text>
849 </xsl:if>
850 <xsl:choose>
851 <xsl:when test="$type='$unknown'">
852 <xsl:text>String</xsl:text>
853 </xsl:when>
854
855 <xsl:when test="//interface[@name=$type]/@wsmap='managed'">
856 <xsl:text>String</xsl:text>
857 </xsl:when>
858
859 <xsl:when test="//interface[@name=$type]/@wsmap='struct'">
860 <xsl:value-of select="concat($G_virtualBoxPackageCom, '.', $type)" />
861 </xsl:when>
862
863 <xsl:when test="//enum[@name=$type]">
864 <xsl:value-of select="concat($G_virtualBoxPackageCom, '.', $type)" />
865 </xsl:when>
866
867 <!-- we encode byte arrays as Base64 strings. -->
868 <xsl:when test="$type='octet'">
869 <xsl:text>/*base64*/String</xsl:text>
870 </xsl:when>
871
872 <xsl:when test="$type='long long'">
873 <xsl:text>Long</xsl:text>
874 </xsl:when>
875
876 <xsl:when test="$type='unsigned long'">
877 <xsl:text>Long</xsl:text>
878 </xsl:when>
879
880 <xsl:when test="$type='long'">
881 <xsl:text>Integer</xsl:text>
882 </xsl:when>
883
884 <xsl:when test="$type='unsigned short'">
885 <xsl:text>Integer</xsl:text>
886 </xsl:when>
887
888 <xsl:when test="$type='short'">
889 <xsl:text>Short</xsl:text>
890 </xsl:when>
891
892 <xsl:when test="$type='boolean'">
893 <xsl:text>Boolean</xsl:text>
894 </xsl:when>
895
896 <xsl:when test="$type='wstring'">
897 <xsl:text>String</xsl:text>
898 </xsl:when>
899
900 <xsl:when test="$type='uuid'">
901 <xsl:text>String</xsl:text>
902 </xsl:when>
903
904 <xsl:otherwise>
905 <xsl:call-template name="fatalError">
906 <xsl:with-param name="msg" select="concat('Unhandled type ', $type, ' (typeIdl2Back)')" />
907 </xsl:call-template>
908 </xsl:otherwise>
909
910 </xsl:choose>
911
912 <xsl:if test="$needarray">
913 <xsl:text>&gt;</xsl:text>
914 </xsl:if>
915 </xsl:when>
916
917 <xsl:otherwise>
918 <xsl:call-template name="fatalError">
919 <xsl:with-param name="msg" select="'Write typeIdl2Back for this style (typeIdl2Back)'" />
920 </xsl:call-template>
921 </xsl:otherwise>
922
923 </xsl:choose>
924</xsl:template>
925
926<xsl:template name="cookOutParamXpcom">
927 <xsl:param name="value"/>
928 <xsl:param name="idltype"/>
929 <xsl:param name="safearray"/>
930 <xsl:variable name="isstruct"
931 select="//interface[@name=$idltype]/@wsmap='struct'" />
932
933 <xsl:variable name="gluetype">
934 <xsl:call-template name="typeIdl2Glue">
935 <xsl:with-param name="type" select="$idltype" />
936 <xsl:with-param name="safearray" select="$safearray" />
937 </xsl:call-template>
938 </xsl:variable>
939
940 <xsl:variable name="elemgluetype">
941 <xsl:if test="$safearray='yes'">
942 <xsl:call-template name="typeIdl2Glue">
943 <xsl:with-param name="type" select="$idltype" />
944 <xsl:with-param name="safearray" select="'no'" />
945 <xsl:with-param name="forceelem" select="'yes'" />
946 </xsl:call-template>
947 </xsl:if>
948 </xsl:variable>
949
950 <xsl:choose>
951 <xsl:when test="//interface[@name=$idltype] or $idltype='$unknown'">
952 <xsl:choose>
953 <xsl:when test="$safearray='yes'">
954 <xsl:variable name="elembacktype">
955 <xsl:call-template name="typeIdl2Back">
956 <xsl:with-param name="type" select="$idltype" />
957 <xsl:with-param name="safearray" select="$safearray" />
958 <xsl:with-param name="forceelem" select="'yes'" />
959 </xsl:call-template>
960 </xsl:variable>
961 <xsl:value-of select="concat('Helper.wrap2(', $elemgluetype, '.class, ', $elembacktype, '.class, ', $value, ')')"/>
962 </xsl:when>
963 <xsl:otherwise>
964 <xsl:value-of select="concat('(', $value, ' != null) ? new ', $gluetype, '(', $value, ') : null')" />
965 </xsl:otherwise>
966 </xsl:choose>
967 </xsl:when>
968
969 <xsl:when test="//enum[@name=$idltype]">
970 <xsl:choose>
971 <xsl:when test="$safearray='yes'">
972 <xsl:variable name="elembacktype">
973 <xsl:call-template name="typeIdl2Back">
974 <xsl:with-param name="type" select="$idltype" />
975 <xsl:with-param name="safearray" select="$safearray" />
976 <xsl:with-param name="forceelem" select="'yes'" />
977 </xsl:call-template>
978 </xsl:variable>
979 <xsl:value-of select="concat('Helper.wrapEnum(', $elemgluetype, '.class, ', $value, ')')"/>
980 </xsl:when>
981 <xsl:otherwise>
982 <xsl:value-of select="concat($gluetype, '.fromValue(', $value, ')')"/>
983 </xsl:otherwise>
984 </xsl:choose>
985 </xsl:when>
986
987 <xsl:otherwise>
988 <xsl:choose>
989 <xsl:when test="($safearray='yes') and ($idltype='octet')">
990 <xsl:value-of select="$value"/>
991 </xsl:when>
992 <xsl:when test="$safearray='yes'">
993 <xsl:value-of select="concat('Helper.wrap(', $value, ')')"/>
994 </xsl:when>
995 <xsl:otherwise>
996 <xsl:value-of select="$value"/>
997 </xsl:otherwise>
998 </xsl:choose>
999 </xsl:otherwise>
1000 </xsl:choose>
1001</xsl:template>
1002
1003<xsl:template name="cookOutParamMscom">
1004 <xsl:param name="value"/>
1005 <xsl:param name="idltype"/>
1006 <xsl:param name="safearray"/>
1007
1008 <xsl:variable name="gluetype">
1009 <xsl:call-template name="typeIdl2Glue">
1010 <xsl:with-param name="type" select="$idltype" />
1011 <xsl:with-param name="safearray" select="$safearray" />
1012 </xsl:call-template>
1013 </xsl:variable>
1014
1015 <xsl:choose>
1016 <xsl:when test="$safearray='yes'">
1017 <xsl:variable name="elemgluetype">
1018 <xsl:call-template name="typeIdl2Glue">
1019 <xsl:with-param name="type" select="$idltype" />
1020 <xsl:with-param name="safearray" select="'no'" />
1021 <xsl:with-param name="forceelem" select="'yes'" />
1022 </xsl:call-template>
1023 </xsl:variable>
1024 <xsl:choose>
1025 <xsl:when test="($idltype='octet')">
1026 <xsl:value-of select="concat('Helper.wrapBytes(', $value, '.toSafeArray())')"/>
1027 </xsl:when>
1028 <xsl:otherwise>
1029 <xsl:value-of select="concat('Helper.wrap(', $elemgluetype, '.class, ', $value, '.toSafeArray())')"/>
1030 </xsl:otherwise>
1031 </xsl:choose>
1032 </xsl:when>
1033
1034 <xsl:when test="//interface[@name=$idltype] or $idltype='$unknown'">
1035 <xsl:value-of select="concat('Helper.wrapDispatch(', $gluetype, '.class, ', $value, '.getDispatch())')"/>
1036 </xsl:when>
1037
1038 <xsl:when test="//enum[@name=$idltype]">
1039 <xsl:value-of select="concat($gluetype, '.fromValue(', $value, '.getInt())')"/>
1040 </xsl:when>
1041
1042 <xsl:when test="$idltype='wstring'">
1043 <xsl:value-of select="concat($value, '.getString()')"/>
1044 </xsl:when>
1045
1046 <xsl:when test="$idltype='uuid'">
1047 <xsl:value-of select="concat($value, '.getString()')"/>
1048 </xsl:when>
1049
1050 <xsl:when test="$idltype='boolean'">
1051 <xsl:value-of select="concat($value, '.toBoolean()')"/>
1052 </xsl:when>
1053
1054 <xsl:when test="$idltype='unsigned short'">
1055 <xsl:value-of select="concat('(int)', $value, '.getShort()')"/>
1056 </xsl:when>
1057
1058 <xsl:when test="$idltype='short'">
1059 <xsl:value-of select="concat($value, '.getShort()')"/>
1060 </xsl:when>
1061
1062 <xsl:when test="$idltype='long'">
1063 <xsl:value-of select="concat($value, '.getInt()')"/>
1064 </xsl:when>
1065
1066
1067 <xsl:when test="$idltype='unsigned long'">
1068 <xsl:value-of select="concat('(long)', $value, '.getInt()')"/>
1069 </xsl:when>
1070
1071 <xsl:when test="$idltype='long'">
1072 <xsl:value-of select="concat($value, '.getInt()')"/>
1073 </xsl:when>
1074
1075 <xsl:when test="$idltype='long long'">
1076 <xsl:value-of select="concat($value, '.getLong()')"/>
1077 </xsl:when>
1078
1079 <xsl:otherwise>
1080 <xsl:call-template name="fatalError">
1081 <xsl:with-param name="msg" select="concat('Unhandled type' , $idltype, ' (cookOutParamMscom)')" />
1082 </xsl:call-template>
1083 </xsl:otherwise>
1084 </xsl:choose>
1085
1086</xsl:template>
1087
1088<xsl:template name="cookOutParamJaxws">
1089 <xsl:param name="value"/>
1090 <xsl:param name="idltype"/>
1091 <xsl:param name="safearray"/>
1092
1093 <xsl:variable name="isstruct"
1094 select="//interface[@name=$idltype]/@wsmap='struct'" />
1095
1096 <xsl:variable name="gluetype">
1097 <xsl:call-template name="typeIdl2Glue">
1098 <xsl:with-param name="type" select="$idltype" />
1099 <xsl:with-param name="safearray" select="$safearray" />
1100 </xsl:call-template>
1101 </xsl:variable>
1102
1103 <xsl:choose>
1104 <xsl:when test="$safearray='yes'">
1105 <xsl:variable name="elemgluetype">
1106 <xsl:call-template name="typeIdl2Glue">
1107 <xsl:with-param name="type" select="$idltype" />
1108 <xsl:with-param name="safearray" select="''" />
1109 <xsl:with-param name="forceelem" select="'yes'" />
1110 </xsl:call-template>
1111 </xsl:variable>
1112 <xsl:variable name="elembacktype">
1113 <xsl:call-template name="typeIdl2Back">
1114 <xsl:with-param name="type" select="$idltype" />
1115 <xsl:with-param name="safearray" select="''" />
1116 <xsl:with-param name="forceelem" select="'yes'" />
1117 </xsl:call-template>
1118 </xsl:variable>
1119 <xsl:choose>
1120 <xsl:when test="$isstruct">
1121 <xsl:value-of select="concat('Helper.wrap2(', $elemgluetype, '.class, ', $elembacktype, '.class, port, ', $value, ')')"/>
1122 </xsl:when>
1123 <xsl:when test="//enum[@name=$idltype]">
1124 <xsl:value-of select="concat('Helper.convertEnums(', $elembacktype, '.class, ', $elemgluetype, '.class, ', $value, ')')"/>
1125 </xsl:when>
1126 <xsl:when test="//interface[@name=$idltype] or $idltype='$unknown'">
1127 <xsl:value-of select="concat('Helper.wrap(', $elemgluetype, '.class, port, ', $value, ')')"/>
1128 </xsl:when>
1129 <xsl:when test="$idltype='octet'">
1130 <xsl:value-of select="concat('Helper.decodeBase64(', $value, ')')"/>
1131 </xsl:when>
1132 <xsl:otherwise>
1133 <xsl:value-of select="$value" />
1134 </xsl:otherwise>
1135 </xsl:choose>
1136 </xsl:when>
1137
1138 <xsl:otherwise>
1139 <xsl:choose>
1140 <xsl:when test="//enum[@name=$idltype]">
1141 <xsl:value-of select="concat($gluetype, '.fromValue(', $value, '.value())')"/>
1142 </xsl:when>
1143 <xsl:when test="$idltype='boolean'">
1144 <xsl:value-of select="$value"/>
1145 </xsl:when>
1146 <xsl:when test="$idltype='long long'">
1147 <xsl:value-of select="$value"/>
1148 </xsl:when>
1149 <xsl:when test="$idltype='unsigned long long'">
1150 <xsl:value-of select="$value"/>
1151 </xsl:when>
1152 <xsl:when test="$idltype='long'">
1153 <xsl:value-of select="$value"/>
1154 </xsl:when>
1155 <xsl:when test="$idltype='unsigned long'">
1156 <xsl:value-of select="$value"/>
1157 </xsl:when>
1158 <xsl:when test="$idltype='short'">
1159 <xsl:value-of select="$value"/>
1160 </xsl:when>
1161 <xsl:when test="$idltype='unsigned short'">
1162 <xsl:value-of select="$value"/>
1163 </xsl:when>
1164 <xsl:when test="$idltype='wstring'">
1165 <xsl:value-of select="$value"/>
1166 </xsl:when>
1167 <xsl:when test="$idltype='uuid'">
1168 <xsl:value-of select="$value"/>
1169 </xsl:when>
1170 <xsl:when test="$isstruct">
1171 <xsl:value-of select="concat('(', $value, ' != null) ? new ', $gluetype, '(', $value, ', port) : null')" />
1172 </xsl:when>
1173 <xsl:when test="//interface[@name=$idltype] or $idltype='$unknown'">
1174 <!-- if the MOR string is empty, that means NULL, so return NULL instead of an object then -->
1175 <xsl:value-of select="concat('(', $value, '.length() > 0) ? new ', $gluetype, '(', $value, ', port) : null')" />
1176 </xsl:when>
1177 <xsl:otherwise>
1178 <xsl:call-template name="fatalError">
1179 <xsl:with-param name="msg" select="concat('Unhandled type ', $idltype, ' (cookOutParamJaxws)')" />
1180 </xsl:call-template>
1181 </xsl:otherwise>
1182 </xsl:choose>
1183 </xsl:otherwise>
1184 </xsl:choose>
1185
1186</xsl:template>
1187
1188<xsl:template name="cookOutParam">
1189 <xsl:param name="value"/>
1190 <xsl:param name="idltype"/>
1191 <xsl:param name="safearray"/>
1192 <xsl:choose>
1193 <xsl:when test="($G_vboxGlueStyle='xpcom')">
1194 <xsl:call-template name="cookOutParamXpcom">
1195 <xsl:with-param name="value" select="$value" />
1196 <xsl:with-param name="idltype" select="$idltype" />
1197 <xsl:with-param name="safearray" select="$safearray" />
1198 </xsl:call-template>
1199 </xsl:when>
1200 <xsl:when test="($G_vboxGlueStyle='mscom')">
1201 <xsl:call-template name="cookOutParamMscom">
1202 <xsl:with-param name="value" select="$value" />
1203 <xsl:with-param name="idltype" select="$idltype" />
1204 <xsl:with-param name="safearray" select="$safearray" />
1205 </xsl:call-template>
1206 </xsl:when>
1207 <xsl:when test="($G_vboxGlueStyle='jaxws')">
1208 <xsl:call-template name="cookOutParamJaxws">
1209 <xsl:with-param name="value" select="$value" />
1210 <xsl:with-param name="idltype" select="$idltype" />
1211 <xsl:with-param name="safearray" select="$safearray" />
1212 </xsl:call-template>
1213 </xsl:when>
1214 <xsl:otherwise>
1215 <xsl:call-template name="fatalError">
1216 <xsl:with-param name="msg" select="'Unhandled style(cookOutParam)'" />
1217 </xsl:call-template>
1218 </xsl:otherwise>
1219 </xsl:choose>
1220</xsl:template>
1221
1222<xsl:template name="cookInParamXpcom">
1223 <xsl:param name="value"/>
1224 <xsl:param name="idltype"/>
1225 <xsl:param name="safearray"/>
1226 <xsl:variable name="isstruct"
1227 select="//interface[@name=$idltype]/@wsmap='struct'" />
1228 <xsl:variable name="gluetype">
1229 <xsl:call-template name="typeIdl2Glue">
1230 <xsl:with-param name="type" select="$idltype" />
1231 <xsl:with-param name="safearray" select="$safearray" />
1232 </xsl:call-template>
1233 </xsl:variable>
1234
1235 <xsl:variable name="backtype">
1236 <xsl:call-template name="typeIdl2Back">
1237 <xsl:with-param name="type" select="$idltype" />
1238 <xsl:with-param name="safearray" select="$safearray" />
1239 </xsl:call-template>
1240 </xsl:variable>
1241
1242 <xsl:variable name="elemgluetype">
1243 <xsl:if test="$safearray='yes'">
1244 <xsl:call-template name="typeIdl2Glue">
1245 <xsl:with-param name="type" select="$idltype" />
1246 <xsl:with-param name="safearray" select="'no'" />
1247 <xsl:with-param name="forceelem" select="'yes'" />
1248 </xsl:call-template>
1249 </xsl:if>
1250 </xsl:variable>
1251
1252 <xsl:choose>
1253 <xsl:when test="//interface[@name=$idltype]">
1254 <xsl:choose>
1255 <xsl:when test="$safearray='yes'">
1256 <xsl:variable name="elembacktype">
1257 <xsl:call-template name="typeIdl2Back">
1258 <xsl:with-param name="type" select="$idltype" />
1259 <xsl:with-param name="safearray" select="$safearray" />
1260 <xsl:with-param name="forceelem" select="'yes'" />
1261 </xsl:call-template>
1262 </xsl:variable>
1263 <xsl:value-of select="concat('Helper.unwrap2(', $elemgluetype, '.class, ', $elembacktype, '.class, ', $value, ')')"/>
1264 </xsl:when>
1265 <xsl:otherwise>
1266 <xsl:value-of select="concat('(', $value, ' != null) ? ', $value, '.getTypedWrapped() : null')" />
1267 </xsl:otherwise>
1268 </xsl:choose>
1269 </xsl:when>
1270
1271 <xsl:when test="$idltype='$unknown'">
1272 <xsl:choose>
1273 <xsl:when test="$safearray='yes'">
1274 <xsl:value-of select="concat('Helper.unwrap2(', $elemgluetype, '.class, nsISupports.class, ', $value, ')')"/>
1275 </xsl:when>
1276 <xsl:otherwise>
1277 <xsl:value-of select="concat('(', $value, ' != null) ? (nsISupports)', $value, '.getWrapped() : null')" />
1278 </xsl:otherwise>
1279 </xsl:choose>
1280 </xsl:when>
1281
1282 <xsl:when test="//enum[@name=$idltype]">
1283 <xsl:choose>
1284 <xsl:when test="$safearray='yes'">
1285 <xsl:value-of select="concat('Helper.unwrapEnum(', $elemgluetype, '.class, ', $value, ')')"/>
1286 </xsl:when>
1287 <xsl:otherwise>
1288 <xsl:value-of select="concat($value, '.value()')"/>
1289 </xsl:otherwise>
1290 </xsl:choose>
1291 </xsl:when>
1292
1293 <xsl:when test="($idltype='octet') and ($safearray='yes')">
1294 <xsl:value-of select="$value"/>
1295 </xsl:when>
1296
1297 <xsl:otherwise>
1298 <xsl:choose>
1299 <xsl:when test="$safearray='yes'">
1300 <xsl:choose>
1301 <xsl:when test="$idltype='boolean'">
1302 <xsl:value-of select="concat('Helper.unwrapBoolean(', $value, ')')"/>
1303 </xsl:when>
1304 <xsl:when test="($idltype='long') or ($idltype='unsigned long') or ($idltype='integer')">
1305 <xsl:value-of select="concat('Helper.unwrapInteger(', $value, ')')"/>
1306 </xsl:when>
1307 <xsl:when test="($idltype='short') or ($idltype='unsigned short')">
1308 <xsl:value-of select="concat('Helper.unwrapUShort(', $value, ')')"/>
1309 </xsl:when>
1310 <xsl:when test="($idltype='unsigned long long') or ($idltype='long long')">
1311 <xsl:value-of select="concat('Helper.unwrapULong(', $value, ')')"/>
1312 </xsl:when>
1313 <xsl:when test="($idltype='wstring') or ($idltype='uuid')">
1314 <xsl:value-of select="concat('Helper.unwrapStr(', $value, ')')"/>
1315 </xsl:when>
1316 <xsl:otherwise>
1317 <xsl:value-of select="$value"/>
1318 </xsl:otherwise>
1319 </xsl:choose>
1320 </xsl:when>
1321 <xsl:otherwise>
1322 <xsl:value-of select="$value"/>
1323 </xsl:otherwise>
1324 </xsl:choose>
1325 </xsl:otherwise>
1326 </xsl:choose>
1327</xsl:template>
1328
1329<xsl:template name="cookInParamMscom">
1330 <xsl:param name="value"/>
1331 <xsl:param name="idltype"/>
1332 <xsl:param name="safearray"/>
1333
1334 <xsl:variable name="gluetype">
1335 <xsl:call-template name="typeIdl2Glue">
1336 <xsl:with-param name="type" select="$idltype" />
1337 <xsl:with-param name="safearray" select="$safearray" />
1338 </xsl:call-template>
1339 </xsl:variable>
1340
1341 <xsl:variable name="backtype">
1342 <xsl:call-template name="typeIdl2Back">
1343 <xsl:with-param name="type" select="$idltype" />
1344 <xsl:with-param name="safearray" select="$safearray" />
1345 </xsl:call-template>
1346 </xsl:variable>
1347
1348 <xsl:variable name="elemgluetype">
1349 <xsl:if test="$safearray='yes'">
1350 <xsl:call-template name="typeIdl2Glue">
1351 <xsl:with-param name="type" select="$idltype" />
1352 <xsl:with-param name="safearray" select="'no'" />
1353 <xsl:with-param name="forceelem" select="'yes'" />
1354 </xsl:call-template>
1355 </xsl:if>
1356 </xsl:variable>
1357
1358 <xsl:choose>
1359 <xsl:when test="//interface[@name=$idltype]">
1360 <xsl:choose>
1361 <xsl:when test="$safearray='yes'">
1362 <xsl:variable name="elembacktype">
1363 <xsl:call-template name="typeIdl2Back">
1364 <xsl:with-param name="type" select="$idltype" />
1365 <xsl:with-param name="safearray" select="$safearray" />
1366 <xsl:with-param name="forceelem" select="'yes'" />
1367 </xsl:call-template>
1368 </xsl:variable>
1369 <xsl:value-of select="concat('Helper.unwrap2(', $elemgluetype, '.class, ', $elembacktype, '.class, ', $value, ')')"/>
1370 </xsl:when>
1371 <xsl:otherwise>
1372 <xsl:value-of select="concat('(', $value, ' != null) ? ', $value, '.getTypedWrapped() : null')" />
1373 </xsl:otherwise>
1374 </xsl:choose>
1375 </xsl:when>
1376
1377 <xsl:when test="$idltype='$unknown'">
1378 <xsl:choose>
1379 <xsl:when test="$safearray='yes'">
1380 <xsl:value-of select="concat('Helper.unwrap2(', $elemgluetype, '.class, Dispatch.class, ', $value, ')')"/>
1381 </xsl:when>
1382 <xsl:otherwise>
1383 <xsl:value-of select="concat('(', $value, ' != null) ? (Dispatch)', $value, '.getWrapped() : null')" />
1384 </xsl:otherwise>
1385 </xsl:choose>
1386 </xsl:when>
1387
1388 <xsl:when test="//enum[@name=$idltype]">
1389 <xsl:choose>
1390 <xsl:when test="$safearray='yes'">
1391 <xsl:value-of select="concat('Helper.unwrapEnum(', $elemgluetype, '.class, ', $value, ')')"/>
1392 </xsl:when>
1393 <xsl:otherwise>
1394 <xsl:value-of select="concat($value, '.value()')"/>
1395 </xsl:otherwise>
1396 </xsl:choose>
1397 </xsl:when>
1398
1399 <xsl:when test="$idltype='boolean'">
1400 <xsl:choose>
1401 <xsl:when test="$safearray='yes'">
1402 <xsl:value-of select="concat('Helper.unwrapBool(', $value, ')')"/>
1403 </xsl:when>
1404 <xsl:otherwise>
1405 <xsl:value-of select="concat('new Variant(', $value, ')')"/>
1406 </xsl:otherwise>
1407 </xsl:choose>
1408 </xsl:when>
1409
1410 <xsl:when test="($idltype='short') or ($idltype='unsigned short')">
1411 <xsl:choose>
1412 <xsl:when test="$safearray='yes'">
1413 <xsl:value-of select="concat('Helper.unwrapShort(', $value, ')')"/>
1414 </xsl:when>
1415 <xsl:otherwise>
1416 <xsl:value-of select="concat('new Variant(', $value, ')')"/>
1417 </xsl:otherwise>
1418 </xsl:choose>
1419 </xsl:when>
1420
1421
1422 <xsl:when test="($idltype='long') or ($idltype='unsigned long')">
1423 <xsl:choose>
1424 <xsl:when test="$safearray='yes'">
1425 <xsl:value-of select="concat('Helper.unwrapInt(', $value, ')')"/>
1426 </xsl:when>
1427 <xsl:otherwise>
1428 <xsl:value-of select="concat('new Variant(', $value, ')')"/>
1429 </xsl:otherwise>
1430 </xsl:choose>
1431 </xsl:when>
1432
1433 <xsl:when test="($idltype='wstring') or ($idltype='uuid')">
1434 <xsl:choose>
1435 <xsl:when test="$safearray='yes'">
1436 <xsl:value-of select="concat('Helper.unwrapString(', $value, ')')"/>
1437 </xsl:when>
1438 <xsl:otherwise>
1439 <xsl:value-of select="concat('new Variant(', $value, ')')"/>
1440 </xsl:otherwise>
1441 </xsl:choose>
1442 </xsl:when>
1443
1444 <xsl:when test="($idltype='unsigned long long') or ($idltype='long long')">
1445 <xsl:choose>
1446 <xsl:when test="$safearray='yes'">
1447 <xsl:value-of select="concat('Helper.unwrapLong(', $value, ')')"/>
1448 </xsl:when>
1449 <xsl:otherwise>
1450 <xsl:value-of select="concat('new Variant(', $value, '.longValue())')"/>
1451 </xsl:otherwise>
1452 </xsl:choose>
1453 </xsl:when>
1454
1455 <xsl:when test="($idltype='octet') and ($safearray='yes')">
1456 <xsl:value-of select="concat('Helper.encodeBase64(', $value, ')')"/>
1457 </xsl:when>
1458
1459 <xsl:otherwise>
1460 <xsl:call-template name="fatalError">
1461 <xsl:with-param name="msg" select="concat('Unhandled type: ', $idltype)" />
1462 </xsl:call-template>
1463 </xsl:otherwise>
1464 </xsl:choose>
1465
1466</xsl:template>
1467
1468<xsl:template name="cookInParamJaxws">
1469 <xsl:param name="value"/>
1470 <xsl:param name="idltype"/>
1471 <xsl:param name="safearray"/>
1472 <xsl:variable name="isstruct"
1473 select="//interface[@name=$idltype]/@wsmap='struct'" />
1474
1475 <xsl:variable name="gluetype">
1476 <xsl:call-template name="typeIdl2Glue">
1477 <xsl:with-param name="type" select="$idltype" />
1478 <xsl:with-param name="safearray" select="$safearray" />
1479 </xsl:call-template>
1480 </xsl:variable>
1481
1482 <xsl:variable name="elemgluetype">
1483 <xsl:if test="$safearray='yes'">
1484 <xsl:call-template name="typeIdl2Glue">
1485 <xsl:with-param name="type" select="$idltype" />
1486 <xsl:with-param name="safearray" select="'no'" />
1487 <xsl:with-param name="forceelem" select="'yes'" />
1488 </xsl:call-template>
1489 </xsl:if>
1490 </xsl:variable>
1491
1492 <xsl:choose>
1493 <xsl:when test="//interface[@name=$idltype] or $idltype='$unknown'">
1494 <xsl:choose>
1495 <xsl:when test="@safearray='yes'">
1496 <xsl:value-of select="concat('Helper.unwrap(', $value, ')')"/>
1497 </xsl:when>
1498 <xsl:otherwise>
1499 <xsl:value-of select="concat('((', $value, ' == null) ? null :', $value, '.getWrapped())')" />
1500 </xsl:otherwise>
1501 </xsl:choose>
1502 </xsl:when>
1503
1504 <xsl:when test="//enum[@name=$idltype]">
1505 <xsl:choose>
1506 <xsl:when test="$safearray='yes'">
1507 <xsl:variable name="elembacktype">
1508 <xsl:call-template name="typeIdl2Back">
1509 <xsl:with-param name="type" select="$idltype" />
1510 <xsl:with-param name="safearray" select="'no'" />
1511 <xsl:with-param name="forceelem" select="'yes'" />
1512 </xsl:call-template>
1513 </xsl:variable>
1514 <xsl:value-of select="concat('Helper.convertEnums(', $elemgluetype, '.class, ', $elembacktype, '.class, ', $value, ')')"/>
1515 </xsl:when>
1516 <xsl:otherwise>
1517 <xsl:variable name="backtype">
1518 <xsl:call-template name="typeIdl2Back">
1519 <xsl:with-param name="type" select="$idltype" />
1520 <xsl:with-param name="safearray" select="'no'" />
1521 <xsl:with-param name="forceelem" select="'yes'" />
1522 </xsl:call-template>
1523 </xsl:variable>
1524 <xsl:value-of select="concat($backtype, '.fromValue(', $value, '.name())')"/>
1525 </xsl:otherwise>
1526 </xsl:choose>
1527 </xsl:when>
1528
1529 <xsl:when test="($idltype='octet') and ($safearray='yes')">
1530 <xsl:value-of select="concat('Helper.encodeBase64(', $value, ')')"/>
1531 </xsl:when>
1532
1533 <xsl:otherwise>
1534 <xsl:value-of select="$value"/>
1535 </xsl:otherwise>
1536 </xsl:choose>
1537
1538</xsl:template>
1539
1540<xsl:template name="cookInParam">
1541 <xsl:param name="value"/>
1542 <xsl:param name="idltype"/>
1543 <xsl:param name="safearray"/>
1544 <xsl:choose>
1545 <xsl:when test="($G_vboxGlueStyle='xpcom')">
1546 <xsl:call-template name="cookInParamXpcom">
1547 <xsl:with-param name="value" select="$value" />
1548 <xsl:with-param name="idltype" select="$idltype" />
1549 <xsl:with-param name="safearray" select="$safearray" />
1550 </xsl:call-template>
1551 </xsl:when>
1552 <xsl:when test="($G_vboxGlueStyle='mscom')">
1553 <xsl:call-template name="cookInParamMscom">
1554 <xsl:with-param name="value" select="$value" />
1555 <xsl:with-param name="idltype" select="$idltype" />
1556 <xsl:with-param name="safearray" select="$safearray" />
1557 </xsl:call-template>
1558 </xsl:when>
1559 <xsl:when test="($G_vboxGlueStyle='jaxws')">
1560 <xsl:call-template name="cookInParamJaxws">
1561 <xsl:with-param name="value" select="$value" />
1562 <xsl:with-param name="idltype" select="$idltype" />
1563 <xsl:with-param name="safearray" select="$safearray" />
1564 </xsl:call-template>
1565 </xsl:when>
1566 <xsl:otherwise>
1567 <xsl:call-template name="fatalError">
1568 <xsl:with-param name="msg" select="'Unhandled style (cookInParam)'" />
1569 </xsl:call-template>
1570 </xsl:otherwise>
1571 </xsl:choose>
1572</xsl:template>
1573
1574<!-- Invoke backend method, including parameter conversion -->
1575<xsl:template name="genBackMethodCall">
1576 <xsl:param name="ifname"/>
1577 <xsl:param name="methodname"/>
1578 <xsl:param name="retval"/>
1579
1580 <xsl:choose>
1581 <xsl:when test="($G_vboxGlueStyle='xpcom')">
1582 <xsl:text> </xsl:text>
1583 <xsl:if test="param[@dir='return']">
1584 <xsl:value-of select="concat($retval, ' = ')" />
1585 </xsl:if>
1586 <xsl:value-of select="concat('getTypedWrapped().', $methodname, '(')"/>
1587 <xsl:for-each select="param">
1588 <xsl:choose>
1589 <xsl:when test="@dir='return'">
1590 <xsl:if test="@safearray='yes'">
1591 <xsl:text>null</xsl:text>
1592 </xsl:if>
1593 </xsl:when>
1594 <xsl:when test="@dir='out'">
1595 <xsl:if test="@safearray='yes'">
1596 <xsl:text>null, </xsl:text>
1597 </xsl:if>
1598 <xsl:value-of select="concat('tmp_', @name)" />
1599 </xsl:when>
1600 <xsl:when test="@dir='in'">
1601 <xsl:if test="(@safearray='yes') and not(@type = 'octet')">
1602 <xsl:value-of select="concat(@name, '.size(), ')" />
1603 </xsl:if>
1604 <xsl:variable name="unwrapped">
1605 <xsl:call-template name="cookInParam">
1606 <xsl:with-param name="value" select="@name" />
1607 <xsl:with-param name="idltype" select="@type" />
1608 <xsl:with-param name="safearray" select="@safearray" />
1609 </xsl:call-template>
1610 </xsl:variable>
1611 <xsl:value-of select="$unwrapped"/>
1612 </xsl:when>
1613 <xsl:otherwise>
1614 <xsl:call-template name="fatalError">
1615 <xsl:with-param name="msg" select="concat('Unsupported param dir: ', @dir, '&quot;.')" />
1616 </xsl:call-template>
1617 </xsl:otherwise>
1618 </xsl:choose>
1619 <xsl:if test="not(position()=last()) and not(following-sibling::param[1]/@dir='return' and not(following-sibling::param[1]/@safearray='yes'))">
1620 <xsl:text>, </xsl:text>
1621 </xsl:if>
1622 </xsl:for-each>
1623 <xsl:text>);&#10;</xsl:text>
1624 </xsl:when>
1625
1626 <xsl:when test="($G_vboxGlueStyle='mscom')">
1627 <xsl:text> </xsl:text>
1628 <xsl:if test="param[@dir='return']">
1629 <xsl:value-of select="concat($retval, ' = ')" />
1630 </xsl:if>
1631 <xsl:value-of select="concat('Helper.invoke(getTypedWrapped(), &quot;', $methodname, '&quot; ')"/>
1632 <xsl:for-each select="param[not(@dir='return')]">
1633 <xsl:text>, </xsl:text>
1634 <xsl:choose>
1635 <xsl:when test="@dir='out'">
1636 <xsl:value-of select="concat('tmp_', @name)" />
1637 </xsl:when>
1638 <xsl:when test="@dir='in'">
1639 <xsl:variable name="unwrapped">
1640 <xsl:call-template name="cookInParam">
1641 <xsl:with-param name="value" select="@name" />
1642 <xsl:with-param name="idltype" select="@type" />
1643 <xsl:with-param name="safearray" select="@safearray" />
1644 </xsl:call-template>
1645 </xsl:variable>
1646 <xsl:value-of select="$unwrapped"/>
1647 </xsl:when>
1648 </xsl:choose>
1649 </xsl:for-each>
1650 <xsl:text>);&#10;</xsl:text>
1651 </xsl:when>
1652
1653 <xsl:when test="($G_vboxGlueStyle='jaxws')">
1654 <xsl:variable name="jaxwsmethod">
1655 <xsl:call-template name="makeJaxwsMethod">
1656 <xsl:with-param name="ifname" select="$ifname" />
1657 <xsl:with-param name="methodname" select="$methodname" />
1658 </xsl:call-template>
1659 </xsl:variable>
1660 <xsl:variable name="portArg">
1661 <xsl:if test="not(//interface[@name=$ifname]/@wsmap='global')">
1662 <xsl:text>obj</xsl:text>
1663 </xsl:if>
1664 </xsl:variable>
1665 <xsl:variable name="paramsinout" select="param[@dir='in' or @dir='out']" />
1666
1667 <xsl:text> </xsl:text>
1668 <xsl:if test="param[@dir='return'] and not(param[@dir='out'])">
1669 <xsl:value-of select="concat($retval, ' = ')" />
1670 </xsl:if>
1671 <xsl:value-of select="concat('port.', $jaxwsmethod, '(', $portArg)" />
1672 <xsl:if test="$paramsinout and not($portArg='')">
1673 <xsl:text>, </xsl:text>
1674 </xsl:if>
1675
1676 <!-- jax-ws has an oddity: if both out params and a return value exist,
1677 then the return value is moved to the function's argument list... -->
1678 <xsl:choose>
1679 <xsl:when test="param[@dir='out'] and param[@dir='return']">
1680 <xsl:for-each select="param">
1681 <xsl:choose>
1682 <xsl:when test="@dir='return'">
1683 <xsl:value-of select="$retval"/>
1684 </xsl:when>
1685 <xsl:when test="@dir='out'">
1686 <xsl:value-of select="concat('tmp_', @name)" />
1687 </xsl:when>
1688 <xsl:otherwise>
1689 <xsl:call-template name="cookInParam">
1690 <xsl:with-param name="value" select="@name" />
1691 <xsl:with-param name="idltype" select="@type" />
1692 <xsl:with-param name="safearray" select="@safearray" />
1693 </xsl:call-template>
1694 </xsl:otherwise>
1695 </xsl:choose>
1696 <xsl:if test="not(position()=last())">
1697 <xsl:text>, </xsl:text>
1698 </xsl:if>
1699 </xsl:for-each>
1700 </xsl:when>
1701 <xsl:otherwise>
1702 <xsl:for-each select="$paramsinout">
1703 <xsl:choose>
1704 <xsl:when test="@dir='return'">
1705 <xsl:value-of select="$retval"/>
1706 </xsl:when>
1707 <xsl:when test="@dir='out'">
1708 <xsl:value-of select="concat('tmp_', @name)" />
1709 </xsl:when>
1710 <xsl:otherwise>
1711 <xsl:call-template name="cookInParam">
1712 <xsl:with-param name="value" select="@name" />
1713 <xsl:with-param name="idltype" select="@type" />
1714 <xsl:with-param name="safearray" select="@safearray" />
1715 </xsl:call-template>
1716 </xsl:otherwise>
1717 </xsl:choose>
1718 <xsl:if test="not(position()=last())">
1719 <xsl:text>, </xsl:text>
1720 </xsl:if>
1721 </xsl:for-each>
1722 </xsl:otherwise>
1723 </xsl:choose>
1724 <xsl:text>);&#10;</xsl:text>
1725 </xsl:when>
1726
1727 <xsl:otherwise>
1728 <xsl:call-template name="fatalError">
1729 <xsl:with-param name="msg" select="'Style unknown (genBackMethodCall)'" />
1730 </xsl:call-template>
1731 </xsl:otherwise>
1732
1733 </xsl:choose>
1734</xsl:template>
1735
1736<xsl:template name="genGetterCall">
1737 <xsl:param name="ifname"/>
1738 <xsl:param name="gettername"/>
1739 <xsl:param name="backtype"/>
1740 <xsl:param name="retval"/>
1741
1742 <xsl:choose>
1743 <xsl:when test="$G_vboxGlueStyle='xpcom'">
1744 <xsl:value-of select="concat(' ', $backtype, ' ', $retval, ' = getTypedWrapped().', $gettername, '(')" />
1745 <xsl:if test="@safearray">
1746 <xsl:text>null</xsl:text>
1747 </xsl:if>
1748 <xsl:text>);&#10;</xsl:text>
1749 </xsl:when>
1750
1751 <xsl:when test="$G_vboxGlueStyle='mscom'">
1752 <xsl:value-of select="concat(' ', $backtype, ' ', $retval, ' = Dispatch.get(getTypedWrapped(), &quot;', @name, '&quot;);&#10;')" />
1753 </xsl:when>
1754
1755 <xsl:when test="$G_vboxGlueStyle='jaxws'">
1756 <xsl:variable name="jaxwsGetter">
1757 <xsl:call-template name="makeJaxwsMethod">
1758 <xsl:with-param name="ifname" select="$ifname" />
1759 <xsl:with-param name="methodname" select="$gettername" />
1760 </xsl:call-template>
1761 </xsl:variable>
1762 <xsl:value-of select="concat(' ', $backtype, ' ', $retval, ' = port.', $jaxwsGetter, '(obj);&#10;')" />
1763 </xsl:when>
1764
1765 <xsl:otherwise>
1766 <xsl:call-template name="fatalError">
1767 <xsl:with-param name="msg" select="'Style unknown (genGetterCall)'" />
1768 </xsl:call-template>
1769 </xsl:otherwise>
1770 </xsl:choose>
1771</xsl:template>
1772
1773<xsl:template name="genSetterCall">
1774 <xsl:param name="ifname"/>
1775 <xsl:param name="settername"/>
1776 <xsl:param name="value"/>
1777
1778 <xsl:choose>
1779 <xsl:when test="$G_vboxGlueStyle='xpcom'">
1780 <xsl:value-of select="concat(' getTypedWrapped().', $settername, '(', $value, ');&#10;')" />
1781 </xsl:when>
1782
1783 <xsl:when test="$G_vboxGlueStyle='mscom'">
1784 <xsl:value-of select="concat(' Dispatch.put(getTypedWrapped(), &quot;', @name, '&quot;, ', $value, ');&#10;')" />
1785 </xsl:when>
1786
1787 <xsl:when test="$G_vboxGlueStyle='jaxws'">
1788 <xsl:variable name="jaxwsSetter">
1789 <xsl:call-template name="makeJaxwsMethod">
1790 <xsl:with-param name="ifname" select="$ifname" />
1791 <xsl:with-param name="methodname" select="$settername" />
1792 </xsl:call-template>
1793 </xsl:variable>
1794 <xsl:value-of select="concat(' port.', $jaxwsSetter, '(obj, ', $value, ');&#10;')" />
1795 </xsl:when>
1796
1797 <xsl:otherwise>
1798 <xsl:call-template name="fatalError">
1799 <xsl:with-param name="msg" select="'Style unknown (genSetterCall)'" />
1800 </xsl:call-template>
1801 </xsl:otherwise>
1802 </xsl:choose>
1803</xsl:template>
1804
1805<xsl:template name="genStructWrapperJaxws">
1806 <xsl:param name="ifname"/>
1807
1808 <xsl:value-of select="concat(' private ', $G_virtualBoxPackageCom, '.', $ifname, ' real;&#10;')"/>
1809 <xsl:text> private VboxPortType port;&#10;&#10;</xsl:text>
1810
1811 <xsl:value-of select="concat(' public ', $ifname, '(', $G_virtualBoxPackageCom, '.', $ifname, ' real, VboxPortType port)&#10;')" />
1812 <xsl:text> {&#10;</xsl:text>
1813 <xsl:text> this.real = real;&#10;</xsl:text>
1814 <xsl:text> this.port = port;&#10;</xsl:text>
1815 <xsl:text> }&#10;&#10;</xsl:text>
1816
1817 <xsl:for-each select="attribute">
1818 <xsl:variable name="attrname"><xsl:value-of select="@name" /></xsl:variable>
1819 <xsl:variable name="attrtype"><xsl:value-of select="@type" /></xsl:variable>
1820 <xsl:variable name="attrsafearray"><xsl:value-of select="@safearray" /></xsl:variable>
1821
1822 <xsl:if test="not(@wsmap = 'suppress')">
1823
1824 <xsl:if test="not(@readonly = 'yes')">
1825 <xsl:call-template name="fatalError">
1826 <xsl:with-param name="msg" select="concat('Non read-only struct (genStructWrapperJaxws) in interface ', $ifname, ', attribute ', $attrname)" />
1827 </xsl:call-template>
1828 </xsl:if>
1829
1830 <!-- Emit getter -->
1831 <xsl:variable name="backgettername">
1832 <xsl:choose>
1833 <!-- Stupid, but backend boolean getters called isFoo(), not getFoo() -->
1834 <xsl:when test="$attrtype = 'boolean'">
1835 <xsl:variable name="capsname">
1836 <xsl:call-template name="capitalize">
1837 <xsl:with-param name="str" select="$attrname" />
1838 </xsl:call-template>
1839 </xsl:variable>
1840 <xsl:value-of select="concat('is', $capsname)" />
1841 </xsl:when>
1842 <xsl:otherwise>
1843 <xsl:call-template name="makeGetterName">
1844 <xsl:with-param name="attrname" select="$attrname" />
1845 </xsl:call-template>
1846 </xsl:otherwise>
1847 </xsl:choose>
1848 </xsl:variable>
1849
1850 <xsl:variable name="gluegettername">
1851 <xsl:call-template name="makeGetterName">
1852 <xsl:with-param name="attrname" select="$attrname" />
1853 </xsl:call-template>
1854 </xsl:variable>
1855
1856 <xsl:variable name="gluegettertype">
1857 <xsl:call-template name="typeIdl2Glue">
1858 <xsl:with-param name="type" select="$attrtype" />
1859 <xsl:with-param name="safearray" select="@safearray" />
1860 </xsl:call-template>
1861 </xsl:variable>
1862
1863 <xsl:variable name="backgettertype">
1864 <xsl:call-template name="typeIdl2Back">
1865 <xsl:with-param name="type" select="$attrtype" />
1866 <xsl:with-param name="safearray" select="@safearray" />
1867 </xsl:call-template>
1868 </xsl:variable>
1869
1870 <xsl:apply-templates select="desc" mode="attribute_get"/>
1871 <xsl:value-of select="concat(' public ', $gluegettertype, ' ', $gluegettername, '()&#10;')" />
1872 <xsl:text> {&#10;</xsl:text>
1873 <xsl:value-of select="concat(' ', $backgettertype, ' retVal = real.', $backgettername, '();&#10;')" />
1874 <xsl:variable name="wrapped">
1875 <xsl:call-template name="cookOutParam">
1876 <xsl:with-param name="value" select="'retVal'" />
1877 <xsl:with-param name="idltype" select="$attrtype" />
1878 <xsl:with-param name="safearray" select="@safearray" />
1879 </xsl:call-template>
1880 </xsl:variable>
1881 <xsl:value-of select="concat(' return ', $wrapped, ';&#10;')" />
1882 <xsl:text> }&#10;</xsl:text>
1883 </xsl:if>
1884
1885 </xsl:for-each>
1886
1887</xsl:template>
1888
1889<!-- Interface method wrapper -->
1890<xsl:template name="genMethod">
1891 <xsl:param name="ifname"/>
1892 <xsl:param name="methodname"/>
1893
1894 <xsl:choose>
1895 <xsl:when test="(param[@mod='ptr']) or (($G_vboxGlueStyle='jaxws') and (param[@type=($G_setSuppressedInterfaces/@name)]))" >
1896 <xsl:value-of select="concat(' // Skipping method ', $methodname, ' for it has parameters with suppressed types&#10;')" />
1897 </xsl:when>
1898 <xsl:when test="($G_vboxGlueStyle='jaxws') and (@wsmap = 'suppress')" >
1899 <xsl:value-of select="concat(' // Skipping method ', $methodname, ' for it is suppressed&#10;')" />
1900 </xsl:when>
1901 <xsl:otherwise>
1902 <xsl:variable name="hasReturnParms" select="param[@dir='return']" />
1903 <xsl:variable name="hasOutParms" select="param[@dir='out']" />
1904 <xsl:variable name="returnidltype" select="param[@dir='return']/@type" />
1905 <xsl:variable name="returnidlsafearray" select="param[@dir='return']/@safearray" />
1906 <xsl:variable name="returngluetype">
1907 <xsl:choose>
1908 <xsl:when test="$returnidltype">
1909 <xsl:call-template name="typeIdl2Glue">
1910 <xsl:with-param name="type" select="$returnidltype" />
1911 <xsl:with-param name="safearray" select="$returnidlsafearray" />
1912 </xsl:call-template>
1913 </xsl:when>
1914 <xsl:otherwise>
1915 <xsl:text>void</xsl:text>
1916 </xsl:otherwise>
1917 </xsl:choose>
1918 </xsl:variable>
1919 <xsl:variable name="retValValue">
1920 <xsl:choose>
1921 <xsl:when test="(param[@dir='out']) and ($G_vboxGlueStyle='jaxws')">
1922 <xsl:text>retVal.value</xsl:text>
1923 </xsl:when>
1924 <xsl:otherwise>
1925 <xsl:text>retVal</xsl:text>
1926 </xsl:otherwise>
1927 </xsl:choose>
1928 </xsl:variable>
1929 <xsl:apply-templates select="desc" mode="method"/>
1930 <xsl:value-of select="concat(' public ', $returngluetype, ' ', $methodname, '(')" />
1931 <xsl:variable name="paramsinout" select="param[@dir='in' or @dir='out']" />
1932 <xsl:for-each select="exsl:node-set($paramsinout)">
1933 <xsl:variable name="paramgluetype">
1934 <xsl:call-template name="typeIdl2Glue">
1935 <xsl:with-param name="type" select="@type" />
1936 <xsl:with-param name="safearray" select="@safearray" />
1937 </xsl:call-template>
1938 </xsl:variable>
1939 <xsl:choose>
1940 <xsl:when test="@dir='out'">
1941 <xsl:value-of select="concat('Holder&lt;', $paramgluetype, '&gt; ', @name)" />
1942 </xsl:when>
1943 <xsl:otherwise>
1944 <xsl:value-of select="concat($paramgluetype, ' ', @name)" />
1945 </xsl:otherwise>
1946 </xsl:choose>
1947 <xsl:if test="not(position()=last())">
1948 <xsl:text>, </xsl:text>
1949 </xsl:if>
1950 </xsl:for-each>
1951 <xsl:text>)&#10;</xsl:text>
1952 <xsl:text> {&#10;</xsl:text>
1953
1954 <xsl:call-template name="startExcWrapper"/>
1955
1956 <!-- declare temp out params -->
1957 <xsl:for-each select="param[@dir='out']">
1958 <xsl:variable name="backouttype">
1959 <xsl:call-template name="typeIdl2Back">
1960 <xsl:with-param name="type" select="@type" />
1961 <xsl:with-param name="safearray" select="@safearray" />
1962 </xsl:call-template>
1963 </xsl:variable>
1964 <xsl:choose>
1965 <xsl:when test="$G_vboxGlueStyle='xpcom'">
1966 <xsl:value-of select="concat(' ', $backouttype, '[] tmp_', @name, ' = (', $backouttype, '[])java.lang.reflect.Array.newInstance(', $backouttype, '.class, 1);&#10;')"/>
1967 </xsl:when>
1968 <xsl:when test="$G_vboxGlueStyle='mscom'">
1969 <xsl:value-of select="concat(' Variant tmp_', @name, ' = new Variant();&#10;')"/>
1970 </xsl:when>
1971 <xsl:when test="$G_vboxGlueStyle='jaxws'">
1972 <xsl:value-of select="concat(' javax.xml.ws.Holder&lt;', $backouttype, '&gt; tmp_', @name, ' = new javax.xml.ws.Holder&lt;', $backouttype, '&gt;();&#10;')"/>
1973 </xsl:when>
1974 <xsl:otherwise>
1975 <xsl:call-template name="fatalError">
1976 <xsl:with-param name="msg" select="'Handle out param (genMethod)'" />
1977 </xsl:call-template>
1978 </xsl:otherwise>
1979 </xsl:choose>
1980 </xsl:for-each>
1981
1982 <!-- declare return param, if any -->
1983 <xsl:if test="$hasReturnParms">
1984 <xsl:variable name="backrettype">
1985 <xsl:call-template name="typeIdl2Back">
1986 <xsl:with-param name="type" select="$returnidltype" />
1987 <xsl:with-param name="safearray" select="$returnidlsafearray" />
1988 </xsl:call-template>
1989 </xsl:variable>
1990 <xsl:choose>
1991 <xsl:when test="(param[@dir='out']) and ($G_vboxGlueStyle='jaxws')">
1992 <xsl:value-of select="concat(' javax.xml.ws.Holder&lt;', $backrettype, '&gt;',
1993 ' retVal = new javax.xml.ws.Holder&lt;', $backrettype,
1994 '&gt;();&#10;')"/>
1995 </xsl:when>
1996 <xsl:otherwise>
1997 <xsl:value-of select="concat(' ', $backrettype, ' retVal;&#10;')"/>
1998 </xsl:otherwise>
1999 </xsl:choose>
2000 </xsl:if>
2001
2002 <!-- Method call -->
2003 <xsl:call-template name="genBackMethodCall">
2004 <xsl:with-param name="ifname" select="$ifname" />
2005 <xsl:with-param name="methodname" select="$methodname" />
2006 <xsl:with-param name="retval" select="'retVal'" />
2007 </xsl:call-template>
2008
2009 <!-- return out params -->
2010 <xsl:for-each select="param[@dir='out']">
2011 <xsl:variable name="varval">
2012 <xsl:choose>
2013 <xsl:when test="$G_vboxGlueStyle='xpcom'">
2014 <xsl:value-of select="concat('tmp_', @name, '[0]')" />
2015 </xsl:when>
2016 <xsl:when test="$G_vboxGlueStyle='mscom'">
2017 <xsl:value-of select="concat('tmp_', @name)" />
2018 </xsl:when>
2019 <xsl:when test="$G_vboxGlueStyle='jaxws'">
2020 <xsl:value-of select="concat('tmp_', @name, '.value')" />
2021 </xsl:when>
2022 <xsl:otherwise>
2023 <xsl:call-template name="fatalError">
2024 <xsl:with-param name="msg" select="'Style unknown (genMethod, outparam)'" />
2025 </xsl:call-template>
2026 </xsl:otherwise>
2027 </xsl:choose>
2028 </xsl:variable>
2029 <xsl:variable name="wrapped">
2030 <xsl:call-template name="cookOutParam">
2031 <xsl:with-param name="value" select="$varval" />
2032 <xsl:with-param name="idltype" select="@type" />
2033 <xsl:with-param name="safearray" select="@safearray" />
2034 </xsl:call-template>
2035 </xsl:variable>
2036 <xsl:value-of select="concat(' ', @name, '.value = ', $wrapped, ';&#10;')"/>
2037 </xsl:for-each>
2038
2039 <xsl:if test="$hasReturnParms">
2040 <!-- actual 'return' statement -->
2041 <xsl:variable name="wrapped">
2042 <xsl:call-template name="cookOutParam">
2043 <xsl:with-param name="value" select="$retValValue" />
2044 <xsl:with-param name="idltype" select="$returnidltype" />
2045 <xsl:with-param name="safearray" select="$returnidlsafearray" />
2046 </xsl:call-template>
2047 </xsl:variable>
2048 <xsl:value-of select="concat(' return ', $wrapped, ';&#10;')" />
2049 </xsl:if>
2050 <xsl:call-template name="endExcWrapper"/>
2051
2052 <xsl:text> }&#10;</xsl:text>
2053 </xsl:otherwise>
2054 </xsl:choose>
2055
2056</xsl:template>
2057
2058<!-- Callback interface method -->
2059<xsl:template name="genCbMethodDecl">
2060 <xsl:param name="ifname"/>
2061 <xsl:param name="methodname"/>
2062
2063 <xsl:choose>
2064 <xsl:when test="(param[@mod='ptr'])" >
2065 <xsl:value-of select="concat(' // Skipping method ', $methodname, ' for it has parameters with suppressed types&#10;')" />
2066 </xsl:when>
2067 <xsl:otherwise>
2068 <xsl:variable name="returnidltype" select="param[@dir='return']/@type" />
2069 <xsl:variable name="returnidlsafearray" select="param[@dir='return']/@safearray" />
2070 <xsl:variable name="returngluetype">
2071 <xsl:choose>
2072 <xsl:when test="$returnidltype">
2073 <xsl:call-template name="typeIdl2Glue">
2074 <xsl:with-param name="type" select="$returnidltype" />
2075 <xsl:with-param name="safearray" select="$returnidlsafearray" />
2076 </xsl:call-template>
2077 </xsl:when>
2078 <xsl:otherwise>
2079 <xsl:text>void</xsl:text>
2080 </xsl:otherwise>
2081 </xsl:choose>
2082 </xsl:variable>
2083 <xsl:value-of select="concat(' public ', $returngluetype, ' ', $methodname, '(')" />
2084 <xsl:variable name="paramsinout" select="param[@dir='in' or @dir='out']" />
2085 <xsl:for-each select="exsl:node-set($paramsinout)">
2086 <xsl:variable name="paramgluetype">
2087 <xsl:call-template name="typeIdl2Glue">
2088 <xsl:with-param name="type" select="@type" />
2089 <xsl:with-param name="safearray" select="@safearray" />
2090 </xsl:call-template>
2091 </xsl:variable>
2092 <xsl:choose>
2093 <xsl:when test="@dir='out'">
2094 <xsl:value-of select="concat('Holder&lt;', $paramgluetype, '&gt; ', @name)" />
2095 </xsl:when>
2096 <xsl:otherwise>
2097 <xsl:value-of select="concat($paramgluetype, ' ', @name)" />
2098 </xsl:otherwise>
2099 </xsl:choose>
2100 <xsl:if test="not(position()=last())">
2101 <xsl:text>, </xsl:text>
2102 </xsl:if>
2103 </xsl:for-each>
2104 <xsl:text>);&#10;</xsl:text>
2105 </xsl:otherwise>
2106 </xsl:choose>
2107</xsl:template>
2108
2109<!-- queryInterface wrapper -->
2110<xsl:template name="genQI">
2111 <xsl:param name="ifname"/>
2112 <xsl:param name="uuid" />
2113
2114 <xsl:value-of select="concat(' public static ', $ifname, ' queryInterface(IUnknown obj)&#10;')" />
2115 <xsl:text> {&#10;</xsl:text>
2116 <xsl:choose>
2117 <xsl:when test="$G_vboxGlueStyle='xpcom'">
2118 <xsl:variable name="backtype">
2119 <xsl:call-template name="typeIdl2Back">
2120 <xsl:with-param name="type" select="$ifname" />
2121 </xsl:call-template>
2122 </xsl:variable>
2123 <xsl:text> nsISupports nsobj = obj != null ? (nsISupports)obj.getWrapped() : null;&#10;</xsl:text>
2124 <xsl:text> if (nsobj == null) return null;&#10;</xsl:text>
2125 <xsl:value-of select="concat(' ', $backtype, ' qiobj = Helper.queryInterface(nsobj, &quot;{', $uuid, '}&quot;, ', $backtype, '.class);&#10;')" />
2126 <xsl:value-of select="concat(' return qiobj == null ? null : new ', $ifname, '(qiobj);&#10;')" />
2127 </xsl:when>
2128
2129 <xsl:when test="$G_vboxGlueStyle='mscom'">
2130 <xsl:value-of select="concat(' return', ' obj == null ? null : new ', $ifname, '((com.jacob.com.Dispatch)obj.getWrapped());&#10;')" />
2131 </xsl:when>
2132
2133 <xsl:when test="$G_vboxGlueStyle='jaxws'">
2134 <!-- bad, need to check that we really can be casted to this type -->
2135 <xsl:value-of select="concat(' return obj == null ? null : new ', $ifname, '(obj.getWrapped(), obj.getRemoteWSPort());&#10;')" />
2136 </xsl:when>
2137
2138 <xsl:otherwise>
2139 <xsl:call-template name="fatalError">
2140 <xsl:with-param name="msg" select="'Style unknown (genQI)'" />
2141 </xsl:call-template>
2142 </xsl:otherwise>
2143
2144 </xsl:choose>
2145 <xsl:text> }&#10;</xsl:text>
2146</xsl:template>
2147
2148
2149<xsl:template name="genCbMethodImpl">
2150 <xsl:param name="ifname"/>
2151 <xsl:param name="methodname"/>
2152
2153 <xsl:choose>
2154 <xsl:when test="(param[@mod='ptr'])" >
2155 <xsl:value-of select="concat(' // Skipping method ', $methodname, ' for it has parameters with suppressed types&#10;')" />
2156 </xsl:when>
2157 <xsl:otherwise>
2158 <xsl:variable name="hasReturnParms" select="param[@dir='return']" />
2159 <xsl:variable name="hasOutParms" select="param[@dir='out']" />
2160 <xsl:variable name="returnidltype" select="param[@dir='return']/@type" />
2161 <xsl:variable name="returnidlsafearray" select="param[@dir='return']/@safearray" />
2162 <xsl:variable name="returnbacktype">
2163 <xsl:choose>
2164 <xsl:when test="$returnidltype">
2165 <xsl:call-template name="typeIdl2Back">
2166 <xsl:with-param name="type" select="$returnidltype" />
2167 <xsl:with-param name="safearray" select="$returnidlsafearray" />
2168 </xsl:call-template>
2169 </xsl:when>
2170 <xsl:otherwise>
2171 <xsl:text>void</xsl:text>
2172 </xsl:otherwise>
2173 </xsl:choose>
2174 </xsl:variable>
2175 <xsl:variable name="paramsinout" select="param[@dir='in' or @dir='out']" />
2176 <xsl:choose>
2177 <xsl:when test="$G_vboxGlueStyle='xpcom'">
2178 <xsl:value-of select="concat(' public ', $returnbacktype, ' ', $methodname, '(')" />
2179 <xsl:for-each select="exsl:node-set($paramsinout)">
2180 <xsl:variable name="parambacktype">
2181 <xsl:call-template name="typeIdl2Back">
2182 <xsl:with-param name="type" select="@type" />
2183 <xsl:with-param name="safearray" select="@safearray" />
2184 </xsl:call-template>
2185 </xsl:variable>
2186 <xsl:choose>
2187 <xsl:when test="@dir='out'">
2188 <xsl:value-of select="concat($parambacktype, '[] ', @name)" />
2189 </xsl:when>
2190 <xsl:otherwise>
2191 <xsl:if test="@safearray">
2192 <xsl:value-of select="concat('long len_', @name, ', ')" />
2193 </xsl:if>
2194 <xsl:value-of select="concat($parambacktype, ' ', @name)" />
2195 </xsl:otherwise>
2196 </xsl:choose>
2197 <xsl:if test="not(position()=last())">
2198 <xsl:text>, </xsl:text>
2199 </xsl:if>
2200 </xsl:for-each>
2201 <xsl:text>)&#10;</xsl:text>
2202 <xsl:text> {&#10;</xsl:text>
2203 </xsl:when>
2204
2205 <xsl:when test="$G_vboxGlueStyle='mscom'">
2206 <xsl:variable name="capsname">
2207 <xsl:call-template name="capitalize">
2208 <xsl:with-param name="str" select="$methodname" />
2209 </xsl:call-template>
2210 </xsl:variable>
2211 <xsl:value-of select="concat(' public ', $returnbacktype, ' ', $capsname, '(')" />
2212 <xsl:text>Variant _args[])&#10;</xsl:text>
2213 <xsl:text> {&#10;</xsl:text>
2214 <xsl:for-each select="exsl:node-set($paramsinout)">
2215 <xsl:variable name="parambacktype">
2216 <xsl:call-template name="typeIdl2Back">
2217 <xsl:with-param name="type" select="@type" />
2218 <xsl:with-param name="safearray" select="@safearray" />
2219 </xsl:call-template>
2220 </xsl:variable>
2221 <xsl:value-of select="concat(' ', $parambacktype, ' ', @name, '=_args[', count(preceding-sibling::param), '];&#10;')" />
2222 </xsl:for-each>
2223 </xsl:when>
2224
2225 <xsl:otherwise>
2226 <xsl:call-template name="fatalError">
2227 <xsl:with-param name="msg" select="'Style unknown (genSetterCall)'" />
2228 </xsl:call-template>
2229 </xsl:otherwise>
2230 </xsl:choose>
2231
2232 <!-- declare temp out params -->
2233 <xsl:for-each select="param[@dir='out']">
2234 <xsl:variable name="glueouttype">
2235 <xsl:call-template name="typeIdl2Glue">
2236 <xsl:with-param name="type" select="@type" />
2237 <xsl:with-param name="safearray" select="@safearray" />
2238 </xsl:call-template>
2239 </xsl:variable>
2240 <xsl:value-of select="concat(' Holder&lt;', $glueouttype, '&gt; tmp_', @name, ' = new Holder&lt;', $glueouttype, '&gt;();&#10;')"/>
2241 </xsl:for-each>
2242
2243 <!-- declare return param, if any -->
2244 <xsl:if test="$hasReturnParms">
2245 <xsl:variable name="gluerettype">
2246 <xsl:call-template name="typeIdl2Glue">
2247 <xsl:with-param name="type" select="$returnidltype" />
2248 <xsl:with-param name="safearray" select="$returnidlsafearray" />
2249 </xsl:call-template>
2250 </xsl:variable>
2251 <xsl:value-of select="concat(' ', $gluerettype, ' retVal = &#10;')"/>
2252 </xsl:if>
2253
2254 <!-- Method call -->
2255 <xsl:value-of select="concat(' sink.', $methodname, '(')"/>
2256 <xsl:for-each select="param[not(@dir='return')]">
2257 <xsl:choose>
2258 <xsl:when test="@dir='out'">
2259 <xsl:value-of select="concat('tmp_', @name)" />
2260 </xsl:when>
2261 <xsl:when test="@dir='in'">
2262 <xsl:variable name="wrapped">
2263 <xsl:call-template name="cookOutParam">
2264 <xsl:with-param name="value" select="@name" />
2265 <xsl:with-param name="idltype" select="@type" />
2266 <xsl:with-param name="safearray" select="@safearray" />
2267 </xsl:call-template>
2268 </xsl:variable>
2269 <xsl:value-of select="$wrapped"/>
2270 </xsl:when>
2271 <xsl:otherwise>
2272 <xsl:call-template name="fatalError">
2273 <xsl:with-param name="msg" select="concat('Unsupported param dir: ', @dir, '&quot;.')" />
2274 </xsl:call-template>
2275 </xsl:otherwise>
2276 </xsl:choose>
2277 <xsl:if test="not(position()=last())">
2278 <xsl:text>, </xsl:text>
2279 </xsl:if>
2280 </xsl:for-each>
2281 <xsl:text>);&#10;</xsl:text>
2282
2283 <!-- return out params -->
2284 <xsl:for-each select="param[@dir='out']">
2285
2286 <xsl:variable name="unwrapped">
2287 <xsl:call-template name="cookInParam">
2288 <xsl:with-param name="value" select="concat('tmp_', @name, '.value')" />
2289 <xsl:with-param name="idltype" select="@type" />
2290 <xsl:with-param name="safearray" select="@safearray" />
2291 </xsl:call-template>
2292 </xsl:variable>
2293 <xsl:choose>
2294 <xsl:when test="$G_vboxGlueStyle='xpcom'">
2295 <xsl:value-of select="concat(' ', @name, '[0] = ', $unwrapped, ';&#10;')"/>
2296 </xsl:when>
2297 <xsl:when test="$G_vboxGlueStyle='mscom'">
2298 <xsl:value-of select="concat(' _args[', count(preceding-sibling::param), '] = ', $unwrapped, ';&#10;')"/>
2299 </xsl:when>
2300 </xsl:choose>
2301 </xsl:for-each>
2302
2303 <xsl:if test="$hasReturnParms">
2304 <!-- actual 'return' statement -->
2305 <xsl:variable name="unwrapped">
2306 <xsl:call-template name="cookInParam">
2307 <xsl:with-param name="value" select="'retVal'" />
2308 <xsl:with-param name="idltype" select="$returnidltype" />
2309 <xsl:with-param name="safearray" select="$returnidlsafearray" />
2310 </xsl:call-template>
2311 </xsl:variable>
2312 <xsl:value-of select="concat(' return ', $unwrapped, ';&#10;')" />
2313 </xsl:if>
2314 <xsl:text> }&#10;</xsl:text>
2315 </xsl:otherwise>
2316 </xsl:choose>
2317</xsl:template>
2318
2319<!-- Interface method -->
2320<xsl:template name="genIfaceWrapper">
2321 <xsl:param name="ifname"/>
2322
2323 <xsl:variable name="wrappedType">
2324 <xsl:call-template name="wrappedName">
2325 <xsl:with-param name="ifname" select="$ifname" />
2326 </xsl:call-template>
2327 </xsl:variable>
2328
2329 <!-- Constructor -->
2330 <xsl:choose>
2331 <xsl:when test="($G_vboxGlueStyle='jaxws')">
2332 <xsl:value-of select="concat(' public ', $ifname, '(String wrapped, VboxPortType port)&#10;')" />
2333 <xsl:text> {&#10;</xsl:text>
2334 <xsl:text> super(wrapped, port);&#10;</xsl:text>
2335 <xsl:text> }&#10;</xsl:text>
2336 </xsl:when>
2337
2338 <xsl:when test="($G_vboxGlueStyle='xpcom') or ($G_vboxGlueStyle='mscom')">
2339 <xsl:value-of select="concat(' public ', $ifname, '(', $wrappedType, ' wrapped)&#10;')" />
2340 <xsl:text> {&#10;</xsl:text>
2341 <xsl:text> super(wrapped);&#10;</xsl:text>
2342 <xsl:text> }&#10;</xsl:text>
2343
2344 <!-- Typed wrapped object accessor -->
2345 <xsl:value-of select="concat(' public ', $wrappedType, ' getTypedWrapped()&#10;')" />
2346 <xsl:text> {&#10;</xsl:text>
2347 <xsl:value-of select="concat(' return (', $wrappedType, ') getWrapped();&#10;')" />
2348 <xsl:text> }&#10;</xsl:text>
2349 </xsl:when>
2350
2351 <xsl:otherwise>
2352 <xsl:call-template name="fatalError">
2353 <xsl:with-param name="msg" select="'Style unknown (root, ctr)'" />
2354 </xsl:call-template>
2355 </xsl:otherwise>
2356 </xsl:choose>
2357 <!-- Attributes -->
2358 <xsl:for-each select="attribute[not(@mod='ptr')]">
2359 <xsl:variable name="attrname"><xsl:value-of select="@name" /></xsl:variable>
2360 <xsl:variable name="attrtype"><xsl:value-of select="@type" /></xsl:variable>
2361 <xsl:variable name="attrsafearray"><xsl:value-of select="@safearray" /></xsl:variable>
2362
2363 <xsl:choose>
2364 <xsl:when test="($G_vboxGlueStyle='jaxws') and ($attrtype=($G_setSuppressedInterfaces/@name))">
2365 <xsl:value-of select="concat(' // Skipping attribute ', $attrname, ' of suppressed type ', $attrtype, '&#10;&#10;')" />
2366 </xsl:when>
2367 <xsl:when test="($G_vboxGlueStyle='jaxws') and (@wsmap = 'suppress')" >
2368 <xsl:value-of select="concat(' // Skipping attribute ', $attrname, ' for it is suppressed&#10;')" />
2369 </xsl:when>
2370
2371 <xsl:otherwise>
2372 <!-- emit getter method -->
2373 <xsl:apply-templates select="desc" mode="attribute_get"/>
2374 <xsl:variable name="gettername">
2375 <xsl:call-template name="makeGetterName">
2376 <xsl:with-param name="attrname" select="$attrname" />
2377 </xsl:call-template>
2378 </xsl:variable>
2379 <xsl:variable name="gluetype">
2380 <xsl:call-template name="typeIdl2Glue">
2381 <xsl:with-param name="type" select="$attrtype" />
2382 <xsl:with-param name="safearray" select="@safearray" />
2383 </xsl:call-template>
2384 </xsl:variable>
2385 <xsl:variable name="backtype">
2386 <xsl:call-template name="typeIdl2Back">
2387 <xsl:with-param name="type" select="$attrtype" />
2388 <xsl:with-param name="safearray" select="@safearray" />
2389 </xsl:call-template>
2390 </xsl:variable>
2391 <xsl:variable name="wrapped">
2392 <xsl:call-template name="cookOutParam">
2393 <xsl:with-param name="value" select="'retVal'" />
2394 <xsl:with-param name="idltype" select="$attrtype" />
2395 <xsl:with-param name="safearray" select="@safearray" />
2396 </xsl:call-template>
2397 </xsl:variable>
2398 <xsl:value-of select="concat(' public ', $gluetype, ' ', $gettername, '()&#10;')" />
2399 <xsl:text> {&#10;</xsl:text>
2400
2401 <xsl:call-template name="startExcWrapper"/>
2402
2403 <!-- Actual getter implementation -->
2404 <xsl:call-template name="genGetterCall">
2405 <xsl:with-param name="ifname" select="$ifname" />
2406 <xsl:with-param name="gettername" select="$gettername" />
2407 <xsl:with-param name="backtype" select="$backtype" />
2408 <xsl:with-param name="retval" select="'retVal'" />
2409 </xsl:call-template>
2410
2411 <xsl:value-of select="concat(' return ', $wrapped, ';&#10;')" />
2412 <xsl:call-template name="endExcWrapper"/>
2413
2414 <xsl:text> }&#10;</xsl:text>
2415 <xsl:if test="not(@readonly = 'yes')">
2416 <!-- emit setter method -->
2417 <xsl:apply-templates select="desc" mode="attribute_set"/>
2418 <xsl:variable name="settername"><xsl:call-template name="makeSetterName"><xsl:with-param name="attrname" select="$attrname" /></xsl:call-template></xsl:variable>
2419 <xsl:variable name="unwrapped">
2420 <xsl:call-template name="cookInParam">
2421 <xsl:with-param name="ifname" select="$ifname" />
2422 <xsl:with-param name="value" select="'value'" />
2423 <xsl:with-param name="idltype" select="$attrtype" />
2424 <xsl:with-param name="safearray" select="@safearray" />
2425 </xsl:call-template>
2426 </xsl:variable>
2427 <xsl:value-of select="concat(' public void ', $settername, '(', $gluetype, ' value)&#10;')" />
2428 <xsl:text> {&#10;</xsl:text>
2429 <xsl:call-template name="startExcWrapper"/>
2430 <!-- Actual setter implementation -->
2431 <xsl:call-template name="genSetterCall">
2432 <xsl:with-param name="ifname" select="$ifname" />
2433 <xsl:with-param name="settername" select="$settername" />
2434 <xsl:with-param name="value" select="$unwrapped" />
2435 </xsl:call-template>
2436 <xsl:call-template name="endExcWrapper"/>
2437 <xsl:text> }&#10;</xsl:text>
2438 </xsl:if>
2439
2440 </xsl:otherwise>
2441 </xsl:choose>
2442
2443 </xsl:for-each>
2444
2445 <!-- emit queryInterface() *to* this class -->
2446 <xsl:call-template name="genQI">
2447 <xsl:with-param name="ifname" select="$ifname" />
2448 <xsl:with-param name="uuid" select="@uuid" />
2449 </xsl:call-template>
2450
2451 <!-- emit methods -->
2452 <xsl:for-each select="method">
2453 <xsl:call-template name="genMethod">
2454 <xsl:with-param name="ifname" select="$ifname" />
2455 <xsl:with-param name="methodname" select="@name" />
2456 </xsl:call-template>
2457 </xsl:for-each>
2458
2459</xsl:template>
2460
2461<xsl:template name="genIface">
2462 <xsl:param name="ifname" />
2463 <xsl:param name="filename" />
2464
2465 <xsl:variable name="wsmap" select="@wsmap" />
2466
2467 <xsl:call-template name="startFile">
2468 <xsl:with-param name="file" select="$filename" />
2469 <xsl:with-param name="package" select="$G_virtualBoxPackage" />
2470 </xsl:call-template>
2471
2472 <xsl:if test="$filelistonly=''">
2473 <xsl:text>import java.util.List;&#10;&#10;</xsl:text>
2474
2475 <xsl:apply-templates select="desc" mode="interface"/>
2476
2477 <xsl:choose>
2478 <xsl:when test="($wsmap='struct') and ($G_vboxGlueStyle='jaxws')">
2479 <xsl:value-of select="concat('public class ', $ifname, '&#10;')" />
2480 <xsl:text>{&#10;&#10;</xsl:text>
2481 <xsl:call-template name="genStructWrapperJaxws">
2482 <xsl:with-param name="ifname" select="$ifname" />
2483 </xsl:call-template>
2484 </xsl:when>
2485
2486 <xsl:otherwise>
2487 <xsl:variable name="extends" select="//interface[@name=$ifname]/@extends" />
2488 <xsl:choose>
2489 <xsl:when test="($extends = '$unknown') or ($extends = '$dispatched') or ($extends = '$errorinfo')">
2490 <xsl:value-of select="concat('public class ', $ifname, ' extends IUnknown&#10;')" />
2491 <xsl:text>{&#10;&#10;</xsl:text>
2492 </xsl:when>
2493 <xsl:when test="//interface[@name=$extends]">
2494 <xsl:value-of select="concat('public class ', $ifname, ' extends ', $extends, '&#10;')" />
2495 <xsl:text>{&#10;&#10;</xsl:text>
2496 </xsl:when>
2497 <xsl:otherwise>
2498 <xsl:call-template name="fatalError">
2499 <xsl:with-param name="msg" select="concat('Interface generation: interface &quot;', $ifname, '&quot; has invalid &quot;extends&quot; value ', $extends, '.')" />
2500 </xsl:call-template>
2501 </xsl:otherwise>
2502 </xsl:choose>
2503 <xsl:call-template name="genIfaceWrapper">
2504 <xsl:with-param name="ifname" select="$ifname" />
2505 </xsl:call-template>
2506 </xsl:otherwise>
2507 </xsl:choose>
2508
2509 <!-- end of class -->
2510 <xsl:text>}&#10;</xsl:text>
2511 </xsl:if>
2512
2513 <xsl:call-template name="endFile">
2514 <xsl:with-param name="file" select="$filename" />
2515 </xsl:call-template>
2516
2517</xsl:template>
2518
2519<xsl:template name="genCb">
2520 <xsl:param name="ifname" />
2521 <xsl:param name="filename" />
2522 <xsl:param name="filenameimpl" />
2523
2524 <xsl:call-template name="startFile">
2525 <xsl:with-param name="file" select="$filename" />
2526 <xsl:with-param name="package" select="$G_virtualBoxPackage" />
2527 </xsl:call-template>
2528
2529 <xsl:text>import java.util.List;&#10;</xsl:text>
2530
2531 <xsl:value-of select="concat('public interface ', $ifname, '&#10;')" />
2532 <xsl:text>{&#10;</xsl:text>
2533
2534 <!-- emit methods declarations-->
2535 <xsl:for-each select="method">
2536 <xsl:call-template name="genCbMethodDecl">
2537 <xsl:with-param name="ifname" select="$ifname" />
2538 <xsl:with-param name="methodname" select="@name" />
2539 </xsl:call-template>
2540 </xsl:for-each>
2541
2542 <xsl:text>}&#10;&#10;</xsl:text>
2543
2544 <xsl:call-template name="endFile">
2545 <xsl:with-param name="file" select="$filename" />
2546 </xsl:call-template>
2547
2548 <xsl:call-template name="startFile">
2549 <xsl:with-param name="file" select="$filenameimpl" />
2550 <xsl:with-param name="package" select="$G_virtualBoxPackage" />
2551 </xsl:call-template>
2552
2553 <xsl:text>import java.util.List;&#10;</xsl:text>
2554
2555 <xsl:variable name="backtype">
2556 <xsl:call-template name="typeIdl2Back">
2557 <xsl:with-param name="type" select="$ifname" />
2558 </xsl:call-template>
2559 </xsl:variable>
2560
2561 <!-- emit glue methods body -->
2562 <xsl:choose>
2563 <xsl:when test="$G_vboxGlueStyle='xpcom'">
2564 <xsl:value-of select="concat('class ', $ifname, 'Impl extends nsISupportsBase implements ', $backtype, '&#10;')" />
2565 <xsl:text>{&#10;</xsl:text>
2566 </xsl:when>
2567
2568 <xsl:when test="$G_vboxGlueStyle='mscom'">
2569 <xsl:value-of select="concat('public class ', $ifname, 'Impl&#10;')" />
2570 <xsl:text>{&#10;</xsl:text>
2571 </xsl:when>
2572 </xsl:choose>
2573
2574 <xsl:value-of select="concat(' ', $ifname, ' sink;&#10;')" />
2575
2576 <xsl:value-of select="concat(' ', $ifname, 'Impl(', $ifname, ' sink)&#10;')" />
2577 <xsl:text> {&#10;</xsl:text>
2578 <xsl:text> this.sink = sink;&#10;</xsl:text>
2579 <xsl:text> }&#10;</xsl:text>
2580
2581 <!-- emit methods implementations -->
2582 <xsl:for-each select="method">
2583 <xsl:call-template name="genCbMethodImpl">
2584 <xsl:with-param name="ifname" select="$ifname" />
2585 <xsl:with-param name="methodname" select="@name" />
2586 </xsl:call-template>
2587 </xsl:for-each>
2588
2589 <xsl:text>}&#10;&#10;</xsl:text>
2590
2591 <xsl:call-template name="endFile">
2592 <xsl:with-param name="file" select="$filenameimpl" />
2593 </xsl:call-template>
2594</xsl:template>
2595
2596<xsl:template name="emitHandwritten">
2597
2598 <xsl:call-template name="startFile">
2599 <xsl:with-param name="file" select="'Holder.java'" />
2600 <xsl:with-param name="package" select="$G_virtualBoxPackage" />
2601 </xsl:call-template>
2602
2603 <xsl:if test="$filelistonly=''">
2604 <xsl:text><![CDATA[
2605public class Holder<T>
2606{
2607 public T value;
2608
2609 public Holder()
2610 {
2611 }
2612 public Holder(T value)
2613 {
2614 this.value = value;
2615 }
2616}
2617]]></xsl:text>
2618 </xsl:if>
2619
2620 <xsl:call-template name="endFile">
2621 <xsl:with-param name="file" select="'Holder.java'" />
2622 </xsl:call-template>
2623</xsl:template>
2624
2625<xsl:template name="emitHandwrittenXpcom">
2626
2627 <xsl:call-template name="startFile">
2628 <xsl:with-param name="file" select="'IUnknown.java'" />
2629 <xsl:with-param name="package" select="$G_virtualBoxPackageCom" />
2630 </xsl:call-template>
2631
2632 <xsl:if test="$filelistonly=''">
2633 <xsl:text><![CDATA[
2634public class IUnknown
2635{
2636 private Object obj;
2637 public IUnknown(Object obj)
2638 {
2639 this.obj = obj;
2640 }
2641
2642 public Object getWrapped()
2643 {
2644 return this.obj;
2645 }
2646
2647 public void setWrapped(Object obj)
2648 {
2649 this.obj = obj;
2650 }
2651}
2652]]></xsl:text>
2653 </xsl:if>
2654
2655 <xsl:call-template name="endFile">
2656 <xsl:with-param name="file" select="'IUnknown.java'" />
2657 </xsl:call-template>
2658
2659 <xsl:call-template name="startFile">
2660 <xsl:with-param name="file" select="'Helper.java'" />
2661 <xsl:with-param name="package" select="$G_virtualBoxPackageCom" />
2662 </xsl:call-template>
2663
2664 <xsl:if test="$filelistonly=''">
2665 <xsl:text><![CDATA[
2666
2667import java.util.List;
2668import java.util.ArrayList;
2669import java.util.Collections;
2670import java.lang.reflect.Array;
2671import java.lang.reflect.Constructor;
2672import java.lang.reflect.InvocationTargetException;
2673
2674public class Helper
2675{
2676 public static List<Short> wrap(byte[] values)
2677 {
2678 if (values == null)
2679 return null;
2680
2681 List<Short> ret = new ArrayList<Short>(values.length);
2682 for (short v : values)
2683 {
2684 ret.add(v);
2685 }
2686 return ret;
2687 }
2688
2689 public static List<Short> wrap(short[] values)
2690 {
2691 if (values == null)
2692 return null;
2693
2694 List<Short> ret = new ArrayList<Short>(values.length);
2695 for (short v : values)
2696 {
2697 ret.add(v);
2698 }
2699 return ret;
2700 }
2701
2702 public static List<Integer> wrap(int[] values)
2703 {
2704 if (values == null)
2705 return null;
2706
2707 List<Integer> ret = new ArrayList<Integer>(values.length);
2708 for (int v : values)
2709 {
2710 ret.add(v);
2711 }
2712 return ret;
2713 }
2714
2715 public static List<Long> wrap(long[] values)
2716 {
2717 if (values == null)
2718 return null;
2719
2720 List<Long> ret = new ArrayList<Long>(values.length);
2721 for (long v : values)
2722 {
2723 ret.add(v);
2724 }
2725 return ret;
2726 }
2727
2728 public static List<Boolean> wrap(boolean[] values)
2729 {
2730 if (values == null)
2731 return null;
2732
2733 List<Boolean> ret = new ArrayList<Boolean>(values.length);
2734 for (boolean v: values)
2735 {
2736 ret.add(v);
2737 }
2738 return ret;
2739 }
2740
2741 public static List<String> wrap(String[] values)
2742 {
2743 if (values == null)
2744 return null;
2745
2746 List<String> ret = new ArrayList<String>(values.length);
2747 for (String v : values)
2748 {
2749 ret.add(v);
2750 }
2751 return ret;
2752 }
2753
2754 public static <T> List<T> wrap(Class<T> wrapperClass, T[] values)
2755 {
2756 if (values == null)
2757 return null;
2758
2759 List<T> ret = new ArrayList<T>(values.length);
2760 for (T v : values)
2761 {
2762 ret.add(v);
2763 }
2764 return ret;
2765 }
2766
2767 public static <T> List<T> wrapEnum(Class<T> wrapperClass, long values[])
2768 {
2769 try
2770 {
2771 if (values == null)
2772 return null;
2773 Constructor<T> c = wrapperClass.getConstructor(int.class);
2774 List<T> ret = new ArrayList<T>(values.length);
2775 for (long v : values)
2776 {
2777 ret.add(c.newInstance(v));
2778 }
2779 return ret;
2780 }
2781 catch (NoSuchMethodException e)
2782 {
2783 throw new AssertionError(e);
2784 }
2785 catch (InstantiationException e)
2786 {
2787 throw new AssertionError(e);
2788 }
2789 catch (IllegalAccessException e)
2790 {
2791 throw new AssertionError(e);
2792 }
2793 catch (InvocationTargetException e)
2794 {
2795 throw new AssertionError(e);
2796 }
2797 }
2798 public static short[] unwrapUShort(List<Short> values)
2799 {
2800 if (values == null)
2801 return null;
2802
2803 short[] ret = new short[values.size()];
2804 int i = 0;
2805 for (short l : values)
2806 {
2807 ret[i++] = l;
2808 }
2809 return ret;
2810 }
2811
2812 public static int[] unwrapInteger(List<Integer> values)
2813 {
2814 if (values == null)
2815 return null;
2816
2817 int[] ret = new int[values.size()];
2818 int i = 0;
2819 for (int l : values)
2820 {
2821 ret[i++] = l;
2822 }
2823 return ret;
2824 }
2825
2826 public static long[] unwrapULong(List<Long> values)
2827 {
2828 if (values == null)
2829 return null;
2830
2831 long[] ret = new long[values.size()];
2832 int i = 0;
2833 for (long l : values)
2834 {
2835 ret[i++] = l;
2836 }
2837 return ret;
2838 }
2839
2840 public static boolean[] unwrapBoolean(List<Boolean> values)
2841 {
2842 if (values == null)
2843 return null;
2844
2845 boolean[] ret = new boolean[values.size()];
2846 int i = 0;
2847 for (boolean l : values)
2848 {
2849 ret[i++] = l;
2850 }
2851 return ret;
2852 }
2853
2854 public static String[] unwrapStr(List<String> values)
2855 {
2856 if (values == null)
2857 return null;
2858
2859 String[] ret = new String[values.size()];
2860 int i = 0;
2861 for (String l : values)
2862 {
2863 ret[i++] = l;
2864 }
2865 return ret;
2866 }
2867
2868 public static <T extends Enum <T>> long[] unwrapEnum(Class<T> enumClass, List<T> values)
2869 {
2870 if (values == null)
2871 return null;
2872
2873 long result[] = new long[values.size()];
2874 try
2875 {
2876 java.lang.reflect.Method valueM = enumClass.getMethod("value");
2877 int i = 0;
2878 for (T v : values)
2879 {
2880 result[i++] = (Integer)valueM.invoke(v);
2881 }
2882 return result;
2883 }
2884 catch (NoSuchMethodException e)
2885 {
2886 throw new AssertionError(e);
2887 }
2888 catch(SecurityException e)
2889 {
2890 throw new AssertionError(e);
2891 }
2892 catch (IllegalAccessException e)
2893 {
2894 throw new AssertionError(e);
2895 }
2896 catch (IllegalArgumentException e)
2897 {
2898 throw new AssertionError(e);
2899 }
2900 catch (InvocationTargetException e)
2901 {
2902 throw new AssertionError(e);
2903 }
2904 }
2905
2906 public static <T1, T2> List<T1> wrap2(Class<T1> wrapperClass1, Class<T2> wrapperClass2, T2[] values)
2907 {
2908 try
2909 {
2910 if (values == null)
2911 return null;
2912
2913 Constructor<T1> c = wrapperClass1.getConstructor(wrapperClass2);
2914 List<T1> ret = new ArrayList<T1>(values.length);
2915 for (T2 v : values)
2916 {
2917 ret.add(c.newInstance(v));
2918 }
2919 return ret;
2920 }
2921 catch (NoSuchMethodException e)
2922 {
2923 throw new AssertionError(e);
2924 }
2925 catch (InstantiationException e)
2926 {
2927 throw new AssertionError(e);
2928 }
2929 catch (IllegalAccessException e)
2930 {
2931 throw new AssertionError(e);
2932 }
2933 catch (InvocationTargetException e)
2934 {
2935 throw new AssertionError(e);
2936 }
2937 }
2938
2939 @SuppressWarnings( "unchecked")
2940 public static <T> T[] unwrap(Class<T> wrapperClass, List<T> values)
2941 {
2942 if (values == null)
2943 return null;
2944 if (values.size() == 0)
2945 return null;
2946 return (T[])values.toArray((T[])Array.newInstance(wrapperClass, values.size()));
2947 }
2948
2949 @SuppressWarnings( "unchecked" )
2950 public static <T> T queryInterface(Object obj, String uuid, Class<T> iface)
2951 {
2952 return (T)queryInterface(obj, uuid);
2953 }
2954
2955 public static Object queryInterface(Object obj, String uuid)
2956 {
2957 try
2958 {
2959 /* Kind of ugly, but does the job of casting */
2960 org.mozilla.xpcom.Mozilla moz = org.mozilla.xpcom.Mozilla.getInstance();
2961 long xpobj = moz.wrapJavaObject(obj, uuid);
2962 return moz.wrapXPCOMObject(xpobj, uuid);
2963 }
2964 catch (Exception e)
2965 {
2966 return null;
2967 }
2968 }
2969
2970 @SuppressWarnings("unchecked")
2971 public static <T1 extends IUnknown, T2> T2[] unwrap2(Class<T1> wrapperClass1, Class<T2> wrapperClass2, List<T1> values)
2972 {
2973 if (values == null)
2974 return null;
2975
2976 T2 ret[] = (T2[])Array.newInstance(wrapperClass2, values.size());
2977 int i = 0;
2978 for (T1 obj : values)
2979 {
2980 ret[i++] = (T2)obj.getWrapped();
2981 }
2982 return ret;
2983 }
2984}
2985]]></xsl:text>
2986 </xsl:if>
2987
2988 <xsl:call-template name="endFile">
2989 <xsl:with-param name="file" select="'Helper.java'" />
2990 </xsl:call-template>
2991
2992 <xsl:call-template name="startFile">
2993 <xsl:with-param name="file" select="'VBoxException.java'" />
2994 <xsl:with-param name="package" select="$G_virtualBoxPackage" />
2995 </xsl:call-template>
2996
2997 <xsl:if test="$filelistonly=''">
2998 <xsl:text>
2999import org.mozilla.xpcom.*;
3000
3001public class VBoxException extends RuntimeException
3002{
3003 private int resultCode;
3004 private IVirtualBoxErrorInfo errorInfo;
3005
3006 public VBoxException(String message)
3007 {
3008 super(message);
3009 resultCode = -1;
3010 errorInfo = null;
3011 }
3012
3013 public VBoxException(String message, Throwable cause)
3014 {
3015 super(message, cause);
3016 if (cause instanceof org.mozilla.xpcom.XPCOMException)
3017 {
3018 resultCode = (int)((org.mozilla.xpcom.XPCOMException)cause).errorcode;
3019 try
3020 {
3021 Mozilla mozilla = Mozilla.getInstance();
3022 nsIServiceManager sm = mozilla.getServiceManager();
3023 nsIExceptionService es = (nsIExceptionService)sm.getServiceByContractID("@mozilla.org/exceptionservice;1", nsIExceptionService.NS_IEXCEPTIONSERVICE_IID);
3024 nsIExceptionManager em = es.getCurrentExceptionManager();
3025 nsIException ex = em.getCurrentException();
3026 errorInfo = new IVirtualBoxErrorInfo((org.mozilla.interfaces.IVirtualBoxErrorInfo)ex.queryInterface(org.mozilla.interfaces.IVirtualBoxErrorInfo.IVIRTUALBOXERRORINFO_IID));
3027 }
3028 catch (NullPointerException e)
3029 {
3030 e.printStackTrace();
3031 // nothing we can do
3032 errorInfo = null;
3033 }
3034 }
3035 else
3036 resultCode = -1;
3037 }
3038
3039 public int getResultCode()
3040 {
3041 return resultCode;
3042 }
3043
3044 public IVirtualBoxErrorInfo getVirtualBoxErrorInfo()
3045 {
3046 return errorInfo;
3047 }
3048}
3049</xsl:text>
3050 </xsl:if>
3051
3052 <xsl:call-template name="endFile">
3053 <xsl:with-param name="file" select="'VBoxException.java'" />
3054 </xsl:call-template>
3055
3056 <xsl:call-template name="startFile">
3057 <xsl:with-param name="file" select="'VirtualBoxManager.java'" />
3058 <xsl:with-param name="package" select="$G_virtualBoxPackage" />
3059 </xsl:call-template>
3060
3061 <xsl:if test="$filelistonly=''">
3062 <xsl:text><![CDATA[
3063
3064import java.io.File;
3065
3066import org.mozilla.xpcom.*;
3067import org.mozilla.interfaces.*;
3068
3069public class VirtualBoxManager
3070{
3071 private Mozilla mozilla;
3072 private IVirtualBox vbox;
3073 private nsIComponentManager componentManager;
3074
3075 private VirtualBoxManager(Mozilla mozilla)
3076 {
3077 this.mozilla = mozilla;
3078 this.componentManager = mozilla.getComponentManager();
3079 this.vbox = new IVirtualBox((org.mozilla.interfaces.IVirtualBox) this.componentManager
3080 .createInstanceByContractID("@virtualbox.org/VirtualBox;1",
3081 null,
3082 org.mozilla.interfaces.IVirtualBox.IVIRTUALBOX_IID));
3083 }
3084
3085 public void connect(String url, String username, String passwd)
3086 {
3087 throw new VBoxException("Connect doesn't make sense for local bindings");
3088 }
3089
3090 public void disconnect()
3091 {
3092 throw new VBoxException("Disconnect doesn't make sense for local bindings");
3093 }
3094
3095 public static void initPerThread()
3096 {
3097 }
3098
3099 public static void deinitPerThread()
3100 {
3101 }
3102
3103 public IVirtualBox getVBox()
3104 {
3105 return this.vbox;
3106 }
3107
3108 public ISession getSessionObject()
3109 {
3110 return new ISession((org.mozilla.interfaces.ISession) componentManager
3111 .createInstanceByContractID("@virtualbox.org/Session;1", null,
3112 org.mozilla.interfaces.ISession.ISESSION_IID));
3113 }
3114
3115 public ISession openMachineSession(IMachine m) throws Exception
3116 {
3117 ISession s = getSessionObject();
3118 m.lockMachine(s, LockType.Shared);
3119 return s;
3120 }
3121
3122 public void closeMachineSession(ISession s)
3123 {
3124 if (s != null)
3125 s.unlockMachine();
3126 }
3127
3128 private static boolean hasInstance = false;
3129 private static boolean isMozillaInited = false;
3130
3131 public static synchronized VirtualBoxManager createInstance(String home)
3132 {
3133 if (hasInstance)
3134 throw new VBoxException("only one instance of VirtualBoxManager at a time allowed");
3135 if (home == null || home.equals(""))
3136 home = System.getProperty("vbox.home");
3137
3138 if (home == null)
3139 throw new VBoxException("vbox.home Java property must be defined to use XPCOM bridge");
3140
3141 File grePath = new File(home);
3142
3143 Mozilla mozilla = Mozilla.getInstance();
3144 if (!isMozillaInited)
3145 {
3146 mozilla.initialize(grePath);
3147 try
3148 {
3149 mozilla.initXPCOM(grePath, null);
3150 isMozillaInited = true;
3151 }
3152 catch (Exception e)
3153 {
3154 e.printStackTrace();
3155 return null;
3156 }
3157 }
3158
3159 hasInstance = true;
3160
3161 return new VirtualBoxManager(mozilla);
3162 }
3163
3164 public IEventListener createListener(Object sink)
3165 {
3166 return new IEventListener(new EventListenerImpl(sink));
3167 }
3168
3169 public void cleanup()
3170 {
3171 deinitPerThread();
3172 // cleanup, we don't do that, as XPCOM bridge doesn't cleanly
3173 // shuts down, so we prefer to avoid native shutdown
3174 // mozilla.shutdownXPCOM(null);
3175 mozilla = null;
3176 hasInstance = false;
3177 }
3178
3179 public void waitForEvents(long tmo)
3180 {
3181 mozilla.waitForEvents(tmo);
3182 }
3183}
3184]]></xsl:text>
3185 </xsl:if>
3186
3187 <xsl:call-template name="endFile">
3188 <xsl:with-param name="file" select="'VirtualBoxManager.java'" />
3189 </xsl:call-template>
3190
3191 <xsl:call-template name="startFile">
3192 <xsl:with-param name="file" select="'EventListenerImpl.java'" />
3193 <xsl:with-param name="package" select="$G_virtualBoxPackage" />
3194 </xsl:call-template>
3195
3196 <xsl:if test="$filelistonly=''">
3197 <xsl:text><![CDATA[
3198import org.mozilla.interfaces.*;
3199
3200public class EventListenerImpl extends nsISupportsBase implements org.mozilla.interfaces.IEventListener
3201{
3202 private Object obj;
3203 private java.lang.reflect.Method handleEvent;
3204 EventListenerImpl(Object obj)
3205 {
3206 this.obj = obj;
3207 try
3208 {
3209 this.handleEvent = obj.getClass().getMethod("handleEvent", IEvent.class);
3210 }
3211 catch (Exception e)
3212 {
3213 e.printStackTrace();
3214 }
3215 }
3216 public void handleEvent(org.mozilla.interfaces.IEvent ev)
3217 {
3218 try
3219 {
3220 if (obj != null && handleEvent != null)
3221 handleEvent.invoke(obj, ev != null ? new IEvent(ev) : null);
3222 }
3223 catch (Exception e)
3224 {
3225 e.printStackTrace();
3226 }
3227 }
3228}]]></xsl:text>
3229 </xsl:if>
3230
3231 <xsl:call-template name="endFile">
3232 <xsl:with-param name="file" select="'EventListenerImpl.java'" />
3233 </xsl:call-template>
3234
3235 <xsl:call-template name="startFile">
3236 <xsl:with-param name="file" select="'VBoxObjectBase.java'" />
3237 <xsl:with-param name="package" select="$G_virtualBoxPackage" />
3238 </xsl:call-template>
3239
3240 <xsl:if test="$filelistonly=''">
3241 <xsl:text><![CDATA[
3242abstract class nsISupportsBase implements org.mozilla.interfaces.nsISupports
3243{
3244 public org.mozilla.interfaces.nsISupports queryInterface(String iid)
3245 {
3246 return org.mozilla.xpcom.Mozilla.queryInterface(this, iid);
3247 }
3248}
3249
3250]]></xsl:text>
3251 </xsl:if>
3252
3253 <xsl:call-template name="endFile">
3254 <xsl:with-param name="file" select="'VBoxObjectBase.java'" />
3255 </xsl:call-template>
3256</xsl:template>
3257
3258
3259<xsl:template name="emitHandwrittenMscom">
3260
3261 <xsl:call-template name="startFile">
3262 <xsl:with-param name="file" select="'IUnknown.java'" />
3263 <xsl:with-param name="package" select="$G_virtualBoxPackageCom" />
3264 </xsl:call-template>
3265
3266 <xsl:if test="$filelistonly=''">
3267 <xsl:text><![CDATA[
3268public class IUnknown
3269{
3270 private Object obj;
3271 public IUnknown(Object obj)
3272 {
3273 this.obj = obj;
3274 }
3275
3276 public Object getWrapped()
3277 {
3278 return this.obj;
3279 }
3280
3281 public void setWrapped(Object obj)
3282 {
3283 this.obj = obj;
3284 }
3285}
3286]]></xsl:text>
3287 </xsl:if>
3288
3289 <xsl:call-template name="endFile">
3290 <xsl:with-param name="file" select="'IUnknown.java'" />
3291 </xsl:call-template>
3292
3293 <xsl:call-template name="startFile">
3294 <xsl:with-param name="file" select="'Helper.java'" />
3295 <xsl:with-param name="package" select="$G_virtualBoxPackageCom" />
3296 </xsl:call-template>
3297
3298 <xsl:if test="$filelistonly=''">
3299 <xsl:text><![CDATA[
3300
3301import java.util.List;
3302import java.util.ArrayList;
3303import java.util.Collections;
3304import java.lang.reflect.Array;
3305import java.lang.reflect.Constructor;
3306import java.lang.reflect.InvocationTargetException;
3307import com.jacob.com.*;
3308
3309public class Helper
3310{
3311 public static List<Short> wrap(short[] values)
3312 {
3313 if (values == null)
3314 return null;
3315 if (values.length == 0)
3316 return Collections.emptyList();
3317
3318 List<Short> ret = new ArrayList<Short>(values.length);
3319 for (short v : values)
3320 {
3321 ret.add(v);
3322 }
3323 return ret;
3324 }
3325
3326 public static List<Integer> wrap(int[] values)
3327 {
3328 if (values == null)
3329 return null;
3330 if (values.length == 0)
3331 return Collections.emptyList();
3332
3333 List<Integer> ret = new ArrayList<Integer>(values.length);
3334 for (int v : values)
3335 {
3336 ret.add(v);
3337 }
3338 return ret;
3339 }
3340
3341 public static List<Long> wrap(long[] values)
3342 {
3343 if (values == null)
3344 return null;
3345 if (values.length == 0)
3346 return Collections.emptyList();
3347
3348 List<Long> ret = new ArrayList<Long>(values.length);
3349 for (long v : values)
3350 {
3351 ret.add(v);
3352 }
3353 return ret;
3354 }
3355
3356 public static List<String> wrap(String[] values)
3357 {
3358 if (values == null)
3359 return null;
3360 if (values.length == 0)
3361 return Collections.emptyList();
3362
3363 List<String> ret = new ArrayList<String>(values.length);
3364 for (String v : values)
3365 {
3366 ret.add(v);
3367 }
3368 return ret;
3369 }
3370
3371 public static <T> T wrapDispatch(Class<T> wrapperClass, Dispatch d)
3372 {
3373 try
3374 {
3375 if (d == null || d.m_pDispatch == 0)
3376 return null;
3377 Constructor<T> c = wrapperClass.getConstructor(Dispatch.class);
3378 return (T)c.newInstance(d);
3379 }
3380 catch (NoSuchMethodException e)
3381 {
3382 throw new AssertionError(e);
3383 }
3384 catch (InstantiationException e)
3385 {
3386 throw new AssertionError(e);
3387 }
3388 catch (IllegalAccessException e)
3389 {
3390 throw new AssertionError(e);
3391 }
3392 catch (InvocationTargetException e)
3393 {
3394 throw new AssertionError(e);
3395 }
3396 }
3397
3398 @SuppressWarnings("unchecked")
3399 public static <T> Object wrapVariant(Class<T> wrapperClass, Variant v)
3400 {
3401 if (v == null)
3402 return null;
3403
3404 short vt = v.getvt();
3405 switch (vt)
3406 {
3407 case Variant.VariantNull:
3408 return null;
3409 case Variant.VariantBoolean:
3410 return v.getBoolean();
3411 case Variant.VariantByte:
3412 return v.getByte();
3413 case Variant.VariantShort:
3414 return v.getShort();
3415 case Variant.VariantInt:
3416 return v.getInt();
3417 case Variant.VariantLongInt:
3418 return v.getLong();
3419 case Variant.VariantString:
3420 return v.getString();
3421 case Variant.VariantDispatch:
3422 return wrapDispatch(wrapperClass, v.getDispatch());
3423 default:
3424 throw new VBoxException("unhandled variant type " + vt);
3425 }
3426 }
3427
3428 public static byte[] wrapBytes(SafeArray sa)
3429 {
3430 if (sa == null)
3431 return null;
3432
3433 int saLen = sa.getUBound() - sa.getLBound() + 1;
3434
3435 byte[] ret = new byte[saLen];
3436 int j = 0;
3437 for (int i = sa.getLBound(); i <= sa.getUBound(); i++)
3438 {
3439 Variant v = sa.getVariant(i);
3440 // come up with more effective approach!!!
3441 ret[j++] = v.getByte();
3442 }
3443 return ret;
3444 }
3445
3446 @SuppressWarnings("unchecked")
3447 public static <T> List<T> wrap(Class<T> wrapperClass, SafeArray sa)
3448 {
3449 if (sa == null)
3450 return null;
3451
3452 int saLen = sa.getUBound() - sa.getLBound() + 1;
3453 if (saLen == 0)
3454 return Collections.emptyList();
3455
3456 List<T> ret = new ArrayList<T>(saLen);
3457 for (int i = sa.getLBound(); i <= sa.getUBound(); i++)
3458 {
3459 Variant v = sa.getVariant(i);
3460 ret.add((T)wrapVariant(wrapperClass, v));
3461 }
3462 return ret;
3463 }
3464
3465 public static <T> List<T> wrapEnum(Class<T> wrapperClass, SafeArray sa)
3466 {
3467 try
3468 {
3469 if (sa == null)
3470 return null;
3471
3472 int saLen = sa.getUBound() - sa.getLBound() + 1;
3473 if (saLen == 0)
3474 return Collections.emptyList();
3475 List<T> ret = new ArrayList<T>(saLen);
3476 Constructor<T> c = wrapperClass.getConstructor(int.class);
3477 for (int i = sa.getLBound(); i <= sa.getUBound(); i++)
3478 {
3479 Variant v = sa.getVariant(i);
3480 ret.add(c.newInstance(v.getInt()));
3481 }
3482 return ret;
3483 }
3484 catch (NoSuchMethodException e)
3485 {
3486 throw new AssertionError(e);
3487 }
3488 catch (InstantiationException e)
3489 {
3490 throw new AssertionError(e);
3491 }
3492 catch (IllegalAccessException e)
3493 {
3494 throw new AssertionError(e);
3495 }
3496 catch (InvocationTargetException e)
3497 {
3498 throw new AssertionError(e);
3499 }
3500 }
3501
3502 public static SafeArray unwrapInt(List<Integer> values)
3503 {
3504 if (values == null)
3505 return null;
3506 SafeArray ret = new SafeArray(Variant.VariantInt, values.size());
3507 int i = 0;
3508 for (int l : values)
3509 {
3510 ret.setInt(i++, l);
3511 }
3512 return ret;
3513 }
3514
3515 public static SafeArray unwrapLong(List<Long> values)
3516 {
3517 if (values == null)
3518 return null;
3519 SafeArray ret = new SafeArray(Variant.VariantLongInt, values.size());
3520 int i = 0;
3521 for (long l : values)
3522 {
3523 ret.setLong(i++, l);
3524 }
3525 return ret;
3526 }
3527
3528 public static SafeArray unwrapBool(List<Boolean> values)
3529 {
3530 if (values == null)
3531 return null;
3532
3533 SafeArray result = new SafeArray(Variant.VariantBoolean, values.size());
3534 int i = 0;
3535 for (boolean l : values)
3536 {
3537 result.setBoolean(i++, l);
3538 }
3539 return result;
3540 }
3541
3542
3543 public static SafeArray unwrapBytes(byte[] values)
3544 {
3545 if (values == null)
3546 return null;
3547
3548 SafeArray result = new SafeArray(Variant.VariantByte, values.length);
3549 int i = 0;
3550 for (byte l : values)
3551 {
3552 result.setByte(i++, l);
3553 }
3554 return result;
3555 }
3556
3557
3558 public static <T extends Enum <T>> SafeArray unwrapEnum(Class<T> enumClass, List<T> values)
3559 {
3560 if (values == null)
3561 return null;
3562
3563 SafeArray result = new SafeArray(Variant.VariantInt, values.size());
3564 try
3565 {
3566 java.lang.reflect.Method valueM = enumClass.getMethod("value");
3567 int i = 0;
3568 for (T v : values)
3569 {
3570 result.setInt(i++, (Integer)valueM.invoke(v));
3571 }
3572 return result;
3573 }
3574 catch (NoSuchMethodException e)
3575 {
3576 throw new AssertionError(e);
3577 }
3578 catch(SecurityException e)
3579 {
3580 throw new AssertionError(e);
3581 }
3582 catch (IllegalAccessException e)
3583 {
3584 throw new AssertionError(e);
3585 }
3586 catch (IllegalArgumentException e)
3587 {
3588 throw new AssertionError(e);
3589 }
3590 catch (InvocationTargetException e)
3591 {
3592 throw new AssertionError(e);
3593 }
3594 }
3595 public static SafeArray unwrapString(List<String> values)
3596 {
3597 if (values == null)
3598 return null;
3599 SafeArray result = new SafeArray(Variant.VariantString, values.size());
3600 int i = 0;
3601 for (String l : values)
3602 {
3603 result.setString(i++, l);
3604 }
3605 return result;
3606 }
3607
3608 public static <T1, T2> List<T1> wrap2(Class<T1> wrapperClass1, Class<T2> wrapperClass2, T2[] values)
3609 {
3610 try
3611 {
3612 if (values == null)
3613 return null;
3614 if (values.length == 0)
3615 return Collections.emptyList();
3616
3617 Constructor<T1> c = wrapperClass1.getConstructor(wrapperClass2);
3618 List<T1> ret = new ArrayList<T1>(values.length);
3619 for (T2 v : values)
3620 {
3621 ret.add(c.newInstance(v));
3622 }
3623 return ret;
3624 }
3625 catch (NoSuchMethodException e)
3626 {
3627 throw new AssertionError(e);
3628 }
3629 catch (InstantiationException e)
3630 {
3631 throw new AssertionError(e);
3632 }
3633 catch (IllegalAccessException e)
3634 {
3635 throw new AssertionError(e);
3636 }
3637 catch (InvocationTargetException e)
3638 {
3639 throw new AssertionError(e);
3640 }
3641 }
3642
3643 @SuppressWarnings("unchecked")
3644 public static <T> T[] unwrap(Class<T> wrapperClass, List<T> values)
3645 {
3646 if (values == null)
3647 return null;
3648 return (T[])values.toArray((T[])Array.newInstance(wrapperClass, values.size()));
3649 }
3650
3651 @SuppressWarnings("unchecked")
3652 public static <T1 extends IUnknown, T2> T2[] unwrap2(Class<T1> wrapperClass1, Class<T2> wrapperClass2, List<T1> values)
3653 {
3654 if (values == null)
3655 return null;
3656
3657 T2 ret[] = (T2[])Array.newInstance(wrapperClass2, values.size());
3658 int i = 0;
3659 for (T1 obj : values)
3660 {
3661 ret[i++] = (T2)obj.getWrapped();
3662 }
3663 return ret;
3664 }
3665
3666 /* We have very long invoke lists sometimes */
3667 public static Variant invoke(Dispatch d, String method, Object ... args)
3668 {
3669 return Dispatch.callN(d, method, args);
3670 }
3671}
3672]]></xsl:text>
3673 </xsl:if>
3674
3675 <xsl:call-template name="endFile">
3676 <xsl:with-param name="file" select="'Helper.java'" />
3677 </xsl:call-template>
3678
3679 <xsl:call-template name="startFile">
3680 <xsl:with-param name="file" select="'VBoxException.java'" />
3681 <xsl:with-param name="package" select="$G_virtualBoxPackage" />
3682 </xsl:call-template>
3683
3684 <xsl:if test="$filelistonly=''">
3685 <xsl:text>
3686
3687public class VBoxException extends RuntimeException
3688{
3689 private int resultCode;
3690 private IVirtualBoxErrorInfo errorInfo;
3691
3692 public VBoxException(String message)
3693 {
3694 super(message);
3695 resultCode = -1;
3696 errorInfo = null;
3697 }
3698
3699 public VBoxException(String message, Throwable cause)
3700 {
3701 super(message, cause);
3702 if (cause instanceof com.jacob.com.ComException)
3703 {
3704 resultCode = ((com.jacob.com.ComException)cause).getHResult();
3705 // JACOB doesn't support calling GetErrorInfo, which
3706 // means there is no way of getting an IErrorInfo reference,
3707 // and that means no way of getting to IVirtualBoxErrorInfo.
3708 errorInfo = null;
3709 }
3710 else
3711 resultCode = -1;
3712 }
3713
3714 public int getResultCode()
3715 {
3716 return resultCode;
3717 }
3718
3719 public IVirtualBoxErrorInfo getVirtualBoxErrorInfo()
3720 {
3721 return errorInfo;
3722 }
3723}
3724</xsl:text>
3725 </xsl:if>
3726
3727 <xsl:call-template name="endFile">
3728 <xsl:with-param name="file" select="'VBoxException.java'" />
3729 </xsl:call-template>
3730
3731
3732 <xsl:call-template name="startFile">
3733 <xsl:with-param name="file" select="'VirtualBoxManager.java'" />
3734 <xsl:with-param name="package" select="$G_virtualBoxPackage" />
3735 </xsl:call-template>
3736
3737 <xsl:if test="$filelistonly=''">
3738 <xsl:text><![CDATA[
3739
3740import com.jacob.activeX.ActiveXComponent;
3741import com.jacob.com.ComThread;
3742import com.jacob.com.Dispatch;
3743import com.jacob.com.Variant;
3744import com.jacob.com.SafeArray;
3745import com.jacob.com.DispatchEvents;
3746
3747public class VirtualBoxManager
3748{
3749 private IVirtualBox vbox;
3750
3751 private VirtualBoxManager()
3752 {
3753 initPerThread();
3754 vbox = new IVirtualBox(new ActiveXComponent("VirtualBox.VirtualBox"));
3755 }
3756
3757 public static void initPerThread()
3758 {
3759 ComThread.InitMTA();
3760 }
3761
3762 public static void deinitPerThread()
3763 {
3764 ComThread.Release();
3765 }
3766
3767 public void connect(String url, String username, String passwd)
3768 {
3769 throw new VBoxException("Connect doesn't make sense for local bindings");
3770 }
3771
3772 public void disconnect()
3773 {
3774 throw new VBoxException("Disconnect doesn't make sense for local bindings");
3775 }
3776
3777 public IVirtualBox getVBox()
3778 {
3779 return this.vbox;
3780 }
3781
3782 public ISession getSessionObject()
3783 {
3784 return new ISession(new ActiveXComponent("VirtualBox.Session"));
3785 }
3786
3787 public ISession openMachineSession(IMachine m)
3788 {
3789 ISession s = getSessionObject();
3790 m.lockMachine(s, LockType.Shared);
3791 return s;
3792 }
3793
3794 public void closeMachineSession(ISession s)
3795 {
3796 if (s != null)
3797 s.unlockMachine();
3798 }
3799
3800 private static boolean hasInstance = false;
3801
3802 public static synchronized VirtualBoxManager createInstance(String home)
3803 {
3804 if (hasInstance)
3805 throw new VBoxException("only one instance of VirtualBoxManager at a time allowed");
3806
3807 hasInstance = true;
3808 return new VirtualBoxManager();
3809 }
3810
3811 public void cleanup()
3812 {
3813 deinitPerThread();
3814 hasInstance = false;
3815 }
3816
3817 public void waitForEvents(long tmo)
3818 {
3819 // what to do here?
3820 try
3821 {
3822 Thread.sleep(tmo);
3823 }
3824 catch (InterruptedException ie)
3825 {
3826 }
3827 }
3828}
3829]]></xsl:text>
3830 </xsl:if>
3831
3832 <xsl:call-template name="endFile">
3833 <xsl:with-param name="file" select="'VirtualBoxManager.java'" />
3834 </xsl:call-template>
3835</xsl:template>
3836
3837<xsl:template name="emitHandwrittenJaxws">
3838
3839 <xsl:call-template name="startFile">
3840 <xsl:with-param name="file" select="'IUnknown.java'" />
3841 <xsl:with-param name="package" select="$G_virtualBoxPackage" />
3842 </xsl:call-template>
3843
3844 <xsl:if test="$filelistonly=''">
3845 <xsl:text><![CDATA[
3846public class IUnknown
3847{
3848 protected String obj;
3849 protected final VboxPortType port;
3850
3851 public IUnknown(String obj, VboxPortType port)
3852 {
3853 this.obj = obj;
3854 this.port = port;
3855 }
3856
3857 public final String getWrapped()
3858 {
3859 return this.obj;
3860 }
3861
3862 public final VboxPortType getRemoteWSPort()
3863 {
3864 return this.port;
3865 }
3866
3867 public synchronized void releaseRemote() throws WebServiceException
3868 {
3869 if (obj == null)
3870 return;
3871
3872 try
3873 {
3874 this.port.iManagedObjectRefRelease(obj);
3875 this.obj = null;
3876 }
3877 catch (InvalidObjectFaultMsg e)
3878 {
3879 throw new WebServiceException(e);
3880 }
3881 catch (RuntimeFaultMsg e)
3882 {
3883 throw new WebServiceException(e);
3884 }
3885 }
3886}
3887]]></xsl:text>
3888 </xsl:if>
3889
3890 <xsl:call-template name="endFile">
3891 <xsl:with-param name="file" select="'IUnknown.java'" />
3892 </xsl:call-template>
3893
3894 <xsl:call-template name="startFile">
3895 <xsl:with-param name="file" select="'Helper.java'" />
3896 <xsl:with-param name="package" select="$G_virtualBoxPackage" />
3897 </xsl:call-template>
3898
3899 <xsl:if test="$filelistonly=''">
3900 <xsl:text><![CDATA[
3901
3902import java.util.List;
3903import java.util.ArrayList;
3904import java.util.Collections;
3905import java.lang.reflect.Array;
3906import java.lang.reflect.Constructor;
3907import java.lang.reflect.InvocationTargetException;
3908import java.math.BigInteger;
3909
3910public class Helper
3911{
3912 public static <T> List<T> wrap(Class<T> wrapperClass, VboxPortType pt, List<String> values)
3913 {
3914 try
3915 {
3916 if (values == null)
3917 return null;
3918
3919 Constructor<T> c = wrapperClass.getConstructor(String.class, VboxPortType.class);
3920 List<T> ret = new ArrayList<T>(values.size());
3921 for (String v : values)
3922 {
3923 ret.add(c.newInstance(v, pt));
3924 }
3925 return ret;
3926 }
3927 catch (NoSuchMethodException e)
3928 {
3929 throw new AssertionError(e);
3930 }
3931 catch (InstantiationException e)
3932 {
3933 throw new AssertionError(e);
3934 }
3935 catch (IllegalAccessException e)
3936 {
3937 throw new AssertionError(e);
3938 }
3939 catch (InvocationTargetException e)
3940 {
3941 throw new AssertionError(e);
3942 }
3943 }
3944
3945 public static <T1, T2> List<T1> wrap2(Class<T1> wrapperClass1, Class<T2> wrapperClass2, VboxPortType pt, List<T2> values)
3946 {
3947 try
3948 {
3949 if (values == null)
3950 return null;
3951
3952 Constructor<T1> c = wrapperClass1.getConstructor(wrapperClass2, VboxPortType.class);
3953 List<T1> ret = new ArrayList<T1>(values.size());
3954 for (T2 v : values)
3955 {
3956 ret.add(c.newInstance(v, pt));
3957 }
3958 return ret;
3959 }
3960 catch (NoSuchMethodException e)
3961 {
3962 throw new AssertionError(e);
3963 }
3964 catch (InstantiationException e)
3965 {
3966 throw new AssertionError(e);
3967 }
3968 catch (IllegalAccessException e)
3969 {
3970 throw new AssertionError(e);
3971 }
3972 catch (InvocationTargetException e)
3973 {
3974 throw new AssertionError(e);
3975 }
3976 }
3977
3978 public static <T extends IUnknown> List<String> unwrap(List<T> values)
3979 {
3980 if (values == null)
3981 return null;
3982
3983 List<String> ret = new ArrayList<String>(values.size());
3984 for (T obj : values)
3985 {
3986 ret.add(obj.getWrapped());
3987 }
3988 return ret;
3989 }
3990
3991 @SuppressWarnings("unchecked" )
3992 public static <T1 extends Enum <T1>, T2 extends Enum <T2>> List<T2> convertEnums(Class<T1> fromClass,
3993 Class<T2> toClass,
3994 List<T1> values)
3995 {
3996 try
3997 {
3998 if (values == null)
3999 return null;
4000 java.lang.reflect.Method fromValue = toClass.getMethod("fromValue", String.class);
4001 List<T2> ret = new ArrayList<T2>(values.size());
4002 for (T1 v : values)
4003 {
4004 // static method is called with null this
4005 ret.add((T2)fromValue.invoke(null, v.name()));
4006 }
4007 return ret;
4008 }
4009 catch (NoSuchMethodException e)
4010 {
4011 throw new AssertionError(e);
4012 }
4013 catch (IllegalAccessException e)
4014 {
4015 throw new AssertionError(e);
4016 }
4017 catch (InvocationTargetException e)
4018 {
4019 throw new AssertionError(e);
4020 }
4021 }
4022
4023 /* Pretty naive Base64 encoder/decoder. */
4024 private static final char[] valToChar = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".toCharArray();
4025 private static final int[] charToVal = new int[256];
4026
4027 /* Initialize recoding alphabet. */
4028 static
4029 {
4030 for (int i = 0; i < charToVal.length; i++)
4031 charToVal[i] = -1;
4032
4033 for (int i = 0; i < valToChar.length; i++)
4034 charToVal[valToChar[i]] = i;
4035
4036 charToVal['='] = 0;
4037 }
4038
4039 public static String encodeBase64(byte[] data)
4040 {
4041 if (data == null)
4042 return null;
4043
4044 if (data.length == 0)
4045 return "";
4046
4047 int fullTriplets = data.length / 3;
4048 int resultLen = ((data.length - 1) / 3 + 1) * 4;
4049 char[] result = new char[resultLen];
4050 int dataIndex = 0, stringIndex = 0;
4051
4052 for (int i = 0; i < fullTriplets; i++)
4053 {
4054 int ch1 = data[dataIndex++] & 0xff;
4055 result[stringIndex++] = valToChar[ch1 >> 2];
4056 int ch2 = data[dataIndex++] & 0xff;
4057 result[stringIndex++] = valToChar[((ch1 << 4) & 0x3f) | (ch2 >> 4)];
4058 int ch3 = data[dataIndex++] & 0xff;
4059 result[stringIndex++] = valToChar[((ch2 << 2) & 0x3f) | (ch3 >> 6)];
4060 result[stringIndex++] = valToChar[ch3 & 0x3f];
4061 }
4062
4063 switch (data.length - dataIndex)
4064 {
4065 case 0:
4066 // do nothing
4067 break;
4068 case 1:
4069 {
4070 int ch1 = data[dataIndex++] & 0xff;
4071 result[stringIndex++] = valToChar[ch1 >> 2];
4072 result[stringIndex++] = valToChar[(ch1 << 4) & 0x3f];
4073 result[stringIndex++] = '=';
4074 result[stringIndex++] = '=';
4075 break;
4076 }
4077 case 2:
4078 {
4079 int ch1 = data[dataIndex++] & 0xff;
4080 result[stringIndex++] = valToChar[ch1 >> 2];
4081 int ch2 = data[dataIndex++] & 0xff;
4082 result[stringIndex++] = valToChar[((ch1 << 4) & 0x3f) | (ch2 >> 4)];
4083 result[stringIndex++] = valToChar[(ch2 << 2) & 0x3f];
4084 result[stringIndex++] = '=';
4085 break;
4086 }
4087 default:
4088 throw new VBoxException("bug!");
4089 }
4090
4091 return new String(result);
4092 }
4093
4094 private static int skipInvalid(String str, int stringIndex)
4095 {
4096 while (charToVal[str.charAt(stringIndex)] < 0)
4097 stringIndex++;
4098
4099 return stringIndex;
4100 }
4101
4102 public static byte[] decodeBase64(String str)
4103 {
4104 if (str == null)
4105 return null;
4106
4107 int stringLength = str.length();
4108 if (stringLength == 0)
4109 return new byte[0];
4110
4111 int validChars = 0, padChars = 0;
4112 for (int i = 0; i < str.length(); i++)
4113 {
4114 char ch = str.charAt(i);
4115
4116 if (charToVal[ch] >= 0)
4117 validChars++;
4118
4119 if (ch == '=')
4120 padChars++;
4121 }
4122
4123 if ((validChars * 3 % 4) != 0)
4124 throw new VBoxException("invalid base64 encoded string " + str);
4125
4126 int resultLength = validChars * 3 / 4 - padChars;
4127 byte[] result = new byte[resultLength];
4128
4129 int dataIndex = 0, stringIndex = 0;
4130 int quadraplets = validChars / 4;
4131
4132 for (int i = 0; i < quadraplets; i++)
4133 {
4134 stringIndex = skipInvalid(str, stringIndex);
4135 int ch1 = str.charAt(stringIndex++);
4136 stringIndex = skipInvalid(str, stringIndex);
4137 int ch2 = str.charAt(stringIndex++);
4138 stringIndex = skipInvalid(str, stringIndex);
4139 int ch3 = str.charAt(stringIndex++);
4140 stringIndex = skipInvalid(str, stringIndex);
4141 int ch4 = str.charAt(stringIndex++);
4142
4143 result[dataIndex++] = (byte)(((charToVal[ch1] << 2) | charToVal[ch2] >> 4) & 0xff);
4144 /* we check this to ensure that we don't override data with '=' padding. */
4145 if (dataIndex < result.length)
4146 result[dataIndex++] = (byte)(((charToVal[ch2] << 4) | charToVal[ch3] >> 2) & 0xff);
4147 if (dataIndex < result.length)
4148 result[dataIndex++] = (byte)(((charToVal[ch3] << 6) | charToVal[ch4]) & 0xff);
4149 }
4150
4151 return result;
4152 }
4153}
4154]]></xsl:text>
4155 </xsl:if>
4156
4157 <xsl:call-template name="endFile">
4158 <xsl:with-param name="file" select="'Helper.java'" />
4159 </xsl:call-template>
4160
4161 <xsl:call-template name="startFile">
4162 <xsl:with-param name="file" select="'VBoxException.java'" />
4163 <xsl:with-param name="package" select="$G_virtualBoxPackage" />
4164 </xsl:call-template>
4165
4166 <xsl:if test="$filelistonly=''">
4167 <xsl:text>
4168public class VBoxException extends RuntimeException
4169{
4170 private int resultCode;
4171 private IVirtualBoxErrorInfo errorInfo;
4172
4173 public VBoxException(String message)
4174 {
4175 super(message);
4176 resultCode = -1;
4177 errorInfo = null;
4178 }
4179
4180 public VBoxException(String message, Throwable cause)
4181 {
4182 super(message, cause);
4183 resultCode = -1;
4184 errorInfo = null;
4185 }
4186
4187 public VBoxException(String message, Throwable cause, VboxPortType port)
4188 {
4189 super(message, cause);
4190 if (cause instanceof RuntimeFaultMsg)
4191 {
4192 RuntimeFaultMsg m = (RuntimeFaultMsg)cause;
4193 RuntimeFault f = m.getFaultInfo();
4194 resultCode = f.getResultCode();
4195 String retVal = f.getReturnval();
4196 errorInfo = (retVal.length() > 0) ? new IVirtualBoxErrorInfo(retVal, port) : null;
4197 }
4198 else
4199 resultCode = -1;
4200 }
4201
4202 public int getResultCode()
4203 {
4204 return resultCode;
4205 }
4206
4207 public IVirtualBoxErrorInfo getVirtualBoxErrorInfo()
4208 {
4209 return errorInfo;
4210 }
4211}
4212</xsl:text>
4213 </xsl:if>
4214
4215 <xsl:call-template name="endFile">
4216 <xsl:with-param name="file" select="'VBoxException.java'" />
4217 </xsl:call-template>
4218
4219 <xsl:call-template name="startFile">
4220 <xsl:with-param name="file" select="'VirtualBoxManager.java'" />
4221 <xsl:with-param name="package" select="$G_virtualBoxPackage" />
4222 </xsl:call-template>
4223
4224 <xsl:if test="$filelistonly=''">
4225 <xsl:text>import java.net.URL;
4226import java.math.BigInteger;
4227import java.util.List;
4228import java.util.Map;
4229import java.util.HashMap;
4230import javax.xml.namespace.QName;
4231import javax.xml.ws.BindingProvider;
4232import javax.xml.ws.Holder;
4233import javax.xml.ws.WebServiceException;
4234
4235class PortPool
4236{
4237 private final static String wsdlFile = </xsl:text>
4238 <xsl:value-of select="$G_virtualBoxWsdl" />
4239 <xsl:text><![CDATA[;
4240 private Map<VboxPortType, Integer> known;
4241 private boolean initStarted;
4242 private VboxService svc;
4243
4244 PortPool(boolean usePreinit)
4245 {
4246 known = new HashMap<VboxPortType, Integer>();
4247
4248 if (usePreinit)
4249 {
4250 new Thread(new Runnable()
4251 {
4252 public void run()
4253 {
4254 // need to sync on something else but 'this'
4255 synchronized (known)
4256 {
4257 initStarted = true;
4258 known.notify();
4259 }
4260
4261 preinit();
4262 }
4263 }).start();
4264
4265 synchronized (known)
4266 {
4267 while (!initStarted)
4268 {
4269 try
4270 {
4271 known.wait();
4272 }
4273 catch (InterruptedException e)
4274 {
4275 break;
4276 }
4277 }
4278 }
4279 }
4280 }
4281
4282 private synchronized void preinit()
4283 {
4284 VboxPortType port = getPort();
4285 releasePort(port);
4286 }
4287
4288 synchronized VboxPortType getPort()
4289 {
4290 VboxPortType port = null;
4291 int ttl = 0;
4292
4293 for (VboxPortType cur: known.keySet())
4294 {
4295 int value = known.get(cur);
4296 if ((value & 0x10000) == 0)
4297 {
4298 port = cur;
4299 ttl = value & 0xffff;
4300 break;
4301 }
4302 }
4303
4304 if (port == null)
4305 {
4306 if (svc == null)
4307 {
4308 URL wsdl = PortPool.class.getClassLoader().getResource(wsdlFile);
4309 if (wsdl == null)
4310 throw new LinkageError(wsdlFile + " not found, but it should have been in the jar");
4311 svc = new VboxService(wsdl,
4312 new QName("http://www.215389.xyz/Service",
4313 "vboxService"));
4314 }
4315 port = svc.getVboxServicePort();
4316 // reuse this object 0x10 times
4317 ttl = 0x10;
4318 }
4319 // mark as used
4320 known.put(port, new Integer(0x10000 | ttl));
4321 return port;
4322 }
4323
4324 synchronized void releasePort(VboxPortType port)
4325 {
4326 Integer val = known.get(port);
4327 if (val == null || val == 0)
4328 {
4329 // know you not
4330 return;
4331 }
4332
4333 int v = val;
4334 int ttl = v & 0xffff;
4335 // decrement TTL, and throw away port if used too much times
4336 if (--ttl <= 0)
4337 {
4338 known.remove(port);
4339 }
4340 else
4341 {
4342 v = ttl; // set new TTL and clear busy bit
4343 known.put(port, v);
4344 }
4345 }
4346}
4347
4348
4349public class VirtualBoxManager
4350{
4351 private static PortPool pool = new PortPool(true);
4352 protected VboxPortType port;
4353
4354 private IVirtualBox vbox;
4355
4356 private VirtualBoxManager()
4357 {
4358 }
4359
4360 public static void initPerThread()
4361 {
4362 }
4363
4364 public static void deinitPerThread()
4365 {
4366 }
4367
4368 public void connect(String url, String username, String passwd)
4369 {
4370 this.port = pool.getPort();
4371 try
4372 {
4373 ((BindingProvider)port).getRequestContext().
4374 put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, url);
4375 String handle = port.iWebsessionManagerLogon(username, passwd);
4376 this.vbox = new IVirtualBox(handle, port);
4377 }
4378 catch (Throwable t)
4379 {
4380 if (this.port != null && pool != null)
4381 {
4382 pool.releasePort(this.port);
4383 this.port = null;
4384 }
4385 // we have to throw smth derived from RuntimeException
4386 throw new VBoxException(t.getMessage(), t, this.port);
4387 }
4388 }
4389
4390 public void connect(String url, String username, String passwd,
4391 Map<String, Object> requestContext, Map<String, Object> responseContext)
4392 {
4393 this.port = pool.getPort();
4394
4395 try
4396 {
4397 ((BindingProvider)port).getRequestContext();
4398 if (requestContext != null)
4399 ((BindingProvider)port).getRequestContext().putAll(requestContext);
4400
4401 if (responseContext != null)
4402 ((BindingProvider)port).getResponseContext().putAll(responseContext);
4403
4404 ((BindingProvider)port).getRequestContext().
4405 put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, url);
4406 String handle = port.iWebsessionManagerLogon(username, passwd);
4407 this.vbox = new IVirtualBox(handle, port);
4408 }
4409 catch (Throwable t)
4410 {
4411 if (this.port != null && pool != null)
4412 {
4413 pool.releasePort(this.port);
4414 this.port = null;
4415 }
4416 // we have to throw smth derived from RuntimeException
4417 throw new VBoxException(t.getMessage(), t, this.port);
4418 }
4419 }
4420
4421 public void disconnect()
4422 {
4423 if (this.port == null)
4424 return;
4425
4426 try
4427 {
4428 if (this.vbox != null && port != null)
4429 port.iWebsessionManagerLogoff(this.vbox.getWrapped());
4430 }
4431 catch (InvalidObjectFaultMsg e)
4432 {
4433 throw new VBoxException(e.getMessage(), e, this.port);
4434 }
4435 catch (RuntimeFaultMsg e)
4436 {
4437 throw new VBoxException(e.getMessage(), e, this.port);
4438 }
4439 finally
4440 {
4441 if (this.port != null)
4442 {
4443 pool.releasePort(this.port);
4444 this.port = null;
4445 }
4446 }
4447 }
4448
4449 public IVirtualBox getVBox()
4450 {
4451 return this.vbox;
4452 }
4453
4454 public ISession getSessionObject()
4455 {
4456 if (this.vbox == null)
4457 throw new VBoxException("connect first");
4458 try
4459 {
4460 String handle = port.iWebsessionManagerGetSessionObject(this.vbox.getWrapped());
4461 return new ISession(handle, port);
4462 }
4463 catch (InvalidObjectFaultMsg e)
4464 {
4465 throw new VBoxException(e.getMessage(), e, this.port);
4466 }
4467 catch (RuntimeFaultMsg e)
4468 {
4469 throw new VBoxException(e.getMessage(), e, this.port);
4470 }
4471 }
4472
4473 public ISession openMachineSession(IMachine m) throws Exception
4474 {
4475 ISession s = getSessionObject();
4476 m.lockMachine(s, LockType.Shared);
4477 return s;
4478 }
4479
4480 public void closeMachineSession(ISession s)
4481 {
4482 if (s != null)
4483 s.unlockMachine();
4484 }
4485
4486 public static synchronized VirtualBoxManager createInstance(String home)
4487 {
4488 return new VirtualBoxManager();
4489 }
4490
4491 public IEventListener createListener(Object sink)
4492 {
4493 throw new VBoxException("no active listeners here");
4494 }
4495
4496 public void cleanup()
4497 {
4498 disconnect();
4499 deinitPerThread();
4500 }
4501
4502 public void waitForEvents(long tmo)
4503 {
4504 }
4505
4506 protected void finalize() throws Throwable
4507 {
4508 try
4509 {
4510 cleanup();
4511 }
4512 catch(Exception e)
4513 {
4514 }
4515 finally
4516 {
4517 super.finalize();
4518 }
4519 }
4520}
4521]]></xsl:text>
4522 </xsl:if>
4523
4524 <xsl:call-template name="endFile">
4525 <xsl:with-param name="file" select="'VirtualBoxManager.java'" />
4526 </xsl:call-template>
4527</xsl:template>
4528
4529
4530<xsl:template match="/">
4531
4532 <xsl:if test="not($G_vboxApiSuffix)">
4533 <xsl:call-template name="fatalError">
4534 <xsl:with-param name="msg" select="'G_vboxApiSuffix must be given'" />
4535 </xsl:call-template>
4536 </xsl:if>
4537
4538 <xsl:if test="not($filelistonly='')">
4539 <xsl:value-of select="concat($filelistonly, ' := \&#10;')"/>
4540 </xsl:if>
4541
4542 <!-- Handwritten files -->
4543 <xsl:call-template name="emitHandwritten"/>
4544
4545 <xsl:choose>
4546 <xsl:when test="$G_vboxGlueStyle='xpcom'">
4547 <xsl:call-template name="emitHandwrittenXpcom"/>
4548 </xsl:when>
4549
4550 <xsl:when test="$G_vboxGlueStyle='mscom'">
4551 <xsl:call-template name="emitHandwrittenMscom"/>
4552 </xsl:when>
4553
4554 <xsl:when test="$G_vboxGlueStyle='jaxws'">
4555 <xsl:call-template name="emitHandwrittenJaxws"/>
4556 </xsl:when>
4557
4558 <xsl:otherwise>
4559 <xsl:call-template name="fatalError">
4560 <xsl:with-param name="msg" select="'Style unknown (root)'" />
4561 </xsl:call-template>
4562 </xsl:otherwise>
4563 </xsl:choose>
4564
4565 <!-- Enums -->
4566 <xsl:for-each select="//enum">
4567 <xsl:call-template name="genEnum">
4568 <xsl:with-param name="enumname" select="@name" />
4569 <xsl:with-param name="filename" select="concat(@name, '.java')" />
4570 </xsl:call-template>
4571 </xsl:for-each>
4572
4573 <!-- Interfaces -->
4574 <xsl:for-each select="//interface">
4575 <xsl:variable name="self_target" select="current()/ancestor::if/@target"/>
4576 <xsl:variable name="module" select="current()/ancestor::module/@name"/>
4577
4578 <xsl:choose>
4579 <xsl:when test="$G_vboxGlueStyle='jaxws'">
4580 <xsl:if test="not($module) and not(@wsmap='suppress')">
4581 <xsl:call-template name="genIface">
4582 <xsl:with-param name="ifname" select="@name" />
4583 <xsl:with-param name="filename" select="concat(@name, '.java')" />
4584 </xsl:call-template>
4585 </xsl:if>
4586 </xsl:when>
4587
4588 <xsl:otherwise>
4589 <!-- We don't need WSDL-specific interfaces here -->
4590 <xsl:if test="not($self_target='wsdl') and not($module)">
4591 <xsl:call-template name="genIface">
4592 <xsl:with-param name="ifname" select="@name" />
4593 <xsl:with-param name="filename" select="concat(@name, '.java')" />
4594 </xsl:call-template>
4595 </xsl:if>
4596 </xsl:otherwise>
4597
4598 </xsl:choose>
4599 </xsl:for-each>
4600
4601 <xsl:if test="not($filelistonly='')">
4602 <xsl:value-of select="'&#10;'"/>
4603 </xsl:if>
4604
4605</xsl:template>
4606</xsl:stylesheet>
Note: See TracBrowser for help on using the repository browser.

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