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