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 sal_Char NULL_STRING[1] = { 0 };
37 : static 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 738 : inline sal_uInt8 readBYTE(sal_uInt32 index) const
64 : {
65 738 : return m_pBuffer[index];
66 : }
67 :
68 6153 : inline sal_Int16 readINT16(sal_uInt32 index) const
69 : {
70 6153 : return ((m_pBuffer[index] << 8) | (m_pBuffer[index+1] << 0));
71 : }
72 :
73 3364489 : inline sal_uInt16 readUINT16(sal_uInt32 index) const
74 : {
75 3364489 : return ((m_pBuffer[index] << 8) | (m_pBuffer[index+1] << 0));
76 : }
77 :
78 20255 : inline sal_Int32 readINT32(sal_uInt32 index) const
79 : {
80 : return (
81 20255 : (m_pBuffer[index] << 24) |
82 20255 : (m_pBuffer[index+1] << 16) |
83 20255 : (m_pBuffer[index+2] << 8) |
84 20255 : (m_pBuffer[index+3] << 0)
85 81020 : );
86 : }
87 :
88 1166186 : inline sal_uInt32 readUINT32(sal_uInt32 index) const
89 : {
90 : return (
91 1166186 : (m_pBuffer[index] << 24) |
92 1166186 : (m_pBuffer[index+1] << 16) |
93 1166186 : (m_pBuffer[index+2] << 8) |
94 1166186 : (m_pBuffer[index+3] << 0)
95 4664744 : );
96 : }
97 :
98 89 : inline sal_Int64 readINT64(sal_uInt32 index) const
99 : {
100 : return (
101 89 : ((sal_Int64)m_pBuffer[index] << 56) |
102 89 : ((sal_Int64)m_pBuffer[index+1] << 48) |
103 89 : ((sal_Int64)m_pBuffer[index+2] << 40) |
104 89 : ((sal_Int64)m_pBuffer[index+3] << 32) |
105 89 : ((sal_Int64)m_pBuffer[index+4] << 24) |
106 89 : ((sal_Int64)m_pBuffer[index+5] << 16) |
107 89 : ((sal_Int64)m_pBuffer[index+6] << 8) |
108 89 : ((sal_Int64)m_pBuffer[index+7] << 0)
109 712 : );
110 : }
111 :
112 2 : inline sal_uInt64 readUINT64(sal_uInt32 index) const
113 : {
114 : return (
115 2 : ((sal_uInt64)m_pBuffer[index] << 56) |
116 2 : ((sal_uInt64)m_pBuffer[index+1] << 48) |
117 2 : ((sal_uInt64)m_pBuffer[index+2] << 40) |
118 2 : ((sal_uInt64)m_pBuffer[index+3] << 32) |
119 2 : ((sal_uInt64)m_pBuffer[index+4] << 24) |
120 2 : ((sal_uInt64)m_pBuffer[index+5] << 16) |
121 2 : ((sal_uInt64)m_pBuffer[index+6] << 8) |
122 2 : ((sal_uInt64)m_pBuffer[index+7] << 0)
123 16 : );
124 : }
125 : };
126 :
127 511615 : BlopObject::BlopObject(const sal_uInt8* buffer, sal_uInt32 len, bool copyBuffer)
128 : : m_bufferLen(len)
129 511615 : , m_isCopied(copyBuffer)
130 : {
131 511615 : if (m_isCopied)
132 : {
133 41735 : m_pBuffer = 0;
134 41735 : sal_uInt8* newBuffer = new sal_uInt8[len];
135 41735 : memcpy(newBuffer, buffer, len);
136 41735 : m_pBuffer = newBuffer;
137 : }
138 : else
139 : {
140 469880 : m_pBuffer = buffer;
141 : }
142 511615 : }
143 :
144 511615 : BlopObject::~BlopObject()
145 : {
146 511615 : if (m_isCopied)
147 : {
148 41735 : delete[] const_cast<sal_uInt8*>(m_pBuffer);
149 : }
150 511615 : }
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 102323 : ConstantPool(const sal_uInt8* buffer, sal_uInt16 numEntries)
238 : : BlopObject(buffer, 0, sal_False)
239 : , m_numOfEntries(numEntries)
240 : , m_pIndex(NULL)
241 102323 : , m_pStringCache(NULL)
242 : {
243 102323 : }
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 : sal_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 204646 : ConstantPool::~ConstantPool()
268 : {
269 102323 : delete[] m_pIndex;
270 102323 : delete m_pStringCache;
271 102323 : }
272 :
273 102323 : sal_uInt32 ConstantPool::parseIndex()
274 : {
275 102323 : if (m_pIndex)
276 : {
277 0 : delete[] m_pIndex;
278 0 : m_pIndex = NULL;
279 : }
280 :
281 102323 : if (m_pStringCache)
282 : {
283 0 : delete m_pStringCache;
284 0 : m_pStringCache = NULL;
285 : }
286 :
287 102323 : sal_uInt32 offset = 0;
288 102323 : sal_uInt16 numOfStrings = 0;
289 :
290 102323 : if (m_numOfEntries)
291 : {
292 102323 : m_pIndex = new sal_Int32[m_numOfEntries];
293 :
294 1063801 : for (int i = 0; i < m_numOfEntries; i++)
295 : {
296 961478 : m_pIndex[i] = offset;
297 :
298 961478 : offset += readUINT32(offset);
299 :
300 961478 : 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 102323 : if (numOfStrings)
310 : {
311 0 : m_pStringCache = new StringCache(numOfStrings);
312 : }
313 :
314 102323 : m_bufferLen = offset;
315 :
316 102323 : return offset;
317 : }
318 :
319 30199 : CPInfoTag ConstantPool::readTag(sal_uInt16 index)
320 : {
321 30199 : CPInfoTag tag = CP_TAG_INVALID;
322 :
323 30199 : if (m_pIndex && (index > 0) && (index <= m_numOfEntries))
324 : {
325 27301 : tag = (CPInfoTag) readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG);
326 : }
327 :
328 30199 : return tag;
329 : }
330 :
331 419403 : const sal_Char* ConstantPool::readUTF8NameConstant(sal_uInt16 index)
332 : {
333 419403 : const sal_Char* aName = NULL_STRING;
334 :
335 419403 : if (m_pIndex && (index > 0) && (index <= m_numOfEntries))
336 : {
337 400500 : if (readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG) == CP_TAG_UTF8_NAME)
338 : {
339 400500 : aName = (const sal_Char*) (m_pBuffer + m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA);
340 : }
341 : }
342 :
343 419403 : return aName;
344 : }
345 :
346 0 : sal_Bool ConstantPool::readBOOLConstant(sal_uInt16 index)
347 : {
348 0 : sal_Bool aBool = sal_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 = (sal_Bool) readBYTE(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA);
355 : }
356 : }
357 :
358 0 : return aBool;
359 : }
360 :
361 738 : sal_Int8 ConstantPool::readBYTEConstant(sal_uInt16 index)
362 : {
363 738 : sal_Int8 aByte = 0;
364 :
365 738 : if (m_pIndex && (index> 0) && (index <= m_numOfEntries))
366 : {
367 738 : if (readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG) == CP_TAG_CONST_BYTE)
368 : {
369 : aByte = static_cast< sal_Int8 >(
370 738 : readBYTE(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA));
371 : }
372 : }
373 :
374 738 : return aByte;
375 : }
376 :
377 6153 : sal_Int16 ConstantPool::readINT16Constant(sal_uInt16 index)
378 : {
379 6153 : sal_Int16 aINT16 = sal_False;
380 :
381 6153 : if (m_pIndex && (index> 0) && (index <= m_numOfEntries))
382 : {
383 6153 : if (readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG) == CP_TAG_CONST_INT16)
384 : {
385 6153 : aINT16 = readINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA);
386 : }
387 : }
388 :
389 6153 : return aINT16;
390 : }
391 :
392 2 : sal_uInt16 ConstantPool::readUINT16Constant(sal_uInt16 index)
393 : {
394 2 : sal_uInt16 asal_uInt16 = sal_False;
395 :
396 2 : if (m_pIndex && (index> 0) && (index <= m_numOfEntries))
397 : {
398 2 : if (readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG) == CP_TAG_CONST_UINT16)
399 : {
400 2 : asal_uInt16 = readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA);
401 : }
402 : }
403 :
404 2 : return asal_uInt16;
405 : }
406 :
407 20255 : sal_Int32 ConstantPool::readINT32Constant(sal_uInt16 index)
408 : {
409 20255 : sal_Int32 aINT32 = sal_False;
410 :
411 20255 : if (m_pIndex && (index> 0) && (index <= m_numOfEntries))
412 : {
413 20255 : if (readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG) == CP_TAG_CONST_INT32)
414 : {
415 20255 : aINT32 = readINT32(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA);
416 : }
417 : }
418 :
419 20255 : return aINT32;
420 : }
421 :
422 2 : sal_uInt32 ConstantPool::readUINT32Constant(sal_uInt16 index)
423 : {
424 2 : sal_uInt32 aUINT32 = sal_False;
425 :
426 2 : if (m_pIndex && (index> 0) && (index <= m_numOfEntries))
427 : {
428 2 : if (readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG) == CP_TAG_CONST_UINT32)
429 : {
430 2 : aUINT32 = readUINT32(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA);
431 : }
432 : }
433 :
434 2 : return aUINT32;
435 : }
436 :
437 89 : sal_Int64 ConstantPool::readINT64Constant(sal_uInt16 index)
438 : {
439 89 : sal_Int64 aINT64 = sal_False;
440 :
441 89 : if (m_pIndex && (index> 0) && (index <= m_numOfEntries))
442 : {
443 89 : if (readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG) == CP_TAG_CONST_INT64)
444 : {
445 89 : aINT64 = readINT64(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA);
446 : }
447 : }
448 :
449 89 : return aINT64;
450 : }
451 :
452 2 : sal_uInt64 ConstantPool::readUINT64Constant(sal_uInt16 index)
453 : {
454 2 : sal_uInt64 aUINT64 = sal_False;
455 :
456 2 : if (m_pIndex && (index> 0) && (index <= m_numOfEntries))
457 : {
458 2 : if (readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG) == CP_TAG_CONST_UINT64)
459 : {
460 2 : aUINT64 = readUINT64(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA);
461 : }
462 : }
463 :
464 2 : return aUINT64;
465 : }
466 :
467 60 : float ConstantPool::readFloatConstant(sal_uInt16 index)
468 : {
469 : union
470 : {
471 : float v;
472 : sal_uInt32 b;
473 60 : } x = { 0.0f };
474 :
475 60 : if (m_pIndex && (index> 0) && (index <= m_numOfEntries))
476 : {
477 60 : if (readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG) == CP_TAG_CONST_FLOAT)
478 : {
479 : #ifdef REGTYPE_IEEE_NATIVE
480 60 : x.b = readUINT32(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA);
481 : #else
482 : # error no IEEE
483 : #endif
484 : }
485 : }
486 :
487 60 : 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 102323 : 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 102323 : FieldList(const sal_uInt8* buffer, sal_uInt16 numEntries, ConstantPool* pCP)
585 : : BlopObject(buffer, 0, sal_False)
586 : , m_numOfEntries(numEntries)
587 102323 : , m_pCP(pCP)
588 : {
589 102323 : if ( m_numOfEntries > 0 )
590 : {
591 24148 : m_numOfFieldEntries = readUINT16(0);
592 24148 : m_FIELD_ENTRY_SIZE = m_numOfFieldEntries * sizeof(sal_uInt16);
593 : } else
594 : {
595 78175 : m_numOfFieldEntries = 0;
596 78175 : m_FIELD_ENTRY_SIZE = 0;
597 : }
598 102323 : }
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 102323 : sal_uInt32 FieldList::parseIndex()
612 : {
613 102323 : return ((m_numOfEntries ? sizeof(sal_uInt16) : 0) + (m_numOfEntries * m_FIELD_ENTRY_SIZE));
614 : }
615 :
616 67329 : const sal_Char* FieldList::getFieldName(sal_uInt16 index)
617 : {
618 67329 : const sal_Char* aName = NULL;
619 :
620 67329 : if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
621 : {
622 67329 : aName = m_pCP->readUTF8NameConstant(readUINT16(sizeof(sal_uInt16) + (index * m_FIELD_ENTRY_SIZE) + FIELD_OFFSET_NAME));
623 : }
624 :
625 67329 : return aName;
626 : }
627 :
628 82019 : const sal_Char* FieldList::getFieldType(sal_uInt16 index)
629 : {
630 82019 : const sal_Char* aName = NULL;
631 :
632 82019 : if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
633 : {
634 82019 : aName = m_pCP->readUTF8NameConstant(readUINT16(sizeof(sal_uInt16) + (index * m_FIELD_ENTRY_SIZE) + FIELD_OFFSET_TYPE));
635 : }
636 :
637 82019 : return aName;
638 : }
639 :
640 73808 : RTFieldAccess FieldList::getFieldAccess(sal_uInt16 index)
641 : {
642 73808 : RTFieldAccess aAccess = RT_ACCESS_INVALID;
643 :
644 73808 : if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
645 : {
646 73808 : aAccess = (RTFieldAccess) readUINT16(sizeof(sal_uInt16) + (index * m_FIELD_ENTRY_SIZE) + FIELD_OFFSET_ACCESS);
647 : }
648 :
649 73808 : return aAccess;
650 : }
651 :
652 30199 : RTValueType FieldList::getFieldConstValue(sal_uInt16 index, RTConstValueUnion* value)
653 : {
654 30199 : RTValueType ret = RT_TYPE_NONE;
655 :
656 30199 : if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
657 : {
658 30199 : sal_uInt16 cpIndex = readUINT16(sizeof(sal_uInt16) + (index * m_FIELD_ENTRY_SIZE) + FIELD_OFFSET_VALUE);
659 :
660 30199 : 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 738 : value->aByte = m_pCP->readBYTEConstant(cpIndex);
668 738 : ret = RT_TYPE_BYTE;
669 738 : break;
670 : case CP_TAG_CONST_INT16:
671 6153 : value->aShort = m_pCP->readINT16Constant(cpIndex);
672 6153 : ret = RT_TYPE_INT16;
673 6153 : break;
674 : case CP_TAG_CONST_UINT16:
675 2 : value->aUShort = m_pCP->readUINT16Constant(cpIndex);
676 2 : ret = RT_TYPE_UINT16;
677 2 : break;
678 : case CP_TAG_CONST_INT32:
679 20255 : value->aLong = m_pCP->readINT32Constant(cpIndex);
680 20255 : ret = RT_TYPE_INT32;
681 20255 : break;
682 : case CP_TAG_CONST_UINT32:
683 2 : value->aULong = m_pCP->readUINT32Constant(cpIndex);
684 2 : ret = RT_TYPE_UINT32;
685 2 : break;
686 : case CP_TAG_CONST_INT64:
687 89 : value->aHyper = m_pCP->readINT64Constant(cpIndex);
688 89 : ret = RT_TYPE_INT64;
689 89 : break;
690 : case CP_TAG_CONST_UINT64:
691 2 : value->aUHyper = m_pCP->readUINT64Constant(cpIndex);
692 2 : ret = RT_TYPE_UINT64;
693 2 : break;
694 : case CP_TAG_CONST_FLOAT:
695 60 : value->aFloat = m_pCP->readFloatConstant(cpIndex);
696 60 : ret = RT_TYPE_FLOAT;
697 60 : 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 2898 : break;
708 : }
709 : }
710 :
711 30199 : return ret;
712 : }
713 :
714 1622 : const sal_Char* FieldList::getFieldDoku(sal_uInt16 index)
715 : {
716 1622 : const sal_Char* aDoku = NULL;
717 :
718 1622 : if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
719 : {
720 1622 : aDoku = m_pCP->readUTF8NameConstant(readUINT16(sizeof(sal_uInt16) + (index * m_FIELD_ENTRY_SIZE) + FIELD_OFFSET_DOKU));
721 : }
722 :
723 1622 : 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 102323 : 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 102323 : ReferenceList(const sal_uInt8* buffer, sal_uInt16 numEntries, ConstantPool* pCP)
754 : : BlopObject(buffer, 0, sal_False)
755 : , m_numOfEntries(numEntries)
756 102323 : , m_pCP(pCP)
757 : {
758 102323 : if ( m_numOfEntries > 0 )
759 : {
760 5591 : m_numOfReferenceEntries = readUINT16(0);
761 5591 : m_REFERENCE_ENTRY_SIZE = m_numOfReferenceEntries * sizeof(sal_uInt16);
762 : } else
763 : {
764 96732 : m_numOfReferenceEntries = 0;
765 96732 : m_REFERENCE_ENTRY_SIZE = 0;
766 : }
767 102323 : }
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 102323 : sal_uInt32 ReferenceList::parseIndex()
778 : {
779 102323 : return ((m_numOfEntries ? sizeof(sal_uInt16) : 0) + (m_numOfEntries * m_REFERENCE_ENTRY_SIZE));
780 : }
781 :
782 6227 : const sal_Char* ReferenceList::getReferenceName(sal_uInt16 index)
783 : {
784 6227 : const sal_Char* aName = NULL;
785 :
786 6227 : if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
787 : {
788 6227 : aName = m_pCP->readUTF8NameConstant(readUINT16(sizeof(sal_uInt16) + (index * m_REFERENCE_ENTRY_SIZE) + REFERENCE_OFFSET_NAME));
789 : }
790 :
791 6227 : return aName;
792 : }
793 :
794 5820 : RTReferenceType ReferenceList::getReferenceType(sal_uInt16 index)
795 : {
796 5820 : RTReferenceType refType = RT_REF_INVALID;
797 :
798 5820 : if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
799 : {
800 5820 : refType = (RTReferenceType) readUINT16(sizeof(sal_uInt16) + (index * m_REFERENCE_ENTRY_SIZE) + REFERENCE_OFFSET_TYPE);
801 : }
802 :
803 5820 : 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 199 : RTFieldAccess ReferenceList::getReferenceAccess(sal_uInt16 index)
819 : {
820 199 : RTFieldAccess aAccess = RT_ACCESS_INVALID;
821 :
822 199 : if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
823 : {
824 199 : aAccess = (RTFieldAccess) readUINT16(sizeof(sal_uInt16) + (index * m_REFERENCE_ENTRY_SIZE) + REFERENCE_OFFSET_ACCESS);
825 : }
826 :
827 199 : 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 102323 : MethodList(const sal_uInt8* buffer, sal_uInt16 numEntries, ConstantPool* pCP)
848 : : BlopObject(buffer, 0, sal_False)
849 : , m_numOfEntries(numEntries)
850 : , m_pIndex(NULL)
851 102323 : , m_pCP(pCP)
852 : {
853 102323 : if ( m_numOfEntries > 0 )
854 : {
855 29024 : m_numOfMethodEntries = readUINT16(0);
856 29024 : m_numOfParamEntries = readUINT16(sizeof(sal_uInt16));
857 29024 : m_PARAM_ENTRY_SIZE = m_numOfParamEntries * sizeof(sal_uInt16);
858 : } else
859 : {
860 73299 : m_numOfMethodEntries = 0;
861 73299 : m_numOfParamEntries = 0;
862 73299 : m_PARAM_ENTRY_SIZE = 0;
863 : }
864 102323 : }
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 204646 : MethodList::~MethodList()
886 : {
887 102323 : if (m_pIndex) delete[] m_pIndex;
888 102323 : }
889 :
890 168359 : sal_uInt16 MethodList::calcMethodParamIndex( const sal_uInt16 index )
891 : {
892 168359 : return (METHOD_OFFSET_PARAM_COUNT + sizeof(sal_uInt16) + (index * m_PARAM_ENTRY_SIZE));
893 : }
894 :
895 102323 : sal_uInt32 MethodList::parseIndex()
896 : {
897 102323 : if (m_pIndex)
898 : {
899 0 : delete[] m_pIndex;
900 0 : m_pIndex = NULL;
901 : }
902 :
903 102323 : sal_uInt32 offset = 0;
904 :
905 102323 : if (m_numOfEntries)
906 : {
907 29024 : offset = 2 * sizeof(sal_uInt16);
908 29024 : m_pIndex = new sal_uInt32[m_numOfEntries];
909 :
910 141153 : for (int i = 0; i < m_numOfEntries; i++)
911 : {
912 112129 : m_pIndex[i] = offset;
913 :
914 112129 : offset += readUINT16(offset);
915 : }
916 : }
917 :
918 102323 : return offset;
919 : }
920 :
921 67819 : const sal_Char* MethodList::getMethodName(sal_uInt16 index)
922 : {
923 67819 : const sal_Char* aName = NULL;
924 :
925 67819 : if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
926 : {
927 67819 : aName = m_pCP->readUTF8NameConstant(readUINT16(m_pIndex[index] + METHOD_OFFSET_NAME));
928 : }
929 :
930 67819 : return aName;
931 : }
932 :
933 66159 : sal_uInt16 MethodList::getMethodParamCount(sal_uInt16 index)
934 : {
935 66159 : sal_uInt16 aCount = 0;
936 :
937 66159 : if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
938 : {
939 66159 : aCount = readUINT16(m_pIndex[index] + METHOD_OFFSET_PARAM_COUNT);
940 : }
941 :
942 66159 : return aCount;
943 : }
944 :
945 47937 : const sal_Char* MethodList::getMethodParamType(sal_uInt16 index, sal_uInt16 paramIndex)
946 : {
947 47937 : const sal_Char* aName = NULL;
948 :
949 95874 : if ((m_numOfEntries > 0) &&
950 : (index <= m_numOfEntries) &&
951 47937 : (paramIndex <= readUINT16(m_pIndex[index] + METHOD_OFFSET_PARAM_COUNT)))
952 : {
953 : aName = m_pCP->readUTF8NameConstant(
954 : readUINT16(
955 47937 : m_pIndex[index] +
956 47937 : calcMethodParamIndex(paramIndex) +
957 47937 : PARAM_OFFSET_TYPE));
958 : }
959 :
960 47937 : return aName;
961 : }
962 :
963 21922 : const sal_Char* MethodList::getMethodParamName(sal_uInt16 index, sal_uInt16 paramIndex)
964 : {
965 21922 : const sal_Char* aName = NULL;
966 :
967 43844 : if ((m_numOfEntries > 0) &&
968 : (index <= m_numOfEntries) &&
969 21922 : (paramIndex <= readUINT16(m_pIndex[index] + METHOD_OFFSET_PARAM_COUNT)))
970 : {
971 : aName = m_pCP->readUTF8NameConstant(
972 : readUINT16(
973 21922 : m_pIndex[index] +
974 21922 : calcMethodParamIndex(paramIndex) +
975 21922 : PARAM_OFFSET_NAME));
976 : }
977 :
978 21922 : return aName;
979 : }
980 :
981 41160 : RTParamMode MethodList::getMethodParamMode(sal_uInt16 index, sal_uInt16 paramIndex)
982 : {
983 41160 : RTParamMode aMode = RT_PARAM_INVALID;
984 :
985 82320 : if ((m_numOfEntries > 0) &&
986 : (index <= m_numOfEntries) &&
987 41160 : (paramIndex <= readUINT16(m_pIndex[index] + METHOD_OFFSET_PARAM_COUNT)))
988 : {
989 : aMode = (RTParamMode) readUINT16(
990 41160 : m_pIndex[index] +
991 41160 : calcMethodParamIndex(paramIndex) +
992 41160 : PARAM_OFFSET_MODE);
993 : }
994 :
995 41160 : return aMode;
996 : }
997 :
998 40520 : sal_uInt16 MethodList::getMethodExcCount(sal_uInt16 index)
999 : {
1000 40520 : sal_uInt16 aCount = 0;
1001 :
1002 40520 : if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
1003 : {
1004 40520 : aCount = readUINT16(m_pIndex[index] + calcMethodParamIndex(readUINT16(m_pIndex[index] + METHOD_OFFSET_PARAM_COUNT)));
1005 : }
1006 :
1007 40520 : return aCount;
1008 : }
1009 :
1010 16820 : const sal_Char* MethodList::getMethodExcType(sal_uInt16 index, sal_uInt16 excIndex)
1011 : {
1012 16820 : const sal_Char* aName = NULL;
1013 :
1014 16820 : if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
1015 : {
1016 16820 : sal_uInt32 excOffset = m_pIndex[index] + calcMethodParamIndex(readUINT16(m_pIndex[index] + METHOD_OFFSET_PARAM_COUNT));
1017 :
1018 16820 : if (excIndex <= readUINT16(excOffset))
1019 : {
1020 : aName = m_pCP->readUTF8NameConstant(
1021 : readUINT16(
1022 : excOffset +
1023 : sizeof(sal_uInt16) +
1024 16820 : (excIndex * sizeof(sal_uInt16))));
1025 : }
1026 : }
1027 :
1028 16820 : return aName;
1029 : }
1030 :
1031 54140 : const sal_Char* MethodList::getMethodReturnType(sal_uInt16 index)
1032 : {
1033 54140 : const sal_Char* aName = NULL;
1034 :
1035 54140 : if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
1036 : {
1037 54140 : aName = m_pCP->readUTF8NameConstant(readUINT16(m_pIndex[index] + METHOD_OFFSET_RETURN));
1038 : }
1039 :
1040 54140 : return aName;
1041 : }
1042 :
1043 115908 : RTMethodMode MethodList::getMethodMode(sal_uInt16 index)
1044 : {
1045 115908 : RTMethodMode aMode = RT_MODE_INVALID;
1046 :
1047 115908 : if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
1048 : {
1049 115908 : aMode = (RTMethodMode) readUINT16(m_pIndex[index] + METHOD_OFFSET_MODE);
1050 : }
1051 :
1052 115908 : return aMode;
1053 : }
1054 :
1055 11711 : const sal_Char* MethodList::getMethodDoku(sal_uInt16 index)
1056 : {
1057 11711 : const sal_Char* aDoku = NULL;
1058 :
1059 11711 : if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
1060 : {
1061 11711 : aDoku = m_pCP->readUTF8NameConstant(readUINT16(m_pIndex[index] + METHOD_OFFSET_DOKU));
1062 : }
1063 :
1064 11711 : 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, sal_Bool copyBuffer);
1085 : // throws std::bad_alloc
1086 :
1087 : ~TypeRegistryEntry();
1088 :
1089 : typereg_Version getVersion() const;
1090 : };
1091 :
1092 102323 : TypeRegistryEntry::TypeRegistryEntry(
1093 : const sal_uInt8* buffer, sal_uInt32 len, sal_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 102323 : m_offset_SUPERTYPES(0)
1097 : {
1098 102323 : std::size_t const entrySize = sizeof(sal_uInt16);
1099 102323 : sal_uInt16 nHeaderEntries = readUINT16(OFFSET_N_ENTRIES);
1100 102323 : sal_uInt16 offset_N_SUPERTYPES = OFFSET_N_ENTRIES + entrySize + (nHeaderEntries * entrySize);
1101 102323 : m_offset_SUPERTYPES = offset_N_SUPERTYPES + entrySize;
1102 102323 : m_nSuperTypes = readUINT16(offset_N_SUPERTYPES);
1103 :
1104 102323 : sal_uInt16 offset_CP_SIZE = m_offset_SUPERTYPES + (m_nSuperTypes * entrySize);
1105 102323 : sal_uInt16 offset_CP = offset_CP_SIZE + entrySize;
1106 :
1107 102323 : m_pCP = new ConstantPool(m_pBuffer + offset_CP, readUINT16(offset_CP_SIZE));
1108 :
1109 102323 : sal_uInt32 offset = offset_CP + m_pCP->parseIndex();
1110 :
1111 : m_pFields = new FieldList(
1112 102323 : m_pBuffer + offset + entrySize, readUINT16(offset), m_pCP);
1113 :
1114 102323 : offset += sizeof(sal_uInt16) + m_pFields->parseIndex();
1115 :
1116 : m_pMethods = new MethodList(
1117 102323 : m_pBuffer + offset + entrySize, readUINT16(offset), m_pCP);
1118 :
1119 102323 : offset += sizeof(sal_uInt16) + m_pMethods->parseIndex();
1120 :
1121 : m_pReferences = new ReferenceList(
1122 102323 : m_pBuffer + offset + entrySize, readUINT16(offset), m_pCP);
1123 :
1124 102323 : m_pReferences->parseIndex();
1125 102323 : }
1126 :
1127 204646 : TypeRegistryEntry::~TypeRegistryEntry()
1128 : {
1129 102323 : delete m_pCP;
1130 102323 : delete m_pFields;
1131 102323 : delete m_pMethods;
1132 102323 : delete m_pReferences;
1133 102323 : }
1134 :
1135 102323 : typereg_Version TypeRegistryEntry::getVersion() const {
1136 : // Assumes two's complement arithmetic with modulo-semantics:
1137 102323 : return static_cast< typereg_Version >(readUINT32(OFFSET_MAGIC) - magic);
1138 : }
1139 :
1140 : /**************************************************************************
1141 :
1142 : C-API
1143 :
1144 : **************************************************************************/
1145 :
1146 : extern "C" {
1147 :
1148 102323 : 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 102323 : if (length < OFFSET_CP || length > SAL_MAX_UINT32) {
1154 0 : *result = 0;
1155 0 : return true;
1156 : }
1157 102323 : std::auto_ptr< TypeRegistryEntry > entry;
1158 : try {
1159 : entry.reset(
1160 : new TypeRegistryEntry(
1161 : static_cast< sal_uInt8 const * >(buffer),
1162 102323 : static_cast< sal_uInt32 >(length), copy));
1163 0 : } catch (std::bad_alloc &) {
1164 0 : return false;
1165 : }
1166 102323 : if (entry->readUINT32(OFFSET_SIZE) != length) {
1167 0 : *result = 0;
1168 0 : return true;
1169 : }
1170 102323 : typereg_Version version = entry->getVersion();
1171 102323 : if (version < TYPEREG_VERSION_0 || version > maxVersion) {
1172 0 : *result = 0;
1173 0 : return true;
1174 : }
1175 102323 : *result = entry.release();
1176 102323 : return true;
1177 : }
1178 :
1179 40828 : static TypeReaderImpl TYPEREG_CALLTYPE createEntry(const sal_uInt8* buffer, sal_uInt32 len, sal_Bool copyBuffer)
1180 : {
1181 : void * handle;
1182 40828 : typereg_reader_create(buffer, len, copyBuffer, TYPEREG_VERSION_1, &handle);
1183 40828 : return handle;
1184 : }
1185 :
1186 54012 : REG_DLLPUBLIC void TYPEREG_CALLTYPE typereg_reader_acquire(void * hEntry) SAL_THROW_EXTERN_C()
1187 : {
1188 54012 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1189 :
1190 54012 : if (pEntry != NULL)
1191 53271 : pEntry->m_refCount++;
1192 54012 : }
1193 :
1194 333532 : REG_DLLPUBLIC void TYPEREG_CALLTYPE typereg_reader_release(void * hEntry) SAL_THROW_EXTERN_C()
1195 : {
1196 333532 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1197 :
1198 333532 : if (pEntry != NULL)
1199 : {
1200 155594 : if (--pEntry->m_refCount == 0)
1201 102323 : delete pEntry;
1202 : }
1203 333532 : }
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 151533 : REG_DLLPUBLIC RTTypeClass TYPEREG_CALLTYPE typereg_reader_getTypeClass(void * hEntry) SAL_THROW_EXTERN_C()
1230 : {
1231 151533 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1232 :
1233 151533 : if (pEntry == NULL) return RT_TYPE_INVALID;
1234 :
1235 : return (RTTypeClass)
1236 151533 : (pEntry->readUINT16(OFFSET_TYPE_CLASS) & ~RT_TYPE_PUBLISHED);
1237 : }
1238 :
1239 4165 : REG_DLLPUBLIC sal_Bool TYPEREG_CALLTYPE typereg_reader_isPublished(void * hEntry) SAL_THROW_EXTERN_C()
1240 : {
1241 4165 : TypeRegistryEntry * entry = static_cast< TypeRegistryEntry * >(hEntry);
1242 : return entry != 0
1243 4165 : && (entry->readUINT16(OFFSET_TYPE_CLASS) & RT_TYPE_PUBLISHED) != 0;
1244 : }
1245 :
1246 10717 : REG_DLLPUBLIC void TYPEREG_CALLTYPE typereg_reader_getTypeName(void * hEntry, rtl_uString** pTypeName)
1247 : SAL_THROW_EXTERN_C()
1248 : {
1249 10717 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1250 :
1251 10717 : if (pEntry == NULL)
1252 : {
1253 0 : rtl_uString_new(pTypeName);
1254 10717 : return;
1255 : }
1256 :
1257 10717 : 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 10717 : 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 3731 : REG_DLLPUBLIC void TYPEREG_CALLTYPE typereg_reader_getDocumentation(void * hEntry, rtl_uString** pDoku)
1297 : SAL_THROW_EXTERN_C()
1298 : {
1299 3731 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1300 :
1301 3731 : if (pEntry == NULL)
1302 : {
1303 0 : rtl_uString_new(pDoku);
1304 3731 : return;
1305 : }
1306 :
1307 3731 : 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 3731 : 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 112213 : REG_DLLPUBLIC sal_uInt16 TYPEREG_CALLTYPE typereg_reader_getFieldCount(void * hEntry) SAL_THROW_EXTERN_C()
1332 : {
1333 112213 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1334 :
1335 112213 : if (pEntry == NULL) return 0;
1336 :
1337 112213 : return pEntry->m_pFields->m_numOfEntries;
1338 : }
1339 :
1340 40820 : static sal_uInt32 TYPEREG_CALLTYPE getFieldCount(TypeReaderImpl hEntry)
1341 : {
1342 40820 : return typereg_reader_getFieldCount(hEntry);
1343 : }
1344 :
1345 67329 : REG_DLLPUBLIC void TYPEREG_CALLTYPE typereg_reader_getFieldName(void * hEntry, rtl_uString** pFieldName, sal_uInt16 index)
1346 : SAL_THROW_EXTERN_C()
1347 : {
1348 67329 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1349 :
1350 67329 : if (pEntry == NULL)
1351 : {
1352 0 : rtl_uString_new(pFieldName);
1353 67329 : return;
1354 : }
1355 67329 : const sal_Char* pTmp = pEntry->m_pFields->getFieldName(index);
1356 : rtl_string2UString(
1357 : pFieldName, pTmp, pTmp == 0 ? 0 : rtl_str_getLength(pTmp),
1358 67329 : RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS);
1359 : }
1360 :
1361 82019 : REG_DLLPUBLIC void TYPEREG_CALLTYPE typereg_reader_getFieldTypeName(void * hEntry, rtl_uString** pFieldType, sal_uInt16 index)
1362 : SAL_THROW_EXTERN_C()
1363 : {
1364 82019 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1365 :
1366 82019 : if (pEntry == NULL)
1367 : {
1368 0 : rtl_uString_new(pFieldType);
1369 82019 : return;
1370 : }
1371 :
1372 82019 : const sal_Char* pTmp = pEntry->m_pFields->getFieldType(index);
1373 : rtl_string2UString(
1374 : pFieldType, pTmp, pTmp == 0 ? 0 : rtl_str_getLength(pTmp),
1375 82019 : RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS);
1376 : }
1377 :
1378 73808 : REG_DLLPUBLIC RTFieldAccess TYPEREG_CALLTYPE typereg_reader_getFieldFlags(void * hEntry, sal_uInt16 index)
1379 : SAL_THROW_EXTERN_C()
1380 : {
1381 73808 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1382 :
1383 73808 : if (pEntry == NULL) return RT_ACCESS_INVALID;
1384 :
1385 73808 : return pEntry->m_pFields->getFieldAccess(index);
1386 : }
1387 :
1388 30199 : 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 30199 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1394 :
1395 30199 : if (pEntry == NULL) {
1396 0 : *type = RT_TYPE_NONE;
1397 0 : return true;
1398 : }
1399 :
1400 : try {
1401 30199 : *type = pEntry->m_pFields->getFieldConstValue(index, value);
1402 0 : } catch (std::bad_alloc &) {
1403 0 : return false;
1404 : }
1405 30199 : 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 1622 : REG_DLLPUBLIC void TYPEREG_CALLTYPE typereg_reader_getFieldDocumentation(void * hEntry, rtl_uString** pDoku, sal_uInt16 index)
1416 : SAL_THROW_EXTERN_C()
1417 : {
1418 1622 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1419 :
1420 1622 : if (pEntry == NULL)
1421 : {
1422 0 : rtl_uString_new(pDoku);
1423 1622 : return;
1424 : }
1425 :
1426 1622 : const sal_Char* pTmp = pEntry->m_pFields->getFieldDoku(index);
1427 : rtl_string2UString(
1428 : pDoku, pTmp, pTmp == 0 ? 0 : rtl_str_getLength(pTmp),
1429 1622 : 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 68151 : REG_DLLPUBLIC sal_uInt16 TYPEREG_CALLTYPE typereg_reader_getMethodCount(void * hEntry) SAL_THROW_EXTERN_C()
1451 : {
1452 68151 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1453 :
1454 68151 : if (pEntry == NULL) return 0;
1455 :
1456 68151 : 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 67819 : REG_DLLPUBLIC void TYPEREG_CALLTYPE typereg_reader_getMethodName(void * hEntry, rtl_uString** pMethodName, sal_uInt16 index)
1465 : SAL_THROW_EXTERN_C()
1466 : {
1467 67819 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1468 :
1469 67819 : if (pEntry == NULL)
1470 : {
1471 0 : rtl_uString_new(pMethodName);
1472 67819 : return;
1473 : }
1474 :
1475 67819 : const sal_Char* pTmp = pEntry->m_pMethods->getMethodName(index);
1476 : rtl_string2UString(
1477 : pMethodName, pTmp, pTmp == 0 ? 0 : rtl_str_getLength(pTmp),
1478 67819 : RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS);
1479 : }
1480 :
1481 66159 : REG_DLLPUBLIC sal_uInt16 TYPEREG_CALLTYPE typereg_reader_getMethodParameterCount(
1482 : void * hEntry, sal_uInt16 index) SAL_THROW_EXTERN_C()
1483 : {
1484 66159 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1485 :
1486 66159 : if (pEntry == NULL) return 0;
1487 :
1488 66159 : 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 47937 : 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 47937 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1500 :
1501 47937 : if (pEntry == NULL)
1502 : {
1503 0 : rtl_uString_new(pMethodParamType);
1504 47937 : return;
1505 : }
1506 :
1507 47937 : const sal_Char* pTmp = pEntry->m_pMethods->getMethodParamType(index, paramIndex);
1508 : rtl_string2UString(
1509 : pMethodParamType, pTmp, pTmp == 0 ? 0 : rtl_str_getLength(pTmp),
1510 47937 : RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS);
1511 : }
1512 :
1513 21922 : 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 21922 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1517 :
1518 21922 : if (pEntry == NULL)
1519 : {
1520 0 : rtl_uString_new(pMethodParamName);
1521 21922 : return;
1522 : }
1523 :
1524 21922 : const sal_Char* pTmp = pEntry->m_pMethods->getMethodParamName(index, paramIndex);
1525 : rtl_string2UString(
1526 : pMethodParamName, pTmp, pTmp == 0 ? 0 : rtl_str_getLength(pTmp),
1527 21922 : RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS);
1528 : }
1529 :
1530 41160 : REG_DLLPUBLIC RTParamMode TYPEREG_CALLTYPE typereg_reader_getMethodParameterFlags(void * hEntry, sal_uInt16 index, sal_uInt16 paramIndex)
1531 : SAL_THROW_EXTERN_C()
1532 : {
1533 41160 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1534 :
1535 41160 : if (pEntry == NULL) return RT_PARAM_INVALID;
1536 :
1537 41160 : return pEntry->m_pMethods->getMethodParamMode(index, paramIndex);
1538 : }
1539 :
1540 40520 : REG_DLLPUBLIC sal_uInt16 TYPEREG_CALLTYPE typereg_reader_getMethodExceptionCount(
1541 : void * hEntry, sal_uInt16 index) SAL_THROW_EXTERN_C()
1542 : {
1543 40520 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1544 :
1545 40520 : if (pEntry == NULL) return 0;
1546 :
1547 40520 : 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 16820 : 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 16820 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1559 :
1560 16820 : if (pEntry == NULL)
1561 : {
1562 0 : rtl_uString_new(pMethodExcpType);
1563 16820 : return;
1564 : }
1565 :
1566 16820 : const sal_Char* pTmp = pEntry->m_pMethods->getMethodExcType(index, excIndex);
1567 : rtl_string2UString(
1568 : pMethodExcpType, pTmp, pTmp == 0 ? 0 : rtl_str_getLength(pTmp),
1569 16820 : RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS);
1570 : }
1571 :
1572 54140 : REG_DLLPUBLIC void TYPEREG_CALLTYPE typereg_reader_getMethodReturnTypeName(void * hEntry, rtl_uString** pMethodReturnType, sal_uInt16 index)
1573 : SAL_THROW_EXTERN_C()
1574 : {
1575 54140 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1576 :
1577 54140 : if (pEntry == NULL)
1578 : {
1579 0 : rtl_uString_new(pMethodReturnType);
1580 54140 : return;
1581 : }
1582 :
1583 54140 : const sal_Char* pTmp = pEntry->m_pMethods->getMethodReturnType(index);
1584 : rtl_string2UString(
1585 : pMethodReturnType, pTmp, pTmp == 0 ? 0 : rtl_str_getLength(pTmp),
1586 54140 : RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS);
1587 : }
1588 :
1589 115908 : REG_DLLPUBLIC RTMethodMode TYPEREG_CALLTYPE typereg_reader_getMethodFlags(void * hEntry, sal_uInt16 index)
1590 : SAL_THROW_EXTERN_C()
1591 : {
1592 115908 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1593 :
1594 115908 : if (pEntry == NULL) return RT_MODE_INVALID;
1595 :
1596 115908 : return pEntry->m_pMethods->getMethodMode(index);
1597 : }
1598 :
1599 11711 : REG_DLLPUBLIC void TYPEREG_CALLTYPE typereg_reader_getMethodDocumentation(void * hEntry, rtl_uString** pMethodDoku, sal_uInt16 index)
1600 : SAL_THROW_EXTERN_C()
1601 : {
1602 11711 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1603 :
1604 11711 : if (pEntry == NULL)
1605 : {
1606 0 : rtl_uString_new(pMethodDoku);
1607 11711 : return;
1608 : }
1609 :
1610 11711 : const sal_Char* pTmp = pEntry->m_pMethods->getMethodDoku(index);
1611 : rtl_string2UString(
1612 : pMethodDoku, pTmp, pTmp == 0 ? 0 : rtl_str_getLength(pTmp),
1613 11711 : RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS);
1614 : }
1615 :
1616 41180 : REG_DLLPUBLIC sal_uInt16 TYPEREG_CALLTYPE typereg_reader_getReferenceCount(void * hEntry) SAL_THROW_EXTERN_C()
1617 : {
1618 41180 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1619 :
1620 41180 : if (pEntry == NULL) return 0;
1621 :
1622 41180 : 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 6227 : REG_DLLPUBLIC void TYPEREG_CALLTYPE typereg_reader_getReferenceTypeName(void * hEntry, rtl_uString** pReferenceName, sal_uInt16 index)
1631 : SAL_THROW_EXTERN_C()
1632 : {
1633 6227 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1634 :
1635 6227 : if (pEntry == NULL)
1636 : {
1637 0 : rtl_uString_new(pReferenceName);
1638 6227 : return;
1639 : }
1640 :
1641 6227 : const sal_Char* pTmp = pEntry->m_pReferences->getReferenceName(index);
1642 : rtl_string2UString(
1643 : pReferenceName, pTmp, pTmp == 0 ? 0 : rtl_str_getLength(pTmp),
1644 6227 : RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS);
1645 : }
1646 :
1647 5820 : REG_DLLPUBLIC RTReferenceType TYPEREG_CALLTYPE typereg_reader_getReferenceSort(void * hEntry, sal_uInt16 index)
1648 : SAL_THROW_EXTERN_C()
1649 : {
1650 5820 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1651 :
1652 5820 : if (pEntry == NULL) return RT_REF_INVALID;
1653 :
1654 5820 : 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 199 : REG_DLLPUBLIC RTFieldAccess TYPEREG_CALLTYPE typereg_reader_getReferenceFlags(void * hEntry, sal_uInt16 index)
1675 : SAL_THROW_EXTERN_C()
1676 : {
1677 199 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1678 :
1679 199 : if (pEntry == NULL) return RT_ACCESS_INVALID;
1680 :
1681 199 : return pEntry->m_pReferences->getReferenceAccess(index);
1682 : }
1683 :
1684 55118 : REG_DLLPUBLIC sal_uInt16 TYPEREG_CALLTYPE typereg_reader_getSuperTypeCount(void * hEntry)
1685 : SAL_THROW_EXTERN_C()
1686 : {
1687 55118 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1688 :
1689 55118 : if (pEntry == NULL) return 0;
1690 :
1691 55118 : return pEntry->m_nSuperTypes;
1692 : }
1693 :
1694 27409 : REG_DLLPUBLIC void TYPEREG_CALLTYPE typereg_reader_getSuperTypeName(
1695 : void * hEntry, rtl_uString ** pSuperTypeName, sal_uInt16 index)
1696 : SAL_THROW_EXTERN_C()
1697 : {
1698 27409 : TypeRegistryEntry* pEntry = (TypeRegistryEntry*) hEntry;
1699 :
1700 27409 : if (pEntry == NULL)
1701 : {
1702 0 : rtl_uString_new(pSuperTypeName);
1703 27409 : return;
1704 : }
1705 :
1706 : OSL_ASSERT(index < pEntry->m_nSuperTypes);
1707 27409 : 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 27409 : RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS);
1711 : }
1712 :
1713 40828 : 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 40828 : if (!aApi.acquire)
1717 : {
1718 5 : aApi.createEntry = &createEntry;
1719 5 : aApi.acquire = &typereg_reader_acquire;
1720 5 : aApi.release = &typereg_reader_release;
1721 5 : aApi.getMinorVersion = &getMinorVersion;
1722 5 : aApi.getMajorVersion = &getMajorVersion;
1723 5 : aApi.getTypeClass = &typereg_reader_getTypeClass;
1724 5 : aApi.getTypeName = &typereg_reader_getTypeName;
1725 5 : aApi.getSuperTypeName = &getSuperTypeName;
1726 5 : aApi.getUik = &getUik;
1727 5 : aApi.getDoku = &typereg_reader_getDocumentation;
1728 5 : aApi.getFileName = &typereg_reader_getFileName;
1729 5 : aApi.getFieldCount = &getFieldCount;
1730 5 : aApi.getFieldName = &typereg_reader_getFieldName;
1731 5 : aApi.getFieldType = &typereg_reader_getFieldTypeName;
1732 5 : aApi.getFieldAccess = &typereg_reader_getFieldFlags;
1733 5 : aApi.getFieldConstValue = &getFieldConstValue;
1734 5 : aApi.getFieldDoku = &typereg_reader_getFieldDocumentation;
1735 5 : aApi.getFieldFileName = &typereg_reader_getFieldFileName;
1736 5 : aApi.getMethodCount = &getMethodCount;
1737 5 : aApi.getMethodName = &typereg_reader_getMethodName;
1738 5 : aApi.getMethodParamCount = &getMethodParamCount;
1739 5 : aApi.getMethodParamType = &typereg_reader_getMethodParameterTypeName;
1740 5 : aApi.getMethodParamName = &typereg_reader_getMethodParameterName;
1741 5 : aApi.getMethodParamMode = &typereg_reader_getMethodParameterFlags;
1742 5 : aApi.getMethodExcCount = &getMethodExcCount;
1743 5 : aApi.getMethodExcType = &typereg_reader_getMethodExceptionTypeName;
1744 5 : aApi.getMethodReturnType = &typereg_reader_getMethodReturnTypeName;
1745 5 : aApi.getMethodMode = &typereg_reader_getMethodFlags;
1746 5 : aApi.getMethodDoku = &typereg_reader_getMethodDocumentation;
1747 5 : aApi.getReferenceCount = &getReferenceCount;
1748 5 : aApi.getReferenceName = &typereg_reader_getReferenceTypeName;
1749 5 : aApi.getReferenceType = &typereg_reader_getReferenceSort;
1750 5 : aApi.getReferenceDoku = &typereg_reader_getReferenceDocumentation;
1751 5 : aApi.getReferenceAccess = &typereg_reader_getReferenceFlags;
1752 :
1753 5 : return (&aApi);
1754 : }
1755 : else
1756 : {
1757 40823 : return (&aApi);
1758 : }
1759 : }
1760 :
1761 : }
1762 :
1763 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
