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