VirtualBox

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

最後變更 在這個檔案從51444是 51444,由 vboxsync 提交於 11 年 前

Main/glue-java.xsl: detect single out parameter and no return parameter if a method parameter list, this is causing trouble with JAX-WS (take the easy way out and ask for changing the IDL, changing the generator would be a lot of effort)
  • 屬性 svn:eol-style 設為 native
  • 屬性 svn:keywords 設為 Author Date Id Revision
檔案大小: 149.3 KB
行 
1<xsl:stylesheet version = '1.0'
2 xmlns:xsl='http://www.w3.org/1999/XSL/Transform'
3 xmlns:vbox="http://www.alldomusa.eu.org/"
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-2014 Oracle Corporation
14
15 This file is part of VirtualBox Open Source Edition (OSE), as
16 available from http://www.alldomusa.eu.org. This file is free software;
17 you can redistribute it and/or modify it under the terms of the GNU
18 General Public License (GPL) as published by the Free Software
19 Foundation, in version 2 as it comes in the "COPYING" file of the
20 VirtualBox OSE distribution. VirtualBox OSE is distributed in the
21 hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
22-->
23
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-2014 Oracle Corporation
50 *
51 * This file is part of the VirtualBox SDK, as available from
52 * http://www.alldomusa.eu.org. 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 <!-- Sometimes javac needs a boost of self-confidence regarding
1370 varargs calls, and this (Object) cast makes sure that it calls
1371 the varargs method - as if there is any other. -->
1372 <xsl:value-of select="concat('(Object)Helper.unwrap2(', $elemgluetype, '.class, ', $elembacktype, '.class, ', $value, ')')"/>
1373 </xsl:when>
1374 <xsl:otherwise>
1375 <xsl:value-of select="concat('(', $value, ' != null) ? ', $value, '.getTypedWrapped() : null')" />
1376 </xsl:otherwise>
1377 </xsl:choose>
1378 </xsl:when>
1379
1380 <xsl:when test="$idltype='$unknown'">
1381 <xsl:choose>
1382 <xsl:when test="$safearray='yes'">
1383 <xsl:value-of select="concat('Helper.unwrap2(', $elemgluetype, '.class, Dispatch.class, ', $value, ')')"/>
1384 </xsl:when>
1385 <xsl:otherwise>
1386 <xsl:value-of select="concat('(', $value, ' != null) ? (Dispatch)', $value, '.getWrapped() : null')" />
1387 </xsl:otherwise>
1388 </xsl:choose>
1389 </xsl:when>
1390
1391 <xsl:when test="//enum[@name=$idltype]">
1392 <xsl:choose>
1393 <xsl:when test="$safearray='yes'">
1394 <xsl:value-of select="concat('Helper.unwrapEnum(', $elemgluetype, '.class, ', $value, ')')"/>
1395 </xsl:when>
1396 <xsl:otherwise>
1397 <xsl:value-of select="concat($value, '.value()')"/>
1398 </xsl:otherwise>
1399 </xsl:choose>
1400 </xsl:when>
1401
1402 <xsl:when test="$idltype='boolean'">
1403 <xsl:choose>
1404 <xsl:when test="$safearray='yes'">
1405 <xsl:value-of select="concat('Helper.unwrapBool(', $value, ')')"/>
1406 </xsl:when>
1407 <xsl:otherwise>
1408 <xsl:value-of select="concat('new Variant(', $value, ')')"/>
1409 </xsl:otherwise>
1410 </xsl:choose>
1411 </xsl:when>
1412
1413 <xsl:when test="($idltype='short') or ($idltype='unsigned short')">
1414 <xsl:choose>
1415 <xsl:when test="$safearray='yes'">
1416 <xsl:value-of select="concat('Helper.unwrapShort(', $value, ')')"/>
1417 </xsl:when>
1418 <xsl:otherwise>
1419 <xsl:value-of select="concat('new Variant(', $value, ')')"/>
1420 </xsl:otherwise>
1421 </xsl:choose>
1422 </xsl:when>
1423
1424
1425 <xsl:when test="($idltype='long') or ($idltype='unsigned long')">
1426 <xsl:choose>
1427 <xsl:when test="$safearray='yes'">
1428 <xsl:value-of select="concat('Helper.unwrapInt(', $value, ')')"/>
1429 </xsl:when>
1430 <xsl:otherwise>
1431 <xsl:value-of select="concat('new Variant(', $value, ')')"/>
1432 </xsl:otherwise>
1433 </xsl:choose>
1434 </xsl:when>
1435
1436 <xsl:when test="($idltype='wstring') or ($idltype='uuid')">
1437 <xsl:choose>
1438 <xsl:when test="$safearray='yes'">
1439 <xsl:value-of select="concat('Helper.unwrapString(', $value, ')')"/>
1440 </xsl:when>
1441 <xsl:otherwise>
1442 <xsl:value-of select="concat('new Variant(', $value, ')')"/>
1443 </xsl:otherwise>
1444 </xsl:choose>
1445 </xsl:when>
1446
1447 <xsl:when test="($idltype='unsigned long long') or ($idltype='long long')">
1448 <xsl:choose>
1449 <xsl:when test="$safearray='yes'">
1450 <xsl:value-of select="concat('Helper.unwrapLong(', $value, ')')"/>
1451 </xsl:when>
1452 <xsl:otherwise>
1453 <xsl:value-of select="concat('new Variant(', $value, '.longValue())')"/>
1454 </xsl:otherwise>
1455 </xsl:choose>
1456 </xsl:when>
1457
1458 <xsl:when test="($idltype='octet') and ($safearray='yes')">
1459 <xsl:value-of select="$value"/>
1460 </xsl:when>
1461
1462 <xsl:otherwise>
1463 <xsl:call-template name="fatalError">
1464 <xsl:with-param name="msg" select="concat('Unhandled type: ', $idltype)" />
1465 </xsl:call-template>
1466 </xsl:otherwise>
1467 </xsl:choose>
1468
1469</xsl:template>
1470
1471<xsl:template name="cookInParamJaxws">
1472 <xsl:param name="value"/>
1473 <xsl:param name="idltype"/>
1474 <xsl:param name="safearray"/>
1475 <xsl:variable name="isstruct"
1476 select="//interface[@name=$idltype]/@wsmap='struct'" />
1477
1478 <xsl:variable name="gluetype">
1479 <xsl:call-template name="typeIdl2Glue">
1480 <xsl:with-param name="type" select="$idltype" />
1481 <xsl:with-param name="safearray" select="$safearray" />
1482 </xsl:call-template>
1483 </xsl:variable>
1484
1485 <xsl:variable name="elemgluetype">
1486 <xsl:if test="$safearray='yes'">
1487 <xsl:call-template name="typeIdl2Glue">
1488 <xsl:with-param name="type" select="$idltype" />
1489 <xsl:with-param name="safearray" select="'no'" />
1490 <xsl:with-param name="forceelem" select="'yes'" />
1491 </xsl:call-template>
1492 </xsl:if>
1493 </xsl:variable>
1494
1495 <xsl:choose>
1496 <xsl:when test="//interface[@name=$idltype] or $idltype='$unknown'">
1497 <xsl:choose>
1498 <xsl:when test="@safearray='yes'">
1499 <xsl:value-of select="concat('Helper.unwrap(', $value, ')')"/>
1500 </xsl:when>
1501 <xsl:otherwise>
1502 <xsl:value-of select="concat('((', $value, ' == null) ? null :', $value, '.getWrapped())')" />
1503 </xsl:otherwise>
1504 </xsl:choose>
1505 </xsl:when>
1506
1507 <xsl:when test="//enum[@name=$idltype]">
1508 <xsl:choose>
1509 <xsl:when test="$safearray='yes'">
1510 <xsl:variable name="elembacktype">
1511 <xsl:call-template name="typeIdl2Back">
1512 <xsl:with-param name="type" select="$idltype" />
1513 <xsl:with-param name="safearray" select="'no'" />
1514 <xsl:with-param name="forceelem" select="'yes'" />
1515 </xsl:call-template>
1516 </xsl:variable>
1517 <xsl:value-of select="concat('Helper.convertEnums(', $elemgluetype, '.class, ', $elembacktype, '.class, ', $value, ')')"/>
1518 </xsl:when>
1519 <xsl:otherwise>
1520 <xsl:variable name="backtype">
1521 <xsl:call-template name="typeIdl2Back">
1522 <xsl:with-param name="type" select="$idltype" />
1523 <xsl:with-param name="safearray" select="'no'" />
1524 <xsl:with-param name="forceelem" select="'yes'" />
1525 </xsl:call-template>
1526 </xsl:variable>
1527 <xsl:value-of select="concat($backtype, '.fromValue(', $value, '.name())')"/>
1528 </xsl:otherwise>
1529 </xsl:choose>
1530 </xsl:when>
1531
1532 <xsl:when test="($idltype='octet') and ($safearray='yes')">
1533 <xsl:value-of select="concat('Helper.encodeBase64(', $value, ')')"/>
1534 </xsl:when>
1535
1536 <xsl:otherwise>
1537 <xsl:value-of select="$value"/>
1538 </xsl:otherwise>
1539 </xsl:choose>
1540
1541</xsl:template>
1542
1543<xsl:template name="cookInParam">
1544 <xsl:param name="value"/>
1545 <xsl:param name="idltype"/>
1546 <xsl:param name="safearray"/>
1547 <xsl:choose>
1548 <xsl:when test="($G_vboxGlueStyle='xpcom')">
1549 <xsl:call-template name="cookInParamXpcom">
1550 <xsl:with-param name="value" select="$value" />
1551 <xsl:with-param name="idltype" select="$idltype" />
1552 <xsl:with-param name="safearray" select="$safearray" />
1553 </xsl:call-template>
1554 </xsl:when>
1555 <xsl:when test="($G_vboxGlueStyle='mscom')">
1556 <xsl:call-template name="cookInParamMscom">
1557 <xsl:with-param name="value" select="$value" />
1558 <xsl:with-param name="idltype" select="$idltype" />
1559 <xsl:with-param name="safearray" select="$safearray" />
1560 </xsl:call-template>
1561 </xsl:when>
1562 <xsl:when test="($G_vboxGlueStyle='jaxws')">
1563 <xsl:call-template name="cookInParamJaxws">
1564 <xsl:with-param name="value" select="$value" />
1565 <xsl:with-param name="idltype" select="$idltype" />
1566 <xsl:with-param name="safearray" select="$safearray" />
1567 </xsl:call-template>
1568 </xsl:when>
1569 <xsl:otherwise>
1570 <xsl:call-template name="fatalError">
1571 <xsl:with-param name="msg" select="'Unhandled style (cookInParam)'" />
1572 </xsl:call-template>
1573 </xsl:otherwise>
1574 </xsl:choose>
1575</xsl:template>
1576
1577<!-- Invoke backend method, including parameter conversion -->
1578<xsl:template name="genBackMethodCall">
1579 <xsl:param name="ifname"/>
1580 <xsl:param name="methodname"/>
1581 <xsl:param name="retval"/>
1582
1583 <xsl:choose>
1584 <xsl:when test="($G_vboxGlueStyle='xpcom')">
1585 <xsl:text> </xsl:text>
1586 <xsl:if test="param[@dir='return']">
1587 <xsl:value-of select="concat($retval, ' = ')" />
1588 </xsl:if>
1589 <xsl:value-of select="concat('getTypedWrapped().', $methodname, '(')"/>
1590 <xsl:for-each select="param">
1591 <xsl:choose>
1592 <xsl:when test="@dir='return'">
1593 <xsl:if test="@safearray='yes'">
1594 <xsl:text>null</xsl:text>
1595 </xsl:if>
1596 </xsl:when>
1597 <xsl:when test="@dir='out'">
1598 <xsl:if test="@safearray='yes'">
1599 <xsl:text>null, </xsl:text>
1600 </xsl:if>
1601 <xsl:value-of select="concat('tmp_', @name)" />
1602 </xsl:when>
1603 <xsl:when test="@dir='in'">
1604 <xsl:if test="(@safearray='yes') and not(@type = 'octet')">
1605 <xsl:value-of select="concat(@name, ' != null ? ', @name, '.size() : 0, ')" />
1606 </xsl:if>
1607 <xsl:variable name="unwrapped">
1608 <xsl:call-template name="cookInParam">
1609 <xsl:with-param name="value" select="@name" />
1610 <xsl:with-param name="idltype" select="@type" />
1611 <xsl:with-param name="safearray" select="@safearray" />
1612 </xsl:call-template>
1613 </xsl:variable>
1614 <xsl:value-of select="$unwrapped"/>
1615 </xsl:when>
1616 <xsl:otherwise>
1617 <xsl:call-template name="fatalError">
1618 <xsl:with-param name="msg" select="concat('Unsupported param dir: ', @dir, '&quot;.')" />
1619 </xsl:call-template>
1620 </xsl:otherwise>
1621 </xsl:choose>
1622 <xsl:if test="not(position()=last()) and not(following-sibling::param[1]/@dir='return' and not(following-sibling::param[1]/@safearray='yes'))">
1623 <xsl:text>, </xsl:text>
1624 </xsl:if>
1625 </xsl:for-each>
1626 <xsl:text>);&#10;</xsl:text>
1627 </xsl:when>
1628
1629 <xsl:when test="($G_vboxGlueStyle='mscom')">
1630 <xsl:text> </xsl:text>
1631 <xsl:if test="param[@dir='return']">
1632 <xsl:value-of select="concat($retval, ' = ')" />
1633 </xsl:if>
1634 <xsl:value-of select="concat('Helper.invoke(getTypedWrapped(), &quot;', $methodname, '&quot; ')"/>
1635 <xsl:for-each select="param[not(@dir='return')]">
1636 <xsl:text>, </xsl:text>
1637 <xsl:choose>
1638 <xsl:when test="@dir='out'">
1639 <xsl:value-of select="concat('tmp_', @name)" />
1640 </xsl:when>
1641 <xsl:when test="@dir='in'">
1642 <xsl:variable name="unwrapped">
1643 <xsl:call-template name="cookInParam">
1644 <xsl:with-param name="value" select="@name" />
1645 <xsl:with-param name="idltype" select="@type" />
1646 <xsl:with-param name="safearray" select="@safearray" />
1647 </xsl:call-template>
1648 </xsl:variable>
1649 <xsl:value-of select="$unwrapped"/>
1650 </xsl:when>
1651 </xsl:choose>
1652 </xsl:for-each>
1653 <xsl:text>);&#10;</xsl:text>
1654 </xsl:when>
1655
1656 <xsl:when test="($G_vboxGlueStyle='jaxws')">
1657 <xsl:variable name="jaxwsmethod">
1658 <xsl:call-template name="makeJaxwsMethod">
1659 <xsl:with-param name="ifname" select="$ifname" />
1660 <xsl:with-param name="methodname" select="$methodname" />
1661 </xsl:call-template>
1662 </xsl:variable>
1663 <xsl:variable name="portArg">
1664 <xsl:if test="not(//interface[@name=$ifname]/@wsmap='global')">
1665 <xsl:text>obj</xsl:text>
1666 </xsl:if>
1667 </xsl:variable>
1668 <xsl:variable name="paramsinout" select="param[@dir='in' or @dir='out']" />
1669
1670 <xsl:text> </xsl:text>
1671 <xsl:if test="param[@dir='return'] and not(param[@dir='out'])">
1672 <xsl:value-of select="concat($retval, ' = ')" />
1673 </xsl:if>
1674 <xsl:value-of select="concat('port.', $jaxwsmethod, '(', $portArg)" />
1675 <xsl:if test="$paramsinout and not($portArg='')">
1676 <xsl:text>, </xsl:text>
1677 </xsl:if>
1678
1679 <!-- jax-ws has an oddity: if both out params and a return value exist,
1680 then the return value is moved to the function's argument list... -->
1681 <xsl:choose>
1682 <xsl:when test="param[@dir='out'] and param[@dir='return']">
1683 <xsl:for-each select="param">
1684 <xsl:choose>
1685 <xsl:when test="@dir='return'">
1686 <xsl:value-of select="$retval"/>
1687 </xsl:when>
1688 <xsl:when test="@dir='out'">
1689 <xsl:value-of select="concat('tmp_', @name)" />
1690 </xsl:when>
1691 <xsl:otherwise>
1692 <xsl:call-template name="cookInParam">
1693 <xsl:with-param name="value" select="@name" />
1694 <xsl:with-param name="idltype" select="@type" />
1695 <xsl:with-param name="safearray" select="@safearray" />
1696 </xsl:call-template>
1697 </xsl:otherwise>
1698 </xsl:choose>
1699 <xsl:if test="not(position()=last())">
1700 <xsl:text>, </xsl:text>
1701 </xsl:if>
1702 </xsl:for-each>
1703 </xsl:when>
1704 <xsl:otherwise>
1705 <xsl:for-each select="$paramsinout">
1706 <xsl:choose>
1707 <xsl:when test="@dir='return'">
1708 <xsl:value-of select="$retval"/>
1709 </xsl:when>
1710 <xsl:when test="@dir='out'">
1711 <xsl:value-of select="concat('tmp_', @name)" />
1712 </xsl:when>
1713 <xsl:otherwise>
1714 <xsl:call-template name="cookInParam">
1715 <xsl:with-param name="value" select="@name" />
1716 <xsl:with-param name="idltype" select="@type" />
1717 <xsl:with-param name="safearray" select="@safearray" />
1718 </xsl:call-template>
1719 </xsl:otherwise>
1720 </xsl:choose>
1721 <xsl:if test="not(position()=last())">
1722 <xsl:text>, </xsl:text>
1723 </xsl:if>
1724 </xsl:for-each>
1725 </xsl:otherwise>
1726 </xsl:choose>
1727 <xsl:text>);&#10;</xsl:text>
1728 </xsl:when>
1729
1730 <xsl:otherwise>
1731 <xsl:call-template name="fatalError">
1732 <xsl:with-param name="msg" select="'Style unknown (genBackMethodCall)'" />
1733 </xsl:call-template>
1734 </xsl:otherwise>
1735
1736 </xsl:choose>
1737</xsl:template>
1738
1739<xsl:template name="genGetterCall">
1740 <xsl:param name="ifname"/>
1741 <xsl:param name="gettername"/>
1742 <xsl:param name="backtype"/>
1743 <xsl:param name="retval"/>
1744
1745 <xsl:choose>
1746 <xsl:when test="$G_vboxGlueStyle='xpcom'">
1747 <xsl:value-of select="concat(' ', $backtype, ' ', $retval, ' = getTypedWrapped().', $gettername, '(')" />
1748 <xsl:if test="@safearray">
1749 <xsl:text>null</xsl:text>
1750 </xsl:if>
1751 <xsl:text>);&#10;</xsl:text>
1752 </xsl:when>
1753
1754 <xsl:when test="$G_vboxGlueStyle='mscom'">
1755 <xsl:value-of select="concat(' ', $backtype, ' ', $retval, ' = Dispatch.get(getTypedWrapped(), &quot;', @name, '&quot;);&#10;')" />
1756 </xsl:when>
1757
1758 <xsl:when test="$G_vboxGlueStyle='jaxws'">
1759 <xsl:variable name="jaxwsGetter">
1760 <xsl:call-template name="makeJaxwsMethod">
1761 <xsl:with-param name="ifname" select="$ifname" />
1762 <xsl:with-param name="methodname" select="$gettername" />
1763 </xsl:call-template>
1764 </xsl:variable>
1765 <xsl:value-of select="concat(' ', $backtype, ' ', $retval, ' = port.', $jaxwsGetter, '(obj);&#10;')" />
1766 </xsl:when>
1767
1768 <xsl:otherwise>
1769 <xsl:call-template name="fatalError">
1770 <xsl:with-param name="msg" select="'Style unknown (genGetterCall)'" />
1771 </xsl:call-template>
1772 </xsl:otherwise>
1773 </xsl:choose>
1774</xsl:template>
1775
1776<xsl:template name="genSetterCall">
1777 <xsl:param name="ifname"/>
1778 <xsl:param name="settername"/>
1779 <xsl:param name="value"/>
1780
1781 <xsl:choose>
1782 <xsl:when test="$G_vboxGlueStyle='xpcom'">
1783 <xsl:value-of select="concat(' getTypedWrapped().', $settername, '(', $value, ');&#10;')" />
1784 </xsl:when>
1785
1786 <xsl:when test="$G_vboxGlueStyle='mscom'">
1787 <xsl:value-of select="concat(' Dispatch.put(getTypedWrapped(), &quot;', @name, '&quot;, ', $value, ');&#10;')" />
1788 </xsl:when>
1789
1790 <xsl:when test="$G_vboxGlueStyle='jaxws'">
1791 <xsl:variable name="jaxwsSetter">
1792 <xsl:call-template name="makeJaxwsMethod">
1793 <xsl:with-param name="ifname" select="$ifname" />
1794 <xsl:with-param name="methodname" select="$settername" />
1795 </xsl:call-template>
1796 </xsl:variable>
1797 <xsl:value-of select="concat(' port.', $jaxwsSetter, '(obj, ', $value, ');&#10;')" />
1798 </xsl:when>
1799
1800 <xsl:otherwise>
1801 <xsl:call-template name="fatalError">
1802 <xsl:with-param name="msg" select="'Style unknown (genSetterCall)'" />
1803 </xsl:call-template>
1804 </xsl:otherwise>
1805 </xsl:choose>
1806</xsl:template>
1807
1808<xsl:template name="genStructWrapperJaxws">
1809 <xsl:param name="ifname"/>
1810
1811 <xsl:value-of select="concat(' private ', $G_virtualBoxPackageCom, '.', $ifname, ' real;&#10;')"/>
1812 <xsl:text> private VboxPortType port;&#10;&#10;</xsl:text>
1813
1814 <xsl:value-of select="concat(' public ', $ifname, '(', $G_virtualBoxPackageCom, '.', $ifname, ' real, VboxPortType port)&#10;')" />
1815 <xsl:text> {&#10;</xsl:text>
1816 <xsl:text> this.real = real;&#10;</xsl:text>
1817 <xsl:text> this.port = port;&#10;</xsl:text>
1818 <xsl:text> }&#10;&#10;</xsl:text>
1819
1820 <xsl:for-each select="attribute">
1821 <xsl:variable name="attrname"><xsl:value-of select="@name" /></xsl:variable>
1822 <xsl:variable name="attrtype"><xsl:value-of select="@type" /></xsl:variable>
1823 <xsl:variable name="attrsafearray"><xsl:value-of select="@safearray" /></xsl:variable>
1824
1825 <xsl:if test="not(@wsmap = 'suppress')">
1826
1827 <xsl:if test="not(@readonly = 'yes')">
1828 <xsl:call-template name="fatalError">
1829 <xsl:with-param name="msg" select="concat('Non read-only struct (genStructWrapperJaxws) in interface ', $ifname, ', attribute ', $attrname)" />
1830 </xsl:call-template>
1831 </xsl:if>
1832
1833 <!-- Emit getter -->
1834 <xsl:variable name="backgettername">
1835 <xsl:choose>
1836 <!-- Stupid, but backend boolean getters called isFoo(), not getFoo() -->
1837 <xsl:when test="$attrtype = 'boolean'">
1838 <xsl:variable name="capsname">
1839 <xsl:call-template name="capitalize">
1840 <xsl:with-param name="str" select="$attrname" />
1841 </xsl:call-template>
1842 </xsl:variable>
1843 <xsl:value-of select="concat('is', $capsname)" />
1844 </xsl:when>
1845 <xsl:otherwise>
1846 <xsl:call-template name="makeGetterName">
1847 <xsl:with-param name="attrname" select="$attrname" />
1848 </xsl:call-template>
1849 </xsl:otherwise>
1850 </xsl:choose>
1851 </xsl:variable>
1852
1853 <xsl:variable name="gluegettername">
1854 <xsl:call-template name="makeGetterName">
1855 <xsl:with-param name="attrname" select="$attrname" />
1856 </xsl:call-template>
1857 </xsl:variable>
1858
1859 <xsl:variable name="gluegettertype">
1860 <xsl:call-template name="typeIdl2Glue">
1861 <xsl:with-param name="type" select="$attrtype" />
1862 <xsl:with-param name="safearray" select="@safearray" />
1863 </xsl:call-template>
1864 </xsl:variable>
1865
1866 <xsl:variable name="backgettertype">
1867 <xsl:call-template name="typeIdl2Back">
1868 <xsl:with-param name="type" select="$attrtype" />
1869 <xsl:with-param name="safearray" select="@safearray" />
1870 </xsl:call-template>
1871 </xsl:variable>
1872
1873 <xsl:apply-templates select="desc" mode="attribute_get"/>
1874 <xsl:value-of select="concat(' public ', $gluegettertype, ' ', $gluegettername, '()&#10;')" />
1875 <xsl:text> {&#10;</xsl:text>
1876 <xsl:value-of select="concat(' ', $backgettertype, ' retVal = real.', $backgettername, '();&#10;')" />
1877 <xsl:variable name="wrapped">
1878 <xsl:call-template name="cookOutParam">
1879 <xsl:with-param name="value" select="'retVal'" />
1880 <xsl:with-param name="idltype" select="$attrtype" />
1881 <xsl:with-param name="safearray" select="@safearray" />
1882 </xsl:call-template>
1883 </xsl:variable>
1884 <xsl:value-of select="concat(' return ', $wrapped, ';&#10;')" />
1885 <xsl:text> }&#10;</xsl:text>
1886 </xsl:if>
1887
1888 </xsl:for-each>
1889
1890</xsl:template>
1891
1892<!-- Interface method wrapper -->
1893<xsl:template name="genMethod">
1894 <xsl:param name="ifname"/>
1895 <xsl:param name="methodname"/>
1896
1897 <xsl:choose>
1898 <xsl:when test="(param[@mod='ptr']) or (($G_vboxGlueStyle='jaxws') and (param[@type=($G_setSuppressedInterfaces/@name)]))" >
1899 <xsl:value-of select="concat(' // Skipping method ', $methodname, ' for it has parameters with suppressed types&#10;')" />
1900 </xsl:when>
1901 <xsl:when test="($G_vboxGlueStyle='jaxws') and (@wsmap = 'suppress')" >
1902 <xsl:value-of select="concat(' // Skipping method ', $methodname, ' for it is suppressed&#10;')" />
1903 </xsl:when>
1904 <xsl:otherwise>
1905 <xsl:variable name="hasReturnParms" select="param[@dir='return']" />
1906 <xsl:variable name="hasOutParms" select="param[@dir='out']" />
1907 <xsl:variable name="returnidltype" select="param[@dir='return']/@type" />
1908 <xsl:variable name="returnidlsafearray" select="param[@dir='return']/@safearray" />
1909 <xsl:if test="$hasOutParms and not($hasReturnParms) and (count(param[@dir='out']) = 1)">
1910 <xsl:call-template name="fatalError">
1911 <xsl:with-param name="msg" select="concat('genMethod: ', $ifname, '::', $methodname, ' has exactly one out parameter and no return parameter, this causes trouble with JAX-WS and the out parameter needs to be converted to return')" />
1912 </xsl:call-template>
1913 </xsl:if>
1914 <xsl:variable name="returngluetype">
1915 <xsl:choose>
1916 <xsl:when test="$returnidltype">
1917 <xsl:call-template name="typeIdl2Glue">
1918 <xsl:with-param name="type" select="$returnidltype" />
1919 <xsl:with-param name="safearray" select="$returnidlsafearray" />
1920 </xsl:call-template>
1921 </xsl:when>
1922 <xsl:otherwise>
1923 <xsl:text>void</xsl:text>
1924 </xsl:otherwise>
1925 </xsl:choose>
1926 </xsl:variable>
1927 <xsl:variable name="retValValue">
1928 <xsl:choose>
1929 <xsl:when test="(param[@dir='out']) and ($G_vboxGlueStyle='jaxws')">
1930 <xsl:text>retVal.value</xsl:text>
1931 </xsl:when>
1932 <xsl:otherwise>
1933 <xsl:text>retVal</xsl:text>
1934 </xsl:otherwise>
1935 </xsl:choose>
1936 </xsl:variable>
1937 <xsl:apply-templates select="desc" mode="method"/>
1938 <xsl:value-of select="concat(' public ', $returngluetype, ' ', $methodname, '(')" />
1939 <xsl:variable name="paramsinout" select="param[@dir='in' or @dir='out']" />
1940 <xsl:for-each select="exsl:node-set($paramsinout)">
1941 <xsl:variable name="paramgluetype">
1942 <xsl:call-template name="typeIdl2Glue">
1943 <xsl:with-param name="type" select="@type" />
1944 <xsl:with-param name="safearray" select="@safearray" />
1945 </xsl:call-template>
1946 </xsl:variable>
1947 <xsl:choose>
1948 <xsl:when test="@dir='out'">
1949 <xsl:value-of select="concat('Holder&lt;', $paramgluetype, '&gt; ', @name)" />
1950 </xsl:when>
1951 <xsl:otherwise>
1952 <xsl:value-of select="concat($paramgluetype, ' ', @name)" />
1953 </xsl:otherwise>
1954 </xsl:choose>
1955 <xsl:if test="not(position()=last())">
1956 <xsl:text>, </xsl:text>
1957 </xsl:if>
1958 </xsl:for-each>
1959 <xsl:text>)&#10;</xsl:text>
1960 <xsl:text> {&#10;</xsl:text>
1961
1962 <xsl:call-template name="startExcWrapper"/>
1963
1964 <!-- declare temp out params -->
1965 <xsl:for-each select="param[@dir='out']">
1966 <xsl:variable name="backouttype">
1967 <xsl:call-template name="typeIdl2Back">
1968 <xsl:with-param name="type" select="@type" />
1969 <xsl:with-param name="safearray" select="@safearray" />
1970 </xsl:call-template>
1971 </xsl:variable>
1972 <xsl:choose>
1973 <xsl:when test="$G_vboxGlueStyle='xpcom'">
1974 <xsl:value-of select="concat(' ', $backouttype, '[] tmp_', @name, ' = (', $backouttype, '[])java.lang.reflect.Array.newInstance(', $backouttype, '.class, 1);&#10;')"/>
1975 </xsl:when>
1976 <xsl:when test="$G_vboxGlueStyle='mscom'">
1977 <xsl:value-of select="concat(' Variant tmp_', @name, ' = new Variant();&#10;')"/>
1978 </xsl:when>
1979 <xsl:when test="$G_vboxGlueStyle='jaxws'">
1980 <xsl:value-of select="concat(' javax.xml.ws.Holder&lt;', $backouttype, '&gt; tmp_', @name, ' = new javax.xml.ws.Holder&lt;', $backouttype, '&gt;();&#10;')"/>
1981 </xsl:when>
1982 <xsl:otherwise>
1983 <xsl:call-template name="fatalError">
1984 <xsl:with-param name="msg" select="'Handle out param (genMethod)'" />
1985 </xsl:call-template>
1986 </xsl:otherwise>
1987 </xsl:choose>
1988 </xsl:for-each>
1989
1990 <!-- declare return param, if any -->
1991 <xsl:if test="$hasReturnParms">
1992 <xsl:variable name="backrettype">
1993 <xsl:call-template name="typeIdl2Back">
1994 <xsl:with-param name="type" select="$returnidltype" />
1995 <xsl:with-param name="safearray" select="$returnidlsafearray" />
1996 </xsl:call-template>
1997 </xsl:variable>
1998 <xsl:choose>
1999 <xsl:when test="(param[@dir='out']) and ($G_vboxGlueStyle='jaxws')">
2000 <xsl:value-of select="concat(' javax.xml.ws.Holder&lt;', $backrettype, '&gt;',
2001 ' retVal = new javax.xml.ws.Holder&lt;', $backrettype,
2002 '&gt;();&#10;')"/>
2003 </xsl:when>
2004 <xsl:otherwise>
2005 <xsl:value-of select="concat(' ', $backrettype, ' retVal;&#10;')"/>
2006 </xsl:otherwise>
2007 </xsl:choose>
2008 </xsl:if>
2009
2010 <!-- Method call -->
2011 <xsl:call-template name="genBackMethodCall">
2012 <xsl:with-param name="ifname" select="$ifname" />
2013 <xsl:with-param name="methodname" select="$methodname" />
2014 <xsl:with-param name="retval" select="'retVal'" />
2015 </xsl:call-template>
2016
2017 <!-- return out params -->
2018 <xsl:for-each select="param[@dir='out']">
2019 <xsl:variable name="varval">
2020 <xsl:choose>
2021 <xsl:when test="$G_vboxGlueStyle='xpcom'">
2022 <xsl:value-of select="concat('tmp_', @name, '[0]')" />
2023 </xsl:when>
2024 <xsl:when test="$G_vboxGlueStyle='mscom'">
2025 <xsl:value-of select="concat('tmp_', @name)" />
2026 </xsl:when>
2027 <xsl:when test="$G_vboxGlueStyle='jaxws'">
2028 <xsl:value-of select="concat('tmp_', @name, '.value')" />
2029 </xsl:when>
2030 <xsl:otherwise>
2031 <xsl:call-template name="fatalError">
2032 <xsl:with-param name="msg" select="'Style unknown (genMethod, outparam)'" />
2033 </xsl:call-template>
2034 </xsl:otherwise>
2035 </xsl:choose>
2036 </xsl:variable>
2037 <xsl:variable name="wrapped">
2038 <xsl:call-template name="cookOutParam">
2039 <xsl:with-param name="value" select="$varval" />
2040 <xsl:with-param name="idltype" select="@type" />
2041 <xsl:with-param name="safearray" select="@safearray" />
2042 </xsl:call-template>
2043 </xsl:variable>
2044 <xsl:value-of select="concat(' ', @name, '.value = ', $wrapped, ';&#10;')"/>
2045 </xsl:for-each>
2046
2047 <xsl:if test="$hasReturnParms">
2048 <!-- actual 'return' statement -->
2049 <xsl:variable name="wrapped">
2050 <xsl:call-template name="cookOutParam">
2051 <xsl:with-param name="value" select="$retValValue" />
2052 <xsl:with-param name="idltype" select="$returnidltype" />
2053 <xsl:with-param name="safearray" select="$returnidlsafearray" />
2054 </xsl:call-template>
2055 </xsl:variable>
2056 <xsl:value-of select="concat(' return ', $wrapped, ';&#10;')" />
2057 </xsl:if>
2058 <xsl:call-template name="endExcWrapper"/>
2059
2060 <xsl:text> }&#10;</xsl:text>
2061 </xsl:otherwise>
2062 </xsl:choose>
2063
2064</xsl:template>
2065
2066<!-- Callback interface method -->
2067<xsl:template name="genCbMethodDecl">
2068 <xsl:param name="ifname"/>
2069 <xsl:param name="methodname"/>
2070
2071 <xsl:choose>
2072 <xsl:when test="(param[@mod='ptr'])" >
2073 <xsl:value-of select="concat(' // Skipping method ', $methodname, ' for it has parameters with suppressed types&#10;')" />
2074 </xsl:when>
2075 <xsl:otherwise>
2076 <xsl:variable name="returnidltype" select="param[@dir='return']/@type" />
2077 <xsl:variable name="returnidlsafearray" select="param[@dir='return']/@safearray" />
2078 <xsl:variable name="returngluetype">
2079 <xsl:choose>
2080 <xsl:when test="$returnidltype">
2081 <xsl:call-template name="typeIdl2Glue">
2082 <xsl:with-param name="type" select="$returnidltype" />
2083 <xsl:with-param name="safearray" select="$returnidlsafearray" />
2084 </xsl:call-template>
2085 </xsl:when>
2086 <xsl:otherwise>
2087 <xsl:text>void</xsl:text>
2088 </xsl:otherwise>
2089 </xsl:choose>
2090 </xsl:variable>
2091 <xsl:value-of select="concat(' public ', $returngluetype, ' ', $methodname, '(')" />
2092 <xsl:variable name="paramsinout" select="param[@dir='in' or @dir='out']" />
2093 <xsl:for-each select="exsl:node-set($paramsinout)">
2094 <xsl:variable name="paramgluetype">
2095 <xsl:call-template name="typeIdl2Glue">
2096 <xsl:with-param name="type" select="@type" />
2097 <xsl:with-param name="safearray" select="@safearray" />
2098 </xsl:call-template>
2099 </xsl:variable>
2100 <xsl:choose>
2101 <xsl:when test="@dir='out'">
2102 <xsl:value-of select="concat('Holder&lt;', $paramgluetype, '&gt; ', @name)" />
2103 </xsl:when>
2104 <xsl:otherwise>
2105 <xsl:value-of select="concat($paramgluetype, ' ', @name)" />
2106 </xsl:otherwise>
2107 </xsl:choose>
2108 <xsl:if test="not(position()=last())">
2109 <xsl:text>, </xsl:text>
2110 </xsl:if>
2111 </xsl:for-each>
2112 <xsl:text>);&#10;</xsl:text>
2113 </xsl:otherwise>
2114 </xsl:choose>
2115</xsl:template>
2116
2117<!-- queryInterface wrapper -->
2118<xsl:template name="genQI">
2119 <xsl:param name="ifname"/>
2120 <xsl:param name="uuid" />
2121
2122 <xsl:value-of select="concat(' public static ', $ifname, ' queryInterface(IUnknown obj)&#10;')" />
2123 <xsl:text> {&#10;</xsl:text>
2124 <xsl:choose>
2125 <xsl:when test="$G_vboxGlueStyle='xpcom'">
2126 <xsl:variable name="backtype">
2127 <xsl:call-template name="typeIdl2Back">
2128 <xsl:with-param name="type" select="$ifname" />
2129 </xsl:call-template>
2130 </xsl:variable>
2131 <xsl:text> nsISupports nsobj = obj != null ? (nsISupports)obj.getWrapped() : null;&#10;</xsl:text>
2132 <xsl:text> if (nsobj == null) return null;&#10;</xsl:text>
2133 <xsl:value-of select="concat(' ', $backtype, ' qiobj = Helper.queryInterface(nsobj, &quot;{', $uuid, '}&quot;, ', $backtype, '.class);&#10;')" />
2134 <xsl:value-of select="concat(' return qiobj == null ? null : new ', $ifname, '(qiobj);&#10;')" />
2135 </xsl:when>
2136
2137 <xsl:when test="$G_vboxGlueStyle='mscom'">
2138 <xsl:value-of select="concat(' return', ' obj == null ? null : new ', $ifname, '((com.jacob.com.Dispatch)obj.getWrapped());&#10;')" />
2139 </xsl:when>
2140
2141 <xsl:when test="$G_vboxGlueStyle='jaxws'">
2142 <!-- bad, need to check that we really can be casted to this type -->
2143 <xsl:value-of select="concat(' return obj == null ? null : new ', $ifname, '(obj.getWrapped(), obj.getRemoteWSPort());&#10;')" />
2144 </xsl:when>
2145
2146 <xsl:otherwise>
2147 <xsl:call-template name="fatalError">
2148 <xsl:with-param name="msg" select="'Style unknown (genQI)'" />
2149 </xsl:call-template>
2150 </xsl:otherwise>
2151
2152 </xsl:choose>
2153 <xsl:text> }&#10;</xsl:text>
2154</xsl:template>
2155
2156
2157<xsl:template name="genCbMethodImpl">
2158 <xsl:param name="ifname"/>
2159 <xsl:param name="methodname"/>
2160
2161 <xsl:choose>
2162 <xsl:when test="(param[@mod='ptr'])" >
2163 <xsl:value-of select="concat(' // Skipping method ', $methodname, ' for it has parameters with suppressed types&#10;')" />
2164 </xsl:when>
2165 <xsl:otherwise>
2166 <xsl:variable name="hasReturnParms" select="param[@dir='return']" />
2167 <xsl:variable name="hasOutParms" select="param[@dir='out']" />
2168 <xsl:variable name="returnidltype" select="param[@dir='return']/@type" />
2169 <xsl:variable name="returnidlsafearray" select="param[@dir='return']/@safearray" />
2170 <xsl:variable name="returnbacktype">
2171 <xsl:choose>
2172 <xsl:when test="$returnidltype">
2173 <xsl:call-template name="typeIdl2Back">
2174 <xsl:with-param name="type" select="$returnidltype" />
2175 <xsl:with-param name="safearray" select="$returnidlsafearray" />
2176 </xsl:call-template>
2177 </xsl:when>
2178 <xsl:otherwise>
2179 <xsl:text>void</xsl:text>
2180 </xsl:otherwise>
2181 </xsl:choose>
2182 </xsl:variable>
2183 <xsl:variable name="paramsinout" select="param[@dir='in' or @dir='out']" />
2184 <xsl:choose>
2185 <xsl:when test="$G_vboxGlueStyle='xpcom'">
2186 <xsl:value-of select="concat(' public ', $returnbacktype, ' ', $methodname, '(')" />
2187 <xsl:for-each select="exsl:node-set($paramsinout)">
2188 <xsl:variable name="parambacktype">
2189 <xsl:call-template name="typeIdl2Back">
2190 <xsl:with-param name="type" select="@type" />
2191 <xsl:with-param name="safearray" select="@safearray" />
2192 </xsl:call-template>
2193 </xsl:variable>
2194 <xsl:choose>
2195 <xsl:when test="@dir='out'">
2196 <xsl:value-of select="concat($parambacktype, '[] ', @name)" />
2197 </xsl:when>
2198 <xsl:otherwise>
2199 <xsl:if test="@safearray">
2200 <xsl:value-of select="concat('long len_', @name, ', ')" />
2201 </xsl:if>
2202 <xsl:value-of select="concat($parambacktype, ' ', @name)" />
2203 </xsl:otherwise>
2204 </xsl:choose>
2205 <xsl:if test="not(position()=last())">
2206 <xsl:text>, </xsl:text>
2207 </xsl:if>
2208 </xsl:for-each>
2209 <xsl:text>)&#10;</xsl:text>
2210 <xsl:text> {&#10;</xsl:text>
2211 </xsl:when>
2212
2213 <xsl:when test="$G_vboxGlueStyle='mscom'">
2214 <xsl:variable name="capsname">
2215 <xsl:call-template name="capitalize">
2216 <xsl:with-param name="str" select="$methodname" />
2217 </xsl:call-template>
2218 </xsl:variable>
2219 <xsl:value-of select="concat(' public ', $returnbacktype, ' ', $capsname, '(')" />
2220 <xsl:text>Variant _args[])&#10;</xsl:text>
2221 <xsl:text> {&#10;</xsl:text>
2222 <xsl:for-each select="exsl:node-set($paramsinout)">
2223 <xsl:variable name="parambacktype">
2224 <xsl:call-template name="typeIdl2Back">
2225 <xsl:with-param name="type" select="@type" />
2226 <xsl:with-param name="safearray" select="@safearray" />
2227 </xsl:call-template>
2228 </xsl:variable>
2229 <xsl:value-of select="concat(' ', $parambacktype, ' ', @name, '=_args[', count(preceding-sibling::param), '];&#10;')" />
2230 </xsl:for-each>
2231 </xsl:when>
2232
2233 <xsl:otherwise>
2234 <xsl:call-template name="fatalError">
2235 <xsl:with-param name="msg" select="'Style unknown (genSetterCall)'" />
2236 </xsl:call-template>
2237 </xsl:otherwise>
2238 </xsl:choose>
2239
2240 <!-- declare temp out params -->
2241 <xsl:for-each select="param[@dir='out']">
2242 <xsl:variable name="glueouttype">
2243 <xsl:call-template name="typeIdl2Glue">
2244 <xsl:with-param name="type" select="@type" />
2245 <xsl:with-param name="safearray" select="@safearray" />
2246 </xsl:call-template>
2247 </xsl:variable>
2248 <xsl:value-of select="concat(' Holder&lt;', $glueouttype, '&gt; tmp_', @name, ' = new Holder&lt;', $glueouttype, '&gt;();&#10;')"/>
2249 </xsl:for-each>
2250
2251 <!-- declare return param, if any -->
2252 <xsl:if test="$hasReturnParms">
2253 <xsl:variable name="gluerettype">
2254 <xsl:call-template name="typeIdl2Glue">
2255 <xsl:with-param name="type" select="$returnidltype" />
2256 <xsl:with-param name="safearray" select="$returnidlsafearray" />
2257 </xsl:call-template>
2258 </xsl:variable>
2259 <xsl:value-of select="concat(' ', $gluerettype, ' retVal = &#10;')"/>
2260 </xsl:if>
2261
2262 <!-- Method call -->
2263 <xsl:value-of select="concat(' sink.', $methodname, '(')"/>
2264 <xsl:for-each select="param[not(@dir='return')]">
2265 <xsl:choose>
2266 <xsl:when test="@dir='out'">
2267 <xsl:value-of select="concat('tmp_', @name)" />
2268 </xsl:when>
2269 <xsl:when test="@dir='in'">
2270 <xsl:variable name="wrapped">
2271 <xsl:call-template name="cookOutParam">
2272 <xsl:with-param name="value" select="@name" />
2273 <xsl:with-param name="idltype" select="@type" />
2274 <xsl:with-param name="safearray" select="@safearray" />
2275 </xsl:call-template>
2276 </xsl:variable>
2277 <xsl:value-of select="$wrapped"/>
2278 </xsl:when>
2279 <xsl:otherwise>
2280 <xsl:call-template name="fatalError">
2281 <xsl:with-param name="msg" select="concat('Unsupported param dir: ', @dir, '&quot;.')" />
2282 </xsl:call-template>
2283 </xsl:otherwise>
2284 </xsl:choose>
2285 <xsl:if test="not(position()=last())">
2286 <xsl:text>, </xsl:text>
2287 </xsl:if>
2288 </xsl:for-each>
2289 <xsl:text>);&#10;</xsl:text>
2290
2291 <!-- return out params -->
2292 <xsl:for-each select="param[@dir='out']">
2293
2294 <xsl:variable name="unwrapped">
2295 <xsl:call-template name="cookInParam">
2296 <xsl:with-param name="value" select="concat('tmp_', @name, '.value')" />
2297 <xsl:with-param name="idltype" select="@type" />
2298 <xsl:with-param name="safearray" select="@safearray" />
2299 </xsl:call-template>
2300 </xsl:variable>
2301 <xsl:choose>
2302 <xsl:when test="$G_vboxGlueStyle='xpcom'">
2303 <xsl:value-of select="concat(' ', @name, '[0] = ', $unwrapped, ';&#10;')"/>
2304 </xsl:when>
2305 <xsl:when test="$G_vboxGlueStyle='mscom'">
2306 <xsl:value-of select="concat(' _args[', count(preceding-sibling::param), '] = ', $unwrapped, ';&#10;')"/>
2307 </xsl:when>
2308 </xsl:choose>
2309 </xsl:for-each>
2310
2311 <xsl:if test="$hasReturnParms">
2312 <!-- actual 'return' statement -->
2313 <xsl:variable name="unwrapped">
2314 <xsl:call-template name="cookInParam">
2315 <xsl:with-param name="value" select="'retVal'" />
2316 <xsl:with-param name="idltype" select="$returnidltype" />
2317 <xsl:with-param name="safearray" select="$returnidlsafearray" />
2318 </xsl:call-template>
2319 </xsl:variable>
2320 <xsl:value-of select="concat(' return ', $unwrapped, ';&#10;')" />
2321 </xsl:if>
2322 <xsl:text> }&#10;</xsl:text>
2323 </xsl:otherwise>
2324 </xsl:choose>
2325</xsl:template>
2326
2327<!-- Interface method -->
2328<xsl:template name="genIfaceWrapper">
2329 <xsl:param name="ifname"/>
2330
2331 <xsl:variable name="wrappedType">
2332 <xsl:call-template name="wrappedName">
2333 <xsl:with-param name="ifname" select="$ifname" />
2334 </xsl:call-template>
2335 </xsl:variable>
2336
2337 <!-- Constructor -->
2338 <xsl:choose>
2339 <xsl:when test="($G_vboxGlueStyle='jaxws')">
2340 <xsl:value-of select="concat(' public ', $ifname, '(String wrapped, VboxPortType port)&#10;')" />
2341 <xsl:text> {&#10;</xsl:text>
2342 <xsl:text> super(wrapped, port);&#10;</xsl:text>
2343 <xsl:text> }&#10;</xsl:text>
2344 </xsl:when>
2345
2346 <xsl:when test="($G_vboxGlueStyle='xpcom') or ($G_vboxGlueStyle='mscom')">
2347 <xsl:value-of select="concat(' public ', $ifname, '(', $wrappedType, ' wrapped)&#10;')" />
2348 <xsl:text> {&#10;</xsl:text>
2349 <xsl:text> super(wrapped);&#10;</xsl:text>
2350 <xsl:text> }&#10;</xsl:text>
2351
2352 <!-- Typed wrapped object accessor -->
2353 <xsl:value-of select="concat(' public ', $wrappedType, ' getTypedWrapped()&#10;')" />
2354 <xsl:text> {&#10;</xsl:text>
2355 <xsl:value-of select="concat(' return (', $wrappedType, ') getWrapped();&#10;')" />
2356 <xsl:text> }&#10;</xsl:text>
2357 </xsl:when>
2358
2359 <xsl:otherwise>
2360 <xsl:call-template name="fatalError">
2361 <xsl:with-param name="msg" select="'Style unknown (root, ctr)'" />
2362 </xsl:call-template>
2363 </xsl:otherwise>
2364 </xsl:choose>
2365 <!-- Attributes -->
2366 <xsl:for-each select="attribute[not(@mod='ptr')]">
2367 <xsl:variable name="attrname"><xsl:value-of select="@name" /></xsl:variable>
2368 <xsl:variable name="attrtype"><xsl:value-of select="@type" /></xsl:variable>
2369 <xsl:variable name="attrsafearray"><xsl:value-of select="@safearray" /></xsl:variable>
2370
2371 <xsl:choose>
2372 <xsl:when test="($G_vboxGlueStyle='jaxws') and ($attrtype=($G_setSuppressedInterfaces/@name))">
2373 <xsl:value-of select="concat(' // Skipping attribute ', $attrname, ' of suppressed type ', $attrtype, '&#10;&#10;')" />
2374 </xsl:when>
2375 <xsl:when test="($G_vboxGlueStyle='jaxws') and (@wsmap = 'suppress')" >
2376 <xsl:value-of select="concat(' // Skipping attribute ', $attrname, ' for it is suppressed&#10;')" />
2377 </xsl:when>
2378
2379 <xsl:otherwise>
2380 <!-- emit getter method -->
2381 <xsl:apply-templates select="desc" mode="attribute_get"/>
2382 <xsl:variable name="gettername">
2383 <xsl:call-template name="makeGetterName">
2384 <xsl:with-param name="attrname" select="$attrname" />
2385 </xsl:call-template>
2386 </xsl:variable>
2387 <xsl:variable name="gluetype">
2388 <xsl:call-template name="typeIdl2Glue">
2389 <xsl:with-param name="type" select="$attrtype" />
2390 <xsl:with-param name="safearray" select="@safearray" />
2391 </xsl:call-template>
2392 </xsl:variable>
2393 <xsl:variable name="backtype">
2394 <xsl:call-template name="typeIdl2Back">
2395 <xsl:with-param name="type" select="$attrtype" />
2396 <xsl:with-param name="safearray" select="@safearray" />
2397 </xsl:call-template>
2398 </xsl:variable>
2399 <xsl:variable name="wrapped">
2400 <xsl:call-template name="cookOutParam">
2401 <xsl:with-param name="value" select="'retVal'" />
2402 <xsl:with-param name="idltype" select="$attrtype" />
2403 <xsl:with-param name="safearray" select="@safearray" />
2404 </xsl:call-template>
2405 </xsl:variable>
2406 <xsl:value-of select="concat(' public ', $gluetype, ' ', $gettername, '()&#10;')" />
2407 <xsl:text> {&#10;</xsl:text>
2408
2409 <xsl:call-template name="startExcWrapper"/>
2410
2411 <!-- Actual getter implementation -->
2412 <xsl:call-template name="genGetterCall">
2413 <xsl:with-param name="ifname" select="$ifname" />
2414 <xsl:with-param name="gettername" select="$gettername" />
2415 <xsl:with-param name="backtype" select="$backtype" />
2416 <xsl:with-param name="retval" select="'retVal'" />
2417 </xsl:call-template>
2418
2419 <xsl:value-of select="concat(' return ', $wrapped, ';&#10;')" />
2420 <xsl:call-template name="endExcWrapper"/>
2421
2422 <xsl:text> }&#10;</xsl:text>
2423 <xsl:if test="not(@readonly = 'yes')">
2424 <!-- emit setter method -->
2425 <xsl:apply-templates select="desc" mode="attribute_set"/>
2426 <xsl:variable name="settername"><xsl:call-template name="makeSetterName"><xsl:with-param name="attrname" select="$attrname" /></xsl:call-template></xsl:variable>
2427 <xsl:variable name="unwrapped">
2428 <xsl:call-template name="cookInParam">
2429 <xsl:with-param name="ifname" select="$ifname" />
2430 <xsl:with-param name="value" select="'value'" />
2431 <xsl:with-param name="idltype" select="$attrtype" />
2432 <xsl:with-param name="safearray" select="@safearray" />
2433 </xsl:call-template>
2434 </xsl:variable>
2435 <xsl:value-of select="concat(' public void ', $settername, '(', $gluetype, ' value)&#10;')" />
2436 <xsl:text> {&#10;</xsl:text>
2437 <xsl:call-template name="startExcWrapper"/>
2438 <!-- Actual setter implementation -->
2439 <xsl:call-template name="genSetterCall">
2440 <xsl:with-param name="ifname" select="$ifname" />
2441 <xsl:with-param name="settername" select="$settername" />
2442 <xsl:with-param name="value" select="$unwrapped" />
2443 </xsl:call-template>
2444 <xsl:call-template name="endExcWrapper"/>
2445 <xsl:text> }&#10;</xsl:text>
2446 </xsl:if>
2447
2448 </xsl:otherwise>
2449 </xsl:choose>
2450
2451 </xsl:for-each>
2452
2453 <!-- emit queryInterface() *to* this class -->
2454 <xsl:call-template name="genQI">
2455 <xsl:with-param name="ifname" select="$ifname" />
2456 <xsl:with-param name="uuid" select="@uuid" />
2457 </xsl:call-template>
2458
2459 <!-- emit methods -->
2460 <xsl:for-each select="method">
2461 <xsl:call-template name="genMethod">
2462 <xsl:with-param name="ifname" select="$ifname" />
2463 <xsl:with-param name="methodname" select="@name" />
2464 </xsl:call-template>
2465 </xsl:for-each>
2466
2467</xsl:template>
2468
2469<xsl:template name="genIface">
2470 <xsl:param name="ifname" />
2471 <xsl:param name="filename" />
2472
2473 <xsl:variable name="wsmap" select="@wsmap" />
2474
2475 <xsl:call-template name="startFile">
2476 <xsl:with-param name="file" select="$filename" />
2477 <xsl:with-param name="package" select="$G_virtualBoxPackage" />
2478 </xsl:call-template>
2479
2480 <xsl:if test="$filelistonly=''">
2481 <xsl:text>import java.util.List;&#10;&#10;</xsl:text>
2482
2483 <xsl:apply-templates select="desc" mode="interface"/>
2484
2485 <xsl:choose>
2486 <xsl:when test="($wsmap='struct') and ($G_vboxGlueStyle='jaxws')">
2487 <xsl:value-of select="concat('public class ', $ifname, '&#10;')" />
2488 <xsl:text>{&#10;&#10;</xsl:text>
2489 <xsl:call-template name="genStructWrapperJaxws">
2490 <xsl:with-param name="ifname" select="$ifname" />
2491 </xsl:call-template>
2492 </xsl:when>
2493
2494 <xsl:otherwise>
2495 <xsl:variable name="extends" select="//interface[@name=$ifname]/@extends" />
2496 <xsl:choose>
2497 <xsl:when test="($extends = '$unknown') or ($extends = '$errorinfo')">
2498 <xsl:value-of select="concat('public class ', $ifname, ' extends IUnknown&#10;')" />
2499 <xsl:text>{&#10;&#10;</xsl:text>
2500 </xsl:when>
2501 <xsl:when test="//interface[@name=$extends]">
2502 <xsl:value-of select="concat('public class ', $ifname, ' extends ', $extends, '&#10;')" />
2503 <xsl:text>{&#10;&#10;</xsl:text>
2504 </xsl:when>
2505 <xsl:otherwise>
2506 <xsl:call-template name="fatalError">
2507 <xsl:with-param name="msg" select="concat('Interface generation: interface &quot;', $ifname, '&quot; has invalid &quot;extends&quot; value ', $extends, '.')" />
2508 </xsl:call-template>
2509 </xsl:otherwise>
2510 </xsl:choose>
2511 <xsl:call-template name="genIfaceWrapper">
2512 <xsl:with-param name="ifname" select="$ifname" />
2513 </xsl:call-template>
2514 </xsl:otherwise>
2515 </xsl:choose>
2516
2517 <!-- end of class -->
2518 <xsl:text>}&#10;</xsl:text>
2519 </xsl:if>
2520
2521 <xsl:call-template name="endFile">
2522 <xsl:with-param name="file" select="$filename" />
2523 </xsl:call-template>
2524
2525</xsl:template>
2526
2527<xsl:template name="genCb">
2528 <xsl:param name="ifname" />
2529 <xsl:param name="filename" />
2530 <xsl:param name="filenameimpl" />
2531
2532 <xsl:call-template name="startFile">
2533 <xsl:with-param name="file" select="$filename" />
2534 <xsl:with-param name="package" select="$G_virtualBoxPackage" />
2535 </xsl:call-template>
2536
2537 <xsl:text>import java.util.List;&#10;</xsl:text>
2538
2539 <xsl:value-of select="concat('public interface ', $ifname, '&#10;')" />
2540 <xsl:text>{&#10;</xsl:text>
2541
2542 <!-- emit methods declarations-->
2543 <xsl:for-each select="method">
2544 <xsl:call-template name="genCbMethodDecl">
2545 <xsl:with-param name="ifname" select="$ifname" />
2546 <xsl:with-param name="methodname" select="@name" />
2547 </xsl:call-template>
2548 </xsl:for-each>
2549
2550 <xsl:text>}&#10;&#10;</xsl:text>
2551
2552 <xsl:call-template name="endFile">
2553 <xsl:with-param name="file" select="$filename" />
2554 </xsl:call-template>
2555
2556 <xsl:call-template name="startFile">
2557 <xsl:with-param name="file" select="$filenameimpl" />
2558 <xsl:with-param name="package" select="$G_virtualBoxPackage" />
2559 </xsl:call-template>
2560
2561 <xsl:text>import java.util.List;&#10;</xsl:text>
2562
2563 <xsl:variable name="backtype">
2564 <xsl:call-template name="typeIdl2Back">
2565 <xsl:with-param name="type" select="$ifname" />
2566 </xsl:call-template>
2567 </xsl:variable>
2568
2569 <!-- emit glue methods body -->
2570 <xsl:choose>
2571 <xsl:when test="$G_vboxGlueStyle='xpcom'">
2572 <xsl:value-of select="concat('class ', $ifname, 'Impl extends nsISupportsBase implements ', $backtype, '&#10;')" />
2573 <xsl:text>{&#10;</xsl:text>
2574 </xsl:when>
2575
2576 <xsl:when test="$G_vboxGlueStyle='mscom'">
2577 <xsl:value-of select="concat('public class ', $ifname, 'Impl&#10;')" />
2578 <xsl:text>{&#10;</xsl:text>
2579 </xsl:when>
2580 </xsl:choose>
2581
2582 <xsl:value-of select="concat(' ', $ifname, ' sink;&#10;')" />
2583
2584 <xsl:value-of select="concat(' ', $ifname, 'Impl(', $ifname, ' sink)&#10;')" />
2585 <xsl:text> {&#10;</xsl:text>
2586 <xsl:text> this.sink = sink;&#10;</xsl:text>
2587 <xsl:text> }&#10;</xsl:text>
2588
2589 <!-- emit methods implementations -->
2590 <xsl:for-each select="method">
2591 <xsl:call-template name="genCbMethodImpl">
2592 <xsl:with-param name="ifname" select="$ifname" />
2593 <xsl:with-param name="methodname" select="@name" />
2594 </xsl:call-template>
2595 </xsl:for-each>
2596
2597 <xsl:text>}&#10;&#10;</xsl:text>
2598
2599 <xsl:call-template name="endFile">
2600 <xsl:with-param name="file" select="$filenameimpl" />
2601 </xsl:call-template>
2602</xsl:template>
2603
2604<xsl:template name="emitHandwritten">
2605
2606 <xsl:call-template name="startFile">
2607 <xsl:with-param name="file" select="'Holder.java'" />
2608 <xsl:with-param name="package" select="$G_virtualBoxPackage" />
2609 </xsl:call-template>
2610
2611 <xsl:if test="$filelistonly=''">
2612 <xsl:text><![CDATA[
2613public class Holder<T>
2614{
2615 public T value;
2616
2617 public Holder()
2618 {
2619 }
2620 public Holder(T value)
2621 {
2622 this.value = value;
2623 }
2624}
2625]]></xsl:text>
2626 </xsl:if>
2627
2628 <xsl:call-template name="endFile">
2629 <xsl:with-param name="file" select="'Holder.java'" />
2630 </xsl:call-template>
2631</xsl:template>
2632
2633<xsl:template name="emitHandwrittenXpcom">
2634
2635 <xsl:call-template name="startFile">
2636 <xsl:with-param name="file" select="'IUnknown.java'" />
2637 <xsl:with-param name="package" select="$G_virtualBoxPackageCom" />
2638 </xsl:call-template>
2639
2640 <xsl:if test="$filelistonly=''">
2641 <xsl:text><![CDATA[
2642public class IUnknown
2643{
2644 private Object obj;
2645 public IUnknown(Object obj)
2646 {
2647 this.obj = obj;
2648 }
2649
2650 public Object getWrapped()
2651 {
2652 return this.obj;
2653 }
2654
2655 public void setWrapped(Object obj)
2656 {
2657 this.obj = obj;
2658 }
2659}
2660]]></xsl:text>
2661 </xsl:if>
2662
2663 <xsl:call-template name="endFile">
2664 <xsl:with-param name="file" select="'IUnknown.java'" />
2665 </xsl:call-template>
2666
2667 <xsl:call-template name="startFile">
2668 <xsl:with-param name="file" select="'Helper.java'" />
2669 <xsl:with-param name="package" select="$G_virtualBoxPackageCom" />
2670 </xsl:call-template>
2671
2672 <xsl:if test="$filelistonly=''">
2673 <xsl:text><![CDATA[
2674
2675import java.util.List;
2676import java.util.ArrayList;
2677import java.util.Collections;
2678import java.lang.reflect.Array;
2679import java.lang.reflect.Constructor;
2680import java.lang.reflect.Method;
2681import java.lang.reflect.InvocationTargetException;
2682
2683public class Helper
2684{
2685 public static List<Short> wrap(byte[] values)
2686 {
2687 if (values == null)
2688 return null;
2689
2690 List<Short> ret = new ArrayList<Short>(values.length);
2691 for (short v : values)
2692 {
2693 ret.add(v);
2694 }
2695 return ret;
2696 }
2697
2698 public static List<Short> wrap(short[] values)
2699 {
2700 if (values == null)
2701 return null;
2702
2703 List<Short> ret = new ArrayList<Short>(values.length);
2704 for (short v : values)
2705 {
2706 ret.add(v);
2707 }
2708 return ret;
2709 }
2710
2711 public static List<Integer> wrap(int[] values)
2712 {
2713 if (values == null)
2714 return null;
2715
2716 List<Integer> ret = new ArrayList<Integer>(values.length);
2717 for (int v : values)
2718 {
2719 ret.add(v);
2720 }
2721 return ret;
2722 }
2723
2724 public static List<Long> wrap(long[] values)
2725 {
2726 if (values == null)
2727 return null;
2728
2729 List<Long> ret = new ArrayList<Long>(values.length);
2730 for (long v : values)
2731 {
2732 ret.add(v);
2733 }
2734 return ret;
2735 }
2736
2737 public static List<Boolean> wrap(boolean[] values)
2738 {
2739 if (values == null)
2740 return null;
2741
2742 List<Boolean> ret = new ArrayList<Boolean>(values.length);
2743 for (boolean v: values)
2744 {
2745 ret.add(v);
2746 }
2747 return ret;
2748 }
2749
2750 public static List<String> wrap(String[] values)
2751 {
2752 if (values == null)
2753 return null;
2754
2755 List<String> ret = new ArrayList<String>(values.length);
2756 for (String v : values)
2757 {
2758 ret.add(v);
2759 }
2760 return ret;
2761 }
2762
2763 public static <T> List<T> wrap(Class<T> wrapperClass, T[] values)
2764 {
2765 if (values == null)
2766 return null;
2767
2768 List<T> ret = new ArrayList<T>(values.length);
2769 for (T v : values)
2770 {
2771 ret.add(v);
2772 }
2773 return ret;
2774 }
2775
2776 @SuppressWarnings( "unchecked")
2777 public static <T> List<T> wrapEnum(Class<T> wrapperClass, long values[])
2778 {
2779 try
2780 {
2781 if (values == null)
2782 return null;
2783 //// This code is questionable, as it invokes a private constructor
2784 //// (all enums only have default constructors), and we don't really
2785 //// know what to pass as the name, and the ordinal may or may not
2786 //// be sensible, especially if the long was abused as a bitset.
2787 //Constructor<T> c = wrapperClass.getDeclaredConstructor(String.class, int.class, int.class);
2788 //c.setAccessible(true); // make it callable
2789 //List<T> ret = new ArrayList<T>(values.length);
2790 //for (long v : values)
2791 //{
2792 // T convEnum = c.newInstance("unknown", (int)v, (int)v);
2793 // ret.add(convEnum);
2794 //}
2795
2796 // Alternative implementation: use the fromValue method, which is
2797 // what the code handling single enums will do. I see no reason to
2798 // use the above very ugly hack if there are better alternatives,
2799 // which as a bonus complain about unknown values. This variant is
2800 // slower, but also orders of magnitude safer.
2801 java.lang.reflect.Method fromValue = wrapperClass.getMethod("fromValue", long.class);
2802 List<T> ret = new ArrayList<T>(values.length);
2803 for (long v : values)
2804 {
2805 T convEnum = (T)fromValue.invoke(null, v);
2806 ret.add(convEnum);
2807 }
2808 return ret;
2809 }
2810 catch (NoSuchMethodException e)
2811 {
2812 throw new AssertionError(e);
2813 }
2814 //catch (InstantiationException e)
2815 //{
2816 // throw new AssertionError(e);
2817 //}
2818 catch (IllegalAccessException e)
2819 {
2820 throw new AssertionError(e);
2821 }
2822 catch (InvocationTargetException e)
2823 {
2824 throw new AssertionError(e);
2825 }
2826 }
2827 public static short[] unwrapUShort(List<Short> values)
2828 {
2829 if (values == null)
2830 return null;
2831
2832 short[] ret = new short[values.size()];
2833 int i = 0;
2834 for (short l : values)
2835 {
2836 ret[i++] = l;
2837 }
2838 return ret;
2839 }
2840
2841 public static int[] unwrapInteger(List<Integer> values)
2842 {
2843 if (values == null)
2844 return null;
2845
2846 int[] ret = new int[values.size()];
2847 int i = 0;
2848 for (int l : values)
2849 {
2850 ret[i++] = l;
2851 }
2852 return ret;
2853 }
2854
2855 public static long[] unwrapULong(List<Long> values)
2856 {
2857 if (values == null)
2858 return null;
2859
2860 long[] ret = new long[values.size()];
2861 int i = 0;
2862 for (long l : values)
2863 {
2864 ret[i++] = l;
2865 }
2866 return ret;
2867 }
2868
2869 public static boolean[] unwrapBoolean(List<Boolean> values)
2870 {
2871 if (values == null)
2872 return null;
2873
2874 boolean[] ret = new boolean[values.size()];
2875 int i = 0;
2876 for (boolean l : values)
2877 {
2878 ret[i++] = l;
2879 }
2880 return ret;
2881 }
2882
2883 public static String[] unwrapStr(List<String> values)
2884 {
2885 if (values == null)
2886 return null;
2887
2888 String[] ret = new String[values.size()];
2889 int i = 0;
2890 for (String l : values)
2891 {
2892 ret[i++] = l;
2893 }
2894 return ret;
2895 }
2896
2897 public static <T extends Enum <T>> long[] unwrapEnum(Class<T> enumClass, List<T> values)
2898 {
2899 if (values == null)
2900 return null;
2901
2902 long result[] = new long[values.size()];
2903 try
2904 {
2905 java.lang.reflect.Method valueM = enumClass.getMethod("value");
2906 int i = 0;
2907 for (T v : values)
2908 {
2909 result[i++] = (Integer)valueM.invoke(v);
2910 }
2911 return result;
2912 }
2913 catch (NoSuchMethodException e)
2914 {
2915 throw new AssertionError(e);
2916 }
2917 catch(SecurityException e)
2918 {
2919 throw new AssertionError(e);
2920 }
2921 catch (IllegalAccessException e)
2922 {
2923 throw new AssertionError(e);
2924 }
2925 catch (IllegalArgumentException e)
2926 {
2927 throw new AssertionError(e);
2928 }
2929 catch (InvocationTargetException e)
2930 {
2931 throw new AssertionError(e);
2932 }
2933 }
2934
2935 public static <T1, T2> List<T1> wrap2(Class<T1> wrapperClass1, Class<T2> wrapperClass2, T2[] values)
2936 {
2937 try
2938 {
2939 if (values == null)
2940 return null;
2941
2942 Constructor<T1> c = wrapperClass1.getConstructor(wrapperClass2);
2943 List<T1> ret = new ArrayList<T1>(values.length);
2944 for (T2 v : values)
2945 {
2946 ret.add(c.newInstance(v));
2947 }
2948 return ret;
2949 }
2950 catch (NoSuchMethodException e)
2951 {
2952 throw new AssertionError(e);
2953 }
2954 catch (InstantiationException e)
2955 {
2956 throw new AssertionError(e);
2957 }
2958 catch (IllegalAccessException e)
2959 {
2960 throw new AssertionError(e);
2961 }
2962 catch (InvocationTargetException e)
2963 {
2964 throw new AssertionError(e);
2965 }
2966 }
2967
2968 @SuppressWarnings( "unchecked")
2969 public static <T> T[] unwrap(Class<T> wrapperClass, List<T> values)
2970 {
2971 if (values == null)
2972 return null;
2973 if (values.size() == 0)
2974 return null;
2975 return (T[])values.toArray((T[])Array.newInstance(wrapperClass, values.size()));
2976 }
2977
2978 @SuppressWarnings( "unchecked" )
2979 public static <T> T queryInterface(Object obj, String uuid, Class<T> iface)
2980 {
2981 return (T)queryInterface(obj, uuid);
2982 }
2983
2984 public static Object queryInterface(Object obj, String uuid)
2985 {
2986 try
2987 {
2988 /* Kind of ugly, but does the job of casting */
2989 org.mozilla.xpcom.Mozilla moz = org.mozilla.xpcom.Mozilla.getInstance();
2990 long xpobj = moz.wrapJavaObject(obj, uuid);
2991 return moz.wrapXPCOMObject(xpobj, uuid);
2992 }
2993 catch (Exception e)
2994 {
2995 return null;
2996 }
2997 }
2998
2999 @SuppressWarnings("unchecked")
3000 public static <T1 extends IUnknown, T2> T2[] unwrap2(Class<T1> wrapperClass1, Class<T2> wrapperClass2, List<T1> values)
3001 {
3002 if (values == null)
3003 return null;
3004
3005 T2 ret[] = (T2[])Array.newInstance(wrapperClass2, values.size());
3006 int i = 0;
3007 for (T1 obj : values)
3008 {
3009 ret[i++] = (T2)obj.getWrapped();
3010 }
3011 return ret;
3012 }
3013}
3014]]></xsl:text>
3015 </xsl:if>
3016
3017 <xsl:call-template name="endFile">
3018 <xsl:with-param name="file" select="'Helper.java'" />
3019 </xsl:call-template>
3020
3021 <xsl:call-template name="startFile">
3022 <xsl:with-param name="file" select="'VBoxException.java'" />
3023 <xsl:with-param name="package" select="$G_virtualBoxPackage" />
3024 </xsl:call-template>
3025
3026 <xsl:if test="$filelistonly=''">
3027 <xsl:text>
3028import org.mozilla.xpcom.*;
3029
3030public class VBoxException extends RuntimeException
3031{
3032 private int resultCode;
3033 private IVirtualBoxErrorInfo errorInfo;
3034
3035 public VBoxException(String message)
3036 {
3037 super(message);
3038 resultCode = -1;
3039 errorInfo = null;
3040 }
3041
3042 public VBoxException(String message, Throwable cause)
3043 {
3044 super(message, cause);
3045 if (cause instanceof org.mozilla.xpcom.XPCOMException)
3046 {
3047 resultCode = (int)((org.mozilla.xpcom.XPCOMException)cause).errorcode;
3048 try
3049 {
3050 Mozilla mozilla = Mozilla.getInstance();
3051 nsIServiceManager sm = mozilla.getServiceManager();
3052 nsIExceptionService es = (nsIExceptionService)sm.getServiceByContractID("@mozilla.org/exceptionservice;1", nsIExceptionService.NS_IEXCEPTIONSERVICE_IID);
3053 nsIExceptionManager em = es.getCurrentExceptionManager();
3054 nsIException ex = em.getCurrentException();
3055 errorInfo = new IVirtualBoxErrorInfo((org.mozilla.interfaces.IVirtualBoxErrorInfo)ex.queryInterface(org.mozilla.interfaces.IVirtualBoxErrorInfo.IVIRTUALBOXERRORINFO_IID));
3056 }
3057 catch (NullPointerException e)
3058 {
3059 e.printStackTrace();
3060 // nothing we can do
3061 errorInfo = null;
3062 }
3063 }
3064 else
3065 resultCode = -1;
3066 }
3067
3068 public int getResultCode()
3069 {
3070 return resultCode;
3071 }
3072
3073 public IVirtualBoxErrorInfo getVirtualBoxErrorInfo()
3074 {
3075 return errorInfo;
3076 }
3077}
3078</xsl:text>
3079 </xsl:if>
3080
3081 <xsl:call-template name="endFile">
3082 <xsl:with-param name="file" select="'VBoxException.java'" />
3083 </xsl:call-template>
3084
3085 <xsl:call-template name="startFile">
3086 <xsl:with-param name="file" select="'VirtualBoxManager.java'" />
3087 <xsl:with-param name="package" select="$G_virtualBoxPackage" />
3088 </xsl:call-template>
3089
3090 <xsl:if test="$filelistonly=''">
3091 <xsl:text><![CDATA[
3092
3093import java.io.File;
3094
3095import org.mozilla.xpcom.*;
3096import org.mozilla.interfaces.*;
3097
3098public class VirtualBoxManager
3099{
3100 private Mozilla mozilla;
3101 private IVirtualBox vbox;
3102 private nsIComponentManager componentManager;
3103
3104 private VirtualBoxManager(Mozilla mozilla)
3105 {
3106 this.mozilla = mozilla;
3107 this.componentManager = mozilla.getComponentManager();
3108 this.vbox = new IVirtualBox((org.mozilla.interfaces.IVirtualBox) this.componentManager
3109 .createInstanceByContractID("@virtualbox.org/VirtualBox;1",
3110 null,
3111 org.mozilla.interfaces.IVirtualBox.IVIRTUALBOX_IID));
3112 }
3113
3114 public void connect(String url, String username, String passwd)
3115 {
3116 throw new VBoxException("Connect doesn't make sense for local bindings");
3117 }
3118
3119 public void disconnect()
3120 {
3121 throw new VBoxException("Disconnect doesn't make sense for local bindings");
3122 }
3123
3124 public static void initPerThread()
3125 {
3126 }
3127
3128 public static void deinitPerThread()
3129 {
3130 }
3131
3132 public IVirtualBox getVBox()
3133 {
3134 return this.vbox;
3135 }
3136
3137 public ISession getSessionObject()
3138 {
3139 return new ISession((org.mozilla.interfaces.ISession) componentManager
3140 .createInstanceByContractID("@virtualbox.org/Session;1", null,
3141 org.mozilla.interfaces.ISession.ISESSION_IID));
3142 }
3143
3144 public ISession openMachineSession(IMachine m) throws Exception
3145 {
3146 ISession s = getSessionObject();
3147 m.lockMachine(s, LockType.Shared);
3148 return s;
3149 }
3150
3151 public void closeMachineSession(ISession s)
3152 {
3153 if (s != null)
3154 s.unlockMachine();
3155 }
3156
3157 private static boolean hasInstance = false;
3158 private static boolean isMozillaInited = false;
3159
3160 public static synchronized VirtualBoxManager createInstance(String home)
3161 {
3162 if (hasInstance)
3163 throw new VBoxException("only one instance of VirtualBoxManager at a time allowed");
3164 if (home == null || home.equals(""))
3165 home = System.getProperty("vbox.home");
3166
3167 if (home == null)
3168 throw new VBoxException("vbox.home Java property must be defined to use XPCOM bridge");
3169
3170 File grePath = new File(home);
3171
3172 Mozilla mozilla = Mozilla.getInstance();
3173 if (!isMozillaInited)
3174 {
3175 mozilla.initialize(grePath);
3176 try
3177 {
3178 mozilla.initXPCOM(grePath, null);
3179 isMozillaInited = true;
3180 }
3181 catch (Exception e)
3182 {
3183 e.printStackTrace();
3184 return null;
3185 }
3186 }
3187
3188 hasInstance = true;
3189
3190 return new VirtualBoxManager(mozilla);
3191 }
3192
3193 public IEventListener createListener(Object sink)
3194 {
3195 return new IEventListener(new EventListenerImpl(sink));
3196 }
3197
3198 public void cleanup()
3199 {
3200 deinitPerThread();
3201 // cleanup, we don't do that, as XPCOM bridge doesn't cleanly
3202 // shuts down, so we prefer to avoid native shutdown
3203 // mozilla.shutdownXPCOM(null);
3204 mozilla = null;
3205 hasInstance = false;
3206 }
3207
3208 public void waitForEvents(long tmo)
3209 {
3210 mozilla.waitForEvents(tmo);
3211 }
3212}
3213]]></xsl:text>
3214 </xsl:if>
3215
3216 <xsl:call-template name="endFile">
3217 <xsl:with-param name="file" select="'VirtualBoxManager.java'" />
3218 </xsl:call-template>
3219
3220 <xsl:call-template name="startFile">
3221 <xsl:with-param name="file" select="'EventListenerImpl.java'" />
3222 <xsl:with-param name="package" select="$G_virtualBoxPackage" />
3223 </xsl:call-template>
3224
3225 <xsl:if test="$filelistonly=''">
3226 <xsl:text><![CDATA[
3227import org.mozilla.interfaces.*;
3228
3229public class EventListenerImpl extends nsISupportsBase implements org.mozilla.interfaces.IEventListener
3230{
3231 private Object obj;
3232 private java.lang.reflect.Method handleEvent;
3233 EventListenerImpl(Object obj)
3234 {
3235 this.obj = obj;
3236 try
3237 {
3238 this.handleEvent = obj.getClass().getMethod("handleEvent", IEvent.class);
3239 }
3240 catch (Exception e)
3241 {
3242 e.printStackTrace();
3243 }
3244 }
3245 public void handleEvent(org.mozilla.interfaces.IEvent ev)
3246 {
3247 try
3248 {
3249 if (obj != null && handleEvent != null)
3250 handleEvent.invoke(obj, ev != null ? new IEvent(ev) : null);
3251 }
3252 catch (Exception e)
3253 {
3254 e.printStackTrace();
3255 }
3256 }
3257}]]></xsl:text>
3258 </xsl:if>
3259
3260 <xsl:call-template name="endFile">
3261 <xsl:with-param name="file" select="'EventListenerImpl.java'" />
3262 </xsl:call-template>
3263
3264 <xsl:call-template name="startFile">
3265 <xsl:with-param name="file" select="'VBoxObjectBase.java'" />
3266 <xsl:with-param name="package" select="$G_virtualBoxPackage" />
3267 </xsl:call-template>
3268
3269 <xsl:if test="$filelistonly=''">
3270 <xsl:text><![CDATA[
3271abstract class nsISupportsBase implements org.mozilla.interfaces.nsISupports
3272{
3273 public org.mozilla.interfaces.nsISupports queryInterface(String iid)
3274 {
3275 return org.mozilla.xpcom.Mozilla.queryInterface(this, iid);
3276 }
3277}
3278
3279]]></xsl:text>
3280 </xsl:if>
3281
3282 <xsl:call-template name="endFile">
3283 <xsl:with-param name="file" select="'VBoxObjectBase.java'" />
3284 </xsl:call-template>
3285</xsl:template>
3286
3287
3288<xsl:template name="emitHandwrittenMscom">
3289
3290 <xsl:call-template name="startFile">
3291 <xsl:with-param name="file" select="'IUnknown.java'" />
3292 <xsl:with-param name="package" select="$G_virtualBoxPackageCom" />
3293 </xsl:call-template>
3294
3295 <xsl:if test="$filelistonly=''">
3296 <xsl:text><![CDATA[
3297public class IUnknown
3298{
3299 private Object obj;
3300 public IUnknown(Object obj)
3301 {
3302 this.obj = obj;
3303 }
3304
3305 public Object getWrapped()
3306 {
3307 return this.obj;
3308 }
3309
3310 public void setWrapped(Object obj)
3311 {
3312 this.obj = obj;
3313 }
3314}
3315]]></xsl:text>
3316 </xsl:if>
3317
3318 <xsl:call-template name="endFile">
3319 <xsl:with-param name="file" select="'IUnknown.java'" />
3320 </xsl:call-template>
3321
3322 <xsl:call-template name="startFile">
3323 <xsl:with-param name="file" select="'Helper.java'" />
3324 <xsl:with-param name="package" select="$G_virtualBoxPackageCom" />
3325 </xsl:call-template>
3326
3327 <xsl:if test="$filelistonly=''">
3328 <xsl:text><![CDATA[
3329
3330import java.util.List;
3331import java.util.ArrayList;
3332import java.util.Collections;
3333import java.lang.reflect.Array;
3334import java.lang.reflect.Constructor;
3335import java.lang.reflect.InvocationTargetException;
3336import com.jacob.com.*;
3337
3338public class Helper
3339{
3340 public static List<Short> wrap(short[] values)
3341 {
3342 if (values == null)
3343 return null;
3344
3345 List<Short> ret = new ArrayList<Short>(values.length);
3346 for (short v : values)
3347 {
3348 ret.add(v);
3349 }
3350 return ret;
3351 }
3352
3353 public static List<Integer> wrap(int[] values)
3354 {
3355 if (values == null)
3356 return null;
3357
3358 List<Integer> ret = new ArrayList<Integer>(values.length);
3359 for (int v : values)
3360 {
3361 ret.add(v);
3362 }
3363 return ret;
3364 }
3365
3366 public static List<Long> wrap(long[] values)
3367 {
3368 if (values == null)
3369 return null;
3370
3371 List<Long> ret = new ArrayList<Long>(values.length);
3372 for (long v : values)
3373 {
3374 ret.add(v);
3375 }
3376 return ret;
3377 }
3378
3379 public static List<String> wrap(String[] values)
3380 {
3381 if (values == null)
3382 return null;
3383
3384 List<String> ret = new ArrayList<String>(values.length);
3385 for (String v : values)
3386 {
3387 ret.add(v);
3388 }
3389 return ret;
3390 }
3391
3392 public static <T> T wrapDispatch(Class<T> wrapperClass, Dispatch d)
3393 {
3394 try
3395 {
3396 if (d == null || d.m_pDispatch == 0)
3397 return null;
3398 Constructor<T> c = wrapperClass.getConstructor(Dispatch.class);
3399 return (T)c.newInstance(d);
3400 }
3401 catch (NoSuchMethodException e)
3402 {
3403 throw new AssertionError(e);
3404 }
3405 catch (InstantiationException e)
3406 {
3407 throw new AssertionError(e);
3408 }
3409 catch (IllegalAccessException e)
3410 {
3411 throw new AssertionError(e);
3412 }
3413 catch (InvocationTargetException e)
3414 {
3415 throw new AssertionError(e);
3416 }
3417 }
3418
3419 @SuppressWarnings("unchecked")
3420 public static <T> Object wrapVariant(Class<T> wrapperClass, Variant v)
3421 {
3422 if (v == null)
3423 return null;
3424
3425 short vt = v.getvt();
3426 switch (vt)
3427 {
3428 case Variant.VariantNull:
3429 return null;
3430 case Variant.VariantBoolean:
3431 return v.getBoolean();
3432 case Variant.VariantByte:
3433 return v.getByte();
3434 case Variant.VariantShort:
3435 return v.getShort();
3436 case Variant.VariantInt:
3437 return v.getInt();
3438 case Variant.VariantLongInt:
3439 return v.getLong();
3440 case Variant.VariantString:
3441 return v.getString();
3442 case Variant.VariantDispatch:
3443 return wrapDispatch(wrapperClass, v.getDispatch());
3444 default:
3445 throw new IllegalArgumentException("unhandled variant type " + vt);
3446 }
3447 }
3448
3449 public static byte[] wrapBytes(SafeArray sa)
3450 {
3451 if (sa == null)
3452 return null;
3453
3454 int saLen = sa.getUBound() - sa.getLBound() + 1;
3455
3456 byte[] ret = new byte[saLen];
3457 int j = 0;
3458 for (int i = sa.getLBound(); i <= sa.getUBound(); i++)
3459 {
3460 Variant v = sa.getVariant(i);
3461 // come up with more effective approach!!!
3462 ret[j++] = v.getByte();
3463 }
3464 return ret;
3465 }
3466
3467 @SuppressWarnings("unchecked")
3468 public static <T> List<T> wrap(Class<T> wrapperClass, SafeArray sa)
3469 {
3470 if (sa == null)
3471 return null;
3472
3473 int saLen = sa.getUBound() - sa.getLBound() + 1;
3474 if (saLen == 0)
3475 return Collections.emptyList();
3476
3477 List<T> ret = new ArrayList<T>(saLen);
3478 for (int i = sa.getLBound(); i <= sa.getUBound(); i++)
3479 {
3480 Variant v = sa.getVariant(i);
3481 ret.add((T)wrapVariant(wrapperClass, v));
3482 }
3483 return ret;
3484 }
3485
3486 public static <T> List<T> wrapEnum(Class<T> wrapperClass, SafeArray sa)
3487 {
3488 try
3489 {
3490 if (sa == null)
3491 return null;
3492
3493 int saLen = sa.getUBound() - sa.getLBound() + 1;
3494 if (saLen == 0)
3495 return Collections.emptyList();
3496 List<T> ret = new ArrayList<T>(saLen);
3497 Constructor<T> c = wrapperClass.getConstructor(int.class);
3498 for (int i = sa.getLBound(); i <= sa.getUBound(); i++)
3499 {
3500 Variant v = sa.getVariant(i);
3501 ret.add(c.newInstance(v.getInt()));
3502 }
3503 return ret;
3504 }
3505 catch (NoSuchMethodException e)
3506 {
3507 throw new AssertionError(e);
3508 }
3509 catch (InstantiationException e)
3510 {
3511 throw new AssertionError(e);
3512 }
3513 catch (IllegalAccessException e)
3514 {
3515 throw new AssertionError(e);
3516 }
3517 catch (InvocationTargetException e)
3518 {
3519 throw new AssertionError(e);
3520 }
3521 }
3522
3523 public static SafeArray unwrapInt(List<Integer> values)
3524 {
3525 if (values == null)
3526 return null;
3527 SafeArray ret = new SafeArray(Variant.VariantInt, values.size());
3528 int i = 0;
3529 for (int l : values)
3530 {
3531 ret.setInt(i++, l);
3532 }
3533 return ret;
3534 }
3535
3536 public static SafeArray unwrapLong(List<Long> values)
3537 {
3538 if (values == null)
3539 return null;
3540 SafeArray ret = new SafeArray(Variant.VariantLongInt, values.size());
3541 int i = 0;
3542 for (long l : values)
3543 {
3544 ret.setLong(i++, l);
3545 }
3546 return ret;
3547 }
3548
3549 public static SafeArray unwrapBool(List<Boolean> values)
3550 {
3551 if (values == null)
3552 return null;
3553
3554 SafeArray result = new SafeArray(Variant.VariantBoolean, values.size());
3555 int i = 0;
3556 for (boolean l : values)
3557 {
3558 result.setBoolean(i++, l);
3559 }
3560 return result;
3561 }
3562
3563
3564 public static SafeArray unwrapBytes(byte[] values)
3565 {
3566 if (values == null)
3567 return null;
3568
3569 SafeArray result = new SafeArray(Variant.VariantByte, values.length);
3570 int i = 0;
3571 for (byte l : values)
3572 {
3573 result.setByte(i++, l);
3574 }
3575 return result;
3576 }
3577
3578
3579 public static <T extends Enum <T>> SafeArray unwrapEnum(Class<T> enumClass, List<T> values)
3580 {
3581 if (values == null)
3582 return null;
3583
3584 SafeArray result = new SafeArray(Variant.VariantInt, values.size());
3585 try
3586 {
3587 java.lang.reflect.Method valueM = enumClass.getMethod("value");
3588 int i = 0;
3589 for (T v : values)
3590 {
3591 result.setInt(i++, (Integer)valueM.invoke(v));
3592 }
3593 return result;
3594 }
3595 catch (NoSuchMethodException e)
3596 {
3597 throw new AssertionError(e);
3598 }
3599 catch(SecurityException e)
3600 {
3601 throw new AssertionError(e);
3602 }
3603 catch (IllegalAccessException e)
3604 {
3605 throw new AssertionError(e);
3606 }
3607 catch (IllegalArgumentException e)
3608 {
3609 throw new AssertionError(e);
3610 }
3611 catch (InvocationTargetException e)
3612 {
3613 throw new AssertionError(e);
3614 }
3615 }
3616 public static SafeArray unwrapString(List<String> values)
3617 {
3618 if (values == null)
3619 return null;
3620 SafeArray result = new SafeArray(Variant.VariantString, values.size());
3621 int i = 0;
3622 for (String l : values)
3623 {
3624 result.setString(i++, l);
3625 }
3626 return result;
3627 }
3628
3629 public static <T1, T2> List<T1> wrap2(Class<T1> wrapperClass1, Class<T2> wrapperClass2, T2[] values)
3630 {
3631 try
3632 {
3633 if (values == null)
3634 return null;
3635 if (values.length == 0)
3636 return Collections.emptyList();
3637
3638 Constructor<T1> c = wrapperClass1.getConstructor(wrapperClass2);
3639 List<T1> ret = new ArrayList<T1>(values.length);
3640 for (T2 v : values)
3641 {
3642 ret.add(c.newInstance(v));
3643 }
3644 return ret;
3645 }
3646 catch (NoSuchMethodException e)
3647 {
3648 throw new AssertionError(e);
3649 }
3650 catch (InstantiationException e)
3651 {
3652 throw new AssertionError(e);
3653 }
3654 catch (IllegalAccessException e)
3655 {
3656 throw new AssertionError(e);
3657 }
3658 catch (InvocationTargetException e)
3659 {
3660 throw new AssertionError(e);
3661 }
3662 }
3663
3664 @SuppressWarnings("unchecked")
3665 public static <T> T[] unwrap(Class<T> wrapperClass, List<T> values)
3666 {
3667 if (values == null)
3668 return null;
3669 return (T[])values.toArray((T[])Array.newInstance(wrapperClass, values.size()));
3670 }
3671
3672 @SuppressWarnings("unchecked")
3673 public static <T1 extends IUnknown, T2> T2[] unwrap2(Class<T1> wrapperClass1, Class<T2> wrapperClass2, List<T1> values)
3674 {
3675 if (values == null)
3676 return null;
3677
3678 T2 ret[] = (T2[])Array.newInstance(wrapperClass2, values.size());
3679 int i = 0;
3680 for (T1 obj : values)
3681 {
3682 ret[i++] = (T2)obj.getWrapped();
3683 }
3684 return ret;
3685 }
3686
3687 /* We have very long invoke lists sometimes */
3688 public static Variant invoke(Dispatch d, String method, Object ... args)
3689 {
3690 return Dispatch.callN(d, method, args);
3691 }
3692}
3693]]></xsl:text>
3694 </xsl:if>
3695
3696 <xsl:call-template name="endFile">
3697 <xsl:with-param name="file" select="'Helper.java'" />
3698 </xsl:call-template>
3699
3700 <xsl:call-template name="startFile">
3701 <xsl:with-param name="file" select="'VBoxException.java'" />
3702 <xsl:with-param name="package" select="$G_virtualBoxPackage" />
3703 </xsl:call-template>
3704
3705 <xsl:if test="$filelistonly=''">
3706 <xsl:text>
3707
3708public class VBoxException extends RuntimeException
3709{
3710 private int resultCode;
3711 private IVirtualBoxErrorInfo errorInfo;
3712
3713 public VBoxException(String message)
3714 {
3715 super(message);
3716 resultCode = -1;
3717 errorInfo = null;
3718 }
3719
3720 public VBoxException(String message, Throwable cause)
3721 {
3722 super(message, cause);
3723 if (cause instanceof com.jacob.com.ComException)
3724 {
3725 resultCode = ((com.jacob.com.ComException)cause).getHResult();
3726 // JACOB doesn't support calling GetErrorInfo, which
3727 // means there is no way of getting an IErrorInfo reference,
3728 // and that means no way of getting to IVirtualBoxErrorInfo.
3729 errorInfo = null;
3730 }
3731 else
3732 resultCode = -1;
3733 }
3734
3735 public int getResultCode()
3736 {
3737 return resultCode;
3738 }
3739
3740 public IVirtualBoxErrorInfo getVirtualBoxErrorInfo()
3741 {
3742 return errorInfo;
3743 }
3744}
3745</xsl:text>
3746 </xsl:if>
3747
3748 <xsl:call-template name="endFile">
3749 <xsl:with-param name="file" select="'VBoxException.java'" />
3750 </xsl:call-template>
3751
3752
3753 <xsl:call-template name="startFile">
3754 <xsl:with-param name="file" select="'VirtualBoxManager.java'" />
3755 <xsl:with-param name="package" select="$G_virtualBoxPackage" />
3756 </xsl:call-template>
3757
3758 <xsl:if test="$filelistonly=''">
3759 <xsl:text><![CDATA[
3760
3761import com.jacob.activeX.ActiveXComponent;
3762import com.jacob.com.ComThread;
3763import com.jacob.com.Dispatch;
3764import com.jacob.com.Variant;
3765import com.jacob.com.SafeArray;
3766import com.jacob.com.DispatchEvents;
3767
3768public class VirtualBoxManager
3769{
3770 private IVirtualBox vbox;
3771
3772 private VirtualBoxManager()
3773 {
3774 initPerThread();
3775 vbox = new IVirtualBox(new ActiveXComponent("VirtualBox.VirtualBox"));
3776 }
3777
3778 public static void initPerThread()
3779 {
3780 ComThread.InitMTA();
3781 }
3782
3783 public static void deinitPerThread()
3784 {
3785 ComThread.Release();
3786 }
3787
3788 public void connect(String url, String username, String passwd)
3789 {
3790 throw new VBoxException("Connect doesn't make sense for local bindings");
3791 }
3792
3793 public void disconnect()
3794 {
3795 throw new VBoxException("Disconnect doesn't make sense for local bindings");
3796 }
3797
3798 public IVirtualBox getVBox()
3799 {
3800 return this.vbox;
3801 }
3802
3803 public ISession getSessionObject()
3804 {
3805 return new ISession(new ActiveXComponent("VirtualBox.Session"));
3806 }
3807
3808 public ISession openMachineSession(IMachine m)
3809 {
3810 ISession s = getSessionObject();
3811 m.lockMachine(s, LockType.Shared);
3812 return s;
3813 }
3814
3815 public void closeMachineSession(ISession s)
3816 {
3817 if (s != null)
3818 s.unlockMachine();
3819 }
3820
3821 private static boolean hasInstance = false;
3822
3823 public static synchronized VirtualBoxManager createInstance(String home)
3824 {
3825 if (hasInstance)
3826 throw new VBoxException("only one instance of VirtualBoxManager at a time allowed");
3827
3828 hasInstance = true;
3829 return new VirtualBoxManager();
3830 }
3831
3832 public void cleanup()
3833 {
3834 deinitPerThread();
3835 hasInstance = false;
3836 }
3837
3838 public void waitForEvents(long tmo)
3839 {
3840 // what to do here?
3841 try
3842 {
3843 Thread.sleep(tmo);
3844 }
3845 catch (InterruptedException ie)
3846 {
3847 }
3848 }
3849}
3850]]></xsl:text>
3851 </xsl:if>
3852
3853 <xsl:call-template name="endFile">
3854 <xsl:with-param name="file" select="'VirtualBoxManager.java'" />
3855 </xsl:call-template>
3856</xsl:template>
3857
3858<xsl:template name="emitHandwrittenJaxws">
3859
3860 <xsl:call-template name="startFile">
3861 <xsl:with-param name="file" select="'IUnknown.java'" />
3862 <xsl:with-param name="package" select="$G_virtualBoxPackage" />
3863 </xsl:call-template>
3864
3865 <xsl:if test="$filelistonly=''">
3866 <xsl:text><![CDATA[
3867public class IUnknown
3868{
3869 protected String obj;
3870 protected final VboxPortType port;
3871
3872 public IUnknown(String obj, VboxPortType port)
3873 {
3874 this.obj = obj;
3875 this.port = port;
3876 }
3877
3878 public final String getWrapped()
3879 {
3880 return this.obj;
3881 }
3882
3883 public final VboxPortType getRemoteWSPort()
3884 {
3885 return this.port;
3886 }
3887
3888 public synchronized void releaseRemote() throws WebServiceException
3889 {
3890 if (obj == null)
3891 return;
3892
3893 try
3894 {
3895 this.port.iManagedObjectRefRelease(obj);
3896 this.obj = null;
3897 }
3898 catch (InvalidObjectFaultMsg e)
3899 {
3900 throw new WebServiceException(e);
3901 }
3902 catch (RuntimeFaultMsg e)
3903 {
3904 throw new WebServiceException(e);
3905 }
3906 }
3907}
3908]]></xsl:text>
3909 </xsl:if>
3910
3911 <xsl:call-template name="endFile">
3912 <xsl:with-param name="file" select="'IUnknown.java'" />
3913 </xsl:call-template>
3914
3915 <xsl:call-template name="startFile">
3916 <xsl:with-param name="file" select="'Helper.java'" />
3917 <xsl:with-param name="package" select="$G_virtualBoxPackage" />
3918 </xsl:call-template>
3919
3920 <xsl:if test="$filelistonly=''">
3921 <xsl:text><![CDATA[
3922
3923import java.util.List;
3924import java.util.ArrayList;
3925import java.util.Collections;
3926import java.lang.reflect.Array;
3927import java.lang.reflect.Constructor;
3928import java.lang.reflect.InvocationTargetException;
3929import java.math.BigInteger;
3930
3931public class Helper
3932{
3933 public static <T> List<T> wrap(Class<T> wrapperClass, VboxPortType pt, List<String> values)
3934 {
3935 try
3936 {
3937 if (values == null)
3938 return null;
3939
3940 Constructor<T> c = wrapperClass.getConstructor(String.class, VboxPortType.class);
3941 List<T> ret = new ArrayList<T>(values.size());
3942 for (String v : values)
3943 {
3944 ret.add(c.newInstance(v, pt));
3945 }
3946 return ret;
3947 }
3948 catch (NoSuchMethodException e)
3949 {
3950 throw new AssertionError(e);
3951 }
3952 catch (InstantiationException e)
3953 {
3954 throw new AssertionError(e);
3955 }
3956 catch (IllegalAccessException e)
3957 {
3958 throw new AssertionError(e);
3959 }
3960 catch (InvocationTargetException e)
3961 {
3962 throw new AssertionError(e);
3963 }
3964 }
3965
3966 public static <T1, T2> List<T1> wrap2(Class<T1> wrapperClass1, Class<T2> wrapperClass2, VboxPortType pt, List<T2> values)
3967 {
3968 try
3969 {
3970 if (values == null)
3971 return null;
3972
3973 Constructor<T1> c = wrapperClass1.getConstructor(wrapperClass2, VboxPortType.class);
3974 List<T1> ret = new ArrayList<T1>(values.size());
3975 for (T2 v : values)
3976 {
3977 ret.add(c.newInstance(v, pt));
3978 }
3979 return ret;
3980 }
3981 catch (NoSuchMethodException e)
3982 {
3983 throw new AssertionError(e);
3984 }
3985 catch (InstantiationException e)
3986 {
3987 throw new AssertionError(e);
3988 }
3989 catch (IllegalAccessException e)
3990 {
3991 throw new AssertionError(e);
3992 }
3993 catch (InvocationTargetException e)
3994 {
3995 throw new AssertionError(e);
3996 }
3997 }
3998
3999 public static <T extends IUnknown> List<String> unwrap(List<T> values)
4000 {
4001 if (values == null)
4002 return null;
4003
4004 List<String> ret = new ArrayList<String>(values.size());
4005 for (T obj : values)
4006 {
4007 ret.add(obj.getWrapped());
4008 }
4009 return ret;
4010 }
4011
4012 @SuppressWarnings("unchecked" )
4013 public static <T1 extends Enum <T1>, T2 extends Enum <T2>> List<T2> convertEnums(Class<T1> fromClass,
4014 Class<T2> toClass,
4015 List<T1> values)
4016 {
4017 try
4018 {
4019 if (values == null)
4020 return null;
4021 List<T2> ret = new ArrayList<T2>(values.size());
4022 for (T1 v : values)
4023 {
4024 // Ordinal based enum conversion, as JAX-WS "invents" its own
4025 // enum names and has string values with the expected content.
4026 int enumOrdinal = v.ordinal();
4027 T2 convEnum = toClass.getEnumConstants()[enumOrdinal];
4028 ret.add(convEnum);
4029 }
4030 return ret;
4031 }
4032 catch (ArrayIndexOutOfBoundsException e)
4033 {
4034 throw new AssertionError(e);
4035 }
4036 }
4037
4038 /* Pretty naive Base64 encoder/decoder. */
4039 private static final char[] valToChar = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".toCharArray();
4040 private static final int[] charToVal = new int[256];
4041
4042 /* Initialize recoding alphabet. */
4043 static
4044 {
4045 for (int i = 0; i < charToVal.length; i++)
4046 charToVal[i] = -1;
4047
4048 for (int i = 0; i < valToChar.length; i++)
4049 charToVal[valToChar[i]] = i;
4050
4051 charToVal['='] = 0;
4052 }
4053
4054 public static String encodeBase64(byte[] data)
4055 {
4056 if (data == null)
4057 return null;
4058
4059 if (data.length == 0)
4060 return "";
4061
4062 int fullTriplets = data.length / 3;
4063 int resultLen = ((data.length - 1) / 3 + 1) * 4;
4064 char[] result = new char[resultLen];
4065 int dataIndex = 0, stringIndex = 0;
4066
4067 for (int i = 0; i < fullTriplets; i++)
4068 {
4069 int ch1 = data[dataIndex++] & 0xff;
4070 result[stringIndex++] = valToChar[ch1 >> 2];
4071 int ch2 = data[dataIndex++] & 0xff;
4072 result[stringIndex++] = valToChar[((ch1 << 4) & 0x3f) | (ch2 >> 4)];
4073 int ch3 = data[dataIndex++] & 0xff;
4074 result[stringIndex++] = valToChar[((ch2 << 2) & 0x3f) | (ch3 >> 6)];
4075 result[stringIndex++] = valToChar[ch3 & 0x3f];
4076 }
4077
4078 switch (data.length - dataIndex)
4079 {
4080 case 0:
4081 // do nothing
4082 break;
4083 case 1:
4084 {
4085 int ch1 = data[dataIndex++] & 0xff;
4086 result[stringIndex++] = valToChar[ch1 >> 2];
4087 result[stringIndex++] = valToChar[(ch1 << 4) & 0x3f];
4088 result[stringIndex++] = '=';
4089 result[stringIndex++] = '=';
4090 break;
4091 }
4092 case 2:
4093 {
4094 int ch1 = data[dataIndex++] & 0xff;
4095 result[stringIndex++] = valToChar[ch1 >> 2];
4096 int ch2 = data[dataIndex++] & 0xff;
4097 result[stringIndex++] = valToChar[((ch1 << 4) & 0x3f) | (ch2 >> 4)];
4098 result[stringIndex++] = valToChar[(ch2 << 2) & 0x3f];
4099 result[stringIndex++] = '=';
4100 break;
4101 }
4102 default:
4103 throw new VBoxException("bug!");
4104 }
4105
4106 return new String(result);
4107 }
4108
4109 private static int skipInvalid(String str, int stringIndex)
4110 {
4111 while (charToVal[str.charAt(stringIndex)] < 0)
4112 stringIndex++;
4113
4114 return stringIndex;
4115 }
4116
4117 public static byte[] decodeBase64(String str)
4118 {
4119 if (str == null)
4120 return null;
4121
4122 int stringLength = str.length();
4123 if (stringLength == 0)
4124 return new byte[0];
4125
4126 int validChars = 0, padChars = 0;
4127 for (int i = 0; i < str.length(); i++)
4128 {
4129 char ch = str.charAt(i);
4130
4131 if (charToVal[ch] >= 0)
4132 validChars++;
4133
4134 if (ch == '=')
4135 padChars++;
4136 }
4137
4138 if ((validChars * 3 % 4) != 0)
4139 throw new VBoxException("invalid base64 encoded string " + str);
4140
4141 int resultLength = validChars * 3 / 4 - padChars;
4142 byte[] result = new byte[resultLength];
4143
4144 int dataIndex = 0, stringIndex = 0;
4145 int quadraplets = validChars / 4;
4146
4147 for (int i = 0; i < quadraplets; i++)
4148 {
4149 stringIndex = skipInvalid(str, stringIndex);
4150 int ch1 = str.charAt(stringIndex++);
4151 stringIndex = skipInvalid(str, stringIndex);
4152 int ch2 = str.charAt(stringIndex++);
4153 stringIndex = skipInvalid(str, stringIndex);
4154 int ch3 = str.charAt(stringIndex++);
4155 stringIndex = skipInvalid(str, stringIndex);
4156 int ch4 = str.charAt(stringIndex++);
4157
4158 result[dataIndex++] = (byte)(((charToVal[ch1] << 2) | charToVal[ch2] >> 4) & 0xff);
4159 /* we check this to ensure that we don't override data with '=' padding. */
4160 if (dataIndex < result.length)
4161 result[dataIndex++] = (byte)(((charToVal[ch2] << 4) | charToVal[ch3] >> 2) & 0xff);
4162 if (dataIndex < result.length)
4163 result[dataIndex++] = (byte)(((charToVal[ch3] << 6) | charToVal[ch4]) & 0xff);
4164 }
4165
4166 return result;
4167 }
4168}
4169]]></xsl:text>
4170 </xsl:if>
4171
4172 <xsl:call-template name="endFile">
4173 <xsl:with-param name="file" select="'Helper.java'" />
4174 </xsl:call-template>
4175
4176 <xsl:call-template name="startFile">
4177 <xsl:with-param name="file" select="'VBoxException.java'" />
4178 <xsl:with-param name="package" select="$G_virtualBoxPackage" />
4179 </xsl:call-template>
4180
4181 <xsl:if test="$filelistonly=''">
4182 <xsl:text>
4183public class VBoxException extends RuntimeException
4184{
4185 private int resultCode;
4186 private IVirtualBoxErrorInfo errorInfo;
4187
4188 public VBoxException(String message)
4189 {
4190 super(message);
4191 resultCode = -1;
4192 errorInfo = null;
4193 }
4194
4195 public VBoxException(String message, Throwable cause)
4196 {
4197 super(message, cause);
4198 resultCode = -1;
4199 errorInfo = null;
4200 }
4201
4202 public VBoxException(String message, Throwable cause, VboxPortType port)
4203 {
4204 super(message, cause);
4205 if (cause instanceof RuntimeFaultMsg)
4206 {
4207 RuntimeFaultMsg m = (RuntimeFaultMsg)cause;
4208 RuntimeFault f = m.getFaultInfo();
4209 resultCode = f.getResultCode();
4210 String retVal = f.getReturnval();
4211 errorInfo = (retVal.length() > 0) ? new IVirtualBoxErrorInfo(retVal, port) : null;
4212 }
4213 else
4214 resultCode = -1;
4215 }
4216
4217 public int getResultCode()
4218 {
4219 return resultCode;
4220 }
4221
4222 public IVirtualBoxErrorInfo getVirtualBoxErrorInfo()
4223 {
4224 return errorInfo;
4225 }
4226}
4227</xsl:text>
4228 </xsl:if>
4229
4230 <xsl:call-template name="endFile">
4231 <xsl:with-param name="file" select="'VBoxException.java'" />
4232 </xsl:call-template>
4233
4234 <xsl:call-template name="startFile">
4235 <xsl:with-param name="file" select="'VirtualBoxManager.java'" />
4236 <xsl:with-param name="package" select="$G_virtualBoxPackage" />
4237 </xsl:call-template>
4238
4239 <xsl:if test="$filelistonly=''">
4240 <xsl:text>import java.net.URL;
4241import java.math.BigInteger;
4242import java.util.List;
4243import java.util.Map;
4244import java.util.HashMap;
4245import javax.xml.namespace.QName;
4246import javax.xml.ws.BindingProvider;
4247import javax.xml.ws.Holder;
4248import javax.xml.ws.WebServiceException;
4249
4250class PortPool
4251{
4252 private final static String wsdlFile = </xsl:text>
4253 <xsl:value-of select="$G_virtualBoxWsdl" />
4254 <xsl:text><![CDATA[;
4255 private Map<VboxPortType, Integer> known;
4256 private boolean initStarted;
4257 private VboxService svc;
4258
4259 PortPool(boolean usePreinit)
4260 {
4261 known = new HashMap<VboxPortType, Integer>();
4262
4263 if (usePreinit)
4264 {
4265 new Thread(new Runnable()
4266 {
4267 public void run()
4268 {
4269 // need to sync on something else but 'this'
4270 synchronized (known)
4271 {
4272 initStarted = true;
4273 known.notify();
4274 }
4275
4276 preinit();
4277 }
4278 }).start();
4279
4280 synchronized (known)
4281 {
4282 while (!initStarted)
4283 {
4284 try
4285 {
4286 known.wait();
4287 }
4288 catch (InterruptedException e)
4289 {
4290 break;
4291 }
4292 }
4293 }
4294 }
4295 }
4296
4297 private synchronized void preinit()
4298 {
4299 VboxPortType port = getPort();
4300 releasePort(port);
4301 }
4302
4303 synchronized VboxPortType getPort()
4304 {
4305 VboxPortType port = null;
4306 int ttl = 0;
4307
4308 for (VboxPortType cur: known.keySet())
4309 {
4310 int value = known.get(cur);
4311 if ((value & 0x10000) == 0)
4312 {
4313 port = cur;
4314 ttl = value & 0xffff;
4315 break;
4316 }
4317 }
4318
4319 if (port == null)
4320 {
4321 if (svc == null)
4322 {
4323 URL wsdl = PortPool.class.getClassLoader().getResource(wsdlFile);
4324 if (wsdl == null)
4325 throw new LinkageError(wsdlFile + " not found, but it should have been in the jar");
4326 svc = new VboxService(wsdl,
4327 new QName("http://www.alldomusa.eu.org/Service",
4328 "vboxService"));
4329 }
4330 port = svc.getVboxServicePort();
4331 // reuse this object 0x10 times
4332 ttl = 0x10;
4333 }
4334 // mark as used
4335 known.put(port, new Integer(0x10000 | ttl));
4336 return port;
4337 }
4338
4339 synchronized void releasePort(VboxPortType port)
4340 {
4341 Integer val = known.get(port);
4342 if (val == null || val == 0)
4343 {
4344 // know you not
4345 return;
4346 }
4347
4348 int v = val;
4349 int ttl = v & 0xffff;
4350 // decrement TTL, and throw away port if used too much times
4351 if (--ttl <= 0)
4352 {
4353 known.remove(port);
4354 }
4355 else
4356 {
4357 v = ttl; // set new TTL and clear busy bit
4358 known.put(port, v);
4359 }
4360 }
4361}
4362
4363
4364public class VirtualBoxManager
4365{
4366 private static PortPool pool = new PortPool(true);
4367 protected VboxPortType port;
4368
4369 private IVirtualBox vbox;
4370
4371 private VirtualBoxManager()
4372 {
4373 }
4374
4375 public static void initPerThread()
4376 {
4377 }
4378
4379 public static void deinitPerThread()
4380 {
4381 }
4382
4383 public void connect(String url, String username, String passwd)
4384 {
4385 this.port = pool.getPort();
4386 try
4387 {
4388 ((BindingProvider)port).getRequestContext().
4389 put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, url);
4390 String handle = port.iWebsessionManagerLogon(username, passwd);
4391 this.vbox = new IVirtualBox(handle, port);
4392 }
4393 catch (Throwable t)
4394 {
4395 if (this.port != null && pool != null)
4396 {
4397 pool.releasePort(this.port);
4398 this.port = null;
4399 }
4400 // we have to throw smth derived from RuntimeException
4401 throw new VBoxException(t.getMessage(), t, this.port);
4402 }
4403 }
4404
4405 public void connect(String url, String username, String passwd,
4406 Map<String, Object> requestContext, Map<String, Object> responseContext)
4407 {
4408 this.port = pool.getPort();
4409
4410 try
4411 {
4412 ((BindingProvider)port).getRequestContext();
4413 if (requestContext != null)
4414 ((BindingProvider)port).getRequestContext().putAll(requestContext);
4415
4416 if (responseContext != null)
4417 ((BindingProvider)port).getResponseContext().putAll(responseContext);
4418
4419 ((BindingProvider)port).getRequestContext().
4420 put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, url);
4421 String handle = port.iWebsessionManagerLogon(username, passwd);
4422 this.vbox = new IVirtualBox(handle, port);
4423 }
4424 catch (Throwable t)
4425 {
4426 if (this.port != null && pool != null)
4427 {
4428 pool.releasePort(this.port);
4429 this.port = null;
4430 }
4431 // we have to throw smth derived from RuntimeException
4432 throw new VBoxException(t.getMessage(), t, this.port);
4433 }
4434 }
4435
4436 public void disconnect()
4437 {
4438 if (this.port == null)
4439 return;
4440
4441 try
4442 {
4443 if (this.vbox != null && port != null)
4444 port.iWebsessionManagerLogoff(this.vbox.getWrapped());
4445 }
4446 catch (InvalidObjectFaultMsg e)
4447 {
4448 throw new VBoxException(e.getMessage(), e, this.port);
4449 }
4450 catch (RuntimeFaultMsg e)
4451 {
4452 throw new VBoxException(e.getMessage(), e, this.port);
4453 }
4454 finally
4455 {
4456 if (this.port != null)
4457 {
4458 pool.releasePort(this.port);
4459 this.port = null;
4460 }
4461 }
4462 }
4463
4464 public IVirtualBox getVBox()
4465 {
4466 return this.vbox;
4467 }
4468
4469 public ISession getSessionObject()
4470 {
4471 if (this.vbox == null)
4472 throw new VBoxException("connect first");
4473 try
4474 {
4475 String handle = port.iWebsessionManagerGetSessionObject(this.vbox.getWrapped());
4476 return new ISession(handle, port);
4477 }
4478 catch (InvalidObjectFaultMsg e)
4479 {
4480 throw new VBoxException(e.getMessage(), e, this.port);
4481 }
4482 catch (RuntimeFaultMsg e)
4483 {
4484 throw new VBoxException(e.getMessage(), e, this.port);
4485 }
4486 }
4487
4488 public ISession openMachineSession(IMachine m) throws Exception
4489 {
4490 ISession s = getSessionObject();
4491 m.lockMachine(s, LockType.Shared);
4492 return s;
4493 }
4494
4495 public void closeMachineSession(ISession s)
4496 {
4497 if (s != null)
4498 s.unlockMachine();
4499 }
4500
4501 public static synchronized VirtualBoxManager createInstance(String home)
4502 {
4503 return new VirtualBoxManager();
4504 }
4505
4506 public IEventListener createListener(Object sink)
4507 {
4508 throw new VBoxException("no active listeners here");
4509 }
4510
4511 public void cleanup()
4512 {
4513 disconnect();
4514 deinitPerThread();
4515 }
4516
4517 public void waitForEvents(long tmo)
4518 {
4519 }
4520
4521 protected void finalize() throws Throwable
4522 {
4523 try
4524 {
4525 cleanup();
4526 }
4527 catch(Exception e)
4528 {
4529 }
4530 finally
4531 {
4532 super.finalize();
4533 }
4534 }
4535}
4536]]></xsl:text>
4537 </xsl:if>
4538
4539 <xsl:call-template name="endFile">
4540 <xsl:with-param name="file" select="'VirtualBoxManager.java'" />
4541 </xsl:call-template>
4542</xsl:template>
4543
4544
4545<xsl:template match="/">
4546
4547 <xsl:if test="not($G_vboxApiSuffix)">
4548 <xsl:call-template name="fatalError">
4549 <xsl:with-param name="msg" select="'G_vboxApiSuffix must be given'" />
4550 </xsl:call-template>
4551 </xsl:if>
4552
4553 <xsl:if test="not($filelistonly='')">
4554 <xsl:value-of select="concat($filelistonly, ' := \&#10;')"/>
4555 </xsl:if>
4556
4557 <!-- Handwritten files -->
4558 <xsl:call-template name="emitHandwritten"/>
4559
4560 <xsl:choose>
4561 <xsl:when test="$G_vboxGlueStyle='xpcom'">
4562 <xsl:call-template name="emitHandwrittenXpcom"/>
4563 </xsl:when>
4564
4565 <xsl:when test="$G_vboxGlueStyle='mscom'">
4566 <xsl:call-template name="emitHandwrittenMscom"/>
4567 </xsl:when>
4568
4569 <xsl:when test="$G_vboxGlueStyle='jaxws'">
4570 <xsl:call-template name="emitHandwrittenJaxws"/>
4571 </xsl:when>
4572
4573 <xsl:otherwise>
4574 <xsl:call-template name="fatalError">
4575 <xsl:with-param name="msg" select="'Style unknown (root)'" />
4576 </xsl:call-template>
4577 </xsl:otherwise>
4578 </xsl:choose>
4579
4580 <!-- Enums -->
4581 <xsl:for-each select="//enum">
4582 <xsl:call-template name="genEnum">
4583 <xsl:with-param name="enumname" select="@name" />
4584 <xsl:with-param name="filename" select="concat(@name, '.java')" />
4585 </xsl:call-template>
4586 </xsl:for-each>
4587
4588 <!-- Interfaces -->
4589 <xsl:for-each select="//interface">
4590 <xsl:variable name="self_target" select="current()/ancestor::if/@target"/>
4591 <xsl:variable name="module" select="current()/ancestor::module/@name"/>
4592
4593 <xsl:choose>
4594 <xsl:when test="$G_vboxGlueStyle='jaxws'">
4595 <xsl:if test="not($module) and not(@wsmap='suppress')">
4596 <xsl:call-template name="genIface">
4597 <xsl:with-param name="ifname" select="@name" />
4598 <xsl:with-param name="filename" select="concat(@name, '.java')" />
4599 </xsl:call-template>
4600 </xsl:if>
4601 </xsl:when>
4602
4603 <xsl:otherwise>
4604 <!-- We don't need WSDL-specific interfaces here -->
4605 <xsl:if test="not($self_target='wsdl') and not($module)">
4606 <xsl:call-template name="genIface">
4607 <xsl:with-param name="ifname" select="@name" />
4608 <xsl:with-param name="filename" select="concat(@name, '.java')" />
4609 </xsl:call-template>
4610 </xsl:if>
4611 </xsl:otherwise>
4612
4613 </xsl:choose>
4614 </xsl:for-each>
4615
4616 <xsl:if test="not($filelistonly='')">
4617 <xsl:value-of select="'&#10;'"/>
4618 </xsl:if>
4619
4620</xsl:template>
4621</xsl:stylesheet>
注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

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