1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_codemaker.hxx"
26 
27 #include <algorithm>
28 #include <map>
29 #include <set>
30 #include <stdio.h>
31 #include <string.h>
32 #include <vector>
33 
34 #include "registry/reader.hxx"
35 #include "rtl/alloc.h"
36 #include "rtl/ustring.hxx"
37 #include "rtl/strbuf.hxx"
38 
39 #include "codemaker/dependencies.hxx"
40 #include "codemaker/exceptiontree.hxx"
41 #include "codemaker/generatedtypeset.hxx"
42 #include "codemaker/unotype.hxx"
43 
44 #include "cpputype.hxx"
45 #include "cppuoptions.hxx"
46 #include "dumputils.hxx"
47 #include "includes.hxx"
48 
49 using namespace rtl;
50 using namespace codemaker::cpp;
51 
52 namespace {
53 
translateSimpleUnoType(rtl::OString const & unoType,bool cppuUnoType=false)54 rtl::OString translateSimpleUnoType(rtl::OString const & unoType, bool cppuUnoType=false) {
55     static rtl::OString const trans[codemaker::UnoType::SORT_COMPLEX + 1] = {
56         "void", "::sal_Bool", "::sal_Int8", "::sal_Int16", "::sal_uInt16",
57         "::sal_Int32", "::sal_uInt32", "::sal_Int64", "::sal_uInt64", "float",
58         "double", "::sal_Unicode", "::rtl::OUString",
59         "::com::sun::star::uno::Type", "::com::sun::star::uno::Any",
60         rtl::OString() };
61 
62     const codemaker::UnoType::Sort sort = codemaker::UnoType::getSort(unoType);
63     if (cppuUnoType &&
64         (sort == codemaker::UnoType::SORT_UNSIGNED_SHORT ||
65          sort == codemaker::UnoType::SORT_CHAR) )
66     {
67         if (sort == codemaker::UnoType::SORT_CHAR)
68             return "::cppu::UnoCharType";
69         else
70             return "::cppu::UnoUnsignedShortType";
71     }
72 
73     return trans[sort];
74 }
75 
76 }
77 
78 //*************************************************************************
79 // CppuType
80 //*************************************************************************
CppuType(typereg::Reader & typeReader,const OString & typeName,const TypeManager & typeMgr)81 CppuType::CppuType(typereg::Reader& typeReader,
82 				   const OString& typeName,
83 				   const TypeManager& typeMgr)
84 	: m_inheritedMemberCount(0)
85 	, m_cppuTypeLeak(sal_False)
86 	, m_cppuTypeDynamic(sal_True)
87 	, m_indentLength(0)
88 	, m_typeName(typeName)
89     , m_name(typeName.copy(typeName.lastIndexOf('/') + 1))
90 	, m_reader(typeReader)
91 	, m_typeMgr(typeMgr)
92 	, m_dependencies(typeMgr, typeName)
93 {}
94 
~CppuType()95 CppuType::~CppuType()
96 {
97 
98 }
99 
addGetCppuTypeIncludes(codemaker::cppumaker::Includes & includes) const100 void CppuType::addGetCppuTypeIncludes(codemaker::cppumaker::Includes & includes)
101     const
102 {
103     if (m_typeName.equals("com/sun/star/uno/XInterface")
104         || m_typeName.equals("com/sun/star/uno/Exception"))
105     {
106         includes.addType();
107         includes.addCppuUnotypeHxx();
108         includes.addSalTypesH();
109         includes.addTypelibTypeclassH();
110         includes.addTypelibTypedescriptionH();
111     } else if (m_cppuTypeLeak) {
112         addLightGetCppuTypeIncludes(includes);
113     } else if (m_cppuTypeDynamic) {
114         addNormalGetCppuTypeIncludes(includes);
115     } else {
116         addComprehensiveGetCppuTypeIncludes(includes);
117     }
118 }
119 
dumpFiles(CppuOptions * options,rtl::OString const & outPath)120 bool CppuType::dumpFiles(CppuOptions * options, rtl::OString const & outPath) {
121     return dumpFile(options, ".hdl", m_typeName, outPath)
122         && dumpFile(options, ".hpp", m_typeName, outPath);
123 }
124 
addLightGetCppuTypeIncludes(codemaker::cppumaker::Includes & includes) const125 void CppuType::addLightGetCppuTypeIncludes(
126     codemaker::cppumaker::Includes & includes) const
127 {
128     //TODO: Determine what is really needed, instead of relying on
129     // addDefaultHxxIncludes
130     includes.addCppuUnotypeHxx();
131 }
132 
addNormalGetCppuTypeIncludes(codemaker::cppumaker::Includes & includes) const133 void CppuType::addNormalGetCppuTypeIncludes(
134     codemaker::cppumaker::Includes & includes) const
135 {
136     //TODO: Determine what is really needed, instead of relying on
137     // addDefaultHxxIncludes
138     includes.addCppuUnotypeHxx();
139 }
140 
addComprehensiveGetCppuTypeIncludes(codemaker::cppumaker::Includes & includes) const141 void CppuType::addComprehensiveGetCppuTypeIncludes(
142     codemaker::cppumaker::Includes & includes) const
143 {
144     //TODO: Determine what is really needed, instead of relying on
145     // addDefaultHxxIncludes
146     includes.addCppuUnotypeHxx();
147 }
148 
isPolymorphic() const149 bool CppuType::isPolymorphic() const { return false; }
150 
dumpTemplateHead(FileStream &) const151 void CppuType::dumpTemplateHead(FileStream &) const {}
152 
dumpTemplateParameters(FileStream &) const153 void CppuType::dumpTemplateParameters(FileStream &) const {}
154 
dumpGetCppuTypePreamble(FileStream & out)155 void CppuType::dumpGetCppuTypePreamble(FileStream & out) {
156     if (isPolymorphic()) {
157         out << "namespace cppu {\n\n";
158         dumpTemplateHead(out);
159         out << "class UnoType< ";
160         dumpType(out, m_typeName);
161         dumpTemplateParameters(out);
162         out << " > {\npublic:\n";
163         inc();
164         out << indent()
165             << "static inline ::com::sun::star::uno::Type const & get() {\n";
166     } else {
167         if (codemaker::cppumaker::dumpNamespaceOpen(out, m_typeName, false)) {
168             out << "\n\n";
169         }
170         out << ("inline ::com::sun::star::uno::Type const &"
171                 " cppu_detail_getUnoType(");
172         dumpType(out, m_typeName, false, false, true);
173         out << " const *) {\n";
174     }
175     inc();
176 }
177 
dumpGetCppuTypePostamble(FileStream & out)178 void CppuType::dumpGetCppuTypePostamble(FileStream & out) {
179     dec();
180     if (isPolymorphic()) {
181         out << indent() << "}\n\nprivate:\n"
182             << indent() << "UnoType(UnoType &); // not defined\n"
183             << indent() << "~UnoType(); // not defined\n"
184             << indent()
185             << "void operator =(UnoType); // not defined\n};\n\n}\n\n";
186     } else {
187         out << "}\n\n";
188         if (codemaker::cppumaker::dumpNamespaceClose(out, m_typeName, false)) {
189             out << "\n\n";
190         }
191     }
192     dumpTemplateHead(out);
193     out << "inline ::com::sun::star::uno::Type const & SAL_CALL getCppuType(";
194     dumpType(out, m_typeName);
195     dumpTemplateParameters(out);
196     out << " const *) SAL_THROW(()) {\n";
197     inc();
198     out << indent() << "return ::cppu::UnoType< ";
199     dumpType(out, m_typeName);
200     dumpTemplateParameters(out);
201     out << " >::get();\n";
202     dec();
203     out << indent() << "}\n";
204 }
205 
dump(CppuOptions * pOptions)206 sal_Bool CppuType::dump(CppuOptions* pOptions)
207 	throw( CannotDumpException )
208 {
209     if (!m_dependencies.isValid()) {
210         return false;
211     }
212     addSpecialDependencies();
213 
214     // -CS was used as an undocumented option to generate static getCppuType
215     // functions; since the introduction of cppu::UnoType this no longer is
216     // meaningful (getCppuType is just a forward to cppu::UnoType::get now), and
217     // -CS is handled the same way as -C now:
218 	if (pOptions->isValid("-L"))
219 		m_cppuTypeLeak = sal_True;
220 	if (pOptions->isValid("-C") || pOptions->isValid("-CS"))
221 		m_cppuTypeDynamic = sal_False;
222 
223 	OString outPath;
224 	if (pOptions->isValid("-O"))
225 		outPath = pOptions->getOption("-O");
226 
227     return dumpFiles(pOptions, outPath);
228 }
229 
dumpFile(CppuOptions * pOptions,const OString & sExtension,const OString & sName,const OString & sOutPath)230 sal_Bool CppuType::dumpFile(CppuOptions* pOptions,
231                             const OString& sExtension,
232                             const OString& sName,
233                             const OString& sOutPath )
234 	throw( CannotDumpException )
235 {
236 	sal_Bool ret = sal_False;
237 
238     OString sTmpExt(".tml");
239     sal_Bool bHdl = sal_True;    ;
240     if (sExtension.equals(".hpp")) {
241         sTmpExt = ".tmp";
242         bHdl = sal_False;
243     }
244 
245     OString sFileName = createFileNameFromType(sOutPath, sName, sExtension);
246     if ( sFileName.isEmpty() )
247         return sal_False;
248 
249 	sal_Bool bFileExists = fileExists( sFileName );
250 	sal_Bool bFileCheck = sal_False;
251 
252 	if ( bFileExists && pOptions->isValid("-G") )
253 		return sal_True;
254 
255 	if ( bFileExists && pOptions->isValid("-Gc") )
256 		bFileCheck = sal_True;
257 
258     OString sTmpDir = getTempDir(sFileName);
259     FileStream oFile;
260     oFile.createTempFile(sTmpDir);
261     OString sTmpFileName;
262 
263     if(!oFile.isValid())
264 	{
265         OString message("cannot open ");
266         message += sFileName + " for writing";
267         throw CannotDumpException(message);
268     } else
269         sTmpFileName = oFile.getName();
270 
271     codemaker::cppumaker::Includes includes(m_typeMgr, m_dependencies, !bHdl);
272     if (bHdl)
273 		ret = dumpHFile(oFile, includes);
274     else {
275         addGetCppuTypeIncludes(includes);
276 		ret = dumpHxxFile(oFile, includes);
277     }
278 
279     oFile.close();
280 
281     if (ret) {
282         ret = makeValidTypeFile(sFileName, sTmpFileName, bFileCheck);
283     } else {
284         // remove existing type file if something goes wrong to ensure consistency
285         if (fileExists(sFileName))
286             removeTypeFile(sFileName);
287 
288         // remove tmp file if something goes wrong
289         removeTypeFile(sTmpFileName);
290     }
291 
292 	return ret;
293 }
294 
dumpDependedTypes(codemaker::GeneratedTypeSet & generated,CppuOptions * options)295 void CppuType::dumpDependedTypes(
296     codemaker::GeneratedTypeSet & generated, CppuOptions * options)
297 {
298     codemaker::Dependencies::Map const & map(m_dependencies.getMap());
299     for (codemaker::Dependencies::Map::const_iterator i(map.begin());
300          i != map.end(); ++i)
301     {
302         if (!produceType(i->first, m_typeMgr, generated, options)) {
303             fprintf(
304                 stderr, "%s ERROR: cannot dump Type '%s'\n",
305                 options->getProgramName().getStr(), i->first.getStr());
306             exit(99);
307         }
308     }
309 }
310 
dumpHeaderDefine(FileStream & o,char const * prefix,sal_Bool bExtended)311 OString CppuType::dumpHeaderDefine(
312     FileStream& o, char const * prefix, sal_Bool bExtended)
313 {
314 	if (m_typeName.equals("/"))
315 	{
316 		bExtended = sal_False;
317 		m_typeName = "global";
318 	}
319 
320 	sal_uInt32 length = 3 + m_typeName.getLength() + strlen(prefix);
321 
322 	if (bExtended)
323 		length += m_name.getLength() + 1;
324 
325 	OStringBuffer tmpBuf(length);
326 
327 	tmpBuf.append("INCLUDED_");
328 	tmpBuf.append(m_typeName);
329 	tmpBuf.append('_');
330 	if (bExtended)
331 	{
332 		tmpBuf.append(m_name);
333 		tmpBuf.append('_');
334 	}
335 	tmpBuf.append(prefix);
336 
337 	OString tmp(tmpBuf.makeStringAndClear().replace('/', '_').toAsciiUpperCase());
338 
339 	o << "#ifndef " << tmp << "\n#define " << tmp << "\n";
340 
341 	return tmp;
342 }
343 
addDefaultHIncludes(codemaker::cppumaker::Includes & includes) const344 void CppuType::addDefaultHIncludes(codemaker::cppumaker::Includes & includes)
345     const
346 {
347     //TODO: Only include what is really needed
348     includes.addCppuMacrosHxx();
349     if (m_typeMgr.getTypeClass(m_typeName) == RT_TYPE_INTERFACE) {
350         includes.addReference();
351     }
352 }
353 
addDefaultHxxIncludes(codemaker::cppumaker::Includes & includes) const354 void CppuType::addDefaultHxxIncludes(codemaker::cppumaker::Includes & includes)
355     const
356 {
357     //TODO: Only include what is really needed
358     includes.addOslMutexHxx();
359     includes.addType();
360     if (m_typeMgr.getTypeClass(m_typeName) == RT_TYPE_INTERFACE) {
361         includes.addReference();
362     }
363 }
364 
dumpInitializer(FileStream & out,bool parameterized,rtl::OUString const & type) const365 void CppuType::dumpInitializer(
366     FileStream & out, bool parameterized, rtl::OUString const & type) const
367 {
368     out << "(";
369     if (!parameterized) {
370         for (rtl::OString t(
371                  rtl::OUStringToOString(type, RTL_TEXTENCODING_UTF8));;)
372         {
373             sal_Int32 rank;
374             std::vector< rtl::OString > args;
375             t = codemaker::UnoType::decompose(t, &rank, &args);
376             if (rank == 0) {
377                 switch (codemaker::UnoType::getSort(t)) {
378                 case codemaker::UnoType::SORT_BOOLEAN:
379                     out << "false";
380                     break;
381 
382                 case codemaker::UnoType::SORT_BYTE:
383                 case codemaker::UnoType::SORT_SHORT:
384                 case codemaker::UnoType::SORT_UNSIGNED_SHORT:
385                 case codemaker::UnoType::SORT_LONG:
386                 case codemaker::UnoType::SORT_UNSIGNED_LONG:
387                 case codemaker::UnoType::SORT_HYPER:
388                 case codemaker::UnoType::SORT_UNSIGNED_HYPER:
389                 case codemaker::UnoType::SORT_FLOAT:
390                 case codemaker::UnoType::SORT_DOUBLE:
391                 case codemaker::UnoType::SORT_CHAR:
392                     out << "0";
393                     break;
394 
395                 case codemaker::UnoType::SORT_COMPLEX:
396                     switch (m_typeMgr.getTypeClass(t)) {
397                     case RT_TYPE_ENUM:
398                         {
399                             typereg::Reader reader(m_typeMgr.getTypeReader(t));
400                             OSL_ASSERT(reader.isValid());
401                             out << scopedCppName(t) << "_"
402                                 << rtl::OUStringToOString(
403                                     reader.getFieldName(0),
404                                     RTL_TEXTENCODING_UTF8);
405                             break;
406                         }
407 
408                     case RT_TYPE_TYPEDEF:
409                         t = resolveTypedefs(t);
410                         continue;
411 
412                     default:
413                         break;
414                     }
415                     break;
416 
417                 default:
418                     break;
419                 }
420             }
421             break;
422         }
423     }
424     out << ")";
425 }
426 
dumpGetCppuType(FileStream & out)427 void CppuType::dumpGetCppuType(FileStream & out) {
428     if (m_typeName.equals("com/sun/star/uno/XInterface")) {
429         out << indent()
430             << ("inline ::com::sun::star::uno::Type const & SAL_CALL"
431                 " getCppuType(");
432         dumpType(out, m_typeName, true, false);
433         out << " *) SAL_THROW(()) {\n";
434         inc();
435         out << indent()
436             << ("return ::cppu::UnoType< ::com::sun::star::uno::XInterface"
437                 " >::get();\n");
438         dec();
439         out << indent() << "}\n";
440     } else if (m_typeName.equals("com/sun/star/uno/Exception")) {
441         out << indent()
442             << ("inline ::com::sun::star::uno::Type const & SAL_CALL"
443                 " getCppuType(");
444         dumpType(out, m_typeName, true, false);
445         out << " *) SAL_THROW(()) {\n";
446         inc();
447         out << indent()
448             << ("return ::cppu::UnoType< ::com::sun::star::uno::Exception"
449                 " >::get();\n");
450         dec();
451         out << indent() << "}\n";
452     } else if (m_cppuTypeLeak) {
453         dumpLightGetCppuType(out);
454     } else if (m_cppuTypeDynamic) {
455         dumpNormalGetCppuType(out);
456     } else {
457         dumpComprehensiveGetCppuType(out);
458     }
459 }
460 
dumpLightGetCppuType(FileStream & o)461 void CppuType::dumpLightGetCppuType(FileStream& o)
462 {
463     dumpGetCppuTypePreamble(o);
464     o << indent()
465       << "static typelib_TypeDescriptionReference * the_type = 0;\n";
466 
467 	o << indent() << "if ( !the_type )\n" << indent() << "{\n";
468 	inc();
469 	o << indent() << "typelib_static_type_init( &the_type, "
470 	  << getTypeClass(m_typeName, sal_True) << ", \"" << m_typeName.replace('/', '.') << "\" );\n";
471 	dec();
472 	o << indent() << "}\n";
473 	o << indent()
474       << ("return * reinterpret_cast< ::com::sun::star::uno::Type * >("
475           " &the_type );\n");
476     dumpGetCppuTypePostamble(o);
477 }
478 
dumpNormalGetCppuType(FileStream & o)479 void CppuType::dumpNormalGetCppuType(FileStream& o)
480 {
481     dumpGetCppuTypePreamble(o);
482 
483     o << indent()
484       << "static typelib_TypeDescriptionReference * the_type = 0;\n";
485 
486     o << indent() << "if ( !the_type )\n" << indent() << "{\n";
487     inc();
488 
489     OString superType;
490     if (m_reader.getSuperTypeCount() >= 1) {
491         superType = rtl::OUStringToOString(
492             m_reader.getSuperTypeName(0), RTL_TEXTENCODING_UTF8);
493     }
494     sal_Bool bIsBaseException = sal_False;
495     if ( !superType.isEmpty() )
496     {
497         if ( superType.equals("com/sun/star/uno/Exception") )
498         {
499             bIsBaseException = sal_True;
500         } else
501         {
502             o << indent() << "const ::com::sun::star::uno::Type& rBaseType = ::cppu::UnoType< ";
503             dumpType(o, superType, true, false, false, true);
504             o << " >::get();\n\n";
505         }
506     }
507 
508     sal_uInt32 count = getMemberCount();
509     if (count)
510     {
511         o << indent() << "typelib_TypeDescriptionReference * aMemberRefs[" << count << "];\n";
512 
513         sal_uInt16      fieldCount = m_reader.getFieldCount();
514         RTFieldAccess   access = RT_ACCESS_INVALID;
515         OString         fieldType, fieldName;
516         OString         scope = m_typeName.replace('/', '.');
517         OString         modFieldType;
518         StringSet       generatedTypeSet;
519         StringSet::iterator	findIter;
520 
521         for (sal_uInt16 i=0; i < fieldCount; i++)
522         {
523             access = m_reader.getFieldFlags(i);
524 
525             if (access == RT_ACCESS_CONST || access == RT_ACCESS_INVALID)
526                 continue;
527 
528             fieldName = rtl::OUStringToOString(
529                 m_reader.getFieldName(i), RTL_TEXTENCODING_UTF8);
530             fieldType = checkRealBaseType(
531                 rtl::OUStringToOString(
532                     m_reader.getFieldTypeName(i), RTL_TEXTENCODING_UTF8),
533                 sal_True);
534 
535             modFieldType = typeToIdentifier(fieldType);
536 
537             findIter = generatedTypeSet.find(fieldType);
538             if ( findIter == generatedTypeSet.end() )
539             {
540                 generatedTypeSet.insert(fieldType);
541                  o << indent() << "const ::com::sun::star::uno::Type& rMemberType_"
542                   << modFieldType/*i*/ << " = ::cppu::UnoType< ";
543                 dumpType(o, fieldType, false, false, false, true);
544                 o << " >::get();\n";
545             }
546 
547             o << indent() << "aMemberRefs[" << i << "] = rMemberType_"
548               << modFieldType/*i*/ << ".getTypeLibType();\n";
549         }
550         o << "\n";
551     }
552 
553     o << indent() << "typelib_static_compound_type_init( &the_type, "
554       << getTypeClass(m_typeName, sal_True) << ", \"" << m_typeName.replace('/', '.') << "\", ";
555     if ( !superType.isEmpty() || bIsBaseException )
556     {
557         if ( bIsBaseException )
558         {
559             o << "* ::typelib_static_type_getByTypeClass( typelib_TypeClass_EXCEPTION ), "
560               << count << ", ";
561         } else
562         {
563             o << "rBaseType.getTypeLibType(), " << count << ", ";
564         }
565     } else
566     {
567         o << "0, " << count << ", ";
568     }
569 
570     if (count)
571     {
572         o << " aMemberRefs );\n";
573     } else
574     {
575         o << " 0 );\n";
576     }
577     dec();
578     o << indent() << "}\n";
579     o << indent()
580       << ("return * reinterpret_cast< const ::com::sun::star::uno::Type * >("
581           " &the_type );\n");
582 
583     dumpGetCppuTypePostamble(o);
584 }
585 
dumpComprehensiveGetCppuType(FileStream & o)586 void CppuType::dumpComprehensiveGetCppuType(FileStream& o)
587 {
588     dumpGetCppuTypePreamble(o);
589 
590     o << indent() << "static ::com::sun::star::uno::Type * the_pType = 0;\n";
591 
592 	o << indent() << "if (the_pType == 0)\n" << indent() << "{\n";
593 	inc();
594 	o << indent() << "::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );\n";
595 
596 	o << indent() << "if (the_pType == 0)\n" << indent() << "{\n";
597 	inc();
598 	o << indent() << "::rtl::OUString sTypeName( RTL_CONSTASCII_USTRINGPARAM(\""
599 	  << m_typeName.replace('/', '.') << "\") );\n\n";
600 
601     o << indent() << "// Start inline typedescription generation\n"
602       << indent() << "typelib_TypeDescription * pTD = 0;\n";
603 
604     OString superType;
605     if (m_reader.getSuperTypeCount() >= 1) {
606         superType = rtl::OUStringToOString(
607             m_reader.getSuperTypeName(0), RTL_TEXTENCODING_UTF8);
608     }
609     if ( !superType.isEmpty() ) {
610         o << indent()
611           << "const ::com::sun::star::uno::Type& rSuperType = ::cppu::UnoType< ";
612         dumpType(o, superType, false, false, false, true);
613         o << " >::get();\n";
614     }
615 
616     dumpCppuGetTypeMemberDecl(o, CPPUTYPEDECL_ALLTYPES);
617 
618     sal_uInt32 count = getMemberCount();
619     if (count)
620     {
621         o << "\n" << indent() << "typelib_CompoundMember_Init aMembers["
622           << count << "];\n";
623 
624         sal_uInt16      fieldCount = m_reader.getFieldCount();
625         RTFieldAccess   access = RT_ACCESS_INVALID;
626         OString         fieldType, fieldName;
627         OString         scope = m_typeName.replace('/', '.');
628         for (sal_uInt16 i=0; i < fieldCount; i++)
629         {
630             access = m_reader.getFieldFlags(i);
631 
632             if (access == RT_ACCESS_CONST || access == RT_ACCESS_INVALID) {
633                 continue;
634             }
635 
636             fieldName = rtl::OUStringToOString(
637                 m_reader.getFieldName(i), RTL_TEXTENCODING_UTF8);
638             fieldType = checkRealBaseType(
639                 rtl::OUStringToOString(
640                     m_reader.getFieldTypeName(i), RTL_TEXTENCODING_UTF8),
641                 sal_True);
642 
643             o << indent() << "::rtl::OUString sMemberType" << i
644               << "( RTL_CONSTASCII_USTRINGPARAM(\""
645               << fieldType.replace('/', '.') << "\") );\n";
646             o << indent() << "::rtl::OUString sMemberName" << i
647               << "( RTL_CONSTASCII_USTRINGPARAM(\"";
648             o << fieldName << "\") );\n";
649             o << indent() << "aMembers[" << i << "].eTypeClass = "
650               << "(typelib_TypeClass)" << getTypeClass(fieldType) << ";\n"
651               << indent() << "aMembers[" << i << "].pTypeName = sMemberType"
652               << i << ".pData;\n"
653               << indent() << "aMembers[" << i << "].pMemberName = sMemberName"
654               << i << ".pData;\n";
655         }
656     }
657 
658     o << "\n" << indent() << "typelib_typedescription_new(\n";
659     inc();
660     o << indent() << "&pTD,\n" << indent() << "(typelib_TypeClass)"
661       << getTypeClass() << ", sTypeName.pData,\n";
662 
663     if ( !superType.isEmpty() ) {
664         o << indent() << "rSuperType.getTypeLibType(),\n";
665     } else {
666         o << indent() << "0,\n";
667     }
668 
669     if ( count ) {
670         o << indent() << count << ",\n" << indent() << "aMembers );\n\n";
671     } else {
672         o << indent() << count << ",\n" << indent() << "0 );\n\n";
673     }
674 
675     dec();
676     o << indent()
677       << ("typelib_typedescription_register( (typelib_TypeDescription**)&pTD"
678           " );\n\n");
679 
680     o << indent() << "typelib_typedescription_release( pTD );\n"
681       << indent() << "// End inline typedescription generation\n\n";
682 
683     o << indent() << "static ::com::sun::star::uno::Type the_staticType( "
684       << getTypeClass(m_typeName) << ", sTypeName );\n";
685     o << indent() << "the_pType = &the_staticType;\n";
686 
687 	dec();
688 	o << indent() << "}\n";
689 	dec();
690 	o << indent() << "}\n\n";
691 	o << indent() << "return *the_pType;\n";
692     dumpGetCppuTypePostamble(o);
693 }
694 
dumpCppuGetTypeMemberDecl(FileStream & o,CppuTypeDecl eDeclFlag)695 void CppuType::dumpCppuGetTypeMemberDecl(FileStream& o, CppuTypeDecl eDeclFlag)
696 {
697 	sal_uInt16 		fieldCount = m_reader.getFieldCount();
698 	RTFieldAccess 	access = RT_ACCESS_INVALID;
699 
700 	StringSet aFinishedTypes;
701 	for (sal_uInt16 i=0; i < fieldCount; i++)
702 	{
703 		access = m_reader.getFieldFlags(i);
704 
705 		if (access == RT_ACCESS_CONST || access == RT_ACCESS_INVALID
706             || (access & RT_ACCESS_PARAMETERIZED_TYPE) != 0)
707 			continue;
708 
709         rtl::OString typeName(
710             rtl::OUStringToOString(
711                 m_reader.getFieldTypeName(i), RTL_TEXTENCODING_UTF8));
712 		if (aFinishedTypes.count(typeName) == 0)
713 		{
714 			aFinishedTypes.insert(typeName);
715 			dumpCppuGetType(o, typeName, sal_True, eDeclFlag);
716 		}
717 	}
718 }
719 
isGlobal() const720 IdentifierTranslationMode CppuType::isGlobal() const {
721     if ( m_typeName.indexOf('/') < 0 )
722         return ITM_GLOBAL;
723     else
724         return ITM_NONGLOBAL;
725 }
726 
getMemberCount()727 sal_uInt32 CppuType::getMemberCount()
728 {
729 	sal_uInt16 count = m_reader.getMethodCount();
730 
731 	sal_uInt16 fieldCount = m_reader.getFieldCount();
732 	RTFieldAccess access = RT_ACCESS_INVALID;
733 	for (sal_uInt16 i=0; i < fieldCount; i++)
734 	{
735 		access = m_reader.getFieldFlags(i);
736 
737 		if (access != RT_ACCESS_CONST && access != RT_ACCESS_INVALID)
738 			count++;
739 	}
740 	return count;
741 }
742 
checkInheritedMemberCount(const typereg::Reader * pReader)743 sal_uInt32 CppuType::checkInheritedMemberCount(const typereg::Reader* pReader)
744 {
745 	sal_Bool bSelfCheck = sal_True;
746 	if (!pReader)
747 	{
748 		bSelfCheck = sal_False;
749 		pReader = &m_reader;
750 	}
751 
752 	sal_uInt32 count = 0;
753 	OString superType;
754     if (pReader->getSuperTypeCount() >= 1) {
755         superType = rtl::OUStringToOString(
756             pReader->getSuperTypeName(0), RTL_TEXTENCODING_UTF8);
757     }
758 	if ( !superType.isEmpty() )
759 	{
760 		typereg::Reader aSuperReader(m_typeMgr.getTypeReader(superType));
761 		if ( aSuperReader.isValid() )
762 		{
763 			count = checkInheritedMemberCount(&aSuperReader);
764 		}
765 	}
766 
767 	if (bSelfCheck)
768 	{
769 		count += pReader->getMethodCount();
770 		sal_uInt16 fieldCount = pReader->getFieldCount();
771 		RTFieldAccess access = RT_ACCESS_INVALID;
772 		for (sal_uInt16 i=0; i < fieldCount; i++)
773 		{
774 			access = pReader->getFieldFlags(i);
775 
776 			if (access != RT_ACCESS_CONST && access != RT_ACCESS_INVALID)
777 			{
778 				count++;
779 			}
780 		}
781 	}
782 
783 	return count;
784 }
785 
getInheritedMemberCount()786 sal_uInt32 CppuType::getInheritedMemberCount()
787 {
788 	if (m_inheritedMemberCount == 0)
789 	{
790 		m_inheritedMemberCount = checkInheritedMemberCount(0);
791 	}
792 
793 	return m_inheritedMemberCount;
794 }
795 
getTypeClass(const OString & type,sal_Bool bCStyle)796 OString	CppuType::getTypeClass(const OString& type, sal_Bool bCStyle)
797 {
798 	OString 	typeName = (!type.isEmpty() ? type : m_typeName);
799 	RTTypeClass	rtTypeClass = RT_TYPE_INVALID;
800 
801 	if ( !type.isEmpty() )
802 	{
803 		typeName = type;
804 		rtTypeClass = m_typeMgr.getTypeClass(typeName);
805 	} else
806 	{
807 		typeName = m_typeName;
808 		rtTypeClass = m_reader.getTypeClass();
809 	}
810 
811 	if (codemaker::UnoType::isSequenceType(typeName))
812 		return bCStyle ? "typelib_TypeClass_SEQUENCE" : "::com::sun::star::uno::TypeClass_SEQUENCE";
813 
814 	switch (rtTypeClass)
815 	{
816 		case RT_TYPE_INTERFACE:
817 			return bCStyle ? "typelib_TypeClass_INTERFACE" : "::com::sun::star::uno::TypeClass_INTERFACE";
818 		case RT_TYPE_MODULE:
819 			return bCStyle ? "typelib_TypeClass_MODULE" : "::com::sun::star::uno::TypeClass_MODULE";
820 		case RT_TYPE_STRUCT:
821 			return bCStyle ? "typelib_TypeClass_STRUCT" : "::com::sun::star::uno::TypeClass_STRUCT";
822 		case RT_TYPE_ENUM:
823 			return bCStyle ? "typelib_TypeClass_ENUM" : "::com::sun::star::uno::TypeClass_ENUM";
824 		case RT_TYPE_EXCEPTION:
825 			return bCStyle ? "typelib_TypeClass_EXCEPTION" : "::com::sun::star::uno::TypeClass_EXCEPTION";
826 		case RT_TYPE_TYPEDEF:
827 			{
828 				OString realType = checkRealBaseType( typeName );
829 				return getTypeClass( realType, bCStyle );
830 			}
831 		case RT_TYPE_SERVICE:
832 			return bCStyle ? "typelib_TypeClass_SERVICE" : "::com::sun::star::uno::TypeClass_SERVICE";
833 		case RT_TYPE_INVALID:
834 			{
835 				if (type.equals("long"))
836 					return bCStyle ? "typelib_TypeClass_LONG" : "::com::sun::star::uno::TypeClass_LONG";
837 				if (type.equals("short"))
838 					return bCStyle ? "typelib_TypeClass_SHORT" : "::com::sun::star::uno::TypeClass_SHORT";
839 				if (type.equals("hyper"))
840 					return bCStyle ? "typelib_TypeClass_HYPER" : "::com::sun::star::uno::TypeClass_HYPER";
841 				if (type.equals("string"))
842 					return bCStyle ? "typelib_TypeClass_STRING" : "::com::sun::star::uno::TypeClass_STRING";
843 				if (type.equals("boolean"))
844 					return bCStyle ? "typelib_TypeClass_BOOLEAN" : "::com::sun::star::uno::TypeClass_BOOLEAN";
845 				if (type.equals("char"))
846 					return bCStyle ? "typelib_TypeClass_CHAR" : "::com::sun::star::uno::TypeClass_CHAR";
847 				if (type.equals("byte"))
848 					return bCStyle ? "typelib_TypeClass_BYTE" : "::com::sun::star::uno::TypeClass_BYTE";
849 				if (type.equals("any"))
850 					return bCStyle ? "typelib_TypeClass_ANY" : "::com::sun::star::uno::TypeClass_ANY";
851 				if (type.equals("type"))
852 					return bCStyle ? "typelib_TypeClass_TYPE" : "::com::sun::star::uno::TypeClass_TYPE";
853 				if (type.equals("float"))
854 					return bCStyle ? "typelib_TypeClass_FLOAT" : "::com::sun::star::uno::TypeClass_FLOAT";
855 				if (type.equals("double"))
856 					return bCStyle ? "typelib_TypeClass_DOUBLE" : "::com::sun::star::uno::TypeClass_DOUBLE";
857 				if (type.equals("void"))
858 					return bCStyle ? "typelib_TypeClass_VOID" : "::com::sun::star::uno::TypeClass_VOID";
859 				if (type.equals("unsigned long"))
860 					return bCStyle ? "typelib_TypeClass_UNSIGNED_LONG" : "::com::sun::star::uno::TypeClass_UNSIGNED_LONG";
861 				if (type.equals("unsigned short"))
862 					return bCStyle ? "typelib_TypeClass_UNSIGNED_SHORT" : "::com::sun::star::uno::TypeClass_UNSIGNED_SHORT";
863 				if (type.equals("unsigned hyper"))
864 					return bCStyle ? "typelib_TypeClass_UNSIGNED_HYPER" : "::com::sun::star::uno::TypeClass_UNSIGNED_HYPER";
865 			}
866 			break;
867         default:
868             OSL_ASSERT(false);
869             break;
870 	}
871 
872 	return bCStyle ? "typelib_TypeClass_UNKNOWN" : "::com::sun::star::uno::TypeClass_UNKNOWN";
873 }
874 
dumpType(FileStream & o,const OString & type,bool bConst,bool bRef,bool bNative,bool cppuUnoType) const875 void CppuType::dumpType(FileStream& o, const OString& type,
876 						bool bConst, bool bRef, bool bNative, bool cppuUnoType)
877 	const throw( CannotDumpException )
878 {
879     sal_Int32 seqNum;
880     std::vector< rtl::OString > args;
881     rtl::OString relType(
882         codemaker::UnoType::decompose(
883             checkRealBaseType(type, true), &seqNum, &args));
884 
885 	RTTypeClass typeClass = m_typeMgr.getTypeClass(relType);
886 
887 	if (bConst) o << "const ";
888 
889     {for (sal_Int32 i = 0; i < seqNum; ++i) {
890         if (cppuUnoType)
891             o << "::cppu::UnoSequenceType< ";
892         else
893             o << "::com::sun::star::uno::Sequence< ";
894     }}
895 
896 	switch (typeClass)
897 	{
898 		case RT_TYPE_INTERFACE:
899 			if (bNative)
900 				o << scopedCppName(relType);
901 			else
902 				o << "::com::sun::star::uno::Reference< "
903                   << scopedCppName(relType) << " >";
904 			break;
905 		case RT_TYPE_INVALID:
906 			{
907 				OString tmp(translateSimpleUnoType(relType, cppuUnoType));
908 				if ( !tmp.isEmpty() )
909 				{
910 					o << tmp;
911 				} else
912 					throw CannotDumpException("Unknown type '" + relType +
913                                               "', incomplete type library.");
914 			}
915 			break;
916 		case RT_TYPE_STRUCT:
917 		case RT_TYPE_ENUM:
918 		case RT_TYPE_TYPEDEF:
919 		case RT_TYPE_EXCEPTION:
920             {
921                 o << scopedCppName(relType);
922                 if (!args.empty()) {
923                     o << "< ";
924                     for (std::vector< rtl::OString >::iterator i(args.begin());
925                          i != args.end(); ++i)
926                     {
927                         if (i != args.begin()) {
928                             o << ", ";
929                         }
930                         dumpType(o, *i);
931                     }
932                     o << " >";
933                 }
934                 break;
935             }
936         default:
937             OSL_ASSERT(false);
938             break;
939 	}
940 
941     {for (sal_Int32 i = 0; i < seqNum; ++i) {
942 		o << " >";
943     }}
944 
945 	if (bRef) o << "&";
946 }
947 
dumpCppuGetType(FileStream & o,const OString & type,sal_Bool bDecl,CppuTypeDecl eDeclFlag)948 void CppuType::dumpCppuGetType(FileStream& o, const OString& type, sal_Bool bDecl, CppuTypeDecl eDeclFlag)
949 {
950     rtl::OString relType(
951         codemaker::UnoType::decompose(checkRealBaseType(type, true)));
952 
953 	if (eDeclFlag == CPPUTYPEDECL_ONLYINTERFACES)
954 	{
955 	 	if (m_typeMgr.getTypeClass(relType) == RT_TYPE_INTERFACE)
956 		{
957 			o << indent() << "::cppu::UnoType< ";
958 			dumpType(o, type, false, false, false, true);
959 			o << " >::get()";
960 
961 			if (bDecl)
962 				o << ";\n";
963 		}
964 	} else
965 	{
966 		if (codemaker::UnoType::getSort(type)
967             != codemaker::UnoType::SORT_COMPLEX)
968 		{
969 			return;
970 		} else
971 		{
972 			if (eDeclFlag == CPPUTYPEDECL_NOINTERFACES &&
973 				m_typeMgr.getTypeClass(relType) == RT_TYPE_INTERFACE)
974 				return;
975 
976 //			if (m_typeMgr.getTypeClass(type) == RT_TYPE_TYPEDEF)
977 //			{
978 //				o << indent() << "get_" << type.replace('/', '_') << "_Type()";
979 //			} else
980 //			{
981 				o << indent() << "::cppu::UnoType< ";
982 				dumpType(o, type, false, false, false, true);
983 				o << " >::get()";
984 //			}
985 		}
986 		if (bDecl)
987 			o << ";\n";
988 	}
989 }
990 
typeToIdentifier(const OString & type)991 OString CppuType::typeToIdentifier(const OString& type)
992 {
993     sal_Int32 seqNum;
994     rtl::OString relType(codemaker::UnoType::decompose(type, &seqNum));
995 	OString sIdentifier;
996 
997 	while( seqNum > 0 )
998 	{
999 		sIdentifier += OString("seq");
1000 
1001 		if ( --seqNum == 0 )
1002 		{
1003 			sIdentifier += OString("_");
1004 		}
1005 	}
1006 
1007     sIdentifier += relType.replace(
1008         ((codemaker::UnoType::getSort(relType)
1009           == codemaker::UnoType::SORT_COMPLEX)
1010          ? '/' : ' '),
1011         '_');
1012 
1013     // TODO: find better solution to create an identifier
1014     sIdentifier = sIdentifier.replace('<', '_');
1015     sIdentifier = sIdentifier.replace('>', '_');
1016     sIdentifier = sIdentifier.replace(',', '_');
1017 
1018 	return sIdentifier;
1019 }
1020 
passByReference(rtl::OString const & unoType)1021 bool CppuType::passByReference(rtl::OString const & unoType) {
1022     rtl::OString type(resolveTypedefs(unoType));
1023     switch (codemaker::UnoType::getSort(type)) {
1024     default:
1025         return false;
1026 
1027     case codemaker::UnoType::SORT_STRING:
1028     case codemaker::UnoType::SORT_TYPE:
1029     case codemaker::UnoType::SORT_ANY:
1030         return true;
1031 
1032     case codemaker::UnoType::SORT_COMPLEX:
1033         return m_typeMgr.getTypeClass(type) != RT_TYPE_ENUM;
1034     }
1035 }
1036 
resolveTypedefs(const OString & type) const1037 OString	CppuType::resolveTypedefs(const OString& type) const
1038 {
1039 	OString baseType(type);
1040 
1041 	RegistryKey 	key;
1042 	RTTypeClass 	typeClass;
1043 	sal_Bool 		isTypeDef = (m_typeMgr.getTypeClass(baseType) == RT_TYPE_TYPEDEF);
1044 	typereg::Reader reader;
1045 
1046 	while (isTypeDef)
1047 	{
1048 		reader = m_typeMgr.getTypeReader(baseType);
1049 
1050 		if (reader.isValid())
1051 		{
1052 			typeClass = reader.getTypeClass();
1053 
1054 			if (typeClass == RT_TYPE_TYPEDEF)
1055 				baseType = rtl::OUStringToOString(
1056                     reader.getSuperTypeName(0), RTL_TEXTENCODING_UTF8);
1057 			else
1058 				isTypeDef = sal_False;
1059 		} else
1060 		{
1061 			break;
1062 		}
1063 	}
1064 
1065 	return baseType;
1066 }
1067 
checkRealBaseType(const OString & type,sal_Bool bResolveTypeOnly) const1068 OString	CppuType::checkRealBaseType(const OString& type, sal_Bool bResolveTypeOnly) const
1069 {
1070     sal_Int32 rank;
1071     rtl::OString baseType(codemaker::UnoType::decompose(type, &rank));
1072 
1073 	RegistryKey 	key;
1074 	RTTypeClass 	typeClass;
1075 	sal_Bool 		mustBeChecked = (m_typeMgr.getTypeClass(baseType) == RT_TYPE_TYPEDEF);
1076 	typereg::Reader reader;
1077 
1078 	while (mustBeChecked)
1079 	{
1080 		reader = m_typeMgr.getTypeReader(baseType);
1081 
1082 		if (reader.isValid())
1083 		{
1084 			typeClass = reader.getTypeClass();
1085 
1086 			if (typeClass == RT_TYPE_TYPEDEF)
1087 			{
1088                 sal_Int32 n;
1089                 baseType = codemaker::UnoType::decompose(
1090                     rtl::OUStringToOString(
1091                         reader.getSuperTypeName(0), RTL_TEXTENCODING_UTF8),
1092                     &n);
1093                 OSL_ASSERT(n <= SAL_MAX_INT32 - rank); //TODO
1094                 rank += n;
1095 			} else
1096 				mustBeChecked = sal_False;
1097 		} else
1098 		{
1099 			break;
1100 		}
1101 	}
1102 
1103     if (bResolveTypeOnly) {
1104         rtl::OStringBuffer buf;
1105         for (sal_Int32 i = 0; i < rank; ++i) {
1106             buf.append(RTL_CONSTASCII_STRINGPARAM("[]"));
1107         }
1108         baseType = buf.makeStringAndClear() + baseType;
1109     }
1110 
1111 	return baseType;
1112 }
1113 
dumpConstantValue(FileStream & o,sal_uInt16 index)1114 void CppuType::dumpConstantValue(FileStream& o, sal_uInt16 index)
1115 {
1116 	RTConstValue constValue = m_reader.getFieldValue(index);
1117 
1118 	switch (constValue.m_type)
1119 	{
1120         case RT_TYPE_NONE:
1121             break;
1122 		case RT_TYPE_BOOL:
1123 			if (constValue.m_value.aBool)
1124 				o << "sal_True";
1125 			else
1126 				o << "sal_False";
1127 			break;
1128 		case RT_TYPE_BYTE:
1129             o << "(sal_Int8)"
1130               << sal::static_int_cast< sal_Int8 >(constValue.m_value.aByte);
1131 			break;
1132 		case RT_TYPE_INT16:
1133 			o << "(sal_Int16)" << constValue.m_value.aShort;
1134 			break;
1135 		case RT_TYPE_UINT16:
1136 			o << "(sal_uInt16)" << constValue.m_value.aUShort;
1137 			break;
1138 		case RT_TYPE_INT32:
1139             // Avoid C++ compiler warnings about (un)signedness of literal
1140             // -2^31:
1141             if (constValue.m_value.aLong == SAL_MIN_INT32) {
1142                 o << "SAL_MIN_INT32";
1143             } else {
1144                 o << "(sal_Int32)" << constValue.m_value.aLong;
1145             }
1146 			break;
1147 		case RT_TYPE_UINT32:
1148 			o << "(sal_uInt32)"
1149               << OString::valueOf(
1150                   static_cast< sal_Int64 >(constValue.m_value.aULong)).getStr()
1151               << "U";
1152 			break;
1153 		case RT_TYPE_INT64:
1154             // Avoid C++ compiler warnings about (un)signedness of literal
1155             // -2^63:
1156             if (constValue.m_value.aHyper == SAL_MIN_INT64) {
1157                 o << "SAL_MIN_INT64";
1158             } else {
1159                 ::rtl::OString tmp(OString::valueOf(constValue.m_value.aHyper));
1160                 o << "(sal_Int64) SAL_CONST_INT64(" << tmp.getStr() << ")";
1161             }
1162 			break;
1163 		case RT_TYPE_UINT64:
1164             {
1165                 o << "SAL_CONST_UINT64(";
1166                 sal_uInt64 n = constValue.m_value.aUHyper;
1167                 if (n == 0) {
1168                     o << "0";
1169                 } else {
1170                     std::vector< char > buf;
1171                     for (; n != 0; n /= 10) {
1172                         buf.push_back('0' + static_cast< char >(n % 10));
1173                     }
1174                     for (std::vector< char >::reverse_iterator i(buf.rbegin());
1175                          i != buf.rend(); ++i)
1176                     {
1177                         o << rtl::OString::valueOf(*i).getStr();
1178                     }
1179                 }
1180                 o << ")";
1181             }
1182 			break;
1183 		case RT_TYPE_FLOAT:
1184             {
1185                 ::rtl::OString tmp( OString::valueOf(constValue.m_value.aFloat) );
1186                 o << "(float)" << tmp.getStr();
1187             }
1188 			break;
1189 		case RT_TYPE_DOUBLE:
1190             {
1191                 ::rtl::OString tmp( OString::valueOf(constValue.m_value.aDouble) );
1192                 o << "(double)" << tmp.getStr();
1193             }
1194 			break;
1195 		case RT_TYPE_STRING:
1196 			{
1197 				::rtl::OUString aUStr(constValue.m_value.aString);
1198 				::rtl::OString aStr = ::rtl::OUStringToOString(aUStr, RTL_TEXTENCODING_ASCII_US);
1199 				o << "::rtl::OUString::createFromAscii(\"" << aStr.getStr() << "\")";
1200 			}
1201 			break;
1202 	}
1203 }
1204 
inc(sal_Int32 num)1205 void CppuType::inc(sal_Int32 num)
1206 {
1207 	m_indentLength += num;
1208 }
1209 
dec(sal_Int32 num)1210 void CppuType::dec(sal_Int32 num)
1211 {
1212     m_indentLength = std::max< sal_Int32 >(m_indentLength - num, 0);
1213 }
1214 
indent() const1215 OString CppuType::indent() const
1216 {
1217 	OStringBuffer tmp(m_indentLength);
1218 
1219 	for (sal_Int32 i=0; i < m_indentLength; i++)
1220 	{
1221 		tmp.append(' ');
1222 	}
1223 	return tmp.makeStringAndClear();
1224 }
1225 
1226 //*************************************************************************
1227 // InterfaceType
1228 //*************************************************************************
InterfaceType(typereg::Reader & typeReader,const OString & typeName,const TypeManager & typeMgr)1229 InterfaceType::InterfaceType(typereg::Reader& typeReader,
1230 			 				 const OString& typeName,
1231 							 const TypeManager& typeMgr)
1232 	: CppuType(typeReader, typeName, typeMgr)
1233 {
1234 	m_inheritedMemberCount = 0;
1235 	m_hasAttributes = sal_False;
1236 	m_hasMethods = sal_False;
1237 }
1238 
~InterfaceType()1239 InterfaceType::~InterfaceType()
1240 {
1241 
1242 }
1243 
dumpHFile(FileStream & o,codemaker::cppumaker::Includes & includes)1244 sal_Bool InterfaceType::dumpHFile(
1245     FileStream& o, codemaker::cppumaker::Includes & includes)
1246 	throw( CannotDumpException )
1247 {
1248 	OString headerDefine(dumpHeaderDefine(o, "HDL"));
1249 	o << "\n";
1250 
1251 	addDefaultHIncludes(includes);
1252     if (m_reader.getMethodCount() != 0) {
1253         includes.add("com/sun/star/uno/RuntimeException");
1254     }
1255     includes.dump(o, 0);
1256 	o << ("\nnamespace com { namespace sun { namespace star { namespace uno {\n"
1257           "class Type;\n} } } }\n\n");
1258 
1259     if (codemaker::cppumaker::dumpNamespaceOpen(o, m_typeName, false)) {
1260         o << "\n";
1261     }
1262 	dumpDeclaration(o);
1263     if (codemaker::cppumaker::dumpNamespaceClose(o, m_typeName, false)) {
1264         o << "\n";
1265     }
1266 
1267 	o << "\ninline const ::com::sun::star::uno::Type& SAL_CALL getCppuType( ";
1268 	dumpType(o, m_typeName, sal_True, sal_False);
1269 	o << "* ) SAL_THROW( () );\n\n";
1270 
1271 	o << "#endif // "<< headerDefine << "\n";
1272 	return sal_True;
1273 }
1274 
dumpDeclaration(FileStream & o)1275 sal_Bool InterfaceType::dumpDeclaration(FileStream& o)
1276 	throw( CannotDumpException )
1277 {
1278 //     rtl::OString cppName(translateUnoToCppIdentifier(
1279 //                              m_name, "interface", ITM_KEYWORDSONLY, &m_name));
1280 
1281 // 	o << "\nclass SAL_NO_VTABLE " << cppName;
1282 	o << "\nclass SAL_NO_VTABLE " << m_name;
1283 
1284     for (sal_Int16 i = 0; i < m_reader.getSuperTypeCount(); ++i) {
1285         o << (i == 0 ? " :" : ",") << " public "
1286           << scopedCppName(rtl::OUStringToOString(
1287                             m_reader.getSuperTypeName(i), RTL_TEXTENCODING_UTF8));
1288     }
1289 
1290 	o << "\n{\npublic:\n";
1291 
1292 	inc();
1293 
1294 	dumpAttributes(o);
1295 	dumpMethods(o);
1296 
1297     o << "\n" << indent()
1298       << ("static inline ::com::sun::star::uno::Type const & SAL_CALL"
1299           " static_type(void * = 0);\n");
1300 
1301 	dec();
1302 	o << "};\n\n";
1303 
1304 	return sal_True;
1305 }
1306 
dumpHxxFile(FileStream & o,codemaker::cppumaker::Includes & includes)1307 sal_Bool InterfaceType::dumpHxxFile(
1308     FileStream& o, codemaker::cppumaker::Includes & includes)
1309 	throw( CannotDumpException )
1310 {
1311 	OString headerDefine(dumpHeaderDefine(o, "HPP"));
1312 	o << "\n";
1313 
1314 	addDefaultHxxIncludes(includes);
1315 	includes.dump(o, &m_typeName);
1316 	o << "\n";
1317 
1318 	dumpGetCppuType(o);
1319 
1320 //     rtl::OString cppName(translateUnoToCppIdentifier(
1321 //                              m_name, "interface", ITM_KEYWORDSONLY, &m_name));
1322 
1323     o << "\n::com::sun::star::uno::Type const & "
1324       << scopedCppName(m_typeName)
1325       << "::static_type(void *) {\n";
1326     inc();
1327     o << indent() << "return ::getCppuType(static_cast< ";
1328     dumpType(o, m_typeName);
1329     o << " * >(0));\n";
1330     dec();
1331     o << "}\n";
1332 
1333 	o << "\n#endif // "<< headerDefine << "\n";
1334 	return sal_True;
1335 }
1336 
dumpAttributes(FileStream & o)1337 void InterfaceType::dumpAttributes(FileStream& o)
1338 {
1339 	sal_uInt16 fieldCount = m_reader.getFieldCount();
1340 	sal_Bool first=sal_True;
1341 
1342 	RTFieldAccess access = RT_ACCESS_INVALID;
1343 	OString fieldName;
1344 	OString fieldType;
1345 	for (sal_uInt16 i=0; i < fieldCount; i++)
1346 	{
1347 		access = m_reader.getFieldFlags(i);
1348 
1349 		if (access == RT_ACCESS_CONST || access == RT_ACCESS_INVALID)
1350 			continue;
1351 
1352         rtl::OUString name(m_reader.getFieldName(i));
1353 		fieldName = rtl::OUStringToOString(name, RTL_TEXTENCODING_UTF8);
1354 		fieldType = rtl::OUStringToOString(
1355             m_reader.getFieldTypeName(i), RTL_TEXTENCODING_UTF8);
1356 
1357 		if (first)
1358 		{
1359 			first = sal_False;
1360 			o << "\n" << indent() << "// Attributes\n";
1361 		}
1362 
1363 		o << indent() << "virtual ";
1364 		dumpType(o, fieldType);
1365 		o << " SAL_CALL get" << fieldName << "()";
1366         dumpAttributeExceptionSpecification(o, name, RT_MODE_ATTRIBUTE_GET);
1367         o << " = 0;\n";
1368 
1369 		if ((access & RT_ACCESS_READONLY) == 0)
1370 		{
1371             bool byRef = passByReference(fieldType);
1372 			o << indent() << "virtual void SAL_CALL set" << fieldName << "( ";
1373 			dumpType(o, fieldType, byRef, byRef);
1374 			o << " _" << fieldName.toAsciiLowerCase() << " )";
1375             dumpAttributeExceptionSpecification(o, name, RT_MODE_ATTRIBUTE_SET);
1376             o << " = 0;\n";
1377 		}
1378 	}
1379 }
1380 
dumpMethods(FileStream & o)1381 void InterfaceType::dumpMethods(FileStream& o)
1382 {
1383 	sal_uInt16 methodCount = m_reader.getMethodCount();
1384 	sal_Bool first=sal_True;
1385 
1386 	OString methodName, returnType, paramType, paramName;
1387 	sal_uInt16 paramCount = 0;
1388 	RTMethodMode methodMode = RT_MODE_INVALID;
1389 	RTParamMode	 paramMode = RT_PARAM_INVALID;
1390 
1391 	sal_Bool bRef = sal_False;
1392 	sal_Bool bConst = sal_False;
1393 	sal_Bool bWithRunTimeExcp = sal_True;
1394 
1395 	for (sal_uInt16 i=0; i < methodCount; i++)
1396 	{
1397 		methodMode = m_reader.getMethodFlags(i);
1398         if (methodMode == RT_MODE_ATTRIBUTE_GET
1399             || methodMode == RT_MODE_ATTRIBUTE_SET)
1400         {
1401             continue;
1402         }
1403 
1404 		methodName = rtl::OUStringToOString(
1405             m_reader.getMethodName(i), RTL_TEXTENCODING_UTF8);
1406 		returnType = rtl::OUStringToOString(
1407             m_reader.getMethodReturnTypeName(i), RTL_TEXTENCODING_UTF8);
1408 		paramCount = m_reader.getMethodParameterCount(i);
1409 
1410 		if ( methodName.equals("acquire") || methodName.equals("release") )
1411 		{
1412 			bWithRunTimeExcp = sal_False;
1413 		}
1414 
1415 		if (first)
1416 		{
1417 			first = sal_False;
1418 			o << "\n" << indent() << "// Methods\n";
1419 		}
1420 
1421 		o << indent() << "virtual ";
1422 		dumpType(o, returnType);
1423 		o << " SAL_CALL " << methodName << "( ";
1424 		for (sal_uInt16 j=0; j < paramCount; j++)
1425 		{
1426 			paramName =	rtl::OUStringToOString(
1427                 m_reader.getMethodParameterName(i, j), RTL_TEXTENCODING_UTF8);
1428 			paramType =	rtl::OUStringToOString(
1429                 m_reader.getMethodParameterTypeName(i, j),
1430                 RTL_TEXTENCODING_UTF8);
1431 			paramMode = m_reader.getMethodParameterFlags(i, j);
1432 
1433 			switch (paramMode)
1434 			{
1435 				case RT_PARAM_IN:
1436                     bConst = passByReference(paramType);
1437                     bRef = bConst;
1438 					break;
1439 				case RT_PARAM_OUT:
1440 				case RT_PARAM_INOUT:
1441 					bConst = sal_False;
1442 					bRef = sal_True;
1443 					break;
1444                 default:
1445                     break;
1446 			}
1447 
1448 			dumpType(o, paramType, bConst, bRef);
1449 // 			o << " " << translateUnoToCppIdentifier(
1450 //                 paramName, "param", ITM_KEYWORDSONLY, NULL);
1451 			o << " " << paramName;
1452 
1453 			if (j+1 < (sal_uInt16)paramCount) o << ", ";
1454 		}
1455 		o << " )";
1456         dumpExceptionSpecification(o, i, bWithRunTimeExcp);
1457 		o << " = 0;\n";
1458 	}
1459 }
1460 
dumpNormalGetCppuType(FileStream & o)1461 void InterfaceType::dumpNormalGetCppuType(FileStream& o)
1462 {
1463     dumpGetCppuTypePreamble(o);
1464 
1465     o << indent()
1466       << "static typelib_TypeDescriptionReference * the_type = 0;\n";
1467 
1468     o << indent() << "if ( !the_type )\n" << indent() << "{\n";
1469     inc();
1470     sal_Int16 nBases = m_reader.getSuperTypeCount();
1471     OSL_ASSERT(nBases > 0);
1472     if (nBases == 1
1473         && m_reader.getSuperTypeName(0).equalsAsciiL(
1474             RTL_CONSTASCII_STRINGPARAM("com/sun/star/uno/XInterface")))
1475     {
1476         nBases = 0;
1477     }
1478     if (nBases > 0) {
1479         o << indent() << "typelib_TypeDescriptionReference * aSuperTypes["
1480           << nBases << "];\n";
1481         for (sal_Int16 i = 0; i < nBases; ++i) {
1482             o << indent() << "aSuperTypes[" << i << "] = ::cppu::UnoType< ";
1483             dumpType(
1484                 o,
1485                 rtl::OUStringToOString(
1486                     m_reader.getSuperTypeName(i), RTL_TEXTENCODING_UTF8),
1487                 true, false, false, true);
1488             o << " >::get().getTypeLibType();\n";
1489         }
1490     }
1491 
1492     o << indent() << "typelib_static_mi_interface_type_init( &the_type, \""
1493       << m_typeName.replace('/', '.') << "\", " << nBases << ", ";
1494 
1495     if ( nBases > 0 )
1496     {
1497         o << "aSuperTypes );\n";
1498     } else
1499     {
1500         o << "0 );\n";
1501     }
1502 
1503     dec();
1504     o << indent() << "}\n";
1505     o << indent()
1506       << ("return * reinterpret_cast< ::com::sun::star::uno::Type * >("
1507           " &the_type );\n");
1508 
1509     dumpGetCppuTypePostamble(o);
1510 }
1511 
dumpComprehensiveGetCppuType(FileStream & o)1512 void InterfaceType::dumpComprehensiveGetCppuType(FileStream& o)
1513 {
1514     dumpGetCppuTypePreamble(o);
1515 
1516     o << indent() << "static ::com::sun::star::uno::Type * the_pType = 0;\n";
1517 
1518 	o << indent() << "if (the_pType == 0)\n" << indent() << "{\n";
1519 	inc();
1520 	o << indent() << "::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );\n";
1521 
1522 	o << indent() << "if (the_pType == 0)\n" << indent() << "{\n";
1523 	inc();
1524 	o << indent() << "::rtl::OUString sTypeName( RTL_CONSTASCII_USTRINGPARAM(\""
1525 	  << m_typeName.replace('/', '.') << "\") );\n\n";
1526 
1527     o << indent() << "// Start inline typedescription generation\n"
1528       << indent() << "typelib_InterfaceTypeDescription * pTD = 0;\n\n";
1529 
1530     OSL_ASSERT(m_reader.getSuperTypeCount() > 0);
1531     o << indent() << "typelib_TypeDescriptionReference * aSuperTypes["
1532       << m_reader.getSuperTypeCount() << "];\n";
1533     for (sal_Int16 i = 0; i < m_reader.getSuperTypeCount(); ++i) {
1534         o << indent() << "aSuperTypes[" << i << "] = ::cppu::UnoType< ";
1535         dumpType(
1536             o,
1537             rtl::OUStringToOString(
1538                 m_reader.getSuperTypeName(i), RTL_TEXTENCODING_UTF8),
1539             false, false, false, true);
1540         o << " >::get().getTypeLibType();\n";
1541     }
1542 
1543     sal_uInt32 count = getMemberCount();
1544     if (count)
1545     {
1546         o << indent() << "typelib_TypeDescriptionReference * pMembers[" << count
1547           << "] = { ";
1548         for (sal_uInt32 i = 0; i < count; i++)
1549         {
1550             o << "0";
1551             if (i+1 < count) {
1552                 o << ",";
1553             } else {
1554                 o << " };\n";
1555             }
1556         }
1557 
1558         sal_uInt32 index = 0;
1559         dumpCppuAttributeRefs(o, index);
1560         dumpCppuMethodRefs(o, index);
1561     }
1562 
1563     o << "\n" << indent() << "typelib_typedescription_newMIInterface(\n";
1564     inc();
1565     o << indent() << "&pTD,\n" << indent() << "sTypeName.pData, ";
1566 
1567     o << "0x00000000, 0x0000, 0x0000, 0x00000000, 0x00000000,\n"; // UIK
1568 
1569     o << indent() << m_reader.getSuperTypeCount() << ", aSuperTypes,\n";
1570 
1571     if ( count ) {
1572         o << indent() << count << ",\n" << indent() << "pMembers );\n\n";
1573     } else {
1574         o << indent() << count << ",\n" << indent() << "0 );\n\n";
1575     }
1576     dec();
1577 
1578     o << indent()
1579       << ("typelib_typedescription_register( (typelib_TypeDescription**)&pTD"
1580           " );\n");
1581     if ( count )
1582     {
1583         for (sal_uInt16 i=0; i < count; i++)
1584         {
1585             o << indent()
1586               << "typelib_typedescriptionreference_release( pMembers[" << i
1587               << "] );\n";
1588         }
1589     }
1590     o << indent()
1591       << ("typelib_typedescription_release( (typelib_TypeDescription*)pTD"
1592           " );\n\n");
1593 
1594     o << indent() << "static ::com::sun::star::uno::Type the_staticType( "
1595       << getTypeClass(m_typeName) << ", sTypeName );\n";
1596     o << indent() << "the_pType = &the_staticType;\n";
1597 
1598     StringSet   aTypes;
1599     // type for RuntimeException is always needed
1600     OString     sRunTimeExceptionType("com/sun/star/uno/RuntimeException");
1601     aTypes.insert(sRunTimeExceptionType);
1602     dumpCppuGetType(o, sRunTimeExceptionType, sal_True, CPPUTYPEDECL_ALLTYPES);
1603 
1604     dumpAttributesCppuDecl(o, &aTypes, CPPUTYPEDECL_ALLTYPES);
1605     dumpMethodsCppuDecl(o, &aTypes, CPPUTYPEDECL_ALLTYPES);
1606 
1607     if (count)
1608     {
1609         sal_uInt32 index = getInheritedMemberCount();
1610         dumpCppuAttributes(o, index);
1611         dumpCppuMethods(o, index);
1612     }
1613 
1614     o << indent() << "// End inline typedescription generation\n";
1615 
1616 	dec();
1617 	o << indent() << "}\n";
1618 	dec();
1619 	o << indent() << "}\n\n"
1620 	  << indent() << "return *the_pType;\n";
1621 
1622     dumpGetCppuTypePostamble(o);
1623 }
1624 
dumpCppuAttributeRefs(FileStream & o,sal_uInt32 & index)1625 void InterfaceType::dumpCppuAttributeRefs(FileStream& o, sal_uInt32& index)
1626 {
1627 	sal_uInt16 fieldCount = m_reader.getFieldCount();
1628 
1629 	RTFieldAccess access = RT_ACCESS_INVALID;
1630 	OString fieldName;
1631 	OString	scope = m_typeName.replace('/', '.');
1632 
1633 	for (sal_uInt16 i=0; i < fieldCount; i++)
1634 	{
1635 		access = m_reader.getFieldFlags(i);
1636 
1637 		if (access == RT_ACCESS_CONST || access == RT_ACCESS_INVALID)
1638 			continue;
1639 
1640 		fieldName = rtl::OUStringToOString(
1641             m_reader.getFieldName(i), RTL_TEXTENCODING_UTF8);
1642 
1643 		o << indent() << "::rtl::OUString sAttributeName" << i << "( RTL_CONSTASCII_USTRINGPARAM(\""
1644 		  << scope.replace('/', '.') << "::" << fieldName << "\") );\n";
1645 		o << indent() << "typelib_typedescriptionreference_new( &pMembers["
1646 		  << index << "],\n";
1647 		inc(38);
1648 		o << indent() << "(typelib_TypeClass)::com::sun::star::uno::TypeClass_INTERFACE_ATTRIBUTE,\n"
1649 		  << indent() << "sAttributeName" << i << ".pData );\n";
1650 		dec(38);
1651 		index++;
1652 	}
1653 }
1654 
dumpCppuMethodRefs(FileStream & o,sal_uInt32 & index)1655 void InterfaceType::dumpCppuMethodRefs(FileStream& o, sal_uInt32& index)
1656 {
1657 	sal_uInt16 	methodCount = m_reader.getMethodCount();
1658 	OString    	methodName;
1659 	OString	   	scope = m_typeName.replace('/', '.');
1660 
1661 	for (sal_uInt16 i = 0; i < methodCount; i++)
1662 	{
1663 		RTMethodMode flags = m_reader.getMethodFlags(i);
1664         if (flags == RT_MODE_ATTRIBUTE_GET || flags == RT_MODE_ATTRIBUTE_SET) {
1665             continue;
1666         }
1667 
1668 		methodName = rtl::OUStringToOString(
1669             m_reader.getMethodName(i), RTL_TEXTENCODING_UTF8);
1670 
1671 		o << indent() << "::rtl::OUString sMethodName" << i << "( RTL_CONSTASCII_USTRINGPARAM(\""
1672 		  << scope.replace('/', '.') << "::" << methodName << "\") );\n";
1673 		o << indent() << "typelib_typedescriptionreference_new( &pMembers["
1674 		  << index << "],\n";
1675 		inc(38);
1676 		o << indent() << "(typelib_TypeClass)::com::sun::star::uno::TypeClass_INTERFACE_METHOD,\n"
1677 		  << indent() << "sMethodName" << i << ".pData );\n";
1678 		dec(38);
1679 		index++;
1680 	}
1681 }
1682 
getMemberCount()1683 sal_uInt32 InterfaceType::getMemberCount() {
1684     sal_uInt16 count = 0;
1685     sal_uInt16 methodCount = m_reader.getMethodCount();
1686     {for (sal_uInt16 i = 0; i < methodCount; ++i) {
1687         RTMethodMode flags = m_reader.getMethodFlags(i);
1688         if (flags != RT_MODE_ATTRIBUTE_GET && flags != RT_MODE_ATTRIBUTE_SET) {
1689             m_hasMethods = true;
1690             ++count;
1691         }
1692     }}
1693     sal_uInt16 fieldCount = m_reader.getFieldCount();
1694     {for (sal_uInt16 i = 0; i < fieldCount; ++i) {
1695         RTFieldAccess flags = m_reader.getFieldFlags(i);
1696         if (flags != RT_ACCESS_CONST && flags != RT_ACCESS_INVALID) {
1697             m_hasAttributes = true;
1698             ++count;
1699         }
1700     }}
1701     return count;
1702 }
1703 
1704 namespace {
1705 
1706 class BaseOffset {
1707 public:
1708     BaseOffset(TypeManager const & theManager, typereg::Reader const & reader);
1709 
get() const1710     sal_Int32 get() const { return offset; }
1711 
1712 private:
1713     void calculateBases(typereg::Reader const & reader);
1714 
1715     void calculate(typereg::Reader const & reader);
1716 
1717     TypeManager const & manager;
1718     std::set< rtl::OString > set;
1719     sal_Int32 offset;
1720 };
1721 
BaseOffset(TypeManager const & theManager,typereg::Reader const & reader)1722 BaseOffset::BaseOffset(
1723     TypeManager const & theManager, typereg::Reader const & reader):
1724     manager(theManager)
1725 {
1726     offset = 0;
1727     calculateBases(reader);
1728 }
1729 
calculateBases(typereg::Reader const & reader)1730 void BaseOffset::calculateBases(typereg::Reader const & reader) {
1731     for (sal_Int16 i = 0; i < reader.getSuperTypeCount(); ++i) {
1732         typereg::Reader super(
1733             manager.getTypeReader(
1734                 rtl::OUStringToOString(
1735                     reader.getSuperTypeName(i), RTL_TEXTENCODING_UTF8)));
1736         if (super.isValid()) {
1737             calculate(super);
1738         }
1739     }
1740 }
1741 
calculate(typereg::Reader const & reader)1742 void BaseOffset::calculate(typereg::Reader const & reader) {
1743     if (set.insert(
1744             rtl::OUStringToOString(reader.getTypeName(), RTL_TEXTENCODING_UTF8))
1745         .second)
1746     {
1747         calculateBases(reader);
1748         {for (sal_uInt16 i = 0; i < reader.getMethodCount(); ++i) {
1749             RTMethodMode flags = reader.getMethodFlags(i);
1750             if (flags != RT_MODE_ATTRIBUTE_GET
1751                 && flags != RT_MODE_ATTRIBUTE_SET)
1752             {
1753                 ++offset;
1754             }
1755         }}
1756         {for (sal_uInt16 i = 0; i < reader.getFieldCount(); ++i) {
1757             RTFieldAccess flags = reader.getFieldFlags(i);
1758             if (flags != RT_ACCESS_CONST && flags != RT_ACCESS_INVALID) {
1759                 ++offset;
1760             }
1761         }}
1762     }
1763 }
1764 
1765 }
1766 
addSpecialDependencies()1767 void InterfaceType::addSpecialDependencies() {
1768     if (m_reader.getMethodCount() > 0 || m_reader.getFieldCount() > 0) {
1769         m_dependencies.add("com/sun/star/uno/RuntimeException");
1770     }
1771 }
1772 
addComprehensiveGetCppuTypeIncludes(codemaker::cppumaker::Includes & includes) const1773 void InterfaceType::addComprehensiveGetCppuTypeIncludes(
1774     codemaker::cppumaker::Includes & includes) const
1775 {
1776     // The comprehensive getCppuType method always includes a line
1777     // "getCppuType( (const ::com::sun::star::uno::RuntimeException*)0 );":
1778     includes.addCppuUnotypeHxx();
1779     includes.add("com/sun/star/uno/RuntimeException");
1780 }
1781 
checkInheritedMemberCount(const typereg::Reader *)1782 sal_uInt32 InterfaceType::checkInheritedMemberCount(const typereg::Reader*)
1783 {
1784     return BaseOffset(m_typeMgr, m_reader).get();
1785 }
1786 
getInheritedMemberCount()1787 sal_uInt32 InterfaceType::getInheritedMemberCount()
1788 {
1789 	if (m_inheritedMemberCount == 0)
1790 	{
1791 		m_inheritedMemberCount = checkInheritedMemberCount(0);
1792 	}
1793 
1794 	return m_inheritedMemberCount;
1795 }
1796 
dumpCppuAttributes(FileStream & o,sal_uInt32 & index)1797 void InterfaceType::dumpCppuAttributes(FileStream& o, sal_uInt32& index)
1798 {
1799 	sal_uInt16 fieldCount = m_reader.getFieldCount();
1800 
1801 	RTFieldAccess access = RT_ACCESS_INVALID;
1802 	OString fieldName;
1803 	OString fieldType;
1804 	OString	scope = m_typeName.replace('/', '.');
1805 
1806 	sal_uInt32 absoluteIndex = index;
1807 
1808 	if (m_hasAttributes)
1809 	{
1810 		o << "\n" << indent() << "typelib_InterfaceAttributeTypeDescription * pAttribute = 0;\n";
1811 
1812 		for (sal_uInt16 i=0; i < fieldCount; i++)
1813 		{
1814 			access = m_reader.getFieldFlags(i);
1815 
1816 			if (access == RT_ACCESS_CONST || access == RT_ACCESS_INVALID)
1817 				continue;
1818 
1819             rtl::OUString name(m_reader.getFieldName(i));
1820 			fieldName = rtl::OUStringToOString(name, RTL_TEXTENCODING_UTF8);
1821 			fieldType = checkRealBaseType(
1822                 rtl::OUStringToOString(
1823                     m_reader.getFieldTypeName(i), RTL_TEXTENCODING_UTF8),
1824                 sal_True);
1825 
1826             o << indent() << "{\n";
1827             inc();
1828 			o << indent() << "::rtl::OUString sAttributeType" << i << "( RTL_CONSTASCII_USTRINGPARAM(\""
1829 			  << fieldType.replace('/', '.') << "\") );\n";
1830             sal_Int32 getExceptions = dumpAttributeExceptionTypeNames(
1831                 o, "get", name, RT_MODE_ATTRIBUTE_GET);
1832             sal_Int32 setExceptions = dumpAttributeExceptionTypeNames(
1833                 o, "set", name, RT_MODE_ATTRIBUTE_SET);
1834 			o << indent()
1835               << ("typelib_typedescription_newExtendedInterfaceAttribute("
1836                   " &pAttribute,\n");
1837 			inc();
1838 			o << indent() << absoluteIndex++ << ", sAttributeName" << i << ".pData,\n";
1839 			o << indent() << "(typelib_TypeClass)" << getTypeClass(fieldType)
1840 			  << ", sAttributeType" << i << ".pData,\n";
1841             o << indent() << "sal_"
1842               << ((access & RT_ACCESS_READONLY) == 0 ? "False" : "True") << ", "
1843               << getExceptions << ", "
1844               << (getExceptions == 0 ? "0" : "the_getExceptions") << ", "
1845               << setExceptions << ", "
1846               << (setExceptions == 0 ? "0" : "the_setExceptions") << " );\n";
1847 			dec();
1848 			o << indent() << "typelib_typedescription_register( (typelib_TypeDescription**)&pAttribute );\n";
1849             dec();
1850             o << indent() << "}\n";
1851 		}
1852  		o << indent() << "typelib_typedescription_release( (typelib_TypeDescription*)pAttribute );\n";
1853 
1854 		index = absoluteIndex;
1855 	}
1856 }
1857 
dumpCppuMethods(FileStream & o,sal_uInt32 & index)1858 void InterfaceType::dumpCppuMethods(FileStream& o, sal_uInt32& index)
1859 {
1860 	sal_uInt16 		methodCount = m_reader.getMethodCount();
1861 	OString 		methodName, returnType, paramType, paramName;
1862 	sal_uInt16 		paramCount = 0;
1863 	RTMethodMode 	methodMode = RT_MODE_INVALID;
1864 	RTParamMode	 	paramMode = RT_PARAM_INVALID;
1865 	sal_Bool 		bWithRuntimeException = sal_True;
1866 
1867 	sal_uInt32 absoluteIndex = index;
1868 
1869 	if (m_hasMethods)
1870 	{
1871 		o << "\n" << indent() << "typelib_InterfaceMethodTypeDescription * pMethod = 0;\n";
1872 
1873 		for (sal_uInt16 i=0; i < methodCount; i++)
1874 		{
1875             methodMode = m_reader.getMethodFlags(i);
1876             if (methodMode == RT_MODE_ATTRIBUTE_GET
1877                 || methodMode == RT_MODE_ATTRIBUTE_SET)
1878             {
1879                 continue;
1880             }
1881 
1882 			methodName = rtl::OUStringToOString(
1883                 m_reader.getMethodName(i), RTL_TEXTENCODING_UTF8);
1884 			returnType = checkRealBaseType(
1885                 rtl::OUStringToOString(
1886                     m_reader.getMethodReturnTypeName(i), RTL_TEXTENCODING_UTF8),
1887                 sal_True);
1888 			paramCount = m_reader.getMethodParameterCount(i);
1889 
1890 			if ( methodName.equals("acquire") || methodName.equals("release") )
1891 			{
1892 				bWithRuntimeException = sal_False;
1893 			}
1894 
1895 			o << indent() << "{\n";
1896 			inc();
1897 
1898 			if (paramCount)
1899 			{
1900 				o << indent() << "typelib_Parameter_Init aParameters[" << paramCount << "];\n";
1901 			}
1902 
1903 			sal_uInt16 j;
1904 			for (j=0; j < paramCount; j++)
1905 			{
1906 				paramName =	rtl::OUStringToOString(
1907                     m_reader.getMethodParameterName(i, j),
1908                     RTL_TEXTENCODING_UTF8);
1909 				paramType =	checkRealBaseType(
1910                     rtl::OUStringToOString(
1911                         m_reader.getMethodParameterTypeName(i, j),
1912                         RTL_TEXTENCODING_UTF8),
1913                     sal_True);
1914 				paramMode = m_reader.getMethodParameterFlags(i, j);
1915 
1916 				o << indent() << "::rtl::OUString sParamName" << j << "( RTL_CONSTASCII_USTRINGPARAM(\""
1917 				  << paramName << "\") );\n";
1918 				o << indent() << "::rtl::OUString sParamType" << j << "( RTL_CONSTASCII_USTRINGPARAM(\""
1919 				  << paramType.replace('/', '.') << "\") );\n";
1920 				o << indent() << "aParameters[" << j << "].pParamName = sParamName" << j << ".pData;\n";
1921 				o << indent() << "aParameters[" << j << "].eTypeClass = (typelib_TypeClass)"
1922 				  << getTypeClass(paramType) << ";\n";
1923 				o << indent() << "aParameters[" << j << "].pTypeName = sParamType" << j << ".pData;\n";
1924 
1925 				if (paramMode == RT_PARAM_IN || paramMode == RT_PARAM_INOUT)
1926 					o << indent() << "aParameters[" << j << "].bIn = sal_True;\n";
1927 				else
1928 					o << indent() << "aParameters[" << j << "].bIn = sal_False;\n";
1929 
1930 				if (paramMode == RT_PARAM_OUT || paramMode == RT_PARAM_INOUT)
1931 					o << indent() << "aParameters[" << j << "].bOut = sal_True;\n";
1932 				else
1933 					o << indent() << "aParameters[" << j << "].bOut = sal_False;\n";
1934 			}
1935 
1936             sal_Int32 excCount = dumpExceptionTypeNames(
1937                 o, "", i, bWithRuntimeException);
1938 
1939 			o << indent() << "::rtl::OUString sReturnType" << i << "( RTL_CONSTASCII_USTRINGPARAM(\""
1940 			  << returnType.replace('/', '.') << "\") );\n";
1941 			o << indent() << "typelib_typedescription_newInterfaceMethod( &pMethod,\n";
1942 			inc();
1943 			o << indent() << absoluteIndex++ << ", ";
1944 			if (methodMode == RT_MODE_ONEWAY || methodMode == RT_MODE_ONEWAY_CONST)
1945 				o << "sal_True,\n";
1946 			else
1947 				o << "sal_False,\n";
1948 			o << indent() << "sMethodName" << i << ".pData,\n";
1949 			o << indent() << "(typelib_TypeClass)" << getTypeClass(returnType)
1950 			  << ", sReturnType" << i << ".pData,\n";
1951 			if (paramCount)
1952 				o << indent() << paramCount << ", aParameters,\n";
1953 			else
1954 				o << indent() << "0, 0,\n";
1955             o << indent() << excCount << ", "
1956               << (excCount == 0 ? "0" : "the_Exceptions") << " );\n";
1957 
1958 			dec();
1959 			o << indent() << "typelib_typedescription_register( (typelib_TypeDescription**)&pMethod );\n";
1960 
1961 			dec();
1962 			o << indent() << "}\n";
1963 		}
1964 		o << indent() << "typelib_typedescription_release( (typelib_TypeDescription*)pMethod );\n";
1965 
1966 		index = absoluteIndex;
1967 	}
1968 }
1969 
dumpAttributesCppuDecl(FileStream & o,StringSet * pFinishedTypes,CppuTypeDecl eDeclFlag)1970 void InterfaceType::dumpAttributesCppuDecl(FileStream& o, StringSet* pFinishedTypes, CppuTypeDecl eDeclFlag)
1971 {
1972 	sal_uInt16 fieldCount = m_reader.getFieldCount();
1973 
1974 	RTFieldAccess access = RT_ACCESS_INVALID;
1975 	OString fieldName;
1976 	OString fieldType;
1977 	for (sal_uInt16 i=0; i < fieldCount; i++)
1978 	{
1979 		access = m_reader.getFieldFlags(i);
1980 
1981 		if (access == RT_ACCESS_CONST || access == RT_ACCESS_INVALID)
1982 			continue;
1983 
1984 		fieldName = rtl::OUStringToOString(
1985             m_reader.getFieldName(i), RTL_TEXTENCODING_UTF8);
1986 		fieldType = rtl::OUStringToOString(
1987             m_reader.getFieldTypeName(i), RTL_TEXTENCODING_UTF8);
1988 
1989 		if (pFinishedTypes->count(fieldType) == 0)
1990 		{
1991 			pFinishedTypes->insert(fieldType);
1992 			dumpCppuGetType(o, fieldType, sal_True, eDeclFlag);
1993 		}
1994 	}
1995 }
1996 
dumpMethodsCppuDecl(FileStream & o,StringSet * pFinishedTypes,CppuTypeDecl eDeclFlag)1997 void InterfaceType::dumpMethodsCppuDecl(FileStream& o, StringSet* pFinishedTypes, CppuTypeDecl eDeclFlag)
1998 {
1999 	sal_uInt16 		methodCount = m_reader.getMethodCount();
2000 	OString 		returnType, paramType, excType;
2001 	sal_uInt16 		paramCount = 0;
2002 	sal_uInt16 		excCount = 0;
2003 
2004 	for (sal_uInt16 i=0; i < methodCount; i++)
2005 	{
2006 		returnType = rtl::OUStringToOString(
2007             m_reader.getMethodReturnTypeName(i), RTL_TEXTENCODING_UTF8);
2008 		paramCount = m_reader.getMethodParameterCount(i);
2009 		excCount = m_reader.getMethodExceptionCount(i);
2010 
2011 		if (pFinishedTypes->count(returnType) == 0)
2012 		{
2013 			pFinishedTypes->insert(returnType);
2014 			dumpCppuGetType(o, returnType, sal_True, eDeclFlag);
2015 		}
2016 		sal_uInt16 j;
2017 		for (j=0; j < paramCount; j++)
2018 		{
2019 			paramType =	rtl::OUStringToOString(
2020                 m_reader.getMethodParameterTypeName(i, j),
2021                 RTL_TEXTENCODING_UTF8);
2022 
2023 			if (pFinishedTypes->count(paramType) == 0)
2024 			{
2025 				pFinishedTypes->insert(paramType);
2026 				dumpCppuGetType(o, paramType, sal_True, eDeclFlag);
2027 			}
2028 		}
2029 
2030 		for (j=0; j < excCount; j++)
2031 		{
2032 			excType = rtl::OUStringToOString(
2033                 m_reader.getMethodExceptionTypeName(i, j),
2034                 RTL_TEXTENCODING_UTF8);
2035 			if (pFinishedTypes->count(excType) == 0)
2036 			{
2037 				pFinishedTypes->insert(excType);
2038 				dumpCppuGetType(o, excType, sal_True, eDeclFlag);
2039 			}
2040 		}
2041 	}
2042 }
2043 
dumpExceptionSpecification(FileStream & out,sal_uInt32 methodIndex,bool runtimeException)2044 void InterfaceType::dumpExceptionSpecification(
2045     FileStream & out, sal_uInt32 methodIndex, bool runtimeException)
2046 {
2047     out << " throw (";
2048     bool first = true;
2049     if (methodIndex <= SAL_MAX_UINT16) {
2050         sal_uInt16 count = m_reader.getMethodExceptionCount(
2051             static_cast< sal_uInt16 >(methodIndex));
2052         for (sal_uInt16 i = 0; i < count; ++i) {
2053             rtl::OUString name(
2054                 m_reader.getMethodExceptionTypeName(
2055                     static_cast< sal_uInt16 >(methodIndex), i));
2056             if (!name.equalsAsciiL(
2057                     RTL_CONSTASCII_STRINGPARAM(
2058                         "com/sun/star/uno/RuntimeException")))
2059             {
2060                 if (!first) {
2061                     out << ", ";
2062                 }
2063                 first = false;
2064                 out << scopedCppName(
2065                     rtl::OUStringToOString(name, RTL_TEXTENCODING_UTF8));
2066             }
2067         }
2068     }
2069     if (runtimeException) {
2070         if (!first) {
2071             out << ", ";
2072         }
2073         out << "::com::sun::star::uno::RuntimeException";
2074     }
2075     out << ")";
2076 }
2077 
dumpAttributeExceptionSpecification(FileStream & out,rtl::OUString const & name,RTMethodMode sort)2078 void InterfaceType::dumpAttributeExceptionSpecification(
2079     FileStream & out, rtl::OUString const & name, RTMethodMode sort)
2080 {
2081     sal_uInt16 methodCount = m_reader.getMethodCount();
2082     for (sal_uInt16 i = 0; i < methodCount; ++i) {
2083         if (m_reader.getMethodFlags(i) == sort
2084             && m_reader.getMethodName(i) == name)
2085         {
2086             dumpExceptionSpecification(out, i, true);
2087             return;
2088         }
2089     }
2090     dumpExceptionSpecification(out, 0xFFFFFFFF, true);
2091 }
2092 
dumpExceptionTypeName(FileStream & out,char const * prefix,sal_uInt32 index,rtl::OUString name)2093 void InterfaceType::dumpExceptionTypeName(
2094     FileStream & out, char const * prefix, sal_uInt32 index, rtl::OUString name)
2095 {
2096     out << indent() << "::rtl::OUString the_" << prefix << "ExceptionName"
2097         << index << "(RTL_CONSTASCII_USTRINGPARAM(\""
2098         << rtl::OUStringToOString(name, RTL_TEXTENCODING_UTF8).replace('/', '.')
2099         << "\"));\n";
2100 }
2101 
dumpExceptionTypeNames(FileStream & out,char const * prefix,sal_uInt16 methodIndex,bool runtimeException)2102 sal_Int32 InterfaceType::dumpExceptionTypeNames(
2103     FileStream & out, char const * prefix, sal_uInt16 methodIndex,
2104     bool runtimeException)
2105 {
2106     sal_Int32 count = 0;
2107     sal_uInt16 n = m_reader.getMethodExceptionCount(methodIndex);
2108     for (sal_uInt16 i = 0; i < n; ++i) {
2109         rtl::OUString name(m_reader.getMethodExceptionTypeName(methodIndex, i));
2110         if (!name.equalsAsciiL(
2111                 RTL_CONSTASCII_STRINGPARAM(
2112                     "com/sun/star/uno/RuntimeException")))
2113         {
2114             dumpExceptionTypeName(out, prefix, count++, name);
2115         }
2116     }
2117     if (runtimeException) {
2118         dumpExceptionTypeName(
2119             out, prefix, count++,
2120             rtl::OUString(
2121                 RTL_CONSTASCII_USTRINGPARAM(
2122                     "com/sun/star/uno/RuntimeException")));
2123     }
2124     if (count > 0) {
2125         out << indent() << "rtl_uString * the_" << prefix << "Exceptions[] = {";
2126         for (sal_Int32 i = 0; i < count; ++i) {
2127             out << (i == 0 ? " " : ", ") << "the_" << prefix << "ExceptionName"
2128                 << i << ".pData";
2129         }
2130         out << " };\n";
2131     }
2132     return count;
2133 }
2134 
dumpAttributeExceptionTypeNames(FileStream & out,char const * prefix,rtl::OUString const & name,RTMethodMode sort)2135 sal_Int32 InterfaceType::dumpAttributeExceptionTypeNames(
2136     FileStream & out, char const * prefix, rtl::OUString const & name,
2137     RTMethodMode sort)
2138 {
2139     sal_uInt16 methodCount = m_reader.getMethodCount();
2140     for (sal_uInt16 i = 0; i < methodCount; ++i) {
2141         if (m_reader.getMethodFlags(i) == sort
2142             && m_reader.getMethodName(i) == name)
2143         {
2144             return dumpExceptionTypeNames(out, prefix, i, false);
2145         }
2146     }
2147     return 0;
2148 }
2149 
2150 //*************************************************************************
2151 // ConstantsType
2152 //*************************************************************************
ConstantsType(typereg::Reader & typeReader,const OString & typeName,const TypeManager & typeMgr)2153 ConstantsType::ConstantsType(typereg::Reader& typeReader,
2154                              const OString& typeName,
2155                              const TypeManager& typeMgr)
2156 	: CppuType(typeReader, typeName, typeMgr)
2157 {
2158 }
2159 
~ConstantsType()2160 ConstantsType::~ConstantsType()
2161 {
2162 
2163 }
2164 
dump(CppuOptions * pOptions)2165 sal_Bool ConstantsType::dump(CppuOptions* pOptions)
2166 	throw( CannotDumpException )
2167 {
2168     if (!m_dependencies.isValid()) {
2169         return false;
2170     }
2171     addSpecialDependencies();
2172 
2173 	if (pOptions->isValid("-U"))
2174 		m_cppuTypeDynamic = sal_True;
2175 
2176 	OString outPath;
2177 	if (pOptions->isValid("-O"))
2178 		outPath = pOptions->getOption("-O");
2179 
2180     return dumpFiles(pOptions, outPath);
2181 }
2182 
dumpHFile(FileStream & o,codemaker::cppumaker::Includes & includes)2183 sal_Bool ConstantsType::dumpHFile(
2184     FileStream& o, codemaker::cppumaker::Includes & includes)
2185 	throw( CannotDumpException )
2186 {
2187 	sal_Bool bSpecialDefine = sal_True;
2188 
2189 	if (m_reader.getTypeClass() == RT_TYPE_CONSTANTS)
2190 	{
2191 		bSpecialDefine = sal_False;
2192 	}
2193 
2194 	OString headerDefine(dumpHeaderDefine(o, "HDL", bSpecialDefine));
2195 	o << "\n";
2196 
2197 	addDefaultHIncludes(includes);
2198 	includes.dump(o, 0);
2199 	o << "\n";
2200 
2201     if (codemaker::cppumaker::dumpNamespaceOpen(o, m_typeName, true)) {
2202         o << "\n";
2203     }
2204 	o << "\n";
2205 
2206 	dumpDeclaration(o);
2207 	o << "\n";
2208 
2209     if (codemaker::cppumaker::dumpNamespaceClose(o, m_typeName, true)) {
2210         o << "\n";
2211     }
2212 	o << "\n#endif // "<< headerDefine << "\n";
2213 
2214 	return sal_True;
2215 }
2216 
dumpDeclaration(FileStream & o)2217 sal_Bool ConstantsType::dumpDeclaration(FileStream& o)
2218 	throw( CannotDumpException )
2219 {
2220 	sal_uInt16 		fieldCount = m_reader.getFieldCount();
2221 	OString 		fieldName;
2222 	OString 		fieldType;
2223 	for (sal_uInt16 i=0; i < fieldCount; i++)
2224 	{
2225         fieldName = rtl::OUStringToOString(
2226             m_reader.getFieldName(i), RTL_TEXTENCODING_UTF8);
2227         fieldType = rtl::OUStringToOString(
2228             m_reader.getFieldTypeName(i), RTL_TEXTENCODING_UTF8);
2229 
2230         o << "static const ";
2231         dumpType(o, fieldType);
2232         o << " " << fieldName << " = ";
2233         dumpConstantValue(o, i);
2234         o << ";\n";
2235 	}
2236 
2237 	return sal_True;
2238 }
2239 
hasConstants()2240 sal_Bool ConstantsType::hasConstants()
2241 {
2242 	return m_reader.getFieldCount() > 0;
2243 }
2244 
dumpHxxFile(FileStream & o,codemaker::cppumaker::Includes &)2245 sal_Bool ConstantsType::dumpHxxFile(
2246     FileStream& o, codemaker::cppumaker::Includes &)
2247 	throw( CannotDumpException )
2248 {
2249 	sal_Bool bSpecialDefine = sal_True;
2250 
2251 	if (m_reader.getTypeClass() == RT_TYPE_CONSTANTS)
2252 	{
2253 		bSpecialDefine = sal_False;
2254 	}
2255 
2256 	OString headerDefine(dumpHeaderDefine(o, "HPP", bSpecialDefine));
2257 	o << "\n";
2258 
2259     rtl::OString suffix;
2260     if (bSpecialDefine) {
2261         suffix = m_name;
2262     }
2263     codemaker::cppumaker::Includes::dumpInclude(o, m_typeName, false, suffix);
2264 
2265 	o << "\n#endif // "<< headerDefine << "\n";
2266 
2267 	return sal_True;
2268 }
2269 
2270 //*************************************************************************
2271 // ModuleType
2272 //*************************************************************************
ModuleType(typereg::Reader & typeReader,const OString & typeName,const TypeManager & typeMgr)2273 ModuleType::ModuleType(typereg::Reader& typeReader,
2274                        const OString& typeName,
2275                        const TypeManager& typeMgr)
2276 	: ConstantsType(typeReader, typeName, typeMgr)
2277 {
2278 }
2279 
~ModuleType()2280 ModuleType::~ModuleType()
2281 {
2282 
2283 }
2284 
dumpFiles(CppuOptions * options,rtl::OString const & outPath)2285 bool ModuleType::dumpFiles(
2286     CppuOptions * options, rtl::OString const & outPath)
2287 {
2288     rtl::OString tmpName(m_typeName);
2289     if (tmpName.equals("/")) {
2290         tmpName = "global";
2291     } else {
2292         tmpName += "/" + m_typeName.copy(m_typeName.lastIndexOf('/') + 1);
2293     }
2294     return dumpFile(options, ".hdl", tmpName, outPath)
2295         && dumpFile(options, ".hpp", tmpName, outPath);
2296 }
2297 
2298 //*************************************************************************
2299 // StructureType
2300 //*************************************************************************
2301 
2302 namespace {
2303 
dumpTypeParameterName(FileStream & out,rtl::OString const & name)2304 void dumpTypeParameterName(FileStream & out, rtl::OString const & name) {
2305     // Prefix all type parameters with "typeparam_" to avoid problems when a
2306     // struct member has the same name as a type parameter, as in
2307     // struct<T> { T T; };
2308     out << "typeparam_" << name;
2309 }
2310 
2311 }
2312 
StructureType(typereg::Reader & typeReader,const OString & typeName,const TypeManager & typeMgr)2313 StructureType::StructureType(typereg::Reader& typeReader,
2314 			 				 const OString& typeName,
2315 							 const TypeManager& typeMgr)
2316 	: CppuType(typeReader, typeName, typeMgr)
2317 {
2318 }
2319 
~StructureType()2320 StructureType::~StructureType()
2321 {
2322 
2323 }
2324 
dumpHFile(FileStream & o,codemaker::cppumaker::Includes & includes)2325 sal_Bool StructureType::dumpHFile(
2326     FileStream& o, codemaker::cppumaker::Includes & includes)
2327 	throw( CannotDumpException )
2328 {
2329 	OString headerDefine(dumpHeaderDefine(o, "HDL"));
2330 	o << "\n";
2331 
2332 	addDefaultHIncludes(includes);
2333 	includes.dump(o, 0);
2334 	o << "\n";
2335 
2336     if (codemaker::cppumaker::dumpNamespaceOpen(o, m_typeName, false)) {
2337         o << "\n";
2338     }
2339 
2340 	dumpDeclaration(o);
2341 
2342     if (codemaker::cppumaker::dumpNamespaceClose(o, m_typeName, false)) {
2343         o << "\n";
2344     }
2345 
2346 	o << "\nnamespace com { namespace sun { namespace star { namespace uno {\n"
2347 	  << "class Type;\n} } } }\n\n";
2348 
2349     dumpTemplateHead(o);
2350 	o << "inline const ::com::sun::star::uno::Type& SAL_CALL getCppuType( ";
2351 	dumpType(o, m_typeName, sal_True, sal_False);
2352     dumpTemplateParameters(o);
2353 	o << "* );\n\n";
2354 
2355 	o << "#endif // "<< headerDefine << "\n";
2356 
2357 	return sal_True;
2358 }
2359 
dumpDeclaration(FileStream & o)2360 sal_Bool StructureType::dumpDeclaration(FileStream& o)
2361 	throw( CannotDumpException )
2362 {
2363 	o << "\n#ifdef SAL_W32\n"
2364 	  << "#   pragma pack(push, 8)\n"
2365 	  << "#elif defined(SAL_OS2)\n"
2366 	  << "#   pragma pack(8)\n"
2367 	  << "#endif\n\n";
2368 
2369     OSL_ASSERT(!isPolymorphic() || m_reader.getSuperTypeCount() == 0); //TODO
2370     o << indent();
2371     dumpTemplateHead(o);
2372     o << "struct " << m_name;
2373     rtl::OString base;
2374     if (m_reader.getSuperTypeCount() != 0) {
2375         base = rtl::OUStringToOString(
2376             m_reader.getSuperTypeName(0), RTL_TEXTENCODING_UTF8);
2377         OSL_ASSERT( !base.isEmpty() ); //TODO
2378     }
2379     if ( !base.isEmpty() ) {
2380         o << ": public " << scopedCppName(base);
2381     }
2382     o << " {\n";
2383     inc();
2384     o << indent() << "inline " << m_name << "() SAL_THROW(());\n";
2385     sal_uInt16 members = m_reader.getFieldCount();
2386     if (members > 0 || getInheritedMemberCount() > 0) {
2387         o << "\n" << indent() << "inline " << m_name << "(";
2388         bool prev = dumpSuperMember(o, base, true);
2389         for (sal_uInt16 i = 0; i < members; ++i) {
2390             if (prev) {
2391                 o << ", ";
2392             }
2393             prev = true;
2394             rtl::OString type(
2395                 rtl::OUStringToOString(
2396                     m_reader.getFieldTypeName(i), RTL_TEXTENCODING_UTF8));
2397             if ((m_reader.getFieldFlags(i) & RT_ACCESS_PARAMETERIZED_TYPE) != 0)
2398             {
2399                 dumpTypeParameterName(o, type);
2400                 o << " const &";
2401             } else {
2402                 dumpType(o, type, true, true);
2403             }
2404             o << " "
2405               << rtl::OUStringToOString(
2406                   m_reader.getFieldName(i), RTL_TEXTENCODING_UTF8)
2407               << "_";
2408         }
2409         o << ") SAL_THROW(());\n";
2410     }
2411     if (members > 0) {
2412         o << "\n";
2413         for (sal_uInt16 i = 0; i < members; ++i) {
2414             o << indent();
2415             bool parameterized
2416                 = ((m_reader.getFieldFlags(i) & RT_ACCESS_PARAMETERIZED_TYPE)
2417                    != 0);
2418             rtl::OString type(
2419                 rtl::OUStringToOString(
2420                     m_reader.getFieldTypeName(i), RTL_TEXTENCODING_UTF8));
2421             if (parameterized) {
2422                 dumpTypeParameterName(o, type);
2423             } else {
2424                 dumpType(o, type);
2425             }
2426             o << " "
2427                 << rtl::OUStringToOString(
2428                     m_reader.getFieldName(i), RTL_TEXTENCODING_UTF8);
2429             if (i == 0 && !base.isEmpty() && type != "double"
2430                 && type != "hyper" && type != "unsigned hyper")
2431             {
2432                 OSL_ASSERT(!parameterized);
2433                 o << " CPPU_GCC3_ALIGN(" << scopedCppName(base) << ")";
2434             }
2435             o << ";\n";
2436         }
2437     }
2438     dec();
2439     o << "};\n\n";
2440 
2441 	o << "#ifdef SAL_W32\n"
2442 	  << "#   pragma pack(pop)\n"
2443 	  << "#elif defined(SAL_OS2)\n"
2444 	  << "#   pragma pack()\n"
2445 	  << "#endif\n\n";
2446 
2447 	return sal_True;
2448 }
2449 
dumpHxxFile(FileStream & o,codemaker::cppumaker::Includes & includes)2450 sal_Bool StructureType::dumpHxxFile(
2451     FileStream& o, codemaker::cppumaker::Includes & includes)
2452 	throw( CannotDumpException )
2453 {
2454 	OString headerDefine(dumpHeaderDefine(o, "HPP"));
2455 	o << "\n";
2456 
2457     includes.dump(o, &m_typeName);
2458     o << "\n";
2459 
2460     if (codemaker::cppumaker::dumpNamespaceOpen(o, m_typeName, false)) {
2461         o << "\n";
2462     }
2463 	o << "\n";
2464 
2465     dumpTemplateHead(o);
2466 	o << "inline " << m_name;
2467     dumpTemplateParameters(o);
2468     o << "::" << m_name << "() SAL_THROW( () )\n";
2469 	inc();
2470 	OString superType;
2471     if (m_reader.getSuperTypeCount() >= 1) {
2472         superType = rtl::OUStringToOString(
2473             m_reader.getSuperTypeName(0), RTL_TEXTENCODING_UTF8);
2474     }
2475 	sal_Bool first = sal_True;
2476 	if ( !superType.isEmpty() )
2477 	{
2478 		o << indent() << ": " << scopedCppName(superType) << "()\n";
2479 		first = sal_False;
2480 	}
2481 
2482 	sal_uInt16 		fieldCount = m_reader.getFieldCount();
2483 	RTFieldAccess 	access = RT_ACCESS_INVALID;
2484 	OString 		fieldName;
2485 	OString 		fieldType;
2486 
2487 	for (sal_uInt16 i=0; i < fieldCount; i++)
2488 	{
2489 		access = m_reader.getFieldFlags(i);
2490 
2491 		if (access == RT_ACCESS_CONST || access == RT_ACCESS_INVALID)
2492 			continue;
2493 
2494 		fieldName = rtl::OUStringToOString(
2495             m_reader.getFieldName(i), RTL_TEXTENCODING_UTF8);
2496 
2497 		if (first)
2498 		{
2499 			first = sal_False;
2500 			o << indent() << ": ";
2501 		} else
2502 			o << indent() << ", ";
2503 
2504 		o << fieldName;
2505         dumpInitializer(
2506             o, (access & RT_ACCESS_PARAMETERIZED_TYPE) != 0,
2507             m_reader.getFieldTypeName(i));
2508         o << "\n";
2509 	}
2510 	dec();
2511 	o << "{\n}\n\n";
2512 
2513 	if (fieldCount > 0 || getInheritedMemberCount() > 0)
2514 	{
2515         dumpTemplateHead(o);
2516 		o << "inline " << m_name;
2517         dumpTemplateParameters(o);
2518         o << "::" << m_name << "(";
2519 
2520 		sal_Bool superHasMember = dumpSuperMember(o, superType, sal_True);
2521 
2522 		for (sal_uInt16 i=0; i < fieldCount; i++)
2523 		{
2524 			access = m_reader.getFieldFlags(i);
2525 
2526 			if (access == RT_ACCESS_CONST || access == RT_ACCESS_INVALID)
2527 				continue;
2528 
2529 			fieldName = rtl::OUStringToOString(
2530                 m_reader.getFieldName(i), RTL_TEXTENCODING_UTF8);
2531 			fieldType = rtl::OUStringToOString(
2532                 m_reader.getFieldTypeName(i), RTL_TEXTENCODING_UTF8);
2533 
2534 			if (superHasMember)
2535 				o << ", ";
2536 			else
2537 				superHasMember = sal_True;
2538 
2539             if ((access & RT_ACCESS_PARAMETERIZED_TYPE) != 0) {
2540                 dumpTypeParameterName(o, fieldType);
2541                 o << " const &";
2542             } else {
2543                 dumpType(o, fieldType, sal_True, sal_True);
2544             }
2545 //			o << " __" << fieldName;
2546 			o << " " << fieldName << "_";
2547 		}
2548 		o << ") SAL_THROW( () )\n";
2549 
2550 		inc();
2551         first = sal_True;
2552 		if ( !superType.isEmpty() )
2553 		{
2554 			o << indent() << ": " << scopedCppName(superType) << "(";
2555 			dumpSuperMember(o, superType, sal_False);
2556 			o << ")\n";
2557 			first = sal_False;
2558 		}
2559 
2560 		for (sal_uInt16 i=0; i < fieldCount; i++)
2561 		{
2562 			access = m_reader.getFieldFlags(i);
2563 
2564 			if (access == RT_ACCESS_CONST || access == RT_ACCESS_INVALID)
2565 				continue;
2566 
2567 			fieldName = rtl::OUStringToOString(
2568                 m_reader.getFieldName(i), RTL_TEXTENCODING_UTF8);
2569 
2570 			if (first)
2571 			{
2572 				first = sal_False;
2573 				o << indent() << ": ";
2574 			} else
2575 				o << indent() << ", ";
2576 
2577 //			o << fieldName << "(__" << fieldName << ")\n";
2578 			o << fieldName << "(" << fieldName << "_)\n";
2579 		}
2580 
2581 		dec();
2582 		o << "{\n}\n\n";
2583 	}
2584 
2585     if (isPolymorphic() && fieldCount > 0) {
2586         o << indent();
2587         dumpTemplateHead(o);
2588         o << "\n";
2589         o << indent();
2590         o << "inline " << m_name;
2591         dumpTemplateParameters(o);
2592         o << "\n";
2593         o << indent();
2594         o << "make_" << m_name << "(";
2595         for (sal_uInt16 i = 0; i < fieldCount; ++i) {
2596             if (i > 0) {
2597                 o << ", ";
2598             }
2599             rtl::OString type(
2600                 rtl::OUStringToOString(
2601                     m_reader.getFieldTypeName(i), RTL_TEXTENCODING_UTF8));
2602             if ((m_reader.getFieldFlags(i) & RT_ACCESS_PARAMETERIZED_TYPE) != 0)
2603             {
2604                 dumpTypeParameterName(o, type);
2605                 o << " const &";
2606             } else {
2607                 dumpType(o, type, true, true);
2608             }
2609             o << " "
2610               << rtl::OUStringToOString(
2611                   m_reader.getFieldName(i), RTL_TEXTENCODING_UTF8)
2612               << "_";
2613         }
2614         o << ") SAL_THROW(())\n";
2615         o << indent() << "{\n";
2616         inc();
2617         o << indent() << "return " << m_name;
2618         dumpTemplateParameters(o);
2619         o << "(";
2620         for (sal_uInt16 i = 0; i < fieldCount; ++i) {
2621             if (i > 0) {
2622                 o << ", ";
2623             }
2624             o << rtl::OUStringToOString(
2625                   m_reader.getFieldName(i), RTL_TEXTENCODING_UTF8)
2626               << "_";
2627         }
2628         o << ");\n";
2629         dec();
2630         o << indent() << "}\n\n";
2631     }
2632 
2633     if (codemaker::cppumaker::dumpNamespaceClose(o, m_typeName, false)) {
2634         o << "\n";
2635     }
2636 
2637 	o << "\n";
2638 	dumpGetCppuType(o);
2639 
2640 	o << "\n#endif // "<< headerDefine << "\n";
2641 
2642 	return sal_True;
2643 }
2644 
dumpLightGetCppuType(FileStream & out)2645 void StructureType::dumpLightGetCppuType(FileStream & out) {
2646     dumpGetCppuTypePreamble(out);
2647     out << indent()
2648         << ("//TODO: On certain platforms with weak memory models, the"
2649             " following code can result in some threads observing that the_type"
2650             " points to garbage\n")
2651         << indent()
2652         << "static ::typelib_TypeDescriptionReference * the_type = 0;\n"
2653         << indent() << "if (the_type == 0) {\n";
2654     inc();
2655     if (isPolymorphic()) {
2656         out << indent() << "::rtl::OStringBuffer the_buffer(\""
2657             << m_typeName.replace('/', '.') << "<\");\n";
2658         sal_uInt16 n = m_reader.getReferenceCount();
2659         for (sal_uInt16 i = 0; i < n; ++i) {
2660             out << indent()
2661                 << ("the_buffer.append(::rtl::OUStringToOString("
2662                     "::cppu::getTypeFavourChar(static_cast< ");
2663             dumpTypeParameterName(
2664                 out,
2665                 rtl::OUStringToOString(
2666                     m_reader.getReferenceTypeName(i), RTL_TEXTENCODING_UTF8));
2667             out << " * >(0)).getTypeName(), RTL_TEXTENCODING_UTF8));\n";
2668             if (i != n - 1) {
2669                 out << indent() << "the_buffer.append(',');\n";
2670             }
2671         }
2672         out << indent() << "the_buffer.append('>');\n";
2673     }
2674     out << indent() << "::typelib_static_type_init(&the_type, "
2675         << getTypeClass(m_typeName, true) << ", ";
2676     if (isPolymorphic()) {
2677         out << "the_buffer.getStr()";
2678     } else {
2679         out << "\"" << m_typeName.replace('/', '.') << "\"";
2680     }
2681     out << ");\n";
2682     dec();
2683     out << indent() << "}\n" << indent()
2684         << ("return *reinterpret_cast< ::com::sun::star::uno::Type * >("
2685             "&the_type);\n");
2686     dumpGetCppuTypePostamble(out);
2687 }
2688 
dumpNormalGetCppuType(FileStream & out)2689 void StructureType::dumpNormalGetCppuType(FileStream & out) {
2690     dumpGetCppuTypePreamble(out);
2691     out << indent()
2692         << ("//TODO: On certain platforms with weak memory models, the"
2693             " following code can result in some threads observing that the_type"
2694             " points to garbage\n")
2695         << indent()
2696         << "static ::typelib_TypeDescriptionReference * the_type = 0;\n"
2697         << indent() << "if (the_type == 0) {\n";
2698     inc();
2699     if (isPolymorphic()) {
2700         out << indent() << "::rtl::OStringBuffer the_buffer(\""
2701             << m_typeName.replace('/', '.') << "<\");\n";
2702         sal_uInt16 n = m_reader.getReferenceCount();
2703         for (sal_uInt16 i = 0; i < n; ++i) {
2704             out << indent()
2705                 << ("the_buffer.append(::rtl::OUStringToOString("
2706                     "::cppu::getTypeFavourChar(static_cast< ");
2707             dumpTypeParameterName(
2708                 out,
2709                 rtl::OUStringToOString(
2710                     m_reader.getReferenceTypeName(i), RTL_TEXTENCODING_UTF8));
2711             out << " * >(0)).getTypeName(), RTL_TEXTENCODING_UTF8));\n";
2712             if (i != n - 1) {
2713                 out << indent() << "the_buffer.append(',');\n";
2714             }
2715         }
2716         out << indent() << "the_buffer.append('>');\n";
2717     }
2718     out << indent()
2719         << "::typelib_TypeDescriptionReference * the_members[] = {\n";
2720     inc();
2721     sal_uInt16 fields = m_reader.getFieldCount();
2722     for (sal_uInt16 i = 0; i < fields; ++i) {
2723         out << indent();
2724         rtl::OString type(
2725             rtl::OUStringToOString(
2726                 m_reader.getFieldTypeName(i), RTL_TEXTENCODING_UTF8));
2727         if ((m_reader.getFieldFlags(i) & RT_ACCESS_PARAMETERIZED_TYPE) != 0) {
2728             out << "::cppu::getTypeFavourChar(static_cast< ";
2729             dumpTypeParameterName(out, type);
2730 			out << " * >(0))";
2731         } else {
2732 			out << "::cppu::UnoType< ";
2733             dumpType(out, type, false, false, false, true);
2734 			out << " >::get()";
2735         }
2736         out << ".getTypeLibType()" << (i == fields - 1 ? " };" : ",")
2737             << "\n";
2738     }
2739     dec();
2740     if (isPolymorphic()) {
2741         out << indent()
2742             << "static ::sal_Bool const the_parameterizedTypes[] = { ";
2743         for (sal_uInt16 i = 0; i < fields; ++i) {
2744             if (i != 0) {
2745                 out << ", ";
2746             }
2747             out << (((m_reader.getFieldFlags(i) & RT_ACCESS_PARAMETERIZED_TYPE)
2748                      == 0)
2749                     ? "false" : "true");
2750         }
2751         out << " };\n";
2752     }
2753     out << indent() << "::typelib_static_struct_type_init(&the_type, ";
2754     if (isPolymorphic()) {
2755         out << "the_buffer.getStr()";
2756     } else {
2757         out << "\"" << m_typeName.replace('/', '.') << "\"";
2758     }
2759     out << ", ";
2760     if (m_reader.getSuperTypeCount() == 0) {
2761         out << "0";
2762     } else {
2763         out << "::cppu::UnoType< ";
2764         dumpType(
2765             out,
2766             rtl::OUStringToOString(
2767                 m_reader.getSuperTypeName(0), RTL_TEXTENCODING_UTF8),
2768             false, false, false, true);
2769         out << " >::get().getTypeLibType()";
2770     }
2771     out << ", " << fields << ", the_members, "
2772         << (isPolymorphic() ? "the_parameterizedTypes" : "0") << ");\n";
2773     dec();
2774     out << indent() << "}\n" << indent()
2775         << ("return *reinterpret_cast< ::com::sun::star::uno::Type * >("
2776             "&the_type);\n");
2777     dumpGetCppuTypePostamble(out);
2778 }
2779 
dumpComprehensiveGetCppuType(FileStream & out)2780 void StructureType::dumpComprehensiveGetCppuType(FileStream & out) {
2781     dumpGetCppuTypePreamble(out);
2782     out << indent() << "static ::com::sun::star::uno::Type * the_pType = 0;\n"
2783         << indent() << "if (the_pType == 0) {\n";
2784     inc();
2785     out << indent()
2786         << "::osl::MutexGuard the_guard(::osl::Mutex::getGlobalMutex());\n"
2787         << indent() << "if (the_pType == 0) {\n";
2788     inc();
2789     if (isPolymorphic()) {
2790         out << indent() << "::rtl::OUStringBuffer the_buffer;\n" << indent()
2791             << "the_buffer.appendAscii(RTL_CONSTASCII_STRINGPARAM(\""
2792             << m_typeName.replace('/', '.') << "<\"));\n";
2793         sal_uInt16 n = m_reader.getReferenceCount();
2794         for (sal_uInt16 i = 0; i < n; ++i) {
2795             out << indent()
2796                 << "the_buffer.append(::cppu::getTypeFavourChar(static_cast< ";
2797             dumpTypeParameterName(
2798                 out,
2799                 rtl::OUStringToOString(
2800                     m_reader.getReferenceTypeName(i), RTL_TEXTENCODING_UTF8));
2801             out << " * >(0)).getTypeName());\n";
2802             if (i != n - 1) {
2803                 out << indent()
2804                     << ("the_buffer.append("
2805                         "static_cast< ::sal_Unicode >(','));\n");
2806             }
2807         }
2808         out << indent()
2809             << "the_buffer.append(static_cast< ::sal_Unicode >('>'));\n"
2810             << indent()
2811             << "::rtl::OUString the_name(the_buffer.makeStringAndClear());\n";
2812     } else {
2813         out << indent()
2814             << "::rtl::OUString the_name(RTL_CONSTASCII_USTRINGPARAM(\""
2815             << m_typeName.replace('/', '.') << "\"));\n";
2816     }
2817     sal_uInt16 fields = m_reader.getFieldCount();
2818     typedef std::map< rtl::OString, sal_uInt32 > Map;
2819     Map parameters;
2820     Map types;
2821     {for (sal_uInt16 i = 0; i < fields; ++i) {
2822         rtl::OString type(
2823             rtl::OUStringToOString(
2824                 m_reader.getFieldTypeName(i), RTL_TEXTENCODING_UTF8));
2825         if ((m_reader.getFieldFlags(i) & RT_ACCESS_PARAMETERIZED_TYPE) != 0) {
2826             if (parameters.insert(
2827                     Map::value_type(
2828                         type, static_cast< sal_uInt32 >(parameters.size()))).
2829                 second)
2830             {
2831                 sal_uInt32 n = static_cast< sal_uInt32 >(parameters.size() - 1);
2832                 out << indent()
2833                     << "::com::sun::star::uno::Type const & the_ptype" << n
2834                     << " = ::cppu::getTypeFavourChar(static_cast< ";
2835                 dumpTypeParameterName(out, type);
2836                 out << " * >(0));\n" << indent()
2837                     << "::typelib_TypeClass the_pclass" << n
2838                     << " = (::typelib_TypeClass) the_ptype" << n
2839                     << ".getTypeClass();\n" << indent()
2840                     << "::rtl::OUString the_pname" << n << "(the_ptype" << n
2841                     << ".getTypeName());\n";
2842             }
2843         } else if (types.insert(
2844                        Map::value_type(
2845                            type, static_cast< sal_uInt32 >(types.size()))).
2846                    second)
2847         {
2848             if ((codemaker::UnoType::getSort(type) ==
2849                  codemaker::UnoType::SORT_COMPLEX) &&
2850                 codemaker::UnoType::decompose(type) != m_typeName)
2851                     // take care of recursion like struct S { sequence<S> x; };
2852             {
2853                 out << indent() << "::cppu::UnoType< ";
2854                 dumpType(out, type, false, false, false, true);
2855                 out << " >::get();\n";
2856             }
2857             // For typedefs, use the resolved type name, as there will be no
2858             // information available about the typedef itself at runtime (the
2859             // above getCppuType call will make available information about the
2860             // resolved type); no extra #include for the resolved type is
2861             // needed, as the header for the typedef includes it already:
2862             out << indent() << "::rtl::OUString the_tname"
2863                 << static_cast< sal_uInt32 >(types.size() - 1)
2864                 << "(RTL_CONSTASCII_USTRINGPARAM(\""
2865                 << checkRealBaseType(type, true).replace('/', '.') << "\"));\n";
2866         }
2867         out << indent() << "::rtl::OUString the_name" << i
2868             << "(RTL_CONSTASCII_USTRINGPARAM(\""
2869             << rtl::OUStringToOString(
2870                 m_reader.getFieldName(i), RTL_TEXTENCODING_UTF8).replace(
2871                     '/', '.')
2872             << "\"));\n";
2873     }}
2874     out << indent() << "::typelib_StructMember_Init the_members[] = {\n";
2875     inc();
2876     {for (sal_uInt16 i = 0; i < fields; ++i) {
2877         out << indent() << "{ { ";
2878         rtl::OString type(
2879             rtl::OUStringToOString(
2880                 m_reader.getFieldTypeName(i), RTL_TEXTENCODING_UTF8));
2881         if ((m_reader.getFieldFlags(i) & RT_ACCESS_PARAMETERIZED_TYPE) != 0) {
2882             sal_uInt32 n = parameters.find(type)->second;
2883             out << "the_pclass" << n << ", the_pname" << n << ".pData";
2884         } else {
2885             out << getTypeClass(type, true) << ", the_tname"
2886                 << types.find(type)->second << ".pData";
2887         }
2888         out << ", the_name" << i << ".pData }, "
2889             << ((m_reader.getFieldFlags(i) & RT_ACCESS_PARAMETERIZED_TYPE) == 0
2890                 ? "false" : "true")
2891             << " }" << (i == fields - 1 ? " };" : ",") << "\n";
2892     }}
2893     dec();
2894     out << indent() << "::typelib_TypeDescription * the_newType = 0;\n";
2895     out << indent()
2896         << "::typelib_typedescription_newStruct(&the_newType, the_name.pData, ";
2897     if (m_reader.getSuperTypeCount() == 0) {
2898         out << "0";
2899     } else {
2900         out << "::cppu::UnoType< ";
2901         dumpType(
2902             out,
2903             rtl::OUStringToOString(
2904                 m_reader.getSuperTypeName(0), RTL_TEXTENCODING_UTF8),
2905             false, false, false, true);
2906         out << " >::get().getTypeLibType()";
2907     }
2908     out << ", " << fields << ", the_members);\n";
2909     out << indent() << "::typelib_typedescription_register(&the_newType);\n";
2910     out << indent() << "::typelib_typedescription_release(the_newType);\n";
2911     out << indent() << "static ::com::sun::star::uno::Type the_staticType("
2912         << getTypeClass(m_typeName) << ", the_name);\n";
2913     out << indent() << "OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER();\n";
2914     out << indent() << "the_pType = &the_staticType;\n";
2915     dec();
2916     out << indent() << "}\n";
2917     dec();
2918     out << indent() << "} else {\n";
2919     inc();
2920     out << indent() << "OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER();\n";
2921     dec();
2922     out << indent() << "}\n" << indent() << "return *the_pType;\n";
2923     dumpGetCppuTypePostamble(out);
2924 }
2925 
dumpSuperMember(FileStream & o,const OString & superType,sal_Bool bWithType)2926 sal_Bool StructureType::dumpSuperMember(FileStream& o, const OString& superType, sal_Bool bWithType)
2927 {
2928 	sal_Bool hasMember = sal_False;
2929 
2930 	if ( !superType.isEmpty() )
2931 	{
2932 		typereg::Reader aSuperReader(m_typeMgr.getTypeReader(superType));
2933 
2934 		if (aSuperReader.isValid())
2935 		{
2936             rtl::OString superSuper;
2937             if (aSuperReader.getSuperTypeCount() >= 1) {
2938                 superSuper = rtl::OUStringToOString(
2939                     aSuperReader.getSuperTypeName(0), RTL_TEXTENCODING_UTF8);
2940             }
2941 			hasMember = dumpSuperMember(o, superSuper, bWithType);
2942 
2943 			sal_uInt16 		fieldCount = aSuperReader.getFieldCount();
2944 			RTFieldAccess 	access = RT_ACCESS_INVALID;
2945 			OString 		fieldName;
2946 			OString 		fieldType;
2947 			for (sal_uInt16 i=0; i < fieldCount; i++)
2948 			{
2949 				access = aSuperReader.getFieldFlags(i);
2950 
2951 				if (access == RT_ACCESS_CONST || access == RT_ACCESS_INVALID)
2952 					continue;
2953 
2954 				fieldName = rtl::OUStringToOString(
2955                     aSuperReader.getFieldName(i), RTL_TEXTENCODING_UTF8);
2956 				fieldType = rtl::OUStringToOString(
2957                     aSuperReader.getFieldTypeName(i), RTL_TEXTENCODING_UTF8);
2958 
2959 				if (hasMember)
2960 				{
2961 					o << ", ";
2962 				} else
2963 				{
2964 					hasMember = (fieldCount > 0);
2965 				}
2966 
2967 				if (bWithType)
2968 				{
2969 					dumpType(o, fieldType, sal_True, sal_True);
2970 					o << " ";
2971 				}
2972 //				o << "__" << fieldName;
2973 				o << fieldName << "_";
2974 			}
2975 		}
2976 	}
2977 
2978 	return hasMember;
2979 }
2980 
addLightGetCppuTypeIncludes(codemaker::cppumaker::Includes & includes) const2981 void StructureType::addLightGetCppuTypeIncludes(
2982     codemaker::cppumaker::Includes & includes) const
2983 {
2984     includes.addType();
2985     includes.addCppuUnotypeHxx();
2986     includes.addSalTypesH();
2987     includes.addTypelibTypeclassH();
2988     includes.addTypelibTypedescriptionH();
2989     if (isPolymorphic()) {
2990         includes.addRtlStrbufHxx();
2991         includes.addRtlTextencH();
2992         includes.addRtlUstringHxx();
2993     }
2994 }
2995 
addNormalGetCppuTypeIncludes(codemaker::cppumaker::Includes & includes) const2996 void StructureType::addNormalGetCppuTypeIncludes(
2997     codemaker::cppumaker::Includes & includes) const
2998 {
2999     includes.addType();
3000     includes.addCppuUnotypeHxx();
3001     includes.addSalTypesH();
3002     includes.addTypelibTypeclassH();
3003     includes.addTypelibTypedescriptionH();
3004     if (isPolymorphic()) {
3005         includes.addRtlStrbufHxx();
3006         includes.addRtlTextencH();
3007         includes.addRtlUstringHxx();
3008     }
3009 }
3010 
addComprehensiveGetCppuTypeIncludes(codemaker::cppumaker::Includes & includes) const3011 void StructureType::addComprehensiveGetCppuTypeIncludes(
3012     codemaker::cppumaker::Includes & includes) const
3013 {
3014     includes.addType();
3015     includes.addCppuUnotypeHxx();
3016     includes.addOslDoublecheckedlockingH();
3017     includes.addOslMutexHxx();
3018     includes.addRtlUstringH();
3019     includes.addRtlUstringHxx();
3020     includes.addSalTypesH();
3021     includes.addTypelibTypeclassH();
3022     includes.addTypelibTypedescriptionH();
3023     if (isPolymorphic()) {
3024         includes.addRtlStringH();
3025         includes.addRtlUstrbufHxx();
3026     }
3027 }
3028 
isPolymorphic() const3029 bool StructureType::isPolymorphic() const {
3030     return m_reader.getReferenceCount() > 0;
3031 }
3032 
dumpTemplateHead(FileStream & out) const3033 void StructureType::dumpTemplateHead(FileStream & out) const {
3034     if (isPolymorphic()) {
3035         out << "template< ";
3036         for (sal_uInt16 i = 0; i < m_reader.getReferenceCount(); ++i) {
3037             if (i != 0) {
3038                 out << ", ";
3039             }
3040             OSL_ASSERT(
3041                 m_reader.getReferenceFlags(i) == RT_ACCESS_INVALID
3042                 && m_reader.getReferenceSort(i) == RT_REF_TYPE_PARAMETER);
3043             out << "typename ";
3044             dumpTypeParameterName(
3045                 out,
3046                 rtl::OUStringToOString(
3047                     m_reader.getReferenceTypeName(i), RTL_TEXTENCODING_UTF8));
3048         }
3049         out << " > ";
3050     }
3051 }
3052 
dumpTemplateParameters(FileStream & out) const3053 void StructureType::dumpTemplateParameters(FileStream & out) const {
3054     if (isPolymorphic()) {
3055         out << "< ";
3056         for (sal_uInt16 i = 0; i < m_reader.getReferenceCount(); ++i) {
3057             if (i != 0) {
3058                 out << ", ";
3059             }
3060             OSL_ASSERT(
3061                 m_reader.getReferenceFlags(i) == RT_ACCESS_INVALID
3062                 && m_reader.getReferenceSort(i) == RT_REF_TYPE_PARAMETER);
3063             dumpTypeParameterName(
3064                 out,
3065                 rtl::OUStringToOString(
3066                     m_reader.getReferenceTypeName(i), RTL_TEXTENCODING_UTF8));
3067         }
3068         out << " >";
3069     }
3070 }
3071 
3072 //*************************************************************************
3073 // ExceptionType
3074 //*************************************************************************
ExceptionType(typereg::Reader & typeReader,const OString & typeName,const TypeManager & typeMgr)3075 ExceptionType::ExceptionType(typereg::Reader& typeReader,
3076 			 				 const OString& typeName,
3077 							 const TypeManager& typeMgr)
3078 	: CppuType(typeReader, typeName, typeMgr)
3079 {
3080 }
3081 
~ExceptionType()3082 ExceptionType::~ExceptionType()
3083 {
3084 
3085 }
3086 
dumpHFile(FileStream & o,codemaker::cppumaker::Includes & includes)3087 sal_Bool ExceptionType::dumpHFile(
3088     FileStream& o, codemaker::cppumaker::Includes & includes)
3089 	throw( CannotDumpException )
3090 {
3091 	OString headerDefine(dumpHeaderDefine(o, "HDL"));
3092 	o << "\n";
3093 
3094 	addDefaultHIncludes(includes);
3095 	includes.dump(o, 0);
3096 	o << "\n";
3097 
3098     if (codemaker::cppumaker::dumpNamespaceOpen(o, m_typeName, false)) {
3099         o << "\n";
3100     }
3101 
3102 	dumpDeclaration(o);
3103 
3104     if (codemaker::cppumaker::dumpNamespaceClose(o, m_typeName, false)) {
3105         o << "\n";
3106     }
3107 
3108 	o << "\nnamespace com { namespace sun { namespace star { namespace uno {\n"
3109 	  << "class Type;\n} } } }\n\n";
3110 
3111 	o << "inline const ::com::sun::star::uno::Type& SAL_CALL getCppuType( ";
3112 	dumpType(o, m_typeName, sal_True, sal_False);
3113 	o << "* ) SAL_THROW( () );\n\n";
3114 
3115 	o << "#endif // "<< headerDefine << "\n";
3116 
3117 	return sal_True;
3118 }
3119 
dumpDeclaration(FileStream & o)3120 sal_Bool ExceptionType::dumpDeclaration(FileStream& o)
3121 	throw( CannotDumpException )
3122 {
3123 	o << "\nclass CPPU_GCC_DLLPUBLIC_EXPORT " << m_name;
3124 
3125 	OString superType;
3126     if (m_reader.getSuperTypeCount() >= 1) {
3127         superType = rtl::OUStringToOString(
3128             m_reader.getSuperTypeName(0), RTL_TEXTENCODING_UTF8);
3129     }
3130 	if ( !superType.isEmpty() )
3131 					o << " : public " << scopedCppName(superType);
3132 
3133 	o << "\n{\npublic:\n";
3134 	inc();
3135 	o << indent() << "inline CPPU_GCC_DLLPRIVATE " << m_name
3136       << "() SAL_THROW( () );\n\n";
3137 
3138 	sal_uInt16 		fieldCount = m_reader.getFieldCount();
3139 	RTFieldAccess 	access = RT_ACCESS_INVALID;
3140 	OString 		fieldName;
3141 	OString 		fieldType;
3142 	sal_uInt16 		i = 0;
3143 
3144 	if (fieldCount > 0 || getInheritedMemberCount() > 0)
3145 	{
3146 		o << indent() << "inline CPPU_GCC_DLLPRIVATE " << m_name << "(";
3147 
3148 		sal_Bool superHasMember = dumpSuperMember(o, superType, sal_True);
3149 
3150 		for (i=0; i < fieldCount; i++)
3151 		{
3152 			access = m_reader.getFieldFlags(i);
3153 
3154 			if (access == RT_ACCESS_CONST || access == RT_ACCESS_INVALID)
3155 							continue;
3156 
3157 			fieldName = rtl::OUStringToOString(
3158                 m_reader.getFieldName(i), RTL_TEXTENCODING_UTF8);
3159 			fieldType = rtl::OUStringToOString(
3160                 m_reader.getFieldTypeName(i), RTL_TEXTENCODING_UTF8);
3161 
3162 			if (superHasMember)
3163 				o << ", ";
3164 			else
3165 				superHasMember = sal_True;
3166 
3167 			dumpType(o, fieldType, sal_True, sal_True);
3168 //			o << " __" << fieldName;
3169 			o << " " << fieldName << "_";
3170 		}
3171 		o << ") SAL_THROW( () );\n\n";
3172 	}
3173     o << indent() << "inline CPPU_GCC_DLLPRIVATE " << m_name << "(" << m_name
3174       << " const &);\n\n"
3175       << indent() << "inline CPPU_GCC_DLLPRIVATE ~" << m_name << "();\n\n"
3176       << indent() << "inline CPPU_GCC_DLLPRIVATE " << m_name << " & operator =("
3177       << m_name << " const &);\n\n";
3178 
3179 	for (i=0; i < fieldCount; i++)
3180 	{
3181 		access = m_reader.getFieldFlags(i);
3182 
3183 		if (access == RT_ACCESS_CONST || access == RT_ACCESS_INVALID)
3184 			continue;
3185 
3186 		fieldName = rtl::OUStringToOString(
3187             m_reader.getFieldName(i), RTL_TEXTENCODING_UTF8);
3188 		fieldType = rtl::OUStringToOString(
3189             m_reader.getFieldTypeName(i), RTL_TEXTENCODING_UTF8);
3190 
3191 		o << indent();
3192 		dumpType(o, fieldType);
3193 		o << " " << fieldName;
3194         if (i == 0 && !superType.isEmpty() &&
3195             !fieldType.equals("double") && !fieldType.equals("hyper") && !fieldType.equals("unsigned hyper"))
3196         {
3197             o << " CPPU_GCC3_ALIGN( " << scopedCppName(superType) << " )";
3198         }
3199         o << ";\n";
3200 	}
3201 
3202 
3203 	dec();
3204 	o << "};\n\n";
3205 
3206 	return sal_True;
3207 }
3208 
dumpHxxFile(FileStream & o,codemaker::cppumaker::Includes & includes)3209 sal_Bool ExceptionType::dumpHxxFile(
3210     FileStream& o, codemaker::cppumaker::Includes & includes)
3211 	throw( CannotDumpException )
3212 {
3213 	OString headerDefine(dumpHeaderDefine(o, "HPP"));
3214 	o << "\n";
3215 
3216 	addDefaultHxxIncludes(includes);
3217 	includes.dump(o, &m_typeName);
3218 	o << "\n";
3219 
3220     if (codemaker::cppumaker::dumpNamespaceOpen(o, m_typeName, false)) {
3221         o << "\n";
3222     }
3223 	o << "\n";
3224 
3225 	o << "inline " << m_name << "::" << m_name << "() SAL_THROW( () )\n";
3226 	inc();
3227 	OString superType;
3228     if (m_reader.getSuperTypeCount() >= 1) {
3229         superType = rtl::OUStringToOString(
3230             m_reader.getSuperTypeName(0), RTL_TEXTENCODING_UTF8);
3231     }
3232 	sal_Bool first = sal_True;
3233 	if ( !superType.isEmpty() )
3234 	{
3235 		o << indent() << ": " << scopedCppName(superType) << "()\n";
3236 		first = sal_False;
3237 	}
3238 
3239 	sal_uInt16 		fieldCount = m_reader.getFieldCount();
3240 	RTFieldAccess 	access = RT_ACCESS_INVALID;
3241 	OString 		fieldName;
3242 	OString 		fieldType;
3243 
3244 	for (sal_uInt16 i=0; i < fieldCount; i++)
3245 	{
3246 		access = m_reader.getFieldFlags(i);
3247 
3248 		if (access == RT_ACCESS_CONST || access == RT_ACCESS_INVALID)
3249 			continue;
3250 
3251 		fieldName = rtl::OUStringToOString(
3252             m_reader.getFieldName(i), RTL_TEXTENCODING_UTF8);
3253 
3254 		if (first)
3255 		{
3256 			first = sal_False;
3257 			o << indent() << ": ";
3258 		} else
3259 			o << indent() << ", ";
3260 
3261 		o << fieldName;
3262         dumpInitializer(o, false, m_reader.getFieldTypeName(i));
3263         o << "\n";
3264 	}
3265 	dec();
3266 	if ( !m_cppuTypeDynamic )
3267 	{
3268 		o << "{\n";
3269 		inc();
3270 		dumpCppuGetType(o, m_typeName, sal_True);
3271 		dec();
3272 		o << "}\n\n";
3273 	} else
3274 	{
3275 		o << "{ }\n\n";
3276 	}
3277 
3278 	if (fieldCount > 0 || getInheritedMemberCount() > 0)
3279 	{
3280 		o << indent() << "inline " << m_name << "::" << m_name << "(";
3281 
3282 		sal_Bool superHasMember = dumpSuperMember(o, superType, sal_True);
3283 
3284 		for (sal_uInt16 i=0; i < fieldCount; i++)
3285 		{
3286 			access = m_reader.getFieldFlags(i);
3287 
3288 			if (access == RT_ACCESS_CONST || access == RT_ACCESS_INVALID)
3289 				continue;
3290 
3291 			fieldName = rtl::OUStringToOString(
3292                 m_reader.getFieldName(i), RTL_TEXTENCODING_UTF8);
3293 			fieldType = rtl::OUStringToOString(
3294                 m_reader.getFieldTypeName(i), RTL_TEXTENCODING_UTF8);
3295 
3296 			if (superHasMember)
3297 				o << ", ";
3298 			else
3299 				superHasMember = sal_True;
3300 
3301 			dumpType(o, fieldType, sal_True, sal_True);
3302 //			o << " __" << fieldName;
3303 			o << " " << fieldName << "_";
3304 		}
3305 		o << ") SAL_THROW( () )\n";
3306 
3307 		inc();
3308         first = sal_True;
3309 		if ( !superType.isEmpty() )
3310 		{
3311 			o << indent() << ": " << scopedCppName(superType) << "(";
3312 			dumpSuperMember(o, superType, sal_False);
3313 			o << ")\n";
3314 			first = sal_False;
3315 		}
3316 
3317 		for (sal_uInt16 i=0; i < fieldCount; i++)
3318 		{
3319 			access = m_reader.getFieldFlags(i);
3320 
3321 			if (access == RT_ACCESS_CONST || access == RT_ACCESS_INVALID)
3322 				continue;
3323 
3324 			fieldName = rtl::OUStringToOString(
3325                 m_reader.getFieldName(i), RTL_TEXTENCODING_UTF8);
3326 
3327 			if (first)
3328 			{
3329 				first = sal_False;
3330 				o << indent() << ": ";
3331 			} else
3332 				o << indent() << ", ";
3333 
3334 //			o << fieldName << "(__" << fieldName << ")\n";
3335 			o << fieldName << "(" << fieldName << "_)\n";
3336 		}
3337 
3338 		dec();
3339 		if ( !m_cppuTypeDynamic )
3340 		{
3341 			o << "{\n";
3342 			inc();
3343 			dumpCppuGetType(o, m_typeName, sal_True);
3344 			dec();
3345 			o << "}\n\n";
3346 		} else
3347 		{
3348 			o << "{ }\n\n";
3349 		}
3350 	}
3351     o << indent() << m_name << "::" << m_name << "(" << m_name
3352       << " const & the_other)";
3353     first = true;
3354     if ( !superType.isEmpty() ) {
3355         o << ": " << scopedCppName(superType) << "(the_other)";
3356         first = false;
3357     }
3358     for (sal_uInt16 i = 0; i < fieldCount; ++i) {
3359         rtl::OString name(
3360             rtl::OUStringToOString(
3361                 m_reader.getFieldName(i), RTL_TEXTENCODING_UTF8));
3362         o << (first ? ": " : ", ") << name << "(the_other." << name << ")";
3363         first = false;
3364     }
3365     o << indent() << " {}\n\n"
3366       << indent() << m_name << "::~" << m_name << "() {}\n\n"
3367       << indent() << m_name << " & " << m_name << "::operator =(" << m_name
3368       << " const & the_other) {\n";
3369     inc();
3370     o << indent()
3371       << ("//TODO: Just like its implicitly-defined counterpart, this function"
3372           " definition is not exception-safe\n");
3373     if ( !superType.isEmpty() ) {
3374         o << indent() << scopedCppName(superType)
3375           << "::operator =(the_other);\n";
3376     }
3377     for (sal_uInt16 i = 0; i < fieldCount; ++i) {
3378         rtl::OString name(
3379             rtl::OUStringToOString(
3380                 m_reader.getFieldName(i), RTL_TEXTENCODING_UTF8));
3381         o << indent() << name << " = the_other." << name << ";\n";
3382     }
3383     o << indent() << "return *this;\n";
3384     dec();
3385     o << indent() << "}\n\n";
3386 
3387     if (codemaker::cppumaker::dumpNamespaceClose(o, m_typeName, false)) {
3388         o << "\n";
3389     }
3390 
3391 	o << "\n";
3392 	dumpGetCppuType(o);
3393 
3394 	o << "\n#endif // "<< headerDefine << "\n";
3395 	return sal_True;
3396 }
3397 
dumpSuperMember(FileStream & o,const OString & superType,sal_Bool bWithType)3398 sal_Bool ExceptionType::dumpSuperMember(FileStream& o, const OString& superType, sal_Bool bWithType)
3399 {
3400 	sal_Bool hasMember = sal_False;
3401 
3402 	if ( !superType.isEmpty() )
3403 	{
3404 		typereg::Reader aSuperReader(m_typeMgr.getTypeReader(superType));
3405 
3406 		if (aSuperReader.isValid())
3407 		{
3408             rtl::OString superSuper;
3409             if (aSuperReader.getSuperTypeCount() >= 1) {
3410                 superSuper = rtl::OUStringToOString(
3411                     aSuperReader.getSuperTypeName(0), RTL_TEXTENCODING_UTF8);
3412             }
3413 			hasMember = dumpSuperMember(o, superSuper, bWithType);
3414 
3415 			sal_uInt16 		fieldCount = aSuperReader.getFieldCount();
3416 			RTFieldAccess 	access = RT_ACCESS_INVALID;
3417 			OString 		fieldName;
3418 			OString 		fieldType;
3419 			for (sal_uInt16 i=0; i < fieldCount; i++)
3420 			{
3421 				access = aSuperReader.getFieldFlags(i);
3422 
3423 				if (access == RT_ACCESS_CONST || access == RT_ACCESS_INVALID)
3424 					continue;
3425 
3426 				fieldName = rtl::OUStringToOString(
3427                     aSuperReader.getFieldName(i), RTL_TEXTENCODING_UTF8);
3428 				fieldType = rtl::OUStringToOString(
3429                     aSuperReader.getFieldTypeName(i), RTL_TEXTENCODING_UTF8);
3430 
3431 				if (hasMember)
3432 				{
3433 					o << ", ";
3434 				} else
3435 				{
3436 					hasMember = (fieldCount > 0);
3437 				}
3438 
3439 				if (bWithType)
3440 				{
3441 					dumpType(o, fieldType, sal_True, sal_True);
3442 					o << " ";
3443 				}
3444 //				o << "__" << fieldName;
3445 				o << fieldName << "_";
3446 			}
3447 		}
3448 	}
3449 
3450 	return hasMember;
3451 }
3452 
3453 //*************************************************************************
3454 // EnumType
3455 //*************************************************************************
EnumType(typereg::Reader & typeReader,const OString & typeName,const TypeManager & typeMgr)3456 EnumType::EnumType(typereg::Reader& typeReader,
3457 			 	   const OString& typeName,
3458 				   const TypeManager& typeMgr)
3459 	: CppuType(typeReader, typeName, typeMgr)
3460 {
3461 }
3462 
~EnumType()3463 EnumType::~EnumType()
3464 {
3465 
3466 }
3467 
dumpHFile(FileStream & o,codemaker::cppumaker::Includes & includes)3468 sal_Bool EnumType::dumpHFile(
3469     FileStream& o, codemaker::cppumaker::Includes & includes)
3470 	throw( CannotDumpException )
3471 {
3472 	OString headerDefine(dumpHeaderDefine(o, "HDL"));
3473 	o << "\n";
3474 
3475 	addDefaultHIncludes(includes);
3476     includes.dump(o, 0);
3477 	o << "\n";
3478 
3479     if (codemaker::cppumaker::dumpNamespaceOpen(o, m_typeName, false)) {
3480         o << "\n";
3481     }
3482 
3483 	dumpDeclaration(o);
3484 
3485     if (codemaker::cppumaker::dumpNamespaceClose(o, m_typeName, false)) {
3486         o << "\n";
3487     }
3488 
3489 	o << "\nnamespace com { namespace sun { namespace star { namespace uno {\n"
3490 	  << "class Type;\n} } } }\n\n";
3491 
3492 	o << "inline const ::com::sun::star::uno::Type& SAL_CALL getCppuType( ";
3493 	dumpType(o, m_typeName, sal_True, sal_False);
3494 	o << "* ) SAL_THROW( () );\n\n";
3495 
3496 	o << "#endif // "<< headerDefine << "\n";
3497 
3498 	return sal_True;
3499 }
3500 
dumpDeclaration(FileStream & o)3501 sal_Bool EnumType::dumpDeclaration(FileStream& o)
3502 	throw( CannotDumpException )
3503 {
3504 	o << "\nenum " << m_name << "\n{\n";
3505 	inc();
3506 
3507 	sal_uInt16 		fieldCount = m_reader.getFieldCount();
3508 	RTFieldAccess 	access = RT_ACCESS_INVALID;
3509 	RTConstValue	constValue;
3510 	OString 		fieldName;
3511 	sal_Int32		value=0;
3512 	for (sal_uInt16 i=0; i < fieldCount; i++)
3513 	{
3514 		access = m_reader.getFieldFlags(i);
3515 
3516 		if (access != RT_ACCESS_CONST)
3517 			continue;
3518 
3519 		fieldName = rtl::OUStringToOString(
3520             m_reader.getFieldName(i), RTL_TEXTENCODING_UTF8);
3521 		constValue = m_reader.getFieldValue(i);
3522 
3523 		if (constValue.m_type == RT_TYPE_INT32)
3524 			value = constValue.m_value.aLong;
3525 		else
3526 			value++;
3527 
3528 		o << indent() << m_name << "_" << fieldName << " = " << value << ",\n";
3529 	}
3530 
3531 	o << indent() << m_name << "_MAKE_FIXED_SIZE = SAL_MAX_ENUM\n";
3532 
3533 	dec();
3534 	o << "};\n\n";
3535 
3536 	return sal_True;
3537 }
3538 
dumpHxxFile(FileStream & o,codemaker::cppumaker::Includes & includes)3539 sal_Bool EnumType::dumpHxxFile(
3540     FileStream& o, codemaker::cppumaker::Includes & includes)
3541 	throw( CannotDumpException )
3542 {
3543 	OString headerDefine(dumpHeaderDefine(o, "HPP"));
3544 	o << "\n";
3545 
3546 	addDefaultHxxIncludes(includes);
3547     includes.dump(o, &m_typeName);
3548 	o << "\n";
3549 
3550 	dumpGetCppuType(o);
3551 
3552 	o << "\n#endif // "<< headerDefine << "\n";
3553 	return sal_True;
3554 }
3555 
dumpNormalGetCppuType(FileStream & o)3556 void EnumType::dumpNormalGetCppuType(FileStream& o)
3557 {
3558     dumpGetCppuTypePreamble(o);
3559 
3560     o << indent()
3561       << "static typelib_TypeDescriptionReference * the_type = 0;\n";
3562 
3563 	o << indent() << "if ( !the_type )\n" << indent() << "{\n";
3564 	inc();
3565 
3566 	o << indent() << "typelib_static_enum_type_init( &the_type,\n";
3567 	inc(31);
3568 	o << indent() << "\"" << m_typeName.replace('/', '.') << "\",\n"
3569 	  << indent() << scopedCppName(m_typeName) << "_"
3570       << rtl::OUStringToOString(m_reader.getFieldName(0), RTL_TEXTENCODING_UTF8)
3571       << " );\n";
3572 	dec(31);
3573 	dec();
3574 	o << indent() << "}\n";
3575 	o << indent()
3576       << ("return * reinterpret_cast< ::com::sun::star::uno::Type * >("
3577           " &the_type );\n");
3578     dumpGetCppuTypePostamble(o);
3579 }
3580 
dumpComprehensiveGetCppuType(FileStream & o)3581 void EnumType::dumpComprehensiveGetCppuType(FileStream& o)
3582 {
3583     dumpGetCppuTypePreamble(o);
3584 
3585     o << indent() << "static ::com::sun::star::uno::Type * the_pType = 0;\n";
3586 
3587 	o << indent() << "if (the_pType == 0)\n" << indent() << "{\n";
3588 	inc();
3589 	o << indent() << "::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );\n";
3590 
3591 	o << indent() << "if (the_pType == 0)\n" << indent() << "{\n";
3592 	inc();
3593 	o << indent() << "::rtl::OUString sTypeName( RTL_CONSTASCII_USTRINGPARAM(\""
3594 	  << m_typeName.replace('/', '.') << "\") );\n\n";
3595 
3596     o << indent() << "// Start inline typedescription generation\n"
3597       << indent() << "typelib_TypeDescription * pTD = 0;\n\n";
3598 
3599     sal_uInt16 count = m_reader.getFieldCount();
3600     o << indent() << "rtl_uString* enumValueNames[" << count << "];\n";
3601     sal_uInt16 i;
3602     for (i = 0; i < count; i++)
3603     {
3604         o << indent() << "::rtl::OUString sEnumValue" << i
3605           << "( RTL_CONSTASCII_USTRINGPARAM(\""
3606           << rtl::OUStringToOString(
3607               m_reader.getFieldName(i), RTL_TEXTENCODING_UTF8)
3608           << "\") );\n";
3609         o << indent() << "enumValueNames[" << i << "] = sEnumValue" << i
3610           << ".pData;\n";
3611     }
3612 
3613     o << "\n" << indent() << "sal_Int32 enumValues[" << count << "];\n";
3614     RTConstValue    constValue;
3615     sal_Int32       value=0;
3616     for (i = 0; i < count; i++)
3617     {
3618         o << indent() << "enumValues[" << i << "] = ";
3619         constValue = m_reader.getFieldValue(i);
3620         if (constValue.m_type == RT_TYPE_INT32)
3621             value = constValue.m_value.aLong;
3622         else
3623             value++;
3624         o << value << ";\n";
3625     }
3626 
3627     o << "\n" << indent() << "typelib_typedescription_newEnum( &pTD,\n";
3628     inc();
3629     o << indent() << "sTypeName.pData,\n"
3630       << indent() << "(sal_Int32)" << scopedCppName(m_typeName, sal_False)
3631       << "_"
3632       << rtl::OUStringToOString(m_reader.getFieldName(0), RTL_TEXTENCODING_UTF8)
3633       << ",\n"
3634       << indent() << count << ", enumValueNames, enumValues );\n\n";
3635     dec();
3636 
3637     o << indent()
3638       << ("typelib_typedescription_register( (typelib_TypeDescription**)&pTD"
3639           " );\n");
3640     o << indent() << "typelib_typedescription_release( pTD );\n"
3641       << indent() << "// End inline typedescription generation\n\n";
3642 
3643     o << indent() << "static ::com::sun::star::uno::Type the_staticType( "
3644       << getTypeClass(m_typeName) << ", sTypeName );\n";
3645     o << indent() << "the_pType = &the_staticType;\n";
3646 
3647 	dec();
3648 	o << indent() << "}\n";
3649 	dec();
3650 	o << indent() << "}\n\n"
3651 	  << indent() << "return *the_pType;\n";
3652 
3653     dumpGetCppuTypePostamble(o);
3654 }
3655 
3656 //*************************************************************************
3657 // TypeDefType
3658 //*************************************************************************
TypeDefType(typereg::Reader & typeReader,const OString & typeName,const TypeManager & typeMgr)3659 TypeDefType::TypeDefType(typereg::Reader& typeReader,
3660 			 	   		 const OString& typeName,
3661 				   		 const TypeManager& typeMgr)
3662 	: CppuType(typeReader, typeName, typeMgr)
3663 {
3664 }
3665 
~TypeDefType()3666 TypeDefType::~TypeDefType()
3667 {
3668 
3669 }
3670 
dumpHFile(FileStream & o,codemaker::cppumaker::Includes & includes)3671 sal_Bool TypeDefType::dumpHFile(
3672     FileStream& o, codemaker::cppumaker::Includes & includes)
3673 	throw( CannotDumpException )
3674 {
3675 	OString headerDefine(dumpHeaderDefine(o, "HDL"));
3676 	o << "\n";
3677 
3678 	addDefaultHIncludes(includes);
3679 	includes.dump(o, 0);
3680 	o << "\n";
3681 
3682     if (codemaker::cppumaker::dumpNamespaceOpen(o, m_typeName, false)) {
3683         o << "\n";
3684     }
3685 
3686 	dumpDeclaration(o);
3687 
3688     if (codemaker::cppumaker::dumpNamespaceClose(o, m_typeName, false)) {
3689         o << "\n";
3690     }
3691 
3692 //	o << "\nnamespace com { namespace sun { namespace star { namespace uno {\n"
3693 //	  << "class Type;\n} } } }\n\n";
3694 //	o << "inline const ::com::sun::star::uno::Type& SAL_CALL get_" << m_typeName.replace('/', '_')
3695 //	  <<  "_Type( ) SAL_THROW( () );\n\n";
3696 
3697 	o << "#endif // "<< headerDefine << "\n";
3698 
3699 	return sal_True;
3700 }
3701 
dumpDeclaration(FileStream & o)3702 sal_Bool TypeDefType::dumpDeclaration(FileStream& o)
3703 	throw( CannotDumpException )
3704 {
3705 	o << "\ntypedef ";
3706 	dumpType(
3707         o,
3708         rtl::OUStringToOString(
3709             m_reader.getSuperTypeName(0), RTL_TEXTENCODING_UTF8));
3710 	o << " " << m_name << ";\n\n";
3711 
3712 	return sal_True;
3713 }
3714 
dumpHxxFile(FileStream & o,codemaker::cppumaker::Includes & includes)3715 sal_Bool TypeDefType::dumpHxxFile(
3716     FileStream& o, codemaker::cppumaker::Includes & includes)
3717 	throw( CannotDumpException )
3718 {
3719 	OString headerDefine(dumpHeaderDefine(o, "HPP"));
3720 	o << "\n";
3721 
3722 	addDefaultHxxIncludes(includes);
3723 	includes.dump(o, &m_typeName);
3724 	o << "\n";
3725 
3726 	o << "\n#endif // "<< headerDefine << "\n";
3727 	return sal_True;
3728 }
3729 
3730 //*************************************************************************
3731 // ConstructiveType
3732 //*************************************************************************
3733 
dumpHFile(FileStream &,codemaker::cppumaker::Includes &)3734 sal_Bool ConstructiveType::dumpHFile(
3735     FileStream &, codemaker::cppumaker::Includes &) throw (CannotDumpException)
3736 {
3737     OSL_ASSERT(false);
3738     return false;
3739 }
3740 
dumpFiles(CppuOptions * options,rtl::OString const & outPath)3741 bool ConstructiveType::dumpFiles(
3742     CppuOptions * options, rtl::OString const & outPath)
3743 {
3744     return dumpFile(options, ".hpp", m_typeName, outPath);
3745 }
3746 
3747 //*************************************************************************
3748 // ServiceType
3749 //*************************************************************************
3750 
3751 namespace {
3752 
includeExceptions(codemaker::cppumaker::Includes & includes,codemaker::ExceptionTreeNode const * node)3753 void includeExceptions(
3754     codemaker::cppumaker::Includes & includes,
3755     codemaker::ExceptionTreeNode const * node)
3756 {
3757     if (node->present) {
3758         includes.add(node->name);
3759     } else {
3760         for (codemaker::ExceptionTreeNode::Children::const_iterator i(
3761                  node->children.begin());
3762              i != node->children.end(); ++i)
3763         {
3764             includeExceptions(includes, *i);
3765         }
3766     }
3767 }
3768 
3769 }
3770 
isSingleInterfaceBased()3771 bool ServiceType::isSingleInterfaceBased() {
3772     return m_reader.getSuperTypeCount() == 1;
3773 }
3774 
dumpHxxFile(FileStream & o,codemaker::cppumaker::Includes & includes)3775 sal_Bool ServiceType::dumpHxxFile(
3776     FileStream & o, codemaker::cppumaker::Includes & includes)
3777     throw (CannotDumpException)
3778 {
3779     sal_uInt16 ctors = m_reader.getMethodCount();
3780     if (ctors > 0) {
3781         //TODO: Decide whether the types added to includes should rather be
3782         // added to m_dependencies (and thus be generated during
3783         // dumpDependedTypes):
3784         includes.addReference();
3785         includes.addRtlUstringH();
3786         includes.addRtlUstringHxx();
3787         includes.add("com/sun/star/lang/XMultiComponentFactory");
3788         includes.add("com/sun/star/uno/DeploymentException");
3789         includes.add("com/sun/star/uno/XComponentContext");
3790         for (sal_uInt16 i = 0; i < ctors; ++i) {
3791             if (isDefaultConstructor(i)) {
3792                 includes.add("com/sun/star/uno/Exception");
3793                 includes.add("com/sun/star/uno/RuntimeException");
3794             } else {
3795                 if (!hasRestParameter(i)) {
3796                     includes.addAny();
3797                     includes.addSequence();
3798                     sal_uInt16 params = m_reader.getMethodParameterCount(i);
3799                     for (sal_uInt16 j = 0; j < params; ++j) {
3800                         if (codemaker::UnoType::getSort(
3801                                 codemaker::UnoType::decompose(
3802                                     rtl::OUStringToOString(
3803                                         m_reader.getMethodParameterTypeName(
3804                                             i, j),
3805                                         RTL_TEXTENCODING_UTF8),
3806                                     0, 0))
3807                             == codemaker::UnoType::SORT_CHAR)
3808                         {
3809                             includes.addCppuUnotypeHxx();
3810                             break;
3811                         }
3812                     }
3813                 }
3814                 codemaker::ExceptionTree tree;
3815                 for (sal_uInt16 j = 0; j < m_reader.getMethodExceptionCount(i);
3816                      ++j)
3817                 {
3818                     tree.add(
3819                         rtl::OUStringToOString(
3820                             m_reader.getMethodExceptionTypeName(i, j),
3821                             RTL_TEXTENCODING_UTF8),
3822                         m_typeMgr);
3823                 }
3824                 if (!tree.getRoot()->present) {
3825                     includes.add("com/sun/star/uno/Exception");
3826                     includes.add("com/sun/star/uno/RuntimeException");
3827                     includeExceptions(includes, tree.getRoot());
3828                 }
3829             }
3830         }
3831     }
3832     rtl::OString cppName(translateUnoToCppIdentifier(
3833                              m_name, "service", isGlobal()));
3834     rtl::OString headerDefine(dumpHeaderDefine(o, "HPP"));
3835     o << "\n";
3836     includes.dump(o, 0);
3837     o << "\n";
3838     if (codemaker::cppumaker::dumpNamespaceOpen(o, m_typeName, false)) {
3839         o << "\n";
3840     }
3841     o << "\nclass " << cppName << " {\n";
3842     inc();
3843     if (ctors > 0) {
3844         rtl::OString fullName(m_typeName.replace('/', '.'));
3845         rtl::OString baseName(
3846             rtl::OUStringToOString(
3847                 m_reader.getSuperTypeName(0), RTL_TEXTENCODING_UTF8));
3848         rtl::OString fullBaseName(baseName.replace('/', '.'));
3849         rtl::OString scopedBaseName(scopedCppName(baseName));
3850         o << "public:\n";
3851         for (sal_uInt16 i = 0; i < ctors; ++i) {
3852             if (isDefaultConstructor(i)) {
3853                 o << indent() << "static ::com::sun::star::uno::Reference< "
3854                   << scopedBaseName << " > "
3855                   << translateUnoToCppIdentifier(
3856                       "create", "method", ITM_NONGLOBAL, &cppName)
3857                   << ("(::com::sun::star::uno::Reference<"
3858                       " ::com::sun::star::uno::XComponentContext > const &"
3859                       " the_context) {\n");
3860                 inc();
3861                 o << indent()
3862                   << ("::com::sun::star::uno::Reference<"
3863                       " ::com::sun::star::lang::XMultiComponentFactory >"
3864                       " the_factory(the_context->getServiceManager());\n")
3865                   << indent() << "if (!the_factory.is()) {\n";
3866                 inc();
3867                 o << indent()
3868                   << ("throw ::com::sun::star::uno::DeploymentException("
3869                       "::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(\"component"
3870                       " context fails to supply service manager\")),"
3871                       " the_context);\n");
3872                 dec();
3873                 o << indent() << "}\n" << indent()
3874                   << "::com::sun::star::uno::Reference< " << scopedBaseName
3875                   << " > the_instance;\n" << indent() << "try {\n";
3876                 inc();
3877                 o << indent()
3878                   << "the_instance = ::com::sun::star::uno::Reference< "
3879                   << scopedBaseName
3880                   << (" >(the_factory->createInstanceWithContext("
3881                       "::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(\"")
3882                   << fullName
3883                   << "\")), the_context), ::com::sun::star::uno::UNO_QUERY);\n";
3884                 dec();
3885                 o << indent()
3886                   << "} catch (::com::sun::star::uno::RuntimeException &) {\n";
3887                 inc();
3888                 o << indent() << "throw;\n";
3889                 dec();
3890                 o << indent()
3891                   << ("} catch (::com::sun::star::uno::Exception &"
3892                       " the_exception) {\n");
3893                 inc();
3894                 o << indent()
3895                   << ("throw ::com::sun::star::uno::DeploymentException("
3896                       "::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("
3897                       "\"component context fails to supply service ")
3898                   << fullName << " of type " << fullBaseName
3899                   << ": \")) + the_exception.Message, the_context);\n";
3900                 dec();
3901                 o << indent() << "}\n" << indent()
3902                   << "if (!the_instance.is()) {\n";
3903                 inc();
3904                 o << indent()
3905                   << ("throw ::com::sun::star::uno::DeploymentException("
3906                       "::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("
3907                       "\"component context fails to supply service ")
3908                   << fullName << " of type " << fullBaseName
3909                   << "\")), the_context);\n";
3910                 dec();
3911                 o << indent() << "}\n" << indent() << "return the_instance;\n";
3912                 dec();
3913                 o << indent() << "}\n\n";
3914             } else {
3915                 o << indent() << "static ::com::sun::star::uno::Reference< "
3916                   << scopedBaseName << " > "
3917                   << translateUnoToCppIdentifier(
3918                       rtl::OUStringToOString(
3919                           m_reader.getMethodName(i), RTL_TEXTENCODING_UTF8),
3920                       "method", ITM_NONGLOBAL, &cppName)
3921                   << ("(::com::sun::star::uno::Reference<"
3922                       " ::com::sun::star::uno::XComponentContext > const &"
3923                       " the_context");
3924                 sal_uInt16 params = m_reader.getMethodParameterCount(i);
3925                 bool rest = hasRestParameter(i);
3926                 for (sal_uInt16 j = 0; j < params; ++j) {
3927                     o << ", ";
3928                     rtl::OStringBuffer buf;
3929                     if ((m_reader.getMethodParameterFlags(i, j) & RT_PARAM_REST)
3930                         != 0)
3931                     {
3932                         buf.append(RTL_CONSTASCII_STRINGPARAM("[]"));
3933                     }
3934                     buf.append(
3935                         rtl::OUStringToOString(
3936                             m_reader.getMethodParameterTypeName(i, j),
3937                             RTL_TEXTENCODING_UTF8));
3938                     rtl::OString type(buf.makeStringAndClear());
3939                     bool byRef = passByReference(type);
3940                     dumpType(o, type, byRef, byRef);
3941                     o << " "
3942                       << translateUnoToCppIdentifier(
3943                           rtl::OUStringToOString(
3944                               m_reader.getMethodParameterName(i, j),
3945                               RTL_TEXTENCODING_UTF8),
3946                           "param", ITM_NONGLOBAL);
3947                 }
3948                 o << ") {\n";
3949                 inc();
3950                 o << indent()
3951                   << ("::com::sun::star::uno::Reference<"
3952                       " ::com::sun::star::lang::XMultiComponentFactory >"
3953                       " the_factory(the_context->getServiceManager());\n")
3954                   << indent() << "if (!the_factory.is()) {\n";
3955                 inc();
3956                 o << indent()
3957                   << ("throw com::sun::star::uno::DeploymentException("
3958                       "::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("
3959                       "\"component context fails to supply service manager\")),"
3960                       " the_context);\n");
3961                 dec();
3962                 o << indent() << "}\n";
3963                 if (!rest && params > 0) {
3964                     o << indent()
3965                       << ("::com::sun::star::uno::Sequence<"
3966                           " ::com::sun::star::uno::Any > the_arguments(")
3967                       << params << ");\n";
3968                     for (sal_uInt16 j = 0; j < params; ++j) {
3969                         o << indent() << "the_arguments[" << j << "] ";
3970                         rtl::OString param(
3971                             translateUnoToCppIdentifier(
3972                                 rtl::OUStringToOString(
3973                                     m_reader.getMethodParameterName(i, j),
3974                                     RTL_TEXTENCODING_UTF8),
3975                                 "param", ITM_NONGLOBAL));
3976                         sal_Int32 rank;
3977                         if (codemaker::UnoType::getSort(
3978                                 codemaker::UnoType::decompose(
3979                                     rtl::OUStringToOString(
3980                                         m_reader.getMethodParameterTypeName(
3981                                             i, j),
3982                                         RTL_TEXTENCODING_UTF8),
3983                                     &rank, 0))
3984                             == codemaker::UnoType::SORT_CHAR)
3985                         {
3986                             o << "= ::com::sun::star::uno::Any(&" << param
3987                               << ", ::cppu::UnoType< ";
3988                             for (sal_Int32 k = 0; k < rank; ++k) {
3989                                 o << "::cppu::UnoSequenceType< ";
3990                             }
3991                             o << "::cppu::UnoCharType";
3992                             for (sal_Int32 k = 0; k < rank; ++k) {
3993                                 o << " >";
3994                             }
3995                             o << " >::get())";
3996                         } else {
3997                             o << "<<= " << param;
3998                         }
3999                         o << ";\n";
4000                     }
4001                 }
4002                 o << indent() << "::com::sun::star::uno::Reference< "
4003                   << scopedBaseName << " > the_instance;\n";
4004                 codemaker::ExceptionTree tree;
4005                 sal_uInt16 exceptions = m_reader.getMethodExceptionCount(i);
4006                 for (sal_uInt16 j = 0; j < exceptions; ++j) {
4007                     tree.add(
4008                         rtl::OUStringToOString(
4009                             m_reader.getMethodExceptionTypeName(i, j),
4010                             RTL_TEXTENCODING_UTF8),
4011                         m_typeMgr);
4012                 }
4013                 if (!tree.getRoot()->present) {
4014                     o << indent() << "try {\n";
4015                     inc();
4016                 }
4017                 o << indent()
4018                   << "the_instance = ::com::sun::star::uno::Reference< "
4019                   << scopedBaseName
4020                   << (" >(the_factory->createInstanceWithArgumentsAndContext("
4021                       "::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(\"")
4022                   << fullName << "\")), ";
4023                 if (rest) {
4024                     o << translateUnoToCppIdentifier(
4025                         rtl::OUStringToOString(
4026                             m_reader.getMethodParameterName(i, 0),
4027                             RTL_TEXTENCODING_UTF8),
4028                         "param", ITM_NONGLOBAL);
4029                 } else if (params == 0) {
4030                     o << ("::com::sun::star::uno::Sequence<"
4031                           " ::com::sun::star::uno::Any >()");
4032                 } else {
4033                     o << "the_arguments";
4034                 }
4035                 o << ", the_context), ::com::sun::star::uno::UNO_QUERY);\n";
4036                 if (!tree.getRoot()->present) {
4037                     dec();
4038                     o << indent()
4039                       << ("} catch (::com::sun::star::uno::RuntimeException &)"
4040                           " {\n");
4041                     inc();
4042                     o << indent() << "throw;\n";
4043                     dec();
4044                     dumpCatchClauses(o, tree.getRoot());
4045                     o << indent()
4046                       << ("} catch (::com::sun::star::uno::Exception &"
4047                           " the_exception) {\n");
4048                     inc();
4049                     o << indent()
4050                       << ("throw ::com::sun::star::uno::DeploymentException("
4051                           "::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("
4052                           "\"component context fails to supply service ")
4053                       << fullName << " of type " << fullBaseName
4054                       << ": \")) + the_exception.Message, the_context);\n";
4055                     dec();
4056                     o << indent() << "}\n";
4057                 }
4058                 o << indent() << "if (!the_instance.is()) {\n";
4059                 inc();
4060                 o << indent()
4061                   << ("throw ::com::sun::star::uno::DeploymentException("
4062                       "::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("
4063                       "\"component context fails to supply service ")
4064                   << fullName << " of type " << fullBaseName
4065                   << "\")), the_context);\n";
4066                 dec();
4067                 o << indent() << "}\n" << indent() << "return the_instance;\n";
4068                 dec();
4069                 o << indent() << "}\n\n";
4070             }
4071         }
4072     }
4073     o << "private:\n";
4074     o << indent() << cppName << "(); // not implemented\n"
4075       << indent() << cppName << "(" << cppName << " &); // not implemented\n"
4076       << indent() << "~" << cppName << "(); // not implemented\n"
4077       << indent() << "void operator =(" << cppName << "); // not implemented\n";
4078     dec();
4079     o << "};\n\n";
4080     if (codemaker::cppumaker::dumpNamespaceClose(o, m_typeName, false)) {
4081         o << "\n";
4082     }
4083     o << "\n#endif // "<< headerDefine << "\n";
4084     return true;
4085 }
4086 
addSpecialDependencies()4087 void ServiceType::addSpecialDependencies() {
4088     if (m_reader.getMethodCount() > 0) {
4089         OSL_ASSERT(m_reader.getSuperTypeCount() == 1);
4090         m_dependencies.add(
4091             rtl::OUStringToOString(
4092                 m_reader.getSuperTypeName(0), RTL_TEXTENCODING_UTF8));
4093     }
4094 }
4095 
isDefaultConstructor(sal_uInt16 ctorIndex) const4096 bool ServiceType::isDefaultConstructor(sal_uInt16 ctorIndex) const {
4097     return m_reader.getMethodName(ctorIndex).isEmpty();
4098 }
4099 
hasRestParameter(sal_uInt16 ctorIndex) const4100 bool ServiceType::hasRestParameter(sal_uInt16 ctorIndex) const {
4101     return m_reader.getMethodParameterCount(ctorIndex) == 1
4102         && ((m_reader.getMethodParameterFlags(ctorIndex, 0) & RT_PARAM_REST)
4103             != 0);
4104 }
4105 
dumpCatchClauses(FileStream & out,codemaker::ExceptionTreeNode const * node)4106 void ServiceType::dumpCatchClauses(
4107     FileStream & out, codemaker::ExceptionTreeNode const * node)
4108 {
4109     if (node->present) {
4110         out << indent() << "} catch (";
4111         dumpType(out, node->name);
4112         out << " &) {\n";
4113         inc();
4114         out << indent() << "throw;\n";
4115         dec();
4116     } else {
4117         for (codemaker::ExceptionTreeNode::Children::const_iterator i(
4118                  node->children.begin());
4119              i != node->children.end(); ++i)
4120         {
4121             dumpCatchClauses(out, *i);
4122         }
4123     }
4124 }
4125 
4126 //*************************************************************************
4127 // SingletonType
4128 //*************************************************************************
4129 
isInterfaceBased()4130 bool SingletonType::isInterfaceBased() {
4131     return (m_typeMgr.getTypeClass(
4132                 rtl::OUStringToOString(
4133                     m_reader.getSuperTypeName(0), RTL_TEXTENCODING_UTF8)))
4134         == RT_TYPE_INTERFACE;
4135 }
4136 
dumpHxxFile(FileStream & o,codemaker::cppumaker::Includes & includes)4137 sal_Bool SingletonType::dumpHxxFile(
4138     FileStream & o, codemaker::cppumaker::Includes & includes)
4139     throw (CannotDumpException)
4140 {
4141     rtl::OString cppName(translateUnoToCppIdentifier(
4142                              m_name, "singleton", isGlobal()));
4143     rtl::OString fullName(m_typeName.replace('/', '.'));
4144     rtl::OString baseName(
4145         rtl::OUStringToOString(
4146             m_reader.getSuperTypeName(0), RTL_TEXTENCODING_UTF8));
4147     rtl::OString fullBaseName(baseName.replace('/', '.'));
4148     rtl::OString scopedBaseName(scopedCppName(baseName));
4149     rtl::OString headerDefine(dumpHeaderDefine(o, "HPP"));
4150     o << "\n";
4151     //TODO: Decide whether the types added to includes should rather be added to
4152     // m_dependencies (and thus be generated during dumpDependedTypes):
4153     includes.add("com/sun/star/uno/DeploymentException");
4154     includes.add("com/sun/star/uno/XComponentContext");
4155     includes.addAny();
4156     includes.addReference();
4157     includes.addRtlUstringH();
4158     includes.addRtlUstringHxx();
4159     includes.dump(o, 0);
4160     o << "\n";
4161     if (codemaker::cppumaker::dumpNamespaceOpen(o, m_typeName, false)) {
4162         o << "\n";
4163     }
4164     o << "\nclass " << cppName << " {\npublic:\n";
4165     inc();
4166     o << indent() << "static ::com::sun::star::uno::Reference< "
4167       << scopedBaseName << " > "
4168       << translateUnoToCppIdentifier("get", "method", ITM_NONGLOBAL, &cppName)
4169       << ("(::com::sun::star::uno::Reference<"
4170           " ::com::sun::star::uno::XComponentContext > const & context) {\n");
4171     inc();
4172     o << indent() << "::com::sun::star::uno::Reference< " << scopedBaseName
4173       << " > instance;\n" << indent()
4174       << ("if (!(context->getValueByName("
4175           "::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(\"/singletons/")
4176       << fullName << "\"))) >>= instance) || !instance.is()) {\n";
4177     inc();
4178     o << indent()
4179       << ("throw ::com::sun::star::uno::DeploymentException("
4180           "::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(\"component context"
4181           " fails to supply singleton ")
4182       << fullName << " of type " << fullBaseName << "\")), context);\n";
4183     dec();
4184     o << indent() << "}\n" << indent() << "return instance;\n";
4185     dec();
4186     o << indent() << "}\n\n";
4187     o << "private:\n";
4188     o << indent() << cppName << "(); // not implemented\n"
4189       << indent() << cppName << "(" << cppName << " &); // not implemented\n"
4190       << indent() << "~" << cppName << "(); // not implemented\n"
4191       << indent() << "void operator =(" << cppName << "); // not implemented\n";
4192     dec();
4193     o << "};\n\n";
4194     if (codemaker::cppumaker::dumpNamespaceClose(o, m_typeName, false)) {
4195         o << "\n";
4196     }
4197     o << "\n#endif // "<< headerDefine << "\n";
4198     return true;
4199 }
4200 
4201 //*************************************************************************
4202 // produceType
4203 //*************************************************************************
produceType(const OString & typeName,TypeManager const & typeMgr,codemaker::GeneratedTypeSet & generated,CppuOptions * pOptions)4204 bool produceType(const OString& typeName,
4205                  TypeManager const & typeMgr,
4206                  codemaker::GeneratedTypeSet & generated,
4207                  CppuOptions* pOptions)
4208 	throw( CannotDumpException )
4209 {
4210 	if (typeName.equals("/") || typeName.equals(typeMgr.getBase()) ||
4211         TypeManager::isBaseType(typeName) || generated.contains(typeName))
4212     {
4213 		return true;
4214     }
4215 
4216     sal_Bool bIsExtraType = sal_False;
4217 	typereg::Reader reader(typeMgr.getTypeReader(typeName, &bIsExtraType));
4218     if (bIsExtraType) {
4219         generated.add(typeName);
4220         return true;
4221     }
4222 
4223 	if (!reader.isValid()) {
4224         return false;
4225     }
4226 
4227 	RTTypeClass typeClass = reader.getTypeClass();
4228 	bool ret = false;
4229 	switch (typeClass)
4230 	{
4231 		case RT_TYPE_INTERFACE:
4232 			{
4233 				InterfaceType iType(reader, typeName, typeMgr);
4234 				ret = iType.dump(pOptions);
4235 				if (ret) generated.add(typeName);
4236 				iType.dumpDependedTypes(generated, pOptions);
4237 			}
4238 			break;
4239 		case RT_TYPE_MODULE:
4240 			{
4241 				ModuleType mType(reader, typeName, typeMgr);
4242 				if (mType.hasConstants())
4243 				{
4244 					ret = mType.dump(pOptions);
4245 					if (ret) generated.add(typeName);
4246 				} else
4247 				{
4248 					generated.add(typeName);
4249 					ret = true;
4250 				}
4251 			}
4252 			break;
4253 		case RT_TYPE_STRUCT:
4254 			{
4255 				StructureType sType(reader, typeName, typeMgr);
4256 				ret = sType.dump(pOptions);
4257 				if (ret) generated.add(typeName);
4258 				sType.dumpDependedTypes(generated, pOptions);
4259 			}
4260 			break;
4261 		case RT_TYPE_ENUM:
4262 			{
4263 				EnumType enType(reader, typeName, typeMgr);
4264 				ret = enType.dump(pOptions);
4265 				if (ret) generated.add(typeName);
4266 				enType.dumpDependedTypes(generated, pOptions);
4267 			}
4268 			break;
4269 		case RT_TYPE_EXCEPTION:
4270 			{
4271 				ExceptionType eType(reader, typeName, typeMgr);
4272 				ret = eType.dump(pOptions);
4273 				if (ret) generated.add(typeName);
4274 				eType.dumpDependedTypes(generated, pOptions);
4275 			}
4276 			break;
4277 		case RT_TYPE_TYPEDEF:
4278 			{
4279 				TypeDefType tdType(reader, typeName, typeMgr);
4280 				ret = tdType.dump(pOptions);
4281 				if (ret) generated.add(typeName);
4282 				tdType.dumpDependedTypes(generated, pOptions);
4283 			}
4284 			break;
4285 		case RT_TYPE_CONSTANTS:
4286 			{
4287 				ConstantsType cType(reader, typeName, typeMgr);
4288 				if (cType.hasConstants())
4289 				{
4290 					ret = cType.dump(pOptions);
4291 					if (ret) generated.add(typeName);
4292 				} else
4293 				{
4294 					generated.add(typeName);
4295 					ret = true;
4296 				}
4297 			}
4298 			break;
4299         case RT_TYPE_SERVICE:
4300             {
4301                 ServiceType t(reader, typeName, typeMgr);
4302                 if (t.isSingleInterfaceBased()) {
4303                     ret = t.dump(pOptions);
4304                     if (ret) {
4305                         generated.add(typeName);
4306                         t.dumpDependedTypes(generated, pOptions);
4307                     }
4308                 } else {
4309                     ret = true;
4310                 }
4311             }
4312             break;
4313         case RT_TYPE_SINGLETON:
4314             {
4315                 SingletonType t(reader, typeName, typeMgr);
4316                 if (t.isInterfaceBased()) {
4317                     ret = t.dump(pOptions);
4318                     if (ret) {
4319                         generated.add(typeName);
4320                         t.dumpDependedTypes(generated, pOptions);
4321                     }
4322                 } else {
4323                     ret = true;
4324                 }
4325             }
4326             break;
4327 		case RT_TYPE_OBJECT:
4328 			ret = true;
4329 			break;
4330         default:
4331             OSL_ASSERT(false);
4332             break;
4333 	}
4334 
4335 	return ret;
4336 }
4337 
produceType(RegistryKey & rTypeKey,bool bIsExtraType,TypeManager const & typeMgr,codemaker::GeneratedTypeSet & generated,CppuOptions * pOptions)4338 bool produceType(RegistryKey& rTypeKey, bool bIsExtraType,
4339 					 TypeManager const & typeMgr,
4340                      codemaker::GeneratedTypeSet & generated,
4341 					 CppuOptions* pOptions)
4342 	throw( CannotDumpException )
4343 {
4344     OString typeName = typeMgr.getTypeName(rTypeKey);
4345 
4346 	if (typeName.equals("/") ||typeName.equals(typeMgr.getBase()) ||
4347         TypeManager::isBaseType(typeName) || generated.contains(typeName))
4348     {
4349 		return true;
4350     }
4351 
4352     if (bIsExtraType) {
4353         generated.add(typeName);
4354         return true;
4355     }
4356 
4357 	typereg::Reader reader(typeMgr.getTypeReader(rTypeKey));
4358 	if (!reader.isValid()) {
4359         return false;
4360     }
4361 
4362 	RTTypeClass typeClass = reader.getTypeClass();
4363 	bool ret = false;
4364 	switch (typeClass)
4365 	{
4366 		case RT_TYPE_INTERFACE:
4367 			{
4368 				InterfaceType iType(reader, typeName, typeMgr);
4369 				ret = iType.dump(pOptions);
4370 				if (ret) generated.add(typeName);
4371 				iType.dumpDependedTypes(generated, pOptions);
4372 			}
4373 			break;
4374 		case RT_TYPE_MODULE:
4375 			{
4376 				ModuleType mType(reader, typeName, typeMgr);
4377 				if (mType.hasConstants())
4378 				{
4379 					ret = mType.dump(pOptions);
4380 					if (ret) generated.add(typeName);
4381 				} else
4382 				{
4383 					generated.add(typeName);
4384 					ret = true;
4385 				}
4386 			}
4387 			break;
4388 		case RT_TYPE_STRUCT:
4389 			{
4390 				StructureType sType(reader, typeName, typeMgr);
4391 				ret = sType.dump(pOptions);
4392 				if (ret) generated.add(typeName);
4393 				sType.dumpDependedTypes(generated, pOptions);
4394 			}
4395 			break;
4396 		case RT_TYPE_ENUM:
4397 			{
4398 				EnumType enType(reader, typeName, typeMgr);
4399 				ret = enType.dump(pOptions);
4400 				if (ret) generated.add(typeName);
4401 				enType.dumpDependedTypes(generated, pOptions);
4402 			}
4403 			break;
4404 		case RT_TYPE_EXCEPTION:
4405 			{
4406 				ExceptionType eType(reader, typeName, typeMgr);
4407 				ret = eType.dump(pOptions);
4408 				if (ret) generated.add(typeName);
4409 				eType.dumpDependedTypes(generated, pOptions);
4410 			}
4411 			break;
4412 		case RT_TYPE_TYPEDEF:
4413 			{
4414 				TypeDefType tdType(reader, typeName, typeMgr);
4415 				ret = tdType.dump(pOptions);
4416 				if (ret) generated.add(typeName);
4417 				tdType.dumpDependedTypes(generated, pOptions);
4418 			}
4419 			break;
4420 		case RT_TYPE_CONSTANTS:
4421 			{
4422 				ConstantsType cType(reader, typeName, typeMgr);
4423 				if (cType.hasConstants())
4424 				{
4425 					ret = cType.dump(pOptions);
4426 					if (ret) generated.add(typeName);
4427 				} else
4428 				{
4429 					generated.add(typeName);
4430 					ret = true;
4431 				}
4432 			}
4433 			break;
4434         case RT_TYPE_SERVICE:
4435             {
4436                 ServiceType t(reader, typeName, typeMgr);
4437                 if (t.isSingleInterfaceBased()) {
4438                     ret = t.dump(pOptions);
4439                     if (ret) {
4440                         generated.add(typeName);
4441                         t.dumpDependedTypes(generated, pOptions);
4442                     }
4443                 } else {
4444                     ret = true;
4445                 }
4446             }
4447             break;
4448         case RT_TYPE_SINGLETON:
4449             {
4450                 SingletonType t(reader, typeName, typeMgr);
4451                 if (t.isInterfaceBased()) {
4452                     ret = t.dump(pOptions);
4453                     if (ret) {
4454                         generated.add(typeName);
4455                         t.dumpDependedTypes(generated, pOptions);
4456                     }
4457                 } else {
4458                     ret = true;
4459                 }
4460             }
4461             break;
4462 		case RT_TYPE_OBJECT:
4463 			ret = true;
4464 			break;
4465         default:
4466             OSL_ASSERT(false);
4467             break;
4468 	}
4469 
4470 	return ret;
4471 }
4472 
4473 //*************************************************************************
4474 // scopedName
4475 //*************************************************************************
4476 /*
4477 OString scopedName(const OString& scope, const OString& type,
4478 				   sal_Bool bNoNameSpace)
4479 {
4480     sal_Int32 nPos = type.lastIndexOf( '/' );
4481 	if (nPos == -1)
4482 		return type;
4483 
4484 	OStringBuffer tmpBuf(type.getLength()*2);
4485     nPos = 0;
4486     do
4487 	{
4488 		tmpBuf.append("::");
4489         OString token(type.getToken(0, '/', nPos));
4490         if (nPos != -1)
4491             tmpBuf.append(translateUnoToCppIndentifier(
4492                               token, "module", ITM_KEYWORDSONLY));
4493         else
4494             tmpBuf.append(translateUnoToCppIndentifier(
4495                               token, "interface", ITM_KEYWORDSONLY));
4496 	} while( nPos != -1 );
4497 
4498 	return tmpBuf.makeStringAndClear();
4499 }
4500 */
4501