LCOV - code coverage report
Current view: top level - usr/local/src/libreoffice/registry/source - reflread.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 532 700 76.0 %
Date: 2013-07-09 Functions: 87 109 79.8 %
Legend: Lines: hit not hit

          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: */

Generated by: LCOV version 1.10