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