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