sc/source/filter/excel/tokstack.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: tokstack.cxx,v $
  10  * $Revision: 1.14.32.3 $
  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 #ifndef PCH
  36 #include <string.h>
  37 #endif
  38
  39 #include "compiler.hxx"
  40 #include "tokstack.hxx"
  41 #include "global.hxx"
  42 #include "scmatrix.hxx"
  43
  44 #include <stdio.h> // printf
  45
  46 const UINT16    TokenPool::nScTokenOff = 8192;
  47
  48
  49 TokenStack::TokenStack( UINT16 nNewSize )
  50 {
  51     pStack = new TokenId[ nNewSize ];
  52
  53     Reset();
  54     nSize = nNewSize;
  55 }
  56
  57
  58 TokenStack::~TokenStack()
  59 {
  60     delete[] pStack;
  61 }
  62
  63
  64
  65
  66 //------------------------------------------------------------------------
  67
  68 // !ACHTUNG!: nach Aussen hin beginnt die Nummerierung mit 1!
  69 // !ACHTUNG!: SC-Token werden mit einem Offset nScTokenOff abgelegt
  70 //                              -> Unterscheidung von anderen Token
  71
  72
  73 TokenPool::TokenPool( void )
  74 {
  75     UINT16      nLauf = nScTokenOff;
  76
  77     // Sammelstelle fuer Id-Folgen
  78     nP_Id = 256;
  79     pP_Id = new UINT16[ nP_Id ];
  80
  81     // Sammelstelle fuer Ids
  82     nElement = 32;
  83     pElement = new UINT16[ nElement ];
  84     pType = new E_TYPE[ nElement ];
  85     pSize = new UINT16[ nElement ];
  86     nP_IdLast = 0;
  87
  88     // Sammelstelle fuer Strings
  89     nP_Str = 4;
  90     ppP_Str = new String *[ nP_Str ];
  91     for( nLauf = 0 ; nLauf < nP_Str ; nLauf++ )
  92         ppP_Str[ nLauf ] = NULL;
  93
  94     // Sammelstelle fuer double
  95     nP_Dbl = 8;
  96     pP_Dbl = new double[ nP_Dbl ];
  97
  98     // Sammelstelle fuer error codes
  99     nP_Err = 8;
 100     pP_Err = new USHORT[ nP_Err ];
 101
 102     // Sammelstellen fuer Referenzen
 103     nP_RefTr = 32;
 104     ppP_RefTr = new ScSingleRefData *[ nP_RefTr ];
 105     for( nLauf = 0 ; nLauf < nP_RefTr ; nLauf++ )
 106         ppP_RefTr[ nLauf ] = NULL;
 107
 108     nP_Ext = 32;
 109     ppP_Ext = new EXTCONT*[ nP_Ext ];
 110     memset( ppP_Ext, 0, sizeof( EXTCONT* ) * nP_Ext );
 111
 112     nP_Nlf = 16;
 113     ppP_Nlf = new NLFCONT*[ nP_Nlf ];
 114     memset( ppP_Nlf, 0, sizeof( NLFCONT* ) * nP_Nlf );
 115
 116     nP_Matrix = 16;
 117     ppP_Matrix = new ScMatrix*[ nP_Matrix ];
 118     memset( ppP_Matrix, 0, sizeof( ScMatrix* ) * nP_Matrix );
 119
 120     pScToken = new ScTokenArray;
 121
 122     Reset();
 123 }
 124
 125
 126 TokenPool::~TokenPool()
 127 {
 128     UINT16      n;
 129
 130     delete[] pP_Id;
 131     delete[] pElement;
 132     delete[] pType;
 133     delete[] pSize;
 134     delete[] pP_Dbl;
 135     delete[] pP_Err;
 136
 137     for( n = 0 ; n < nP_RefTr ; n++/*, pAktTr++*/ )
 138     {
 139         if( ppP_RefTr[ n ] )
 140             delete ppP_RefTr[ n ];
 141     }
 142     delete[] ppP_RefTr;
 143
 144     for( n = 0 ; n < nP_Str ; n++/*, pAktStr++*/ )
 145     {
 146         if( ppP_Str[ n ] )
 147             delete ppP_Str[ n ];
 148     }
 149     delete[] ppP_Str;
 150
 151     for( n = 0 ; n < nP_Ext ; n++ )
 152     {
 153         if( ppP_Ext[ n ] )
 154             delete ppP_Ext[ n ];
 155     }
 156     delete[] ppP_Ext;
 157
 158     for( n = 0 ; n < nP_Nlf ; n++ )
 159     {
 160         if( ppP_Nlf[ n ] )
 161             delete ppP_Nlf[ n ];
 162     }
 163     delete[] ppP_Nlf;
 164
 165     for( n = 0 ; n < nP_Matrix ; n++ )
 166     {
 167         if( ppP_Matrix[ n ] )
 168             ppP_Matrix[ n ]->DecRef( );
 169     }
 170     delete[] ppP_Matrix;
 171
 172     delete pScToken;
 173 }
 174
 175
 176 void TokenPool::GrowString( void )
 177 {
 178     UINT16              nP_StrNew = nP_Str * 2;
 179     UINT16              nL;
 180
 181     String**    ppP_StrNew = new String *[ nP_StrNew ];
 182
 183     for( nL = 0 ; nL < nP_Str ; nL++ )
 184         ppP_StrNew[ nL ] = ppP_Str[ nL ];
 185     for( nL = nP_Str ; nL < nP_StrNew ; nL++ )
 186         ppP_StrNew[ nL ] = NULL;
 187
 188     nP_Str = nP_StrNew;
 189
 190     delete[]    ppP_Str;
 191     ppP_Str = ppP_StrNew;
 192 }
 193
 194
 195 void TokenPool::GrowDouble( void )
 196 {
 197     UINT16              nP_DblNew = nP_Dbl * 2;
 198
 199     double*             pP_DblNew = new double[ nP_DblNew ];
 200
 201     for( UINT16 nL = 0 ; nL < nP_Dbl ; nL++ )
 202         pP_DblNew[ nL ] = pP_Dbl[ nL ];
 203
 204     nP_Dbl = nP_DblNew;
 205
 206     delete[] pP_Dbl;
 207     pP_Dbl = pP_DblNew;
 208 }
 209
 210
 211 //UNUSED2009-05 void TokenPool::GrowError( void )
 212 //UNUSED2009-05 {
 213 //UNUSED2009-05     UINT16      nP_ErrNew = nP_Err * 2;
 214 //UNUSED2009-05
 215 //UNUSED2009-05     USHORT*     pP_ErrNew = new USHORT[ nP_ErrNew ];
 216 //UNUSED2009-05
 217 //UNUSED2009-05     for( UINT16 nL = 0 ; nL < nP_Err ; nL++ )
 218 //UNUSED2009-05         pP_ErrNew[ nL ] = pP_Err[ nL ];
 219 //UNUSED2009-05
 220 //UNUSED2009-05     nP_Err = nP_ErrNew;
 221 //UNUSED2009-05
 222 //UNUSED2009-05     delete[] pP_Err;
 223 //UNUSED2009-05     pP_Err = pP_ErrNew;
 224 //UNUSED2009-05 }
 225
 226
 227 void TokenPool::GrowTripel( void )
 228 {
 229     UINT16                      nP_RefTrNew = nP_RefTr * 2;
 230     UINT16                      nL;
 231
 232     ScSingleRefData**   ppP_RefTrNew = new ScSingleRefData *[ nP_RefTrNew ];
 233
 234     for( nL = 0 ; nL < nP_RefTr ; nL++ )
 235         ppP_RefTrNew[ nL ] = ppP_RefTr[ nL ];
 236     for( nL = nP_RefTr ; nL < nP_RefTrNew ; nL++ )
 237         ppP_RefTrNew[ nL ] = NULL;
 238
 239     nP_RefTr = nP_RefTrNew;
 240
 241     delete[] ppP_RefTr;
 242     ppP_RefTr = ppP_RefTrNew;
 243 }
 244
 245
 246 void TokenPool::GrowId( void )
 247 {
 248     UINT16      nP_IdNew = nP_Id * 2;
 249
 250     UINT16*     pP_IdNew = new UINT16[ nP_IdNew ];
 251
 252     for( UINT16 nL = 0 ; nL < nP_Id ; nL++ )
 253         pP_IdNew[ nL ] = pP_Id[ nL ];
 254
 255     nP_Id = nP_IdNew;
 256
 257     delete[] pP_Id;
 258     pP_Id = pP_IdNew;
 259 }
 260
 261
 262 void TokenPool::GrowElement( void )
 263 {
 264     UINT16      nElementNew = nElement * 2;
 265
 266     UINT16*     pElementNew = new UINT16[ nElementNew ];
 267     E_TYPE*     pTypeNew = new E_TYPE[ nElementNew ];
 268     UINT16*     pSizeNew = new UINT16[ nElementNew ];
 269
 270     for( UINT16 nL = 0 ; nL < nElement ; nL++ )
 271     {
 272         pElementNew[ nL ] = pElement[ nL ];
 273         pTypeNew[ nL ] = pType[ nL ];
 274         pSizeNew[ nL ] = pSize[ nL ];
 275     }
 276
 277     nElement = nElementNew;
 278
 279     delete[] pElement;
 280     delete[] pType;
 281     delete[] pSize;
 282     pElement = pElementNew;
 283     pType = pTypeNew;
 284     pSize = pSizeNew;
 285 }
 286
 287
 288 void TokenPool::GrowExt( void )
 289 {
 290     UINT16              nNewSize = nP_Ext * 2;
 291
 292     EXTCONT**   ppNew = new EXTCONT*[ nNewSize ];
 293
 294     memset( ppNew, 0, sizeof( EXTCONT* ) * nNewSize );
 295     memcpy( ppNew, ppP_Ext, sizeof( EXTCONT* ) * nP_Ext );
 296
 297     delete[] ppP_Ext;
 298     ppP_Ext = ppNew;
 299     nP_Ext = nNewSize;
 300 }
 301
 302
 303 void TokenPool::GrowNlf( void )
 304 {
 305     UINT16              nNewSize = nP_Nlf * 2;
 306
 307     NLFCONT**   ppNew = new NLFCONT*[ nNewSize ];
 308
 309     memset( ppNew, 0, sizeof( NLFCONT* ) * nNewSize );
 310     memcpy( ppNew, ppP_Nlf, sizeof( NLFCONT* ) * nP_Nlf );
 311
 312     delete[] ppP_Nlf;
 313     ppP_Nlf = ppNew;
 314     nP_Nlf = nNewSize;
 315 }
 316
 317
 318 void TokenPool::GrowMatrix( void )
 319 {
 320     UINT16      nNewSize = nP_Matrix * 2;
 321
 322     ScMatrix**  ppNew = new ScMatrix*[ nNewSize ];
 323
 324     memset( ppNew, 0, sizeof( ScMatrix* ) * nNewSize );
 325     memcpy( ppNew, ppP_Matrix, sizeof( ScMatrix* ) * nP_Matrix );
 326
 327     delete[] ppP_Matrix;
 328     ppP_Matrix = ppNew;
 329     nP_Matrix = nNewSize;
 330 }
 331
 332 void TokenPool::GetElement( const UINT16 nId )
 333 {
 334     DBG_ASSERT( nId < nElementAkt, "*TokenPool::GetElement(): Id zu gross!?" );
 335
 336     if( pType[ nId ] == T_Id )
 337         GetElementRek( nId );
 338     else
 339     {
 340         switch( pType[ nId ] )
 341         {
 342 #ifdef DBG_UTIL
 343             case T_Id:
 344                 DBG_ERROR( "-TokenPool::GetElement(): hier hast Du nichts zu suchen!" );
 345                 break;
 346 #endif
 347             case T_Str:
 348                 pScToken->AddString( ppP_Str[ pElement[ nId ] ]->GetBuffer() );
 349                 break;
 350             case T_D:
 351                 pScToken->AddDouble( pP_Dbl[ pElement[ nId ] ] );
 352                 break;
 353             case T_Err:
 354 #if 0   // erAck
 355                 pScToken->AddError( pP_Err[ pElement[ nId ] ] );
 356 #endif
 357                 break;
 358             case T_RefC:
 359                 pScToken->AddSingleReference( *ppP_RefTr[ pElement[ (UINT16) nId ] ] );
 360                 break;
 361             case T_RefA:
 362                 {
 363                 ScComplexRefData        aScComplexRefData;
 364                 aScComplexRefData.Ref1 = *ppP_RefTr[ pElement[ nId ] ];
 365                 aScComplexRefData.Ref2 = *ppP_RefTr[ pElement[ nId ] + 1 ];
 366                 pScToken->AddDoubleReference( aScComplexRefData );
 367                 }
 368                 break;
 369             case T_RN:
 370                 pScToken->AddName( pElement[ nId ] );
 371                 break;
 372             case T_Ext:
 373                 {
 374                 UINT16                  n = pElement[ nId ];
 375                 EXTCONT*                p = ( n < nP_Ext )? ppP_Ext[ n ] : NULL;
 376
 377                 if( p )
 378                 {
 379                     if( p->eId == ocEuroConvert )
 380                         pScToken->AddOpCode( p->eId );
 381                     else
 382                         pScToken->AddExternal( p->aText, p->eId );
 383                 }
 384                 }
 385                 break;
 386             case T_Nlf:
 387                 {
 388                 UINT16                  n = pElement[ nId ];
 389                 NLFCONT*                p = ( n < nP_Nlf )? ppP_Nlf[ n ] : NULL;
 390
 391                 if( p )
 392                         pScToken->AddColRowName( p->aRef );
 393                 }
 394                 break;
 395             case T_Matrix:
 396                 {
 397                 UINT16          n = pElement[ nId ];
 398                 ScMatrix*       p = ( n < nP_Matrix )? ppP_Matrix[ n ] : NULL;
 399
 400                 if( p )
 401                         pScToken->AddMatrix( p );
 402                 }
 403                 break;
 404             case T_ExtName:
 405             {
 406                 UINT16 n = pElement[nId];
 407                 if (n < maExtNames.size())
 408                 {
 409                     const ExtName& r = maExtNames[n];
 410                     pScToken->AddExternalName(r.mnFileId, r.maName);
 411                 }
 412             }
 413             case T_ExtRefC:
 414             {
 415                 UINT16 n = pElement[nId];
 416                 if (n < maExtCellRefs.size())
 417                 {
 418                     const ExtCellRef& r = maExtCellRefs[n];
 419                     pScToken->AddExternalSingleReference(r.mnFileId, r.maTabName, r.maRef);
 420                 }
 421             }
 422             case T_ExtRefA:
 423             {
 424                 UINT16 n = pElement[nId];
 425                 if (n < maExtAreaRefs.size())
 426                 {
 427                     const ExtAreaRef& r = maExtAreaRefs[n];
 428                     pScToken->AddExternalDoubleReference(r.mnFileId, r.maTabName, r.maRef);
 429                 }
 430             }
 431             break;
 432             default:
 433                 DBG_ERROR("-TokenPool::GetElement(): Zustand undefiniert!?");
 434         }
 435     }
 436 }
 437
 438
 439 void TokenPool::GetElementRek( const UINT16 nId )
 440 {
 441 #ifdef DBG_UTIL
 442     nRek++;
 443     DBG_ASSERT( nRek <= nP_Id, "*TokenPool::GetElement(): Rekursion loopt!?" );
 444 #endif
 445
 446     DBG_ASSERT( nId < nElementAkt, "*TokenPool::GetElementRek(): Id zu gross!?" );
 447
 448     DBG_ASSERT( pType[ nId ] == T_Id, "-TokenPool::GetElementRek(): nId nicht Id-Folge!" );
 449
 450
 451     UINT16              nAnz = pSize[ nId ];
 452     UINT16*             pAkt = &pP_Id[ pElement[ nId ] ];
 453     for( ; nAnz > 0 ; nAnz--, pAkt++ )
 454     {
 455         if( *pAkt < nScTokenOff )
 456         {// Rekursion oder nicht?
 457             switch( pType[ *pAkt ] )
 458             {
 459                 case T_Id:
 460                     GetElementRek( *pAkt );
 461                     break;
 462                 case T_Str:
 463                     pScToken->AddString( ppP_Str[ pElement[ *pAkt ] ]->GetBuffer() );
 464                     break;
 465                 case T_D:
 466                     pScToken->AddDouble( pP_Dbl[ pElement[ *pAkt ] ] );
 467                     break;
 468                 case T_Err:
 469 #if 0   // erAck
 470                     pScToken->AddError( pP_Err[ pElement[ *pAkt ] ] );
 471 #endif
 472                     break;
 473                 case T_RefC:
 474                     pScToken->AddSingleReference( *ppP_RefTr[ pElement[ *pAkt ] ] );
 475                     break;
 476                 case T_RefA:
 477                     {
 478                     ScComplexRefData    aScComplexRefData;
 479                     aScComplexRefData.Ref1 = *ppP_RefTr[ pElement[ *pAkt ] ];
 480                     aScComplexRefData.Ref2 = *ppP_RefTr[ pElement[ *pAkt ] + 1 ];
 481                     pScToken->AddDoubleReference( aScComplexRefData );
 482                     }
 483                     break;
 484                 case T_RN:
 485                     pScToken->AddName( pElement[ *pAkt ] );
 486                     break;
 487                 case T_Ext:
 488                     {
 489                     UINT16              n = pElement[ *pAkt ];
 490                     EXTCONT*    p = ( n < nP_Ext )? ppP_Ext[ n ] : NULL;
 491
 492                     if( p )
 493                         pScToken->AddExternal( p->aText, p->eId );
 494                     }
 495                     break;
 496                 case T_Nlf:
 497                     {
 498                     UINT16              n = pElement[ *pAkt ];
 499                     NLFCONT*    p = ( n < nP_Nlf )? ppP_Nlf[ n ] : NULL;
 500
 501                     if( p )
 502                         pScToken->AddColRowName( p->aRef );
 503                     }
 504                     break;
 505                 case T_Matrix:
 506                     {
 507                     UINT16          n = pElement[ *pAkt ];
 508                     ScMatrix*       p = ( n < nP_Matrix )? ppP_Matrix[ n ] : NULL;
 509
 510                     if( p )
 511                             pScToken->AddMatrix( p );
 512                     }
 513                     break;
 514                 case T_ExtName:
 515                 {
 516                     UINT16 n = pElement[*pAkt];
 517                     if (n < maExtNames.size())
 518                     {
 519                         const ExtName& r = maExtNames[n];
 520                         pScToken->AddExternalName(r.mnFileId, r.maName);
 521                     }
 522                 }
 523                 case T_ExtRefC:
 524                 {
 525                     UINT16 n = pElement[*pAkt];
 526                     if (n < maExtCellRefs.size())
 527                     {
 528                         const ExtCellRef& r = maExtCellRefs[n];
 529                         pScToken->AddExternalSingleReference(r.mnFileId, r.maTabName, r.maRef);
 530                     }
 531                 }
 532                 case T_ExtRefA:
 533                 {
 534                     UINT16 n = pElement[*pAkt];
 535                     if (n < maExtAreaRefs.size())
 536                     {
 537                         const ExtAreaRef& r = maExtAreaRefs[n];
 538                         pScToken->AddExternalDoubleReference(r.mnFileId, r.maTabName, r.maRef);
 539                     }
 540                 }
 541                 break;
 542                 default:
 543                     DBG_ERROR("-TokenPool::GetElementRek(): Zustand undefiniert!?");
 544             }
 545         }
 546         else    // elementarer SC_Token
 547             pScToken->AddOpCode( ( DefTokenId ) ( *pAkt - nScTokenOff ) );
 548     }
 549
 550
 551 #ifdef DBG_UTIL
 552     nRek--;
 553 #endif
 554 }
 555
 556
 557 void TokenPool::operator >>( TokenId& rId )
 558 {
 559     rId = ( TokenId ) ( nElementAkt + 1 );
 560
 561     if( nElementAkt >= nElement )
 562         GrowElement();
 563
 564     pElement[ nElementAkt ] = nP_IdLast;        // Start der Token-Folge
 565     pType[ nElementAkt ] = T_Id;                        // Typinfo eintragen
 566     pSize[ nElementAkt ] = nP_IdAkt - nP_IdLast;
 567         // von nP_IdLast bis nP_IdAkt-1 geschrieben -> Laenge der Folge
 568
 569     nElementAkt++;                      // Startwerte fuer naechste Folge
 570     nP_IdLast = nP_IdAkt;
 571 }
 572
 573
 574 const TokenId TokenPool::Store( const double& rDouble )
 575 {
 576     if( nElementAkt >= nElement )
 577         GrowElement();
 578
 579     if( nP_DblAkt >= nP_Dbl )
 580         GrowDouble();
 581
 582     pElement[ nElementAkt ] = nP_DblAkt;        // Index in Double-Array
 583     pType[ nElementAkt ] = T_D;                         // Typinfo Double eintragen
 584
 585     pP_Dbl[ nP_DblAkt ] = rDouble;
 586
 587     pSize[ nElementAkt ] = 1;                   // eigentlich Banane
 588
 589     nElementAkt++;
 590     nP_DblAkt++;
 591
 592     return ( const TokenId ) nElementAkt; // Ausgabe von altem Wert + 1!
 593 }
 594
 595
 596 const TokenId TokenPool::Store( const UINT16 nIndex )
 597 {
 598     if( nElementAkt >= nElement )
 599         GrowElement();
 600
 601     pElement[ nElementAkt ] = nIndex;                   // Daten direkt im Index!
 602     pType[ nElementAkt ] = T_RN;                                // Typinfo Range Name eintragen
 603
 604     nElementAkt++;
 605     return ( const TokenId ) nElementAkt;                               // Ausgabe von altem Wert + 1!
 606 }
 607
 608
 609 const TokenId TokenPool::Store( const String& rString )
 610 {
 611     // weitgehend nach Store( const sal_Char* ) kopiert, zur Vermeidung
 612     //  eines temporaeren Strings in "
 613     if( nElementAkt >= nElement )
 614         GrowElement();
 615
 616     if( nP_StrAkt >= nP_Str )
 617         GrowString();
 618
 619     pElement[ nElementAkt ] = nP_StrAkt;        // Index in String-Array
 620     pType[ nElementAkt ] = T_Str;                       // Typinfo String eintragen
 621
 622     // String anlegen
 623     if( !ppP_Str[ nP_StrAkt ] )
 624         //...aber nur, wenn noch nicht vorhanden
 625         ppP_Str[ nP_StrAkt ] = new String( rString );
 626     else
 627         //...ansonsten nur kopieren
 628         *ppP_Str[ nP_StrAkt ] = rString;
 629
 630     DBG_ASSERT( sizeof( xub_StrLen ) <= 2, "*TokenPool::Store(): StrLen doesn't match!" );
 631
 632     pSize[ nElementAkt ] = ( UINT16 ) ppP_Str[ nP_StrAkt ]->Len();
 633
 634     nElementAkt++;
 635     nP_StrAkt++;
 636
 637     return ( const TokenId ) nElementAkt; // Ausgabe von altem Wert + 1!
 638 }
 639
 640
 641 const TokenId TokenPool::Store( const ScSingleRefData& rTr )
 642 {
 643     if( nElementAkt >= nElement )
 644         GrowElement();
 645
 646     if( nP_RefTrAkt >= nP_RefTr )
 647         GrowTripel();
 648
 649     pElement[ nElementAkt ] = nP_RefTrAkt;
 650     pType[ nElementAkt ] = T_RefC;                      // Typinfo Cell-Reff eintragen
 651
 652     if( !ppP_RefTr[ nP_RefTrAkt ] )
 653         ppP_RefTr[ nP_RefTrAkt ] = new ScSingleRefData( rTr );
 654     else
 655         *ppP_RefTr[ nP_RefTrAkt ] = rTr;
 656
 657     nElementAkt++;
 658     nP_RefTrAkt++;
 659
 660     return ( const TokenId ) nElementAkt; // Ausgabe von altem Wert + 1!
 661 }
 662
 663
 664 const TokenId TokenPool::Store( const ScComplexRefData& rTr )
 665 {
 666     if( nElementAkt >= nElement )
 667         GrowElement();
 668
 669     if( nP_RefTrAkt + 1 >= nP_RefTr )
 670         GrowTripel();
 671
 672     pElement[ nElementAkt ] = nP_RefTrAkt;
 673     pType[ nElementAkt ] = T_RefA;                      // Typinfo Area-Reff eintragen
 674
 675     if( !ppP_RefTr[ nP_RefTrAkt ] )
 676         ppP_RefTr[ nP_RefTrAkt ] = new ScSingleRefData( rTr.Ref1 );
 677     else
 678         *ppP_RefTr[ nP_RefTrAkt ] = rTr.Ref1;
 679     nP_RefTrAkt++;
 680
 681     if( !ppP_RefTr[ nP_RefTrAkt ] )
 682         ppP_RefTr[ nP_RefTrAkt ] = new ScSingleRefData( rTr.Ref2 );
 683     else
 684         *ppP_RefTr[ nP_RefTrAkt ] = rTr.Ref2;
 685     nP_RefTrAkt++;
 686
 687     nElementAkt++;
 688
 689     return ( const TokenId ) nElementAkt; // Ausgabe von altem Wert + 1!
 690 }
 691
 692
 693 const TokenId TokenPool::Store( const DefTokenId e, const String& r )
 694 {
 695     if( nElementAkt >= nElement )
 696         GrowElement();
 697
 698     if( nP_ExtAkt >= nP_Ext )
 699         GrowExt();
 700
 701     pElement[ nElementAkt ] = nP_ExtAkt;
 702     pType[ nElementAkt ] = T_Ext;                       // Typinfo String eintragen
 703
 704     if( ppP_Ext[ nP_ExtAkt ] )
 705     {
 706         ppP_Ext[ nP_ExtAkt ]->eId = e;
 707         ppP_Ext[ nP_ExtAkt ]->aText = r;
 708     }
 709     else
 710         ppP_Ext[ nP_ExtAkt ] = new EXTCONT( e, r );
 711
 712     nElementAkt++;
 713     nP_ExtAkt++;
 714
 715     return ( const TokenId ) nElementAkt; // Ausgabe von altem Wert + 1!
 716 }
 717
 718
 719 const TokenId TokenPool::StoreNlf( const ScSingleRefData& rTr )
 720 {
 721     if( nElementAkt >= nElement )
 722         GrowElement();
 723
 724     if( nP_NlfAkt >= nP_Nlf )
 725         GrowNlf();
 726
 727     pElement[ nElementAkt ] = nP_NlfAkt;
 728     pType[ nElementAkt ] = T_Nlf;
 729
 730     if( ppP_Nlf[ nP_NlfAkt ] )
 731     {
 732         ppP_Nlf[ nP_NlfAkt ]->aRef = rTr;
 733     }
 734     else
 735         ppP_Nlf[ nP_NlfAkt ] = new NLFCONT( rTr );
 736
 737     nElementAkt++;
 738     nP_NlfAkt++;
 739
 740     return ( const TokenId ) nElementAkt;
 741 }
 742
 743 const TokenId TokenPool::StoreMatrix( SCSIZE nC, SCSIZE nR )
 744 {
 745     ScMatrix* pM;
 746
 747     if( nElementAkt >= nElement )
 748         GrowElement();
 749
 750     if( nP_MatrixAkt >= nP_Matrix )
 751         GrowMatrix();
 752
 753     pElement[ nElementAkt ] = nP_MatrixAkt;
 754     pType[ nElementAkt ] = T_Matrix;
 755
 756     pM = new ScMatrix( nC, nR );
 757     pM->FillDouble( 0., 0,0, nC-1, nR-1 );
 758     pM->IncRef( );
 759     ppP_Matrix[ nP_MatrixAkt ] = pM;
 760
 761     nElementAkt++;
 762     nP_MatrixAkt++;
 763
 764     return ( const TokenId ) nElementAkt;
 765 }
 766
 767 const TokenId TokenPool::StoreExtName( sal_uInt16 nFileId, const String& rName )
 768 {
 769     if ( nElementAkt >= nElement )
 770         GrowElement();
 771
 772     pElement[nElementAkt] = static_cast<UINT16>(maExtNames.size());
 773     pType[nElementAkt] = T_ExtName;
 774
 775     maExtNames.push_back(ExtName());
 776     ExtName& r = maExtNames.back();
 777     r.mnFileId = nFileId;
 778     r.maName = rName;
 779
 780     ++nElementAkt;
 781
 782     return static_cast<const TokenId>(nElementAkt);
 783 }
 784
 785 const TokenId TokenPool::StoreExtRef( sal_uInt16 nFileId, const String& rTabName, const ScSingleRefData& rRef )
 786 {
 787     if ( nElementAkt >= nElement )
 788         GrowElement();
 789
 790     pElement[nElementAkt] = static_cast<UINT16>(maExtCellRefs.size());
 791     pType[nElementAkt] = T_ExtRefC;
 792
 793     maExtCellRefs.push_back(ExtCellRef());
 794     ExtCellRef& r = maExtCellRefs.back();
 795     r.mnFileId = nFileId;
 796     r.maTabName = rTabName;
 797     r.maRef = rRef;
 798
 799     ++nElementAkt;
 800
 801     return static_cast<const TokenId>(nElementAkt);
 802 }
 803
 804 const TokenId TokenPool::StoreExtRef( sal_uInt16 nFileId, const String& rTabName, const ScComplexRefData& rRef )
 805 {
 806     if ( nElementAkt >= nElement )
 807         GrowElement();
 808
 809     pElement[nElementAkt] = static_cast<UINT16>(maExtAreaRefs.size());
 810     pType[nElementAkt] = T_ExtRefA;
 811
 812     maExtAreaRefs.push_back(ExtAreaRef());
 813     ExtAreaRef& r = maExtAreaRefs.back();
 814     r.mnFileId = nFileId;
 815     r.maTabName = rTabName;
 816     r.maRef = rRef;
 817
 818     ++nElementAkt;
 819
 820     return static_cast<const TokenId>(nElementAkt);
 821 }
 822
 823 void TokenPool::Reset( void )
 824 {
 825     nP_IdAkt = nP_IdLast = nElementAkt = nP_StrAkt = nP_DblAkt = nP_ErrAkt = nP_RefTrAkt = nP_ExtAkt = nP_NlfAkt = nP_MatrixAkt = 0;
 826     maExtNames.clear();
 827     maExtCellRefs.clear();
 828     maExtAreaRefs.clear();
 829 }
 830
 831
 832 BOOL TokenPool::IsSingleOp( const TokenId& rId, const DefTokenId eId ) const
 833 {
 834     UINT16 nId = (UINT16) rId;
 835     if( nId && nId <= nElementAkt )
 836     {// existent?
 837         nId--;
 838         if( T_Id == pType[ nId ] )
 839         {// Tokenfolge?
 840             if( pSize[ nId ] == 1 )
 841             {// GENAU 1 Token
 842                 UINT16  nSecId = pP_Id[ pElement[ nId ] ];
 843                 if( nSecId >= nScTokenOff )
 844                 {// Default-Token?
 845                     return ( DefTokenId ) ( nSecId - nScTokenOff ) == eId;      // Gesuchter?
 846                 }
 847             }
 848         }
 849     }
 850
 851     return FALSE;
 852 }
 853
 854
 855 const String* TokenPool::GetExternal( const TokenId& rId ) const
 856 {
 857     const String*   p = NULL;
 858     UINT16 n = (UINT16) rId;
 859     if( n && n <= nElementAkt )
 860     {
 861         n--;
 862         if( (pType[ n ] == T_Ext) && ppP_Ext[ pElement[ n ] ] )
 863             p = &ppP_Ext[ pElement[ n ] ]->aText;
 864     }
 865
 866     return p;
 867 }
 868
 869
 870 //UNUSED2008-05  const String* TokenPool::GetString( const TokenId& r ) const
 871 //UNUSED2008-05  {
 872 //UNUSED2008-05      const String*   p = NULL;
 873 //UNUSED2008-05      UINT16 n = (UINT16) r;
 874 //UNUSED2008-05      if( n && n <= nElementAkt )
 875 //UNUSED2008-05      {
 876 //UNUSED2008-05          n--;
 877 //UNUSED2008-05          if( pType[ n ] == T_Str )
 878 //UNUSED2008-05              p = ppP_Str[ pElement[ n ] ];
 879 //UNUSED2008-05      }
 880 //UNUSED2008-05
 881 //UNUSED2008-05      return p;
 882 //UNUSED2008-05  }
 883
 884 ScMatrix* TokenPool::GetMatrix( unsigned int n ) const
 885 {
 886     if( n < nP_MatrixAkt )
 887         return ppP_Matrix[ n ];
 888     else
 889         printf ("GETMATRIX %d >= %d\n", n, nP_MatrixAkt);
 890     return NULL;
 891 }
 892