sc/source/core/tool/rangenam.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: rangenam.cxx,v $
  10  * $Revision: 1.28.30.2 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sc.hxx"
  33
  34
  35 //------------------------------------------------------------------------
  36
  37 #include <tools/debug.hxx>
  38 #include <string.h>
  39 #include <memory>
  40 #include <unotools/collatorwrapper.hxx>
  41 #include <unotools/transliterationwrapper.hxx>
  42
  43 #include "token.hxx"
  44 #include "tokenarray.hxx"
  45 #include "rangenam.hxx"
  46 #include "global.hxx"
  47 #include "compiler.hxx"
  48 #include "rangeutl.hxx"
  49 #include "rechead.hxx"
  50 #include "refupdat.hxx"
  51 #include "document.hxx"
  52 #include "indexmap.hxx"
  53
  54 using namespace formula;
  55
  56 //========================================================================
  57 // ScRangeData
  58 //========================================================================
  59
  60 // Interner ctor fuer das Suchen nach einem Index
  61
  62 ScRangeData::ScRangeData( USHORT n )
  63            : pCode( NULL ), nIndex( n ), bModified( FALSE )
  64 {}
  65
  66 ScRangeData::ScRangeData( ScDocument* pDok,
  67                                                   const String& rName,
  68                                                   const String& rSymbol,
  69                           const ScAddress& rAddress,
  70                                                   RangeType nType,
  71                                                   const FormulaGrammar::Grammar eGrammar ) :
  72                                 aName           ( rName ),
  73                 aUpperName  ( ScGlobal::pCharClass->upper( rName ) ),
  74                                 pCode           ( NULL ),
  75                                 aPos            ( rAddress ),
  76                                 eType           ( nType ),
  77                                 pDoc            ( pDok ),
  78                                 nIndex          ( 0 ),
  79                                 bModified       ( FALSE )
  80 {
  81         if (rSymbol.Len() > 0)
  82         {
  83                 ScCompiler aComp( pDoc, aPos );
  84         aComp.SetGrammar(eGrammar);
  85                 pCode = aComp.CompileString( rSymbol );
  86                 if( !pCode->GetCodeError() )
  87                 {
  88                         pCode->Reset();
  89                         FormulaToken* p = pCode->GetNextReference();
  90                         if( p )// genau eine Referenz als erstes
  91                         {
  92                                 if( p->GetType() == svSingleRef )
  93                                         eType = eType | RT_ABSPOS;
  94                                 else
  95                                         eType = eType | RT_ABSAREA;
  96                         }
  97                         // ggf. den Fehlercode wg. unvollstaendiger Formel setzen!
  98                         // Dies ist fuer die manuelle Eingabe
  99                         aComp.CompileTokenArray();
 100                         pCode->DelRPN();
 101                 }
 102         }
 103     else
 104     {
 105         // #i63513#/#i65690# don't leave pCode as NULL.
 106         // Copy ctor default-constructs pCode if it was NULL, so it's initialized here, too,
 107         // to ensure same behavior if unnecessary copying is left out.
 108
 109         pCode = new ScTokenArray();
 110     }
 111 }
 112
 113 ScRangeData::ScRangeData( ScDocument* pDok,
 114                                                   const String& rName,
 115                                                   const ScTokenArray& rArr,
 116                           const ScAddress& rAddress,
 117                                                   RangeType nType ) :
 118                                 aName           ( rName ),
 119                 aUpperName  ( ScGlobal::pCharClass->upper( rName ) ),
 120                                 pCode           ( new ScTokenArray( rArr ) ),
 121                                 aPos            ( rAddress ),
 122                                 eType           ( nType ),
 123                                 pDoc            ( pDok ),
 124                                 nIndex          ( 0 ),
 125                                 bModified       ( FALSE )
 126 {
 127         if( !pCode->GetCodeError() )
 128         {
 129                 pCode->Reset();
 130                 FormulaToken* p = pCode->GetNextReference();
 131                 if( p )// genau eine Referenz als erstes
 132                 {
 133                         if( p->GetType() == svSingleRef )
 134                                 eType = eType | RT_ABSPOS;
 135                         else
 136                                 eType = eType | RT_ABSAREA;
 137                 }
 138                 // Die Importfilter haben diesen Test nicht,
 139                 // da die benannten Bereiche z.T. noch unvollstaendig sind.
 140 //              if( !pCode->GetCodeLen() )
 141 //              {
 142 //                      // ggf. den Fehlercode wg. unvollstaendiger Formel setzen!
 143 //                      ScCompiler aComp( pDok, aPos, *pCode );
 144 //                      aComp.CompileTokenArray();
 145 //                      pCode->DelRPN();
 146 //              }
 147         }
 148 }
 149
 150 ScRangeData::ScRangeData( ScDocument* pDok,
 151                                                   const String& rName,
 152                                                   const ScAddress& rTarget ) :
 153                                 aName           ( rName ),
 154                 aUpperName  ( ScGlobal::pCharClass->upper( rName ) ),
 155                                 pCode           ( new ScTokenArray() ),
 156                                 aPos            ( rTarget ),
 157                                 eType           ( RT_NAME ),
 158                                 pDoc            ( pDok ),
 159                                 nIndex          ( 0 ),
 160                                 bModified       ( FALSE )
 161 {
 162         ScSingleRefData aRefData;
 163         aRefData.InitAddress( rTarget );
 164         aRefData.SetFlag3D( TRUE );
 165         pCode->AddSingleReference( aRefData );
 166         ScCompiler aComp( pDoc, aPos, *pCode );
 167     aComp.SetGrammar(pDoc->GetGrammar());
 168         aComp.CompileTokenArray();
 169         if ( !pCode->GetCodeError() )
 170                 eType |= RT_ABSPOS;
 171 }
 172
 173 ScRangeData::ScRangeData(const ScRangeData& rScRangeData) :
 174     ScDataObject(),
 175         aName   (rScRangeData.aName),
 176     aUpperName  (rScRangeData.aUpperName),
 177         pCode           (rScRangeData.pCode ? rScRangeData.pCode->Clone() : new ScTokenArray()),                // echte Kopie erzeugen (nicht copy-ctor)
 178         aPos            (rScRangeData.aPos),
 179         eType           (rScRangeData.eType),
 180         pDoc            (rScRangeData.pDoc),
 181         nIndex          (rScRangeData.nIndex),
 182         bModified       (rScRangeData.bModified)
 183 {}
 184
 185 ScRangeData::~ScRangeData()
 186 {
 187         delete pCode;
 188 }
 189
 190 ScDataObject* ScRangeData::Clone() const
 191 {
 192         return new ScRangeData(*this);
 193 }
 194
 195 void ScRangeData::GuessPosition()
 196 {
 197         //      setzt eine Position, mit der alle relative Referenzen bei CalcAbsIfRel
 198         //      ohne Fehler verabsolutiert werden koennen
 199
 200         DBG_ASSERT(aPos == ScAddress(), "die Position geht jetzt verloren");
 201
 202         SCsCOL nMinCol = 0;
 203         SCsROW nMinRow = 0;
 204         SCsTAB nMinTab = 0;
 205
 206         ScToken* t;
 207         pCode->Reset();
 208     while ( ( t = static_cast<ScToken*>(pCode->GetNextReference()) ) != NULL )
 209         {
 210                 ScSingleRefData& rRef1 = t->GetSingleRef();
 211                 if ( rRef1.IsColRel() && rRef1.nRelCol < nMinCol )
 212                         nMinCol = rRef1.nRelCol;
 213                 if ( rRef1.IsRowRel() && rRef1.nRelRow < nMinRow )
 214                         nMinRow = rRef1.nRelRow;
 215                 if ( rRef1.IsTabRel() && rRef1.nRelTab < nMinTab )
 216                         nMinTab = rRef1.nRelTab;
 217
 218                 if ( t->GetType() == svDoubleRef )
 219                 {
 220                         ScSingleRefData& rRef2 = t->GetDoubleRef().Ref2;
 221                         if ( rRef2.IsColRel() && rRef2.nRelCol < nMinCol )
 222                                 nMinCol = rRef2.nRelCol;
 223                         if ( rRef2.IsRowRel() && rRef2.nRelRow < nMinRow )
 224                                 nMinRow = rRef2.nRelRow;
 225                         if ( rRef2.IsTabRel() && rRef2.nRelTab < nMinTab )
 226                                 nMinTab = rRef2.nRelTab;
 227                 }
 228         }
 229
 230         aPos = ScAddress( (SCCOL)(-nMinCol), (SCROW)(-nMinRow), (SCTAB)(-nMinTab) );
 231
 232         //!     Test
 233 //      DBG_ERROR(String("Pos ")+String((SCCOL)(-nMinCol))+String("/")+
 234 //                      String((SCROW)(-nMinRow))+String("/")+String((SCTAB)(-nMinTab)));
 235 }
 236
 237 void ScRangeData::GetSymbol( String& rSymbol, const FormulaGrammar::Grammar eGrammar ) const
 238 {
 239         ScCompiler aComp(pDoc, aPos, *pCode);
 240     aComp.SetGrammar(eGrammar);
 241         aComp.CreateStringFromTokenArray( rSymbol );
 242 }
 243
 244 void ScRangeData::UpdateSymbol( rtl::OUStringBuffer& rBuffer, const ScAddress& rPos,
 245                                                                 const FormulaGrammar::Grammar eGrammar )
 246 {
 247     ::std::auto_ptr<ScTokenArray> pTemp( pCode->Clone() );
 248         ScCompiler aComp( pDoc, rPos, *pTemp.get());
 249     aComp.SetGrammar(eGrammar);
 250         aComp.MoveRelWrap();
 251         aComp.CreateStringFromTokenArray( rBuffer );
 252 }
 253
 254 void ScRangeData::UpdateReference(      UpdateRefMode eUpdateRefMode,
 255                                                                         const ScRange& r,
 256                                                                         SCsCOL nDx, SCsROW nDy, SCsTAB nDz )
 257 {
 258         BOOL bChanged = FALSE;
 259
 260         pCode->Reset();
 261         if( pCode->GetNextReference() )
 262         {
 263         BOOL bSharedFormula = ((eType & RT_SHARED) == RT_SHARED);
 264                 ScCompiler aComp( pDoc, aPos, *pCode );
 265         aComp.SetGrammar(pDoc->GetGrammar());
 266                 const BOOL bRelRef = aComp.UpdateNameReference( eUpdateRefMode, r,
 267                                                                                                         nDx, nDy, nDz,
 268                                                                                                         bChanged, bSharedFormula);
 269                 if (bSharedFormula)
 270                 {
 271                         if (bRelRef)
 272                                 eType = eType | RT_SHAREDMOD;
 273                         else
 274                                 eType = eType & ~RT_SHAREDMOD;
 275                 }
 276         }
 277
 278         bModified = bChanged;
 279 }
 280
 281
 282 void ScRangeData::UpdateTranspose( const ScRange& rSource, const ScAddress& rDest )
 283 {
 284         BOOL bChanged = FALSE;
 285
 286         ScToken* t;
 287         pCode->Reset();
 288
 289         while ( ( t = static_cast<ScToken*>(pCode->GetNextReference()) ) != NULL )
 290         {
 291                 if( t->GetType() != svIndex )
 292                 {
 293                         SingleDoubleRefModifier aMod( *t );
 294                         ScComplexRefData& rRef = aMod.Ref();
 295                         if (!rRef.Ref1.IsColRel() && !rRef.Ref1.IsRowRel() &&
 296                                         (!rRef.Ref1.IsFlag3D() || !rRef.Ref1.IsTabRel()) &&
 297                                 ( t->GetType() == svSingleRef ||
 298                                 (!rRef.Ref2.IsColRel() && !rRef.Ref2.IsRowRel() &&
 299                                         (!rRef.Ref2.IsFlag3D() || !rRef.Ref2.IsTabRel()))))
 300                         {
 301                                 if ( ScRefUpdate::UpdateTranspose( pDoc, rSource, rDest, rRef ) != UR_NOTHING )
 302                                         bChanged = TRUE;
 303                         }
 304                 }
 305         }
 306
 307         bModified = bChanged;
 308 }
 309
 310 void ScRangeData::UpdateGrow( const ScRange& rArea, SCCOL nGrowX, SCROW nGrowY )
 311 {
 312         BOOL bChanged = FALSE;
 313
 314         ScToken* t;
 315         pCode->Reset();
 316
 317         while ( ( t = static_cast<ScToken*>(pCode->GetNextReference()) ) != NULL )
 318         {
 319                 if( t->GetType() != svIndex )
 320                 {
 321                         SingleDoubleRefModifier aMod( *t );
 322                         ScComplexRefData& rRef = aMod.Ref();
 323                         if (!rRef.Ref1.IsColRel() && !rRef.Ref1.IsRowRel() &&
 324                                         (!rRef.Ref1.IsFlag3D() || !rRef.Ref1.IsTabRel()) &&
 325                                 ( t->GetType() == svSingleRef ||
 326                                 (!rRef.Ref2.IsColRel() && !rRef.Ref2.IsRowRel() &&
 327                                         (!rRef.Ref2.IsFlag3D() || !rRef.Ref2.IsTabRel()))))
 328                         {
 329                                 if ( ScRefUpdate::UpdateGrow( rArea,nGrowX,nGrowY, rRef ) != UR_NOTHING )
 330                                         bChanged = TRUE;
 331                         }
 332                 }
 333         }
 334
 335         bModified = bChanged;                   // muss direkt hinterher ausgewertet werden
 336 }
 337
 338 BOOL ScRangeData::operator== (const ScRangeData& rData) const           // fuer Undo
 339 {
 340         if ( nIndex     != rData.nIndex ||
 341                  aName  != rData.aName  ||
 342                  aPos   != rData.aPos   ||
 343                  eType  != rData.eType     ) return FALSE;
 344
 345         USHORT nLen = pCode->GetLen();
 346         if ( nLen != rData.pCode->GetLen() ) return FALSE;
 347
 348         FormulaToken** ppThis = pCode->GetArray();
 349         FormulaToken** ppOther = rData.pCode->GetArray();
 350
 351         for ( USHORT i=0; i<nLen; i++ )
 352                 if ( ppThis[i] != ppOther[i] && !(*ppThis[i] == *ppOther[i]) )
 353                         return FALSE;
 354
 355         return TRUE;
 356 }
 357
 358 BOOL ScRangeData::IsRangeAtCursor( const ScAddress& rPos, BOOL bStartOnly ) const
 359 {
 360         BOOL bRet = FALSE;
 361         ScRange aRange;
 362         if ( IsReference(aRange) )
 363         {
 364                 if ( bStartOnly )
 365                         bRet = ( rPos == aRange.aStart );
 366                 else
 367                         bRet = ( aRange.In( rPos ) );
 368         }
 369         return bRet;
 370 }
 371
 372 BOOL ScRangeData::IsRangeAtBlock( const ScRange& rBlock ) const
 373 {
 374         BOOL bRet = FALSE;
 375         ScRange aRange;
 376         if ( IsReference(aRange) )
 377                 bRet = ( rBlock == aRange );
 378         return bRet;
 379 }
 380
 381 BOOL ScRangeData::IsReference( ScRange& rRange ) const
 382 {
 383         if ( (eType & ( RT_ABSAREA | RT_REFAREA | RT_ABSPOS )) && pCode )
 384                 return pCode->IsReference( rRange );
 385
 386     return FALSE;
 387 }
 388
 389 BOOL ScRangeData::IsReference( ScRange& rRange, const ScAddress& rPos ) const
 390 {
 391         if ( (eType & ( RT_ABSAREA | RT_REFAREA | RT_ABSPOS ) ) && pCode )
 392     {
 393         ::std::auto_ptr<ScTokenArray> pTemp( pCode->Clone() );
 394         ScCompiler aComp( pDoc, rPos, *pTemp);
 395         aComp.SetGrammar(pDoc->GetGrammar());
 396         aComp.MoveRelWrap();
 397         return pTemp->IsReference( rRange );
 398     }
 399
 400     return FALSE;
 401 }
 402
 403 BOOL ScRangeData::IsValidReference( ScRange& rRange ) const
 404 {
 405     if ( (eType & ( RT_ABSAREA | RT_REFAREA | RT_ABSPOS ) ) && pCode )
 406         return pCode->IsValidReference( rRange );
 407
 408     return FALSE;
 409 }
 410
 411 void ScRangeData::UpdateTabRef(SCTAB nOldTable, USHORT nFlag, SCTAB nNewTable)
 412 {
 413         pCode->Reset();
 414         if( pCode->GetNextReference() )
 415         {
 416         ScRangeData* pRangeData = NULL;     // must not be dereferenced
 417                 BOOL bChanged;
 418                 ScCompiler aComp( pDoc, aPos, *pCode);
 419         aComp.SetGrammar(pDoc->GetGrammar());
 420                 switch (nFlag)
 421                 {
 422                         case 1:                                                                         // einfache InsertTab (doc.cxx)
 423                                 pRangeData = aComp.UpdateInsertTab(nOldTable, TRUE );   // und CopyTab (doc2.cxx)
 424                                 break;
 425                         case 2:                                                                         // einfaches delete (doc.cxx)
 426                                 pRangeData = aComp.UpdateDeleteTab(nOldTable, FALSE, TRUE, bChanged);
 427                                 break;
 428                         case 3:                                                                         // move (doc2.cxx)
 429                         {
 430                                 pRangeData = aComp.UpdateMoveTab(nOldTable, nNewTable, TRUE );
 431                         }
 432                                 break;
 433                         default:
 434                         {
 435                                 DBG_ERROR("ScRangeName::UpdateTabRef: Unknown Flag");
 436                         }
 437                                 break;
 438                 }
 439                 if (eType&RT_SHARED)
 440                 {
 441                         if (pRangeData)
 442                                 eType = eType | RT_SHAREDMOD;
 443                         else
 444                                 eType = eType & ~RT_SHAREDMOD;
 445                 }
 446         }
 447 }
 448
 449 //      wie beim Uebernehmen von Namen in Excel
 450
 451 void ScRangeData::MakeValidName( String& rName )                // static
 452 {
 453     //ScCompiler::InitSymbolsNative();
 454
 455         //      ungueltige Zeichen vorne weglassen
 456         xub_StrLen nPos = 0;
 457         xub_StrLen nLen = rName.Len();
 458         while ( nPos < nLen && !ScCompiler::IsWordChar( rName, nPos) )
 459                 ++nPos;
 460         if ( nPos>0 )
 461                 rName.Erase(0,nPos);
 462
 463         //      wenn vorne ein ungueltiges Anfangszeichen steht, '_' davor
 464         if ( rName.Len() && !ScCompiler::IsCharWordChar( rName, 0 ) )
 465                 rName.Insert('_',0);
 466
 467         //      ungueltige durch '_' ersetzen
 468         nLen = rName.Len();
 469         for (nPos=0; nPos<nLen; nPos++)
 470         {
 471                 if ( !ScCompiler::IsWordChar( rName, nPos) )
 472                         rName.SetChar( nPos, '_' );
 473         }
 474
 475         // Name darf keine Referenz beinhalten, wie in IsNameValid
 476         ScAddress aAddr;
 477                 ScRange aRange;
 478         int nConv = FormulaGrammar::CONV_UNSPECIFIED; // use int so that op++ works
 479
 480         // Ensure that the proposed name is not an address under any convention
 481         while ( ++nConv != FormulaGrammar::CONV_LAST )
 482                 {
 483                 ScAddress::Details details( static_cast<FormulaGrammar::AddressConvention>( nConv ) );
 484                 while( aRange.Parse( rName, NULL, details )
 485                            || aAddr.Parse( rName, NULL, details ) )
 486                 {
 487                         //! Range Parse auch bei Bereich mit ungueltigem Tabellennamen gueltig
 488                         //! Address Parse dito, Name erzeugt deswegen bei Compile ein #REF!
 489                         if ( rName.SearchAndReplace( ':', '_' ) == STRING_NOTFOUND
 490                           && rName.SearchAndReplace( '.', '_' ) == STRING_NOTFOUND )
 491                                 rName.Insert('_',0);
 492                 }
 493         }
 494 }
 495
 496 BOOL ScRangeData::IsNameValid( const String& rName, ScDocument* pDoc )
 497 {
 498     /*  If changed, ScfTools::ConvertToScDefinedName (sc/source/filter/ftools/ftools.cxx)
 499         needs to be changed too. */
 500         xub_StrLen nPos = 0;
 501         xub_StrLen nLen = rName.Len();
 502         if ( !nLen || !ScCompiler::IsCharWordChar( rName, nPos++ ) )
 503                 return FALSE;
 504         while ( nPos < nLen )
 505         {
 506                 if ( !ScCompiler::IsWordChar( rName, nPos++ ) )
 507                         return FALSE;
 508         }
 509         // Parse nicht auf VALID pruefen, es reicht, wenn irgendein Bestandteil
 510         // erkannt wurde
 511         ScRange aRange;
 512         if( aRange.Parse( rName, pDoc ) )       // THIS IS WRONG
 513                 return FALSE;
 514         else
 515         {
 516                 ScAddress aAddr;
 517                 if ( aAddr.Parse( rName, pDoc ) )       // THIS IS WRONG
 518                         return FALSE;
 519         }
 520         return TRUE;
 521 }
 522
 523
 524 USHORT ScRangeData::GetErrCode()
 525 {
 526         return pCode ? pCode->GetCodeError() : 0;
 527 }
 528
 529 BOOL ScRangeData::HasReferences() const
 530 {
 531         pCode->Reset();
 532         return BOOL( pCode->GetNextReference() != NULL );
 533 }
 534
 535 // bei TransferTab von einem in ein anderes Dokument anpassen,
 536 // um Referenzen auf die eigene Tabelle mitzubekommen
 537
 538 void ScRangeData::TransferTabRef( SCTAB nOldTab, SCTAB nNewTab )
 539 {
 540         long nTabDiff = (long)nNewTab - nOldTab;
 541         long nPosDiff = (long)nNewTab - aPos.Tab();
 542         aPos.SetTab( nNewTab );
 543         ScToken* t;
 544         pCode->Reset();
 545     while ( ( t = static_cast<ScToken*>(pCode->GetNextReference()) ) != NULL )
 546         {
 547                 ScSingleRefData& rRef1 = t->GetSingleRef();
 548                 if ( rRef1.IsTabRel() )
 549             rRef1.nTab = sal::static_int_cast<SCsTAB>( rRef1.nTab + nPosDiff );
 550                 else
 551             rRef1.nTab = sal::static_int_cast<SCsTAB>( rRef1.nTab + nTabDiff );
 552                 if ( t->GetType() == svDoubleRef )
 553                 {
 554                         ScSingleRefData& rRef2 = t->GetDoubleRef().Ref2;
 555                         if ( rRef2.IsTabRel() )
 556                 rRef2.nTab = sal::static_int_cast<SCsTAB>( rRef2.nTab + nPosDiff );
 557                         else
 558                 rRef2.nTab = sal::static_int_cast<SCsTAB>( rRef2.nTab + nTabDiff );
 559                 }
 560         }
 561 }
 562
 563
 564 void ScRangeData::ReplaceRangeNamesInUse( const ScIndexMap& rMap )
 565 {
 566         BOOL bCompile = FALSE;
 567         for ( FormulaToken* p = pCode->First(); p; p = pCode->Next() )
 568         {
 569                 if ( p->GetOpCode() == ocName )
 570                 {
 571             const USHORT nOldIndex = p->GetIndex();
 572             const USHORT nNewIndex = rMap.Find( nOldIndex );
 573             if ( nOldIndex != nNewIndex )
 574                         {
 575                                 p->SetIndex( nNewIndex );
 576                                 bCompile = TRUE;
 577                         }
 578                 }
 579         }
 580         if ( bCompile )
 581         {
 582                 ScCompiler aComp( pDoc, aPos, *pCode);
 583         aComp.SetGrammar(pDoc->GetGrammar());
 584                 aComp.CompileTokenArray();
 585         }
 586 }
 587
 588 void ScRangeData::ReplaceRangeNamesInUse( const IndexMap& rMap )
 589 {
 590     bool bCompile = false;
 591     for ( FormulaToken* p = pCode->First(); p; p = pCode->Next() )
 592     {
 593         if ( p->GetOpCode() == ocName )
 594         {
 595             const sal_uInt16 nOldIndex = p->GetIndex();
 596             IndexMap::const_iterator itr = rMap.find(nOldIndex);
 597             const sal_uInt16 nNewIndex = itr == rMap.end() ? nOldIndex : itr->second;
 598             if ( nOldIndex != nNewIndex )
 599             {
 600                 p->SetIndex( nNewIndex );
 601                 bCompile = true;
 602             }
 603         }
 604     }
 605     if ( bCompile )
 606     {
 607         ScCompiler aComp( pDoc, aPos, *pCode);
 608         aComp.SetGrammar(pDoc->GetGrammar());
 609         aComp.CompileTokenArray();
 610     }
 611 }
 612
 613
 614 void ScRangeData::ValidateTabRefs()
 615 {
 616         //      try to make sure all relative references and the reference position
 617         //      are within existing tables, so they can be represented as text
 618         //      (if the range of used tables is more than the existing tables,
 619         //      the result may still contain invalid tables, because the relative
 620         //      references aren't changed so formulas stay the same)
 621
 622         //      find range of used tables
 623
 624         SCTAB nMinTab = aPos.Tab();
 625         SCTAB nMaxTab = nMinTab;
 626         ScToken* t;
 627         pCode->Reset();
 628     while ( ( t = static_cast<ScToken*>(pCode->GetNextReference()) ) != NULL )
 629         {
 630                 ScSingleRefData& rRef1 = t->GetSingleRef();
 631                 if ( rRef1.IsTabRel() && !rRef1.IsTabDeleted() )
 632                 {
 633                         if ( rRef1.nTab < nMinTab )
 634                                 nMinTab = rRef1.nTab;
 635                         if ( rRef1.nTab > nMaxTab )
 636                                 nMaxTab = rRef1.nTab;
 637                 }
 638                 if ( t->GetType() == svDoubleRef )
 639                 {
 640                         ScSingleRefData& rRef2 = t->GetDoubleRef().Ref2;
 641                         if ( rRef2.IsTabRel() && !rRef2.IsTabDeleted() )
 642                         {
 643                                 if ( rRef2.nTab < nMinTab )
 644                                         nMinTab = rRef2.nTab;
 645                                 if ( rRef2.nTab > nMaxTab )
 646                                         nMaxTab = rRef2.nTab;
 647                         }
 648                 }
 649         }
 650
 651         SCTAB nTabCount = pDoc->GetTableCount();
 652         if ( nMaxTab >= nTabCount && nMinTab > 0 )
 653         {
 654                 //      move position and relative tab refs
 655                 //      The formulas that use the name are not changed by this
 656
 657                 SCTAB nMove = nMinTab;
 658                 aPos.SetTab( aPos.Tab() - nMove );
 659
 660                 pCode->Reset();
 661         while ( ( t = static_cast<ScToken*>(pCode->GetNextReference()) ) != NULL )
 662                 {
 663                         ScSingleRefData& rRef1 = t->GetSingleRef();
 664                         if ( rRef1.IsTabRel() && !rRef1.IsTabDeleted() )
 665                 rRef1.nTab = sal::static_int_cast<SCsTAB>( rRef1.nTab - nMove );
 666                         if ( t->GetType() == svDoubleRef )
 667                         {
 668                                 ScSingleRefData& rRef2 = t->GetDoubleRef().Ref2;
 669                                 if ( rRef2.IsTabRel() && !rRef2.IsTabDeleted() )
 670                     rRef2.nTab = sal::static_int_cast<SCsTAB>( rRef2.nTab - nMove );
 671                         }
 672                 }
 673         }
 674 }
 675
 676
 677 extern "C" int
 678 #ifdef WNT
 679 __cdecl
 680 #endif
 681 ScRangeData_QsortNameCompare( const void* p1, const void* p2 )
 682 {
 683         return (int) ScGlobal::pCollator->compareString(
 684                         (*(const ScRangeData**)p1)->GetName(),
 685                         (*(const ScRangeData**)p2)->GetName() );
 686 }
 687
 688
 689 //========================================================================
 690 // ScRangeName
 691 //========================================================================
 692
 693 ScRangeName::ScRangeName(const ScRangeName& rScRangeName, ScDocument* pDocument) :
 694                                 ScSortedCollection ( rScRangeName ),
 695                                 pDoc ( pDocument ),
 696                                 nSharedMaxIndex (rScRangeName.nSharedMaxIndex)
 697 {
 698         for (USHORT i = 0; i < nCount; i++)
 699         {
 700                 ((ScRangeData*)At(i))->SetDocument(pDocument);
 701                 ((ScRangeData*)At(i))->SetIndex(((ScRangeData*)rScRangeName.At(i))->GetIndex());
 702         }
 703 }
 704
 705 short ScRangeName::Compare(ScDataObject* pKey1, ScDataObject* pKey2) const
 706 {
 707         USHORT i1 = ((ScRangeData*)pKey1)->GetIndex();
 708         USHORT i2 = ((ScRangeData*)pKey2)->GetIndex();
 709         return (short) i1 - (short) i2;
 710 }
 711
 712 BOOL ScRangeName::SearchNameUpper( const String& rUpperName, USHORT& rIndex ) const
 713 {
 714     // SearchNameUpper must be called with an upper-case search string
 715
 716     USHORT i = 0;
 717     while (i < nCount)
 718     {
 719         if ( ((*this)[i])->GetUpperName() == rUpperName )
 720         {
 721             rIndex = i;
 722             return TRUE;
 723         }
 724         i++;
 725     }
 726     return FALSE;
 727 }
 728
 729 BOOL ScRangeName::SearchName( const String& rName, USHORT& rIndex ) const
 730 {
 731     if ( nCount > 0 )
 732         return SearchNameUpper( ScGlobal::pCharClass->upper( rName ), rIndex );
 733     else
 734         return FALSE;
 735 }
 736
 737 void ScRangeName::UpdateReference(      UpdateRefMode eUpdateRefMode,
 738                                                                         const ScRange& rRange,
 739                                                                         SCsCOL nDx, SCsROW nDy, SCsTAB nDz )
 740 {
 741         for (USHORT i=0; i<nCount; i++)
 742                 ((ScRangeData*)pItems[i])->UpdateReference(eUpdateRefMode, rRange,
 743                                                                                                    nDx, nDy, nDz);
 744 }
 745
 746 void ScRangeName::UpdateTranspose( const ScRange& rSource, const ScAddress& rDest )
 747 {
 748         for (USHORT i=0; i<nCount; i++)
 749                 ((ScRangeData*)pItems[i])->UpdateTranspose( rSource, rDest );
 750 }
 751
 752 void ScRangeName::UpdateGrow( const ScRange& rArea, SCCOL nGrowX, SCROW nGrowY )
 753 {
 754         for (USHORT i=0; i<nCount; i++)
 755                 ((ScRangeData*)pItems[i])->UpdateGrow( rArea, nGrowX, nGrowY );
 756 }
 757
 758 BOOL ScRangeName::IsEqual(ScDataObject* pKey1, ScDataObject* pKey2) const
 759 {
 760         return *(ScRangeData*)pKey1 == *(ScRangeData*)pKey2;
 761 }
 762
 763 BOOL ScRangeName::Insert(ScDataObject* pScDataObject)
 764 {
 765         if (!((ScRangeData*)pScDataObject)->GetIndex())         // schon gesetzt?
 766         {
 767                 ((ScRangeData*)pScDataObject)->SetIndex( GetEntryIndex() );
 768         }
 769
 770         return ScSortedCollection::Insert(pScDataObject);
 771 }
 772
 773 // Suche nach einem freien Index
 774
 775 USHORT ScRangeName::GetEntryIndex()
 776 {
 777         USHORT nLast = 0;
 778         for ( USHORT i = 0; i < nCount; i++ )
 779         {
 780                 USHORT nIdx = ((ScRangeData*)pItems[i])->GetIndex();
 781                 if( nIdx > nLast )
 782                 {
 783                         nLast = nIdx;
 784                 }
 785         }
 786         return nLast + 1;
 787 }
 788
 789 ScRangeData* ScRangeName::FindIndex( USHORT nIndex )
 790 {
 791         ScRangeData aDataObj( nIndex );
 792         USHORT n;
 793         if( Search( &aDataObj, n ) )
 794                 return (*this)[ n ];
 795         else
 796                 return NULL;
 797 }
 798
 799 ScRangeData* ScRangeName::GetRangeAtCursor( const ScAddress& rPos, BOOL bStartOnly ) const
 800 {
 801         if ( pItems )
 802         {
 803                 for ( USHORT i = 0; i < nCount; i++ )
 804                         if ( ((ScRangeData*)pItems[i])->IsRangeAtCursor( rPos, bStartOnly ) )
 805                                 return (ScRangeData*)pItems[i];
 806         }
 807         return NULL;
 808 }
 809
 810 ScRangeData* ScRangeName::GetRangeAtBlock( const ScRange& rBlock ) const
 811 {
 812         if ( pItems )
 813         {
 814                 for ( USHORT i = 0; i < nCount; i++ )
 815                         if ( ((ScRangeData*)pItems[i])->IsRangeAtBlock( rBlock ) )
 816                                 return (ScRangeData*)pItems[i];
 817         }
 818         return NULL;
 819 }
 820
 821 void ScRangeName::UpdateTabRef(SCTAB nOldTable, USHORT nFlag, SCTAB nNewTable)
 822 {
 823         for (USHORT i=0; i<nCount; i++)
 824                 ((ScRangeData*)pItems[i])->UpdateTabRef(nOldTable, nFlag, nNewTable);
 825 }
 826
 827
 828
 829