VirtualBox

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

Last change on this file since 52320 was 51448, checked in by vboxsync, 11 years ago

Main/glue-java.xsl: fix the check, it was a bit too paranoid
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 149.5 KB
Line 
1<xsl:stylesheet version = '1.0'
2 xmlns:xsl='http://www.w3.org/1999/XSL/Transform'
3 xmlns:vbox="http://www.virtualbox.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.virtualbox.org. This file is free software;
17 you can redistribute it and/or modify it under the terms of the GNU
18 General Public License (GPL) as published by the Free Software
19 Foundation, in version 2 as it comes in the "COPYING" file of the
20 VirtualBox OSE distribution. VirtualBox OSE is distributed in the
21 hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
22-->
23
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.virtualbox.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="count(param[@dir='out']) > 0" />
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 (string-length(@wsmap) = 0) and (count(param[@dir='out']) = 1)">
1910 <xsl:call-template name="fatalError">
1911 <xsl:with-param name="msg" select="concat('genMethod: ', $ifname, $hasOutParms, not($hasReturnParms), 'a', string-length(@wsmap) = 0, 'b', @wsmap, (count(param[@dir='out']) = 1), '::', $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="returnidltype" select="param[@dir='return']/@type" />
2168 <xsl:variable name="returnidlsafearray" select="param[@dir='return']/@safearray" />
2169 <xsl:variable name="returnbacktype">
2170 <xsl:choose>
2171 <xsl:when test="$returnidltype">
2172 <xsl:call-template name="typeIdl2Back">
2173 <xsl:with-param name="type" select="$returnidltype" />
2174 <xsl:with-param name="safearray" select="$returnidlsafearray" />
2175 </xsl:call-template>
2176 </xsl:when>
2177 <xsl:otherwise>
2178 <xsl:text>void</xsl:text>
2179 </xsl:otherwise>
2180 </xsl:choose>
2181 </xsl:variable>
2182 <xsl:variable name="paramsinout" select="param[@dir='in' or @dir='out']" />
2183 <xsl:choose>
2184 <xsl:when test="$G_vboxGlueStyle='xpcom'">
2185 <xsl:value-of select="concat(' public ', $returnbacktype, ' ', $methodname, '(')" />
2186 <xsl:for-each select="exsl:node-set($paramsinout)">
2187 <xsl:variable name="parambacktype">
2188 <xsl:call-template name="typeIdl2Back">
2189 <xsl:with-param name="type" select="@type" />
2190 <xsl:with-param name="safearray" select="@safearray" />
2191 </xsl:call-template>
2192 </xsl:variable>
2193 <xsl:choose>
2194 <xsl:when test="@dir='out'">
2195 <xsl:value-of select="concat($parambacktype, '[] ', @name)" />
2196 </xsl:when>
2197 <xsl:otherwise>
2198 <xsl:if test="@safearray">
2199 <xsl:value-of select="concat('long len_', @name, ', ')" />
2200 </xsl:if>
2201 <xsl:value-of select="concat($parambacktype, ' ', @name)" />
2202 </xsl:otherwise>
2203 </xsl:choose>
2204 <xsl:if test="not(position()=last())">
2205 <xsl:text>, </xsl:text>
2206 </xsl:if>
2207 </xsl:for-each>
2208 <xsl:text>)&#10;</xsl:text>
2209 <xsl:text> {&#10;</xsl:text>
2210 </xsl:when>
2211
2212 <xsl:when test="$G_vboxGlueStyle='mscom'">
2213 <xsl:variable name="capsname">
2214 <xsl:call-template name="capitalize">
2215 <xsl:with-param name="str" select="$methodname" />
2216 </xsl:call-template>
2217 </xsl:variable>
2218 <xsl:value-of select="concat(' public ', $returnbacktype, ' ', $capsname, '(')" />
2219 <xsl:text>Variant _args[])&#10;</xsl:text>
2220 <xsl:text> {&#10;</xsl:text>
2221 <xsl:for-each select="exsl:node-set($paramsinout)">
2222 <xsl:variable name="parambacktype">
2223 <xsl:call-template name="typeIdl2Back">
2224 <xsl:with-param name="type" select="@type" />
2225 <xsl:with-param name="safearray" select="@safearray" />
2226 </xsl:call-template>
2227 </xsl:variable>
2228 <xsl:value-of select="concat(' ', $parambacktype, ' ', @name, '=_args[', count(preceding-sibling::param), '];&#10;')" />
2229 </xsl:for-each>
2230 </xsl:when>
2231
2232 <xsl:otherwise>
2233 <xsl:call-template name="fatalError">
2234 <xsl:with-param name="msg" select="'Style unknown (genSetterCall)'" />
2235 </xsl:call-template>
2236 </xsl:otherwise>
2237 </xsl:choose>
2238
2239 <!-- declare temp out params -->
2240 <xsl:for-each select="param[@dir='out']">
2241 <xsl:variable name="glueouttype">
2242 <xsl:call-template name="typeIdl2Glue">
2243 <xsl:with-param name="type" select="@type" />
2244 <xsl:with-param name="safearray" select="@safearray" />
2245 </xsl:call-template>
2246 </xsl:variable>
2247 <xsl:value-of select="concat(' Holder&lt;', $glueouttype, '&gt; tmp_', @name, ' = new Holder&lt;', $glueouttype, '&gt;();&#10;')"/>
2248 </xsl:for-each>
2249
2250 <!-- declare return param, if any -->
2251 <xsl:if test="$hasReturnParms">
2252 <xsl:variable name="gluerettype">
2253 <xsl:call-template name="typeIdl2Glue">
2254 <xsl:with-param name="type" select="$returnidltype" />
2255 <xsl:with-param name="safearray" select="$returnidlsafearray" />
2256 </xsl:call-template>
2257 </xsl:variable>
2258 <xsl:value-of select="concat(' ', $gluerettype, ' retVal = &#10;')"/>
2259 </xsl:if>
2260
2261 <!-- Method call -->
2262 <xsl:value-of select="concat(' sink.', $methodname, '(')"/>
2263 <xsl:for-each select="param[not(@dir='return')]">
2264 <xsl:choose>
2265 <xsl:when test="@dir='out'">
2266 <xsl:value-of select="concat('tmp_', @name)" />
2267 </xsl:when>
2268 <xsl:when test="@dir='in'">
2269 <xsl:variable name="wrapped">
2270 <xsl:call-template name="cookOutParam">
2271 <xsl:with-param name="value" select="@name" />
2272 <xsl:with-param name="idltype" select="@type" />
2273 <xsl:with-param name="safearray" select="@safearray" />
2274 </xsl:call-template>
2275 </xsl:variable>
2276 <xsl:value-of select="$wrapped"/>
2277 </xsl:when>
2278 <xsl:otherwise>
2279 <xsl:call-template name="fatalError">
2280 <xsl:with-param name="msg" select="concat('Unsupported param dir: ', @dir, '&quot;.')" />
2281 </xsl:call-template>
2282 </xsl:otherwise>
2283 </xsl:choose>
2284 <xsl:if test="not(position()=last())">
2285 <xsl:text>, </xsl:text>
2286 </xsl:if>
2287 </xsl:for-each>
2288 <xsl:text>);&#10;</xsl:text>
2289
2290 <!-- return out params -->
2291 <xsl:for-each select="param[@dir='out']">
2292
2293 <xsl:variable name="unwrapped">
2294 <xsl:call-template name="cookInParam">
2295 <xsl:with-param name="value" select="concat('tmp_', @name, '.value')" />
2296 <xsl:with-param name="idltype" select="@type" />
2297 <xsl:with-param name="safearray" select="@safearray" />
2298 </xsl:call-template>
2299 </xsl:variable>
2300 <xsl:choose>
2301 <xsl:when test="$G_vboxGlueStyle='xpcom'">
2302 <xsl:value-of select="concat(' ', @name, '[0] = ', $unwrapped, ';&#10;')"/>
2303 </xsl:when>
2304 <xsl:when test="$G_vboxGlueStyle='mscom'">
2305 <xsl:value-of select="concat(' _args[', count(preceding-sibling::param), '] = ', $unwrapped, ';&#10;')"/>
2306 </xsl:when>
2307 </xsl:choose>
2308 </xsl:for-each>
2309
2310 <xsl:if test="$hasReturnParms">
2311 <!-- actual 'return' statement -->
2312 <xsl:variable name="unwrapped">
2313 <xsl:call-template name="cookInParam">
2314 <xsl:with-param name="value" select="'retVal'" />
2315 <xsl:with-param name="idltype" select="$returnidltype" />
2316 <xsl:with-param name="safearray" select="$returnidlsafearray" />
2317 </xsl:call-template>
2318 </xsl:variable>
2319 <xsl:value-of select="concat(' return ', $unwrapped, ';&#10;')" />
2320 </xsl:if>
2321 <xsl:text> }&#10;</xsl:text>
2322 </xsl:otherwise>
2323 </xsl:choose>
2324</xsl:template>
2325
2326<!-- Interface method -->
2327<xsl:template name="genIfaceWrapper">
2328 <xsl:param name="ifname"/>
2329
2330 <xsl:variable name="wrappedType">
2331 <xsl:call-template name="wrappedName">
2332 <xsl:with-param name="ifname" select="$ifname" />
2333 </xsl:call-template>
2334 </xsl:variable>
2335
2336 <!-- Constructor -->
2337 <xsl:choose>
2338 <xsl:when test="($G_vboxGlueStyle='jaxws')">
2339 <xsl:value-of select="concat(' public ', $ifname, '(String wrapped, VboxPortType port)&#10;')" />
2340 <xsl:text> {&#10;</xsl:text>
2341 <xsl:text> super(wrapped, port);&#10;</xsl:text>
2342 <xsl:text> }&#10;</xsl:text>
2343 </xsl:when>
2344
2345 <xsl:when test="($G_vboxGlueStyle='xpcom') or ($G_vboxGlueStyle='mscom')">
2346 <xsl:value-of select="concat(' public ', $ifname, '(', $wrappedType, ' wrapped)&#10;')" />
2347 <xsl:text> {&#10;</xsl:text>
2348 <xsl:text> super(wrapped);&#10;</xsl:text>
2349 <xsl:text> }&#10;</xsl:text>
2350
2351 <!-- Typed wrapped object accessor -->
2352 <xsl:value-of select="concat(' public ', $wrappedType, ' getTypedWrapped()&#10;')" />
2353 <xsl:text> {&#10;</xsl:text>
2354 <xsl:value-of select="concat(' return (', $wrappedType, ') getWrapped();&#10;')" />
2355 <xsl:text> }&#10;</xsl:text>
2356 </xsl:when>
2357
2358 <xsl:otherwise>
2359 <xsl:call-template name="fatalError">
2360 <xsl:with-param name="msg" select="'Style unknown (root, ctr)'" />
2361 </xsl:call-template>
2362 </xsl:otherwise>
2363 </xsl:choose>
2364 <!-- Attributes -->
2365 <xsl:for-each select="attribute[not(@mod='ptr')]">
2366 <xsl:variable name="attrname"><xsl:value-of select="@name" /></xsl:variable>
2367 <xsl:variable name="attrtype"><xsl:value-of select="@type" /></xsl:variable>
2368 <xsl:variable name="attrsafearray"><xsl:value-of select="@safearray" /></xsl:variable>
2369
2370 <xsl:choose>
2371 <xsl:when test="($G_vboxGlueStyle='jaxws') and ($attrtype=($G_setSuppressedInterfaces/@name))">
2372 <xsl:value-of select="concat(' // Skipping attribute ', $attrname, ' of suppressed type ', $attrtype, '&#10;&#10;')" />
2373 </xsl:when>
2374 <xsl:when test="($G_vboxGlueStyle='jaxws') and (@wsmap = 'suppress')" >
2375 <xsl:value-of select="concat(' // Skipping attribute ', $attrname, ' for it is suppressed&#10;')" />
2376 </xsl:when>
2377
2378 <xsl:otherwise>
2379 <!-- emit getter method -->
2380 <xsl:apply-templates select="desc" mode="attribute_get"/>
2381 <xsl:variable name="gettername">
2382 <xsl:call-template name="makeGetterName">
2383 <xsl:with-param name="attrname" select="$attrname" />
2384 </xsl:call-template>
2385 </xsl:variable>
2386 <xsl:variable name="gluetype">
2387 <xsl:call-template name="typeIdl2Glue">
2388 <xsl:with-param name="type" select="$attrtype" />
2389 <xsl:with-param name="safearray" select="@safearray" />
2390 </xsl:call-template>
2391 </xsl:variable>
2392 <xsl:variable name="backtype">
2393 <xsl:call-template name="typeIdl2Back">
2394 <xsl:with-param name="type" select="$attrtype" />
2395 <xsl:with-param name="safearray" select="@safearray" />
2396 </xsl:call-template>
2397 </xsl:variable>
2398 <xsl:variable name="wrapped">
2399 <xsl:call-template name="cookOutParam">
2400 <xsl:with-param name="value" select="'retVal'" />
2401 <xsl:with-param name="idltype" select="$attrtype" />
2402 <xsl:with-param name="safearray" select="@safearray" />
2403 </xsl:call-template>
2404 </xsl:variable>
2405 <xsl:value-of select="concat(' public ', $gluetype, ' ', $gettername, '()&#10;')" />
2406 <xsl:text> {&#10;</xsl:text>
2407
2408 <xsl:call-template name="startExcWrapper"/>
2409
2410 <!-- Actual getter implementation -->
2411 <xsl:call-template name="genGetterCall">
2412 <xsl:with-param name="ifname" select="$ifname" />
2413 <xsl:with-param name="gettername" select="$gettername" />
2414 <xsl:with-param name="backtype" select="$backtype" />
2415 <xsl:with-param name="retval" select="'retVal'" />
2416 </xsl:call-template>
2417
2418 <xsl:value-of select="concat(' return ', $wrapped, ';&#10;')" />
2419 <xsl:call-template name="endExcWrapper"/>
2420
2421 <xsl:text> }&#10;</xsl:text>
2422 <xsl:if test="not(@readonly = 'yes')">
2423 <!-- emit setter method -->
2424 <xsl:apply-templates select="desc" mode="attribute_set"/>
2425 <xsl:variable name="settername"><xsl:call-template name="makeSetterName"><xsl:with-param name="attrname" select="$attrname" /></xsl:call-template></xsl:variable>
2426 <xsl:variable name="unwrapped">
2427 <xsl:call-template name="cookInParam">
2428 <xsl:with-param name="ifname" select="$ifname" />
2429 <xsl:with-param name="value" select="'value'" />
2430 <xsl:with-param name="idltype" select="$attrtype" />
2431 <xsl:with-param name="safearray" select="@safearray" />
2432 </xsl:call-template>
2433 </xsl:variable>
2434 <xsl:value-of select="concat(' public void ', $settername, '(', $gluetype, ' value)&#10;')" />
2435 <xsl:text> {&#10;</xsl:text>
2436 <xsl:call-template name="startExcWrapper"/>
2437 <!-- Actual setter implementation -->
2438 <xsl:call-template name="genSetterCall">
2439 <xsl:with-param name="ifname" select="$ifname" />
2440 <xsl:with-param name="settername" select="$settername" />
2441 <xsl:with-param name="value" select="$unwrapped" />
2442 </xsl:call-template>
2443 <xsl:call-template name="endExcWrapper"/>
2444 <xsl:text> }&#10;</xsl:text>
2445 </xsl:if>
2446
2447 </xsl:otherwise>
2448 </xsl:choose>
2449
2450 </xsl:for-each>
2451
2452 <!-- emit queryInterface() *to* this class -->
2453 <xsl:call-template name="genQI">
2454 <xsl:with-param name="ifname" select="$ifname" />
2455 <xsl:with-param name="uuid" select="@uuid" />
2456 </xsl:call-template>
2457
2458 <!-- emit methods -->
2459 <xsl:for-each select="method">
2460 <xsl:call-template name="genMethod">
2461 <xsl:with-param name="ifname" select="$ifname" />
2462 <xsl:with-param name="methodname" select="@name" />
2463 </xsl:call-template>
2464 </xsl:for-each>
2465
2466</xsl:template>
2467
2468<xsl:template name="genIface">
2469 <xsl:param name="ifname" />
2470 <xsl:param name="filename" />
2471
2472 <xsl:variable name="wsmap" select="@wsmap" />
2473
2474 <xsl:call-template name="startFile">
2475 <xsl:with-param name="file" select="$filename" />
2476 <xsl:with-param name="package" select="$G_virtualBoxPackage" />
2477 </xsl:call-template>
2478
2479 <xsl:if test="$filelistonly=''">
2480 <xsl:text>import java.util.List;&#10;&#10;</xsl:text>
2481
2482 <xsl:apply-templates select="desc" mode="interface"/>
2483
2484 <xsl:choose>
2485 <xsl:when test="($wsmap='struct') and ($G_vboxGlueStyle='jaxws')">
2486 <xsl:value-of select="concat('public class ', $ifname, '&#10;')" />
2487 <xsl:text>{&#10;&#10;</xsl:text>
2488 <xsl:call-template name="genStructWrapperJaxws">
2489 <xsl:with-param name="ifname" select="$ifname" />
2490 </xsl:call-template>
2491 </xsl:when>
2492
2493 <xsl:otherwise>
2494 <xsl:variable name="extends" select="//interface[@name=$ifname]/@extends" />
2495 <xsl:choose>
2496 <xsl:when test="($extends = '$unknown') or ($extends = '$errorinfo')">
2497 <xsl:value-of select="concat('public class ', $ifname, ' extends IUnknown&#10;')" />
2498 <xsl:text>{&#10;&#10;</xsl:text>
2499 </xsl:when>
2500 <xsl:when test="//interface[@name=$extends]">
2501 <xsl:value-of select="concat('public class ', $ifname, ' extends ', $extends, '&#10;')" />
2502 <xsl:text>{&#10;&#10;</xsl:text>
2503 </xsl:when>
2504 <xsl:otherwise>
2505 <xsl:call-template name="fatalError">
2506 <xsl:with-param name="msg" select="concat('Interface generation: interface &quot;', $ifname, '&quot; has invalid &quot;extends&quot; value ', $extends, '.')" />
2507 </xsl:call-template>
2508 </xsl:otherwise>
2509 </xsl:choose>
2510 <xsl:call-template name="genIfaceWrapper">
2511 <xsl:with-param name="ifname" select="$ifname" />
2512 </xsl:call-template>
2513 </xsl:otherwise>
2514 </xsl:choose>
2515
2516 <!-- end of class -->
2517 <xsl:text>}&#10;</xsl:text>
2518 </xsl:if>
2519
2520 <xsl:call-template name="endFile">
2521 <xsl:with-param name="file" select="$filename" />
2522 </xsl:call-template>
2523
2524</xsl:template>
2525
2526<xsl:template name="genCb">
2527 <xsl:param name="ifname" />
2528 <xsl:param name="filename" />
2529 <xsl:param name="filenameimpl" />
2530
2531 <xsl:call-template name="startFile">
2532 <xsl:with-param name="file" select="$filename" />
2533 <xsl:with-param name="package" select="$G_virtualBoxPackage" />
2534 </xsl:call-template>
2535
2536 <xsl:text>import java.util.List;&#10;</xsl:text>
2537
2538 <xsl:value-of select="concat('public interface ', $ifname, '&#10;')" />
2539 <xsl:text>{&#10;</xsl:text>
2540
2541 <!-- emit methods declarations-->
2542 <xsl:for-each select="method">
2543 <xsl:call-template name="genCbMethodDecl">
2544 <xsl:with-param name="ifname" select="$ifname" />
2545 <xsl:with-param name="methodname" select="@name" />
2546 </xsl:call-template>
2547 </xsl:for-each>
2548
2549 <xsl:text>}&#10;&#10;</xsl:text>
2550
2551 <xsl:call-template name="endFile">
2552 <xsl:with-param name="file" select="$filename" />
2553 </xsl:call-template>
2554
2555 <xsl:call-template name="startFile">
2556 <xsl:with-param name="file" select="$filenameimpl" />
2557 <xsl:with-param name="package" select="$G_virtualBoxPackage" />
2558 </xsl:call-template>
2559
2560 <xsl:text>import java.util.List;&#10;</xsl:text>
2561
2562 <xsl:variable name="backtype">
2563 <xsl:call-template name="typeIdl2Back">
2564 <xsl:with-param name="type" select="$ifname" />
2565 </xsl:call-template>
2566 </xsl:variable>
2567
2568 <!-- emit glue methods body -->
2569 <xsl:choose>
2570 <xsl:when test="$G_vboxGlueStyle='xpcom'">
2571 <xsl:value-of select="concat('class ', $ifname, 'Impl extends nsISupportsBase implements ', $backtype, '&#10;')" />
2572 <xsl:text>{&#10;</xsl:text>
2573 </xsl:when>
2574
2575 <xsl:when test="$G_vboxGlueStyle='mscom'">
2576 <xsl:value-of select="concat('public class ', $ifname, 'Impl&#10;')" />
2577 <xsl:text>{&#10;</xsl:text>
2578 </xsl:when>
2579 </xsl:choose>
2580
2581 <xsl:value-of select="concat(' ', $ifname, ' sink;&#10;')" />
2582
2583 <xsl:value-of select="concat(' ', $ifname, 'Impl(', $ifname, ' sink)&#10;')" />
2584 <xsl:text> {&#10;</xsl:text>
2585 <xsl:text> this.sink = sink;&#10;</xsl:text>
2586 <xsl:text> }&#10;</xsl:text>
2587
2588 <!-- emit methods implementations -->
2589 <xsl:for-each select="method">
2590 <xsl:call-template name="genCbMethodImpl">
2591 <xsl:with-param name="ifname" select="$ifname" />
2592 <xsl:with-param name="methodname" select="@name" />
2593 </xsl:call-template>
2594 </xsl:for-each>
2595
2596 <xsl:text>}&#10;&#10;</xsl:text>
2597
2598 <xsl:call-template name="endFile">
2599 <xsl:with-param name="file" select="$filenameimpl" />
2600 </xsl:call-template>
2601</xsl:template>
2602
2603<xsl:template name="emitHandwritten">
2604
2605 <xsl:call-template name="startFile">
2606 <xsl:with-param name="file" select="'Holder.java'" />
2607 <xsl:with-param name="package" select="$G_virtualBoxPackage" />
2608 </xsl:call-template>
2609
2610 <xsl:if test="$filelistonly=''">
2611 <xsl:text><![CDATA[
2612public class Holder<T>
2613{
2614 public T value;
2615
2616 public Holder()
2617 {
2618 }
2619 public Holder(T value)
2620 {
2621 this.value = value;
2622 }
2623}
2624]]></xsl:text>
2625 </xsl:if>
2626
2627 <xsl:call-template name="endFile">
2628 <xsl:with-param name="file" select="'Holder.java'" />
2629 </xsl:call-template>
2630</xsl:template>
2631
2632<xsl:template name="emitHandwrittenXpcom">
2633
2634 <xsl:call-template name="startFile">
2635 <xsl:with-param name="file" select="'IUnknown.java'" />
2636 <xsl:with-param name="package" select="$G_virtualBoxPackageCom" />
2637 </xsl:call-template>
2638
2639 <xsl:if test="$filelistonly=''">
2640 <xsl:text><![CDATA[
2641public class IUnknown
2642{
2643 private Object obj;
2644 public IUnknown(Object obj)
2645 {
2646 this.obj = obj;
2647 }
2648
2649 public Object getWrapped()
2650 {
2651 return this.obj;
2652 }
2653
2654 public void setWrapped(Object obj)
2655 {
2656 this.obj = obj;
2657 }
2658}
2659]]></xsl:text>
2660 </xsl:if>
2661
2662 <xsl:call-template name="endFile">
2663 <xsl:with-param name="file" select="'IUnknown.java'" />
2664 </xsl:call-template>
2665
2666 <xsl:call-template name="startFile">
2667 <xsl:with-param name="file" select="'Helper.java'" />
2668 <xsl:with-param name="package" select="$G_virtualBoxPackageCom" />
2669 </xsl:call-template>
2670
2671 <xsl:if test="$filelistonly=''">
2672 <xsl:text><![CDATA[
2673
2674import java.util.List;
2675import java.util.ArrayList;
2676import java.util.Collections;
2677import java.lang.reflect.Array;
2678import java.lang.reflect.Constructor;
2679import java.lang.reflect.Method;
2680import java.lang.reflect.InvocationTargetException;
2681
2682public class Helper
2683{
2684 public static List<Short> wrap(byte[] values)
2685 {
2686 if (values == null)
2687 return null;
2688
2689 List<Short> ret = new ArrayList<Short>(values.length);
2690 for (short v : values)
2691 {
2692 ret.add(v);
2693 }
2694 return ret;
2695 }
2696
2697 public static List<Short> wrap(short[] values)
2698 {
2699 if (values == null)
2700 return null;
2701
2702 List<Short> ret = new ArrayList<Short>(values.length);
2703 for (short v : values)
2704 {
2705 ret.add(v);
2706 }
2707 return ret;
2708 }
2709
2710 public static List<Integer> wrap(int[] values)
2711 {
2712 if (values == null)
2713 return null;
2714
2715 List<Integer> ret = new ArrayList<Integer>(values.length);
2716 for (int v : values)
2717 {
2718 ret.add(v);
2719 }
2720 return ret;
2721 }
2722
2723 public static List<Long> wrap(long[] values)
2724 {
2725 if (values == null)
2726 return null;
2727
2728 List<Long> ret = new ArrayList<Long>(values.length);
2729 for (long v : values)
2730 {
2731 ret.add(v);
2732 }
2733 return ret;
2734 }
2735
2736 public static List<Boolean> wrap(boolean[] values)
2737 {
2738 if (values == null)
2739 return null;
2740
2741 List<Boolean> ret = new ArrayList<Boolean>(values.length);
2742 for (boolean v: values)
2743 {
2744 ret.add(v);
2745 }
2746 return ret;
2747 }
2748
2749 public static List<String> wrap(String[] values)
2750 {
2751 if (values == null)
2752 return null;
2753
2754 List<String> ret = new ArrayList<String>(values.length);
2755 for (String v : values)
2756 {
2757 ret.add(v);
2758 }
2759 return ret;
2760 }
2761
2762 public static <T> List<T> wrap(Class<T> wrapperClass, T[] values)
2763 {
2764 if (values == null)
2765 return null;
2766
2767 List<T> ret = new ArrayList<T>(values.length);
2768 for (T v : values)
2769 {
2770 ret.add(v);
2771 }
2772 return ret;
2773 }
2774
2775 @SuppressWarnings( "unchecked")
2776 public static <T> List<T> wrapEnum(Class<T> wrapperClass, long values[])
2777 {
2778 try
2779 {
2780 if (values == null)
2781 return null;
2782 //// This code is questionable, as it invokes a private constructor
2783 //// (all enums only have default constructors), and we don't really
2784 //// know what to pass as the name, and the ordinal may or may not
2785 //// be sensible, especially if the long was abused as a bitset.
2786 //Constructor<T> c = wrapperClass.getDeclaredConstructor(String.class, int.class, int.class);
2787 //c.setAccessible(true); // make it callable
2788 //List<T> ret = new ArrayList<T>(values.length);
2789 //for (long v : values)
2790 //{
2791 // T convEnum = c.newInstance("unknown", (int)v, (int)v);
2792 // ret.add(convEnum);
2793 //}
2794
2795 // Alternative implementation: use the fromValue method, which is
2796 // what the code handling single enums will do. I see no reason to
2797 // use the above very ugly hack if there are better alternatives,
2798 // which as a bonus complain about unknown values. This variant is
2799 // slower, but also orders of magnitude safer.
2800 java.lang.reflect.Method fromValue = wrapperClass.getMethod("fromValue", long.class);
2801 List<T> ret = new ArrayList<T>(values.length);
2802 for (long v : values)
2803 {
2804 T convEnum = (T)fromValue.invoke(null, v);
2805 ret.add(convEnum);
2806 }
2807 return ret;
2808 }
2809 catch (NoSuchMethodException e)
2810 {
2811 throw new AssertionError(e);
2812 }
2813 //catch (InstantiationException e)
2814 //{
2815 // throw new AssertionError(e);
2816 //}
2817 catch (IllegalAccessException e)
2818 {
2819 throw new AssertionError(e);
2820 }
2821 catch (InvocationTargetException e)
2822 {
2823 throw new AssertionError(e);
2824 }
2825 }
2826 public static short[] unwrapUShort(List<Short> values)
2827 {
2828 if (values == null)
2829 return null;
2830
2831 short[] ret = new short[values.size()];
2832 int i = 0;
2833 for (short l : values)
2834 {
2835 ret[i++] = l;
2836 }
2837 return ret;
2838 }
2839
2840 public static int[] unwrapInteger(List<Integer> values)
2841 {
2842 if (values == null)
2843 return null;
2844
2845 int[] ret = new int[values.size()];
2846 int i = 0;
2847 for (int l : values)
2848 {
2849 ret[i++] = l;
2850 }
2851 return ret;
2852 }
2853
2854 public static long[] unwrapULong(List<Long> values)
2855 {
2856 if (values == null)
2857 return null;
2858
2859 long[] ret = new long[values.size()];
2860 int i = 0;
2861 for (long l : values)
2862 {
2863 ret[i++] = l;
2864 }
2865 return ret;
2866 }
2867
2868 public static boolean[] unwrapBoolean(List<Boolean> values)
2869 {
2870 if (values == null)
2871 return null;
2872
2873 boolean[] ret = new boolean[values.size()];
2874 int i = 0;
2875 for (boolean l : values)
2876 {
2877 ret[i++] = l;
2878 }
2879 return ret;
2880 }
2881
2882 public static String[] unwrapStr(List<String> values)
2883 {
2884 if (values == null)
2885 return null;
2886
2887 String[] ret = new String[values.size()];
2888 int i = 0;
2889 for (String l : values)
2890 {
2891 ret[i++] = l;
2892 }
2893 return ret;
2894 }
2895
2896 public static <T extends Enum <T>> long[] unwrapEnum(Class<T> enumClass, List<T> values)
2897 {
2898 if (values == null)
2899 return null;
2900
2901 long result[] = new long[values.size()];
2902 try
2903 {
2904 java.lang.reflect.Method valueM = enumClass.getMethod("value");
2905 int i = 0;
2906 for (T v : values)
2907 {
2908 result[i++] = (Integer)valueM.invoke(v);
2909 }
2910 return result;
2911 }
2912 catch (NoSuchMethodException e)
2913 {
2914 throw new AssertionError(e);
2915 }
2916 catch(SecurityException e)
2917 {
2918 throw new AssertionError(e);
2919 }
2920 catch (IllegalAccessException e)
2921 {
2922 throw new AssertionError(e);
2923 }
2924 catch (IllegalArgumentException e)
2925 {
2926 throw new AssertionError(e);
2927 }
2928 catch (InvocationTargetException e)
2929 {
2930 throw new AssertionError(e);
2931 }
2932 }
2933
2934 public static <T1, T2> List<T1> wrap2(Class<T1> wrapperClass1, Class<T2> wrapperClass2, T2[] values)
2935 {
2936 try
2937 {
2938 if (values == null)
2939 return null;
2940
2941 Constructor<T1> c = wrapperClass1.getConstructor(wrapperClass2);
2942 List<T1> ret = new ArrayList<T1>(values.length);
2943 for (T2 v : values)
2944 {
2945 ret.add(c.newInstance(v));
2946 }
2947 return ret;
2948 }
2949 catch (NoSuchMethodException e)
2950 {
2951 throw new AssertionError(e);
2952 }
2953 catch (InstantiationException e)
2954 {
2955 throw new AssertionError(e);
2956 }
2957 catch (IllegalAccessException e)
2958 {
2959 throw new AssertionError(e);
2960 }
2961 catch (InvocationTargetException e)
2962 {
2963 throw new AssertionError(e);
2964 }
2965 }
2966
2967 @SuppressWarnings( "unchecked")
2968 public static <T> T[] unwrap(Class<T> wrapperClass, List<T> values)
2969 {
2970 if (values == null)
2971 return null;
2972 if (values.size() == 0)
2973 return null;
2974 return (T[])values.toArray((T[])Array.newInstance(wrapperClass, values.size()));
2975 }
2976
2977 @SuppressWarnings( "unchecked" )
2978 public static <T> T queryInterface(Object obj, String uuid, Class<T> iface)
2979 {
2980 return (T)queryInterface(obj, uuid);
2981 }
2982
2983 public static Object queryInterface(Object obj, String uuid)
2984 {
2985 try
2986 {
2987 /* Kind of ugly, but does the job of casting */
2988 org.mozilla.xpcom.Mozilla moz = org.mozilla.xpcom.Mozilla.getInstance();
2989 long xpobj = moz.wrapJavaObject(obj, uuid);
2990 return moz.wrapXPCOMObject(xpobj, uuid);
2991 }
2992 catch (Exception e)
2993 {
2994 return null;
2995 }
2996 }
2997
2998 @SuppressWarnings("unchecked")
2999 public static <T1 extends IUnknown, T2> T2[] unwrap2(Class<T1> wrapperClass1, Class<T2> wrapperClass2, List<T1> values)
3000 {
3001 if (values == null)
3002 return null;
3003
3004 T2 ret[] = (T2[])Array.newInstance(wrapperClass2, values.size());
3005 int i = 0;
3006 for (T1 obj : values)
3007 {
3008 ret[i++] = (T2)obj.getWrapped();
3009 }
3010 return ret;
3011 }
3012}
3013]]></xsl:text>
3014 </xsl:if>
3015
3016 <xsl:call-template name="endFile">
3017 <xsl:with-param name="file" select="'Helper.java'" />
3018 </xsl:call-template>
3019
3020 <xsl:call-template name="startFile">
3021 <xsl:with-param name="file" select="'VBoxException.java'" />
3022 <xsl:with-param name="package" select="$G_virtualBoxPackage" />
3023 </xsl:call-template>
3024
3025 <xsl:if test="$filelistonly=''">
3026 <xsl:text>
3027import org.mozilla.xpcom.*;
3028
3029public class VBoxException extends RuntimeException
3030{
3031 private int resultCode;
3032 private IVirtualBoxErrorInfo errorInfo;
3033
3034 public VBoxException(String message)
3035 {
3036 super(message);
3037 resultCode = -1;
3038 errorInfo = null;
3039 }
3040
3041 public VBoxException(String message, Throwable cause)
3042 {
3043 super(message, cause);
3044 if (cause instanceof org.mozilla.xpcom.XPCOMException)
3045 {
3046 resultCode = (int)((org.mozilla.xpcom.XPCOMException)cause).errorcode;
3047 try
3048 {
3049 Mozilla mozilla = Mozilla.getInstance();
3050 nsIServiceManager sm = mozilla.getServiceManager();
3051 nsIExceptionService es = (nsIExceptionService)sm.getServiceByContractID("@mozilla.org/exceptionservice;1", nsIExceptionService.NS_IEXCEPTIONSERVICE_IID);
3052 nsIExceptionManager em = es.getCurrentExceptionManager();
3053 nsIException ex = em.getCurrentException();
3054 errorInfo = new IVirtualBoxErrorInfo((org.mozilla.interfaces.IVirtualBoxErrorInfo)ex.queryInterface(org.mozilla.interfaces.IVirtualBoxErrorInfo.IVIRTUALBOXERRORINFO_IID));
3055 }
3056 catch (NullPointerException e)
3057 {
3058 e.printStackTrace();
3059 // nothing we can do
3060 errorInfo = null;
3061 }
3062 }
3063 else
3064 resultCode = -1;
3065 }
3066
3067 public int getResultCode()
3068 {
3069 return resultCode;
3070 }
3071
3072 public IVirtualBoxErrorInfo getVirtualBoxErrorInfo()
3073 {
3074 return errorInfo;
3075 }
3076}
3077</xsl:text>
3078 </xsl:if>
3079
3080 <xsl:call-template name="endFile">
3081 <xsl:with-param name="file" select="'VBoxException.java'" />
3082 </xsl:call-template>
3083
3084 <xsl:call-template name="startFile">
3085 <xsl:with-param name="file" select="'VirtualBoxManager.java'" />
3086 <xsl:with-param name="package" select="$G_virtualBoxPackage" />
3087 </xsl:call-template>
3088
3089 <xsl:if test="$filelistonly=''">
3090 <xsl:text><![CDATA[
3091
3092import java.io.File;
3093
3094import org.mozilla.xpcom.*;
3095import org.mozilla.interfaces.*;
3096
3097public class VirtualBoxManager
3098{
3099 private Mozilla mozilla;
3100 private IVirtualBox vbox;
3101 private nsIComponentManager componentManager;
3102
3103 private VirtualBoxManager(Mozilla mozilla)
3104 {
3105 this.mozilla = mozilla;
3106 this.componentManager = mozilla.getComponentManager();
3107 this.vbox = new IVirtualBox((org.mozilla.interfaces.IVirtualBox) this.componentManager
3108 .createInstanceByContractID("@virtualbox.org/VirtualBox;1",
3109 null,
3110 org.mozilla.interfaces.IVirtualBox.IVIRTUALBOX_IID));
3111 }
3112
3113 public void connect(String url, String username, String passwd)
3114 {
3115 throw new VBoxException("Connect doesn't make sense for local bindings");
3116 }
3117
3118 public void disconnect()
3119 {
3120 throw new VBoxException("Disconnect doesn't make sense for local bindings");
3121 }
3122
3123 public static void initPerThread()
3124 {
3125 }
3126
3127 public static void deinitPerThread()
3128 {
3129 }
3130
3131 public IVirtualBox getVBox()
3132 {
3133 return this.vbox;
3134 }
3135
3136 public ISession getSessionObject()
3137 {
3138 return new ISession((org.mozilla.interfaces.ISession) componentManager
3139 .createInstanceByContractID("@virtualbox.org/Session;1", null,
3140 org.mozilla.interfaces.ISession.ISESSION_IID));
3141 }
3142
3143 public ISession openMachineSession(IMachine m) throws Exception
3144 {
3145 ISession s = getSessionObject();
3146 m.lockMachine(s, LockType.Shared);
3147 return s;
3148 }
3149
3150 public void closeMachineSession(ISession s)
3151 {
3152 if (s != null)
3153 s.unlockMachine();
3154 }
3155
3156 private static boolean hasInstance = false;
3157 private static boolean isMozillaInited = false;
3158
3159 public static synchronized VirtualBoxManager createInstance(String home)
3160 {
3161 if (hasInstance)
3162 throw new VBoxException("only one instance of VirtualBoxManager at a time allowed");
3163 if (home == null || home.equals(""))
3164 home = System.getProperty("vbox.home");
3165
3166 if (home == null)
3167 throw new VBoxException("vbox.home Java property must be defined to use XPCOM bridge");
3168
3169 File grePath = new File(home);
3170
3171 Mozilla mozilla = Mozilla.getInstance();
3172 if (!isMozillaInited)
3173 {
3174 mozilla.initialize(grePath);
3175 try
3176 {
3177 mozilla.initXPCOM(grePath, null);
3178 isMozillaInited = true;
3179 }
3180 catch (Exception e)
3181 {
3182 e.printStackTrace();
3183 return null;
3184 }
3185 }
3186
3187 hasInstance = true;
3188
3189 return new VirtualBoxManager(mozilla);
3190 }
3191
3192 public IEventListener createListener(Object sink)
3193 {
3194 return new IEventListener(new EventListenerImpl(sink));
3195 }
3196
3197 public void cleanup()
3198 {
3199 deinitPerThread();
3200 // cleanup, we don't do that, as XPCOM bridge doesn't cleanly
3201 // shuts down, so we prefer to avoid native shutdown
3202 // mozilla.shutdownXPCOM(null);
3203 mozilla = null;
3204 hasInstance = false;
3205 }
3206
3207 public void waitForEvents(long tmo)
3208 {
3209 mozilla.waitForEvents(tmo);
3210 }
3211}
3212]]></xsl:text>
3213 </xsl:if>
3214
3215 <xsl:call-template name="endFile">
3216 <xsl:with-param name="file" select="'VirtualBoxManager.java'" />
3217 </xsl:call-template>
3218
3219 <xsl:call-template name="startFile">
3220 <xsl:with-param name="file" select="'EventListenerImpl.java'" />
3221 <xsl:with-param name="package" select="$G_virtualBoxPackage" />
3222 </xsl:call-template>
3223
3224 <xsl:if test="$filelistonly=''">
3225 <xsl:text><![CDATA[
3226import org.mozilla.interfaces.*;
3227
3228public class EventListenerImpl extends nsISupportsBase implements org.mozilla.interfaces.IEventListener
3229{
3230 private Object obj;
3231 private java.lang.reflect.Method handleEvent;
3232 EventListenerImpl(Object obj)
3233 {
3234 this.obj = obj;
3235 try
3236 {
3237 this.handleEvent = obj.getClass().getMethod("handleEvent", IEvent.class);
3238 }
3239 catch (Exception e)
3240 {
3241 e.printStackTrace();
3242 }
3243 }
3244 public void handleEvent(org.mozilla.interfaces.IEvent ev)
3245 {
3246 try
3247 {
3248 if (obj != null && handleEvent != null)
3249 handleEvent.invoke(obj, ev != null ? new IEvent(ev) : null);
3250 }
3251 catch (Exception e)
3252 {
3253 e.printStackTrace();
3254 }
3255 }
3256}]]></xsl:text>
3257 </xsl:if>
3258
3259 <xsl:call-template name="endFile">
3260 <xsl:with-param name="file" select="'EventListenerImpl.java'" />
3261 </xsl:call-template>
3262
3263 <xsl:call-template name="startFile">
3264 <xsl:with-param name="file" select="'VBoxObjectBase.java'" />
3265 <xsl:with-param name="package" select="$G_virtualBoxPackage" />
3266 </xsl:call-template>
3267
3268 <xsl:if test="$filelistonly=''">
3269 <xsl:text><![CDATA[
3270abstract class nsISupportsBase implements org.mozilla.interfaces.nsISupports
3271{
3272 public org.mozilla.interfaces.nsISupports queryInterface(String iid)
3273 {
3274 return org.mozilla.xpcom.Mozilla.queryInterface(this, iid);
3275 }
3276}
3277
3278]]></xsl:text>
3279 </xsl:if>
3280
3281 <xsl:call-template name="endFile">
3282 <xsl:with-param name="file" select="'VBoxObjectBase.java'" />
3283 </xsl:call-template>
3284</xsl:template>
3285
3286
3287<xsl:template name="emitHandwrittenMscom">
3288
3289 <xsl:call-template name="startFile">
3290 <xsl:with-param name="file" select="'IUnknown.java'" />
3291 <xsl:with-param name="package" select="$G_virtualBoxPackageCom" />
3292 </xsl:call-template>
3293
3294 <xsl:if test="$filelistonly=''">
3295 <xsl:text><![CDATA[
3296public class IUnknown
3297{
3298 private Object obj;
3299 public IUnknown(Object obj)
3300 {
3301 this.obj = obj;
3302 }
3303
3304 public Object getWrapped()
3305 {
3306 return this.obj;
3307 }
3308
3309 public void setWrapped(Object obj)
3310 {
3311 this.obj = obj;
3312 }
3313}
3314]]></xsl:text>
3315 </xsl:if>
3316
3317 <xsl:call-template name="endFile">
3318 <xsl:with-param name="file" select="'IUnknown.java'" />
3319 </xsl:call-template>
3320
3321 <xsl:call-template name="startFile">
3322 <xsl:with-param name="file" select="'Helper.java'" />
3323 <xsl:with-param name="package" select="$G_virtualBoxPackageCom" />
3324 </xsl:call-template>
3325
3326 <xsl:if test="$filelistonly=''">
3327 <xsl:text><![CDATA[
3328
3329import java.util.List;
3330import java.util.ArrayList;
3331import java.util.Collections;
3332import java.lang.reflect.Array;
3333import java.lang.reflect.Constructor;
3334import java.lang.reflect.InvocationTargetException;
3335import com.jacob.com.*;
3336
3337public class Helper
3338{
3339 public static List<Short> wrap(short[] values)
3340 {
3341 if (values == null)
3342 return null;
3343
3344 List<Short> ret = new ArrayList<Short>(values.length);
3345 for (short v : values)
3346 {
3347 ret.add(v);
3348 }
3349 return ret;
3350 }
3351
3352 public static List<Integer> wrap(int[] values)
3353 {
3354 if (values == null)
3355 return null;
3356
3357 List<Integer> ret = new ArrayList<Integer>(values.length);
3358 for (int v : values)
3359 {
3360 ret.add(v);
3361 }
3362 return ret;
3363 }
3364
3365 public static List<Long> wrap(long[] values)
3366 {
3367 if (values == null)
3368 return null;
3369
3370 List<Long> ret = new ArrayList<Long>(values.length);
3371 for (long v : values)
3372 {
3373 ret.add(v);
3374 }
3375 return ret;
3376 }
3377
3378 public static List<String> wrap(String[] values)
3379 {
3380 if (values == null)
3381 return null;
3382
3383 List<String> ret = new ArrayList<String>(values.length);
3384 for (String v : values)
3385 {
3386 ret.add(v);
3387 }
3388 return ret;
3389 }
3390
3391 public static <T> T wrapDispatch(Class<T> wrapperClass, Dispatch d)
3392 {
3393 try
3394 {
3395 if (d == null || d.m_pDispatch == 0)
3396 return null;
3397 Constructor<T> c = wrapperClass.getConstructor(Dispatch.class);
3398 return (T)c.newInstance(d);
3399 }
3400 catch (NoSuchMethodException e)
3401 {
3402 throw new AssertionError(e);
3403 }
3404 catch (InstantiationException e)
3405 {
3406 throw new AssertionError(e);
3407 }
3408 catch (IllegalAccessException e)
3409 {
3410 throw new AssertionError(e);
3411 }
3412 catch (InvocationTargetException e)
3413 {
3414 throw new AssertionError(e);
3415 }
3416 }
3417
3418 @SuppressWarnings("unchecked")
3419 public static <T> Object wrapVariant(Class<T> wrapperClass, Variant v)
3420 {
3421 if (v == null)
3422 return null;
3423
3424 short vt = v.getvt();
3425 switch (vt)
3426 {
3427 case Variant.VariantNull:
3428 return null;
3429 case Variant.VariantBoolean:
3430 return v.getBoolean();
3431 case Variant.VariantByte:
3432 return v.getByte();
3433 case Variant.VariantShort:
3434 return v.getShort();
3435 case Variant.VariantInt:
3436 return v.getInt();
3437 case Variant.VariantLongInt:
3438 return v.getLong();
3439 case Variant.VariantString:
3440 return v.getString();
3441 case Variant.VariantDispatch:
3442 return wrapDispatch(wrapperClass, v.getDispatch());
3443 default:
3444 throw new IllegalArgumentException("unhandled variant type " + vt);
3445 }
3446 }
3447
3448 public static byte[] wrapBytes(SafeArray sa)
3449 {
3450 if (sa == null)
3451 return null;
3452
3453 int saLen = sa.getUBound() - sa.getLBound() + 1;
3454
3455 byte[] ret = new byte[saLen];
3456 int j = 0;
3457 for (int i = sa.getLBound(); i <= sa.getUBound(); i++)
3458 {
3459 Variant v = sa.getVariant(i);
3460 // come up with more effective approach!!!
3461 ret[j++] = v.getByte();
3462 }
3463 return ret;
3464 }
3465
3466 @SuppressWarnings("unchecked")
3467 public static <T> List<T> wrap(Class<T> wrapperClass, SafeArray sa)
3468 {
3469 if (sa == null)
3470 return null;
3471
3472 int saLen = sa.getUBound() - sa.getLBound() + 1;
3473 if (saLen == 0)
3474 return Collections.emptyList();
3475
3476 List<T> ret = new ArrayList<T>(saLen);
3477 for (int i = sa.getLBound(); i <= sa.getUBound(); i++)
3478 {
3479 Variant v = sa.getVariant(i);
3480 ret.add((T)wrapVariant(wrapperClass, v));
3481 }
3482 return ret;
3483 }
3484
3485 public static <T> List<T> wrapEnum(Class<T> wrapperClass, SafeArray sa)
3486 {
3487 try
3488 {
3489 if (sa == null)
3490 return null;
3491
3492 int saLen = sa.getUBound() - sa.getLBound() + 1;
3493 if (saLen == 0)
3494 return Collections.emptyList();
3495 List<T> ret = new ArrayList<T>(saLen);
3496 Constructor<T> c = wrapperClass.getConstructor(int.class);
3497 for (int i = sa.getLBound(); i <= sa.getUBound(); i++)
3498 {
3499 Variant v = sa.getVariant(i);
3500 ret.add(c.newInstance(v.getInt()));
3501 }
3502 return ret;
3503 }
3504 catch (NoSuchMethodException e)
3505 {
3506 throw new AssertionError(e);
3507 }
3508 catch (InstantiationException e)
3509 {
3510 throw new AssertionError(e);
3511 }
3512 catch (IllegalAccessException e)
3513 {
3514 throw new AssertionError(e);
3515 }
3516 catch (InvocationTargetException e)
3517 {
3518 throw new AssertionError(e);
3519 }
3520 }
3521
3522 public static SafeArray unwrapInt(List<Integer> values)
3523 {
3524 if (values == null)
3525 return null;
3526 SafeArray ret = new SafeArray(Variant.VariantInt, values.size());
3527 int i = 0;
3528 for (int l : values)
3529 {
3530 ret.setInt(i++, l);
3531 }
3532 return ret;
3533 }
3534
3535 public static SafeArray unwrapLong(List<Long> values)
3536 {
3537 if (values == null)
3538 return null;
3539 SafeArray ret = new SafeArray(Variant.VariantLongInt, values.size());
3540 int i = 0;
3541 for (long l : values)
3542 {
3543 ret.setLong(i++, l);
3544 }
3545 return ret;
3546 }
3547
3548 public static SafeArray unwrapBool(List<Boolean> values)
3549 {
3550 if (values == null)
3551 return null;
3552
3553 SafeArray result = new SafeArray(Variant.VariantBoolean, values.size());
3554 int i = 0;
3555 for (boolean l : values)
3556 {
3557 result.setBoolean(i++, l);
3558 }
3559 return result;
3560 }
3561
3562
3563 public static SafeArray unwrapBytes(byte[] values)
3564 {
3565 if (values == null)
3566 return null;
3567
3568 SafeArray result = new SafeArray(Variant.VariantByte, values.length);
3569 int i = 0;
3570 for (byte l : values)
3571 {
3572 result.setByte(i++, l);
3573 }
3574 return result;
3575 }
3576
3577
3578 public static <T extends Enum <T>> SafeArray unwrapEnum(Class<T> enumClass, List<T> values)
3579 {
3580 if (values == null)
3581 return null;
3582
3583 SafeArray result = new SafeArray(Variant.VariantInt, values.size());
3584 try
3585 {
3586 java.lang.reflect.Method valueM = enumClass.getMethod("value");
3587 int i = 0;
3588 for (T v : values)
3589 {
3590 result.setInt(i++, (Integer)valueM.invoke(v));
3591 }
3592 return result;
3593 }
3594 catch (NoSuchMethodException e)
3595 {
3596 throw new AssertionError(e);
3597 }
3598 catch(SecurityException e)
3599 {
3600 throw new AssertionError(e);
3601 }
3602 catch (IllegalAccessException e)
3603 {
3604 throw new AssertionError(e);
3605 }
3606 catch (IllegalArgumentException e)
3607 {
3608 throw new AssertionError(e);
3609 }
3610 catch (InvocationTargetException e)
3611 {
3612 throw new AssertionError(e);
3613 }
3614 }
3615 public static SafeArray unwrapString(List<String> values)
3616 {
3617 if (values == null)
3618 return null;
3619 SafeArray result = new SafeArray(Variant.VariantString, values.size());
3620 int i = 0;
3621 for (String l : values)
3622 {
3623 result.setString(i++, l);
3624 }
3625 return result;
3626 }
3627
3628 public static <T1, T2> List<T1> wrap2(Class<T1> wrapperClass1, Class<T2> wrapperClass2, T2[] values)
3629 {
3630 try
3631 {
3632 if (values == null)
3633 return null;
3634 if (values.length == 0)
3635 return Collections.emptyList();
3636
3637 Constructor<T1> c = wrapperClass1.getConstructor(wrapperClass2);
3638 List<T1> ret = new ArrayList<T1>(values.length);
3639 for (T2 v : values)
3640 {
3641 ret.add(c.newInstance(v));
3642 }
3643 return ret;
3644 }
3645 catch (NoSuchMethodException e)
3646 {
3647 throw new AssertionError(e);
3648 }
3649 catch (InstantiationException e)
3650 {
3651 throw new AssertionError(e);
3652 }
3653 catch (IllegalAccessException e)
3654 {
3655 throw new AssertionError(e);
3656 }
3657 catch (InvocationTargetException e)
3658 {
3659 throw new AssertionError(e);
3660 }
3661 }
3662
3663 @SuppressWarnings("unchecked")
3664 public static <T> T[] unwrap(Class<T> wrapperClass, List<T> values)
3665 {
3666 if (values == null)
3667 return null;
3668 return (T[])values.toArray((T[])Array.newInstance(wrapperClass, values.size()));
3669 }
3670
3671 @SuppressWarnings("unchecked")
3672 public static <T1 extends IUnknown, T2> T2[] unwrap2(Class<T1> wrapperClass1, Class<T2> wrapperClass2, List<T1> values)
3673 {
3674 if (values == null)
3675 return null;
3676
3677 T2 ret[] = (T2[])Array.newInstance(wrapperClass2, values.size());
3678 int i = 0;
3679 for (T1 obj : values)
3680 {
3681 ret[i++] = (T2)obj.getWrapped();
3682 }
3683 return ret;
3684 }
3685
3686 /* We have very long invoke lists sometimes */
3687 public static Variant invoke(Dispatch d, String method, Object ... args)
3688 {
3689 return Dispatch.callN(d, method, args);
3690 }
3691}
3692]]></xsl:text>
3693 </xsl:if>
3694
3695 <xsl:call-template name="endFile">
3696 <xsl:with-param name="file" select="'Helper.java'" />
3697 </xsl:call-template>
3698
3699 <xsl:call-template name="startFile">
3700 <xsl:with-param name="file" select="'VBoxException.java'" />
3701 <xsl:with-param name="package" select="$G_virtualBoxPackage" />
3702 </xsl:call-template>
3703
3704 <xsl:if test="$filelistonly=''">
3705 <xsl:text>
3706
3707public class VBoxException extends RuntimeException
3708{
3709 private int resultCode;
3710 private IVirtualBoxErrorInfo errorInfo;
3711
3712 public VBoxException(String message)
3713 {
3714 super(message);
3715 resultCode = -1;
3716 errorInfo = null;
3717 }
3718
3719 public VBoxException(String message, Throwable cause)
3720 {
3721 super(message, cause);
3722 if (cause instanceof com.jacob.com.ComException)
3723 {
3724 resultCode = ((com.jacob.com.ComException)cause).getHResult();
3725 // JACOB doesn't support calling GetErrorInfo, which
3726 // means there is no way of getting an IErrorInfo reference,
3727 // and that means no way of getting to IVirtualBoxErrorInfo.
3728 errorInfo = null;
3729 }
3730 else
3731 resultCode = -1;
3732 }
3733
3734 public int getResultCode()
3735 {
3736 return resultCode;
3737 }
3738
3739 public IVirtualBoxErrorInfo getVirtualBoxErrorInfo()
3740 {
3741 return errorInfo;
3742 }
3743}
3744</xsl:text>
3745 </xsl:if>
3746
3747 <xsl:call-template name="endFile">
3748 <xsl:with-param name="file" select="'VBoxException.java'" />
3749 </xsl:call-template>
3750
3751
3752 <xsl:call-template name="startFile">
3753 <xsl:with-param name="file" select="'VirtualBoxManager.java'" />
3754 <xsl:with-param name="package" select="$G_virtualBoxPackage" />
3755 </xsl:call-template>
3756
3757 <xsl:if test="$filelistonly=''">
3758 <xsl:text><![CDATA[
3759
3760import com.jacob.activeX.ActiveXComponent;
3761import com.jacob.com.ComThread;
3762import com.jacob.com.Dispatch;
3763import com.jacob.com.Variant;
3764import com.jacob.com.SafeArray;
3765import com.jacob.com.DispatchEvents;
3766
3767public class VirtualBoxManager
3768{
3769 private IVirtualBox vbox;
3770
3771 private VirtualBoxManager()
3772 {
3773 initPerThread();
3774 vbox = new IVirtualBox(new ActiveXComponent("VirtualBox.VirtualBox"));
3775 }
3776
3777 public static void initPerThread()
3778 {
3779 ComThread.InitMTA();
3780 }
3781
3782 public static void deinitPerThread()
3783 {
3784 ComThread.Release();
3785 }
3786
3787 public void connect(String url, String username, String passwd)
3788 {
3789 throw new VBoxException("Connect doesn't make sense for local bindings");
3790 }
3791
3792 public void disconnect()
3793 {
3794 throw new VBoxException("Disconnect doesn't make sense for local bindings");
3795 }
3796
3797 public IVirtualBox getVBox()
3798 {
3799 return this.vbox;
3800 }
3801
3802 public ISession getSessionObject()
3803 {
3804 return new ISession(new ActiveXComponent("VirtualBox.Session"));
3805 }
3806
3807 public ISession openMachineSession(IMachine m)
3808 {
3809 ISession s = getSessionObject();
3810 m.lockMachine(s, LockType.Shared);
3811 return s;
3812 }
3813
3814 public void closeMachineSession(ISession s)
3815 {
3816 if (s != null)
3817 s.unlockMachine();
3818 }
3819
3820 private static boolean hasInstance = false;
3821
3822 public static synchronized VirtualBoxManager createInstance(String home)
3823 {
3824 if (hasInstance)
3825 throw new VBoxException("only one instance of VirtualBoxManager at a time allowed");
3826
3827 hasInstance = true;
3828 return new VirtualBoxManager();
3829 }
3830
3831 public void cleanup()
3832 {
3833 deinitPerThread();
3834 hasInstance = false;
3835 }
3836
3837 public void waitForEvents(long tmo)
3838 {
3839 // what to do here?
3840 try
3841 {
3842 Thread.sleep(tmo);
3843 }
3844 catch (InterruptedException ie)
3845 {
3846 }
3847 }
3848}
3849]]></xsl:text>
3850 </xsl:if>
3851
3852 <xsl:call-template name="endFile">
3853 <xsl:with-param name="file" select="'VirtualBoxManager.java'" />
3854 </xsl:call-template>
3855</xsl:template>
3856
3857<xsl:template name="emitHandwrittenJaxws">
3858
3859 <xsl:call-template name="startFile">
3860 <xsl:with-param name="file" select="'IUnknown.java'" />
3861 <xsl:with-param name="package" select="$G_virtualBoxPackage" />
3862 </xsl:call-template>
3863
3864 <xsl:if test="$filelistonly=''">
3865 <xsl:text><![CDATA[
3866public class IUnknown
3867{
3868 protected String obj;
3869 protected final VboxPortType port;
3870
3871 public IUnknown(String obj, VboxPortType port)
3872 {
3873 this.obj = obj;
3874 this.port = port;
3875 }
3876
3877 public final String getWrapped()
3878 {
3879 return this.obj;
3880 }
3881
3882 public final VboxPortType getRemoteWSPort()
3883 {
3884 return this.port;
3885 }
3886
3887 public synchronized void releaseRemote() throws WebServiceException
3888 {
3889 if (obj == null)
3890 return;
3891
3892 try
3893 {
3894 this.port.iManagedObjectRefRelease(obj);
3895 this.obj = null;
3896 }
3897 catch (InvalidObjectFaultMsg e)
3898 {
3899 throw new WebServiceException(e);
3900 }
3901 catch (RuntimeFaultMsg e)
3902 {
3903 throw new WebServiceException(e);
3904 }
3905 }
3906}
3907]]></xsl:text>
3908 </xsl:if>
3909
3910 <xsl:call-template name="endFile">
3911 <xsl:with-param name="file" select="'IUnknown.java'" />
3912 </xsl:call-template>
3913
3914 <xsl:call-template name="startFile">
3915 <xsl:with-param name="file" select="'Helper.java'" />
3916 <xsl:with-param name="package" select="$G_virtualBoxPackage" />
3917 </xsl:call-template>
3918
3919 <xsl:if test="$filelistonly=''">
3920 <xsl:text><![CDATA[
3921
3922import java.util.List;
3923import java.util.ArrayList;
3924import java.util.Collections;
3925import java.lang.reflect.Array;
3926import java.lang.reflect.Constructor;
3927import java.lang.reflect.InvocationTargetException;
3928import java.math.BigInteger;
3929
3930public class Helper
3931{
3932 public static <T> List<T> wrap(Class<T> wrapperClass, VboxPortType pt, List<String> values)
3933 {
3934 try
3935 {
3936 if (values == null)
3937 return null;
3938
3939 Constructor<T> c = wrapperClass.getConstructor(String.class, VboxPortType.class);
3940 List<T> ret = new ArrayList<T>(values.size());
3941 for (String v : values)
3942 {
3943 ret.add(c.newInstance(v, pt));
3944 }
3945 return ret;
3946 }
3947 catch (NoSuchMethodException e)
3948 {
3949 throw new AssertionError(e);
3950 }
3951 catch (InstantiationException e)
3952 {
3953 throw new AssertionError(e);
3954 }
3955 catch (IllegalAccessException e)
3956 {
3957 throw new AssertionError(e);
3958 }
3959 catch (InvocationTargetException e)
3960 {
3961 throw new AssertionError(e);
3962 }
3963 }
3964
3965 public static <T1, T2> List<T1> wrap2(Class<T1> wrapperClass1, Class<T2> wrapperClass2, VboxPortType pt, List<T2> values)
3966 {
3967 try
3968 {
3969 if (values == null)
3970 return null;
3971
3972 Constructor<T1> c = wrapperClass1.getConstructor(wrapperClass2, VboxPortType.class);
3973 List<T1> ret = new ArrayList<T1>(values.size());
3974 for (T2 v : values)
3975 {
3976 ret.add(c.newInstance(v, pt));
3977 }
3978 return ret;
3979 }
3980 catch (NoSuchMethodException e)
3981 {
3982 throw new AssertionError(e);
3983 }
3984 catch (InstantiationException e)
3985 {
3986 throw new AssertionError(e);
3987 }
3988 catch (IllegalAccessException e)
3989 {
3990 throw new AssertionError(e);
3991 }
3992 catch (InvocationTargetException e)
3993 {
3994 throw new AssertionError(e);
3995 }
3996 }
3997
3998 public static <T extends IUnknown> List<String> unwrap(List<T> values)
3999 {
4000 if (values == null)
4001 return null;
4002
4003 List<String> ret = new ArrayList<String>(values.size());
4004 for (T obj : values)
4005 {
4006 ret.add(obj.getWrapped());
4007 }
4008 return ret;
4009 }
4010
4011 @SuppressWarnings("unchecked" )
4012 public static <T1 extends Enum <T1>, T2 extends Enum <T2>> List<T2> convertEnums(Class<T1> fromClass,
4013 Class<T2> toClass,
4014 List<T1> values)
4015 {
4016 try
4017 {
4018 if (values == null)
4019 return null;
4020 List<T2> ret = new ArrayList<T2>(values.size());
4021 for (T1 v : values)
4022 {
4023 // Ordinal based enum conversion, as JAX-WS "invents" its own
4024 // enum names and has string values with the expected content.
4025 int enumOrdinal = v.ordinal();
4026 T2 convEnum = toClass.getEnumConstants()[enumOrdinal];
4027 ret.add(convEnum);
4028 }
4029 return ret;
4030 }
4031 catch (ArrayIndexOutOfBoundsException e)
4032 {
4033 throw new AssertionError(e);
4034 }
4035 }
4036
4037 /* Pretty naive Base64 encoder/decoder. */
4038 private static final char[] valToChar = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".toCharArray();
4039 private static final int[] charToVal = new int[256];
4040
4041 /* Initialize recoding alphabet. */
4042 static
4043 {
4044 for (int i = 0; i < charToVal.length; i++)
4045 charToVal[i] = -1;
4046
4047 for (int i = 0; i < valToChar.length; i++)
4048 charToVal[valToChar[i]] = i;
4049
4050 charToVal['='] = 0;
4051 }
4052
4053 public static String encodeBase64(byte[] data)
4054 {
4055 if (data == null)
4056 return null;
4057
4058 if (data.length == 0)
4059 return "";
4060
4061 int fullTriplets = data.length / 3;
4062 int resultLen = ((data.length - 1) / 3 + 1) * 4;
4063 char[] result = new char[resultLen];
4064 int dataIndex = 0, stringIndex = 0;
4065
4066 for (int i = 0; i < fullTriplets; i++)
4067 {
4068 int ch1 = data[dataIndex++] & 0xff;
4069 result[stringIndex++] = valToChar[ch1 >> 2];
4070 int ch2 = data[dataIndex++] & 0xff;
4071 result[stringIndex++] = valToChar[((ch1 << 4) & 0x3f) | (ch2 >> 4)];
4072 int ch3 = data[dataIndex++] & 0xff;
4073 result[stringIndex++] = valToChar[((ch2 << 2) & 0x3f) | (ch3 >> 6)];
4074 result[stringIndex++] = valToChar[ch3 & 0x3f];
4075 }
4076
4077 switch (data.length - dataIndex)
4078 {
4079 case 0:
4080 // do nothing
4081 break;
4082 case 1:
4083 {
4084 int ch1 = data[dataIndex++] & 0xff;
4085 result[stringIndex++] = valToChar[ch1 >> 2];
4086 result[stringIndex++] = valToChar[(ch1 << 4) & 0x3f];
4087 result[stringIndex++] = '=';
4088 result[stringIndex++] = '=';
4089 break;
4090 }
4091 case 2:
4092 {
4093 int ch1 = data[dataIndex++] & 0xff;
4094 result[stringIndex++] = valToChar[ch1 >> 2];
4095 int ch2 = data[dataIndex++] & 0xff;
4096 result[stringIndex++] = valToChar[((ch1 << 4) & 0x3f) | (ch2 >> 4)];
4097 result[stringIndex++] = valToChar[(ch2 << 2) & 0x3f];
4098 result[stringIndex++] = '=';
4099 break;
4100 }
4101 default:
4102 throw new VBoxException("bug!");
4103 }
4104
4105 return new String(result);
4106 }
4107
4108 private static int skipInvalid(String str, int stringIndex)
4109 {
4110 while (charToVal[str.charAt(stringIndex)] < 0)
4111 stringIndex++;
4112
4113 return stringIndex;
4114 }
4115
4116 public static byte[] decodeBase64(String str)
4117 {
4118 if (str == null)
4119 return null;
4120
4121 int stringLength = str.length();
4122 if (stringLength == 0)
4123 return new byte[0];
4124
4125 int validChars = 0, padChars = 0;
4126 for (int i = 0; i < str.length(); i++)
4127 {
4128 char ch = str.charAt(i);
4129
4130 if (charToVal[ch] >= 0)
4131 validChars++;
4132
4133 if (ch == '=')
4134 padChars++;
4135 }
4136
4137 if ((validChars * 3 % 4) != 0)
4138 throw new VBoxException("invalid base64 encoded string " + str);
4139
4140 int resultLength = validChars * 3 / 4 - padChars;
4141 byte[] result = new byte[resultLength];
4142
4143 int dataIndex = 0, stringIndex = 0;
4144 int quadraplets = validChars / 4;
4145
4146 for (int i = 0; i < quadraplets; i++)
4147 {
4148 stringIndex = skipInvalid(str, stringIndex);
4149 int ch1 = str.charAt(stringIndex++);
4150 stringIndex = skipInvalid(str, stringIndex);
4151 int ch2 = str.charAt(stringIndex++);
4152 stringIndex = skipInvalid(str, stringIndex);
4153 int ch3 = str.charAt(stringIndex++);
4154 stringIndex = skipInvalid(str, stringIndex);
4155 int ch4 = str.charAt(stringIndex++);
4156
4157 result[dataIndex++] = (byte)(((charToVal[ch1] << 2) | charToVal[ch2] >> 4) & 0xff);
4158 /* we check this to ensure that we don't override data with '=' padding. */
4159 if (dataIndex < result.length)
4160 result[dataIndex++] = (byte)(((charToVal[ch2] << 4) | charToVal[ch3] >> 2) & 0xff);
4161 if (dataIndex < result.length)
4162 result[dataIndex++] = (byte)(((charToVal[ch3] << 6) | charToVal[ch4]) & 0xff);
4163 }
4164
4165 return result;
4166 }
4167}
4168]]></xsl:text>
4169 </xsl:if>
4170
4171 <xsl:call-template name="endFile">
4172 <xsl:with-param name="file" select="'Helper.java'" />
4173 </xsl:call-template>
4174
4175 <xsl:call-template name="startFile">
4176 <xsl:with-param name="file" select="'VBoxException.java'" />
4177 <xsl:with-param name="package" select="$G_virtualBoxPackage" />
4178 </xsl:call-template>
4179
4180 <xsl:if test="$filelistonly=''">
4181 <xsl:text>
4182public class VBoxException extends RuntimeException
4183{
4184 private int resultCode;
4185 private IVirtualBoxErrorInfo errorInfo;
4186
4187 public VBoxException(String message)
4188 {
4189 super(message);
4190 resultCode = -1;
4191 errorInfo = null;
4192 }
4193
4194 public VBoxException(String message, Throwable cause)
4195 {
4196 super(message, cause);
4197 resultCode = -1;
4198 errorInfo = null;
4199 }
4200
4201 public VBoxException(String message, Throwable cause, VboxPortType port)
4202 {
4203 super(message, cause);
4204 if (cause instanceof RuntimeFaultMsg)
4205 {
4206 RuntimeFaultMsg m = (RuntimeFaultMsg)cause;
4207 RuntimeFault f = m.getFaultInfo();
4208 resultCode = f.getResultCode();
4209 String retVal = f.getReturnval();
4210 errorInfo = (retVal.length() > 0) ? new IVirtualBoxErrorInfo(retVal, port) : null;
4211 }
4212 else
4213 resultCode = -1;
4214 }
4215
4216 public int getResultCode()
4217 {
4218 return resultCode;
4219 }
4220
4221 public IVirtualBoxErrorInfo getVirtualBoxErrorInfo()
4222 {
4223 return errorInfo;
4224 }
4225}
4226</xsl:text>
4227 </xsl:if>
4228
4229 <xsl:call-template name="endFile">
4230 <xsl:with-param name="file" select="'VBoxException.java'" />
4231 </xsl:call-template>
4232
4233 <xsl:call-template name="startFile">
4234 <xsl:with-param name="file" select="'VirtualBoxManager.java'" />
4235 <xsl:with-param name="package" select="$G_virtualBoxPackage" />
4236 </xsl:call-template>
4237
4238 <xsl:if test="$filelistonly=''">
4239 <xsl:text>import java.net.URL;
4240import java.math.BigInteger;
4241import java.util.List;
4242import java.util.Map;
4243import java.util.HashMap;
4244import javax.xml.namespace.QName;
4245import javax.xml.ws.BindingProvider;
4246import javax.xml.ws.Holder;
4247import javax.xml.ws.WebServiceException;
4248
4249class PortPool
4250{
4251 private final static String wsdlFile = </xsl:text>
4252 <xsl:value-of select="$G_virtualBoxWsdl" />
4253 <xsl:text><![CDATA[;
4254 private Map<VboxPortType, Integer> known;
4255 private boolean initStarted;
4256 private VboxService svc;
4257
4258 PortPool(boolean usePreinit)
4259 {
4260 known = new HashMap<VboxPortType, Integer>();
4261
4262 if (usePreinit)
4263 {
4264 new Thread(new Runnable()
4265 {
4266 public void run()
4267 {
4268 // need to sync on something else but 'this'
4269 synchronized (known)
4270 {
4271 initStarted = true;
4272 known.notify();
4273 }
4274
4275 preinit();
4276 }
4277 }).start();
4278
4279 synchronized (known)
4280 {
4281 while (!initStarted)
4282 {
4283 try
4284 {
4285 known.wait();
4286 }
4287 catch (InterruptedException e)
4288 {
4289 break;
4290 }
4291 }
4292 }
4293 }
4294 }
4295
4296 private synchronized void preinit()
4297 {
4298 VboxPortType port = getPort();
4299 releasePort(port);
4300 }
4301
4302 synchronized VboxPortType getPort()
4303 {
4304 VboxPortType port = null;
4305 int ttl = 0;
4306
4307 for (VboxPortType cur: known.keySet())
4308 {
4309 int value = known.get(cur);
4310 if ((value & 0x10000) == 0)
4311 {
4312 port = cur;
4313 ttl = value & 0xffff;
4314 break;
4315 }
4316 }
4317
4318 if (port == null)
4319 {
4320 if (svc == null)
4321 {
4322 URL wsdl = PortPool.class.getClassLoader().getResource(wsdlFile);
4323 if (wsdl == null)
4324 throw new LinkageError(wsdlFile + " not found, but it should have been in the jar");
4325 svc = new VboxService(wsdl,
4326 new QName("http://www.virtualbox.org/Service",
4327 "vboxService"));
4328 }
4329 port = svc.getVboxServicePort();
4330 // reuse this object 0x10 times
4331 ttl = 0x10;
4332 }
4333 // mark as used
4334 known.put(port, new Integer(0x10000 | ttl));
4335 return port;
4336 }
4337
4338 synchronized void releasePort(VboxPortType port)
4339 {
4340 Integer val = known.get(port);
4341 if (val == null || val == 0)
4342 {
4343 // know you not
4344 return;
4345 }
4346
4347 int v = val;
4348 int ttl = v & 0xffff;
4349 // decrement TTL, and throw away port if used too much times
4350 if (--ttl <= 0)
4351 {
4352 known.remove(port);
4353 }
4354 else
4355 {
4356 v = ttl; // set new TTL and clear busy bit
4357 known.put(port, v);
4358 }
4359 }
4360}
4361
4362
4363public class VirtualBoxManager
4364{
4365 private static PortPool pool = new PortPool(true);
4366 protected VboxPortType port;
4367
4368 private IVirtualBox vbox;
4369
4370 private VirtualBoxManager()
4371 {
4372 }
4373
4374 public static void initPerThread()
4375 {
4376 }
4377
4378 public static void deinitPerThread()
4379 {
4380 }
4381
4382 public void connect(String url, String username, String passwd)
4383 {
4384 this.port = pool.getPort();
4385 try
4386 {
4387 ((BindingProvider)port).getRequestContext().
4388 put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, url);
4389 String handle = port.iWebsessionManagerLogon(username, passwd);
4390 this.vbox = new IVirtualBox(handle, port);
4391 }
4392 catch (Throwable t)
4393 {
4394 if (this.port != null && pool != null)
4395 {
4396 pool.releasePort(this.port);
4397 this.port = null;
4398 }
4399 // we have to throw smth derived from RuntimeException
4400 throw new VBoxException(t.getMessage(), t, this.port);
4401 }
4402 }
4403
4404 public void connect(String url, String username, String passwd,
4405 Map<String, Object> requestContext, Map<String, Object> responseContext)
4406 {
4407 this.port = pool.getPort();
4408
4409 try
4410 {
4411 ((BindingProvider)port).getRequestContext();
4412 if (requestContext != null)
4413 ((BindingProvider)port).getRequestContext().putAll(requestContext);
4414
4415 if (responseContext != null)
4416 ((BindingProvider)port).getResponseContext().putAll(responseContext);
4417
4418 ((BindingProvider)port).getRequestContext().
4419 put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, url);
4420 String handle = port.iWebsessionManagerLogon(username, passwd);
4421 this.vbox = new IVirtualBox(handle, port);
4422 }
4423 catch (Throwable t)
4424 {
4425 if (this.port != null && pool != null)
4426 {
4427 pool.releasePort(this.port);
4428 this.port = null;
4429 }
4430 // we have to throw smth derived from RuntimeException
4431 throw new VBoxException(t.getMessage(), t, this.port);
4432 }
4433 }
4434
4435 public void disconnect()
4436 {
4437 if (this.port == null)
4438 return;
4439
4440 try
4441 {
4442 if (this.vbox != null && port != null)
4443 port.iWebsessionManagerLogoff(this.vbox.getWrapped());
4444 }
4445 catch (InvalidObjectFaultMsg e)
4446 {
4447 throw new VBoxException(e.getMessage(), e, this.port);
4448 }
4449 catch (RuntimeFaultMsg e)
4450 {
4451 throw new VBoxException(e.getMessage(), e, this.port);
4452 }
4453 finally
4454 {
4455 if (this.port != null)
4456 {
4457 pool.releasePort(this.port);
4458 this.port = null;
4459 }
4460 }
4461 }
4462
4463 public IVirtualBox getVBox()
4464 {
4465 return this.vbox;
4466 }
4467
4468 public ISession getSessionObject()
4469 {
4470 if (this.vbox == null)
4471 throw new VBoxException("connect first");
4472 try
4473 {
4474 String handle = port.iWebsessionManagerGetSessionObject(this.vbox.getWrapped());
4475 return new ISession(handle, port);
4476 }
4477 catch (InvalidObjectFaultMsg e)
4478 {
4479 throw new VBoxException(e.getMessage(), e, this.port);
4480 }
4481 catch (RuntimeFaultMsg e)
4482 {
4483 throw new VBoxException(e.getMessage(), e, this.port);
4484 }
4485 }
4486
4487 public ISession openMachineSession(IMachine m) throws Exception
4488 {
4489 ISession s = getSessionObject();
4490 m.lockMachine(s, LockType.Shared);
4491 return s;
4492 }
4493
4494 public void closeMachineSession(ISession s)
4495 {
4496 if (s != null)
4497 s.unlockMachine();
4498 }
4499
4500 public static synchronized VirtualBoxManager createInstance(String home)
4501 {
4502 return new VirtualBoxManager();
4503 }
4504
4505 public IEventListener createListener(Object sink)
4506 {
4507 throw new VBoxException("no active listeners here");
4508 }
4509
4510 public void cleanup()
4511 {
4512 disconnect();
4513 deinitPerThread();
4514 }
4515
4516 public void waitForEvents(long tmo)
4517 {
4518 }
4519
4520 protected void finalize() throws Throwable
4521 {
4522 try
4523 {
4524 cleanup();
4525 }
4526 catch(Exception e)
4527 {
4528 }
4529 finally
4530 {
4531 super.finalize();
4532 }
4533 }
4534}
4535]]></xsl:text>
4536 </xsl:if>
4537
4538 <xsl:call-template name="endFile">
4539 <xsl:with-param name="file" select="'VirtualBoxManager.java'" />
4540 </xsl:call-template>
4541</xsl:template>
4542
4543
4544<xsl:template match="/">
4545
4546 <xsl:if test="not($G_vboxApiSuffix)">
4547 <xsl:call-template name="fatalError">
4548 <xsl:with-param name="msg" select="'G_vboxApiSuffix must be given'" />
4549 </xsl:call-template>
4550 </xsl:if>
4551
4552 <xsl:if test="not($filelistonly='')">
4553 <xsl:value-of select="concat($filelistonly, ' := \&#10;')"/>
4554 </xsl:if>
4555
4556 <!-- Handwritten files -->
4557 <xsl:call-template name="emitHandwritten"/>
4558
4559 <xsl:choose>
4560 <xsl:when test="$G_vboxGlueStyle='xpcom'">
4561 <xsl:call-template name="emitHandwrittenXpcom"/>
4562 </xsl:when>
4563
4564 <xsl:when test="$G_vboxGlueStyle='mscom'">
4565 <xsl:call-template name="emitHandwrittenMscom"/>
4566 </xsl:when>
4567
4568 <xsl:when test="$G_vboxGlueStyle='jaxws'">
4569 <xsl:call-template name="emitHandwrittenJaxws"/>
4570 </xsl:when>
4571
4572 <xsl:otherwise>
4573 <xsl:call-template name="fatalError">
4574 <xsl:with-param name="msg" select="'Style unknown (root)'" />
4575 </xsl:call-template>
4576 </xsl:otherwise>
4577 </xsl:choose>
4578
4579 <!-- Enums -->
4580 <xsl:for-each select="//enum">
4581 <xsl:call-template name="genEnum">
4582 <xsl:with-param name="enumname" select="@name" />
4583 <xsl:with-param name="filename" select="concat(@name, '.java')" />
4584 </xsl:call-template>
4585 </xsl:for-each>
4586
4587 <!-- Interfaces -->
4588 <xsl:for-each select="//interface">
4589 <xsl:variable name="self_target" select="current()/ancestor::if/@target"/>
4590 <xsl:variable name="module" select="current()/ancestor::module/@name"/>
4591
4592 <xsl:choose>
4593 <xsl:when test="$G_vboxGlueStyle='jaxws'">
4594 <xsl:if test="not($module) and not(@wsmap='suppress')">
4595 <xsl:call-template name="genIface">
4596 <xsl:with-param name="ifname" select="@name" />
4597 <xsl:with-param name="filename" select="concat(@name, '.java')" />
4598 </xsl:call-template>
4599 </xsl:if>
4600 </xsl:when>
4601
4602 <xsl:otherwise>
4603 <!-- We don't need WSDL-specific interfaces here -->
4604 <xsl:if test="not(@internal='yes') and not($self_target='wsdl') and not($module)">
4605 <xsl:call-template name="genIface">
4606 <xsl:with-param name="ifname" select="@name" />
4607 <xsl:with-param name="filename" select="concat(@name, '.java')" />
4608 </xsl:call-template>
4609 </xsl:if>
4610 </xsl:otherwise>
4611
4612 </xsl:choose>
4613 </xsl:for-each>
4614
4615 <xsl:if test="not($filelistonly='')">
4616 <xsl:value-of select="'&#10;'"/>
4617 </xsl:if>
4618
4619</xsl:template>
4620</xsl:stylesheet>
Note: See TracBrowser for help on using the repository browser.

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