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 : #include "osl/thread.hxx"
21 :
22 : #include "codemaker/commonjava.hxx"
23 : #include "codemaker/commoncpp.hxx"
24 : #include "codemaker/generatedtypeset.hxx"
25 : #include "codemaker/global.hxx"
26 : #include "unoidl/unoidl.hxx"
27 :
28 : #include "skeletoncommon.hxx"
29 :
30 : #include <cassert>
31 : #include <iostream>
32 :
33 : using namespace ::codemaker::cpp;
34 :
35 : namespace skeletonmaker {
36 :
37 0 : void printLicenseHeader(std::ostream& o, rtl::OString const & filename)
38 : {
39 0 : sal_Int32 index = -1;
40 : #ifdef SAL_UNX
41 0 : index = filename.lastIndexOf('/');
42 : #else
43 : index = filename.lastIndexOf('\\');
44 : #endif
45 0 : OString shortfilename(filename);
46 0 : if ( index != -1 )
47 0 : shortfilename = filename.copy(index+1);
48 :
49 : o << "/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */\n"
50 : "/*\n"
51 : " * This file is part of the LibreOffice project.\n"
52 : " *\n"
53 : " * This Source Code Form is subject to the terms of the Mozilla Public\n"
54 : " * License, v. 2.0. If a copy of the MPL was not distributed with this\n"
55 : " * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n"
56 0 : " */\n\n";
57 0 : }
58 :
59 0 : bool getOutputStream(ProgramOptions const & options,
60 : OString const & extension,
61 : std::ostream** ppOutputStream,
62 : OString & targetSourceFileName,
63 : OString & tmpSourceFileName)
64 : {
65 0 : bool bStandardout = false;
66 0 : if ( options.outputpath.equals("stdout") )
67 : {
68 0 : bStandardout = true;
69 0 : *ppOutputStream = &std::cout;
70 0 : return bStandardout;
71 : }
72 :
73 0 : targetSourceFileName = createFileNameFromType(
74 0 : options.outputpath, options.implname.replace('.','/'), extension);
75 :
76 0 : OString tmpDir = getTempDir(targetSourceFileName);
77 0 : FileStream file;
78 0 : file.createTempFile(tmpDir);
79 :
80 0 : if( !file.isValid() )
81 : {
82 : throw CannotDumpException(
83 0 : "cannot open " + b2u(targetSourceFileName) + " for writing");
84 : } else {
85 0 : tmpSourceFileName = file.getName();
86 : }
87 0 : file.close();
88 : *ppOutputStream = new std::ofstream(tmpSourceFileName.getStr(),
89 0 : std::ios_base::binary);
90 :
91 0 : return bStandardout;
92 : }
93 :
94 0 : bool containsAttribute(AttributeInfo& attributes, OUString const & attrname)
95 : {
96 0 : for ( AttributeInfo::const_iterator i(attributes.begin());
97 0 : i != attributes.end(); ++i ) {
98 0 : if ( (*i).name == attrname ) {
99 0 : return true;
100 : }
101 : }
102 0 : return false;
103 : }
104 :
105 : // collect attributes including inherited attributes
106 0 : void checkAttributes(rtl::Reference< TypeManager > const & manager,
107 : OUString const & name,
108 : AttributeInfo& attributes,
109 : std::set< OUString >& propinterfaces)
110 : {
111 0 : if ( name == "com.sun.star.beans.XPropertySet" ||
112 0 : name == "com.sun.star.beans.XFastPropertySet" ||
113 0 : name == "com.sun.star.beans.XPropertyAccess" )
114 : {
115 0 : propinterfaces.insert(name);
116 : }
117 0 : rtl::Reference< unoidl::Entity > ent;
118 0 : switch (manager->getSort(name, &ent)) {
119 : case codemaker::UnoType::SORT_INTERFACE_TYPE:
120 : {
121 : rtl::Reference< unoidl::InterfaceTypeEntity > ent2(
122 0 : dynamic_cast< unoidl::InterfaceTypeEntity * >(ent.get()));
123 : assert(ent2.is());
124 0 : for (std::vector< unoidl::AnnotatedReference >::const_iterator i(
125 0 : ent2->getDirectMandatoryBases().begin());
126 0 : i != ent2->getDirectMandatoryBases().end(); ++i)
127 : {
128 0 : checkAttributes(manager, i->name, attributes, propinterfaces);
129 : }
130 0 : for (std::vector< unoidl::InterfaceTypeEntity::Attribute >::
131 0 : const_iterator i(ent2->getDirectAttributes().begin());
132 0 : i != ent2->getDirectAttributes().end(); ++i)
133 : {
134 0 : if (!containsAttribute(attributes, i->name)) {
135 : attributes.push_back(
136 : unoidl::AccumulationBasedServiceEntity::Property(
137 0 : i->name,
138 0 : i->type,
139 : (unoidl::AccumulationBasedServiceEntity::Property::
140 : Attributes(
141 0 : ((i->bound
142 : ? (unoidl::AccumulationBasedServiceEntity::
143 : Property::ATTRIBUTE_BOUND)
144 : : 0)
145 0 : | (i->readOnly
146 : ? (unoidl::AccumulationBasedServiceEntity::
147 : Property::ATTRIBUTE_READ_ONLY)
148 : : 0)))),
149 0 : std::vector< OUString >()));
150 : }
151 : }
152 0 : break;
153 : }
154 : case codemaker::UnoType::SORT_ACCUMULATION_BASED_SERVICE:
155 : {
156 : rtl::Reference< unoidl::AccumulationBasedServiceEntity > ent2(
157 : dynamic_cast< unoidl::AccumulationBasedServiceEntity * >(
158 0 : ent.get()));
159 : assert(ent2.is());
160 0 : for (std::vector< unoidl::AnnotatedReference >::const_iterator i(
161 0 : ent2->getDirectMandatoryBaseServices().begin());
162 0 : i != ent2->getDirectMandatoryBaseServices().end(); ++i)
163 : {
164 0 : checkAttributes(manager, i->name, attributes, propinterfaces);
165 : }
166 0 : for (std::vector< unoidl::AnnotatedReference >::const_iterator i(
167 0 : ent2->getDirectMandatoryBaseInterfaces().begin());
168 0 : i != ent2->getDirectMandatoryBaseInterfaces().end(); ++i)
169 : {
170 0 : checkAttributes(manager, i->name, attributes, propinterfaces);
171 : }
172 0 : for (std::vector<
173 : unoidl::AccumulationBasedServiceEntity::Property >::
174 0 : const_iterator i(ent2->getDirectProperties().begin());
175 0 : i != ent2->getDirectProperties().end(); ++i)
176 : {
177 0 : if (!containsAttribute(attributes, i->name)) {
178 0 : attributes.push_back(*i);
179 : }
180 : }
181 0 : break;
182 : }
183 : default:
184 : throw CannotDumpException(
185 0 : "unexpected entity \"" + name
186 0 : + "\" in call to skeletonmaker::checkAttributes");
187 0 : }
188 0 : }
189 :
190 0 : void checkType(rtl::Reference< TypeManager > const & manager,
191 : OUString const & name,
192 : std::set< OUString >& interfaceTypes,
193 : std::set< OUString >& serviceTypes,
194 : AttributeInfo& properties)
195 : {
196 0 : rtl::Reference< unoidl::Entity > ent;
197 0 : switch (manager->getSort(name, &ent)) {
198 : case codemaker::UnoType::SORT_INTERFACE_TYPE:
199 : // com.sun.star.lang.XComponent should be also not in the list
200 : // but it will be used for checking the impl helper and will be
201 : // removed later if necessary.
202 0 : if ( name == "com.sun.star.lang.XTypeProvider" ||
203 0 : name == "com.sun.star.uno.XWeak" )
204 0 : return;
205 0 : if (interfaceTypes.find(name) == interfaceTypes.end()) {
206 0 : interfaceTypes.insert(name);
207 : }
208 0 : break;
209 : case codemaker::UnoType::SORT_SINGLE_INTERFACE_BASED_SERVICE:
210 0 : if (serviceTypes.find(name) == serviceTypes.end()) {
211 0 : serviceTypes.insert(name);
212 : rtl::Reference< unoidl::SingleInterfaceBasedServiceEntity > ent2(
213 : dynamic_cast< unoidl::SingleInterfaceBasedServiceEntity * >(
214 0 : ent.get()));
215 : assert(ent2.is());
216 0 : if (interfaceTypes.find(ent2->getBase()) == interfaceTypes.end()) {
217 0 : interfaceTypes.insert(ent2->getBase());
218 : // check if constructors are specified, if yes automatically
219 : // support of XInitialization. We will take care of the default
220 : // constructor because in this case XInitialization is not
221 : // called.
222 0 : if (ent2->getConstructors().size() > 1 ||
223 0 : (ent2->getConstructors().size() == 1 &&
224 0 : !ent2->getConstructors()[0].defaultConstructor))
225 : {
226 0 : OUString s("com.sun.star.lang.XInitialization");
227 0 : if (interfaceTypes.find(s) == interfaceTypes.end())
228 0 : interfaceTypes.insert(s);
229 : }
230 0 : }
231 : }
232 0 : break;
233 : case codemaker::UnoType::SORT_ACCUMULATION_BASED_SERVICE:
234 0 : if ( serviceTypes.find(name) == serviceTypes.end() ) {
235 0 : serviceTypes.insert(name);
236 : rtl::Reference< unoidl::AccumulationBasedServiceEntity > ent2(
237 : dynamic_cast< unoidl::AccumulationBasedServiceEntity * >(
238 0 : ent.get()));
239 : assert(ent2.is());
240 0 : for (std::vector< unoidl::AnnotatedReference >::const_iterator i(
241 0 : ent2->getDirectMandatoryBaseServices().begin());
242 0 : i != ent2->getDirectMandatoryBaseServices().end(); ++i)
243 : {
244 : checkType(
245 0 : manager, i->name, interfaceTypes, serviceTypes, properties);
246 : }
247 0 : for (std::vector< unoidl::AnnotatedReference >::const_iterator i(
248 0 : ent2->getDirectMandatoryBaseInterfaces().begin());
249 0 : i != ent2->getDirectMandatoryBaseInterfaces().end(); ++i)
250 : {
251 : checkType(
252 0 : manager, i->name, interfaceTypes, serviceTypes, properties);
253 : }
254 0 : for (std::vector<
255 : unoidl::AccumulationBasedServiceEntity::Property >::
256 0 : const_iterator i(ent2->getDirectProperties().begin());
257 0 : i != ent2->getDirectProperties().end(); ++i)
258 : {
259 0 : properties.push_back(*i);
260 0 : }
261 : }
262 0 : break;
263 : default:
264 : throw CannotDumpException(
265 0 : "unexpected entity \"" + name
266 0 : + "\" in call to skeletonmaker::checkType");
267 0 : }
268 : }
269 :
270 0 : void checkDefaultInterfaces(
271 : std::set< OUString >& interfaces,
272 : const std::set< OUString >& services,
273 : const OUString & propertyhelper)
274 : {
275 0 : if ( services.empty() ) {
276 0 : interfaces.erase("com.sun.star.lang.XServiceInfo");
277 : } else {
278 0 : if (interfaces.find("com.sun.star.lang.XServiceInfo") == interfaces.end())
279 0 : interfaces.insert("com.sun.star.lang.XServiceInfo");
280 : }
281 :
282 0 : if ( propertyhelper.equals("_") ) {
283 0 : interfaces.erase("com.sun.star.beans.XPropertySet");
284 0 : interfaces.erase("com.sun.star.beans.XFastPropertySet");
285 0 : interfaces.erase("com.sun.star.beans.XPropertyAccess");
286 : }
287 0 : }
288 :
289 0 : bool checkServiceProperties(rtl::Reference< TypeManager > const & manager,
290 : OUString const & name)
291 : {
292 0 : rtl::Reference< unoidl::Entity > ent;
293 0 : if (manager->getSort(name, &ent)
294 : == codemaker::UnoType::SORT_ACCUMULATION_BASED_SERVICE)
295 : {
296 : rtl::Reference< unoidl::AccumulationBasedServiceEntity > ent2(
297 : dynamic_cast< unoidl::AccumulationBasedServiceEntity * >(
298 0 : ent.get()));
299 : assert(ent2.is());
300 0 : if (!ent2->getDirectProperties().empty()) {
301 0 : return true;
302 : }
303 0 : for (std::vector< unoidl::AnnotatedReference >::const_iterator i(
304 0 : ent2->getDirectMandatoryBaseServices().begin());
305 0 : i != ent2->getDirectMandatoryBaseServices().end(); ++i)
306 : {
307 0 : if (checkServiceProperties(manager, i->name)) {
308 0 : return true;
309 : }
310 0 : }
311 : }
312 0 : return false;
313 : }
314 :
315 :
316 0 : OUString checkPropertyHelper(
317 : ProgramOptions const & options,
318 : rtl::Reference< TypeManager > const & manager,
319 : const std::set< OUString >& services,
320 : const std::set< OUString >& interfaces,
321 : AttributeInfo& attributes,
322 : std::set< OUString >& propinterfaces)
323 : {
324 0 : std::set< OUString >::const_iterator iter;
325 0 : std::set< OUString >::const_iterator end;
326 :
327 0 : if ( !services.empty() ) {
328 0 : iter = services.begin();
329 0 : end = services.end();
330 : } else {
331 0 : iter = interfaces.begin();
332 0 : end = interfaces.end();
333 : }
334 :
335 0 : bool oldStyleWithProperties = false;
336 0 : while ( iter != end ) {
337 0 : rtl::Reference< unoidl::Entity > ent;
338 0 : codemaker::UnoType::Sort sort = manager->getSort(*iter, &ent);
339 0 : if ( !services.empty() ) {
340 0 : if (options.supportpropertysetmixin
341 0 : && (sort
342 : == codemaker::UnoType::SORT_SINGLE_INTERFACE_BASED_SERVICE))
343 : {
344 : rtl::Reference< unoidl::SingleInterfaceBasedServiceEntity >
345 : ent2(
346 : dynamic_cast<
347 : unoidl::SingleInterfaceBasedServiceEntity * >(
348 0 : ent.get()));
349 : assert(ent2.is());
350 : checkAttributes(
351 0 : manager, ent2->getBase(), attributes, propinterfaces);
352 0 : if (!(attributes.empty() || propinterfaces.empty())) {
353 0 : return ent2->getBase();
354 0 : }
355 : } else {
356 0 : oldStyleWithProperties = checkServiceProperties(manager, *iter);
357 : }
358 : } else {
359 0 : checkAttributes(manager, *iter, attributes, propinterfaces);
360 0 : if (!(attributes.empty() || propinterfaces.empty())) {
361 0 : return *iter;
362 : }
363 : }
364 0 : ++iter;
365 0 : }
366 :
367 0 : return oldStyleWithProperties ? OUString("_") : OUString();
368 : }
369 :
370 0 : bool checkXComponentSupport(
371 : rtl::Reference< TypeManager > const & manager, OUString const & name)
372 : {
373 : assert(manager.is());
374 0 : if (name == "com.sun.star.lang.XComponent") {
375 0 : return true;
376 : }
377 0 : rtl::Reference< unoidl::Entity > ent;
378 0 : codemaker::UnoType::Sort sort = manager->getSort(name, &ent);
379 0 : if (sort != codemaker::UnoType::SORT_INTERFACE_TYPE) {
380 : throw CannotDumpException(
381 0 : "unexpected entity \"" + name
382 0 : + "\" in call to skeletonmaker::checkXComponentSupport");
383 : }
384 : rtl::Reference< unoidl::InterfaceTypeEntity > ent2(
385 0 : dynamic_cast< unoidl::InterfaceTypeEntity * >(ent.get()));
386 : assert(ent2.is());
387 0 : for (std::vector< unoidl::AnnotatedReference >::const_iterator i(
388 0 : ent2->getDirectMandatoryBases().begin());
389 0 : i != ent2->getDirectMandatoryBases().end(); ++i)
390 : {
391 0 : if (checkXComponentSupport(manager, i->name)) {
392 0 : return true;
393 : }
394 : }
395 0 : return false;
396 : }
397 :
398 :
399 : // if XComponent is directly specified, return true and remove it from the
400 : // supported interfaces list
401 0 : bool checkXComponentSupport(rtl::Reference< TypeManager > const & manager,
402 : std::set< OUString >& interfaces)
403 : {
404 0 : if ( interfaces.empty() )
405 0 : return false;
406 :
407 0 : std::set< OUString >::const_iterator iter = interfaces.begin();
408 0 : while ( iter != interfaces.end() ) {
409 0 : if ( (*iter).equals("com.sun.star.lang.XComponent") ) {
410 0 : interfaces.erase("com.sun.star.lang.XComponent");
411 0 : return true;
412 : }
413 0 : if ( checkXComponentSupport(manager, *iter) )
414 0 : return true;
415 0 : ++iter;
416 : }
417 :
418 0 : return false;
419 : }
420 :
421 : unoidl::AccumulationBasedServiceEntity::Property::Attributes
422 0 : checkAdditionalPropertyFlags(
423 : unoidl::InterfaceTypeEntity::Attribute const & attribute)
424 : {
425 0 : int flags = 0;
426 0 : bool getterSupportsUnknown = false;
427 0 : for (std::vector< OUString >::const_iterator i(
428 0 : attribute.getExceptions.begin());
429 0 : i != attribute.getExceptions.end(); ++i)
430 : {
431 0 : if (*i == "com.sun.star.beans.UnknownPropertyException") {
432 0 : getterSupportsUnknown = true;
433 : }
434 : }
435 0 : for (std::vector< OUString >::const_iterator i(
436 0 : attribute.setExceptions.begin());
437 0 : i != attribute.setExceptions.end(); ++i)
438 : {
439 0 : if (*i == "com.sun.star.beans.PropertyVetoException") {
440 : flags |= unoidl::AccumulationBasedServiceEntity::Property::
441 0 : ATTRIBUTE_CONSTRAINED;
442 0 : } else if (getterSupportsUnknown
443 0 : && *i == "com.sun.star.beans.UnknownPropertyException")
444 : {
445 : flags |= unoidl::AccumulationBasedServiceEntity::Property::
446 0 : ATTRIBUTE_OPTIONAL;
447 : }
448 : }
449 0 : return unoidl::AccumulationBasedServiceEntity::Property::Attributes(flags);
450 : }
451 :
452 : // This function checks if the specified types for parameters and return
453 : // types are allowed add-in types, for more info see the com.sun.star.sheet.AddIn
454 : // service description
455 0 : bool checkAddinType(rtl::Reference< TypeManager > const & manager,
456 : OUString const & type, bool & bLastAny,
457 : bool & bHasXPropertySet, bool bIsReturn)
458 : {
459 : assert(manager.is());
460 : sal_Int32 rank;
461 : codemaker::UnoType::Sort sort = manager->decompose(
462 0 : type, true, 0, &rank, 0, 0);
463 :
464 0 : if ( sort == codemaker::UnoType::SORT_LONG ||
465 0 : sort == codemaker::UnoType::SORT_DOUBLE ||
466 : sort == codemaker::UnoType::SORT_STRING )
467 : {
468 0 : if ( rank == 0 || rank ==2 )
469 0 : return true;
470 : }
471 0 : if ( sort == codemaker::UnoType::SORT_ANY )
472 : {
473 0 : if ( rank <= 2 ) {
474 0 : if ( rank ==1 ) {
475 0 : if ( bIsReturn )
476 0 : return false;
477 0 : bLastAny = true;
478 : }
479 :
480 0 : return true;
481 : }
482 : }
483 0 : if ( sort == codemaker::UnoType::SORT_INTERFACE_TYPE )
484 : {
485 0 : if ( bIsReturn && type == "com.sun.star.sheet.XVolatileResult" )
486 0 : return true;
487 0 : if ( !bIsReturn && type == "com.sun.star.table.XCellRange" )
488 0 : return true;
489 0 : if ( !bIsReturn && type == "com.sun.star.beans.XPropertySet" )
490 : {
491 0 : if ( bHasXPropertySet ) {
492 0 : return false;
493 : } else {
494 0 : bHasXPropertySet = true;
495 0 : return true;
496 : }
497 : }
498 : }
499 0 : return false;
500 : }
501 :
502 0 : void checkAddInTypes(
503 : rtl::Reference< TypeManager > const & manager, OUString const & name,
504 : rtl::Reference< unoidl::InterfaceTypeEntity > const & entity)
505 : {
506 : assert(entity.is());
507 0 : bool bLastAny = false;
508 0 : bool bHasXPropertySet = false;
509 0 : for (std::vector< unoidl::InterfaceTypeEntity::Method >::const_iterator i(
510 0 : entity->getDirectMethods().begin());
511 0 : i != entity->getDirectMethods().end(); ++i)
512 : {
513 0 : if ( !checkAddinType(
514 0 : manager, i->returnType, bLastAny, bHasXPropertySet, true) )
515 : {
516 : throw CannotDumpException(
517 0 : "the return type of the calc add-in function '" + name
518 0 : + ":" + i->name
519 0 : + "' is invalid. Please check your IDL defintion.");
520 : }
521 :
522 0 : bHasXPropertySet = false;
523 0 : for (std::vector< unoidl::InterfaceTypeEntity::Method::Parameter >::
524 0 : const_iterator j(i->parameters.begin());
525 0 : j != i->parameters.end(); ++j)
526 : {
527 0 : bLastAny = false;
528 0 : if ( !checkAddinType(manager, j->type,
529 0 : bLastAny, bHasXPropertySet, false) ||
530 : bLastAny )
531 : {
532 : throw CannotDumpException(
533 0 : "the type of the " + j->name
534 0 : + " parameter of the calc add-in function '" + name
535 0 : + ":" + i->name + "' is invalid."
536 0 : + (bLastAny
537 : ? OUString(
538 : " The type 'sequence<any>' is allowed as last"
539 : " parameter only.")
540 0 : : OUString())
541 0 : + (bHasXPropertySet
542 : ? OUString(
543 : " The type 'XPropertySet' is allowed only once.")
544 0 : : OUString())
545 0 : + " Please check your IDL definition.");
546 : }
547 : }
548 : }
549 0 : }
550 :
551 0 : void generateFunctionParameterMap(std::ostream& o,
552 : ProgramOptions const & options,
553 : rtl::Reference< TypeManager > const & manager,
554 : OUString const & name,
555 : ::codemaker::GeneratedTypeSet & generated,
556 : bool bFirst)
557 : {
558 0 : if ( name == "com.sun.star.uno.XInterface" ||
559 0 : name == "com.sun.star.lang.XLocalizable" ||
560 0 : name == "com.sun.star.lang.XServiceInfo" ||
561 : // the next three checks becomes obsolete when configuration is used
562 0 : name == "com.sun.star.sheet.XAddIn" ||
563 0 : name == "com.sun.star.sheet.XCompatibilityNames" ||
564 0 : name == "com.sun.star.lang.XServiceName" )
565 : {
566 0 : return;
567 : }
568 :
569 0 : rtl::Reference< unoidl::Entity > ent;
570 0 : codemaker::UnoType::Sort sort = manager->getSort(name, &ent);
571 0 : if (sort != codemaker::UnoType::SORT_INTERFACE_TYPE) {
572 : throw CannotDumpException(
573 0 : "unexpected entity \"" + name
574 0 : + "\" in call to skeletonmaker::generateFunctionParameterMap");
575 : }
576 : rtl::Reference< unoidl::InterfaceTypeEntity > ent2(
577 0 : dynamic_cast< unoidl::InterfaceTypeEntity * >(ent.get()));
578 : assert(ent2.is());
579 :
580 : // check if the specified add-in functions supports valid types
581 0 : checkAddInTypes(manager, name, ent2);
582 :
583 0 : for (std::vector< unoidl::AnnotatedReference >::const_iterator i(
584 0 : ent2->getDirectMandatoryBases().begin());
585 0 : i != ent2->getDirectMandatoryBases().end(); ++i)
586 : {
587 : generateFunctionParameterMap(
588 0 : o, options, manager, i->name, generated, bFirst);
589 : }
590 :
591 0 : if ( generated.contains(u2b(name)) )
592 0 : return;
593 : else
594 0 : generated.add(u2b(name));
595 :
596 0 : for (std::vector< unoidl::InterfaceTypeEntity::Method >::const_iterator i(
597 0 : ent2->getDirectMethods().begin());
598 0 : i != ent2->getDirectMethods().end(); ++i)
599 : {
600 0 : if ( bFirst ) {
601 0 : if (options.language == 2) {
602 0 : o << " ParamMap fpm;\n";
603 : }
604 : else {
605 : o << " java.util.Hashtable< Integer, String > fpm = "
606 0 : "new java.util.Hashtable< Integer, String >();\n";
607 : }
608 0 : bFirst = false;
609 : } else
610 0 : if ( options.language == 2 ) {
611 0 : o << " fpm = ParamMap();\n";
612 : }
613 : else {
614 : o << " fpm = new java.util.Hashtable< "
615 0 : "Integer, String >();\n";
616 : }
617 :
618 : std::vector< unoidl::InterfaceTypeEntity::Method::Parameter >::size_type
619 0 : n = 0;
620 0 : for (std::vector< unoidl::InterfaceTypeEntity::Method::Parameter >::
621 0 : const_iterator j(i->parameters.begin());
622 0 : j != i->parameters.end(); ++j)
623 : {
624 0 : if ( options.language == 2 ) {
625 0 : o << " fpm[" << n
626 0 : << "] = ::rtl::OUString(\""
627 0 : << j->name
628 0 : << "\");\n";
629 : }
630 : else {
631 0 : o << " fpm.put(" << n << ", \""
632 0 : << j->name
633 0 : << "\");\n";
634 : }
635 0 : ++n;
636 : }
637 :
638 0 : if ( options.language == 2 ) {
639 0 : o << " m_functionMap[::rtl::OUString(\""
640 0 : << i->name << "\")] = fpm;\n\n";
641 : }
642 : else {
643 0 : o << " m_functionMap.put(\"" << i->name << "\", fpm);\n\n";
644 : }
645 0 : }
646 : }
647 :
648 0 : void generateFunctionParameterMap(std::ostream& o,
649 : ProgramOptions const & options,
650 : rtl::Reference< TypeManager > const & manager,
651 : const std::set< OUString >& interfaces)
652 : {
653 0 : ::codemaker::GeneratedTypeSet generated;
654 0 : bool bFirst = true;
655 0 : std::set< OUString >::const_iterator iter = interfaces.begin();
656 0 : while ( iter != interfaces.end() ) {
657 0 : generateFunctionParameterMap(o, options, manager, *iter, generated, bFirst);
658 0 : ++iter;
659 0 : }
660 0 : }
661 :
662 0 : }
663 :
664 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
