rsc/source/res/rscarray.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 <rscconst.hxx>
  26 #include <rscarray.hxx>
  27 #include <rscdb.hxx>
  28
  29 RscInstNode::RscInstNode( sal_uInt32 nId )
  30 {
  31     nTypeId = nId;
  32 }
  33
  34 RscInstNode::~RscInstNode()
  35 {
  36     if( aInst.IsInst() )
  37     {
  38         aInst.pClass->Destroy( aInst );
  39         rtl_freeMemory( aInst.pData );
  40     }
  41 }
  42
  43 sal_uInt32 RscInstNode::GetId() const
  44 {
  45     return nTypeId;
  46 }
  47
  48 RscArray::RscArray( Atom nId, sal_uInt32 nTypeId, RscTop * pSuper, RscEnum * pTypeCl )
  49     : RscTop( nId, nTypeId, pSuper )
  50 {
  51     pTypeClass = pTypeCl;
  52     nOffInstData = RscTop::Size();
  53     nSize = nOffInstData + ALIGNED_SIZE( sizeof( RscArrayInst ) );
  54 }
  55
  56 RscArray::~RscArray()
  57 {
  58 }
  59
  60 RSCCLASS_TYPE RscArray::GetClassType() const
  61 {
  62     return RSCCLASS_ENUMARRAY;
  63 }
  64
  65 RscTop * RscArray::GetTypeClass() const
  66 {
  67     return pTypeClass;
  68 }
  69
  70 static RscInstNode * Create( RscInstNode * pNode )
  71 {
  72     RscInstNode * pRetNode = NULL;
  73
  74     if( pNode )
  75     {
  76         pRetNode = new RscInstNode( pNode->GetId() );
  77         pRetNode->aInst = pNode->aInst.pClass->Create( NULL, pNode->aInst );
  78         RscInstNode * pTmpNode = Create(pNode->Left());
  79         if (pTmpNode)
  80             pRetNode->Insert( pTmpNode );
  81         if( (pTmpNode = Create( pNode->Right() )) != NULL )
  82             pRetNode->Insert( pTmpNode );
  83     }
  84
  85     return pRetNode;
  86 }
  87
  88 RSCINST RscArray::Create( RSCINST * pInst, const RSCINST & rDflt,
  89                           bool bOwnClass )
  90 {
  91     RSCINST aInst;
  92     RscArrayInst *  pClassData;
  93
  94     if( !pInst )
  95     {
  96         aInst.pClass = this;
  97         aInst.pData = static_cast<CLASS_DATA>(rtl_allocateMemory( Size() ));
  98     }
  99     else
 100         aInst = *pInst;
 101
 102     if( !bOwnClass && rDflt.IsInst() )
 103         bOwnClass = rDflt.pClass->InHierarchy( this );
 104
 105     RscTop::Create( &aInst, rDflt, bOwnClass );
 106
 107     pClassData = reinterpret_cast<RscArrayInst *>(aInst.pData + nOffInstData);
 108     pClassData->pNode = NULL;
 109     if( bOwnClass )
 110     {
 111         RscArrayInst *   pDfltClassData;
 112
 113         pDfltClassData = reinterpret_cast<RscArrayInst *>(rDflt.pData + nOffInstData);
 114
 115         pClassData->pNode = ::Create( pDfltClassData->pNode );
 116     }
 117     return aInst;
 118 }
 119
 120 static void Destroy( RscInstNode * pNode )
 121 {
 122     if( pNode )
 123     {
 124         Destroy( pNode->Left() );
 125         Destroy( pNode->Right() );
 126         delete pNode;
 127     }
 128 }
 129
 130 void RscArray::Destroy( const RSCINST & rInst )
 131 {
 132     RscArrayInst *  pClassData;
 133
 134     RscTop::Destroy( rInst );
 135
 136     pClassData = reinterpret_cast<RscArrayInst *>(rInst.pData + nOffInstData);
 137
 138     //Baum rekursiv loeschen
 139     ::Destroy( pClassData->pNode );
 140 }
 141
 142 ERRTYPE RscArray::GetValueEle( const RSCINST & rInst,
 143                                sal_Int32 lValue,
 144                                RscTop * pCreateClass,
 145                                RSCINST * pGetInst)
 146 {
 147     RscArrayInst *  pClassData;
 148     RscInstNode *   pNode;
 149
 150     pClassData = reinterpret_cast<RscArrayInst *>(rInst.pData + nOffInstData);
 151
 152     ERRTYPE     aError;
 153
 154     Atom  nId;
 155     if( !pTypeClass->GetValueConst( sal_uInt32(lValue), &nId ) )
 156     { // nicht gefunden
 157         return ERR_ARRAY_INVALIDINDEX;
 158     }
 159
 160     if( pClassData->pNode )
 161         pNode = pClassData->pNode->Search( sal_uInt32(lValue) );
 162     else
 163         pNode = NULL;
 164
 165     if( !pNode )
 166     {
 167         pNode = new RscInstNode( sal_uInt32(lValue) );
 168         if( pCreateClass && GetSuperClass()->InHierarchy( pCreateClass ) )
 169             pNode->aInst = pCreateClass->Create( NULL, rInst );
 170         else
 171             pNode->aInst = GetSuperClass()->Create( NULL, rInst );
 172
 173         pNode->aInst.pClass->SetToDefault( pNode->aInst );
 174         if( pClassData->pNode )
 175             pClassData->pNode->Insert( pNode );
 176         else
 177             pClassData->pNode = pNode;
 178     }
 179
 180     *pGetInst = pNode->aInst;
 181     return aError;
 182 }
 183
 184 ERRTYPE RscArray::GetArrayEle( const RSCINST & rInst,
 185                                Atom nId,
 186                                RscTop * pCreateClass,
 187                                RSCINST * pGetInst)
 188 {
 189     sal_Int32  lValue;
 190     if( !pTypeClass->GetConstValue( nId, &lValue ) )
 191     { // nicht gefunden
 192         return ERR_ARRAY_INVALIDINDEX;
 193     }
 194
 195     return GetValueEle( rInst, lValue, pCreateClass, pGetInst );
 196 }
 197
 198 static bool IsConsistent( RscInstNode * pNode )
 199 {
 200     bool bRet = true;
 201
 202     if( pNode )
 203     {
 204         bRet = pNode->aInst.pClass->IsConsistent( pNode->aInst );
 205         if( !IsConsistent( pNode->Left() ) )
 206             bRet = false;
 207         if( !IsConsistent( pNode->Right() ) )
 208             bRet = false;
 209     }
 210     return bRet;
 211 }
 212
 213 bool RscArray::IsConsistent( const RSCINST & rInst )
 214 {
 215     RscArrayInst * pClassData;
 216     bool    bRet;
 217
 218     bRet = RscTop::IsConsistent( rInst );
 219
 220     pClassData = reinterpret_cast<RscArrayInst *>(rInst.pData + nOffInstData);
 221     if( !::IsConsistent( pClassData->pNode ) )
 222         bRet = false;
 223
 224     return bRet;
 225 }
 226
 227 static void SetToDefault( RscInstNode * pNode )
 228 {
 229     if( pNode )
 230     {
 231         pNode->aInst.pClass->SetToDefault( pNode->aInst );
 232         SetToDefault( pNode->Left() );
 233         SetToDefault( pNode->Right() );
 234     }
 235 }
 236
 237 void RscArray::SetToDefault( const RSCINST & rInst )
 238 {
 239     RscArrayInst * pClassData;
 240
 241     pClassData = reinterpret_cast<RscArrayInst *>(rInst.pData + nOffInstData);
 242
 243     ::SetToDefault( pClassData->pNode );
 244
 245     RscTop::SetToDefault( rInst );
 246 }
 247
 248 static bool IsDefault( RscInstNode * pNode )
 249 {
 250     bool bRet = true;
 251
 252     if( pNode )
 253     {
 254         bRet = pNode->aInst.pClass->IsDefault( pNode->aInst );
 255         if( bRet )
 256             bRet = IsDefault( pNode->Left() );
 257         if( bRet )
 258             bRet = IsDefault( pNode->Right() );
 259     }
 260     return bRet;
 261 }
 262
 263 bool RscArray::IsDefault( const RSCINST & rInst )
 264 {
 265     RscArrayInst * pClassData;
 266
 267     pClassData = reinterpret_cast<RscArrayInst *>(rInst.pData + nOffInstData);
 268
 269     bool bRet = ::IsDefault( pClassData->pNode );
 270
 271     if( bRet )
 272         bRet = RscTop::IsDefault( rInst );
 273     return bRet;
 274 }
 275
 276 static bool IsValueDefault( RscInstNode * pNode, CLASS_DATA pDef )
 277 {
 278     bool bRet = true;
 279
 280     if( pNode )
 281     {
 282         bRet = pNode->aInst.pClass->IsValueDefault( pNode->aInst, pDef );
 283         if( bRet )
 284             bRet = IsValueDefault( pNode->Left(), pDef );
 285         if( bRet )
 286             bRet = IsValueDefault( pNode->Right(), pDef );
 287     }
 288     return bRet;
 289 }
 290
 291 bool RscArray::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef )
 292 {
 293     bool bRet = RscTop::IsValueDefault( rInst, pDef );
 294
 295     if( bRet )
 296     {
 297         RscArrayInst * pClassData = reinterpret_cast<RscArrayInst *>(rInst.pData + nOffInstData);
 298
 299         bRet = ::IsValueDefault( pClassData->pNode, pDef );
 300     }
 301     return bRet;
 302 }
 303
 304 void RscArray::WriteSrcHeader( const RSCINST & rInst, FILE * fOutput,
 305                                RscTypCont * pTC, sal_uInt32 nTab,
 306                                const RscId & aId, const char * pVarName )
 307 {
 308     RscArrayInst * pClassData;
 309
 310     pClassData = reinterpret_cast<RscArrayInst *>(rInst.pData + nOffInstData);
 311
 312     if( pTC->IsSrsDefault() )
 313     { // nur einen Wert schreiben
 314         RscInstNode *   pNode = NULL;
 315         if( pClassData->pNode )
 316         {
 317             std::vector< sal_uInt32 >::const_iterator it;
 318             for( it = pTC->GetFallbacks().begin(); !pNode && it != pTC->GetFallbacks().end(); ++it )
 319                 pNode = pClassData->pNode->Search( *it );
 320         }
 321
 322         if( pNode )
 323         {
 324             if( pNode->aInst.pClass->IsDefault( pNode->aInst ) )
 325                 fprintf( fOutput, "Default" );
 326             else
 327                 pNode->aInst.pClass->WriteSrcHeader(
 328                                         pNode->aInst, fOutput,
 329                                         pTC, nTab, aId, pVarName );
 330             return;
 331         }
 332     }
 333
 334     if( IsDefault( rInst ) )
 335         fprintf( fOutput, "Default" );
 336     else
 337     {
 338         RSCINST aSuper( GetSuperClass(), rInst.pData );
 339         aSuper.pClass->WriteSrcHeader( aSuper, fOutput, pTC,
 340                                         nTab, aId, pVarName );
 341     }
 342     if( !pTC->IsSrsDefault() )
 343         WriteSrc( rInst, fOutput, pTC, nTab, pVarName );
 344 }
 345
 346 static void WriteSrc( RscInstNode * pNode, FILE * fOutput, RscTypCont * pTC,
 347                       sal_uInt32 nTab, const char * pVarName,
 348                       CLASS_DATA pDfltData, RscConst * pTypeClass )
 349 {
 350     if( pNode )
 351     {
 352         WriteSrc( pNode->Left(), fOutput, pTC, nTab, pVarName,
 353                     pDfltData, pTypeClass );
 354         if( !pNode->aInst.pClass->IsValueDefault( pNode->aInst, pDfltData ) )
 355         {
 356             fprintf( fOutput, ";\n" );
 357             for( sal_uInt32 n = 0; n < nTab; n++ )
 358                 fputc( '\t', fOutput );
 359
 360             Atom  nIdxId;
 361             pTypeClass->GetValueConst( pNode->GetId(), &nIdxId );
 362             fprintf( fOutput, "%s[ %s ] = ", pVarName, pHS->getString( nIdxId ).getStr() );
 363             pNode->aInst.pClass->WriteSrcHeader( pNode->aInst, fOutput, pTC,
 364                                                 nTab, RscId(), pVarName );
 365         }
 366         WriteSrc( pNode->Right(), fOutput, pTC, nTab, pVarName,
 367                     pDfltData, pTypeClass );
 368     }
 369 }
 370
 371 void RscArray::WriteSrcArray( const RSCINST & rInst, FILE * fOutput,
 372                               RscTypCont * pTC, sal_uInt32 nTab,
 373                               const char * pVarName )
 374 {
 375     RscArrayInst * pClassData;
 376
 377     pClassData = reinterpret_cast<RscArrayInst *>(rInst.pData + nOffInstData);
 378
 379     ::WriteSrc( pClassData->pNode, fOutput, pTC, nTab, pVarName,
 380                 rInst.pData, pTypeClass );
 381 };
 382
 383 void RscArray::WriteSrc( const RSCINST & rInst, FILE * fOutput,
 384                          RscTypCont * pTC, sal_uInt32 nTab,
 385                          const char * pVarName )
 386 {
 387     WriteSrcArray( rInst, fOutput, pTC, nTab, pVarName );
 388 }
 389
 390 ERRTYPE RscArray::WriteRc( const RSCINST & rInst, RscWriteRc & rMem,
 391                            RscTypCont * pTC, sal_uInt32 nDeep, bool bExtra )
 392 {
 393     ERRTYPE aError;
 394     RscArrayInst * pClassData;
 395     RscInstNode *   pNode = NULL;
 396
 397     pClassData = reinterpret_cast<RscArrayInst *>(rInst.pData + nOffInstData);
 398
 399     if( pClassData->pNode )
 400     {
 401 #if OSL_DEBUG_LEVEL > 2
 402         fprintf( stderr, "RscArray::WriteRc: Fallback " );
 403 #endif
 404         std::vector< sal_uInt32 >::const_iterator it;
 405         for( it = pTC->GetFallbacks().begin(); !pNode && it != pTC->GetFallbacks().end(); ++it )
 406         {
 407             pNode = pClassData->pNode->Search( *it );
 408 #if OSL_DEBUG_LEVEL > 2
 409             fprintf( stderr, " 0x%hx", *it );
 410 #endif
 411         }
 412 #if OSL_DEBUG_LEVEL > 2
 413             fprintf( stderr, "\n" );
 414 #endif
 415     }
 416
 417     if( pNode )
 418         aError = pNode->aInst.pClass->WriteRc( pNode->aInst, rMem, pTC,
 419                                                 nDeep, bExtra );
 420     else
 421         aError = RscTop::WriteRc( rInst, rMem, pTC, nDeep, bExtra );
 422
 423     return aError;
 424 }
 425
 426 RscClassArray::RscClassArray( Atom nId, sal_uInt32 nTypeId, RscTop * pSuper,
 427                               RscEnum * pTypeCl )
 428     : RscArray( nId, nTypeId, pSuper, pTypeCl )
 429 {
 430 }
 431
 432 RscClassArray::~RscClassArray()
 433 {
 434 }
 435
 436 void RscClassArray::WriteSrcHeader( const RSCINST & rInst, FILE * fOutput,
 437                                     RscTypCont * pTC, sal_uInt32 nTab,
 438                                     const RscId & aId, const char * pName )
 439 {
 440     RscArray::WriteSrcHeader( rInst, fOutput, pTC, nTab, aId, pName );
 441 }
 442
 443 void RscClassArray::WriteSrc( const RSCINST & rInst, FILE * fOutput,
 444                              RscTypCont * pTC, sal_uInt32 nTab,
 445                                  const char * pVarName )
 446 {
 447     RscArray::WriteSrc( rInst, fOutput, pTC, nTab, pVarName );
 448 }
 449
 450 ERRTYPE RscClassArray::WriteRcHeader( const RSCINST & rInst, RscWriteRc & aMem,
 451                                       RscTypCont * pTC, const RscId & aId,
 452                                       sal_uInt32 nDeep, bool bExtra )
 453 {
 454     // Eigenen Typ schreiben
 455     return GetSuperClass()->WriteRcHeader( rInst, aMem, pTC, aId,
 456                                            nDeep, bExtra );
 457 }
 458
 459 RscLangArray::RscLangArray( Atom nId, sal_uInt32 nTypeId, RscTop * pSuper,
 460                           RscEnum * pTypeCl )
 461     : RscArray( nId, nTypeId, pSuper, pTypeCl )
 462 {
 463 }
 464
 465 RSCCLASS_TYPE RscLangArray::GetClassType() const
 466 {
 467     if( GetSuperClass() )
 468         return GetSuperClass()->GetClassType();
 469     else
 470         return RscArray::GetClassType();
 471
 472 }
 473
 474 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */