Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 :
21 : #include <memory>
22 : #include <new>
23 :
24 : #include <string.h>
25 : #include <sal/types.h>
26 : #include <osl/endian.h>
27 : #include <registry/reflread.hxx>
28 :
29 : #include "registry/reader.h"
30 : #include "registry/version.h"
31 :
32 : #include "reflcnst.hxx"
33 :
34 : #include <cstddef>
35 :
36 : static const sal_Char NULL_STRING[1] = { 0 };
37 : static const sal_Unicode NULL_WSTRING[1] = { 0 };
38 :
39 : const sal_uInt32 magic = 0x12345678;
40 : const sal_uInt16 minorVersion = 0x0000;
41 : const sal_uInt16 majorVersion = 0x0001;
42 :
43 : /**************************************************************************
44 :
45 : class BlopObject
46 :
47 : holds any data in a flat memory buffer
48 :
49 : **************************************************************************/
50 :
51 : class BlopObject
52 : {
53 : public:
54 : const sal_uInt8* m_pBuffer;
55 : sal_uInt32 m_bufferLen;
56 : bool m_isCopied;
57 :
58 : BlopObject(const sal_uInt8* buffer, sal_uInt32 len, bool copyBuffer);
59 : // throws std::bad_alloc
60 :
61 : ~BlopObject();
62 :
63 0 : inline sal_uInt8 readBYTE(sal_uInt32 index) const
64 : {
65 0 : return m_pBuffer[index];
66 : }
67 :
68 0 : inline sal_Int16 readINT16(sal_uInt32 index) const
69 : {
70 0 : return ((m_pBuffer[index] << 8) | (m_pBuffer[index+1] << 0));
71 : }
72 :
73 0 : inline sal_uInt16 readUINT16(sal_uInt32 index) const
74 : {
75 0 : return ((m_pBuffer[index] << 8) | (m_pBuffer[index+1] << 0));
76 : }
77 :
78 0 : inline sal_Int32 readINT32(sal_uInt32 index) const
79 : {
80 : return (
81 0 : (m_pBuffer[index] << 24) |
82 0 : (m_pBuffer[index+1] << 16) |
83 0 : (m_pBuffer[index+2] << 8) |
84 0 : (m_pBuffer[index+3] << 0)
85 0 : );
86 : }
87 :
88 0 : inline sal_uInt32 readUINT32(sal_uInt32 index) const
89 : {
90 : return (
91 0 : (m_pBuffer[index] << 24) |
92 0 : (m_pBuffer[index+1] << 16) |
93 0 : (m_pBuffer[index+2] << 8) |
94 0 : (m_pBuffer[index+3] << 0)
95 0 : );
96 : }
97 :
98 0 : inline sal_Int64 readINT64(sal_uInt32 index) const
99 : {
100 : return (
101 0 : ((sal_Int64)m_pBuffer[index] << 56) |
102 0 : ((sal_Int64)m_pBuffer[index+1] << 48) |
103 0 : ((sal_Int64)m_pBuffer[index+2] << 40) |
104 0 : ((sal_Int64)m_pBuffer[index+3] << 32) |
105 0 : ((sal_Int64)m_pBuffer[index+4] << 24) |
106 0 : ((sal_Int64)m_pBuffer[index+5] << 16) |
107 0 : ((sal_Int64)m_pBuffer[index+6] << 8) |
108 0 : ((sal_Int64)m_pBuffer[index+7] << 0)
109 0 : );
110 : }
111 :
112 0 : inline sal_uInt64 readUINT64(sal_uInt32 index) const
113 : {
114 : return (
115 0 : ((sal_uInt64)m_pBuffer[index] << 56) |
116 0 : ((sal_uInt64)m_pBuffer[index+1] << 48) |
117 0 : ((sal_uInt64)m_pBuffer[index+2] << 40) |
118 0 : ((sal_uInt64)m_pBuffer[index+3] << 32) |
119 0 : ((sal_uInt64)m_pBuffer[index+4] << 24) |
120 0 : ((sal_uInt64)m_pBuffer[index+5] << 16) |
121 0 : ((sal_uInt64)m_pBuffer[index+6] << 8) |
122 0 : ((sal_uInt64)m_pBuffer[index+7] << 0)
123 0 : );
124 : }
125 : };
126 :
127 0 : BlopObject::BlopObject(const sal_uInt8* buffer, sal_uInt32 len, bool copyBuffer)
128 : : m_bufferLen(len)
129 0 : , m_isCopied(copyBuffer)
130 : {
131 0 : if (m_isCopied)
132 : {
133 0 : m_pBuffer = 0;
134 0 : sal_uInt8* newBuffer = new sal_uInt8[len];
135 0 : memcpy(newBuffer, buffer, len);
136 0 : m_pBuffer = newBuffer;
137 : }
138 : else
139 : {
140 0 : m_pBuffer = buffer;
141 : }
142 0 : }
143 :
144 0 : BlopObject::~BlopObject()
145 : {
146 0 : if (m_isCopied)
147 : {
148 0 : delete[] const_cast<sal_uInt8*>(m_pBuffer);
149 : }
150 0 : }
151 :
152 : /**************************************************************************
153 :
154 : class StringCache
155 :
156 : **************************************************************************/
157 :
158 : class StringCache
159 : {
160 : public:
161 : sal_Unicode** m_stringTable;
162 : sal_uInt16 m_numOfStrings;
163 : sal_uInt16 m_stringsCopied;
164 :
165 : StringCache(sal_uInt16 size); // throws std::bad_alloc
166 : ~StringCache();
167 :
168 : const sal_Unicode* getString(sal_uInt16 index);
169 : sal_uInt16 createString(const sal_uInt8* buffer); // throws std::bad_alloc
170 : };
171 :
172 0 : StringCache::StringCache(sal_uInt16 size)
173 : : m_stringTable(NULL)
174 : , m_numOfStrings(size)
175 0 : , m_stringsCopied(0)
176 : {
177 0 : m_stringTable = new sal_Unicode*[m_numOfStrings];
178 :
179 0 : for (sal_uInt16 i = 0; i < m_numOfStrings; i++)
180 : {
181 0 : m_stringTable[i] = NULL;
182 : }
183 0 : }
184 :
185 0 : StringCache::~StringCache()
186 : {
187 0 : if (m_stringTable)
188 : {
189 0 : for (sal_uInt16 i = 0; i < m_stringsCopied; i++)
190 : {
191 0 : delete[] m_stringTable[i];
192 : }
193 :
194 0 : delete[] m_stringTable;
195 : }
196 0 : }
197 :
198 0 : const sal_Unicode* StringCache::getString(sal_uInt16 index)
199 : {
200 0 : if ((index > 0) && (index <= m_stringsCopied))
201 0 : return m_stringTable[index - 1];
202 : else
203 0 : return NULL;
204 : }
205 :
206 0 : sal_uInt16 StringCache::createString(const sal_uInt8* buffer)
207 : {
208 0 : if (m_stringsCopied < m_numOfStrings)
209 : {
210 0 : sal_uInt32 len = UINT16StringLen(buffer);
211 :
212 0 : m_stringTable[m_stringsCopied] = new sal_Unicode[len + 1];
213 :
214 0 : readString(buffer, m_stringTable[m_stringsCopied], (len + 1) * sizeof(sal_Unicode));
215 :
216 0 : return ++m_stringsCopied;
217 : }
218 : else
219 0 : return 0;
220 : }
221 :
222 : /**************************************************************************
223 :
224 : class ConstantPool
225 :
226 : **************************************************************************/
227 :
228 : class ConstantPool : public BlopObject
229 : {
230 : public:
231 :
232 : sal_uInt16 m_numOfEntries;
233 : sal_Int32* m_pIndex; // index values may be < 0 for cached string constants
234 :
235 : StringCache* m_pStringCache;
236 :
237 0 : ConstantPool(const sal_uInt8* buffer, sal_uInt16 numEntries)
238 : : BlopObject(buffer, 0, false)
239 : , m_numOfEntries(numEntries)
240 : , m_pIndex(NULL)
241 0 : , m_pStringCache(NULL)
242 : {
243 0 : }
244 :
245 : ~ConstantPool();
246 :
247 : sal_uInt32 parseIndex(); // throws std::bad_alloc
248 :
249 : CPInfoTag readTag(sal_uInt16 index);
250 :
251 : const sal_Char* readUTF8NameConstant(sal_uInt16 index);
252 : bool readBOOLConstant(sal_uInt16 index);
253 : sal_Int8 readBYTEConstant(sal_uInt16 index);
254 : sal_Int16 readINT16Constant(sal_uInt16 index);
255 : sal_uInt16 readUINT16Constant(sal_uInt16 index);
256 : sal_Int32 readINT32Constant(sal_uInt16 index);
257 : sal_uInt32 readUINT32Constant(sal_uInt16 index);
258 : sal_Int64 readINT64Constant(sal_uInt16 index);
259 : sal_uInt64 readUINT64Constant(sal_uInt16 index);
260 : float readFloatConstant(sal_uInt16 index);
261 : double readDoubleConstant(sal_uInt16 index);
262 : const sal_Unicode* readStringConstant(sal_uInt16 index);
263 : // throws std::bad_alloc
264 : void readUIK(sal_uInt16 index, RTUik* uik);
265 : };
266 :
267 0 : ConstantPool::~ConstantPool()
268 : {
269 0 : delete[] m_pIndex;
270 0 : delete m_pStringCache;
271 0 : }
272 :
273 0 : sal_uInt32 ConstantPool::parseIndex()
274 : {
275 0 : if (m_pIndex)
276 : {
277 0 : delete[] m_pIndex;
278 0 : m_pIndex = NULL;
279 : }
280 :
281 0 : if (m_pStringCache)
282 : {
283 0 : delete m_pStringCache;
284 0 : m_pStringCache = NULL;
285 : }
286 :
287 0 : sal_uInt32 offset = 0;
288 0 : sal_uInt16 numOfStrings = 0;
289 :
290 0 : if (m_numOfEntries)
291 : {
292 0 : m_pIndex = new sal_Int32[m_numOfEntries];
293 :
294 0 : for (int i = 0; i < m_numOfEntries; i++)
295 : {
296 0 : m_pIndex[i] = offset;
297 :
298 0 : offset += readUINT32(offset);
299 :
300 0 : if ( ((CPInfoTag) readUINT16(m_pIndex[i] + CP_OFFSET_ENTRY_TAG)) ==
301 : CP_TAG_CONST_STRING )
302 : {
303 0 : numOfStrings++;
304 : }
305 :
306 : }
307 : }
308 :
309 0 : if (numOfStrings)
310 : {
311 0 : m_pStringCache = new StringCache(numOfStrings);
312 : }
313 :
314 0 : m_bufferLen = offset;
315 :
316 0 : return offset;
317 : }
318 :
319 0 : CPInfoTag ConstantPool::readTag(sal_uInt16 index)
320 : {
321 0 : CPInfoTag tag = CP_TAG_INVALID;
322 :
323 0 : if (m_pIndex && (index > 0) && (index <= m_numOfEntries))
324 : {
325 0 : tag = (CPInfoTag) readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG);
326 : }
327 :
328 0 : return tag;
329 : }
330 :
331 0 : const sal_Char* ConstantPool::readUTF8NameConstant(sal_uInt16 index)
332 : {
333 0 : const sal_Char* aName = NULL_STRING;
334 :
335 0 : if (m_pIndex && (index > 0) && (index <= m_numOfEntries))
336 : {
337 0 : if (readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG) == CP_TAG_UTF8_NAME)
338 : {
339 0 : aName = (const sal_Char*) (m_pBuffer + m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA);
340 : }
341 : }
342 :
343 0 : return aName;
344 : }
345 :
346 0 : bool ConstantPool::readBOOLConstant(sal_uInt16 index)
347 : {
348 0 : bool aBool = false;
349 :
350 0 : if (m_pIndex && (index> 0) && (index <= m_numOfEntries))
351 : {
352 0 : if (readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG) == CP_TAG_CONST_BOOL)
353 : {
354 0 : aBool = readBYTE(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA) != 0;
355 : }
356 : }
357 :
358 0 : return aBool;
359 : }
360 :
361 0 : sal_Int8 ConstantPool::readBYTEConstant(sal_uInt16 index)
362 : {
363 0 : sal_Int8 aByte = 0;
364 :
365 0 : if (m_pIndex && (index> 0) && (index <= m_numOfEntries))
366 : {
367 0 : if (readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG) == CP_TAG_CONST_BYTE)
368 : {
369 : aByte = static_cast< sal_Int8 >(
370 0 : readBYTE(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA));
371 : }
372 : }
373 :
374 0 : return aByte;
375 : }
376 :
377 0 : sal_Int16 ConstantPool::readINT16Constant(sal_uInt16 index)
378 : {
379 0 : sal_Int16 aINT16 = 0;
380 :
381 0 : if (m_pIndex && (index> 0) && (index <= m_numOfEntries))
382 : {
383 0 : if (readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG) == CP_TAG_CONST_INT16)
384 : {
385 0 : aINT16 = readINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA);
386 : }
387 : }
388 :
389 0 : return aINT16;
390 : }
391 :
392 0 : sal_uInt16 ConstantPool::readUINT16Constant(sal_uInt16 index)
393 : {
394 0 : sal_uInt16 asal_uInt16 = 0;
395 :
396 0 : if (m_pIndex && (index> 0) && (index <= m_numOfEntries))
397 : {
398 0 : if (readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG) == CP_TAG_CONST_UINT16)
399 : {
400 0 : asal_uInt16 = readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA);
401 : }
402 : }
403 :
404 0 : return asal_uInt16;
405 : }
406 :
407 0 : sal_Int32 ConstantPool::readINT32Constant(sal_uInt16 index)
408 : {
409 0 : sal_Int32 aINT32 = 0;
410 :
411 0 : if (m_pIndex && (index> 0) && (index <= m_numOfEntries))
412 : {
413 0 : if (readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG) == CP_TAG_CONST_INT32)
414 : {
415 0 : aINT32 = readINT32(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA);
416 : }
417 : }
418 :
419 0 : return aINT32;
420 : }
421 :
422 0 : sal_uInt32 ConstantPool::readUINT32Constant(sal_uInt16 index)
423 : {
424 0 : sal_uInt32 aUINT32 = 0;
425 :
426 0 : if (m_pIndex && (index> 0) && (index <= m_numOfEntries))
427 : {
428 0 : if (readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG) == CP_TAG_CONST_UINT32)
429 : {
430 0 : aUINT32 = readUINT32(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA);
431 : }
432 : }
433 :
434 0 : return aUINT32;
435 : }
436 :
437 0 : sal_Int64 ConstantPool::readINT64Constant(sal_uInt16 index)
438 : {
439 0 : sal_Int64 aINT64 = 0;
440 :
441 0 : if (m_pIndex && (index> 0) && (index <= m_numOfEntries))
442 : {
443 0 : if (readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG) == CP_TAG_CONST_INT64)
444 : {
445 0 : aINT64 = readINT64(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA);
446 : }
447 : }
448 :
449 0 : return aINT64;
450 : }
451 :
452 0 : sal_uInt64 ConstantPool::readUINT64Constant(sal_uInt16 index)
453 : {
454 0 : sal_uInt64 aUINT64 = 0;
455 :
456 0 : if (m_pIndex && (index> 0) && (index <= m_numOfEntries))
457 : {
458 0 : if (readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG) == CP_TAG_CONST_UINT64)
459 : {
460 0 : aUINT64 = readUINT64(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA);
461 : }
462 : }
463 :
464 0 : return aUINT64;
465 : }
466 :
467 0 : float ConstantPool::readFloatConstant(sal_uInt16 index)
468 : {
469 : union
470 : {
471 : float v;
472 : sal_uInt32 b;
473 0 : } x = { 0.0f };
474 :
475 0 : if (m_pIndex && (index> 0) && (index <= m_numOfEntries))
476 : {
477 0 : if (readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG) == CP_TAG_CONST_FLOAT)
478 : {
479 : #ifdef REGTYPE_IEEE_NATIVE
480 0 : x.b = readUINT32(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA);
481 : #else
482 : # error no IEEE
483 : #endif
484 : }
485 : }
486 :
487 0 : return x.v;
488 : }
489 :
490 0 : double ConstantPool::readDoubleConstant(sal_uInt16 index)
491 : {
492 : union
493 : {
494 : double v;
495 : struct
496 : {
497 : sal_uInt32 b1;
498 : sal_uInt32 b2;
499 : } b;
500 0 : } x = { 0.0 };
501 :
502 0 : if (m_pIndex && (index> 0) && (index <= m_numOfEntries))
503 : {
504 0 : if (readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG) == CP_TAG_CONST_DOUBLE)
505 : {
506 :
507 : #ifdef REGTYPE_IEEE_NATIVE
508 : # ifdef OSL_BIGENDIAN
509 : x.b.b1 = readUINT32(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA);
510 : x.b.b2 = readUINT32(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA + sizeof(sal_uInt32));
511 : # else
512 0 : x.b.b1 = readUINT32(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA + sizeof(sal_uInt32));
513 0 : x.b.b2 = readUINT32(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA);
514 : # endif
515 : #else
516 : # error no IEEE
517 : #endif
518 : }
519 : }
520 :
521 0 : return x.v;
522 : }
523 :
524 0 : const sal_Unicode* ConstantPool::readStringConstant(sal_uInt16 index)
525 : {
526 0 : const sal_Unicode* aString = NULL_WSTRING;
527 :
528 0 : if (m_pIndex && (index> 0) && (index <= m_numOfEntries) && m_pStringCache)
529 : {
530 0 : if (m_pIndex[index - 1] >= 0)
531 : {
532 : // create cached string now
533 :
534 0 : if (readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG) == CP_TAG_CONST_STRING)
535 : {
536 0 : m_pIndex[index - 1] = -1 * m_pStringCache->createString(m_pBuffer + m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA);
537 : }
538 : }
539 :
540 0 : aString = m_pStringCache->getString((sal_uInt16) (m_pIndex[index - 1] * -1));
541 : }
542 :
543 0 : return aString;
544 : }
545 :
546 0 : void ConstantPool::readUIK(sal_uInt16 index, RTUik* uik)
547 : {
548 0 : if (index == 0)
549 : {
550 0 : uik->m_Data1 = 0;
551 0 : uik->m_Data2 = 0;
552 0 : uik->m_Data3 = 0;
553 0 : uik->m_Data4 = 0;
554 0 : uik->m_Data5 = 0;
555 : }
556 0 : else if (m_pIndex && (index <= m_numOfEntries))
557 : {
558 0 : if (readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG) == CP_TAG_UIK)
559 : {
560 0 : uik->m_Data1 = readUINT32(m_pIndex[index - 1] + CP_OFFSET_ENTRY_UIK1);
561 0 : uik->m_Data2 = readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_UIK2);
562 0 : uik->m_Data3 = readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_UIK3);
563 0 : uik->m_Data4 = readUINT32(m_pIndex[index - 1] + CP_OFFSET_ENTRY_UIK4);
564 0 : uik->m_Data5 = readUINT32(m_pIndex[index - 1] + CP_OFFSET_ENTRY_UIK5);
565 : }
566 : }
567 0 : }
568 :
569 : /**************************************************************************
570 :
571 : class FieldList
572 :
573 : **************************************************************************/
574 :
575 0 : class FieldList : public BlopObject
576 : {
577 : public:
578 :
579 : sal_uInt16 m_numOfEntries;
580 : sal_uInt16 m_numOfFieldEntries;
581 : sal_uInt16 m_FIELD_ENTRY_SIZE;
582 : ConstantPool* m_pCP;
583 :
584 0 : FieldList(const sal_uInt8* buffer, sal_uInt16 numEntries, ConstantPool* pCP)
585 : : BlopObject(buffer, 0, false)
586 : , m_numOfEntries(numEntries)
587 0 : , m_pCP(pCP)
588 : {
589 0 : if ( m_numOfEntries > 0 )
590 : {
591 0 : m_numOfFieldEntries = readUINT16(0);
592 0 : m_FIELD_ENTRY_SIZE = m_numOfFieldEntries * sizeof(sal_uInt16);
593 : } else
594 : {
595 0 : m_numOfFieldEntries = 0;
596 0 : m_FIELD_ENTRY_SIZE = 0;
597 : }
598 0 : }
599 :
600 : sal_uInt32 parseIndex();
601 :
602 : const sal_Char* getFieldName(sal_uInt16 index);
603 : const sal_Char* getFieldType(sal_uInt16 index);
604 : RTFieldAccess getFieldAccess(sal_uInt16 index);
605 : RTValueType getFieldConstValue(sal_uInt16 index, RTConstValueUnion* value);
606 : // throws std::bad_alloc
607 : const sal_Char* getFieldDoku(sal_uInt16 index);
608 : const sal_Char* getFieldFileName(sal_uInt16 index);
609 : };
610 :
611 0 : sal_uInt32 FieldList::parseIndex()
612 : {
613 0 : return ((m_numOfEntries ? sizeof(sal_uInt16) : 0) + (m_numOfEntries * m_FIELD_ENTRY_SIZE));
614 : }
615 :
616 0 : const sal_Char* FieldList::getFieldName(sal_uInt16 index)
617 : {
618 0 : const sal_Char* aName = NULL;
619 :
620 0 : if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
621 : {
622 0 : aName = m_pCP->readUTF8NameConstant(readUINT16(sizeof(sal_uInt16) + (index * m_FIELD_ENTRY_SIZE) + FIELD_OFFSET_NAME));
623 : }
624 :
625 0 : return aName;
626 : }
627 :
628 0 : const sal_Char* FieldList::getFieldType(sal_uInt16 index)
629 : {
630 0 : const sal_Char* aName = NULL;
631 :
632 0 : if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
633 : {
634 0 : aName = m_pCP->readUTF8NameConstant(readUINT16(sizeof(sal_uInt16) + (index * m_FIELD_ENTRY_SIZE) + FIELD_OFFSET_TYPE));
635 : }
636 :
637 0 : return aName;
638 : }
639 :
640 0 : RTFieldAccess FieldList::getFieldAccess(sal_uInt16 index)
641 : {
642 0 : RTFieldAccess aAccess = RT_ACCESS_INVALID;
643 :
644 0 : if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
645 : {
646 0 : aAccess = (RTFieldAccess) readUINT16(sizeof(sal_uInt16) + (index * m_FIELD_ENTRY_SIZE) + FIELD_OFFSET_ACCESS);
647 : }
648 :
649 0 : return aAccess;
650 : }
651 :
652 0 : RTValueType FieldList::getFieldConstValue(sal_uInt16 index, RTConstValueUnion* value)
653 : {
654 0 : RTValueType ret = RT_TYPE_NONE;
655 :
656 0 : if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
657 : {
658 0 : sal_uInt16 cpIndex = readUINT16(sizeof(sal_uInt16) + (index * m_FIELD_ENTRY_SIZE) + FIELD_OFFSET_VALUE);
659 :
660 0 : switch (m_pCP->readTag(cpIndex))
661 : {
662 : case CP_TAG_CONST_BOOL:
663 0 : value->aBool = m_pCP->readBOOLConstant(cpIndex);
664 0 : ret = RT_TYPE_BOOL;
665 0 : break;
666 : case CP_TAG_CONST_BYTE:
667 0 : value->aByte = m_pCP->readBYTEConstant(cpIndex);
668 0 : ret = RT_TYPE_BYTE;
669 0 : break;
670 : case CP_TAG_CONST_INT16:
671 0 : value->aShort = m_pCP->readINT16Constant(cpIndex);
672 0 : ret = RT_TYPE_INT16;
673 0 : break;
674 : case CP_TAG_CONST_UINT16:
675 0 : value->aUShort = m_pCP->readUINT16Constant(cpIndex);
676 0 : ret = RT_TYPE_UINT16;
677 0 : break;
678 : case CP_TAG_CONST_INT32:
679 0 : value->aLong = m_pCP->readINT32Constant(cpIndex);
680 0 : ret = RT_TYPE_INT32;
681 0 : break;
682 : case CP_TAG_CONST_UINT32:
683 0 : value->aULong = m_pCP->readUINT32Constant(cpIndex);
684 0 : ret = RT_TYPE_UINT32;
685 0 : break;
686 : case CP_TAG_CONST_INT64:
687 0 : value->aHyper = m_pCP->readINT64Constant(cpIndex);
688 0 : ret = RT_TYPE_INT64;
689 0 : break;
690 : case CP_TAG_CONST_UINT64:
691 0 : value->aUHyper = m_pCP->readUINT64Constant(cpIndex);
692 0 : ret = RT_TYPE_UINT64;
693 0 : break;
694 : case CP_TAG_CONST_FLOAT:
695 0 : value->aFloat = m_pCP->readFloatConstant(cpIndex);
696 0 : ret = RT_TYPE_FLOAT;
697 0 : break;
698 : case CP_TAG_CONST_DOUBLE:
699 0 : value->aDouble = m_pCP->readDoubleConstant(cpIndex);
700 0 : ret = RT_TYPE_DOUBLE;
701 0 : break;
702 : case CP_TAG_CONST_STRING:
703 0 : value->aString = m_pCP->readStringConstant(cpIndex);
704 0 : ret = RT_TYPE_STRING;
705 0 : break;
706 : default:
707 0 : break;
708 : }
709 : }
710 :
711 0 : return ret;
712 : }
713 :
714 0 : const sal_Char* FieldList::getFieldDoku(sal_uInt16 index)
715 : {
716 0 : const sal_Char* aDoku = NULL;
717 :
718 0 : if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
719 : {
720 0 : aDoku = m_pCP->readUTF8NameConstant(readUINT16(sizeof(sal_uInt16) + (index * m_FIELD_ENTRY_SIZE) + FIELD_OFFSET_DOKU));
721 : }
722 :
723 0 : return aDoku;
724 : }
725 :
726 0 : const sal_Char* FieldList::getFieldFileName(sal_uInt16 index)
727 : {
728 0 : const sal_Char* aFileName = NULL;
729 :
730 0 : if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
731 : {
732 0 : aFileName = m_pCP->readUTF8NameConstant(readUINT16(sizeof(sal_uInt16) + (index * m_FIELD_ENTRY_SIZE) + FIELD_OFFSET_FILENAME));
733 : }
734 :
735 0 : return aFileName;
736 : }
737 :
738 : /**************************************************************************
739 :
740 : class ReferenceList
741 :
742 : **************************************************************************/
743 :
744 0 : class ReferenceList : public BlopObject
745 : {
746 : public:
747 :
748 : sal_uInt16 m_numOfEntries;
749 : sal_uInt16 m_numOfReferenceEntries;
750 : sal_uInt16 m_REFERENCE_ENTRY_SIZE;
751 : ConstantPool* m_pCP;
752 :
753 0 : ReferenceList(const sal_uInt8* buffer, sal_uInt16 numEntries, ConstantPool* pCP)
754 : : BlopObject(buffer, 0, false)
755 : , m_numOfEntries(numEntries)
756 0 : , m_pCP(pCP)
757 : {
758 0 : if ( m_numOfEntries > 0 )
759 : {
760 0 : m_numOfReferenceEntries = readUINT16(0);
761 0 : m_REFERENCE_ENTRY_SIZE = m_numOfReferenceEntries * sizeof(sal_uInt16);
762 : } else
763 : {
764 0 : m_numOfReferenceEntries = 0;
765 0 : m_REFERENCE_ENTRY_SIZE = 0;
766 : }
767 0 : }
768 :
769 : sal_uInt32 parseIndex();
770 :
771 : const sal_Char* getReferenceName(sal_uInt16 index);
772 : RTReferenceType getReferenceType(sal_uInt16 index);
773 : const sal_Char* getReferenceDoku(sal_uInt16 index);
774 : RTFieldAccess getReferenceAccess(sal_uInt16 index);
775 : };
776 :
777 0 : sal_uInt32 ReferenceList::parseIndex()
778 : {
779 0 : return ((m_numOfEntries ? sizeof(sal_uInt16) : 0) + (m_numOfEntries * m_REFERENCE_ENTRY_SIZE));
780 : }
781 :
782 0 : const sal_Char* ReferenceList::getReferenceName(sal_uInt16 index)
783 : {
784 0 : const sal_Char* aName = NULL;
785 :
786 0 : if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
787 : {
788 0 : aName = m_pCP->readUTF8NameConstant(readUINT16(sizeof(sal_uInt16) + (index * m_REFERENCE_ENTRY_SIZE) + REFERENCE_OFFSET_NAME));
789 : }
790 :
791 0 : return aName;
792 : }
793 :
794 0 : RTReferenceType ReferenceList::getReferenceType(sal_uInt16 index)
795 : {
796 0 : RTReferenceType refType = RT_REF_INVALID;
797 :
798 0 : if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
799 : {
800 0 : refType = (RTReferenceType) readUINT16(sizeof(sal_uInt16) + (index * m_REFERENCE_ENTRY_SIZE) + REFERENCE_OFFSET_TYPE);
801 : }
802 :
803 0 : return refType;
804 : }
805 :
806 0 : const sal_Char* ReferenceList::getReferenceDoku(sal_uInt16 index)
807 : {
808 0 : const sal_Char* aDoku = NULL;
809 :
810 0 : if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
811 : {
812 0 : aDoku = m_pCP->readUTF8NameConstant(readUINT16(sizeof(sal_uInt16) + (index * m_REFERENCE_ENTRY_SIZE) + REFERENCE_OFFSET_DOKU));
813 : }
814 :
815 0 : return aDoku;
816 : }
817 :
818 0 : RTFieldAccess ReferenceList::getReferenceAccess(sal_uInt16 index)
819 : {
820 0 : RTFieldAccess aAccess = RT_ACCESS_INVALID;
821 :
822 0 : if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
823 : {
824 0 : aAccess = (RTFieldAccess) readUINT16(sizeof(sal_uInt16) + (index * m_REFERENCE_ENTRY_SIZE) + REFERENCE_OFFSET_ACCESS);
825 : }
826 :
827 0 : return aAccess;
828 : }
829 :
830 : /**************************************************************************
831 :
832 : class MethodList
833 :
834 : **************************************************************************/
835 :
836 : class MethodList : public BlopObject
837 : {
838 : public:
839 :
840 : sal_uInt16 m_numOfEntries;
841 : sal_uInt16 m_numOfMethodEntries;
842 : sal_uInt16 m_numOfParamEntries;
843 : sal_uInt16 m_PARAM_ENTRY_SIZE;
844 : sal_uInt32* m_pIndex;
845 : ConstantPool* m_pCP;
846 :
847 0 : MethodList(const sal_uInt8* buffer, sal_uInt16 numEntries, ConstantPool* pCP)
848 : : BlopObject(buffer, 0, false)
849 : , m_numOfEntries(numEntries)
850 : , m_pIndex(NULL)
851 0 : , m_pCP(pCP)
852 : {
853 0 : if ( m_numOfEntries > 0 )
854 : {
855 0 : m_numOfMethodEntries = readUINT16(0);
856 0 : m_numOfParamEntries = readUINT16(sizeof(sal_uInt16));
857 0 : m_PARAM_ENTRY_SIZE = m_numOfParamEntries * sizeof(sal_uInt16);
858 : } else
859 : {
860 0 : m_numOfMethodEntries = 0;
861 0 : m_numOfParamEntries = 0;
862 0 : m_PARAM_ENTRY_SIZE = 0;
863 : }
864 0 : }
865 :
866 : ~MethodList();
867 :
868 : sal_uInt32 parseIndex(); // throws std::bad_alloc
869 :
870 : const sal_Char* getMethodName(sal_uInt16 index);
871 : sal_uInt16 getMethodParamCount(sal_uInt16 index);
872 : const sal_Char* getMethodParamType(sal_uInt16 index, sal_uInt16 paramIndex);
873 : const sal_Char* getMethodParamName(sal_uInt16 index, sal_uInt16 paramIndex);
874 : RTParamMode getMethodParamMode(sal_uInt16 index, sal_uInt16 paramIndex);
875 : sal_uInt16 getMethodExcCount(sal_uInt16 index);
876 : const sal_Char* getMethodExcType(sal_uInt16 index, sal_uInt16 excIndex);
877 : const sal_Char* getMethodReturnType(sal_uInt16 index);
878 : RTMethodMode getMethodMode(sal_uInt16 index);
879 : const sal_Char* getMethodDoku(sal_uInt16 index);
880 :
881 : private:
882 : sal_uInt16 calcMethodParamIndex( const sal_uInt16 index );
883 : };
884 :
885 0 : MethodList::~MethodList()
886 : {
887 0 : if (m_pIndex) delete[] m_pIndex;
888 0 : }
889 :
890 0 : sal_uInt16 MethodList::calcMethodParamIndex( const sal_uInt16 index )
891 : {
892 0 : return (METHOD_OFFSET_PARAM_COUNT + sizeof(sal_uInt16) + (index * m_PARAM_ENTRY_SIZE));
893 : }
894 :
895 0 : sal_uInt32 MethodList::parseIndex()
896 : {
897 0 : if (m_pIndex)
898 : {
899 0 : delete[] m_pIndex;
900 0 : m_pIndex = NULL;
901 : }
902 :
903 0 : sal_uInt32 offset = 0;
904 :
905 0 : if (m_numOfEntries)
906 : {
907 0 : offset = 2 * sizeof(sal_uInt16);
908 0 : m_pIndex = new sal_uInt32[m_numOfEntries];
909 :
910 0 : for (int i = 0; i < m_numOfEntries; i++)
911 : {
912 0 : m_pIndex[i] = offset;
913 :
914 0 : offset += readUINT16(offset);
915 : }
916 : }
917 :
918 0 : return offset;
919 : }
920 :
921 0 : const sal_Char* MethodList::getMethodName(sal_uInt16 index)
922 : {
923 0 : const sal_Char* aName = NULL;
924 :
925 0 : if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
926 : {
927 0 : aName = m_pCP->readUTF8NameConstant(readUINT16(m_pIndex[index] + METHOD_OFFSET_NAME));
928 : }
929 :
930 0 : return aName;
931 : }
932 :
933 0 : sal_uInt16 MethodList::getMethodParamCount(sal_uInt16 index)
934 : {
935 0 : sal_uInt16 aCount = 0;
936 :
937 0 : if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
938 : {
939 0 : aCount = readUINT16(m_pIndex[index] + METHOD_OFFSET_PARAM_COUNT);
940 : }
941 :
942 0 : return aCount;
943 : }
944 :
945 0 : const sal_Char* MethodList::getMethodParamType(sal_uInt16 index, sal_uInt16 paramIndex)
946 : {
947 0 : const sal_Char* aName = NULL;
948 :
949 0 : if ((m_numOfEntries > 0) &&
950 0 : (index <= m_numOfEntries) &&
951 0 : (paramIndex <= readUINT16(m_pIndex[index] + METHOD_OFFSET_PARAM_COUNT)))
952 : {
953 : aName = m_pCP->readUTF8NameConstant(
954 : readUINT16(
955 0 : m_pIndex[index] +
956 0 : calcMethodParamIndex(paramIndex) +
957 0 : PARAM_OFFSET_TYPE));
958 : }
959 :
960 0 : return aName;
961 : }
962 :
963 0 : const sal_Char* MethodList::getMethodParamName(sal_uInt16 index, sal_uInt16 paramIndex)
964 : {
965 0 : const sal_Char* aName = NULL;
966 :
967 0 : if ((m_numOfEntries > 0) &&
968 0 : (index <= m_numOfEntries) &&
969 0 : (paramIndex <= readUINT16(m_pIndex[index] + METHOD_OFFSET_PARAM_COUNT)))
970 : {
971 : aName = m_pCP->readUTF8NameConstant(
972 : readUINT16(
973 0 : m_pIndex[index] +
974 0 : calcMethodParamIndex(paramIndex) +
975 0 : PARAM_OFFSET_NAME));
976 : }
977 :
978 0 : return aName;
979 : }
980 :
981 0 : RTParamMode MethodList::getMethodParamMode(sal_uInt16 index, sal_uInt16 paramIndex)
982 : {
983 0 : RTParamMode aMode = RT_PARAM_INVALID;
984 :
985 0 : if ((m_numOfEntries > 0) &&
986 0 : (index <= m_numOfEntries) &&
987 0 : (paramIndex <= readUINT16(m_pIndex[index] + METHOD_OFFSET_PARAM_COUNT)))
988 : {
989 : aMode = (RTParamMode) readUINT16(
990 0 : m_pIndex[index] +
991 0 : calcMethodParamIndex(paramIndex) +
992 0 : PARAM_OFFSET_MODE);
993 : }
994 :
995 0 : return aMode;
996 : }
997 :
998 0 : sal_uInt16 MethodList::getMethodExcCount(sal_uInt16 index)
999 : {
1000 0 : sal_uInt16 aCount = 0;
1001 :
1002 0 : if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
1003 : {
1004 0 : aCount = readUINT16(m_pIndex[index] + calcMethodParamIndex(readUINT16(m_pIndex[index] + METHOD_OFFSET_PARAM_COUNT)));
1005 : }
1006 :
1007 0 : return aCount;
1008 : }
1009 :
1010 0 : const sal_Char* MethodList::getMethodExcType(sal_uInt16 index, sal_uInt16 excIndex)
1011 : {
1012 0 : const sal_Char* aName = NULL;
1013 :
1014 0 : if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
1015 : {
1016 0 : sal_uInt32 excOffset = m_pIndex[index] + calcMethodParamIndex(readUINT16(m_pIndex[index] + METHOD_OFFSET_PARAM_COUNT));
1017 :
1018 0 : if (excIndex <= readUINT16(excOffset))
1019 : {
1020 : aName = m_pCP->readUTF8NameConstant(
1021 : readUINT16(
1022 : excOffset +
1023 : sizeof(sal_uInt16) +
1024 0 : (excIndex * sizeof(sal_uInt16))));
1025 : }
1026 : }
1027 :
1028 0 : return aName;
1029 : }
1030 :
1031 0 : const sal_Char* MethodList::getMethodReturnType(sal_uInt16 index)
1032 : {
1033 0 : const sal_Char* aName = NULL;
1034 :
1035 0 : if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
1036 : {
1037 0 : aName = m_pCP->readUTF8NameConstant(readUINT16(m_pIndex[index] + METHOD_OFFSET_RETURN));
1038 : }
1039 :
1040 0 : return aName;
1041 : }
1042 :
1043 0 : RTMethodMode MethodList::getMethodMode(sal_uInt16 index)
1044 : {
1045 0 : RTMethodMode aMode = RT_MODE_INVALID;
1046 :
1047 0 : if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
1048 : {
1049 0 : aMode = (RTMethodMode) readUINT16(m_pIndex[index] + METHOD_OFFSET_MODE);
1050 : }
1051 :
1052 0 : return aMode;
1053 : }
1054 :
1055 0 : const sal_Char* MethodList::getMethodDoku(sal_uInt16 index)
1056 : {
1057 0 : const sal_Char* aDoku = NULL;
1058 :
1059 0 : if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
1060 : {
1061 0 : aDoku = m_pCP->readUTF8NameConstant(readUINT16(m_pIndex[index] + METHOD_OFFSET_DOKU));
1062 : }
1063 :
1064 0 : return aDoku;
1065 : }
1066 :
1067 : /**************************************************************************
1068 :
1069 : class TypeRegistryEntry
1070 :
1071 : **************************************************************************/
1072 :
1073 : class TypeRegistryEntry: public BlopObject {
1074 : public:
1075 : ConstantPool* m_pCP;
1076 : FieldList* m_pFields;
1077 : MethodList* m_pMethods;
1078 : ReferenceList* m_pReferences;
1079 : sal_uInt32 m_refCount;
1080 : sal_uInt16 m_nSuperTypes;
1081 : sal_uInt16 m_offset_SUPERTYPES;
1082 :
1083 : TypeRegistryEntry(
1084 : const sal_uInt8* buffer, sal_uInt32 len, bool copyBuffer);
1085 : // throws std::bad_alloc
1086 :
1087 : ~TypeRegistryEntry();
1088 :
1089 : typereg_Version getVersion() const;
1090 : };
1091 :
1092 0 : TypeRegistryEntry::TypeRegistryEntry(
1093 : const sal_uInt8* buffer, sal_uInt32 len, bool copyBuffer):
1094 : BlopObject(buffer, len, copyBuffer), m_pCP(NULL), m_pFields(NULL),
1095 : m_pMethods(NULL), m_pReferences(NULL), m_refCount(1), m_nSuperTypes(0),
1096 0 : m_offset_SUPERTYPES(0)
1097 : {
1098 0 : std::size_t const entrySize = sizeof(sal_uInt16);
1099 0 : sal_uInt16 nHeaderEntries = readUINT16(OFFSET_N_ENTRIES);
1100 0 : sal_uInt16 offset_N_SUPERTYPES = OFFSET_N_ENTRIES + entrySize + (nHeaderEntries * entrySize);
1101 0 : m_offset_SUPERTYPES = offset_N_SUPERTYPES + entrySize;
1102 0 : m_nSuperTypes = readUINT16(offset_N_SUPERTYPES);
1103 :
1104 0 : sal_uInt16 offset_CP_SIZE = m_offset_SUPERTYPES + (m_nSuperTypes * entrySize);
1105 0 : sal_uInt16 offset_CP = offset_CP_SIZE + entrySize;
1106 :
1107 0 : m_pCP = new ConstantPool(m_pBuffer + offset_CP, readUINT16(offset_CP_SIZE));
1108 :
1109 0 : sal_uInt32 offset = offset_CP + m_pCP->parseIndex();
1110 :
1111 : m_pFields = new FieldList(
1112 0 : m_pBuffer + offset + entrySize, readUINT16(offset), m_pCP);
1113 :
1114 0 : offset += sizeof(sal_uInt16) + m_pFields->parseIndex();
1115 :
1116 : m_pMethods = new MethodList(
1117 0 : m_pBuffer + offset + entrySize, readUINT16(offset), m_pCP);
1118 :
1119 0 : offset += sizeof(sal_uInt16) + m_pMethods->parseIndex();
1120 :
1121 : m_pReferences = new ReferenceList(
1122 0 : m_pBuffer + offset + entrySize, readUINT16(offset), m_pCP);
1123 :
1124 0 : m_pReferences->parseIndex();
1125 0 : }
1126 :
1127 0 : TypeRegistryEntry::~TypeRegistryEntry()
1128 : {
1129 0 : delete m_pCP;
1130 0 : delete m_pFields;
1131 0 : delete m_pMethods;
1132 0 : delete m_pReferences;
1133 0 : }
1134 :
1135 0 : typereg_Version TypeRegistryEntry::getVersion() const {
1136 : // Assumes two's complement arithmetic with modulo-semantics:
1137 0 : return static_cast< typereg_Version >(readUINT32(OFFSET_MAGIC) - magic);
1138 : }
1139 :
1140 : /**************************************************************************
1141 :
1142 : C-API
1143 :
1144 : **************************************************************************/
1145 :
1146 : extern "C" {
1147 :
1148 0 : REG_DLLPUBLIC sal_Bool TYPEREG_CALLTYPE typereg_reader_create(
1149 : void const * buffer, sal_uInt32 length, sal_Bool copy,
1150 : typereg_Version maxVersion, void ** result)
1151 : SAL_THROW_EXTERN_C()
1152 : {
1153 0 : if (length < OFFSET_CP || length > SAL_MAX_UINT32) {
1154 0 : *result = 0;
1155 0 : return true;
1156 : }
1157 0 : std::auto_ptr< TypeRegistryEntry > entry;
1158 : try {
1159 : entry.reset(
1160 : new TypeRegistryEntry(
1161 : static_cast< sal_uInt8 const * >(buffer),
1162 0 : static_cast< sal_uInt32 >(length), copy));
1163 0 : } catch (std::bad_alloc &) {
1164 0 : return false;
1165 : }
1166 0 : if (entry->readUINT32(OFFSET_SIZE) != length) {
1167 0 : *result = 0;
1168 0 : return true;
1169 : }
1170 0 : typereg_Version version = entry->getVersion();
1171 0 : if (version < TYPEREG_VERSION_0 || version > maxVersion) {
1172 0 : *result = 0;
1173 0 : return true;
1174 : }
1175 0 : *result = entry.release();
1176 0 : return true;
1177 : }
1178 :
1179 0 : static TypeReaderImpl TYPEREG_CALLTYPE createEntry(const sal_uInt8* buffer, sal_uInt32 len, sal_Bool copyBuffer)
1180 : {
1181 : void * handle;
1182 0 : typereg_reader_create(buffer, len, copyBuffer, TYPEREG_VERSION_1, &handle);
1183 0 : return handle;
1184 : }
1185 :
1186 0 : REG_DLLPUBLIC void TYPEREG_CALLTYPE typereg_reader_acquire(void * hEntry) SAL_THROW_EXTERN_C()
1187 : {
1188 0 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1189 :
1190 0 : if (pEntry != NULL)
1191 0 : pEntry->m_refCount++;
1192 0 : }
1193 :
1194 0 : REG_DLLPUBLIC void TYPEREG_CALLTYPE typereg_reader_release(void * hEntry) SAL_THROW_EXTERN_C()
1195 : {
1196 0 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1197 :
1198 0 : if (pEntry != NULL)
1199 : {
1200 0 : if (--pEntry->m_refCount == 0)
1201 0 : delete pEntry;
1202 : }
1203 0 : }
1204 :
1205 0 : REG_DLLPUBLIC typereg_Version TYPEREG_CALLTYPE typereg_reader_getVersion(void * handle) SAL_THROW_EXTERN_C() {
1206 : return handle == 0
1207 : ? TYPEREG_VERSION_0
1208 0 : : static_cast< TypeRegistryEntry * >(handle)->getVersion();
1209 : }
1210 :
1211 0 : static sal_uInt16 TYPEREG_CALLTYPE getMinorVersion(TypeReaderImpl hEntry)
1212 : {
1213 0 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1214 :
1215 0 : if (pEntry == NULL) return 0;
1216 :
1217 0 : return pEntry->readUINT16(OFFSET_MINOR_VERSION);
1218 : }
1219 :
1220 0 : static sal_uInt16 TYPEREG_CALLTYPE getMajorVersion(TypeReaderImpl hEntry)
1221 : {
1222 0 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1223 :
1224 0 : if (pEntry == NULL) return 0;
1225 :
1226 0 : return pEntry->readUINT16(OFFSET_MAJOR_VERSION);
1227 : }
1228 :
1229 0 : REG_DLLPUBLIC RTTypeClass TYPEREG_CALLTYPE typereg_reader_getTypeClass(void * hEntry) SAL_THROW_EXTERN_C()
1230 : {
1231 0 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1232 :
1233 0 : if (pEntry == NULL) return RT_TYPE_INVALID;
1234 :
1235 : return (RTTypeClass)
1236 0 : (pEntry->readUINT16(OFFSET_TYPE_CLASS) & ~RT_TYPE_PUBLISHED);
1237 : }
1238 :
1239 0 : REG_DLLPUBLIC sal_Bool TYPEREG_CALLTYPE typereg_reader_isPublished(void * hEntry) SAL_THROW_EXTERN_C()
1240 : {
1241 0 : TypeRegistryEntry * entry = static_cast< TypeRegistryEntry * >(hEntry);
1242 : return entry != 0
1243 0 : && (entry->readUINT16(OFFSET_TYPE_CLASS) & RT_TYPE_PUBLISHED) != 0;
1244 : }
1245 :
1246 0 : REG_DLLPUBLIC void TYPEREG_CALLTYPE typereg_reader_getTypeName(void * hEntry, rtl_uString** pTypeName)
1247 : SAL_THROW_EXTERN_C()
1248 : {
1249 0 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1250 :
1251 0 : if (pEntry == NULL)
1252 : {
1253 0 : rtl_uString_new(pTypeName);
1254 0 : return;
1255 : }
1256 :
1257 0 : const sal_Char* pTmp = pEntry->m_pCP->readUTF8NameConstant(pEntry->readUINT16(OFFSET_THIS_TYPE));
1258 : rtl_string2UString(
1259 : pTypeName, pTmp, pTmp == 0 ? 0 : rtl_str_getLength(pTmp),
1260 0 : RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS);
1261 : }
1262 :
1263 :
1264 0 : static void TYPEREG_CALLTYPE getSuperTypeName(TypeReaderImpl hEntry, rtl_uString** pSuperTypeName)
1265 : {
1266 0 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1267 :
1268 0 : if (pEntry == NULL)
1269 : {
1270 0 : rtl_uString_new(pSuperTypeName);
1271 0 : return;
1272 : }
1273 :
1274 0 : if (pEntry->m_nSuperTypes == 0)
1275 : {
1276 0 : rtl_uString_new(pSuperTypeName);
1277 0 : return;
1278 : }
1279 :
1280 0 : const sal_Char* pTmp = pEntry->m_pCP->readUTF8NameConstant(pEntry->readUINT16(pEntry->m_offset_SUPERTYPES )); //+ (index * sizeof(sal_uInt16))));
1281 : rtl_string2UString(
1282 : pSuperTypeName, pTmp, pTmp == 0 ? 0 : rtl_str_getLength(pTmp),
1283 0 : RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS);
1284 : }
1285 :
1286 0 : static void TYPEREG_CALLTYPE getUik(TypeReaderImpl hEntry, RTUik* uik)
1287 : {
1288 0 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1289 :
1290 0 : if (pEntry != NULL)
1291 : {
1292 0 : pEntry->m_pCP->readUIK(pEntry->readUINT16(OFFSET_UIK), uik);
1293 : }
1294 0 : }
1295 :
1296 0 : REG_DLLPUBLIC void TYPEREG_CALLTYPE typereg_reader_getDocumentation(void * hEntry, rtl_uString** pDoku)
1297 : SAL_THROW_EXTERN_C()
1298 : {
1299 0 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1300 :
1301 0 : if (pEntry == NULL)
1302 : {
1303 0 : rtl_uString_new(pDoku);
1304 0 : return;
1305 : }
1306 :
1307 0 : const sal_Char* pTmp = pEntry->m_pCP->readUTF8NameConstant(pEntry->readUINT16(OFFSET_DOKU));
1308 : rtl_string2UString(
1309 : pDoku, pTmp, pTmp == 0 ? 0 : rtl_str_getLength(pTmp),
1310 0 : RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS);
1311 : }
1312 :
1313 0 : REG_DLLPUBLIC void TYPEREG_CALLTYPE typereg_reader_getFileName(void * hEntry, rtl_uString** pFileName)
1314 : SAL_THROW_EXTERN_C()
1315 : {
1316 0 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1317 :
1318 0 : if (pEntry == NULL)
1319 : {
1320 0 : rtl_uString_new(pFileName);
1321 0 : return;
1322 : }
1323 :
1324 0 : const sal_Char* pTmp = pEntry->m_pCP->readUTF8NameConstant(pEntry->readUINT16(OFFSET_FILENAME));
1325 : rtl_string2UString(
1326 : pFileName, pTmp, pTmp == 0 ? 0 : rtl_str_getLength(pTmp),
1327 0 : RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS);
1328 : }
1329 :
1330 :
1331 0 : REG_DLLPUBLIC sal_uInt16 TYPEREG_CALLTYPE typereg_reader_getFieldCount(void * hEntry) SAL_THROW_EXTERN_C()
1332 : {
1333 0 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1334 :
1335 0 : if (pEntry == NULL) return 0;
1336 :
1337 0 : return pEntry->m_pFields->m_numOfEntries;
1338 : }
1339 :
1340 0 : static sal_uInt32 TYPEREG_CALLTYPE getFieldCount(TypeReaderImpl hEntry)
1341 : {
1342 0 : return typereg_reader_getFieldCount(hEntry);
1343 : }
1344 :
1345 0 : REG_DLLPUBLIC void TYPEREG_CALLTYPE typereg_reader_getFieldName(void * hEntry, rtl_uString** pFieldName, sal_uInt16 index)
1346 : SAL_THROW_EXTERN_C()
1347 : {
1348 0 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1349 :
1350 0 : if (pEntry == NULL)
1351 : {
1352 0 : rtl_uString_new(pFieldName);
1353 0 : return;
1354 : }
1355 0 : const sal_Char* pTmp = pEntry->m_pFields->getFieldName(index);
1356 : rtl_string2UString(
1357 : pFieldName, pTmp, pTmp == 0 ? 0 : rtl_str_getLength(pTmp),
1358 0 : RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS);
1359 : }
1360 :
1361 0 : REG_DLLPUBLIC void TYPEREG_CALLTYPE typereg_reader_getFieldTypeName(void * hEntry, rtl_uString** pFieldType, sal_uInt16 index)
1362 : SAL_THROW_EXTERN_C()
1363 : {
1364 0 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1365 :
1366 0 : if (pEntry == NULL)
1367 : {
1368 0 : rtl_uString_new(pFieldType);
1369 0 : return;
1370 : }
1371 :
1372 0 : const sal_Char* pTmp = pEntry->m_pFields->getFieldType(index);
1373 : rtl_string2UString(
1374 : pFieldType, pTmp, pTmp == 0 ? 0 : rtl_str_getLength(pTmp),
1375 0 : RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS);
1376 : }
1377 :
1378 0 : REG_DLLPUBLIC RTFieldAccess TYPEREG_CALLTYPE typereg_reader_getFieldFlags(void * hEntry, sal_uInt16 index)
1379 : SAL_THROW_EXTERN_C()
1380 : {
1381 0 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1382 :
1383 0 : if (pEntry == NULL) return RT_ACCESS_INVALID;
1384 :
1385 0 : return pEntry->m_pFields->getFieldAccess(index);
1386 : }
1387 :
1388 0 : REG_DLLPUBLIC sal_Bool TYPEREG_CALLTYPE typereg_reader_getFieldValue(
1389 : void * hEntry, sal_uInt16 index, RTValueType * type,
1390 : RTConstValueUnion * value)
1391 : SAL_THROW_EXTERN_C()
1392 : {
1393 0 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1394 :
1395 0 : if (pEntry == NULL) {
1396 0 : *type = RT_TYPE_NONE;
1397 0 : return true;
1398 : }
1399 :
1400 : try {
1401 0 : *type = pEntry->m_pFields->getFieldConstValue(index, value);
1402 0 : } catch (std::bad_alloc &) {
1403 0 : return false;
1404 : }
1405 0 : return true;
1406 : }
1407 :
1408 0 : static RTValueType TYPEREG_CALLTYPE getFieldConstValue(TypeReaderImpl hEntry, sal_uInt16 index, RTConstValueUnion* value)
1409 : {
1410 0 : RTValueType t = RT_TYPE_NONE;
1411 0 : typereg_reader_getFieldValue(hEntry, index, &t, value);
1412 0 : return t;
1413 : }
1414 :
1415 0 : REG_DLLPUBLIC void TYPEREG_CALLTYPE typereg_reader_getFieldDocumentation(void * hEntry, rtl_uString** pDoku, sal_uInt16 index)
1416 : SAL_THROW_EXTERN_C()
1417 : {
1418 0 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1419 :
1420 0 : if (pEntry == NULL)
1421 : {
1422 0 : rtl_uString_new(pDoku);
1423 0 : return;
1424 : }
1425 :
1426 0 : const sal_Char* pTmp = pEntry->m_pFields->getFieldDoku(index);
1427 : rtl_string2UString(
1428 : pDoku, pTmp, pTmp == 0 ? 0 : rtl_str_getLength(pTmp),
1429 0 : RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS);
1430 : }
1431 :
1432 0 : REG_DLLPUBLIC void TYPEREG_CALLTYPE typereg_reader_getFieldFileName(void * hEntry, rtl_uString** pFieldFileName, sal_uInt16 index)
1433 : SAL_THROW_EXTERN_C()
1434 : {
1435 0 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1436 :
1437 0 : if (pEntry == NULL)
1438 : {
1439 0 : rtl_uString_new(pFieldFileName);
1440 0 : return;
1441 : }
1442 :
1443 0 : const sal_Char* pTmp = pEntry->m_pFields->getFieldFileName(index);
1444 : rtl_string2UString(
1445 : pFieldFileName, pTmp, pTmp == 0 ? 0 : rtl_str_getLength(pTmp),
1446 0 : RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS);
1447 : }
1448 :
1449 :
1450 0 : REG_DLLPUBLIC sal_uInt16 TYPEREG_CALLTYPE typereg_reader_getMethodCount(void * hEntry) SAL_THROW_EXTERN_C()
1451 : {
1452 0 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1453 :
1454 0 : if (pEntry == NULL) return 0;
1455 :
1456 0 : return pEntry->m_pMethods->m_numOfEntries;
1457 : }
1458 :
1459 0 : static sal_uInt32 TYPEREG_CALLTYPE getMethodCount(TypeReaderImpl hEntry)
1460 : {
1461 0 : return typereg_reader_getMethodCount(hEntry);
1462 : }
1463 :
1464 0 : REG_DLLPUBLIC void TYPEREG_CALLTYPE typereg_reader_getMethodName(void * hEntry, rtl_uString** pMethodName, sal_uInt16 index)
1465 : SAL_THROW_EXTERN_C()
1466 : {
1467 0 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1468 :
1469 0 : if (pEntry == NULL)
1470 : {
1471 0 : rtl_uString_new(pMethodName);
1472 0 : return;
1473 : }
1474 :
1475 0 : const sal_Char* pTmp = pEntry->m_pMethods->getMethodName(index);
1476 : rtl_string2UString(
1477 : pMethodName, pTmp, pTmp == 0 ? 0 : rtl_str_getLength(pTmp),
1478 0 : RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS);
1479 : }
1480 :
1481 0 : REG_DLLPUBLIC sal_uInt16 TYPEREG_CALLTYPE typereg_reader_getMethodParameterCount(
1482 : void * hEntry, sal_uInt16 index) SAL_THROW_EXTERN_C()
1483 : {
1484 0 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1485 :
1486 0 : if (pEntry == NULL) return 0;
1487 :
1488 0 : return pEntry->m_pMethods->getMethodParamCount(index);
1489 : }
1490 :
1491 0 : static sal_uInt32 TYPEREG_CALLTYPE getMethodParamCount(TypeReaderImpl hEntry, sal_uInt16 index)
1492 : {
1493 0 : return typereg_reader_getMethodParameterCount(hEntry, index);
1494 : }
1495 :
1496 0 : REG_DLLPUBLIC void TYPEREG_CALLTYPE typereg_reader_getMethodParameterTypeName(void * hEntry, rtl_uString** pMethodParamType, sal_uInt16 index, sal_uInt16 paramIndex)
1497 : SAL_THROW_EXTERN_C()
1498 : {
1499 0 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1500 :
1501 0 : if (pEntry == NULL)
1502 : {
1503 0 : rtl_uString_new(pMethodParamType);
1504 0 : return;
1505 : }
1506 :
1507 0 : const sal_Char* pTmp = pEntry->m_pMethods->getMethodParamType(index, paramIndex);
1508 : rtl_string2UString(
1509 : pMethodParamType, pTmp, pTmp == 0 ? 0 : rtl_str_getLength(pTmp),
1510 0 : RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS);
1511 : }
1512 :
1513 0 : REG_DLLPUBLIC void TYPEREG_CALLTYPE typereg_reader_getMethodParameterName(void * hEntry, rtl_uString** pMethodParamName, sal_uInt16 index, sal_uInt16 paramIndex)
1514 : SAL_THROW_EXTERN_C()
1515 : {
1516 0 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1517 :
1518 0 : if (pEntry == NULL)
1519 : {
1520 0 : rtl_uString_new(pMethodParamName);
1521 0 : return;
1522 : }
1523 :
1524 0 : const sal_Char* pTmp = pEntry->m_pMethods->getMethodParamName(index, paramIndex);
1525 : rtl_string2UString(
1526 : pMethodParamName, pTmp, pTmp == 0 ? 0 : rtl_str_getLength(pTmp),
1527 0 : RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS);
1528 : }
1529 :
1530 0 : REG_DLLPUBLIC RTParamMode TYPEREG_CALLTYPE typereg_reader_getMethodParameterFlags(void * hEntry, sal_uInt16 index, sal_uInt16 paramIndex)
1531 : SAL_THROW_EXTERN_C()
1532 : {
1533 0 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1534 :
1535 0 : if (pEntry == NULL) return RT_PARAM_INVALID;
1536 :
1537 0 : return pEntry->m_pMethods->getMethodParamMode(index, paramIndex);
1538 : }
1539 :
1540 0 : REG_DLLPUBLIC sal_uInt16 TYPEREG_CALLTYPE typereg_reader_getMethodExceptionCount(
1541 : void * hEntry, sal_uInt16 index) SAL_THROW_EXTERN_C()
1542 : {
1543 0 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1544 :
1545 0 : if (pEntry == NULL) return 0;
1546 :
1547 0 : return pEntry->m_pMethods->getMethodExcCount(index);
1548 : }
1549 :
1550 0 : static sal_uInt32 TYPEREG_CALLTYPE getMethodExcCount(TypeReaderImpl hEntry, sal_uInt16 index)
1551 : {
1552 0 : return typereg_reader_getMethodExceptionCount(hEntry, index);
1553 : }
1554 :
1555 0 : REG_DLLPUBLIC void TYPEREG_CALLTYPE typereg_reader_getMethodExceptionTypeName(void * hEntry, rtl_uString** pMethodExcpType, sal_uInt16 index, sal_uInt16 excIndex)
1556 : SAL_THROW_EXTERN_C()
1557 : {
1558 0 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1559 :
1560 0 : if (pEntry == NULL)
1561 : {
1562 0 : rtl_uString_new(pMethodExcpType);
1563 0 : return;
1564 : }
1565 :
1566 0 : const sal_Char* pTmp = pEntry->m_pMethods->getMethodExcType(index, excIndex);
1567 : rtl_string2UString(
1568 : pMethodExcpType, pTmp, pTmp == 0 ? 0 : rtl_str_getLength(pTmp),
1569 0 : RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS);
1570 : }
1571 :
1572 0 : REG_DLLPUBLIC void TYPEREG_CALLTYPE typereg_reader_getMethodReturnTypeName(void * hEntry, rtl_uString** pMethodReturnType, sal_uInt16 index)
1573 : SAL_THROW_EXTERN_C()
1574 : {
1575 0 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1576 :
1577 0 : if (pEntry == NULL)
1578 : {
1579 0 : rtl_uString_new(pMethodReturnType);
1580 0 : return;
1581 : }
1582 :
1583 0 : const sal_Char* pTmp = pEntry->m_pMethods->getMethodReturnType(index);
1584 : rtl_string2UString(
1585 : pMethodReturnType, pTmp, pTmp == 0 ? 0 : rtl_str_getLength(pTmp),
1586 0 : RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS);
1587 : }
1588 :
1589 0 : REG_DLLPUBLIC RTMethodMode TYPEREG_CALLTYPE typereg_reader_getMethodFlags(void * hEntry, sal_uInt16 index)
1590 : SAL_THROW_EXTERN_C()
1591 : {
1592 0 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1593 :
1594 0 : if (pEntry == NULL) return RT_MODE_INVALID;
1595 :
1596 0 : return pEntry->m_pMethods->getMethodMode(index);
1597 : }
1598 :
1599 0 : REG_DLLPUBLIC void TYPEREG_CALLTYPE typereg_reader_getMethodDocumentation(void * hEntry, rtl_uString** pMethodDoku, sal_uInt16 index)
1600 : SAL_THROW_EXTERN_C()
1601 : {
1602 0 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1603 :
1604 0 : if (pEntry == NULL)
1605 : {
1606 0 : rtl_uString_new(pMethodDoku);
1607 0 : return;
1608 : }
1609 :
1610 0 : const sal_Char* pTmp = pEntry->m_pMethods->getMethodDoku(index);
1611 : rtl_string2UString(
1612 : pMethodDoku, pTmp, pTmp == 0 ? 0 : rtl_str_getLength(pTmp),
1613 0 : RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS);
1614 : }
1615 :
1616 0 : REG_DLLPUBLIC sal_uInt16 TYPEREG_CALLTYPE typereg_reader_getReferenceCount(void * hEntry) SAL_THROW_EXTERN_C()
1617 : {
1618 0 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1619 :
1620 0 : if (pEntry == NULL) return 0;
1621 :
1622 0 : return pEntry->m_pReferences->m_numOfEntries;
1623 : }
1624 :
1625 0 : static sal_uInt32 TYPEREG_CALLTYPE getReferenceCount(TypeReaderImpl hEntry)
1626 : {
1627 0 : return typereg_reader_getReferenceCount(hEntry);
1628 : }
1629 :
1630 0 : REG_DLLPUBLIC void TYPEREG_CALLTYPE typereg_reader_getReferenceTypeName(void * hEntry, rtl_uString** pReferenceName, sal_uInt16 index)
1631 : SAL_THROW_EXTERN_C()
1632 : {
1633 0 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1634 :
1635 0 : if (pEntry == NULL)
1636 : {
1637 0 : rtl_uString_new(pReferenceName);
1638 0 : return;
1639 : }
1640 :
1641 0 : const sal_Char* pTmp = pEntry->m_pReferences->getReferenceName(index);
1642 : rtl_string2UString(
1643 : pReferenceName, pTmp, pTmp == 0 ? 0 : rtl_str_getLength(pTmp),
1644 0 : RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS);
1645 : }
1646 :
1647 0 : REG_DLLPUBLIC RTReferenceType TYPEREG_CALLTYPE typereg_reader_getReferenceSort(void * hEntry, sal_uInt16 index)
1648 : SAL_THROW_EXTERN_C()
1649 : {
1650 0 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1651 :
1652 0 : if (pEntry == NULL) return RT_REF_INVALID;
1653 :
1654 0 : return pEntry->m_pReferences->getReferenceType(index);
1655 : }
1656 :
1657 0 : REG_DLLPUBLIC void TYPEREG_CALLTYPE typereg_reader_getReferenceDocumentation(void * hEntry, rtl_uString** pReferenceDoku, sal_uInt16 index)
1658 : SAL_THROW_EXTERN_C()
1659 : {
1660 0 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1661 :
1662 0 : if (pEntry == NULL)
1663 : {
1664 0 : rtl_uString_new(pReferenceDoku);
1665 0 : return;
1666 : }
1667 :
1668 0 : const sal_Char* pTmp = pEntry->m_pReferences->getReferenceDoku(index);
1669 : rtl_string2UString(
1670 : pReferenceDoku, pTmp, pTmp == 0 ? 0 : rtl_str_getLength(pTmp),
1671 0 : RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS);
1672 : }
1673 :
1674 0 : REG_DLLPUBLIC RTFieldAccess TYPEREG_CALLTYPE typereg_reader_getReferenceFlags(void * hEntry, sal_uInt16 index)
1675 : SAL_THROW_EXTERN_C()
1676 : {
1677 0 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1678 :
1679 0 : if (pEntry == NULL) return RT_ACCESS_INVALID;
1680 :
1681 0 : return pEntry->m_pReferences->getReferenceAccess(index);
1682 : }
1683 :
1684 0 : REG_DLLPUBLIC sal_uInt16 TYPEREG_CALLTYPE typereg_reader_getSuperTypeCount(void * hEntry)
1685 : SAL_THROW_EXTERN_C()
1686 : {
1687 0 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1688 :
1689 0 : if (pEntry == NULL) return 0;
1690 :
1691 0 : return pEntry->m_nSuperTypes;
1692 : }
1693 :
1694 0 : REG_DLLPUBLIC void TYPEREG_CALLTYPE typereg_reader_getSuperTypeName(
1695 : void * hEntry, rtl_uString ** pSuperTypeName, sal_uInt16 index)
1696 : SAL_THROW_EXTERN_C()
1697 : {
1698 0 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1699 :
1700 0 : if (pEntry == NULL)
1701 : {
1702 0 : rtl_uString_new(pSuperTypeName);
1703 0 : return;
1704 : }
1705 :
1706 : OSL_ASSERT(index < pEntry->m_nSuperTypes);
1707 0 : const sal_Char* pTmp = pEntry->m_pCP->readUTF8NameConstant(pEntry->readUINT16(pEntry->m_offset_SUPERTYPES + (index * sizeof(sal_uInt16))));
1708 : rtl_string2UString(
1709 : pSuperTypeName, pTmp, pTmp == 0 ? 0 : rtl_str_getLength(pTmp),
1710 0 : RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS);
1711 : }
1712 :
1713 0 : REG_DLLPUBLIC RegistryTypeReader_Api* TYPEREG_CALLTYPE initRegistryTypeReader_Api(void)
1714 : {
1715 : static RegistryTypeReader_Api aApi= {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
1716 0 : if (!aApi.acquire)
1717 : {
1718 0 : aApi.createEntry = &createEntry;
1719 0 : aApi.acquire = &typereg_reader_acquire;
1720 0 : aApi.release = &typereg_reader_release;
1721 0 : aApi.getMinorVersion = &getMinorVersion;
1722 0 : aApi.getMajorVersion = &getMajorVersion;
1723 0 : aApi.getTypeClass = &typereg_reader_getTypeClass;
1724 0 : aApi.getTypeName = &typereg_reader_getTypeName;
1725 0 : aApi.getSuperTypeName = &getSuperTypeName;
1726 0 : aApi.getUik = &getUik;
1727 0 : aApi.getDoku = &typereg_reader_getDocumentation;
1728 0 : aApi.getFileName = &typereg_reader_getFileName;
1729 0 : aApi.getFieldCount = &getFieldCount;
1730 0 : aApi.getFieldName = &typereg_reader_getFieldName;
1731 0 : aApi.getFieldType = &typereg_reader_getFieldTypeName;
1732 0 : aApi.getFieldAccess = &typereg_reader_getFieldFlags;
1733 0 : aApi.getFieldConstValue = &getFieldConstValue;
1734 0 : aApi.getFieldDoku = &typereg_reader_getFieldDocumentation;
1735 0 : aApi.getFieldFileName = &typereg_reader_getFieldFileName;
1736 0 : aApi.getMethodCount = &getMethodCount;
1737 0 : aApi.getMethodName = &typereg_reader_getMethodName;
1738 0 : aApi.getMethodParamCount = &getMethodParamCount;
1739 0 : aApi.getMethodParamType = &typereg_reader_getMethodParameterTypeName;
1740 0 : aApi.getMethodParamName = &typereg_reader_getMethodParameterName;
1741 0 : aApi.getMethodParamMode = &typereg_reader_getMethodParameterFlags;
1742 0 : aApi.getMethodExcCount = &getMethodExcCount;
1743 0 : aApi.getMethodExcType = &typereg_reader_getMethodExceptionTypeName;
1744 0 : aApi.getMethodReturnType = &typereg_reader_getMethodReturnTypeName;
1745 0 : aApi.getMethodMode = &typereg_reader_getMethodFlags;
1746 0 : aApi.getMethodDoku = &typereg_reader_getMethodDocumentation;
1747 0 : aApi.getReferenceCount = &getReferenceCount;
1748 0 : aApi.getReferenceName = &typereg_reader_getReferenceTypeName;
1749 0 : aApi.getReferenceType = &typereg_reader_getReferenceSort;
1750 0 : aApi.getReferenceDoku = &typereg_reader_getReferenceDocumentation;
1751 0 : aApi.getReferenceAccess = &typereg_reader_getReferenceFlags;
1752 :
1753 0 : return (&aApi);
1754 : }
1755 : else
1756 : {
1757 0 : return (&aApi);
1758 : }
1759 : }
1760 :
1761 : }
1762 :
1763 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
