Branch data Line data Source code
1 : : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : : /*
3 : : * This file is part of the LibreOffice project.
4 : : *
5 : : * This Source Code Form is subject to the terms of the Mozilla Public
6 : : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : : *
9 : : * This file incorporates work covered by the following license notice:
10 : : *
11 : : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : : * contributor license agreements. See the NOTICE file distributed
13 : : * with this work for additional information regarding copyright
14 : : * ownership. The ASF licenses this file to you under the Apache
15 : : * License, Version 2.0 (the "License"); you may not use this file
16 : : * except in compliance with the License. You may obtain a copy of
17 : : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : : */
19 : :
20 : :
21 : : #include "javatype.hxx"
22 : :
23 : : #include "classfile.hxx"
24 : : #include "javaoptions.hxx"
25 : :
26 : : #include "codemaker/exceptiontree.hxx"
27 : : #include "codemaker/generatedtypeset.hxx"
28 : : #include "codemaker/global.hxx"
29 : : #include "codemaker/options.hxx"
30 : : #include "codemaker/typemanager.hxx"
31 : : #include "codemaker/unotype.hxx"
32 : : #include "codemaker/commonjava.hxx"
33 : :
34 : : #include "osl/diagnose.h"
35 : : #include "registry/reader.hxx"
36 : : #include "registry/refltype.hxx"
37 : : #include "registry/types.h"
38 : : #include "rtl/strbuf.hxx"
39 : : #include "rtl/string.h"
40 : : #include "rtl/string.hxx"
41 : : #include "rtl/textcvt.h"
42 : : #include "rtl/textenc.h"
43 : : #include "rtl/ustring.h"
44 : : #include "rtl/ustring.hxx"
45 : : #include "sal/types.h"
46 : :
47 : : #include <algorithm>
48 : : #include <list>
49 : : #include <map>
50 : : #include <memory>
51 : : #include <set>
52 : : #include <utility>
53 : : #include <vector>
54 : :
55 : : using codemaker::javamaker::ClassFile;
56 : :
57 : : namespace {
58 : :
59 : : // helper function for createUnoName
60 : 279 : void appendUnoName(
61 : : TypeManager const & manager, rtl::OString const & nucleus, sal_Int32 rank,
62 : : std::vector< rtl::OString > const & arguments, rtl::OStringBuffer * buffer)
63 : : {
64 : : OSL_ASSERT(rank >= 0 && buffer != 0);
65 [ + + ]: 345 : for (sal_Int32 i = 0; i < rank; ++i) {
66 : 66 : buffer->append(RTL_CONSTASCII_STRINGPARAM("[]"));
67 : : }
68 [ + - ]: 279 : buffer->append(nucleus.replace('/', '.'));
69 [ + + ]: 279 : if (!arguments.empty()) {
70 : 123 : buffer->append('<');
71 [ + + ][ + - ]: 566 : for (std::vector< rtl::OString >::const_iterator i(arguments.begin());
72 : 283 : i != arguments.end(); ++i)
73 : : {
74 [ + - ][ + + ]: 160 : if (i != arguments.begin()) {
75 [ + - ]: 37 : buffer->append(',');
76 : : }
77 : : RTTypeClass argTypeClass;
78 : 160 : rtl::OString argNucleus;
79 : : sal_Int32 argRank;
80 [ + - ]: 160 : std::vector< rtl::OString > argArgs;
81 : : codemaker::decomposeAndResolve(
82 : 160 : manager, *i, true, false, false, &argTypeClass, &argNucleus,
83 [ + - ]: 160 : &argRank, &argArgs);
84 [ + - ]: 160 : appendUnoName(manager, argNucleus, argRank, argArgs, buffer);
85 : 160 : }
86 : 123 : buffer->append('>');
87 : : }
88 : 279 : }
89 : :
90 : : // Translate the name of a UNO type registry entity (enum type, plain struct
91 : : // type, polymorphic struct type template, or interface type, decomposed into
92 : : // nucleus, rank, and arguments) into a core UNO type name:
93 : 119 : rtl::OString createUnoName(
94 : : TypeManager const & manager, rtl::OString const & nucleus, sal_Int32 rank,
95 : : std::vector< rtl::OString > const & arguments)
96 : : {
97 : 119 : rtl::OStringBuffer buf;
98 [ + - ]: 119 : appendUnoName(manager, nucleus, rank, arguments, &buf);
99 : 119 : return buf.makeStringAndClear();
100 : : }
101 : :
102 : : /**
103 : : Set of UTF-8--encoded names of UNO type registry entities a given UNO type
104 : : registry entity depends on.
105 : :
106 : : UNO type registry entities are enum types, plain struct types, polymorphic
107 : : struct type templates, exception types, interface types, typedefs, modules,
108 : : constant groupds, single-interface--based services, accumulation-based
109 : : services, interface-based singletons, and service-based singletons.
110 : : */
111 : : typedef std::set< rtl::OString > Dependencies;
112 : :
113 : : enum SpecialType {
114 : : SPECIAL_TYPE_NONE,
115 : : SPECIAL_TYPE_ANY,
116 : : SPECIAL_TYPE_UNSIGNED,
117 : : SPECIAL_TYPE_INTERFACE
118 : : };
119 : :
120 : 11350 : bool isSpecialType(SpecialType special) {
121 : 11350 : return special >= SPECIAL_TYPE_UNSIGNED;
122 : : }
123 : :
124 : 361 : rtl::OString translateUnoTypeToJavaFullyQualifiedName(
125 : : rtl::OString const & type, rtl::OString const & prefix)
126 : : {
127 : 361 : sal_Int32 i = type.lastIndexOf('/') + 1;
128 : : return type.copy(0, i) +
129 [ + - ]: 361 : codemaker::java::translateUnoToJavaIdentifier(type.copy(i), prefix);
130 : : }
131 : :
132 : 127915 : struct PolymorphicUnoType {
133 : 27841 : PolymorphicUnoType(): kind(KIND_NONE) {}
134 : :
135 : : enum Kind { KIND_NONE, KIND_STRUCT, KIND_SEQUENCE };
136 : : Kind kind;
137 : : rtl::OString name;
138 : : };
139 : :
140 : : SpecialType translateUnoTypeToDescriptor(
141 : : TypeManager const & manager, rtl::OString const & type, bool array,
142 : : bool classType, Dependencies * dependencies,
143 : : rtl::OStringBuffer * descriptor, rtl::OStringBuffer * signature,
144 : : bool * needsSignature, PolymorphicUnoType * polymorphicUnoType);
145 : :
146 : 48237 : SpecialType translateUnoTypeToDescriptor(
147 : : TypeManager const & manager, codemaker::UnoType::Sort sort,
148 : : RTTypeClass typeClass, rtl::OString const & nucleus, sal_Int32 rank,
149 : : std::vector< rtl::OString > const & arguments, bool array, bool classType,
150 : : Dependencies * dependencies, rtl::OStringBuffer * descriptor,
151 : : rtl::OStringBuffer * signature, bool * needsSignature,
152 : : PolymorphicUnoType * polymorphicUnoType)
153 : : {
154 : : OSL_ASSERT(rank >= 0 && (signature == 0) == (needsSignature == 0));
155 [ + + ][ - + ]: 48237 : if (rank > 0xFF - (array ? 1 : 0)) {
156 : : throw CannotDumpException(
157 : : rtl::OString(
158 : : RTL_CONSTASCII_STRINGPARAM(
159 : 0 : "Too many array dimensions for Java class file format")));
160 : : }
161 [ + + ]: 48237 : if (array) {
162 : 379 : ++rank;
163 : : }
164 [ + + ]: 52075 : for (sal_Int32 i = 0; i < rank; ++i) {
165 [ + + ]: 3838 : if (descriptor != 0) {
166 : 3813 : descriptor->append('[');
167 : : }
168 [ + + ]: 3838 : if (signature != 0) {
169 : 3539 : signature->append('[');
170 : : }
171 : : }
172 [ + + ]: 48237 : if (sort == codemaker::UnoType::SORT_COMPLEX) {
173 : : //TODO: check that nucleus is a valid (Java-modified UTF-8) identifier
174 : 12192 : rtl::OString superClass;
175 [ + + ]: 31294 : if (typeClass == RT_TYPE_INTERFACE
[ + + + + ]
176 : : && (nucleus
177 : : == rtl::OString(
178 [ + + ]: 19102 : RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/XInterface"))))
179 : : {
180 [ + + ]: 1007 : if (descriptor != 0) {
181 : : descriptor->append(
182 : : rtl::OString(
183 [ + - ]: 1005 : RTL_CONSTASCII_STRINGPARAM("Ljava/lang/Object;")));
184 : : }
185 [ + + ]: 1007 : if (signature != 0) {
186 : : signature->append(
187 : : rtl::OString(
188 [ + - ]: 1005 : RTL_CONSTASCII_STRINGPARAM("Ljava/lang/Object;")));
189 : : }
190 [ + + ]: 1007 : if (polymorphicUnoType != 0) {
191 : 252 : polymorphicUnoType->kind = PolymorphicUnoType::KIND_NONE;
192 : : }
193 : 1007 : return SPECIAL_TYPE_INTERFACE;
194 : : } else {
195 [ + + ]: 11185 : if (dependencies != 0) {
196 [ + - ]: 10805 : dependencies->insert(nucleus);
197 : : }
198 [ + + ]: 11185 : if (descriptor != 0) {
199 [ + - ]: 11149 : descriptor->append('L');
200 [ + - ]: 11149 : descriptor->append(nucleus);
201 [ + - ]: 11149 : descriptor->append(';');
202 : : }
203 [ + + ]: 11185 : if (signature != 0) {
204 [ + - ]: 10671 : signature->append('L');
205 [ + - ]: 10671 : signature->append(nucleus);
206 [ + + ]: 10671 : if (!arguments.empty()) {
207 [ + - ]: 139 : signature->append('<');
208 [ + - ][ + + ]: 630 : for (std::vector< rtl::OString >::const_iterator i(
209 : 139 : arguments.begin());
210 : 315 : i != arguments.end(); ++i)
211 : : {
212 : : translateUnoTypeToDescriptor(
213 : 176 : manager, *i, false, true, dependencies, 0,
214 [ + - ]: 176 : signature, needsSignature, 0);
215 : : }
216 [ + - ]: 139 : signature->append('>');
217 : 139 : *needsSignature = true;
218 : : }
219 [ + - ]: 10671 : signature->append(';');
220 : : }
221 [ + + ]: 11185 : if (polymorphicUnoType != 0) {
222 [ + + ]: 8173 : if (arguments.empty()) {
223 : 8127 : polymorphicUnoType->kind = PolymorphicUnoType::KIND_NONE;
224 : : } else {
225 : : polymorphicUnoType->kind = rank == 0
226 : : ? PolymorphicUnoType::KIND_STRUCT
227 [ + + ]: 46 : : PolymorphicUnoType::KIND_SEQUENCE;
228 : : polymorphicUnoType->name = createUnoName(
229 [ + - ]: 46 : manager, nucleus, rank, arguments);
230 : : }
231 : : }
232 : 11185 : return SPECIAL_TYPE_NONE;
233 : 12192 : }
234 : : } else {
235 : : static rtl::OString const
236 : : simpleTypeDescriptors[codemaker::UnoType::SORT_ANY + 1][2] = {
237 : : { rtl::OString(RTL_CONSTASCII_STRINGPARAM("V")),
238 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("Ljava/lang/Void;"))
239 : : },
240 : : { rtl::OString(RTL_CONSTASCII_STRINGPARAM("Z")),
241 : : rtl::OString(
242 : : RTL_CONSTASCII_STRINGPARAM("Ljava/lang/Boolean;"))
243 : : },
244 : : { rtl::OString(RTL_CONSTASCII_STRINGPARAM("B")),
245 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("Ljava/lang/Byte;"))
246 : : },
247 : : { rtl::OString(RTL_CONSTASCII_STRINGPARAM("S")),
248 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("Ljava/lang/Short;"))
249 : : },
250 : : { rtl::OString(RTL_CONSTASCII_STRINGPARAM("S")),
251 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("Ljava/lang/Short;"))
252 : : },
253 : : { rtl::OString(RTL_CONSTASCII_STRINGPARAM("I")),
254 : : rtl::OString(
255 : : RTL_CONSTASCII_STRINGPARAM("Ljava/lang/Integer;"))
256 : : },
257 : : { rtl::OString(RTL_CONSTASCII_STRINGPARAM("I")),
258 : : rtl::OString(
259 : : RTL_CONSTASCII_STRINGPARAM("Ljava/lang/Integer;"))
260 : : },
261 : : { rtl::OString(RTL_CONSTASCII_STRINGPARAM("J")),
262 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("Ljava/lang/Long;"))
263 : : },
264 : : { rtl::OString(RTL_CONSTASCII_STRINGPARAM("J")),
265 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("Ljava/lang/Long;"))
266 : : },
267 : : { rtl::OString(RTL_CONSTASCII_STRINGPARAM("F")),
268 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("Ljava/lang/Float;"))
269 : : },
270 : : { rtl::OString(RTL_CONSTASCII_STRINGPARAM("D")),
271 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("Ljava/lang/Double;"))
272 : : },
273 : : { rtl::OString(RTL_CONSTASCII_STRINGPARAM("C")),
274 : : rtl::OString(
275 : : RTL_CONSTASCII_STRINGPARAM("Ljava/lang/Character;"))
276 : : },
277 : : { rtl::OString(
278 : : RTL_CONSTASCII_STRINGPARAM("Ljava/lang/String;")),
279 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("Ljava/lang/String;"))
280 : : },
281 : : { rtl::OString(
282 : : RTL_CONSTASCII_STRINGPARAM("Lcom/sun/star/uno/Type;")),
283 : : rtl::OString(
284 : : RTL_CONSTASCII_STRINGPARAM("Lcom/sun/star/uno/Type;"))
285 : : },
286 : : { rtl::OString(
287 : : RTL_CONSTASCII_STRINGPARAM("Ljava/lang/Object;")),
288 : : rtl::OString(
289 : : RTL_CONSTASCII_STRINGPARAM("Ljava/lang/Object;"))
290 [ + + ][ + - ]: 36231 : } };
[ + + ]
291 : : rtl::OString const & s
292 [ + + ][ + + ]: 36045 : = simpleTypeDescriptors[sort][rank == 0 && classType];
293 [ + + ]: 36045 : if (descriptor != 0) {
294 : 35907 : descriptor->append(s);
295 : : }
296 [ + + ]: 36045 : if (signature != 0) {
297 : 35894 : signature->append(s);
298 : : }
299 [ + + ]: 36045 : if (polymorphicUnoType != 0) {
300 : 19403 : polymorphicUnoType->kind = PolymorphicUnoType::KIND_NONE;
301 : : }
302 : : static SpecialType const
303 : : simpleTypeSpecials[codemaker::UnoType::SORT_ANY + 1] = {
304 : : SPECIAL_TYPE_NONE, SPECIAL_TYPE_NONE, SPECIAL_TYPE_NONE,
305 : : SPECIAL_TYPE_NONE, SPECIAL_TYPE_UNSIGNED, SPECIAL_TYPE_NONE,
306 : : SPECIAL_TYPE_UNSIGNED, SPECIAL_TYPE_NONE, SPECIAL_TYPE_UNSIGNED,
307 : : SPECIAL_TYPE_NONE, SPECIAL_TYPE_NONE, SPECIAL_TYPE_NONE,
308 : : SPECIAL_TYPE_NONE, SPECIAL_TYPE_NONE, SPECIAL_TYPE_ANY };
309 : 48237 : return simpleTypeSpecials[sort];
310 : : }
311 : : }
312 : :
313 : 47570 : SpecialType translateUnoTypeToDescriptor(
314 : : TypeManager const & manager, rtl::OString const & type, bool array,
315 : : bool classType, Dependencies * dependencies,
316 : : rtl::OStringBuffer * descriptor, rtl::OStringBuffer * signature,
317 : : bool * needsSignature, PolymorphicUnoType * polymorphicUnoType)
318 : : {
319 : : RTTypeClass typeClass;
320 : 47570 : rtl::OString nucleus;
321 : : sal_Int32 rank;
322 [ + - ]: 47570 : std::vector< rtl::OString > args;
323 : : codemaker::UnoType::Sort sort = codemaker::decomposeAndResolve(
324 [ + - ]: 47570 : manager, type, true, true, false, &typeClass, &nucleus, &rank, &args);
325 : : OSL_ASSERT(rank < SAL_MAX_INT32);
326 : : return translateUnoTypeToDescriptor(
327 : : manager, sort, typeClass, nucleus, rank, args, array, classType,
328 : : dependencies, descriptor, signature, needsSignature,
329 [ + - ]: 47570 : polymorphicUnoType);
330 : : }
331 : :
332 : 13742 : SpecialType getFieldDescriptor(
333 : : TypeManager const & manager, Dependencies * dependencies,
334 : : rtl::OString const & type, rtl::OString * descriptor,
335 : : rtl::OString * signature, PolymorphicUnoType * polymorphicUnoType)
336 : : {
337 : : OSL_ASSERT(dependencies != 0 && descriptor != 0);
338 : 13742 : rtl::OStringBuffer desc;
339 : 13742 : rtl::OStringBuffer sig;
340 : 13742 : bool needsSig = false;
341 : : SpecialType specialType = translateUnoTypeToDescriptor(
342 : : manager, type, false, false, dependencies, &desc, &sig, &needsSig,
343 [ + - ]: 13742 : polymorphicUnoType);
344 : 13742 : *descriptor = desc.makeStringAndClear();
345 [ + + ]: 13742 : if (signature != 0) {
346 [ + + ]: 10185 : if (needsSig) {
347 : 4 : *signature = sig.makeStringAndClear();
348 : : } else {
349 : 10181 : *signature = rtl::OString();
350 : : }
351 : : }
352 : 13742 : return specialType;
353 : : }
354 : :
355 : 15167 : class MethodDescriptor {
356 : : public:
357 : : MethodDescriptor(
358 : : TypeManager const & manager, Dependencies * dependencies,
359 : : rtl::OString const & returnType, SpecialType * specialReturnType,
360 : : PolymorphicUnoType * polymorphicUnoType);
361 : :
362 : : SpecialType addParameter(
363 : : rtl::OString const & type, bool array, bool dependency,
364 : : PolymorphicUnoType * polymorphicUnoType);
365 : :
366 : : void addTypeParameter(rtl::OString const & name);
367 : :
368 : : rtl::OString getDescriptor() const;
369 : :
370 : : rtl::OString getSignature() const;
371 : :
372 : : private:
373 : : TypeManager const & m_manager;
374 : : Dependencies * m_dependencies;
375 : : rtl::OStringBuffer m_descriptorStart;
376 : : rtl::OString m_descriptorEnd;
377 : : rtl::OStringBuffer m_signatureStart;
378 : : rtl::OString m_signatureEnd;
379 : : bool m_needsSignature;
380 : : };
381 : :
382 : 15167 : MethodDescriptor::MethodDescriptor(
383 : : TypeManager const & manager, Dependencies * dependencies,
384 : : rtl::OString const & returnType, SpecialType * specialReturnType,
385 : : PolymorphicUnoType * polymorphicUnoType):
386 : 15167 : m_manager(manager), m_dependencies(dependencies), m_needsSignature(false)
387 : : {
388 : : OSL_ASSERT(dependencies != 0);
389 [ + - ]: 15167 : m_descriptorStart.append('(');
390 [ + - ]: 15167 : m_signatureStart.append('(');
391 : 15167 : rtl::OStringBuffer descEnd;
392 [ + - ]: 15167 : descEnd.append(')');
393 : 15167 : rtl::OStringBuffer sigEnd;
394 [ + - ]: 15167 : sigEnd.append(')');
395 : : SpecialType special = translateUnoTypeToDescriptor(
396 : : m_manager, returnType, false, false, m_dependencies, &descEnd, &sigEnd,
397 [ + - ]: 15167 : &m_needsSignature, polymorphicUnoType);
398 : 15167 : m_descriptorEnd = descEnd.makeStringAndClear();
399 : 15167 : m_signatureEnd = sigEnd.makeStringAndClear();
400 [ + + ]: 15167 : if (specialReturnType != 0) {
401 : 12543 : *specialReturnType = special;
402 : 15167 : }
403 : 15167 : }
404 : :
405 : 18485 : SpecialType MethodDescriptor::addParameter(
406 : : rtl::OString const & type, bool array, bool dependency,
407 : : PolymorphicUnoType * polymorphicUnoType)
408 : : {
409 : : return translateUnoTypeToDescriptor(
410 : : m_manager, type, array, false, dependency ? m_dependencies : 0,
411 : : &m_descriptorStart, &m_signatureStart, &m_needsSignature,
412 [ + + ]: 18485 : polymorphicUnoType);
413 : : }
414 : :
415 : 13 : void MethodDescriptor::addTypeParameter(rtl::OString const & name) {
416 : 13 : m_descriptorStart.append(RTL_CONSTASCII_STRINGPARAM("Ljava/lang/Object;"));
417 : 13 : m_signatureStart.append('T');
418 : 13 : m_signatureStart.append(name);
419 : 13 : m_signatureStart.append(';');
420 : 13 : m_needsSignature = true;
421 : 13 : }
422 : :
423 : 16560 : rtl::OString MethodDescriptor::getDescriptor() const {
424 [ + - ]: 16560 : rtl::OStringBuffer buf(m_descriptorStart);
425 [ + - ]: 16560 : buf.append(m_descriptorEnd);
426 : 16560 : return buf.makeStringAndClear();
427 : : }
428 : :
429 : 15167 : rtl::OString MethodDescriptor::getSignature() const {
430 [ + + ]: 15167 : if (m_needsSignature) {
431 [ + - ]: 64 : rtl::OStringBuffer buf(m_signatureStart);
432 [ + - ]: 64 : buf.append(m_signatureEnd);
433 : 64 : return buf.makeStringAndClear();
434 : : } else {
435 : 15167 : return rtl::OString();
436 : : }
437 : : }
438 : :
439 : 83432 : class TypeInfo {
440 : : public:
441 : : enum Kind { KIND_MEMBER, KIND_ATTRIBUTE, KIND_METHOD, KIND_PARAMETER };
442 : :
443 : : // Same values as in com/sun/star/lib/uno/typeinfo/TypeInfo.java:
444 : : enum Flags {
445 : : FLAG_READONLY = 0x008, FLAG_BOUND = 0x100, FLAG_ONEWAY = 0x010
446 : : };
447 : :
448 : : // KIND_MEMBER:
449 : : TypeInfo(
450 : : rtl::OString const & name, SpecialType specialType, sal_Int32 index,
451 : : PolymorphicUnoType const & polymorphicUnoType,
452 : : sal_Int32 typeParameterIndex);
453 : :
454 : : // KIND_ATTRIBUTE/METHOD:
455 : : TypeInfo(
456 : : Kind kind, rtl::OString const & name, SpecialType specialType,
457 : : Flags flags, sal_Int32 index,
458 : : PolymorphicUnoType const & polymorphicUnoType);
459 : :
460 : : // KIND_PARAMETER:
461 : : TypeInfo(
462 : : rtl::OString const & parameterName, SpecialType specialType,
463 : : bool inParameter, bool outParameter, rtl::OString const & methodName,
464 : : sal_Int32 index, PolymorphicUnoType const & polymorphicUnoType);
465 : :
466 : : sal_uInt16 generateCode(ClassFile::Code & code, Dependencies * dependencies)
467 : : const;
468 : :
469 : : void generatePolymorphicUnoTypeCode(
470 : : ClassFile::Code & code, Dependencies * dependencies) const;
471 : :
472 : : private:
473 : : Kind m_kind;
474 : : rtl::OString m_name;
475 : : sal_Int32 m_flags;
476 : : sal_Int32 m_index;
477 : : rtl::OString m_methodName;
478 : : PolymorphicUnoType m_polymorphicUnoType;
479 : : sal_Int32 m_typeParameterIndex;
480 : : };
481 : :
482 : 16642 : sal_Int32 translateSpecialTypeFlags(
483 : : SpecialType specialType, bool inParameter, bool outParameter)
484 : : {
485 : : static sal_Int32 const specialTypeFlags[SPECIAL_TYPE_INTERFACE + 1] = {
486 : : 0, 0x0040 /* ANY */, 0x0004 /* UNSIGNED */, 0x0080 /* INTERFACE */ };
487 : 16642 : sal_Int32 flags = specialTypeFlags[specialType];
488 [ + + ]: 16642 : if (inParameter) {
489 : 295 : flags |= 0x0001; /* IN */
490 : : }
491 [ + + ]: 16642 : if (outParameter) {
492 : 378 : flags |= 0x0002; /* OUT */
493 : : }
494 : 16642 : return flags;
495 : : }
496 : :
497 : 3570 : TypeInfo::TypeInfo(
498 : : rtl::OString const & name, SpecialType specialType, sal_Int32 index,
499 : : PolymorphicUnoType const & polymorphicUnoType,
500 : : sal_Int32 typeParameterIndex):
501 : : m_kind(KIND_MEMBER), m_name(name),
502 : 3570 : m_flags(translateSpecialTypeFlags(specialType, false, false)),
503 : : m_index(index), m_polymorphicUnoType(polymorphicUnoType),
504 : 7140 : m_typeParameterIndex(typeParameterIndex)
505 : : {
506 : : OSL_ASSERT(
507 : : polymorphicUnoType.kind == PolymorphicUnoType::KIND_NONE
508 : : ? typeParameterIndex >= -1 : typeParameterIndex == -1);
509 : 3570 : }
510 : :
511 : 12543 : TypeInfo::TypeInfo(
512 : : Kind kind, rtl::OString const & name, SpecialType specialType,
513 : : Flags flags, sal_Int32 index,
514 : : PolymorphicUnoType const & polymorphicUnoType):
515 : : m_kind(kind), m_name(name),
516 : 12543 : m_flags(flags | translateSpecialTypeFlags(specialType, false, false)),
517 : 25086 : m_index(index), m_polymorphicUnoType(polymorphicUnoType)
518 : : {
519 : : OSL_ASSERT(kind == KIND_ATTRIBUTE || kind == KIND_METHOD);
520 : 12543 : }
521 : :
522 : 529 : TypeInfo::TypeInfo(
523 : : rtl::OString const & parameterName, SpecialType specialType,
524 : : bool inParameter, bool outParameter, rtl::OString const & methodName,
525 : : sal_Int32 index, PolymorphicUnoType const & polymorphicUnoType):
526 : : m_kind(KIND_PARAMETER), m_name(parameterName),
527 : 529 : m_flags(translateSpecialTypeFlags(specialType, inParameter, outParameter)),
528 : : m_index(index), m_methodName(methodName),
529 : 1058 : m_polymorphicUnoType(polymorphicUnoType)
530 : 529 : {}
531 : :
532 : 16642 : sal_uInt16 TypeInfo::generateCode(
533 : : ClassFile::Code & code, Dependencies * dependencies) const
534 : : {
535 : : OSL_ASSERT(dependencies != 0);
536 [ + + + + : 16642 : switch (m_kind) {
- ]
537 : : case KIND_MEMBER:
538 : : code.instrNew(
539 : : rtl::OString(
540 : : RTL_CONSTASCII_STRINGPARAM(
541 [ + - ]: 3570 : "com/sun/star/lib/uno/typeinfo/MemberTypeInfo")));
542 : 3570 : code.instrDup();
543 : 3570 : code.loadStringConstant(m_name);
544 : 3570 : code.loadIntegerConstant(m_index);
545 : 3570 : code.loadIntegerConstant(m_flags);
546 [ + + ]: 3570 : if (m_polymorphicUnoType.kind != PolymorphicUnoType::KIND_NONE) {
547 : 4 : generatePolymorphicUnoTypeCode(code, dependencies);
548 : 4 : code.loadIntegerConstant(m_typeParameterIndex);
549 : : code.instrInvokespecial(
550 : : rtl::OString(
551 : : RTL_CONSTASCII_STRINGPARAM(
552 : : "com/sun/star/lib/uno/typeinfo/MemberTypeInfo")),
553 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
554 : : rtl::OString(
555 : : RTL_CONSTASCII_STRINGPARAM(
556 [ + - ]: 4 : "(Ljava/lang/String;IILcom/sun/star/uno/Type;I)V")));
557 : 4 : return 8;
558 [ + + ]: 3566 : } else if (m_typeParameterIndex >= 0) {
559 : 13 : code.instrAconstNull();
560 : 13 : code.loadIntegerConstant(m_typeParameterIndex);
561 : : code.instrInvokespecial(
562 : : rtl::OString(
563 : : RTL_CONSTASCII_STRINGPARAM(
564 : : "com/sun/star/lib/uno/typeinfo/MemberTypeInfo")),
565 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
566 : : rtl::OString(
567 : : RTL_CONSTASCII_STRINGPARAM(
568 [ + - ]: 13 : "(Ljava/lang/String;IILcom/sun/star/uno/Type;I)V")));
569 : 13 : return 6;
570 : : } else {
571 : : code.instrInvokespecial(
572 : : rtl::OString(
573 : : RTL_CONSTASCII_STRINGPARAM(
574 : : "com/sun/star/lib/uno/typeinfo/MemberTypeInfo")),
575 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
576 : : rtl::OString(
577 [ + - ]: 3553 : RTL_CONSTASCII_STRINGPARAM("(Ljava/lang/String;II)V")));
578 : 3553 : return 4;
579 : : }
580 : :
581 : : case KIND_ATTRIBUTE:
582 : : code.instrNew(
583 : : rtl::OString(
584 : : RTL_CONSTASCII_STRINGPARAM(
585 [ + - ]: 1116 : "com/sun/star/lib/uno/typeinfo/AttributeTypeInfo")));
586 : 1116 : code.instrDup();
587 : 1116 : code.loadStringConstant(m_name);
588 : 1116 : code.loadIntegerConstant(m_index);
589 : 1116 : code.loadIntegerConstant(m_flags);
590 [ + + ]: 1116 : if (m_polymorphicUnoType.kind != PolymorphicUnoType::KIND_NONE) {
591 : 8 : generatePolymorphicUnoTypeCode(code, dependencies);
592 : : code.instrInvokespecial(
593 : : rtl::OString(
594 : : RTL_CONSTASCII_STRINGPARAM(
595 : : "com/sun/star/lib/uno/typeinfo/AttributeTypeInfo")),
596 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
597 : : rtl::OString(
598 : : RTL_CONSTASCII_STRINGPARAM(
599 [ + - ]: 8 : "(Ljava/lang/String;IILcom/sun/star/uno/Type;)V")));
600 : 8 : return 8;
601 : : } else {
602 : : code.instrInvokespecial(
603 : : rtl::OString(
604 : : RTL_CONSTASCII_STRINGPARAM(
605 : : "com/sun/star/lib/uno/typeinfo/AttributeTypeInfo")),
606 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
607 : : rtl::OString(
608 [ + - ]: 1108 : RTL_CONSTASCII_STRINGPARAM("(Ljava/lang/String;II)V")));
609 : 1108 : return 4;
610 : : }
611 : :
612 : : case KIND_METHOD:
613 : : code.instrNew(
614 : : rtl::OString(
615 : : RTL_CONSTASCII_STRINGPARAM(
616 [ + - ]: 11427 : "com/sun/star/lib/uno/typeinfo/MethodTypeInfo")));
617 : 11427 : code.instrDup();
618 : 11427 : code.loadStringConstant(m_name);
619 : 11427 : code.loadIntegerConstant(m_index);
620 : 11427 : code.loadIntegerConstant(m_flags);
621 [ + + ]: 11427 : if (m_polymorphicUnoType.kind != PolymorphicUnoType::KIND_NONE) {
622 : 28 : generatePolymorphicUnoTypeCode(code, dependencies);
623 : : code.instrInvokespecial(
624 : : rtl::OString(
625 : : RTL_CONSTASCII_STRINGPARAM(
626 : : "com/sun/star/lib/uno/typeinfo/MethodTypeInfo")),
627 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
628 : : rtl::OString(
629 : : RTL_CONSTASCII_STRINGPARAM(
630 [ + - ]: 28 : "(Ljava/lang/String;IILcom/sun/star/uno/Type;)V")));
631 : 28 : return 8;
632 : : } else {
633 : : code.instrInvokespecial(
634 : : rtl::OString(
635 : : RTL_CONSTASCII_STRINGPARAM(
636 : : "com/sun/star/lib/uno/typeinfo/MethodTypeInfo")),
637 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
638 : : rtl::OString(
639 [ + - ]: 11399 : RTL_CONSTASCII_STRINGPARAM("(Ljava/lang/String;II)V")));
640 : 11399 : return 4;
641 : : }
642 : :
643 : : case KIND_PARAMETER:
644 : : code.instrNew(
645 : : rtl::OString(
646 : : RTL_CONSTASCII_STRINGPARAM(
647 [ + - ]: 529 : "com/sun/star/lib/uno/typeinfo/ParameterTypeInfo")));
648 : 529 : code.instrDup();
649 : 529 : code.loadStringConstant(m_name);
650 : 529 : code.loadStringConstant(m_methodName);
651 : 529 : code.loadIntegerConstant(m_index);
652 : 529 : code.loadIntegerConstant(m_flags);
653 [ + + ]: 529 : if (m_polymorphicUnoType.kind != PolymorphicUnoType::KIND_NONE) {
654 : 6 : generatePolymorphicUnoTypeCode(code, dependencies);
655 : : code.instrInvokespecial(
656 : : rtl::OString(
657 : : RTL_CONSTASCII_STRINGPARAM(
658 : : "com/sun/star/lib/uno/typeinfo/ParameterTypeInfo")),
659 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
660 : : rtl::OString(
661 : : RTL_CONSTASCII_STRINGPARAM(
662 : : "(Ljava/lang/String;Ljava/lang/String;II"
663 [ + - ]: 6 : "Lcom/sun/star/uno/Type;)V")));
664 : 6 : return 9;
665 : : } else {
666 : : code.instrInvokespecial(
667 : : rtl::OString(
668 : : RTL_CONSTASCII_STRINGPARAM(
669 : : "com/sun/star/lib/uno/typeinfo/ParameterTypeInfo")),
670 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
671 : : rtl::OString(
672 : : RTL_CONSTASCII_STRINGPARAM(
673 [ + - ]: 523 : "(Ljava/lang/String;Ljava/lang/String;II)V")));
674 : 523 : return 5;
675 : : }
676 : :
677 : : default:
678 : : OSL_ASSERT(false);
679 : 16642 : return 0;
680 : : }
681 : : }
682 : :
683 : 46 : void TypeInfo::generatePolymorphicUnoTypeCode(
684 : : ClassFile::Code & code, Dependencies * dependencies) const
685 : : {
686 : : OSL_ASSERT(
687 : : dependencies != 0
688 : : && m_polymorphicUnoType.kind != PolymorphicUnoType::KIND_NONE);
689 : : code.instrNew(
690 [ + - ]: 46 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Type")));
691 : 46 : code.instrDup();
692 : 46 : code.loadStringConstant(m_polymorphicUnoType.name);
693 [ + + ]: 46 : if (m_polymorphicUnoType.kind == PolymorphicUnoType::KIND_STRUCT) {
694 : : code.instrGetstatic(
695 : : rtl::OString(
696 : : RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/TypeClass")),
697 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("STRUCT")),
698 : : rtl::OString(
699 [ + - ]: 40 : RTL_CONSTASCII_STRINGPARAM("Lcom/sun/star/uno/TypeClass;")));
700 : : } else {
701 : : code.instrGetstatic(
702 : : rtl::OString(
703 : : RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/TypeClass")),
704 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("SEQUENCE")),
705 : : rtl::OString(
706 [ + - ]: 6 : RTL_CONSTASCII_STRINGPARAM("Lcom/sun/star/uno/TypeClass;")));
707 : : }
708 : : dependencies->insert(
709 [ + - ]: 46 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/TypeClass")));
710 : : code.instrInvokespecial(
711 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Type")),
712 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
713 : : rtl::OString(
714 : : RTL_CONSTASCII_STRINGPARAM(
715 [ + - ]: 46 : "(Ljava/lang/String;Lcom/sun/star/uno/TypeClass;)V")));
716 : 46 : }
717 : :
718 : 6200 : void writeClassFile(
719 : : JavaOptions /*TODO const*/ & options, rtl::OString const & type,
720 : : ClassFile const & classFile)
721 : : {
722 : 6200 : rtl::OString path;
723 [ + - ][ + - ]: 6200 : if (options.isValid(rtl::OString(RTL_CONSTASCII_STRINGPARAM("-O")))) {
724 : : path = options.getOption(
725 [ + - ]: 6200 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("-O")));
726 : : }
727 : : rtl::OString filename(
728 : : createFileNameFromType(
729 [ + - ]: 6200 : path, type, rtl::OString(RTL_CONSTASCII_STRINGPARAM(".class"))));
730 : 6200 : bool check = false;
731 [ + + ][ + - ]: 6200 : if (fileExists(filename)) {
732 [ + - ][ - + ]: 416 : if (options.isValid(rtl::OString(RTL_CONSTASCII_STRINGPARAM("-G")))) {
733 : 6200 : return;
734 : : }
735 : : check = options.isValid(
736 [ + - ]: 416 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("-Gc")));
737 : : }
738 [ + - ]: 6200 : FileStream tempfile;
739 [ + - ][ + - ]: 6200 : tempfile.createTempFile(getTempDir(filename));
740 [ - + ][ + - ]: 6200 : if (!tempfile.isValid()) {
741 : : throw CannotDumpException(
742 : : rtl::OString(
743 : : RTL_CONSTASCII_STRINGPARAM("Cannot create temporary file for "))
744 : 0 : + filename);
745 : : }
746 : 6200 : rtl::OString tempname(tempfile.getName());
747 : : try {
748 [ + - ]: 6200 : classFile.write(tempfile);
749 : 0 : } catch (...) {
750 : : // Remove existing file for consistency:
751 [ # # # # ]: 0 : if (fileExists(filename)) {
752 [ # # ]: 0 : removeTypeFile(filename);
753 : : }
754 [ # # ]: 0 : tempfile.close();
755 [ # # ]: 0 : removeTypeFile(tempname);
756 : 0 : throw;
757 : : }
758 [ + - ]: 6200 : tempfile.close();
759 [ + - ][ - + ]: 6200 : if (!makeValidTypeFile(filename, tempname, check)) {
760 : 0 : rtl::OStringBuffer msg;
761 [ # # ]: 0 : msg.append(RTL_CONSTASCII_STRINGPARAM("Cannot create "));
762 [ # # ]: 0 : msg.append(filename);
763 [ # # ]: 0 : msg.append(RTL_CONSTASCII_STRINGPARAM(" from temporary file "));
764 [ # # ]: 0 : msg.append(tempname);
765 : 0 : throw CannotDumpException(msg.makeStringAndClear());
766 [ + - ][ - + ]: 6200 : }
[ + - ]
767 : : }
768 : :
769 : 4716 : void addTypeInfo(
770 : : rtl::OString const & className, std::vector< TypeInfo > const & typeInfo,
771 : : Dependencies * dependencies, ClassFile * classFile)
772 : : {
773 : : OSL_ASSERT(dependencies != 0 && classFile != 0);
774 : 4716 : std::vector< TypeInfo >::size_type typeInfos = typeInfo.size();
775 [ - + ]: 4716 : if (typeInfos > SAL_MAX_INT32) {
776 : : throw CannotDumpException(
777 : : rtl::OString(
778 : : RTL_CONSTASCII_STRINGPARAM(
779 : 0 : "UNOTYPEINFO array too big for Java class file format")));
780 : : }
781 [ + + ]: 4716 : if (typeInfos != 0) {
782 : : classFile->addField(
783 : : static_cast< ClassFile::AccessFlags >(
784 : : ClassFile::ACC_PUBLIC | ClassFile::ACC_STATIC
785 : : | ClassFile::ACC_FINAL),
786 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("UNOTYPEINFO")),
787 : : rtl::OString(
788 : : RTL_CONSTASCII_STRINGPARAM(
789 : : "[Lcom/sun/star/lib/uno/typeinfo/TypeInfo;")),
790 [ + - ]: 4320 : 0, rtl::OString());
791 : : SAL_WNODEPRECATED_DECLARATIONS_PUSH
792 [ + - ]: 4320 : std::auto_ptr< ClassFile::Code > code(classFile->newCode());
793 : : SAL_WNODEPRECATED_DECLARATIONS_POP
794 [ + - ]: 4320 : code->loadIntegerConstant(static_cast< sal_Int32 >(typeInfos));
795 : : code->instrAnewarray(
796 : : rtl::OString(
797 : : RTL_CONSTASCII_STRINGPARAM(
798 [ + - ]: 4320 : "com/sun/star/lib/uno/typeinfo/TypeInfo")));
799 : 4320 : sal_Int32 index = 0;
800 : 4320 : sal_uInt16 stack = 0;
801 [ + - ][ + + ]: 41924 : for (std::vector< TypeInfo >::const_iterator i(typeInfo.begin());
802 : 20962 : i != typeInfo.end(); ++i)
803 : : {
804 [ + - ]: 16642 : code->instrDup();
805 [ + - ]: 16642 : code->loadIntegerConstant(index++);
806 [ + - ][ + - ]: 16642 : stack = std::max(stack, i->generateCode(*code, dependencies));
807 [ + - ]: 16642 : code->instrAastore();
808 : : }
809 : : code->instrPutstatic(
810 : : className, rtl::OString(RTL_CONSTASCII_STRINGPARAM("UNOTYPEINFO")),
811 : : rtl::OString(
812 : : RTL_CONSTASCII_STRINGPARAM(
813 [ + - ]: 4320 : "[Lcom/sun/star/lib/uno/typeinfo/TypeInfo;")));
814 [ + - ]: 4320 : code->instrReturn();
815 [ - + ]: 4320 : if (stack > SAL_MAX_UINT16 - 4) {
816 : : throw CannotDumpException(
817 : : rtl::OString(
818 : : RTL_CONSTASCII_STRINGPARAM(
819 : 0 : "Stack too big for Java class file format")));
820 : : }
821 : 4320 : code->setMaxStackAndLocals(static_cast< sal_uInt16 >(stack + 4), 0);
822 : : classFile->addMethod(
823 : : static_cast< ClassFile::AccessFlags >(
824 : : ClassFile::ACC_PRIVATE | ClassFile::ACC_STATIC),
825 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("<clinit>")),
826 : 4320 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("()V")), code.get(),
827 [ + - ]: 8640 : std::vector< rtl::OString >(), rtl::OString());
[ + - + - ]
828 : : }
829 : 4716 : }
830 : :
831 : : typedef void (* handleUnoTypeRegistryEntityFunction)(
832 : : TypeManager const & manager, JavaOptions /*TODO const*/ & options,
833 : : typereg::Reader const & reader, Dependencies * dependencies);
834 : :
835 : 409 : void handleEnumType(
836 : : SAL_UNUSED_PARAMETER TypeManager const &,
837 : : JavaOptions /*TODO const*/ & options, typereg::Reader const & reader,
838 : : SAL_UNUSED_PARAMETER Dependencies *)
839 : : {
840 : 409 : sal_uInt16 fields = reader.getFieldCount();
841 [ + - + - : 1227 : if (fields == 0 || reader.getSuperTypeCount() != 0
- + ][ - + ]
[ + - ]
842 : 818 : || reader.getMethodCount() != 0 || reader.getReferenceCount() != 0)
843 : : {
844 : : throw CannotDumpException(
845 : 0 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("Bad type information")));
846 : : //TODO
847 : : }
848 [ + - ][ + - ]: 409 : rtl::OString className(codemaker::convertString(reader.getTypeName()));
849 : : SAL_WNODEPRECATED_DECLARATIONS_PUSH
850 : : std::auto_ptr< ClassFile > cf(
851 : : new ClassFile(
852 : : static_cast< ClassFile::AccessFlags >(
853 : : ClassFile::ACC_PUBLIC | ClassFile::ACC_FINAL
854 : : | ClassFile::ACC_SUPER),
855 : : className,
856 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Enum")),
857 [ + - ][ + - ]: 409 : rtl::OString()));
858 : : SAL_WNODEPRECATED_DECLARATIONS_POP
859 : 409 : rtl::OStringBuffer buf;
860 [ + - ]: 409 : buf.append('L');
861 [ + - ]: 409 : buf.append(className);
862 [ + - ]: 409 : buf.append(';');
863 : 409 : rtl::OString classDescriptor(buf.makeStringAndClear());
864 [ + + ]: 3230 : {for (sal_uInt16 i = 0; i < fields; ++i) {
865 [ + - ]: 2821 : RTConstValue fieldValue(reader.getFieldValue(i));
866 [ + - + - : 11284 : if (fieldValue.m_type != RT_TYPE_INT32
- + ][ - + ]
867 : 2821 : || reader.getFieldFlags(i) != RT_ACCESS_CONST
868 [ + - ][ + - ]: 5642 : || reader.getFieldTypeName(i).getLength() != 0)
[ # # ]
869 : : {
870 : : throw CannotDumpException(
871 : : rtl::OString(
872 : 0 : RTL_CONSTASCII_STRINGPARAM("Bad type information"))); //TODO
873 : : }
874 : : rtl::OString fieldName(
875 [ + - ][ + - ]: 2821 : codemaker::convertString(reader.getFieldName(i)));
876 : : cf->addField(
877 : : static_cast< ClassFile::AccessFlags >(
878 : : ClassFile::ACC_PUBLIC | ClassFile::ACC_STATIC
879 : : | ClassFile::ACC_FINAL),
880 [ + - ]: 2821 : fieldName, classDescriptor, 0, rtl::OString());
881 : : cf->addField(
882 : : static_cast< ClassFile::AccessFlags >(
883 : : ClassFile::ACC_PUBLIC | ClassFile::ACC_STATIC
884 : : | ClassFile::ACC_FINAL),
885 : : fieldName + rtl::OString(RTL_CONSTASCII_STRINGPARAM("_value")),
886 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("I")),
887 [ + - ][ + - ]: 2821 : cf->addIntegerInfo(fieldValue.m_value.aLong), rtl::OString());
888 : 2821 : }}
889 : : SAL_WNODEPRECATED_DECLARATIONS_PUSH
890 [ + - ]: 409 : std::auto_ptr< ClassFile::Code > code(cf->newCode());
891 : : SAL_WNODEPRECATED_DECLARATIONS_POP
892 [ + - ]: 409 : code->loadLocalReference(0);
893 [ + - ]: 409 : code->loadLocalInteger(1);
894 : : code->instrInvokespecial(
895 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Enum")),
896 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
897 [ + - ]: 409 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("(I)V")));
898 [ + - ]: 409 : code->instrReturn();
899 : 409 : code->setMaxStackAndLocals(2, 2);
900 : : cf->addMethod(
901 : : ClassFile::ACC_PRIVATE,
902 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
903 : 409 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("(I)V")), code.get(),
904 [ + - + - ]: 818 : std::vector< rtl::OString >(), rtl::OString());
905 [ + - ]: 409 : code.reset(cf->newCode());
906 : : code->instrGetstatic(
907 : : className,
908 [ + - ][ + - ]: 409 : codemaker::convertString(reader.getFieldName(0)), classDescriptor);
[ + - ]
909 [ + - ]: 409 : code->instrAreturn();
910 : 409 : code->setMaxStackAndLocals(1, 0);
911 : : cf->addMethod(
912 : : static_cast< ClassFile::AccessFlags >(
913 : : ClassFile::ACC_PUBLIC | ClassFile::ACC_STATIC),
914 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("getDefault")),
915 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("()")) + classDescriptor,
916 [ + - ][ + - ]: 409 : code.get(), std::vector< rtl::OString >(), rtl::OString());
917 [ + - ]: 409 : code.reset(cf->newCode());
918 [ + - ]: 409 : code->loadLocalInteger(0);
919 [ + - ]: 409 : std::map< sal_Int32, rtl::OString > map;
920 : 409 : sal_Int32 min = SAL_MAX_INT32;
921 : 409 : sal_Int32 max = SAL_MIN_INT32;
922 [ + + ]: 3230 : {for (sal_uInt16 i = 0; i < fields; ++i) {
923 [ + - ]: 2821 : sal_Int32 value = reader.getFieldValue(i).m_value.aLong;
924 [ + - ]: 2821 : min = std::min(min, value);
925 [ + - ]: 2821 : max = std::max(max, value);
926 : : map.insert(
927 : : std::map< sal_Int32, rtl::OString >::value_type(
928 [ + - ][ + - ]: 2821 : value, codemaker::convertString(reader.getFieldName(i))));
[ + - ]
929 : : }}
930 : 409 : sal_uInt64 size = static_cast< sal_uInt64 >(map.size());
931 [ - + ][ + + ]: 409 : if ((static_cast< sal_uInt64 >(max) - static_cast< sal_uInt64 >(min)
932 : : <= 2 * size)
933 : : || size > SAL_MAX_INT32)
934 : : {
935 : : SAL_WNODEPRECATED_DECLARATIONS_PUSH
936 [ + - ]: 407 : std::auto_ptr< ClassFile::Code > defCode(cf->newCode());
937 : : SAL_WNODEPRECATED_DECLARATIONS_POP
938 [ + - ]: 407 : defCode->instrAconstNull();
939 [ + - ]: 407 : defCode->instrAreturn();
940 [ + - ]: 407 : std::list< ClassFile::Code * > blocks;
941 : : //FIXME: pointers contained in blocks may leak
942 : 407 : sal_Int32 last = SAL_MAX_INT32;
943 [ + + ]: 6308 : for (std::map< sal_Int32, rtl::OString >::iterator i(map.begin());
944 : 3154 : i != map.end(); ++i)
945 : : {
946 : 2747 : sal_Int32 value = i->first;
947 [ + + ]: 2747 : if (last != SAL_MAX_INT32) {
948 [ + + ]: 2348 : for (sal_Int32 j = last + 1; j < value; ++j) {
949 [ + - ]: 8 : blocks.push_back(0);
950 : : }
951 : : }
952 : 2747 : last = value;
953 : : SAL_WNODEPRECATED_DECLARATIONS_PUSH
954 [ + - ]: 2747 : std::auto_ptr< ClassFile::Code > blockCode(cf->newCode());
955 : : SAL_WNODEPRECATED_DECLARATIONS_POP
956 [ + - ]: 2747 : blockCode->instrGetstatic(className, i->second, classDescriptor);
957 [ + - ]: 2747 : blockCode->instrAreturn();
958 [ + - ]: 2747 : blocks.push_back(blockCode.get());
959 : 2747 : blockCode.release();
960 [ + - ]: 2747 : }
961 [ + - ]: 407 : code->instrTableswitch(defCode.get(), min, blocks);
962 [ + + ]: 6324 : {for (std::list< ClassFile::Code * >::iterator i(blocks.begin());
963 : 3162 : i != blocks.end(); ++i)
964 : : {
965 [ + + ][ + - ]: 2755 : delete *i;
966 [ + - ]: 407 : }}
967 : : } else{
968 : : SAL_WNODEPRECATED_DECLARATIONS_PUSH
969 [ + - ]: 2 : std::auto_ptr< ClassFile::Code > defCode(cf->newCode());
970 : : SAL_WNODEPRECATED_DECLARATIONS_POP
971 [ + - ]: 2 : defCode->instrAconstNull();
972 [ + - ]: 2 : defCode->instrAreturn();
973 [ + - ]: 2 : std::list< std::pair< sal_Int32, ClassFile::Code * > > blocks;
974 : : //FIXME: pointers contained in blocks may leak
975 [ + + ]: 152 : for (std::map< sal_Int32, rtl::OString >::iterator i(map.begin());
976 : 76 : i != map.end(); ++i)
977 : : {
978 : : SAL_WNODEPRECATED_DECLARATIONS_PUSH
979 [ + - ]: 74 : std::auto_ptr< ClassFile::Code > blockCode(cf->newCode());
980 : : SAL_WNODEPRECATED_DECLARATIONS_POP
981 [ + - ]: 74 : blockCode->instrGetstatic(className, i->second, classDescriptor);
982 [ + - ]: 74 : blockCode->instrAreturn();
983 [ + - ]: 74 : blocks.push_back(std::make_pair(i->first, blockCode.get()));
984 : 74 : blockCode.release();
985 [ + - ]: 74 : }
986 [ + - ]: 2 : code->instrLookupswitch(defCode.get(), blocks);
987 [ + + ]: 152 : {for (std::list< std::pair< sal_Int32, ClassFile::Code * > >::iterator
988 : 2 : i(blocks.begin());
989 : 76 : i != blocks.end(); ++i)
990 : : {
991 [ + - ][ + - ]: 74 : delete i->second;
992 [ + - ]: 2 : }}
993 : : }
994 : 409 : code->setMaxStackAndLocals(1, 1);
995 : : cf->addMethod(
996 : : static_cast< ClassFile::AccessFlags >(
997 : : ClassFile::ACC_PUBLIC | ClassFile::ACC_STATIC),
998 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("fromInt")),
999 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("(I)")) + classDescriptor,
1000 [ + - ][ + - ]: 409 : code.get(), std::vector< rtl::OString >(), rtl::OString());
1001 [ + - ]: 409 : code.reset(cf->newCode());
1002 [ + + ]: 3230 : {for (sal_uInt16 i = 0; i < fields; ++i) {
1003 [ + - ]: 2821 : code->instrNew(className);
1004 [ + - ]: 2821 : code->instrDup();
1005 [ + - ][ + - ]: 2821 : code->loadIntegerConstant(reader.getFieldValue(i).m_value.aLong);
1006 : : code->instrInvokespecial(
1007 : : className, rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
1008 [ + - ]: 2821 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("(I)V")));
1009 : : code->instrPutstatic(
1010 : : className,
1011 : : codemaker::convertString(reader.getFieldName(i)),
1012 [ + - ][ + - ]: 2821 : classDescriptor);
[ + - ]
1013 : : }}
1014 [ + - ]: 409 : code->instrReturn();
1015 : 409 : code->setMaxStackAndLocals(3, 0);
1016 : : cf->addMethod(
1017 : : static_cast< ClassFile::AccessFlags >(
1018 : : ClassFile::ACC_PRIVATE | ClassFile::ACC_STATIC),
1019 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("<clinit>")),
1020 : 409 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("()V")), code.get(),
1021 [ + - + - ]: 818 : std::vector< rtl::OString >(), rtl::OString());
1022 [ + - ][ + - ]: 409 : writeClassFile(options, className, *cf.get());
[ + - ]
1023 : 409 : }
1024 : :
1025 : 3570 : void addField(
1026 : : TypeManager const & manager, Dependencies * dependencies,
1027 : : ClassFile * classFile, std::vector< TypeInfo > * typeInfo,
1028 : : sal_Int32 typeParameterIndex, rtl::OString const & type,
1029 : : rtl::OString const & name, sal_Int32 index)
1030 : : {
1031 : : OSL_ASSERT(dependencies != 0 && classFile != 0 && typeInfo != 0);
1032 : 3570 : rtl::OString descriptor;
1033 : 3570 : rtl::OString signature;
1034 : : SpecialType specialType;
1035 : 3570 : PolymorphicUnoType polymorphicUnoType;
1036 [ + + ]: 3570 : if (typeParameterIndex >= 0) {
1037 : : descriptor = rtl::OString(
1038 : 13 : RTL_CONSTASCII_STRINGPARAM("Ljava/lang/Object;"));
1039 : 13 : rtl::OStringBuffer buf;
1040 [ + - ]: 13 : buf.append('T');
1041 [ + - ]: 13 : buf.append(type);
1042 [ + - ]: 13 : buf.append(';');
1043 : 13 : signature = buf.makeStringAndClear();
1044 : 13 : specialType = SPECIAL_TYPE_NONE; //TODO: SPECIAL_TYPE_TYPE_PARAMETER?
1045 : : } else {
1046 : : specialType = getFieldDescriptor(
1047 : : manager, dependencies, type, &descriptor, &signature,
1048 [ + - ]: 3557 : &polymorphicUnoType);
1049 : : }
1050 [ + - ]: 3570 : classFile->addField(ClassFile::ACC_PUBLIC, name, descriptor, 0, signature);
1051 : : typeInfo->push_back(
1052 : : TypeInfo(
1053 [ + - ]: 3570 : name, specialType, index, polymorphicUnoType, typeParameterIndex));
1054 : 3570 : }
1055 : :
1056 : 3886 : sal_uInt16 addFieldInit(
1057 : : TypeManager const & manager, rtl::OString const & className,
1058 : : rtl::OString const & fieldName, bool typeParameter,
1059 : : rtl::OString const & fieldType, Dependencies * dependencies,
1060 : : ClassFile::Code * code)
1061 : : {
1062 : : OSL_ASSERT(dependencies != 0 && code != 0);
1063 [ + + ]: 3886 : if (typeParameter) {
1064 : 13 : return 0;
1065 : : } else {
1066 : : RTTypeClass typeClass;
1067 : 3873 : rtl::OString nucleus;
1068 : : sal_Int32 rank;
1069 [ + - ]: 3873 : std::vector< rtl::OString > args;
1070 : : codemaker::UnoType::Sort sort = codemaker::decomposeAndResolve(
1071 : : manager, fieldType, true, false, false, &typeClass, &nucleus, &rank,
1072 [ + - ]: 3873 : &args);
1073 [ + + ]: 3873 : if (rank == 0) {
1074 [ + + + + : 3608 : switch (sort) {
+ ]
1075 : : case codemaker::UnoType::SORT_STRING:
1076 [ + - ]: 954 : code->loadLocalReference(0);
1077 [ + - ]: 954 : code->loadStringConstant(rtl::OString());
1078 : : code->instrPutfield(
1079 : : className, fieldName,
1080 : : rtl::OString(
1081 [ + - ]: 954 : RTL_CONSTASCII_STRINGPARAM("Ljava/lang/String;")));
1082 : 954 : return 2;
1083 : :
1084 : : case codemaker::UnoType::SORT_TYPE:
1085 [ + - ]: 10 : code->loadLocalReference(0);
1086 : : code->instrGetstatic(
1087 : : rtl::OString(
1088 : : RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Type")),
1089 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("VOID")),
1090 : : rtl::OString(
1091 [ + - ]: 10 : RTL_CONSTASCII_STRINGPARAM("Lcom/sun/star/uno/Type;")));
1092 : : code->instrPutfield(
1093 : : className, fieldName,
1094 : : rtl::OString(
1095 [ + - ]: 10 : RTL_CONSTASCII_STRINGPARAM("Lcom/sun/star/uno/Type;")));
1096 : 10 : return 2;
1097 : :
1098 : : case codemaker::UnoType::SORT_ANY:
1099 [ + - ]: 194 : code->loadLocalReference(0);
1100 : : code->instrGetstatic(
1101 : : rtl::OString(
1102 : : RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Any")),
1103 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("VOID")),
1104 : : rtl::OString(
1105 [ + - ]: 194 : RTL_CONSTASCII_STRINGPARAM("Lcom/sun/star/uno/Any;")));
1106 : : code->instrPutfield(
1107 : : className, fieldName,
1108 : : rtl::OString(
1109 [ + - ]: 194 : RTL_CONSTASCII_STRINGPARAM("Ljava/lang/Object;")));
1110 : 194 : return 2;
1111 : :
1112 : : case codemaker::UnoType::SORT_COMPLEX:
1113 [ + + + ]: 594 : switch (typeClass) {
1114 : : case RT_TYPE_ENUM:
1115 : : {
1116 [ + - ]: 157 : code->loadLocalReference(0);
1117 [ + - ]: 157 : typereg::Reader reader(manager.getTypeReader(nucleus));
1118 [ - + ]: 157 : if (reader.getFieldCount() == 0) {
1119 : : throw CannotDumpException(
1120 : : rtl::OString(
1121 : : RTL_CONSTASCII_STRINGPARAM(
1122 : 0 : "Bad type information"))); //TODO
1123 : : }
1124 : 157 : rtl::OStringBuffer descBuf;
1125 : : translateUnoTypeToDescriptor(
1126 : : manager, sort, typeClass, nucleus, 0,
1127 : : std::vector< rtl::OString >(), false, false,
1128 [ + - ][ + - ]: 157 : dependencies, &descBuf, 0, 0, 0);
1129 : 157 : rtl::OString desc(descBuf.makeStringAndClear());
1130 : : code->instrGetstatic(
1131 : : nucleus,
1132 : : codemaker::convertString(reader.getFieldName(0)),
1133 [ + - ][ + - ]: 157 : desc);
[ + - ]
1134 [ + - ]: 157 : code->instrPutfield(className, fieldName, desc);
1135 : 157 : return 2;
1136 : : }
1137 : :
1138 : : case RT_TYPE_STRUCT:
1139 : : {
1140 [ + - ]: 228 : code->loadLocalReference(0);
1141 [ + - ]: 228 : code->instrNew(nucleus);
1142 [ + - ]: 228 : code->instrDup();
1143 : : code->instrInvokespecial(
1144 : : nucleus,
1145 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
1146 [ + - ]: 228 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("()V")));
1147 : 228 : rtl::OStringBuffer desc;
1148 : : translateUnoTypeToDescriptor(
1149 : : manager, sort, typeClass, nucleus, 0,
1150 : : std::vector< rtl::OString >(), false, false,
1151 [ + - ][ + - ]: 228 : dependencies, &desc, 0, 0, 0);
1152 : : code->instrPutfield(
1153 [ + - ]: 228 : className, fieldName, desc.makeStringAndClear());
1154 : 228 : return 3;
1155 : : }
1156 : :
1157 : : default:
1158 : : OSL_ASSERT(typeClass == RT_TYPE_INTERFACE);
1159 : 209 : return 0;
1160 : : }
1161 : :
1162 : : default:
1163 : 1856 : return 0;
1164 : : }
1165 : : } else {
1166 [ + - ]: 265 : code->loadLocalReference(0);
1167 [ + - ]: 265 : code->loadIntegerConstant(0);
1168 [ + + ]: 265 : if (rank == 1) {
1169 [ + - ][ + + ]: 248 : if (sort >= codemaker::UnoType::SORT_BOOLEAN
1170 : : && sort <= codemaker::UnoType::SORT_CHAR)
1171 : : {
1172 [ + - ]: 67 : code->instrNewarray(sort);
1173 : : } else {
1174 : : code->instrAnewarray(
1175 : : codemaker::java::translateUnoToJavaType(sort, typeClass,
1176 [ + - ][ + - ]: 248 : nucleus, 0));
1177 : : }
1178 : : } else {
1179 : 17 : rtl::OStringBuffer desc;
1180 : : translateUnoTypeToDescriptor(
1181 : : manager, sort, typeClass, nucleus, rank - 1,
1182 : : std::vector< rtl::OString >(), false, false, dependencies,
1183 [ + - ][ + - ]: 17 : &desc, 0, 0, 0);
1184 [ + - ]: 17 : code->instrAnewarray(desc.makeStringAndClear());
1185 : : }
1186 : 265 : rtl::OStringBuffer desc;
1187 : : translateUnoTypeToDescriptor(
1188 : : manager, sort, typeClass, nucleus, rank,
1189 : : std::vector< rtl::OString >(), false, false, dependencies,
1190 [ + - ][ + - ]: 265 : &desc, 0, 0, 0);
1191 : : code->instrPutfield(
1192 [ + - ]: 265 : className, fieldName, desc.makeStringAndClear());
1193 : 265 : return 2;
1194 : 3886 : }
1195 : : }
1196 : : }
1197 : :
1198 : 5041 : sal_uInt16 addLoadLocal(
1199 : : TypeManager const & manager, ClassFile::Code * code, sal_uInt16 * index,
1200 : : bool typeParameter, rtl::OString const & type, bool any,
1201 : : Dependencies * dependencies)
1202 : : {
1203 : : OSL_ASSERT(
1204 : : code != 0 && index != 0 && !(typeParameter && any)
1205 : : && dependencies != 0);
1206 : 5041 : sal_uInt16 stack = 1;
1207 : 5041 : sal_uInt16 size = 1;
1208 [ + + ]: 5041 : if (typeParameter) {
1209 : 13 : code->loadLocalReference(*index);
1210 : 13 : stack = size = 1;
1211 : : } else {
1212 : : RTTypeClass typeClass;
1213 : 5028 : rtl::OString nucleus;
1214 : : sal_Int32 rank;
1215 [ + - ]: 5028 : std::vector< rtl::OString > args;
1216 : : codemaker::UnoType::Sort sort = codemaker::decomposeAndResolve(
1217 [ + - ]: 5028 : manager, type, true, false, false, &typeClass, &nucleus, &rank, &args);
1218 [ + + ]: 5028 : if (rank == 0) {
1219 [ + + + + : 4732 : switch (sort) {
+ + + + +
+ + + +
- ]
1220 : : case codemaker::UnoType::SORT_BOOLEAN:
1221 [ + + ]: 419 : if (any) {
1222 : : code->instrNew(
1223 : : rtl::OString(
1224 [ + - ]: 11 : RTL_CONSTASCII_STRINGPARAM("java/lang/Boolean")));
1225 [ + - ]: 11 : code->instrDup();
1226 [ + - ]: 11 : code->loadLocalInteger(*index);
1227 : : code->instrInvokespecial(
1228 : : rtl::OString(
1229 : : RTL_CONSTASCII_STRINGPARAM("java/lang/Boolean")),
1230 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
1231 [ + - ]: 11 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("(Z)V")));
1232 : 11 : stack = 3;
1233 : : } else {
1234 [ + - ]: 408 : code->loadLocalInteger(*index);
1235 : 408 : stack = 1;
1236 : : }
1237 : 419 : size = 1;
1238 : 419 : break;
1239 : :
1240 : : case codemaker::UnoType::SORT_BYTE:
1241 [ + + ]: 140 : if (any) {
1242 : : code->instrNew(
1243 : : rtl::OString(
1244 [ + - ]: 1 : RTL_CONSTASCII_STRINGPARAM("java/lang/Byte")));
1245 [ + - ]: 1 : code->instrDup();
1246 [ + - ]: 1 : code->loadLocalInteger(*index);
1247 : : code->instrInvokespecial(
1248 : : rtl::OString(
1249 : : RTL_CONSTASCII_STRINGPARAM("java/lang/Byte")),
1250 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
1251 [ + - ]: 1 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("(B)V")));
1252 : 1 : stack = 3;
1253 : : } else {
1254 [ + - ]: 139 : code->loadLocalInteger(*index);
1255 : 139 : stack = 1;
1256 : : }
1257 : 140 : size = 1;
1258 : 140 : break;
1259 : :
1260 : : case codemaker::UnoType::SORT_SHORT:
1261 [ + + ]: 279 : if (any) {
1262 : : code->instrNew(
1263 : : rtl::OString(
1264 [ + - ]: 7 : RTL_CONSTASCII_STRINGPARAM("java/lang/Short")));
1265 [ + - ]: 7 : code->instrDup();
1266 [ + - ]: 7 : code->loadLocalInteger(*index);
1267 : : code->instrInvokespecial(
1268 : : rtl::OString(
1269 : : RTL_CONSTASCII_STRINGPARAM("java/lang/Short")),
1270 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
1271 [ + - ]: 7 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("(S)V")));
1272 : 7 : stack = 3;
1273 : : } else {
1274 [ + - ]: 272 : code->loadLocalInteger(*index);
1275 : 272 : stack = 1;
1276 : : }
1277 : 279 : size = 1;
1278 : 279 : break;
1279 : :
1280 : : case codemaker::UnoType::SORT_UNSIGNED_SHORT:
1281 [ + + ]: 97 : if (any) {
1282 : : code->instrNew(
1283 : : rtl::OString(
1284 : : RTL_CONSTASCII_STRINGPARAM(
1285 [ + - ]: 1 : "com/sun/star/uno/Any")));
1286 [ + - ]: 1 : code->instrDup();
1287 : : code->instrGetstatic(
1288 : : rtl::OString(
1289 : : RTL_CONSTASCII_STRINGPARAM(
1290 : : "com/sun/star/uno/Type")),
1291 : : rtl::OString(
1292 : : RTL_CONSTASCII_STRINGPARAM("UNSIGNED_SHORT")),
1293 : : rtl::OString(
1294 : : RTL_CONSTASCII_STRINGPARAM(
1295 [ + - ]: 1 : "Lcom/sun/star/uno/Type;")));
1296 : : code->instrNew(
1297 : : rtl::OString(
1298 [ + - ]: 1 : RTL_CONSTASCII_STRINGPARAM("java/lang/Short")));
1299 [ + - ]: 1 : code->instrDup();
1300 [ + - ]: 1 : code->loadLocalInteger(*index);
1301 : : code->instrInvokespecial(
1302 : : rtl::OString(
1303 : : RTL_CONSTASCII_STRINGPARAM("java/lang/Short")),
1304 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
1305 [ + - ]: 1 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("(S)V")));
1306 : : code->instrInvokespecial(
1307 : : rtl::OString(
1308 : : RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Any")),
1309 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
1310 : : rtl::OString(
1311 : : RTL_CONSTASCII_STRINGPARAM(
1312 : : "(Lcom/sun/star/uno/Type;Ljava/lang/Object;)"
1313 [ + - ]: 1 : "V")));
1314 : 1 : stack = 6;
1315 : : } else {
1316 [ + - ]: 96 : code->loadLocalInteger(*index);
1317 : 96 : stack = 1;
1318 : : }
1319 : 97 : size = 1;
1320 : 97 : break;
1321 : :
1322 : : case codemaker::UnoType::SORT_LONG:
1323 [ + + ]: 687 : if (any) {
1324 : : code->instrNew(
1325 : : rtl::OString(
1326 [ + - ]: 19 : RTL_CONSTASCII_STRINGPARAM("java/lang/Integer")));
1327 [ + - ]: 19 : code->instrDup();
1328 [ + - ]: 19 : code->loadLocalInteger(*index);
1329 : : code->instrInvokespecial(
1330 : : rtl::OString(
1331 : : RTL_CONSTASCII_STRINGPARAM("java/lang/Integer")),
1332 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
1333 [ + - ]: 19 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("(I)V")));
1334 : 19 : stack = 3;
1335 : : } else {
1336 [ + - ]: 668 : code->loadLocalInteger(*index);
1337 : 668 : stack = 1;
1338 : : }
1339 : 687 : size = 1;
1340 : 687 : break;
1341 : :
1342 : : case codemaker::UnoType::SORT_UNSIGNED_LONG:
1343 [ + + ]: 79 : if (any) {
1344 : : code->instrNew(
1345 : : rtl::OString(
1346 : : RTL_CONSTASCII_STRINGPARAM(
1347 [ + - ]: 1 : "com/sun/star/uno/Any")));
1348 [ + - ]: 1 : code->instrDup();
1349 : : code->instrGetstatic(
1350 : : rtl::OString(
1351 : : RTL_CONSTASCII_STRINGPARAM(
1352 : : "com/sun/star/uno/Type")),
1353 : : rtl::OString(
1354 : : RTL_CONSTASCII_STRINGPARAM("UNSIGNED_LONG")),
1355 : : rtl::OString(
1356 : : RTL_CONSTASCII_STRINGPARAM(
1357 [ + - ]: 1 : "Lcom/sun/star/uno/Type;")));
1358 : : code->instrNew(
1359 : : rtl::OString(
1360 [ + - ]: 1 : RTL_CONSTASCII_STRINGPARAM("java/lang/Integer")));
1361 [ + - ]: 1 : code->instrDup();
1362 [ + - ]: 1 : code->loadLocalInteger(*index);
1363 : : code->instrInvokespecial(
1364 : : rtl::OString(
1365 : : RTL_CONSTASCII_STRINGPARAM("java/lang/Integer")),
1366 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
1367 [ + - ]: 1 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("(I)V")));
1368 : : code->instrInvokespecial(
1369 : : rtl::OString(
1370 : : RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Any")),
1371 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
1372 : : rtl::OString(
1373 : : RTL_CONSTASCII_STRINGPARAM(
1374 : : "(Lcom/sun/star/uno/Type;Ljava/lang/Object;)"
1375 [ + - ]: 1 : "V")));
1376 : 1 : stack = 6;
1377 : : } else {
1378 [ + - ]: 78 : code->loadLocalInteger(*index);
1379 : 78 : stack = 1;
1380 : : }
1381 : 79 : size = 1;
1382 : 79 : break;
1383 : :
1384 : : case codemaker::UnoType::SORT_HYPER:
1385 [ + + ]: 45 : if (any) {
1386 : : code->instrNew(
1387 : : rtl::OString(
1388 [ + - ]: 1 : RTL_CONSTASCII_STRINGPARAM("java/lang/Long")));
1389 [ + - ]: 1 : code->instrDup();
1390 [ + - ]: 1 : code->loadLocalLong(*index);
1391 : : code->instrInvokespecial(
1392 : : rtl::OString(
1393 : : RTL_CONSTASCII_STRINGPARAM("java/lang/Long")),
1394 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
1395 [ + - ]: 1 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("(J)V")));
1396 : 1 : stack = 4;
1397 : : } else {
1398 [ + - ]: 44 : code->loadLocalLong(*index);
1399 : 44 : stack = 2;
1400 : : }
1401 : 45 : size = 2;
1402 : 45 : break;
1403 : :
1404 : : case codemaker::UnoType::SORT_UNSIGNED_HYPER:
1405 [ + + ]: 15 : if (any) {
1406 : : code->instrNew(
1407 : : rtl::OString(
1408 : : RTL_CONSTASCII_STRINGPARAM(
1409 [ + - ]: 1 : "com/sun/star/uno/Any")));
1410 [ + - ]: 1 : code->instrDup();
1411 : : code->instrGetstatic(
1412 : : rtl::OString(
1413 : : RTL_CONSTASCII_STRINGPARAM(
1414 : : "com/sun/star/uno/Type")),
1415 : : rtl::OString(
1416 : : RTL_CONSTASCII_STRINGPARAM("UNSIGNED_HYPER")),
1417 : : rtl::OString(
1418 : : RTL_CONSTASCII_STRINGPARAM(
1419 [ + - ]: 1 : "Lcom/sun/star/uno/Type;")));
1420 : : code->instrNew(
1421 : : rtl::OString(
1422 [ + - ]: 1 : RTL_CONSTASCII_STRINGPARAM("java/lang/Long")));
1423 [ + - ]: 1 : code->instrDup();
1424 [ + - ]: 1 : code->loadLocalLong(*index);
1425 : : code->instrInvokespecial(
1426 : : rtl::OString(
1427 : : RTL_CONSTASCII_STRINGPARAM("java/lang/Long")),
1428 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
1429 [ + - ]: 1 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("(J)V")));
1430 : : code->instrInvokespecial(
1431 : : rtl::OString(
1432 : : RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Any")),
1433 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
1434 : : rtl::OString(
1435 : : RTL_CONSTASCII_STRINGPARAM(
1436 : : "(Lcom/sun/star/uno/Type;Ljava/lang/Object;)"
1437 [ + - ]: 1 : "V")));
1438 : 1 : stack = 7;
1439 : : } else {
1440 [ + - ]: 14 : code->loadLocalLong(*index);
1441 : 14 : stack = 2;
1442 : : }
1443 : 15 : size = 2;
1444 : 15 : break;
1445 : :
1446 : : case codemaker::UnoType::SORT_FLOAT:
1447 [ + + ]: 32 : if (any) {
1448 : : code->instrNew(
1449 : : rtl::OString(
1450 [ + - ]: 1 : RTL_CONSTASCII_STRINGPARAM("java/lang/Float")));
1451 [ + - ]: 1 : code->instrDup();
1452 [ + - ]: 1 : code->loadLocalFloat(*index);
1453 : : code->instrInvokespecial(
1454 : : rtl::OString(
1455 : : RTL_CONSTASCII_STRINGPARAM("java/lang/Float")),
1456 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
1457 [ + - ]: 1 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("(F)V")));
1458 : 1 : stack = 3;
1459 : : } else {
1460 [ + - ]: 31 : code->loadLocalFloat(*index);
1461 : 31 : stack = 1;
1462 : : }
1463 : 32 : size = 1;
1464 : 32 : break;
1465 : :
1466 : : case codemaker::UnoType::SORT_DOUBLE:
1467 [ + + ]: 225 : if (any) {
1468 : : code->instrNew(
1469 : : rtl::OString(
1470 [ + - ]: 1 : RTL_CONSTASCII_STRINGPARAM("java/lang/Double")));
1471 [ + - ]: 1 : code->instrDup();
1472 [ + - ]: 1 : code->loadLocalDouble(*index);
1473 : : code->instrInvokespecial(
1474 : : rtl::OString(
1475 : : RTL_CONSTASCII_STRINGPARAM("java/lang/Double")),
1476 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
1477 [ + - ]: 1 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("(D)V")));
1478 : 1 : stack = 4;
1479 : : } else {
1480 [ + - ]: 224 : code->loadLocalDouble(*index);
1481 : 224 : stack = 2;
1482 : : }
1483 : 225 : size = 2;
1484 : 225 : break;
1485 : :
1486 : : case codemaker::UnoType::SORT_CHAR:
1487 [ + + ]: 27 : if (any) {
1488 : : code->instrNew(
1489 : : rtl::OString(
1490 [ + - ]: 1 : RTL_CONSTASCII_STRINGPARAM("java/lang/Character")));
1491 [ + - ]: 1 : code->instrDup();
1492 [ + - ]: 1 : code->loadLocalInteger(*index);
1493 : : code->instrInvokespecial(
1494 : : rtl::OString(
1495 : : RTL_CONSTASCII_STRINGPARAM("java/lang/Character")),
1496 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
1497 [ + - ]: 1 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("(C)V")));
1498 : 1 : stack = 3;
1499 : : } else {
1500 [ + - ]: 26 : code->loadLocalInteger(*index);
1501 : 26 : stack = 1;
1502 : : }
1503 : 27 : size = 1;
1504 : 27 : break;
1505 : :
1506 : : case codemaker::UnoType::SORT_STRING:
1507 : : case codemaker::UnoType::SORT_TYPE:
1508 : : case codemaker::UnoType::SORT_ANY:
1509 [ + - ]: 1201 : code->loadLocalReference(*index);
1510 : 1201 : stack = size = 1;
1511 : 1201 : break;
1512 : :
1513 : : case codemaker::UnoType::SORT_COMPLEX:
1514 [ + + + - ]: 1486 : switch (typeClass) {
1515 : : case RT_TYPE_ENUM:
1516 : : // Assuming that no Java types are derived from Java types
1517 : : // that are directly derived from com.sun.star.uno.Enum:
1518 [ + - ]: 264 : code->loadLocalReference(*index);
1519 : 264 : stack = size = 1;
1520 : 264 : break;
1521 : :
1522 : : case RT_TYPE_STRUCT:
1523 [ + + ]: 268 : if (any) {
1524 : : code->instrNew(
1525 : : rtl::OString(
1526 : : RTL_CONSTASCII_STRINGPARAM(
1527 [ + - ]: 44 : "com/sun/star/uno/Any")));
1528 [ + - ]: 44 : code->instrDup();
1529 : : code->instrNew(
1530 : : rtl::OString(
1531 : : RTL_CONSTASCII_STRINGPARAM(
1532 [ + - ]: 44 : "com/sun/star/uno/Type")));
1533 [ + - ]: 44 : code->instrDup();
1534 : : code->loadStringConstant(
1535 [ + - ][ + - ]: 44 : createUnoName(manager, nucleus, rank, args));
1536 : : code->instrGetstatic(
1537 : : rtl::OString(
1538 : : RTL_CONSTASCII_STRINGPARAM(
1539 : : "com/sun/star/uno/TypeClass")),
1540 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("STRUCT")),
1541 : : rtl::OString(
1542 : : RTL_CONSTASCII_STRINGPARAM(
1543 [ + - ]: 44 : "Lcom/sun/star/uno/TypeClass;")));
1544 : : dependencies->insert(
1545 : : rtl::OString(
1546 : : RTL_CONSTASCII_STRINGPARAM(
1547 [ + - ]: 44 : "com/sun/star/uno/TypeClass")));
1548 : : code->instrInvokespecial(
1549 : : rtl::OString(
1550 : : RTL_CONSTASCII_STRINGPARAM(
1551 : : "com/sun/star/uno/Type")),
1552 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
1553 : : rtl::OString(
1554 : : RTL_CONSTASCII_STRINGPARAM(
1555 : : "(Ljava/lang/String;"
1556 [ + - ]: 44 : "Lcom/sun/star/uno/TypeClass;)V")));
1557 [ + - ]: 44 : code->loadLocalReference(*index);
1558 : : code->instrInvokespecial(
1559 : : rtl::OString(
1560 : : RTL_CONSTASCII_STRINGPARAM(
1561 : : "com/sun/star/uno/Any")),
1562 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
1563 : : rtl::OString(
1564 : : RTL_CONSTASCII_STRINGPARAM(
1565 : : "(Lcom/sun/star/uno/Type;"
1566 [ + - ]: 44 : "Ljava/lang/Object;)V")));
1567 : 44 : stack = 6;
1568 : : } else {
1569 [ + - ]: 224 : code->loadLocalReference(*index);
1570 : 224 : stack = 1;
1571 : : }
1572 : 268 : size = 1;
1573 : 268 : break;
1574 : :
1575 : : case RT_TYPE_INTERFACE:
1576 [ + + + + ]: 1995 : if (any
[ + + ]
1577 : : && (nucleus
1578 : : != rtl::OString(
1579 : : RTL_CONSTASCII_STRINGPARAM(
1580 [ + + ]: 1041 : "com/sun/star/uno/XInterface"))))
1581 : : {
1582 : : code->instrNew(
1583 : : rtl::OString(
1584 : : RTL_CONSTASCII_STRINGPARAM(
1585 [ + - ]: 82 : "com/sun/star/uno/Any")));
1586 [ + - ]: 82 : code->instrDup();
1587 : : code->instrNew(
1588 : : rtl::OString(
1589 : : RTL_CONSTASCII_STRINGPARAM(
1590 [ + - ]: 82 : "com/sun/star/uno/Type")));
1591 [ + - ]: 82 : code->instrDup();
1592 [ + - ]: 82 : code->loadStringConstant(nucleus.replace('/', '.'));
1593 : : code->instrGetstatic(
1594 : : rtl::OString(
1595 : : RTL_CONSTASCII_STRINGPARAM(
1596 : : "com/sun/star/uno/TypeClass")),
1597 : : rtl::OString(
1598 : : RTL_CONSTASCII_STRINGPARAM("INTERFACE")),
1599 : : rtl::OString(
1600 : : RTL_CONSTASCII_STRINGPARAM(
1601 [ + - ]: 82 : "Lcom/sun/star/uno/TypeClass;")));
1602 : : dependencies->insert(
1603 : : rtl::OString(
1604 : : RTL_CONSTASCII_STRINGPARAM(
1605 [ + - ]: 82 : "com/sun/star/uno/TypeClass")));
1606 : : code->instrInvokespecial(
1607 : : rtl::OString(
1608 : : RTL_CONSTASCII_STRINGPARAM(
1609 : : "com/sun/star/uno/Type")),
1610 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
1611 : : rtl::OString(
1612 : : RTL_CONSTASCII_STRINGPARAM(
1613 : : "(Ljava/lang/String;"
1614 [ + - ]: 82 : "Lcom/sun/star/uno/TypeClass;)V")));
1615 [ + - ]: 82 : code->loadLocalReference(*index);
1616 : : code->instrInvokespecial(
1617 : : rtl::OString(
1618 : : RTL_CONSTASCII_STRINGPARAM(
1619 : : "com/sun/star/uno/Any")),
1620 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
1621 : : rtl::OString(
1622 : : RTL_CONSTASCII_STRINGPARAM(
1623 : : "(Lcom/sun/star/uno/Type;"
1624 [ + - ]: 82 : "Ljava/lang/Object;)V")));
1625 : 82 : stack = 6;
1626 : : } else {
1627 [ + - ]: 872 : code->loadLocalReference(*index);
1628 : 872 : stack = 1;
1629 : : }
1630 : 954 : size = 1;
1631 : 954 : break;
1632 : :
1633 : : default:
1634 : : OSL_ASSERT(false);
1635 : 0 : break;
1636 : : }
1637 : 1486 : break;
1638 : :
1639 : : default:
1640 : : OSL_ASSERT(false);
1641 : 4732 : break;
1642 : : }
1643 : : } else {
1644 : 296 : bool wrap = false;
1645 [ + + ]: 296 : if (any) {
1646 [ + + + - ]: 49 : switch (sort) {
1647 : : case codemaker::UnoType::SORT_BOOLEAN:
1648 : : case codemaker::UnoType::SORT_BYTE:
1649 : : case codemaker::UnoType::SORT_SHORT:
1650 : : case codemaker::UnoType::SORT_LONG:
1651 : : case codemaker::UnoType::SORT_HYPER:
1652 : : case codemaker::UnoType::SORT_FLOAT:
1653 : : case codemaker::UnoType::SORT_DOUBLE:
1654 : : case codemaker::UnoType::SORT_CHAR:
1655 : : case codemaker::UnoType::SORT_STRING:
1656 : : case codemaker::UnoType::SORT_TYPE:
1657 : : // assuming that no Java types are derived from
1658 : : // com.sun.star.uno.Type
1659 : 19 : break;
1660 : :
1661 : : case codemaker::UnoType::SORT_UNSIGNED_SHORT:
1662 : : case codemaker::UnoType::SORT_UNSIGNED_LONG:
1663 : : case codemaker::UnoType::SORT_UNSIGNED_HYPER:
1664 : : case codemaker::UnoType::SORT_ANY:
1665 : 9 : wrap = true;
1666 : 9 : break;
1667 : :
1668 : : case codemaker::UnoType::SORT_COMPLEX:
1669 [ + + - ]: 21 : switch (typeClass) {
1670 : : case RT_TYPE_ENUM:
1671 : : // assuming that no Java types are derived from Java
1672 : : // types that are directly derived from
1673 : : // com.sun.star.uno.Enum
1674 : 1 : break;
1675 : :
1676 : : case RT_TYPE_STRUCT:
1677 : : case RT_TYPE_INTERFACE:
1678 : 20 : wrap = true;
1679 : 20 : break;
1680 : :
1681 : : default:
1682 : : OSL_ASSERT(false);
1683 : 0 : break;
1684 : : }
1685 : 21 : break;
1686 : :
1687 : : default:
1688 : : OSL_ASSERT(false);
1689 : 49 : break;
1690 : : }
1691 : : }
1692 [ + + ]: 296 : if (wrap) {
1693 : : code->instrNew(
1694 : : rtl::OString(
1695 [ + - ]: 29 : RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Any")));
1696 [ + - ]: 29 : code->instrDup();
1697 : : code->instrNew(
1698 : : rtl::OString(
1699 [ + - ]: 29 : RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Type")));
1700 [ + - ]: 29 : code->instrDup();
1701 : : code->loadStringConstant(
1702 [ + - ][ + - ]: 29 : createUnoName(manager, nucleus, rank, args));
1703 : : code->instrInvokespecial(
1704 : : rtl::OString(
1705 : : RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Type")),
1706 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
1707 : : rtl::OString(
1708 [ + - ]: 29 : RTL_CONSTASCII_STRINGPARAM("(Ljava/lang/String;)V")));
1709 [ + - ]: 29 : code->loadLocalReference(*index);
1710 : : code->instrInvokespecial(
1711 : : rtl::OString(
1712 : : RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Any")),
1713 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
1714 : : rtl::OString(
1715 : : RTL_CONSTASCII_STRINGPARAM(
1716 [ + - ]: 29 : "(Lcom/sun/star/uno/Type;Ljava/lang/Object;)V")));
1717 : 29 : stack = 5;
1718 : : } else {
1719 [ + - ]: 267 : code->loadLocalReference(*index);
1720 : 267 : stack = 1;
1721 : : }
1722 : 296 : size = 1;
1723 : 5028 : }
1724 : : }
1725 [ - + ]: 5041 : if (*index > SAL_MAX_UINT16 - size) {
1726 : : throw CannotDumpException(
1727 : : rtl::OString(
1728 : : RTL_CONSTASCII_STRINGPARAM(
1729 : 0 : "Too many local variables for Java class file format")));
1730 : : }
1731 : 5041 : *index = *index + size;
1732 : 5041 : return stack;
1733 : : }
1734 : :
1735 : 1102 : void addBaseArguments(
1736 : : TypeManager const & manager, Dependencies * dependencies,
1737 : : MethodDescriptor * methodDescriptor, ClassFile::Code * code,
1738 : : RTTypeClass typeClass, rtl::OString const & type, sal_uInt16 * index)
1739 : : {
1740 : : OSL_ASSERT(
1741 : : dependencies != 0 && methodDescriptor != 0 && code != 0 && index != 0);
1742 [ + - ]: 1102 : typereg::Reader reader(manager.getTypeReader(type));
1743 [ + - ][ + - : 5510 : if (!reader.isValid() || reader.getTypeClass() != typeClass
+ - + - -
+ ][ - + ]
1744 [ + - ][ + - ]: 2204 : || codemaker::convertString(reader.getTypeName()) != type
[ + - ][ + - ]
[ # # # # ]
1745 : 2204 : || reader.getMethodCount() != 0 || reader.getReferenceCount() != 0)
1746 : : {
1747 : : throw CannotDumpException(
1748 : 0 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("Bad type information")));
1749 : : //TODO
1750 : : }
1751 : 1102 : sal_uInt16 superTypes = reader.getSuperTypeCount();
1752 : 1102 : sal_uInt16 fields = reader.getFieldCount();
1753 : 1102 : sal_uInt16 firstField = 0;
1754 [ + + ]: 1102 : if (type
1755 : : == rtl::OString(
1756 : 1102 : RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Exception")))
1757 : : {
1758 [ + - ][ + - ]: 493 : if (typeClass != RT_TYPE_EXCEPTION || superTypes != 0 || fields != 2) {
[ - + ]
1759 : : throw CannotDumpException(
1760 : : rtl::OString(
1761 : 0 : RTL_CONSTASCII_STRINGPARAM("Bad type information"))); //TODO
1762 : : }
1763 : 493 : firstField = 1;
1764 : : } else {
1765 [ + + ][ + - ]: 609 : if (
[ + - ][ + + ]
[ - + ]
1766 : : (typeClass == RT_TYPE_STRUCT && (superTypes > 1 || fields == 0)) ||
1767 : : (typeClass == RT_TYPE_EXCEPTION && superTypes != 1)
1768 : : )
1769 : : {
1770 : : throw CannotDumpException(
1771 : : rtl::OString(
1772 : 0 : RTL_CONSTASCII_STRINGPARAM("Bad type information"))); //TODO
1773 : : }
1774 [ + + ]: 609 : if (superTypes == 1) {
1775 : : addBaseArguments(
1776 : : manager, dependencies, methodDescriptor, code, typeClass,
1777 [ + - ][ + - ]: 383 : codemaker::convertString(reader.getSuperTypeName(0)), index);
[ + - ]
1778 : : }
1779 : : }
1780 [ + + ]: 2258 : for (sal_uInt16 i = firstField; i < fields; ++i) {
1781 [ + - ][ + - ]: 1156 : if (reader.getFieldFlags(i) != RT_ACCESS_READWRITE
[ - + ][ + - ]
[ - + # # ]
1782 : : || reader.getFieldValue(i).m_type != RT_TYPE_NONE)
1783 : : {
1784 : : throw CannotDumpException(
1785 : : rtl::OString(
1786 : 0 : RTL_CONSTASCII_STRINGPARAM("Bad type information"))); //TODO
1787 : : }
1788 : : rtl::OString fieldType(
1789 [ + - ][ + - ]: 1156 : codemaker::convertString(reader.getFieldTypeName(i)));
1790 [ + - ]: 1156 : methodDescriptor->addParameter(fieldType, false, true, 0);
1791 : : addLoadLocal(
1792 [ + - ]: 1156 : manager, code, index, false, fieldType, false, dependencies);
1793 : 2258 : }
1794 : 1102 : }
1795 : :
1796 : 3570 : sal_uInt16 addDirectArgument(
1797 : : TypeManager const & manager, Dependencies * dependencies,
1798 : : MethodDescriptor * methodDescriptor, ClassFile::Code * code,
1799 : : sal_uInt16 * index, rtl::OString const & className,
1800 : : rtl::OString const & fieldName, bool typeParameter,
1801 : : rtl::OString const & fieldType)
1802 : : {
1803 : : OSL_ASSERT(
1804 : : dependencies != 0 && methodDescriptor != 0 && code != 0 && index != 0);
1805 : 3570 : rtl::OString desc;
1806 [ + + ]: 3570 : if (typeParameter) {
1807 [ + - ]: 13 : methodDescriptor->addTypeParameter(fieldType);
1808 : 13 : desc = rtl::OString(RTL_CONSTASCII_STRINGPARAM("Ljava/lang/Object;"));
1809 : : } else {
1810 [ + - ]: 3557 : methodDescriptor->addParameter(fieldType, false, true, 0);
1811 [ + - ]: 3557 : getFieldDescriptor(manager, dependencies, fieldType, &desc, 0, 0);
1812 : : }
1813 [ + - ]: 3570 : code->loadLocalReference(0);
1814 : : sal_uInt16 stack = addLoadLocal(
1815 [ + - ]: 3570 : manager, code, index, typeParameter, fieldType, false, dependencies);
1816 [ + - ]: 3570 : code->instrPutfield(className, fieldName, desc);
1817 : 3570 : return stack + 1;
1818 : : }
1819 : :
1820 : 1393 : void handleAggregatingType(
1821 : : TypeManager const & manager, JavaOptions /*TODO const*/ & options,
1822 : : typereg::Reader const & reader, Dependencies * dependencies)
1823 : : {
1824 : : OSL_ASSERT(dependencies != 0);
1825 [ - + ]: 1393 : if (reader.getMethodCount() != 0)
1826 : : {
1827 : : throw CannotDumpException(
1828 : 0 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("Bad type information")));
1829 : : //TODO
1830 : : }
1831 : 1393 : RTTypeClass typeClass = reader.getTypeClass();
1832 [ + - ][ + - ]: 1393 : rtl::OString className(codemaker::convertString(reader.getTypeName()));
1833 : 1393 : sal_uInt16 superTypes = reader.getSuperTypeCount();
1834 : 1393 : sal_uInt16 fields = reader.getFieldCount();
1835 : 1393 : sal_uInt16 firstField = 0;
1836 : 1393 : sal_uInt16 references = reader.getReferenceCount();
1837 : 1393 : bool runtimeException = false;
1838 : 1393 : rtl::OString superClass;
1839 [ + + ]: 1393 : if (className
1840 : : == rtl::OString(
1841 : 1393 : RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Exception")))
1842 : : {
1843 [ + - ][ + - ]: 2 : if (typeClass != RT_TYPE_EXCEPTION || superTypes != 0 || fields != 2
[ + - ][ - + ]
1844 : : || references != 0)
1845 : : {
1846 : : throw CannotDumpException(
1847 : : rtl::OString(
1848 : 0 : RTL_CONSTASCII_STRINGPARAM("Bad type information"))); //TODO
1849 : : }
1850 : 2 : firstField = 1;
1851 : : superClass = rtl::OString(
1852 : 2 : RTL_CONSTASCII_STRINGPARAM("java/lang/Exception"));
1853 [ + + ]: 1391 : } else if (className
1854 : : == rtl::OString(
1855 : : RTL_CONSTASCII_STRINGPARAM(
1856 : 1391 : "com/sun/star/uno/RuntimeException")))
1857 : : {
1858 [ + - ][ + - ]: 2 : if (typeClass != RT_TYPE_EXCEPTION || superTypes != 1 || fields != 0
[ + - ][ - + ]
1859 : : || references != 0)
1860 : : {
1861 : : throw CannotDumpException(
1862 : : rtl::OString(
1863 : 0 : RTL_CONSTASCII_STRINGPARAM("Bad type information"))); //TODO
1864 : : }
1865 : 2 : superTypes = 0;
1866 : : superClass = rtl::OString(
1867 : 2 : RTL_CONSTASCII_STRINGPARAM("java/lang/RuntimeException"));
1868 : 2 : runtimeException = true;
1869 : : } else {
1870 [ + + ][ + - ]: 1389 : if (
[ + + ][ + - ]
[ + - ][ + + ]
[ - + ]
1871 : : (
1872 : : typeClass == RT_TYPE_STRUCT &&
1873 : : (
1874 : : fields == 0 ||
1875 : : (references == 0 ? superTypes > 1 : superTypes != 0)
1876 : : )
1877 : : ) ||
1878 : : (typeClass == RT_TYPE_EXCEPTION && superTypes != 1)
1879 : : )
1880 : : {
1881 : : throw CannotDumpException(
1882 : : rtl::OString(
1883 : 0 : RTL_CONSTASCII_STRINGPARAM("Bad type information"))); //TODO
1884 : : }
1885 [ + + ]: 1389 : if (superTypes == 0) {
1886 : : superClass = rtl::OString(
1887 : 670 : RTL_CONSTASCII_STRINGPARAM("java/lang/Object"));
1888 : : } else {
1889 [ + - ][ + - ]: 719 : superClass = codemaker::convertString(reader.getSuperTypeName(0));
1890 [ + - ]: 719 : dependencies->insert(superClass);
1891 : : }
1892 : : }
1893 : 1393 : rtl::OString sig;
1894 [ + - ]: 1393 : std::map< rtl::OString, sal_Int32 > typeParameters;
1895 [ + + ]: 1393 : if (references != 0) {
1896 : 10 : rtl::OStringBuffer buf;
1897 [ + - ]: 10 : buf.append('<');
1898 [ + + ]: 23 : for (sal_uInt16 i = 0; i < references; ++i) {
1899 [ + - - + ]: 26 : if (reader.getReferenceFlags(i) != RT_ACCESS_INVALID
[ - + ]
1900 : 13 : || reader.getReferenceSort(i) != RT_REF_TYPE_PARAMETER)
1901 : : {
1902 : : throw CannotDumpException(
1903 : : rtl::OString(
1904 : 0 : RTL_CONSTASCII_STRINGPARAM("Bad type information")));
1905 : : //TODO
1906 : : }
1907 : : rtl::OString name(
1908 [ + - ][ + - ]: 13 : codemaker::convertString(reader.getReferenceTypeName(i)));
1909 [ + - ]: 13 : buf.append(name);
1910 [ + - ]: 13 : buf.append(RTL_CONSTASCII_STRINGPARAM(":Ljava/lang/Object;"));
1911 [ - + ]: 13 : if (!typeParameters.insert(
1912 : : std::map< rtl::OString, sal_Int32 >::value_type(name, i)).
1913 [ + - ]: 13 : second)
1914 : : {
1915 : : throw CannotDumpException(
1916 : : rtl::OString(
1917 : 0 : RTL_CONSTASCII_STRINGPARAM("Bad type information")));
1918 : : //TODO
1919 : : }
1920 : 13 : }
1921 [ + - ]: 10 : buf.append(RTL_CONSTASCII_STRINGPARAM(">Ljava/lang/Object;"));
1922 : 10 : sig = buf.makeStringAndClear();
1923 : : }
1924 : : SAL_WNODEPRECATED_DECLARATIONS_PUSH
1925 : : std::auto_ptr< ClassFile > cf(
1926 : : new ClassFile(
1927 : : static_cast< ClassFile::AccessFlags >(
1928 : : ClassFile::ACC_PUBLIC | ClassFile::ACC_SUPER),
1929 [ + - ][ + - ]: 1393 : className, superClass, sig));
1930 : : SAL_WNODEPRECATED_DECLARATIONS_POP
1931 [ + - ]: 1393 : std::vector< TypeInfo > typeInfo;
1932 [ + + ]: 4961 : {for (sal_uInt16 i = firstField; i < fields; ++i) {
1933 : 3568 : RTFieldAccess flags = reader.getFieldFlags(i);
1934 [ + - ][ + + ]: 3568 : if ((flags != RT_ACCESS_READWRITE
[ + - ][ + - ]
[ - + ][ + - ]
[ - + # # ]
[ + + ]
1935 : : && flags != (RT_ACCESS_READWRITE | RT_ACCESS_PARAMETERIZED_TYPE))
1936 : : || ((flags & RT_ACCESS_PARAMETERIZED_TYPE) != 0 && references == 0)
1937 : : || reader.getFieldValue(i).m_type != RT_TYPE_NONE)
1938 : : {
1939 : : throw CannotDumpException(
1940 : : rtl::OString(
1941 : 0 : RTL_CONSTASCII_STRINGPARAM("Bad type information"))); //TODO
1942 : : }
1943 : : rtl::OString type(
1944 [ + - ][ + - ]: 3568 : codemaker::convertString(reader.getFieldTypeName(i)));
1945 : : sal_Int32 typeParameterIndex;
1946 [ + + ]: 3568 : if ((flags & RT_ACCESS_PARAMETERIZED_TYPE) == 0) {
1947 : 3555 : typeParameterIndex = -1;
1948 : : } else {
1949 : : std::map< rtl::OString, sal_Int32 >::iterator it(
1950 [ + - ]: 13 : typeParameters.find(type));
1951 [ - + ]: 13 : if (it == typeParameters.end()) {
1952 : : throw CannotDumpException(
1953 : : rtl::OString(
1954 : 0 : RTL_CONSTASCII_STRINGPARAM("Bad type information")));
1955 : : //TODO
1956 : : }
1957 : 13 : typeParameterIndex = it->second;
1958 : : }
1959 : : addField(
1960 : : manager, dependencies, cf.get(), &typeInfo, typeParameterIndex,
1961 [ + - ][ + - ]: 3568 : type, codemaker::convertString(reader.getFieldName(i)), i - firstField);
[ + - ]
1962 : 3568 : }}
1963 [ + + ]: 1393 : if (runtimeException) {
1964 : : addField(
1965 : : manager, dependencies, cf.get(), &typeInfo, -1,
1966 : : rtl::OString(
1967 : : RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/XInterface")),
1968 [ + - ]: 2 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("Context")), 0);
1969 : : }
1970 : : SAL_WNODEPRECATED_DECLARATIONS_PUSH
1971 [ + - ]: 1393 : std::auto_ptr< ClassFile::Code > code(cf->newCode());
1972 : : SAL_WNODEPRECATED_DECLARATIONS_POP
1973 [ + - ]: 1393 : code->loadLocalReference(0);
1974 : : code->instrInvokespecial(
1975 : : superClass, rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
1976 [ + - ]: 1393 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("()V")));
1977 : 1393 : sal_uInt16 stack = 0;
1978 [ + + ]: 4961 : {for (sal_uInt16 i = firstField; i < fields; ++i) {
1979 : : stack = std::max(
1980 : : stack,
1981 : : addFieldInit(
1982 : : manager, className,
1983 : : codemaker::convertString(reader.getFieldName(i)),
1984 : 3568 : (reader.getFieldFlags(i) & RT_ACCESS_PARAMETERIZED_TYPE) != 0,
1985 : : codemaker::convertString(reader.getFieldTypeName(i)),
1986 [ + - ]: 7136 : dependencies, code.get()));
[ + - + - ]
[ + - ][ + - ]
[ + - ]
1987 : : }}
1988 [ + + ]: 1393 : if (runtimeException) {
1989 : : stack = std::max(
1990 : : stack,
1991 : : addFieldInit(
1992 : : manager, className,
1993 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("Context")), false,
1994 : : rtl::OString(
1995 : : RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/XInterface")),
1996 [ + - ][ + - ]: 2 : dependencies, code.get()));
1997 : : }
1998 [ + - ]: 1393 : code->instrReturn();
1999 : 1393 : code->setMaxStackAndLocals(stack + 1, 1);
2000 : : cf->addMethod(
2001 : : ClassFile::ACC_PUBLIC,
2002 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
2003 : 1393 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("()V")), code.get(),
2004 [ + - + - ]: 2786 : std::vector< rtl::OString >(), rtl::OString());
2005 [ + + ]: 1393 : if (typeClass == RT_TYPE_EXCEPTION) {
2006 [ + - ]: 497 : code.reset(cf->newCode());
2007 [ + - ]: 497 : code->loadLocalReference(0);
2008 [ + - ]: 497 : code->loadLocalReference(1);
2009 : : code->instrInvokespecial(
2010 : : superClass, rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
2011 [ + - ]: 497 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("(Ljava/lang/String;)V")));
2012 : 497 : stack = 0;
2013 [ + + ]: 811 : for (sal_uInt16 i = firstField; i < fields; ++i) {
2014 : : stack = std::max(
2015 : : stack,
2016 : : addFieldInit(
2017 : : manager, className,
2018 : : codemaker::convertString(reader.getFieldName(i)),
2019 : 314 : ((reader.getFieldFlags(i) & RT_ACCESS_PARAMETERIZED_TYPE)
2020 : : != 0),
2021 : : codemaker::convertString(reader.getFieldTypeName(i)),
2022 [ + - ]: 628 : dependencies, code.get()));
[ + - + - ]
[ + - ][ + - ]
[ + - ]
2023 : : }
2024 [ + + ]: 497 : if (runtimeException) {
2025 : : stack = std::max(
2026 : : stack,
2027 : : addFieldInit(
2028 : : manager, className,
2029 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("Context")), false,
2030 : : rtl::OString(
2031 : : RTL_CONSTASCII_STRINGPARAM(
2032 : : "com/sun/star/uno/XInterface")),
2033 [ + - ][ + - ]: 2 : dependencies, code.get()));
2034 : : }
2035 [ + - ]: 497 : code->instrReturn();
2036 : 497 : code->setMaxStackAndLocals(stack + 2, 2);
2037 : : cf->addMethod(
2038 : : ClassFile::ACC_PUBLIC,
2039 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
2040 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("(Ljava/lang/String;)V")),
2041 [ + - ][ + - ]: 497 : code.get(), std::vector< rtl::OString >(), rtl::OString());
2042 : : }
2043 : : MethodDescriptor desc(
2044 : : manager, dependencies, rtl::OString(RTL_CONSTASCII_STRINGPARAM("void")),
2045 [ + - ]: 1393 : 0, 0);
2046 [ + - ]: 1393 : code.reset(cf->newCode());
2047 [ + - ]: 1393 : code->loadLocalReference(0);
2048 : 1393 : sal_uInt16 index = 1;
2049 [ + + ]: 1393 : if (typeClass == RT_TYPE_EXCEPTION) {
2050 : : desc.addParameter(
2051 [ + - ]: 497 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("string")), false, true, 0);
2052 [ + - ]: 497 : code->loadLocalReference(index++);
2053 : : }
2054 [ + + ]: 1393 : if (superTypes != 0) {
2055 : : addBaseArguments(
2056 : : manager, dependencies, &desc, code.get(), typeClass, superClass,
2057 [ + - ]: 719 : &index);
2058 : : }
2059 : : code->instrInvokespecial(
2060 : : superClass, rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
2061 [ + - ][ + - ]: 1393 : desc.getDescriptor());
2062 : 1393 : sal_uInt16 maxSize = index;
2063 [ + + ]: 4961 : {for (sal_uInt16 i = firstField; i < fields; ++i) {
2064 : : maxSize = std::max(
2065 : : maxSize,
2066 : : addDirectArgument(
2067 : : manager, dependencies, &desc, code.get(), &index, className,
2068 : : codemaker::convertString(reader.getFieldName(i)),
2069 : 3568 : (reader.getFieldFlags(i) & RT_ACCESS_PARAMETERIZED_TYPE) != 0,
2070 [ + - ]: 7136 : codemaker::convertString(reader.getFieldTypeName(i))));
[ + - + - ]
[ + - ][ + - ]
[ + - ]
2071 : : }}
2072 [ + + ]: 1393 : if (runtimeException) {
2073 : : maxSize = std::max(
2074 : : maxSize,
2075 : : addDirectArgument(
2076 : : manager, dependencies, &desc, code.get(), &index, className,
2077 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("Context")), false,
2078 : : rtl::OString(
2079 : : RTL_CONSTASCII_STRINGPARAM(
2080 [ + - ][ + - ]: 2 : "com/sun/star/uno/XInterface"))));
2081 : : }
2082 [ + - ]: 1393 : code->instrReturn();
2083 : 1393 : code->setMaxStackAndLocals(maxSize, index);
2084 : : cf->addMethod(
2085 : : ClassFile::ACC_PUBLIC,
2086 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
2087 : 1393 : desc.getDescriptor(), code.get(), std::vector< rtl::OString >(),
2088 [ + - + - ]: 2786 : desc.getSignature());
[ + - ][ + - ]
2089 [ + - ]: 1393 : addTypeInfo(className, typeInfo, dependencies, cf.get());
2090 [ + - ][ + - ]: 1393 : writeClassFile(options, className, *cf.get());
[ + - ]
2091 : 1393 : }
2092 : :
2093 : 11972 : void createExceptionsAttribute(
2094 : : TypeManager const & manager, typereg::Reader const & reader,
2095 : : sal_uInt16 methodIndex, Dependencies * dependencies,
2096 : : std::vector< rtl::OString > * exceptions, codemaker::ExceptionTree * tree)
2097 : : {
2098 : : OSL_ASSERT(dependencies != 0 && exceptions != 0);
2099 : 11972 : sal_uInt16 n = reader.getMethodExceptionCount(methodIndex);
2100 [ + + ]: 17747 : for (sal_uInt16 i = 0; i < n; ++i) {
2101 : : rtl::OString type(
2102 : : codemaker::convertString(
2103 [ + - ][ + - ]: 5775 : reader.getMethodExceptionTypeName(methodIndex, i)));
2104 [ + - ]: 5775 : dependencies->insert(type);
2105 [ + - ]: 5775 : exceptions->push_back(type);
2106 [ + + ]: 5775 : if (tree != 0) {
2107 [ + - ]: 90 : tree->add(type, manager);
2108 : : }
2109 : 5775 : }
2110 : 11972 : }
2111 : :
2112 : 3323 : void handleInterfaceType(
2113 : : TypeManager const & manager, JavaOptions /*TODO const*/ & options,
2114 : : typereg::Reader const & reader, Dependencies * dependencies)
2115 : : {
2116 : : OSL_ASSERT(dependencies != 0);
2117 : :
2118 [ + - ][ + - ]: 3323 : rtl::OString className(codemaker::convertString(reader.getTypeName()));
2119 : 3323 : sal_uInt16 superTypes = reader.getSuperTypeCount();
2120 : 3323 : sal_uInt16 fields = reader.getFieldCount();
2121 : 3323 : sal_uInt16 methods = reader.getMethodCount();
2122 [ + + ]: 3323 : if (className
2123 : : == rtl::OString(
2124 : 3323 : RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/XInterface")))
2125 : : {
2126 [ + - ][ + - ]: 2 : if (superTypes != 0 || fields != 0 || methods != 3) {
[ - + ]
2127 : : throw CannotDumpException(
2128 : : rtl::OString(
2129 : 0 : RTL_CONSTASCII_STRINGPARAM("Bad type information"))); //TODO
2130 : : }
2131 : 2 : methods = 0;
2132 [ - + ]: 3321 : } else if (superTypes == 0) {
2133 : : throw CannotDumpException(
2134 : 0 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("Bad type information")));
2135 : : //TODO
2136 : : }
2137 : : SAL_WNODEPRECATED_DECLARATIONS_PUSH
2138 : : std::auto_ptr< ClassFile > cf(
2139 : : new ClassFile(
2140 : : static_cast< ClassFile::AccessFlags >(
2141 : : ClassFile::ACC_PUBLIC | ClassFile::ACC_INTERFACE
2142 : : | ClassFile::ACC_ABSTRACT),
2143 : : className,
2144 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("java/lang/Object")),
2145 [ + - ][ + - ]: 3323 : rtl::OString()));
2146 : : SAL_WNODEPRECATED_DECLARATIONS_POP
2147 [ + + ]: 6907 : {for (sal_uInt16 i = 0; i < superTypes; ++i) {
2148 [ + - ][ + - ]: 3584 : rtl::OString t(codemaker::convertString(reader.getSuperTypeName(i)));
2149 [ + - ]: 3584 : dependencies->insert(t);
2150 [ + - ]: 3584 : cf->addInterface(t);
2151 : 3584 : }}
2152 : : // As a special case, let com.sun.star.lang.XEventListener extend
2153 : : // java.util.EventListener ("A tagging interface that all event listener
2154 : : // interfaces must extend"):
2155 [ + + ]: 3323 : if (className ==
2156 : : rtl::OString(
2157 : 3323 : RTL_CONSTASCII_STRINGPARAM("com/sun/star/lang/XEventListener")))
2158 : : {
2159 : : cf->addInterface(
2160 : : rtl::OString(
2161 [ + - ]: 2 : RTL_CONSTASCII_STRINGPARAM("java/util/EventListener")));
2162 : : }
2163 [ + - ]: 3323 : std::vector< TypeInfo > typeInfo;
2164 : 3323 : sal_Int32 index = 0;
2165 [ + + ]: 4439 : {for (sal_uInt16 i = 0; i < fields; ++i) {
2166 : 1116 : RTFieldAccess flags = reader.getFieldFlags(i);
2167 : : //TODO: ok if both READONLY and BOUND?
2168 [ + - ][ + - ]: 1116 : if (((((flags & RT_ACCESS_READWRITE) != 0)
[ - + ][ + - ]
[ - + # # ]
[ + - ]
2169 : : ^ ((flags & RT_ACCESS_READONLY) != 0))
2170 : : == 0)
2171 : : || ((flags
2172 : : & ~(RT_ACCESS_READWRITE | RT_ACCESS_READONLY
2173 : : | RT_ACCESS_BOUND))
2174 : : != 0)
2175 : : || reader.getFieldValue(i).m_type != RT_TYPE_NONE)
2176 : : {
2177 : : throw CannotDumpException(
2178 : : rtl::OString(
2179 : 0 : RTL_CONSTASCII_STRINGPARAM("Bad type information"))); //TODO
2180 : : }
2181 : : //TODO: exploit the fact that attribute getter/setter methods preceed
2182 : : // real methods
2183 [ + - ]: 1116 : rtl::OUString attrNameUtf16(reader.getFieldName(i));
2184 : 1116 : sal_uInt16 getter = SAL_MAX_UINT16;
2185 : 1116 : sal_uInt16 setter = SAL_MAX_UINT16;
2186 [ + + ]: 20854 : for (sal_uInt16 j = 0; j < methods; ++j) {
2187 : 19738 : RTMethodMode mflags = reader.getMethodFlags(j);
2188 [ + + + + ]: 55774 : if ((mflags == RT_MODE_ATTRIBUTE_GET
[ + + ][ + + ]
2189 : : || mflags == RT_MODE_ATTRIBUTE_SET)
2190 [ + - ][ + + ]: 36036 : && reader.getMethodName(j) == attrNameUtf16)
[ # # ]
2191 : : {
2192 [ + - ]: 756 : if (reader.getMethodReturnTypeName(j) != "void"
[ + - + - ]
[ + + ][ - + ]
[ + - ][ - + ]
[ + - ]
[ - + # # ]
2193 : 378 : || reader.getMethodParameterCount(j) != 0
2194 : : || (mflags == RT_MODE_ATTRIBUTE_GET
2195 : : ? getter != SAL_MAX_UINT16
2196 : : : (setter != SAL_MAX_UINT16
2197 : : || (flags & RT_ACCESS_READONLY) != 0)))
2198 : : {
2199 : : throw CannotDumpException(
2200 : : rtl::OString(
2201 : : RTL_CONSTASCII_STRINGPARAM(
2202 : 0 : "Bad type information"))); //TODO
2203 : : }
2204 : : OSL_ASSERT(j != SAL_MAX_UINT16);
2205 [ + + ]: 378 : (mflags == RT_MODE_ATTRIBUTE_GET ? getter : setter) = j;
2206 : : }
2207 : : }
2208 : : rtl::OString fieldType(
2209 [ + - ][ + - ]: 1116 : codemaker::convertString(reader.getFieldTypeName(i)));
2210 : : SpecialType specialType;
2211 : 1116 : PolymorphicUnoType polymorphicUnoType;
2212 : : MethodDescriptor gdesc(
2213 : : manager, dependencies, fieldType, &specialType,
2214 [ + - ]: 1116 : &polymorphicUnoType);
2215 [ + - ]: 1116 : std::vector< rtl::OString > exc;
2216 [ + + ]: 1116 : if (getter != SAL_MAX_UINT16) {
2217 : : createExceptionsAttribute(
2218 [ + - ]: 167 : manager, reader, getter, dependencies, &exc, 0);
2219 : : }
2220 [ + - ]: 1116 : rtl::OString attrName(codemaker::convertString(attrNameUtf16));
2221 : : cf->addMethod(
2222 : : static_cast< ClassFile::AccessFlags >(
2223 : : ClassFile::ACC_PUBLIC | ClassFile::ACC_ABSTRACT),
2224 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("get")) + attrName,
2225 [ + - ][ + - ]: 1116 : gdesc.getDescriptor(), 0, exc, gdesc.getSignature());
[ + - ]
2226 [ + + ]: 1116 : if ((flags & RT_ACCESS_READONLY) == 0) {
2227 : : MethodDescriptor sdesc(
2228 : : manager, dependencies,
2229 [ + - ]: 851 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("void")), 0, 0);
2230 [ + - ]: 851 : sdesc.addParameter(fieldType, false, true, 0);
2231 [ + - ]: 851 : std::vector< rtl::OString > exc2;
2232 [ + + ]: 851 : if (setter != SAL_MAX_UINT16) {
2233 : : createExceptionsAttribute(
2234 [ + - ]: 211 : manager, reader, setter, dependencies, &exc2, 0);
2235 : : }
2236 : : cf->addMethod(
2237 : : static_cast< ClassFile::AccessFlags >(
2238 : : ClassFile::ACC_PUBLIC | ClassFile::ACC_ABSTRACT),
2239 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("set")) + attrName,
2240 [ + - ][ + - ]: 851 : sdesc.getDescriptor(), 0, exc2, sdesc.getSignature());
[ + - ]
2241 : : }
2242 : : typeInfo.push_back(
2243 : : TypeInfo(
2244 : : TypeInfo::KIND_ATTRIBUTE, attrName, specialType,
2245 : : static_cast< TypeInfo::Flags >(
2246 : : ((flags & RT_ACCESS_READONLY) == 0
2247 : : ? 0 : TypeInfo::FLAG_READONLY)
2248 : : | ((flags & RT_ACCESS_BOUND) == 0
2249 : : ? 0 : TypeInfo::FLAG_BOUND)),
2250 [ + + ][ + + ]: 1116 : index, polymorphicUnoType));
[ + - ]
2251 [ + + ]: 1116 : index += ((flags & RT_ACCESS_READONLY) == 0 ? 2 : 1);
2252 : 1116 : }}
2253 [ + + ]: 15128 : {for (sal_uInt16 i = 0; i < methods; ++i) {
2254 : 11805 : RTMethodMode flags = reader.getMethodFlags(i);
2255 [ + + - ]: 11805 : switch (flags) {
2256 : : case RT_MODE_ONEWAY:
2257 : : case RT_MODE_TWOWAY:
2258 : : {
2259 : : rtl::OString methodName(
2260 [ + - ][ + - ]: 11427 : codemaker::convertString(reader.getMethodName(i)));
2261 : : SpecialType specialReturnType;
2262 : 11427 : PolymorphicUnoType polymorphicUnoReturnType;
2263 : : MethodDescriptor desc(
2264 : : manager, dependencies,
2265 : : codemaker::convertString(
2266 : : reader.getMethodReturnTypeName(i)),
2267 [ + - ][ + - ]: 11427 : &specialReturnType, &polymorphicUnoReturnType);
[ + - ]
2268 : : typeInfo.push_back(
2269 : : TypeInfo(
2270 : : TypeInfo::KIND_METHOD, methodName, specialReturnType,
2271 : : static_cast< TypeInfo::Flags >(
2272 : : flags == RT_MODE_ONEWAY
2273 : : ? TypeInfo::FLAG_ONEWAY : 0),
2274 [ + - ][ + + ]: 11427 : index++, polymorphicUnoReturnType));
2275 [ + + ]: 23155 : for (sal_uInt16 j = 0; j < reader.getMethodParameterCount(i);
2276 : : ++j)
2277 : : {
2278 : : bool in;
2279 : : bool out;
2280 [ + + + - ]: 11728 : switch (reader.getMethodParameterFlags(i, j)) {
2281 : : case RT_PARAM_IN:
2282 : 11350 : in = true;
2283 : 11350 : out = false;
2284 : 11350 : break;
2285 : :
2286 : : case RT_PARAM_OUT:
2287 : 234 : in = false;
2288 : 234 : out = true;
2289 : 234 : break;
2290 : :
2291 : : case RT_PARAM_INOUT:
2292 : 144 : in = true;
2293 : 144 : out = true;
2294 : 144 : break;
2295 : :
2296 : : default:
2297 : : throw CannotDumpException(
2298 : : rtl::OString(
2299 : : RTL_CONSTASCII_STRINGPARAM(
2300 : 0 : "Bad type information"))); //TODO
2301 : : }
2302 : 11728 : PolymorphicUnoType polymorphicUnoType;
2303 : : SpecialType specialType = desc.addParameter(
2304 : : codemaker::convertString(
2305 : : reader.getMethodParameterTypeName(i, j)),
2306 [ + - ][ + - ]: 11728 : out, true, &polymorphicUnoType);
[ + - ]
2307 [ + + ][ + + ]: 11728 : if (out || isSpecialType(specialType)
[ + + ][ + + ]
2308 : : || (polymorphicUnoType.kind
2309 : : != PolymorphicUnoType::KIND_NONE))
2310 : : {
2311 : : typeInfo.push_back(
2312 : : TypeInfo(
2313 : : codemaker::convertString(
2314 : : reader.getMethodParameterName(i, j)),
2315 : : specialType, in, out, methodName, j,
2316 [ + - ][ + - ]: 529 : polymorphicUnoType));
[ + - ]
2317 : : }
2318 : 11728 : }
2319 [ + - ]: 11427 : std::vector< rtl::OString > exc2;
2320 : : createExceptionsAttribute(
2321 [ + - ]: 11427 : manager, reader, i, dependencies, &exc2, 0);
2322 : : cf->addMethod(
2323 : : static_cast< ClassFile::AccessFlags >(
2324 : : ClassFile::ACC_PUBLIC | ClassFile::ACC_ABSTRACT),
2325 : : methodName, desc.getDescriptor(), 0, exc2,
2326 [ + - ][ + - ]: 11427 : desc.getSignature());
[ + - ]
2327 : 11427 : break;
2328 : : }
2329 : :
2330 : : case RT_MODE_ATTRIBUTE_GET:
2331 : : case RT_MODE_ATTRIBUTE_SET:
2332 : : {
2333 : : //TODO: exploit the fact that attribute getter/setter methods
2334 : : // are ordered the same way as the attribute fields themselves
2335 [ + - ]: 378 : rtl::OUString methodNameUtf16(reader.getMethodName(i));
2336 : 378 : bool found = false;
2337 [ + - ]: 8509 : for (sal_uInt16 j = 0; j < fields; ++j) {
2338 [ + - ][ + + ]: 8509 : if (reader.getFieldName(j) == methodNameUtf16) {
2339 : 378 : found = true;
2340 : 378 : break;
2341 : : }
2342 : : }
2343 [ + - ]: 378 : if (found) {
2344 : : break;
2345 [ - + ]: 378 : }
2346 : : }
2347 : : default:
2348 : : throw CannotDumpException(
2349 : : rtl::OString(
2350 : 0 : RTL_CONSTASCII_STRINGPARAM("Bad type information"))); //TODO
2351 : : }
2352 : : }}
2353 [ + - ]: 3323 : addTypeInfo(className, typeInfo, dependencies, cf.get());
2354 [ + - ][ + - ]: 3323 : writeClassFile(options, className, *cf.get());
2355 : 3323 : }
2356 : :
2357 : 63 : void handleTypedef(
2358 : : TypeManager const & manager,
2359 : : SAL_UNUSED_PARAMETER JavaOptions /*TODO const*/ &,
2360 : : typereg::Reader const & reader, Dependencies * dependencies)
2361 : : {
2362 : : OSL_ASSERT(dependencies != 0);
2363 [ + - ][ + - : 189 : if (reader.getSuperTypeCount() != 1 || reader.getFieldCount() != 0
+ - - + ]
[ - + ]
2364 : 126 : || reader.getMethodCount() != 0 || reader.getReferenceCount() != 0)
2365 : : {
2366 : : throw CannotDumpException(
2367 : 0 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("Bad type information")));
2368 : : //TODO
2369 : : }
2370 : : RTTypeClass typeClass;
2371 : 63 : rtl::OString nucleus;
2372 : : sal_Int32 rank;
2373 [ + - ]: 63 : std::vector< rtl::OString > args;
2374 [ + + ]: 63 : if (codemaker::decomposeAndResolve(
2375 : : manager, codemaker::convertString(reader.getSuperTypeName(0)),
2376 [ + - ][ + - ]: 63 : false, false, false, &typeClass, &nucleus, &rank, &args)
[ + - ]
2377 : : == codemaker::UnoType::SORT_COMPLEX)
2378 : : {
2379 [ + + - ]: 31 : switch (typeClass) {
2380 : : case RT_TYPE_STRUCT:
2381 [ - + ]: 27 : if (!args.empty()) {
2382 : : throw CannotDumpException(
2383 : : rtl::OString(
2384 : 0 : RTL_CONSTASCII_STRINGPARAM("Bad type information")));
2385 : : //TODO
2386 : : }
2387 : : case RT_TYPE_ENUM:
2388 : : case RT_TYPE_INTERFACE:
2389 : : case RT_TYPE_TYPEDEF:
2390 [ + - ]: 31 : dependencies->insert(nucleus);
2391 : 31 : break;
2392 : :
2393 : : default:
2394 : : OSL_ASSERT(false);
2395 : 31 : break;
2396 : : }
2397 : 63 : }
2398 : 63 : }
2399 : :
2400 : 6628 : void addConstant(
2401 : : TypeManager const & manager, typereg::Reader const & reader,
2402 : : bool publishable, sal_uInt16 index, Dependencies * dependencies,
2403 : : ClassFile * classFile)
2404 : : {
2405 : : OSL_ASSERT(dependencies != 0 && classFile != 0);
2406 : 6628 : RTFieldAccess flags = reader.getFieldFlags(index);
2407 [ # # ][ # # ]: 6628 : if (flags != RT_ACCESS_CONST
[ - + ]
2408 : 0 : && (!publishable || flags != (RT_ACCESS_CONST | RT_ACCESS_PUBLISHED)))
2409 : : {
2410 : : throw CannotDumpException(
2411 : 0 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("Bad type information")));
2412 : : //TODO
2413 : : }
2414 [ + - ]: 6628 : RTConstValue fieldValue(reader.getFieldValue(index));
2415 : : sal_uInt16 valueIndex;
2416 : : RTTypeClass typeClass;
2417 : 6628 : rtl::OString nucleus;
2418 : : sal_Int32 rank;
2419 [ + - ]: 6628 : std::vector< rtl::OString > args;
2420 [ - + + - : 6628 : switch (codemaker::decomposeAndResolve(
+ + + - +
- - ]
2421 : : manager,
2422 : : codemaker::convertString(reader.getFieldTypeName(index)),
2423 [ + - ][ + - ]: 6628 : true, false, false, &typeClass, &nucleus, &rank, &args))
[ + - ]
2424 : : {
2425 : : case codemaker::UnoType::SORT_BOOLEAN:
2426 [ # # ]: 0 : if (fieldValue.m_type != RT_TYPE_BOOL) {
2427 : : throw CannotDumpException(
2428 : : rtl::OString(
2429 : 0 : RTL_CONSTASCII_STRINGPARAM("Bad type information"))); //TODO
2430 : : }
2431 [ # # ]: 0 : valueIndex = classFile->addIntegerInfo(fieldValue.m_value.aBool);
2432 : 0 : break;
2433 : :
2434 : : case codemaker::UnoType::SORT_BYTE:
2435 [ - + ]: 490 : if (fieldValue.m_type != RT_TYPE_BYTE) {
2436 : : throw CannotDumpException(
2437 : : rtl::OString(
2438 : 0 : RTL_CONSTASCII_STRINGPARAM("Bad type information"))); //TODO
2439 : : }
2440 [ + - ]: 490 : valueIndex = classFile->addIntegerInfo(fieldValue.m_value.aByte);
2441 : 490 : break;
2442 : :
2443 : : case codemaker::UnoType::SORT_SHORT:
2444 [ - + ]: 4096 : if (fieldValue.m_type != RT_TYPE_INT16) {
2445 : : throw CannotDumpException(
2446 : : rtl::OString(
2447 : 0 : RTL_CONSTASCII_STRINGPARAM("Bad type information"))); //TODO
2448 : : }
2449 [ + - ]: 4096 : valueIndex = classFile->addIntegerInfo(fieldValue.m_value.aShort);
2450 : 4096 : break;
2451 : :
2452 : : case codemaker::UnoType::SORT_UNSIGNED_SHORT:
2453 : : case codemaker::UnoType::SORT_CHAR:
2454 [ # # ]: 0 : if (fieldValue.m_type != RT_TYPE_UINT16) {
2455 : : throw CannotDumpException(
2456 : : rtl::OString(
2457 : 0 : RTL_CONSTASCII_STRINGPARAM("Bad type information"))); //TODO
2458 : : }
2459 [ # # ]: 0 : valueIndex = classFile->addIntegerInfo(fieldValue.m_value.aUShort);
2460 : 0 : break;
2461 : :
2462 : : case codemaker::UnoType::SORT_LONG:
2463 [ - + ]: 1866 : if (fieldValue.m_type != RT_TYPE_INT32) {
2464 : : throw CannotDumpException(
2465 : : rtl::OString(
2466 : 0 : RTL_CONSTASCII_STRINGPARAM("Bad type information"))); //TODO
2467 : : }
2468 [ + - ]: 1866 : valueIndex = classFile->addIntegerInfo(fieldValue.m_value.aLong);
2469 : 1866 : break;
2470 : :
2471 : : case codemaker::UnoType::SORT_UNSIGNED_LONG:
2472 [ - + ]: 78 : if (fieldValue.m_type != RT_TYPE_UINT32) {
2473 : : throw CannotDumpException(
2474 : : rtl::OString(
2475 : 0 : RTL_CONSTASCII_STRINGPARAM("Bad type information"))); //TODO
2476 : : }
2477 : : valueIndex = classFile->addIntegerInfo(
2478 [ + - ]: 78 : static_cast< sal_Int32 >(fieldValue.m_value.aULong));
2479 : 78 : break;
2480 : :
2481 : : case codemaker::UnoType::SORT_HYPER:
2482 [ - + ]: 58 : if (fieldValue.m_type != RT_TYPE_INT64) {
2483 : : throw CannotDumpException(
2484 : : rtl::OString(
2485 : 0 : RTL_CONSTASCII_STRINGPARAM("Bad type information"))); //TODO
2486 : : }
2487 [ + - ]: 58 : valueIndex = classFile->addLongInfo(fieldValue.m_value.aHyper);
2488 : 58 : break;
2489 : :
2490 : : case codemaker::UnoType::SORT_UNSIGNED_HYPER:
2491 [ # # ]: 0 : if (fieldValue.m_type != RT_TYPE_UINT64) {
2492 : : throw CannotDumpException(
2493 : : rtl::OString(
2494 : 0 : RTL_CONSTASCII_STRINGPARAM("Bad type information"))); //TODO
2495 : : }
2496 : : valueIndex = classFile->addLongInfo(
2497 [ # # ]: 0 : static_cast< sal_Int64 >(fieldValue.m_value.aUHyper));
2498 : 0 : break;
2499 : :
2500 : : case codemaker::UnoType::SORT_FLOAT:
2501 [ - + ]: 40 : if (fieldValue.m_type != RT_TYPE_FLOAT) {
2502 : : throw CannotDumpException(
2503 : : rtl::OString(
2504 : 0 : RTL_CONSTASCII_STRINGPARAM("Bad type information"))); //TODO
2505 : : }
2506 [ + - ]: 40 : valueIndex = classFile->addFloatInfo(fieldValue.m_value.aFloat);
2507 : 40 : break;
2508 : :
2509 : : case codemaker::UnoType::SORT_DOUBLE:
2510 [ # # ]: 0 : if (fieldValue.m_type != RT_TYPE_DOUBLE) {
2511 : : throw CannotDumpException(
2512 : : rtl::OString(
2513 : 0 : RTL_CONSTASCII_STRINGPARAM("Bad type information"))); //TODO
2514 : : }
2515 [ # # ]: 0 : valueIndex = classFile->addDoubleInfo(fieldValue.m_value.aDouble);
2516 : 0 : break;
2517 : :
2518 : : default:
2519 : : throw CannotDumpException(
2520 : 0 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("Bad type information")));
2521 : : //TODO
2522 : : }
2523 : 6628 : rtl::OString desc;
2524 : 6628 : rtl::OString sig;
2525 : : getFieldDescriptor(
2526 : : manager, dependencies,
2527 : : codemaker::convertString(reader.getFieldTypeName(index)),
2528 [ + - ][ + - ]: 6628 : &desc, &sig, 0);
[ + - ]
2529 : : classFile->addField(
2530 : : static_cast< ClassFile::AccessFlags >(
2531 : : ClassFile::ACC_PUBLIC | ClassFile::ACC_STATIC
2532 : : | ClassFile::ACC_FINAL),
2533 : : codemaker::convertString(reader.getFieldName(index)),
2534 [ + - ][ + - ]: 6628 : desc, valueIndex, sig);
[ + - ]
2535 : 6628 : }
2536 : :
2537 : 714 : void handleConstantGroup(
2538 : : TypeManager const & manager, JavaOptions /*TODO const*/ & options,
2539 : : typereg::Reader const & reader, Dependencies * dependencies)
2540 : : {
2541 : : OSL_ASSERT(dependencies != 0);
2542 [ + - ]: 1428 : if (reader.getSuperTypeCount() != 0 || reader.getMethodCount() != 0
[ + - - + ]
[ - + ]
2543 : 714 : || reader.getReferenceCount() != 0)
2544 : : {
2545 : : throw CannotDumpException(
2546 : 0 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("Bad type information")));
2547 : : //TODO
2548 : : }
2549 [ + - ][ + - ]: 714 : rtl::OString className(codemaker::convertString(reader.getTypeName()));
2550 : : SAL_WNODEPRECATED_DECLARATIONS_PUSH
2551 : : std::auto_ptr< ClassFile > cf(
2552 : : new ClassFile(
2553 : : static_cast< ClassFile::AccessFlags >(
2554 : : ClassFile::ACC_PUBLIC | ClassFile::ACC_INTERFACE
2555 : : | ClassFile::ACC_ABSTRACT),
2556 : : className,
2557 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("java/lang/Object")),
2558 [ + - ][ + - ]: 714 : rtl::OString()));
2559 : : SAL_WNODEPRECATED_DECLARATIONS_POP
2560 : 714 : sal_uInt16 fields = reader.getFieldCount();
2561 [ + + ]: 7342 : for (sal_uInt16 i = 0; i < fields; ++i) {
2562 [ + - ]: 6628 : addConstant(manager, reader, false, i, dependencies, cf.get());
2563 : : }
2564 [ + - ][ + - ]: 714 : writeClassFile(options, className, *cf.get());
2565 : 714 : }
2566 : :
2567 : 296 : void handleModule(
2568 : : TypeManager const & manager, JavaOptions /*TODO const*/ & options,
2569 : : typereg::Reader const & reader, Dependencies * dependencies)
2570 : : {
2571 : : OSL_ASSERT(dependencies != 0);
2572 [ + - ]: 592 : if (reader.getSuperTypeCount() != 0 || reader.getMethodCount() != 0
[ + - - + ]
[ - + ]
2573 : 296 : || reader.getReferenceCount() != 0)
2574 : : {
2575 : : throw CannotDumpException(
2576 : 0 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("Bad type information")));
2577 : : //TODO
2578 : : }
2579 [ + - ][ + - ]: 296 : rtl::OStringBuffer buf(codemaker::convertString(reader.getTypeName()));
[ + - ]
2580 [ + - ]: 296 : buf.append('/');
2581 : 296 : rtl::OString prefix(buf.makeStringAndClear());
2582 : 296 : sal_uInt16 fields = reader.getFieldCount();
2583 [ - + ]: 296 : for (sal_uInt16 i = 0; i < fields; ++i) {
2584 : : rtl::OString className(
2585 [ # # ][ # # ]: 0 : prefix + codemaker::convertString(reader.getFieldName(i)));
2586 : : SAL_WNODEPRECATED_DECLARATIONS_PUSH
2587 : : std::auto_ptr< ClassFile > cf(
2588 : : new ClassFile(
2589 : : static_cast< ClassFile::AccessFlags >(
2590 : : ClassFile::ACC_PUBLIC | ClassFile::ACC_INTERFACE
2591 : : | ClassFile::ACC_ABSTRACT),
2592 : : className,
2593 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("java/lang/Object")),
2594 [ # # ][ # # ]: 0 : rtl::OString()));
2595 : : SAL_WNODEPRECATED_DECLARATIONS_POP
2596 [ # # ]: 0 : addConstant(manager, reader, true, i, dependencies, cf.get());
2597 [ # # ]: 0 : writeClassFile(options, className, *cf.get());
2598 [ # # ]: 296 : }
2599 : 296 : }
2600 : :
2601 : 426 : void addExceptionHandlers(
2602 : : codemaker::ExceptionTreeNode const * node,
2603 : : ClassFile::Code::Position start, ClassFile::Code::Position end,
2604 : : ClassFile::Code::Position handler, ClassFile::Code * code)
2605 : : {
2606 : : OSL_ASSERT(node != 0 && code != 0);
2607 [ + + ]: 426 : if (node->present) {
2608 : 72 : code->addException(start, end, handler, node->name);
2609 : : } else {
2610 [ + - ][ + + ]: 852 : for (codemaker::ExceptionTreeNode::Children::const_iterator i(
2611 : 354 : node->children.begin());
2612 : 426 : i != node->children.end(); ++i)
2613 : : {
2614 [ + - ]: 72 : addExceptionHandlers(*i, start, end, handler, code);
2615 : : }
2616 : : }
2617 : 426 : }
2618 : :
2619 : 360 : void addConstructor(
2620 : : TypeManager const & manager, rtl::OString const & realJavaBaseName,
2621 : : rtl::OString const & unoName, rtl::OString const & className,
2622 : : typereg::Reader const & reader, sal_uInt16 methodIndex,
2623 : : rtl::OString const & methodName, rtl::OString const & returnType,
2624 : : bool defaultConstructor, Dependencies * dependencies, ClassFile * classFile)
2625 : : {
2626 : : OSL_ASSERT(dependencies != 0 && classFile != 0);
2627 [ + - ]: 360 : MethodDescriptor desc(manager, dependencies, returnType, 0, 0);
2628 : : desc.addParameter(
2629 : : rtl::OString(
2630 : : RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/XComponentContext")),
2631 [ + - ]: 360 : false, false, 0);
2632 : : SAL_WNODEPRECATED_DECLARATIONS_PUSH
2633 [ + - ]: 360 : std::auto_ptr< ClassFile::Code > code(classFile->newCode());
2634 : : SAL_WNODEPRECATED_DECLARATIONS_POP
2635 [ + - ]: 360 : code->loadLocalReference(0);
2636 : : // stack: context
2637 : : code->instrInvokestatic(
2638 : : className, rtl::OString(RTL_CONSTASCII_STRINGPARAM("$getFactory")),
2639 : : rtl::OString(
2640 : : RTL_CONSTASCII_STRINGPARAM(
2641 : : "(Lcom/sun/star/uno/XComponentContext;)"
2642 [ + - ]: 360 : "Lcom/sun/star/lang/XMultiComponentFactory;")));
2643 : : // stack: factory
2644 [ + - ]: 360 : code->loadStringConstant(unoName);
2645 : : // stack: factory serviceName
2646 [ + - ]: 360 : codemaker::ExceptionTree tree;
2647 : : ClassFile::Code::Position tryStart;
2648 : : ClassFile::Code::Position tryEnd;
2649 [ + - ]: 360 : std::vector< rtl::OString > exc;
2650 : : sal_uInt16 stack;
2651 : 360 : sal_uInt16 localIndex = 1;
2652 : : ClassFile::AccessFlags access = static_cast< ClassFile::AccessFlags >(
2653 : 360 : ClassFile::ACC_PUBLIC | ClassFile::ACC_STATIC);
2654 [ + + ]: 360 : if (defaultConstructor) {
2655 [ + - ]: 193 : code->loadLocalReference(0);
2656 : : // stack: factory serviceName context
2657 [ + - ]: 193 : tryStart = code->getPosition();
2658 : : code->instrInvokeinterface(
2659 : : rtl::OString(
2660 : : RTL_CONSTASCII_STRINGPARAM(
2661 : : "com/sun/star/lang/XMultiComponentFactory")),
2662 : : rtl::OString(
2663 : : RTL_CONSTASCII_STRINGPARAM(
2664 : : "createInstanceWithContext")),
2665 : : rtl::OString(
2666 : : RTL_CONSTASCII_STRINGPARAM(
2667 : : "(Ljava/lang/String;Lcom/sun/star/uno/XComponentContext;)"
2668 : : "Ljava/lang/Object;")),
2669 [ + - ]: 193 : 3);
2670 [ + - ]: 193 : tryEnd = code->getPosition();
2671 : : // stack: instance
2672 : 193 : stack = 3;
2673 : : } else {
2674 : 167 : sal_uInt16 parameters = reader.getMethodParameterCount(methodIndex);
2675 [ + + ][ + + : 402 : if (parameters == 1
+ + + - ]
2676 : 67 : && (reader.getMethodParameterFlags(methodIndex, 0)
2677 : : == (RT_PARAM_IN | RT_PARAM_REST))
2678 : : && (reader.getMethodParameterTypeName(methodIndex, 0)
2679 [ + - ][ + - ]: 168 : == rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("any"))))
[ + + ][ + + ]
[ # # # # ]
2680 : : {
2681 : : desc.addParameter(
2682 [ + - ]: 1 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("any")), true, true, 0);
2683 [ + - ]: 1 : code->loadLocalReference(localIndex++);
2684 : : // stack: factory serviceName args
2685 : 1 : stack = 4;
2686 : : access = static_cast< ClassFile::AccessFlags >(
2687 : 1 : access | ClassFile::ACC_VARARGS);
2688 : : } else {
2689 [ + - ]: 166 : code->loadIntegerConstant(parameters);
2690 : : // stack: factory serviceName N
2691 : : code->instrAnewarray(
2692 [ + - ]: 166 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("java/lang/Object")));
2693 : : // stack: factory serviceName args
2694 : 166 : stack = 0;
2695 [ + + ]: 481 : for (sal_uInt16 i = 0; i < parameters; ++i) {
2696 : : RTParamMode flags = reader.getMethodParameterFlags(
2697 : 315 : methodIndex, i);
2698 : : rtl::OString paramType(
2699 : : codemaker::convertString(
2700 [ + - ][ + - ]: 315 : reader.getMethodParameterTypeName(methodIndex, i)));
2701 [ # # ][ - + ]: 630 : if ((flags != RT_PARAM_IN
[ # # # # ]
[ - + ][ - + ]
2702 : : && flags != (RT_PARAM_IN | RT_PARAM_REST))
2703 : : || ((flags & RT_PARAM_REST) != 0
2704 : : && (parameters != 1
2705 : : || (paramType
2706 : : != rtl::OString(
2707 [ - + ]: 315 : RTL_CONSTASCII_STRINGPARAM("any"))))))
2708 : : {
2709 : : throw CannotDumpException(
2710 : : rtl::OString(
2711 : : RTL_CONSTASCII_STRINGPARAM(
2712 : 0 : "Bad type information"))); //TODO
2713 : : }
2714 [ + - ]: 315 : desc.addParameter(paramType, false, true, 0);
2715 [ + - ]: 315 : code->instrDup();
2716 : : // stack: factory serviceName args args
2717 [ + - ]: 315 : code->loadIntegerConstant(i);
2718 : : // stack: factory serviceName args args i
2719 : : stack = std::max(
2720 : : stack,
2721 : : addLoadLocal(
2722 : : manager, code.get(), &localIndex, false, paramType,
2723 [ + - ][ + - ]: 315 : true, dependencies));
2724 : : // stack: factory serviceName args args i any
2725 [ + - ]: 315 : code->instrAastore();
2726 : : // stack: factory serviceName args
2727 : 315 : }
2728 : 166 : stack += 5;
2729 : : }
2730 [ + - ]: 167 : code->loadLocalReference(0);
2731 : : // stack: factory serviceName args context
2732 [ + - ]: 167 : tryStart = code->getPosition();
2733 : : code->instrInvokeinterface(
2734 : : rtl::OString(
2735 : : RTL_CONSTASCII_STRINGPARAM(
2736 : : "com/sun/star/lang/XMultiComponentFactory")),
2737 : : rtl::OString(
2738 : : RTL_CONSTASCII_STRINGPARAM(
2739 : : "createInstanceWithArgumentsAndContext")),
2740 : : rtl::OString(
2741 : : RTL_CONSTASCII_STRINGPARAM(
2742 : : "(Ljava/lang/String;[Ljava/lang/Object;"
2743 : : "Lcom/sun/star/uno/XComponentContext;)Ljava/lang/Object;")),
2744 [ + - ]: 167 : 4);
2745 [ + - ]: 167 : tryEnd = code->getPosition();
2746 : : // stack: instance
2747 : : createExceptionsAttribute(
2748 [ + - ]: 167 : manager, reader, methodIndex, dependencies, &exc, &tree);
2749 : : }
2750 [ + - ]: 360 : code->loadLocalReference(0);
2751 : : // stack: instance context
2752 : : code->instrInvokestatic(
2753 : : className, rtl::OString(RTL_CONSTASCII_STRINGPARAM("$castInstance")),
2754 : : rtl::OString(
2755 : : RTL_CONSTASCII_STRINGPARAM(
2756 : : "(Ljava/lang/Object;Lcom/sun/star/uno/XComponentContext;)"
2757 [ + - ]: 360 : "Ljava/lang/Object;")));
2758 : : // stack: instance
2759 [ + - ]: 360 : code->instrCheckcast(returnType);
2760 : : // stack: instance
2761 [ + - ]: 360 : code->instrAreturn();
2762 [ + + ]: 360 : if (!tree.getRoot()->present) {
2763 [ + - ]: 354 : ClassFile::Code::Position pos1 = code->getPosition();
2764 : : // stack: e
2765 : : code->instrInvokevirtual(
2766 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("java/lang/Throwable")),
2767 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("toString")),
2768 [ + - ]: 354 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("()Ljava/lang/String;")));
2769 : : // stack: str
2770 [ + - ]: 354 : localIndex = std::max< sal_uInt16 >(localIndex, 2);
2771 [ + - ]: 354 : code->storeLocalReference(1);
2772 : : // stack: -
2773 : : code->instrNew(
2774 : : rtl::OString(
2775 : : RTL_CONSTASCII_STRINGPARAM(
2776 [ + - ]: 354 : "com/sun/star/uno/DeploymentException")));
2777 : : // stack: ex
2778 [ + - ]: 354 : code->instrDup();
2779 : : // stack: ex ex
2780 : 354 : rtl::OStringBuffer msg;
2781 : : msg.append(
2782 : : RTL_CONSTASCII_STRINGPARAM(
2783 [ + - ]: 354 : "component context fails to supply service "));
2784 [ + - ]: 354 : msg.append(unoName);
2785 [ + - ]: 354 : msg.append(RTL_CONSTASCII_STRINGPARAM(" of type "));
2786 [ + - ]: 354 : msg.append(realJavaBaseName);
2787 [ + - ]: 354 : msg.append(RTL_CONSTASCII_STRINGPARAM(": "));
2788 [ + - ]: 354 : code->loadStringConstant(msg.makeStringAndClear());
2789 : : // stack: ex ex "..."
2790 [ + - ]: 354 : code->loadLocalReference(1);
2791 : : // stack: ex ex "..." str
2792 : : code->instrInvokevirtual(
2793 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("java/lang/String")),
2794 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("concat")),
2795 : : rtl::OString(
2796 : : RTL_CONSTASCII_STRINGPARAM(
2797 [ + - ]: 354 : "(Ljava/lang/String;)Ljava/lang/String;")));
2798 : : // stack: ex ex "..."
2799 [ + - ]: 354 : code->loadLocalReference(0);
2800 : : // stack: ex ex "..." context
2801 : : code->instrInvokespecial(
2802 : : rtl::OString(
2803 : : RTL_CONSTASCII_STRINGPARAM(
2804 : : "com/sun/star/uno/DeploymentException")),
2805 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
2806 : : rtl::OString(
2807 : : RTL_CONSTASCII_STRINGPARAM(
2808 [ + - ]: 354 : "(Ljava/lang/String;Ljava/lang/Object;)V")));
2809 : : // stack: ex
2810 [ + - ]: 354 : ClassFile::Code::Position pos2 = code->getPosition();
2811 [ + - ]: 354 : code->instrAthrow();
2812 : : addExceptionHandlers(
2813 [ + - ]: 354 : tree.getRoot(), tryStart, tryEnd, pos2, code.get());
2814 : : code->addException(
2815 : : tryStart, tryEnd, pos1,
2816 : : rtl::OString(
2817 [ + - ]: 354 : RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Exception")));
2818 : : dependencies->insert(
2819 : : rtl::OString(
2820 [ + - ]: 354 : RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Exception")));
2821 [ + - ]: 354 : stack = std::max< sal_uInt16 >(stack, 4);
2822 : : }
2823 : 360 : code->setMaxStackAndLocals(stack, localIndex);
2824 : : classFile->addMethod(
2825 : 360 : access, methodName, desc.getDescriptor(), code.get(), exc,
2826 [ + - ][ + - ]: 720 : desc.getSignature());
[ + - ]
[ + - + - ]
2827 : 360 : }
2828 : :
2829 : 2620 : void handleService(
2830 : : TypeManager const & manager, JavaOptions /*TODO const*/ & options,
2831 : : typereg::Reader const & reader, Dependencies * dependencies)
2832 : : {
2833 : : OSL_ASSERT(dependencies != 0);
2834 : 2620 : sal_uInt16 superTypes = reader.getSuperTypeCount();
2835 : 2620 : sal_uInt16 methods = reader.getMethodCount();
2836 [ + - + - : 3302 : if (superTypes == 0
- + ][ - + ]
[ + + ]
2837 : : ? methods != 0
2838 : 341 : : (superTypes != 1 || reader.getFieldCount() != 0
2839 : 341 : || reader.getReferenceCount() != 0))
2840 : : {
2841 : : throw CannotDumpException(
2842 : 0 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("Bad type information")));
2843 : : //TODO
2844 : : }
2845 [ + + ]: 2620 : if (superTypes == 0) {
2846 : 2620 : return;
2847 : : }
2848 [ + - ][ + - ]: 341 : rtl::OString unoName(codemaker::convertString(reader.getTypeName()));
2849 : : rtl::OString className(
2850 : : translateUnoTypeToJavaFullyQualifiedName(
2851 [ + - ]: 341 : unoName, rtl::OString(RTL_CONSTASCII_STRINGPARAM("service"))));
2852 : 341 : unoName = unoName.replace('/', '.');
2853 : : SAL_WNODEPRECATED_DECLARATIONS_PUSH
2854 : : std::auto_ptr< ClassFile > cf(
2855 : : new ClassFile(
2856 : : static_cast< ClassFile::AccessFlags >(
2857 : : ClassFile::ACC_PUBLIC | ClassFile::ACC_FINAL
2858 : : | ClassFile::ACC_SUPER),
2859 : : className,
2860 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("java/lang/Object")),
2861 [ + - ][ + - ]: 341 : rtl::OString()));
2862 : : SAL_WNODEPRECATED_DECLARATIONS_POP
2863 [ + + ]: 341 : if (methods > 0) {
2864 : : rtl::OString base(codemaker::convertString(
2865 [ + - ][ + - ]: 301 : reader.getSuperTypeName(0)));
2866 : 301 : rtl::OString realJavaBaseName(base.replace('/', '.'));
2867 [ + - ]: 301 : dependencies->insert(base);
2868 : : dependencies->insert(
2869 : : rtl::OString(
2870 : : RTL_CONSTASCII_STRINGPARAM(
2871 [ + - ]: 301 : "com/sun/star/lang/XMultiComponentFactory")));
2872 : : dependencies->insert(
2873 : : rtl::OString(
2874 : : RTL_CONSTASCII_STRINGPARAM(
2875 [ + - ]: 301 : "com/sun/star/uno/DeploymentException")));
2876 : : dependencies->insert(
2877 : : rtl::OString(
2878 [ + - ]: 301 : RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/TypeClass")));
2879 : : dependencies->insert(
2880 : : rtl::OString(
2881 : : RTL_CONSTASCII_STRINGPARAM(
2882 [ + - ]: 301 : "com/sun/star/uno/XComponentContext")));
2883 [ + + ]: 661 : for (sal_uInt16 i = 0; i < methods; ++i) {
2884 : : rtl::OString name(codemaker::convertString(
2885 [ + - ][ + - ]: 360 : reader.getMethodName(i)));
2886 : 360 : bool defaultCtor = name.getLength() == 0;
2887 [ + + ][ + - : 1466 : if (reader.getMethodFlags(i) != RT_MODE_TWOWAY
+ - - + ]
[ - + ]
[ + - + - ]
2888 [ + - ][ + - ]: 720 : || (reader.getMethodReturnTypeName(i) != "void")
[ # # ]
2889 : : || (defaultCtor
2890 : 193 : && (methods != 1 || reader.getMethodParameterCount(i) != 0
2891 : 193 : || reader.getMethodExceptionCount(i) != 0)))
2892 : : {
2893 : : throw CannotDumpException(
2894 : : rtl::OString(
2895 : 0 : RTL_CONSTASCII_STRINGPARAM("Bad type information")));
2896 : : //TODO
2897 : : }
2898 [ + + ]: 360 : if (defaultCtor) {
2899 : 193 : name = rtl::OString(RTL_CONSTASCII_STRINGPARAM("create"));
2900 : : } else {
2901 : : name = codemaker::java::translateUnoToJavaIdentifier(
2902 [ + - ]: 167 : name, rtl::OString(RTL_CONSTASCII_STRINGPARAM("method")));
2903 : : }
2904 : : addConstructor(
2905 : : manager, realJavaBaseName, unoName, className, reader, i, name,
2906 [ + - ]: 360 : base, defaultCtor, dependencies, cf.get());
2907 : 360 : }
2908 : : // Synthetic getFactory method:
2909 : : {
2910 : : SAL_WNODEPRECATED_DECLARATIONS_PUSH
2911 [ + - ]: 301 : std::auto_ptr< ClassFile::Code > code(cf->newCode());
2912 : : SAL_WNODEPRECATED_DECLARATIONS_POP
2913 [ + - ]: 301 : code->loadLocalReference(0);
2914 : : // stack: context
2915 : : code->instrInvokeinterface(
2916 : : rtl::OString(
2917 : : RTL_CONSTASCII_STRINGPARAM(
2918 : : "com/sun/star/uno/XComponentContext")),
2919 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("getServiceManager")),
2920 : : rtl::OString(
2921 : : RTL_CONSTASCII_STRINGPARAM(
2922 : : "()Lcom/sun/star/lang/XMultiComponentFactory;")),
2923 [ + - ]: 301 : 1);
2924 : : // stack: factory
2925 [ + - ]: 301 : code->instrDup();
2926 : : // stack: factory factory
2927 [ + - ]: 301 : ClassFile::Code::Branch branch = code->instrIfnull();
2928 : : // stack: factory
2929 [ + - ]: 301 : code->instrAreturn();
2930 [ + - ]: 301 : code->branchHere(branch);
2931 [ + - ]: 301 : code->instrPop();
2932 : : // stack: -
2933 : : code->instrNew(
2934 : : rtl::OString(
2935 : : RTL_CONSTASCII_STRINGPARAM(
2936 [ + - ]: 301 : "com/sun/star/uno/DeploymentException")));
2937 : : // stack: ex
2938 [ + - ]: 301 : code->instrDup();
2939 : : // stack: ex ex
2940 : : code->loadStringConstant(
2941 : : rtl::OString(
2942 : : RTL_CONSTASCII_STRINGPARAM(
2943 [ + - ]: 301 : "component context fails to supply service manager")));
2944 : : // stack: ex ex "..."
2945 [ + - ]: 301 : code->loadLocalReference(0);
2946 : : // stack: ex ex "..." context
2947 : : code->instrInvokespecial(
2948 : : rtl::OString(
2949 : : RTL_CONSTASCII_STRINGPARAM(
2950 : : "com/sun/star/uno/DeploymentException")),
2951 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
2952 : : rtl::OString(
2953 : : RTL_CONSTASCII_STRINGPARAM(
2954 [ + - ]: 301 : "(Ljava/lang/String;Ljava/lang/Object;)V")));
2955 : : // stack: ex
2956 [ + - ]: 301 : code->instrAthrow();
2957 : 301 : code->setMaxStackAndLocals(4, 1);
2958 : : cf->addMethod(
2959 : : static_cast< ClassFile::AccessFlags >(
2960 : : ClassFile::ACC_PRIVATE | ClassFile::ACC_STATIC
2961 : : | ClassFile::ACC_SYNTHETIC),
2962 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("$getFactory")),
2963 : : rtl::OString(
2964 : : RTL_CONSTASCII_STRINGPARAM(
2965 : : "(Lcom/sun/star/uno/XComponentContext;)"
2966 : : "Lcom/sun/star/lang/XMultiComponentFactory;")),
2967 [ + - ][ + - ]: 301 : code.get(), std::vector< rtl::OString >(), rtl::OString());
[ + - ]
2968 : : }
2969 : : // Synthetic castInstance method:
2970 : : {
2971 : : SAL_WNODEPRECATED_DECLARATIONS_PUSH
2972 [ + - ]: 301 : std::auto_ptr< ClassFile::Code > code(cf->newCode());
2973 : : SAL_WNODEPRECATED_DECLARATIONS_POP
2974 : : code->instrNew(
2975 : : rtl::OString(
2976 [ + - ]: 301 : RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Type")));
2977 : : // stack: type
2978 [ + - ]: 301 : code->instrDup();
2979 : : // stack: type type
2980 [ + - ]: 301 : code->loadStringConstant(realJavaBaseName);
2981 : : // stack: type type "..."
2982 : : code->instrGetstatic(
2983 : : rtl::OString(
2984 : : RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/TypeClass")),
2985 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("INTERFACE")),
2986 : : rtl::OString(
2987 : : RTL_CONSTASCII_STRINGPARAM(
2988 [ + - ]: 301 : "Lcom/sun/star/uno/TypeClass;")));
2989 : : // stack: type type "..." INTERFACE
2990 : : code->instrInvokespecial(
2991 : : rtl::OString(
2992 : : RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Type")),
2993 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
2994 : : rtl::OString(
2995 : : RTL_CONSTASCII_STRINGPARAM(
2996 [ + - ]: 301 : "(Ljava/lang/String;Lcom/sun/star/uno/TypeClass;)V")));
2997 : : // stack: type
2998 [ + - ]: 301 : code->loadLocalReference(0);
2999 : : // stack: type instance
3000 : : code->instrInvokestatic(
3001 : : rtl::OString(
3002 : : RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/UnoRuntime")),
3003 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("queryInterface")),
3004 : : rtl::OString(
3005 : : RTL_CONSTASCII_STRINGPARAM(
3006 : : "(Lcom/sun/star/uno/Type;Ljava/lang/Object;)"
3007 [ + - ]: 301 : "Ljava/lang/Object;")));
3008 : : // stack: instance
3009 [ + - ]: 301 : code->instrDup();
3010 : : // stack: instance instance
3011 [ + - ]: 301 : ClassFile::Code::Branch branch = code->instrIfnull();
3012 : : // stack: instance
3013 [ + - ]: 301 : code->instrAreturn();
3014 [ + - ]: 301 : code->branchHere(branch);
3015 [ + - ]: 301 : code->instrPop();
3016 : : // stack: -
3017 : : code->instrNew(
3018 : : rtl::OString(
3019 : : RTL_CONSTASCII_STRINGPARAM(
3020 [ + - ]: 301 : "com/sun/star/uno/DeploymentException")));
3021 : : // stack: ex
3022 [ + - ]: 301 : code->instrDup();
3023 : : // stack: ex ex
3024 : 301 : rtl::OStringBuffer msg;
3025 : : msg.append(
3026 : : RTL_CONSTASCII_STRINGPARAM(
3027 [ + - ]: 301 : "component context fails to supply service "));
3028 [ + - ]: 301 : msg.append(unoName);
3029 [ + - ]: 301 : msg.append(RTL_CONSTASCII_STRINGPARAM(" of type "));
3030 [ + - ]: 301 : msg.append(realJavaBaseName);
3031 [ + - ]: 301 : code->loadStringConstant(msg.makeStringAndClear());
3032 : : // stack: ex ex "..."
3033 [ + - ]: 301 : code->loadLocalReference(1);
3034 : : // stack: ex ex "..." context
3035 : : code->instrInvokespecial(
3036 : : rtl::OString(
3037 : : RTL_CONSTASCII_STRINGPARAM(
3038 : : "com/sun/star/uno/DeploymentException")),
3039 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
3040 : : rtl::OString(
3041 : : RTL_CONSTASCII_STRINGPARAM(
3042 [ + - ]: 301 : "(Ljava/lang/String;Ljava/lang/Object;)V")));
3043 : : // stack: ex
3044 [ + - ]: 301 : code->instrAthrow();
3045 : 301 : code->setMaxStackAndLocals(4, 2);
3046 : : cf->addMethod(
3047 : : static_cast< ClassFile::AccessFlags >(
3048 : : ClassFile::ACC_PRIVATE | ClassFile::ACC_STATIC
3049 : : | ClassFile::ACC_SYNTHETIC),
3050 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("$castInstance")),
3051 : : rtl::OString(
3052 : : RTL_CONSTASCII_STRINGPARAM(
3053 : : "(Ljava/lang/Object;Lcom/sun/star/uno/"
3054 : : "XComponentContext;)Ljava/lang/Object;")),
3055 [ + - ][ + - ]: 301 : code.get(), std::vector< rtl::OString >(), rtl::OString());
[ + - ]
3056 : 301 : }
3057 : : }
3058 [ + - ][ + - ]: 2620 : writeClassFile(options, className, *cf.get());
3059 : : }
3060 : :
3061 : 28 : void handleSingleton(
3062 : : TypeManager const & manager, JavaOptions /*TODO const*/ & options,
3063 : : typereg::Reader const & reader, Dependencies * dependencies)
3064 : : {
3065 : : OSL_ASSERT(dependencies != 0);
3066 [ + - ][ + - : 84 : if (reader.getSuperTypeCount() != 1 || reader.getFieldCount() != 0
+ - - + ]
[ - + ]
3067 : 56 : || reader.getMethodCount() != 0 || reader.getReferenceCount() != 0)
3068 : : {
3069 : : throw CannotDumpException(
3070 : 0 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("Bad type information")));
3071 : : //TODO
3072 : : }
3073 [ + - ][ + - ]: 28 : rtl::OString base(codemaker::convertString(reader.getSuperTypeName(0)));
3074 : 28 : rtl::OString realJavaBaseName(base.replace('/', '.'));
3075 [ + + - ]: 28 : switch (manager.getTypeReader(base).getTypeClass()) {
[ + - ]
3076 : : case RT_TYPE_INTERFACE:
3077 : 28 : break;
3078 : :
3079 : : case RT_TYPE_SERVICE:
3080 : 28 : return;
3081 : :
3082 : : default:
3083 : : throw CannotDumpException(
3084 : 0 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("Bad type information")));
3085 : : //TODO
3086 : : }
3087 [ + - ]: 20 : dependencies->insert(base);
3088 [ + - ][ + - ]: 20 : rtl::OString unoName(codemaker::convertString(reader.getTypeName()));
3089 : : rtl::OString className(
3090 : : translateUnoTypeToJavaFullyQualifiedName(
3091 [ + - ]: 20 : unoName, rtl::OString(RTL_CONSTASCII_STRINGPARAM("singleton"))));
3092 : 20 : unoName = unoName.replace('/', '.');
3093 : : dependencies->insert(
3094 : : rtl::OString(
3095 : : RTL_CONSTASCII_STRINGPARAM(
3096 [ + - ]: 20 : "com/sun/star/uno/DeploymentException")));
3097 : : dependencies->insert(
3098 [ + - ]: 20 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/TypeClass")));
3099 : : dependencies->insert(
3100 : : rtl::OString(
3101 [ + - ]: 20 : RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/XComponentContext")));
3102 : : SAL_WNODEPRECATED_DECLARATIONS_PUSH
3103 : : std::auto_ptr< ClassFile > cf(
3104 : : new ClassFile(
3105 : : static_cast< ClassFile::AccessFlags >(
3106 : : ClassFile::ACC_PUBLIC | ClassFile::ACC_FINAL
3107 : : | ClassFile::ACC_SUPER),
3108 : : className,
3109 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("java/lang/Object")),
3110 [ + - ][ + - ]: 20 : rtl::OString()));
3111 : : SAL_WNODEPRECATED_DECLARATIONS_POP
3112 [ + - ]: 20 : MethodDescriptor desc(manager, dependencies, base, 0, 0);
3113 : : desc.addParameter(
3114 : : rtl::OString(
3115 : : RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/XComponentContext")),
3116 [ + - ]: 20 : false, false, 0);
3117 : : SAL_WNODEPRECATED_DECLARATIONS_PUSH
3118 [ + - ]: 20 : std::auto_ptr< ClassFile::Code > code(cf->newCode());
3119 : : SAL_WNODEPRECATED_DECLARATIONS_POP
3120 [ + - ]: 20 : code->loadLocalReference(0);
3121 : : // stack: context
3122 : : code->loadStringConstant(
3123 [ + - ]: 20 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("/singletons/")) + unoName);
3124 : : // stack: context "..."
3125 : : code->instrInvokeinterface(
3126 : : rtl::OString(
3127 : : RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/XComponentContext")),
3128 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("getValueByName")),
3129 : : rtl::OString(
3130 : : RTL_CONSTASCII_STRINGPARAM(
3131 : : "(Ljava/lang/String;)Ljava/lang/Object;")),
3132 [ + - ]: 20 : 2);
3133 : : // stack: value
3134 [ + - ]: 20 : code->instrDup();
3135 : : // stack: value value
3136 : : code->instrInstanceof(
3137 [ + - ]: 20 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Any")));
3138 : : // stack: value 0/1
3139 [ + - ]: 20 : ClassFile::Code::Branch branch1 = code->instrIfeq();
3140 : : // stack: value
3141 : : code->instrCheckcast(
3142 [ + - ]: 20 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Any")));
3143 : : // stack: value
3144 [ + - ]: 20 : code->instrDup();
3145 : : // stack: value value
3146 : : code->instrInvokevirtual(
3147 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Any")),
3148 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("getType")),
3149 [ + - ]: 20 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("()Lcom/sun/star/uno/Type;")));
3150 : : // stack: value type
3151 : : code->instrInvokevirtual(
3152 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Type")),
3153 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("getTypeClass")),
3154 : : rtl::OString(
3155 [ + - ]: 20 : RTL_CONSTASCII_STRINGPARAM("()Lcom/sun/star/uno/TypeClass;")));
3156 : : // stack: value typeClass
3157 : : code->instrGetstatic(
3158 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/TypeClass")),
3159 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("INTERFACE")),
3160 : : rtl::OString(
3161 [ + - ]: 20 : RTL_CONSTASCII_STRINGPARAM("Lcom/sun/star/uno/TypeClass;")));
3162 : : // stack: value typeClass INTERFACE
3163 [ + - ]: 20 : ClassFile::Code::Branch branch2 = code->instrIfAcmpne();
3164 : : // stack: value
3165 : : code->instrInvokevirtual(
3166 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Any")),
3167 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("getObject")),
3168 [ + - ]: 20 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("()Ljava/lang/Object;")));
3169 : : // stack: value
3170 [ + - ]: 20 : code->branchHere(branch1);
3171 : : code->instrNew(
3172 [ + - ]: 20 : rtl::OString(RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Type")));
3173 : : // stack: value type
3174 [ + - ]: 20 : code->instrDup();
3175 : : // stack: value type type
3176 [ + - ]: 20 : code->loadStringConstant(realJavaBaseName);
3177 : : // stack: value type type "..."
3178 : : code->instrGetstatic(
3179 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/TypeClass")),
3180 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("INTERFACE")),
3181 : : rtl::OString(
3182 [ + - ]: 20 : RTL_CONSTASCII_STRINGPARAM("Lcom/sun/star/uno/TypeClass;")));
3183 : : // stack: value type type "..." INTERFACE
3184 : : code->instrInvokespecial(
3185 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/Type")),
3186 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
3187 : : rtl::OString(
3188 : : RTL_CONSTASCII_STRINGPARAM(
3189 [ + - ]: 20 : "(Ljava/lang/String;Lcom/sun/star/uno/TypeClass;)V")));
3190 : : // stack: value type
3191 [ + - ]: 20 : code->instrSwap();
3192 : : // stack: type value
3193 : : code->instrInvokestatic(
3194 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/UnoRuntime")),
3195 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("queryInterface")),
3196 : : rtl::OString(
3197 : : RTL_CONSTASCII_STRINGPARAM(
3198 : : "(Lcom/sun/star/uno/Type;Ljava/lang/Object;)"
3199 [ + - ]: 20 : "Ljava/lang/Object;")));
3200 : : // stack: instance
3201 [ + - ]: 20 : code->instrDup();
3202 : : // stack: instance instance
3203 [ + - ]: 20 : ClassFile::Code::Branch branch3 = code->instrIfnull();
3204 : : // stack: instance
3205 [ + - ]: 20 : code->instrCheckcast(base);
3206 : : // stack: instance
3207 [ + - ]: 20 : code->instrAreturn();
3208 [ + - ]: 20 : code->branchHere(branch2);
3209 [ + - ]: 20 : code->branchHere(branch3);
3210 [ + - ]: 20 : code->instrPop();
3211 : : // stack: -
3212 : : code->instrNew(
3213 : : rtl::OString(
3214 : : RTL_CONSTASCII_STRINGPARAM(
3215 [ + - ]: 20 : "com/sun/star/uno/DeploymentException")));
3216 : : // stack: ex
3217 [ + - ]: 20 : code->instrDup();
3218 : : // stack: ex ex
3219 : 20 : rtl::OStringBuffer msg;
3220 : : msg.append(
3221 : : RTL_CONSTASCII_STRINGPARAM(
3222 [ + - ]: 20 : "component context fails to supply singleton "));
3223 [ + - ]: 20 : msg.append(unoName);
3224 [ + - ]: 20 : msg.append(RTL_CONSTASCII_STRINGPARAM(" of type "));
3225 [ + - ]: 20 : msg.append(realJavaBaseName);
3226 [ + - ]: 20 : code->loadStringConstant(msg.makeStringAndClear());
3227 : : // stack: ex ex "..."
3228 [ + - ]: 20 : code->loadLocalReference(0);
3229 : : // stack: ex ex "..." context
3230 : : code->instrInvokespecial(
3231 : : rtl::OString(
3232 : : RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/DeploymentException")),
3233 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("<init>")),
3234 : : rtl::OString(
3235 : : RTL_CONSTASCII_STRINGPARAM(
3236 [ + - ]: 20 : "(Ljava/lang/String;Ljava/lang/Object;)V")));
3237 : : // stack: ex
3238 [ + - ]: 20 : code->instrAthrow();
3239 : 20 : code->setMaxStackAndLocals(5, 1);
3240 : : cf->addMethod(
3241 : : static_cast< ClassFile::AccessFlags >(
3242 : : ClassFile::ACC_PUBLIC | ClassFile::ACC_STATIC),
3243 : : rtl::OString(RTL_CONSTASCII_STRINGPARAM("get")), desc.getDescriptor(),
3244 [ + - ][ + - ]: 20 : code.get(), std::vector< rtl::OString >(), desc.getSignature());
[ + - ][ + - ]
3245 [ + - ][ + - ]: 28 : writeClassFile(options, className, *cf.get());
[ + + ][ + + ]
[ + - ]
3246 : : }
3247 : :
3248 : : }
3249 : :
3250 : 13288 : bool produceType(
3251 : : rtl::OString const & type, TypeManager const & manager,
3252 : : codemaker::GeneratedTypeSet & generated, JavaOptions * options)
3253 : : {
3254 : : OSL_ASSERT(options != 0);
3255 [ + + + - ]: 53140 : if (type.equals("/")
[ + + ][ + - ]
[ + - ][ + +
# # # # ]
3256 [ + - ][ + + ]: 26570 : || type.equals(manager.getBase())
[ # # ]
3257 [ + - ]: 13282 : || generated.contains(type))
3258 : : {
3259 : 11216 : return true;
3260 : : }
3261 : 2072 : sal_Bool extra = sal_False;
3262 [ + - ]: 2072 : typereg::Reader reader(manager.getTypeReader(type, &extra));
3263 [ + + ]: 2072 : if (extra) {
3264 [ + - ]: 166 : generated.add(type);
3265 : 166 : return true;
3266 : : }
3267 [ - + ]: 1906 : if (!reader.isValid()) {
3268 : 0 : return false;
3269 : : }
3270 : :
3271 : : handleUnoTypeRegistryEntityFunction handler;
3272 [ + + + - : 1906 : switch (reader.getTypeClass()) {
- - - -
- ]
3273 : : case RT_TYPE_ENUM:
3274 : 152 : handler = handleEnumType;
3275 : 152 : break;
3276 : :
3277 : : case RT_TYPE_STRUCT:
3278 : : case RT_TYPE_EXCEPTION:
3279 : 638 : handler = handleAggregatingType;
3280 : 638 : break;
3281 : :
3282 : : case RT_TYPE_INTERFACE:
3283 : 1116 : handler = handleInterfaceType;
3284 : 1116 : break;
3285 : :
3286 : : case RT_TYPE_TYPEDEF:
3287 : 0 : handler = handleTypedef;
3288 : 0 : break;
3289 : :
3290 : : case RT_TYPE_CONSTANTS:
3291 : 0 : handler = handleConstantGroup;
3292 : 0 : break;
3293 : :
3294 : : case RT_TYPE_MODULE:
3295 : 0 : handler = handleModule;
3296 : 0 : break;
3297 : :
3298 : : case RT_TYPE_SERVICE:
3299 : 0 : handler = handleService;
3300 : 0 : break;
3301 : :
3302 : : case RT_TYPE_SINGLETON:
3303 : 0 : handler = handleSingleton;
3304 : 0 : break;
3305 : :
3306 : : default:
3307 : 0 : return false;
3308 : : }
3309 [ + - ]: 1906 : Dependencies deps;
3310 [ + - ]: 1906 : handler(manager, *options, reader, &deps);
3311 [ + - ]: 1906 : generated.add(type);
3312 [ + - ][ + - ]: 1906 : if (!options->isValid(rtl::OString(RTL_CONSTASCII_STRINGPARAM("-nD")))) {
3313 [ + + ]: 6121 : for (Dependencies::iterator i(deps.begin()); i != deps.end(); ++i) {
3314 [ + - ][ - + ]: 4215 : if (!produceType(*i, manager, generated, options)) {
3315 : 0 : return false;
3316 : : }
3317 : : }
3318 : : }
3319 : 13288 : return true;
3320 : : }
3321 : :
3322 : 8846 : bool produceType(
3323 : : RegistryKey & rTypeKey, bool bIsExtraType, TypeManager const & manager,
3324 : : codemaker::GeneratedTypeSet & generated, JavaOptions * options)
3325 : : {
3326 [ + - ]: 8846 : ::rtl::OString typeName = manager.getTypeName(rTypeKey);
3327 : :
3328 : : OSL_ASSERT(options != 0);
3329 [ + - + - ]: 35384 : if (typeName.equals("/")
[ + + ][ + - ]
[ + - ][ + +
# # # # ]
3330 [ + - ][ + - ]: 17692 : || typeName.equals(manager.getBase())
[ # # ]
3331 [ + - ]: 8846 : || generated.contains(typeName))
3332 : : {
3333 : 1906 : return true;
3334 : : }
3335 [ + - ]: 6940 : typereg::Reader reader(manager.getTypeReader(rTypeKey));
3336 [ - + ]: 6940 : if (bIsExtraType) {
3337 [ # # ]: 0 : generated.add(typeName);
3338 : 0 : return true;
3339 : : }
3340 [ - + ]: 6940 : if (!reader.isValid()) {
3341 : 0 : return false;
3342 : : }
3343 : : handleUnoTypeRegistryEntityFunction handler;
3344 [ + + + + : 6940 : switch (reader.getTypeClass()) {
+ + + +
- ]
3345 : : case RT_TYPE_ENUM:
3346 : 257 : handler = handleEnumType;
3347 : 257 : break;
3348 : :
3349 : : case RT_TYPE_STRUCT:
3350 : : case RT_TYPE_EXCEPTION:
3351 : 755 : handler = handleAggregatingType;
3352 : 755 : break;
3353 : :
3354 : : case RT_TYPE_INTERFACE:
3355 : 2207 : handler = handleInterfaceType;
3356 : 2207 : break;
3357 : :
3358 : : case RT_TYPE_TYPEDEF:
3359 : 63 : handler = handleTypedef;
3360 : 63 : break;
3361 : :
3362 : : case RT_TYPE_CONSTANTS:
3363 : 714 : handler = handleConstantGroup;
3364 : 714 : break;
3365 : :
3366 : : case RT_TYPE_MODULE:
3367 : 296 : handler = handleModule;
3368 : 296 : break;
3369 : :
3370 : : case RT_TYPE_SERVICE:
3371 : 2620 : handler = handleService;
3372 : 2620 : break;
3373 : :
3374 : : case RT_TYPE_SINGLETON:
3375 : 28 : handler = handleSingleton;
3376 : 28 : break;
3377 : :
3378 : : default:
3379 : 0 : return false;
3380 : : }
3381 [ + - ]: 6940 : Dependencies deps;
3382 [ + - ]: 6940 : handler(manager, *options, reader, &deps);
3383 [ + - ]: 6940 : generated.add(typeName);
3384 [ + - ][ + + ]: 6940 : if (!options->isValid(rtl::OString(RTL_CONSTASCII_STRINGPARAM("-nD")))) {
3385 [ + + ]: 15957 : for (Dependencies::iterator i(deps.begin()); i != deps.end(); ++i) {
3386 [ + - ][ - + ]: 9067 : if (!produceType(*i, manager, generated, options)) {
3387 : 0 : return false;
3388 : : }
3389 : : }
3390 : : }
3391 : 8846 : return true;
3392 : : }
3393 : :
3394 : : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
