rsc/source/res/rscstr.cxx

   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 <rscdb.hxx>
  26 #include <rscstr.hxx>
  27
  28 #include <rtl/textcvt.h>
  29 #include <rtl/textenc.h>
  30
  31 RscString::RscString( Atom nId, sal_uInt32 nTypeId )
  32     : RscTop( nId, nTypeId )
  33 {
  34     nSize = ALIGNED_SIZE( sizeof( RscStringInst ) );
  35     pRefClass = NULL;
  36 }
  37
  38 RSCCLASS_TYPE RscString::GetClassType() const
  39 {
  40     return RSCCLASS_STRING;
  41 }
  42
  43 ERRTYPE RscString::SetString( const RSCINST & rInst, const char * pStr )
  44 {
  45     char    * pTmp;
  46     ERRTYPE aError;
  47
  48     if( aError.IsOk() )
  49     {
  50         reinterpret_cast<RscStringInst *>(rInst.pData)->bDflt = false;
  51
  52         pTmp = reinterpret_cast<RscStringInst *>(rInst.pData)->pStr;
  53         if( pTmp )
  54         {
  55             rtl_freeMemory( pTmp );
  56             pTmp = NULL;
  57         }
  58
  59         if( pStr )
  60         {
  61             sal_uInt32  nLen = strlen( pStr ) +1;
  62             pTmp = static_cast<char *>(rtl_allocateMemory( nLen ));
  63             memcpy( pTmp, pStr, nLen );
  64         }
  65
  66         reinterpret_cast<RscStringInst *>(rInst.pData)->pStr = pTmp;
  67     }
  68
  69     return aError;
  70 }
  71
  72 ERRTYPE RscString::GetString( const RSCINST & rInst, char ** ppStr )
  73 {
  74     *ppStr = reinterpret_cast<RscStringInst *>(rInst.pData)->pStr;
  75     return ERR_OK;
  76 }
  77
  78 ERRTYPE RscString::GetRef( const RSCINST & rInst, RscId * pRscId )
  79 {
  80     *pRscId = reinterpret_cast<RscStringInst *>(rInst.pData)->aRefId;
  81     return ERR_OK;
  82 }
  83
  84 ERRTYPE RscString::SetRef( const RSCINST & rInst, const RscId & rRefId )
  85 {
  86     if( pRefClass )
  87     {
  88         reinterpret_cast<RscStringInst *>(rInst.pData)->aRefId = rRefId;
  89         reinterpret_cast<RscStringInst *>(rInst.pData)->bDflt  = false;
  90     }
  91     else
  92         return ERR_REFNOTALLOWED;
  93
  94     return ERR_OK;
  95 }
  96
  97 RSCINST RscString::Create( RSCINST * pInst, const RSCINST & rDflt,
  98                            bool bOwnClass )
  99 {
 100     RSCINST aInst;
 101
 102     if( !pInst )
 103     {
 104         aInst.pClass = this;
 105         aInst.pData = static_cast<CLASS_DATA>(
 106                       rtl_allocateMemory( sizeof( RscStringInst ) ));
 107     }
 108     else
 109         aInst = *pInst;
 110
 111     if( !bOwnClass && rDflt.IsInst() )
 112         bOwnClass = rDflt.pClass->InHierarchy( this );
 113
 114     reinterpret_cast<RscStringInst *>(aInst.pData)->aRefId.Create();
 115     reinterpret_cast<RscStringInst *>(aInst.pData)->pStr = NULL;
 116     reinterpret_cast<RscStringInst *>(aInst.pData)->bDflt = true;
 117
 118     if( bOwnClass )
 119     {
 120         reinterpret_cast<RscStringInst *>(aInst.pData)->aRefId =
 121             reinterpret_cast<RscStringInst *>(rDflt.pData)->aRefId;
 122         SetString( aInst, reinterpret_cast<RscStringInst *>(rDflt.pData)->pStr );
 123         reinterpret_cast<RscStringInst *>(aInst.pData)->bDflt =
 124             reinterpret_cast<RscStringInst *>(rDflt.pData)->bDflt;
 125     }
 126
 127     return aInst;
 128 }
 129
 130 void RscString::Destroy( const RSCINST & rInst )
 131 {
 132     if( reinterpret_cast<RscStringInst *>(rInst.pData)->pStr )
 133         rtl_freeMemory( reinterpret_cast<RscStringInst *>(rInst.pData)->pStr );
 134     reinterpret_cast<RscStringInst *>(rInst.pData)->aRefId.Destroy();
 135 }
 136
 137 bool RscString::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef )
 138 {
 139     RscStringInst * pData    = reinterpret_cast<RscStringInst*>(rInst.pData);
 140     RscStringInst * pDefData = reinterpret_cast<RscStringInst*>(pDef);
 141
 142     if( pDef )
 143     {
 144         if( pData->aRefId.IsId() || pDefData->aRefId.IsId() )
 145         {
 146             if( pData->aRefId.aExp.IsNumber() &&
 147                 pDefData->aRefId.aExp.IsNumber() )
 148             {
 149                 // Sind die Referenzidentifier gleich
 150                 if( pData->aRefId.GetNumber() == pDefData->aRefId.GetNumber() )
 151                 {
 152                     return true;
 153                 }
 154             }
 155         }
 156         else
 157         {
 158             bool bStrEmpty = false;
 159             bool bDefStrEmpty = false;
 160
 161             if( pData->pStr )
 162             {
 163                 bStrEmpty = ('\0' == *pData->pStr);
 164             }
 165             else
 166                 bStrEmpty = true;
 167
 168             if( pDefData->pStr )
 169             {
 170                 bDefStrEmpty = ('\0' == *pDefData->pStr);
 171             }
 172             else
 173                 bDefStrEmpty = true;
 174
 175             if( !bStrEmpty || !bDefStrEmpty )
 176             {
 177                 return false;
 178             }
 179             return true;
 180         }
 181     }
 182
 183     return false;
 184 }
 185
 186 void RscString::WriteSrc( const RSCINST & rInst, FILE * fOutput,
 187                           RscTypCont *, sal_uInt32, const char * )
 188 {
 189     if ( reinterpret_cast<RscStringInst *>(rInst.pData)->aRefId.IsId() )
 190     {
 191         fprintf( fOutput, "%s",
 192                  reinterpret_cast<RscStringInst *>(rInst.pData)->aRefId.GetName().getStr() );
 193     }
 194     else
 195     {
 196         RscStringInst * pStrI = reinterpret_cast<RscStringInst *>(rInst.pData);
 197         if(  pStrI->pStr ){
 198             //char *  pChangeTab = RscChar::GetChangeTab();
 199             sal_uInt32  n = 0;
 200             sal_uInt32  nPos, nSlashPos;
 201
 202             do
 203             {
 204                 fputc( '\"', fOutput );
 205                 nSlashPos = nPos = 0;
 206
 207                 while( pStrI->pStr[ n ] && (nPos < 72 || nPos - nSlashPos <= 3) )
 208                 { // nach \ mindesten 3 Zeichen wegeb \xa7
 209                     fputc( pStrI->pStr[ n ], fOutput );
 210                     if( pStrI->pStr[ n ] == '\\' )
 211                         nSlashPos = nPos;
 212                     n++;
 213                     nPos++;
 214                 }
 215
 216                 fputc( '\"', fOutput );
 217                 if( pStrI->pStr[ n ] ) //nocht nicht zu ende
 218                 {
 219                     fputc( '\n', fOutput );
 220                 }
 221             }
 222             while( pStrI->pStr[ n ] );
 223         }
 224         else
 225             fprintf( fOutput, "\"\"" );
 226     }
 227 }
 228
 229 ERRTYPE RscString::WriteRc( const RSCINST & rInst, RscWriteRc & rMem,
 230                             RscTypCont * pTC, sal_uInt32 nDeep, bool bExtra )
 231 {
 232     ERRTYPE aError;
 233     ObjNode *       pObjNode = NULL;
 234
 235
 236     if( reinterpret_cast<RscStringInst *>(rInst.pData)->aRefId.IsId() )
 237     {
 238         RscId   aId( reinterpret_cast<RscStringInst *>(rInst.pData)->aRefId );
 239         RSCINST aTmpI;
 240
 241         aTmpI.pClass = pRefClass;
 242
 243         while( aError.IsOk() && aId.IsId() )
 244         {
 245             //Erhoehen und abfragen um Endlosrekusion zu vermeiden
 246             nDeep++;
 247             if( nDeep > nRefDeep )
 248                 aError = ERR_REFTODEEP;
 249             else
 250             {
 251                 pObjNode = pRefClass->GetObjNode( aId );
 252                 if( pObjNode )
 253                 {
 254                     aTmpI.pData = pObjNode->GetRscObj();
 255                     aError = pRefClass->GetRef( aTmpI, &aId );
 256                 }
 257                 else
 258                 {
 259                     if( pTC )
 260                     {
 261                         OStringBuffer aMsg(pHS->getString(
 262                             pRefClass->GetId()));
 263                         aMsg.append(' ').append(aId.GetName());
 264                         aError = WRN_STR_REFNOTFOUND;
 265                         pTC->pEH->Error( aError, rInst.pClass,
 266                                          RscId(), aMsg.getStr() );
 267                     }
 268                     break;
 269                 }
 270             }
 271         }
 272     }
 273
 274     if( aError.IsOk() )
 275     {
 276         if( pObjNode )
 277         {
 278             RSCINST     aRefI;
 279
 280             aRefI = RSCINST( pRefClass, pObjNode->GetRscObj() );
 281             aError = aRefI.pClass->WriteRc( aRefI, rMem, pTC, nDeep, bExtra );
 282         }
 283         else
 284         {
 285             if( reinterpret_cast<RscStringInst *>(rInst.pData)->pStr && pTC )
 286             {
 287                 char * pStr = RscChar::MakeUTF8( reinterpret_cast<RscStringInst *>(rInst.pData)->pStr,
 288                                                 pTC->GetSourceCharSet() );
 289                 rMem.PutUTF8( pStr );
 290                 rtl_freeMemory( pStr );
 291             }
 292             else
 293                 rMem.PutUTF8( reinterpret_cast<RscStringInst *>(rInst.pData)->pStr );
 294         }
 295     }
 296     return aError;
 297 }
 298
 299 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */