LCOV - code coverage report
Current view: top level - rsc/source/res - rscflag.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 97 165 58.8 %
Date: 2014-11-03 Functions: 13 19 68.4 %
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 <stdlib.h>
      22             : #include <stdio.h>
      23             : #include <string.h>
      24             : 
      25             : #include <rscflag.hxx>
      26             : 
      27        2095 : RscFlag::RscFlag( Atom nId, sal_uInt32 nTypeId )
      28        2095 :     : RscConst( nId, nTypeId )
      29             : {
      30        2095 : }
      31             : 
      32       62460 : sal_uInt32 RscFlag::Size()
      33             : {
      34       62460 :     return ALIGNED_SIZE( sizeof( RscFlagInst ) *
      35             :             ( 1 + (nEntries -1) / (sizeof( sal_uInt32 ) * 8) ) );
      36             : }
      37             : 
      38          42 : ERRTYPE RscFlag::SetNotConst( const RSCINST & rInst, Atom nConst )
      39             : {
      40          42 :     sal_uInt32 i = 0;
      41             : 
      42          42 :     if( nEntries != (i = GetConstPos( nConst )) )
      43             :     {
      44          42 :         sal_uInt32 nFlag = 1 << (i % (sizeof( sal_uInt32 ) * 8) );
      45             : 
      46          42 :         i = i / (sizeof( sal_uInt32 ) * 8);
      47          42 :         ((RscFlagInst *)rInst.pData)[ i ].nFlags     &= ~nFlag;
      48          42 :         ((RscFlagInst *)rInst.pData)[ i ].nDfltFlags &= ~nFlag;
      49          42 :         return ERR_OK;
      50             :     }
      51             : 
      52           0 :     return ERR_RSCFLAG;
      53             : }
      54             : 
      55        1971 : ERRTYPE RscFlag::SetConst( const RSCINST & rInst, Atom nConst, sal_Int32 /*nVal*/ )
      56             : {
      57        1971 :     sal_uInt32 i = 0;
      58             : 
      59        1971 :     if( nEntries != (i = GetConstPos( nConst )) )
      60             :     {
      61        1971 :         sal_uInt32 nFlag = 1 << (i % (sizeof( sal_uInt32 ) * 8) );
      62             : 
      63        1971 :         i = i / (sizeof( sal_uInt32 ) * 8);
      64        1971 :         ((RscFlagInst *)rInst.pData)[ i ].nFlags     |= nFlag;
      65        1971 :         ((RscFlagInst *)rInst.pData)[ i ].nDfltFlags &= ~nFlag;
      66        1971 :         return ERR_OK;
      67             :     }
      68             : 
      69           0 :     return ERR_RSCFLAG;
      70             : }
      71             : 
      72       59335 : RSCINST RscFlag::CreateBasic( RSCINST * pInst )
      73             : {
      74       59335 :     RSCINST aInst;
      75             : 
      76       59335 :     if( !pInst )
      77             :     {
      78        1069 :         aInst.pClass = this;
      79        1069 :         aInst.pData = (CLASS_DATA) rtl_allocateMemory( Size() );
      80             :     }
      81             :     else
      82       58266 :         aInst = *pInst;
      83             : 
      84       59335 :     return aInst;
      85             : }
      86             : 
      87        9169 : RSCINST RscFlag::Create( RSCINST * pInst, const RSCINST & rDflt, bool bOwnClass )
      88             : {
      89        9169 :     RSCINST aInst = CreateBasic( pInst );
      90             : 
      91        9169 :     if( !bOwnClass && rDflt.IsInst() )
      92           0 :         bOwnClass = rDflt.pClass->InHierarchy( this );
      93             : 
      94        9169 :     if( bOwnClass )
      95           0 :         memmove( aInst.pData, rDflt.pData, Size() );
      96             :     else
      97             :     {
      98       19072 :         for( sal_uInt32 i = 0; i < Size() / sizeof( RscFlagInst ); i++ )
      99             :         {
     100        9903 :             ((RscFlagInst *)aInst.pData)[ i ].nFlags = 0;
     101        9903 :             ((RscFlagInst *)aInst.pData)[ i ].nDfltFlags = 0xFFFFFFFF;
     102             :         }
     103             :     }
     104             : 
     105        9169 :     return aInst;
     106             : }
     107             : 
     108       50166 : RSCINST RscFlag::CreateClient( RSCINST * pInst, const RSCINST & rDfltI,
     109             :                                bool bOwnClass, Atom nConstId )
     110             : {
     111       50166 :     RSCINST aInst = CreateBasic( pInst );
     112       50166 :     sal_uInt32 i = 0;
     113             : 
     114       50166 :     if( !bOwnClass && rDfltI.IsInst() )
     115           0 :         bOwnClass = rDfltI.pClass->InHierarchy( this );
     116             : 
     117       50166 :     if( nEntries != (i = GetConstPos( nConstId )) )
     118             :     {
     119       50166 :         sal_uInt32 nFlag = 1 << (i % (sizeof( sal_uInt32 ) * 8) );
     120       50166 :         i = i / (sizeof( sal_uInt32 ) * 8);
     121       50166 :         if( bOwnClass )
     122             :         {
     123             :             ((RscFlagInst *)aInst.pData)[ i ].nFlags &=
     124           0 :                 ~nFlag | ((RscFlagInst *)rDfltI.pData)[ i ].nFlags;
     125             :             ((RscFlagInst *)aInst.pData)[ i ].nDfltFlags &=
     126           0 :                 ~nFlag | ((RscFlagInst *)rDfltI.pData)[ i ].nDfltFlags;
     127             :         }
     128             :         else
     129             :         {
     130       50166 :             ((RscFlagInst *)aInst.pData)[ i ].nFlags &= ~nFlag;
     131       50166 :             ((RscFlagInst *)aInst.pData)[ i ].nDfltFlags |= nFlag;
     132             :         }
     133             :     }
     134             : 
     135       50166 :     return aInst;
     136             : }
     137             : 
     138           0 : void RscFlag::SetToDefault( const RSCINST & rInst )
     139             : {
     140           0 :     sal_uInt32 i = 0;
     141             : 
     142           0 :     for( i = 0; i < Size() / sizeof( RscFlagInst ); i++ )
     143           0 :         ((RscFlagInst *)rInst.pData)[ i ].nDfltFlags = 0xFFFFFFFF;
     144           0 : }
     145             : 
     146           0 : bool RscFlag::IsDefault( const RSCINST & rInst )
     147             : {
     148           0 :     sal_uInt32 i = 0;
     149             : 
     150           0 :     for( i = 0; i < Size() / sizeof( RscFlagInst ); i++ )
     151             :     {
     152           0 :         if( ((RscFlagInst *)rInst.pData)[ i ].nDfltFlags != 0xFFFFFFFF )
     153           0 :             return false;
     154             :     }
     155           0 :     return true;
     156             : }
     157             : 
     158           0 : bool RscFlag::IsDefault( const RSCINST & rInst, Atom nConstId )
     159             : {
     160           0 :     sal_uInt32 i = 0, nFlag = 0;
     161             : 
     162           0 :     if( nEntries != (i = GetConstPos( nConstId )) )
     163             :     {
     164           0 :         nFlag = 1 << (i % (sizeof( sal_uInt32 ) * 8) );
     165           0 :         i = i / (sizeof( sal_uInt32 ) * 8);
     166             : 
     167           0 :         if( ((RscFlagInst *)rInst.pData)[ i ].nDfltFlags & nFlag )
     168           0 :             return true ;
     169             :         else
     170           0 :             return false;
     171             :     }
     172           0 :     return true;
     173             : }
     174             : 
     175        1017 : bool RscFlag::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef,
     176             :                               Atom nConstId )
     177             : {
     178        1017 :     sal_uInt32 i = 0, nFlag = 0;
     179             : 
     180        1017 :     if( nEntries != (i = GetConstPos( nConstId )) )
     181             :     {
     182        1017 :         nFlag = 1 << (i % (sizeof( sal_uInt32 ) * 8) );
     183        1017 :         i = i / (sizeof( sal_uInt32 ) * 8);
     184             : 
     185        1017 :         if( pDef )
     186             :         {
     187        2034 :             if( (((RscFlagInst *)rInst.pData)[ i ].nFlags & nFlag) ==
     188        1017 :                 (((RscFlagInst *)pDef)[ i ].nFlags & nFlag) )
     189             :             {
     190          40 :                 return true;
     191             :             }
     192             :         }
     193             :     }
     194             : 
     195         977 :     return false;
     196             : }
     197             : 
     198           0 : bool RscFlag::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef )
     199             : {
     200           0 :     if( pDef )
     201             :     {
     202           0 :         sal_uInt32  Flag = 0, nIndex = 0;
     203             : 
     204           0 :         Flag = 1;
     205           0 :         for( sal_uInt32 i = 0; i < nEntries; i++ )
     206             :         {
     207           0 :             nIndex = i / (sizeof( sal_uInt32 ) * 8);
     208             : 
     209           0 :             if( (((RscFlagInst *)rInst.pData)[ nIndex ].nFlags & Flag) !=
     210           0 :                 (((RscFlagInst *)pDef)[ nIndex ].nFlags & Flag)  )
     211             :             {
     212           0 :                 return false;
     213             :             }
     214           0 :             Flag <<= 1;
     215           0 :             if( !Flag )
     216           0 :                 Flag = 1;
     217             :         }
     218             :     }
     219             :     else
     220           0 :         return false;
     221             : 
     222           0 :     return true;
     223             : }
     224             : 
     225         977 : bool RscFlag::IsSet( const RSCINST & rInst, Atom nConstId )
     226             : {
     227         977 :     sal_uInt32 i = 0, nFlag = 0;
     228             : 
     229         977 :     if( nEntries != (i = GetConstPos( nConstId )) )
     230             :     {
     231         977 :         nFlag = 1 << (i % (sizeof( sal_uInt32 ) * 8) );
     232         977 :         i = i / (sizeof( sal_uInt32 ) * 8);
     233             : 
     234         977 :         if( ((RscFlagInst *)rInst.pData)[ i ].nFlags & nFlag )
     235         977 :             return true;
     236             :         else
     237           0 :             return false;
     238             :     }
     239           0 :     return true;
     240             : }
     241             : 
     242           0 : void RscFlag::WriteSrc( const RSCINST & rInst, FILE * fOutput,
     243             :                         RscTypCont *, sal_uInt32, const char * )
     244             : {
     245           0 :     sal_uInt32  i = 0, Flag = 0, nIndex = 0;
     246           0 :     bool    bComma = false;
     247             : 
     248           0 :     Flag = 1;
     249           0 :     for( i = 0; i < nEntries; i++ )
     250             :     {
     251           0 :         nIndex = i / (sizeof( sal_uInt32 ) * 8);
     252           0 :         if( !( ((RscFlagInst *)rInst.pData)[ nIndex ].nDfltFlags & Flag) )
     253             :         {
     254           0 :             if( bComma )
     255           0 :                 fprintf( fOutput, ", " );
     256             : 
     257           0 :             if( ((RscFlagInst *)rInst.pData)[ nIndex ].nFlags & Flag )
     258           0 :                 fprintf( fOutput, "%s", pHS->getString( pVarArray[ i ].nId ).getStr() );
     259             :             else
     260             :             {
     261           0 :                 fprintf( fOutput, "not " );
     262           0 :                 fprintf( fOutput, "%s", pHS->getString( pVarArray[ i ].nId ).getStr() );
     263             :             }
     264           0 :             bComma = true;
     265             :         }
     266           0 :         Flag <<= 1;
     267           0 :         if( !Flag )
     268           0 :             Flag = 1;
     269             :     }
     270           0 : }
     271             : 
     272         966 : ERRTYPE RscFlag::WriteRc( const RSCINST & rInst, RscWriteRc & aMem,
     273             :                           RscTypCont *, sal_uInt32, bool )
     274             : {
     275         966 :     sal_Int32   lVal = 0;
     276         966 :     sal_uInt32  i = 0, Flag = 0, nIndex = 0;
     277             : 
     278         966 :     Flag = 1;
     279       22885 :     for( i = 0; i < nEntries; i++ )
     280             :     {
     281       21919 :         nIndex = i / (sizeof( sal_uInt32 ) * 8);
     282             : 
     283       21919 :         if( ((RscFlagInst *)rInst.pData)[ nIndex ].nFlags & Flag )
     284         977 :             lVal |= pVarArray[ i ].lValue;
     285             : 
     286       21919 :         Flag <<= 1;
     287       21919 :         if( !Flag )
     288         363 :             Flag = 1;
     289             :     }
     290             : 
     291         966 :     aMem.Put( (sal_Int32)lVal );
     292         966 :     return ERR_OK;
     293             : }
     294             : 
     295       38548 : RscClient::RscClient( Atom nId, sal_uInt32 nTypeId, RscFlag * pClass,
     296             :                       Atom nConstantId )
     297       38548 :     : RscTop ( nId, nTypeId )
     298             : {
     299       38548 :    pRefClass = pClass;
     300       38548 :    nConstId = nConstantId;
     301       38548 : }
     302             : 
     303           0 : RSCCLASS_TYPE RscClient::GetClassType() const
     304             : {
     305           0 :     return RSCCLASS_BOOL;
     306             : }
     307             : 
     308         977 : void RscClient::WriteSrc( const RSCINST & rInst, FILE * fOutput,
     309             :                           RscTypCont *, sal_uInt32, const char * )
     310             : {
     311         977 :     if( pRefClass->IsSet( rInst, nConstId ) )
     312         977 :         fprintf( fOutput, "TRUE" );
     313             :     else
     314           0 :         fprintf( fOutput, "FALSE" );
     315         977 : }
     316             : 
     317       50166 : RSCINST RscClient::Create( RSCINST * pInst, const RSCINST & rDflt,
     318             :                            bool bOwnClass )
     319             : {
     320       50166 :     RSCINST aTmpI, aDfltI;
     321             : 
     322       50166 :     if( pInst )
     323             :     {
     324       49842 :         aTmpI.pClass = pRefClass;
     325       49842 :         aTmpI.pData  = pInst->pData;
     326             :     }
     327             : 
     328       50166 :     if( !bOwnClass && rDflt.IsInst() )
     329             :     {
     330           0 :         bOwnClass = rDflt.pClass->InHierarchy( this );
     331           0 :         if( bOwnClass )
     332             :         {
     333           0 :             aDfltI.pClass = pRefClass;
     334           0 :             aDfltI.pData = rDflt.pData;
     335             :         }
     336             :     }
     337             : 
     338       50166 :     if( pInst )
     339             :         aTmpI = pRefClass->CreateClient( &aTmpI, aDfltI,
     340       49842 :                                          bOwnClass, nConstId );
     341             :     else
     342             :         aTmpI = pRefClass->CreateClient( NULL, aDfltI,
     343         324 :                                          bOwnClass, nConstId );
     344       50166 :     aTmpI.pClass = this;
     345             : 
     346       50166 :     return aTmpI;
     347             : }
     348             : 
     349             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10