basic/source/sbx/sbxarray.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 #include <tools/stream.hxx>
  21 #include <basic/sbx.hxx>
  22 #include "runtime.hxx"
  23 #include <vector>
  24 using namespace std;
  25
  26 struct SbxDim {                 // an array-dimension:
  27     SbxDim* pNext;              // Link
  28     sal_Int32 nLbound, nUbound; // Limitations
  29     sal_Int32 nSize;            // Number of elements
  30 };
  31
  32 class SbxVarEntry : public SbxVariableRef {
  33 public:
  34     OUString* pAlias;
  35     SbxVarEntry() : SbxVariableRef(), pAlias( NULL ) {}
  36    ~SbxVarEntry() { delete pAlias; }
  37 };
  38
  39 typedef SbxVarEntry* SbxVarEntryPtr;
  40 typedef vector< SbxVarEntryPtr > SbxVarEntryPtrVector;
  41 class SbxVarRefs : public SbxVarEntryPtrVector
  42 {
  43 public:
  44     SbxVarRefs( void ) {}
  45 };
  46
  47
  48 TYPEINIT1(SbxArray,SbxBase)
  49 TYPEINIT1(SbxDimArray,SbxArray)
  50
  51 //  SbxArray
  52
  53 SbxArray::SbxArray( SbxDataType t ) : SbxBase()
  54 {
  55     pData = new SbxVarRefs;
  56     eType = t;
  57     if( t != SbxVARIANT )
  58         SetFlag( SBX_FIXED );
  59 }
  60
  61 SbxArray::SbxArray( const SbxArray& rArray ) :
  62     SvRefBase( rArray ), SbxBase()
  63 {
  64     pData = new SbxVarRefs;
  65     if( rArray.eType != SbxVARIANT )
  66         SetFlag( SBX_FIXED );
  67     *this = rArray;
  68 }
  69
  70 SbxArray& SbxArray::operator=( const SbxArray& rArray )
  71 {
  72     if( &rArray != this )
  73     {
  74         eType = rArray.eType;
  75         Clear();
  76         SbxVarRefs* pSrc = rArray.pData;
  77         for( sal_uInt32 i = 0; i < pSrc->size(); i++ )
  78         {
  79             SbxVarEntryPtr pSrcRef = (*pSrc)[i];
  80             const SbxVariable* pSrc_ = *pSrcRef;
  81             if( !pSrc_ )
  82                 continue;
  83             SbxVarEntryPtr pDstRef = new SbxVarEntry;
  84             *((SbxVariableRef*) pDstRef) = *((SbxVariableRef*) pSrcRef);
  85             if( pSrcRef->pAlias )
  86             {
  87                 pDstRef->pAlias = new OUString( *pSrcRef->pAlias );
  88             }
  89             if( eType != SbxVARIANT )
  90             {
  91                 // Convert no objects
  92                 if( eType != SbxOBJECT || pSrc_->GetClass() != SbxCLASS_OBJECT )
  93                 {
  94                     ((SbxVariable*) pSrc_)->Convert( eType );
  95                 }
  96             }
  97             pData->push_back( pDstRef );
  98         }
  99     }
 100     return *this;
 101 }
 102
 103 SbxArray::~SbxArray()
 104 {
 105     Clear();
 106     delete pData;
 107 }
 108
 109 SbxDataType SbxArray::GetType() const
 110 {
 111     return (SbxDataType) ( eType | SbxARRAY );
 112 }
 113
 114 SbxClassType SbxArray::GetClass() const
 115 {
 116     return SbxCLASS_ARRAY;
 117 }
 118
 119 void SbxArray::Clear()
 120 {
 121     sal_uInt32 nSize = pData->size();
 122     for( sal_uInt32 i = 0 ; i < nSize ; i++ )
 123     {
 124         SbxVarEntry* pEntry = (*pData)[i];
 125         delete pEntry;
 126     }
 127     pData->clear();
 128 }
 129
 130 sal_uInt32 SbxArray::Count32() const
 131 {
 132     return pData->size();
 133 }
 134
 135 sal_uInt16 SbxArray::Count() const
 136 {
 137     sal_uInt32 nCount = pData->size();
 138     DBG_ASSERT( nCount <= SBX_MAXINDEX, "SBX: Array-Index > SBX_MAXINDEX" );
 139     return (sal_uInt16)nCount;
 140 }
 141
 142 SbxVariableRef& SbxArray::GetRef32( sal_uInt32 nIdx )
 143 {
 144     // If necessary extend the array
 145     DBG_ASSERT( nIdx <= SBX_MAXINDEX32, "SBX: Array-Index > SBX_MAXINDEX32" );
 146     // Very Hot Fix
 147     if( nIdx > SBX_MAXINDEX32 )
 148     {
 149         SetError( SbxERR_BOUNDS );
 150         nIdx = 0;
 151     }
 152     while( pData->size() <= nIdx )
 153     {
 154         const SbxVarEntryPtr p = new SbxVarEntry;
 155         pData->push_back( p );
 156     }
 157     return *((*pData)[nIdx]);
 158 }
 159
 160 SbxVariableRef& SbxArray::GetRef( sal_uInt16 nIdx )
 161 {
 162     // If necessary extend the array
 163     DBG_ASSERT( nIdx <= SBX_MAXINDEX, "SBX: Array-Index > SBX_MAXINDEX" );
 164     // Very Hot Fix
 165     if( nIdx > SBX_MAXINDEX )
 166     {
 167         SetError( SbxERR_BOUNDS );
 168         nIdx = 0;
 169     }
 170     while( pData->size() <= nIdx )
 171     {
 172         const SbxVarEntryPtr p = new SbxVarEntry;
 173         pData->push_back( p );
 174     }
 175     return *((*pData)[nIdx]);
 176 }
 177
 178 SbxVariable* SbxArray::Get32( sal_uInt32 nIdx )
 179 {
 180     if( !CanRead() )
 181     {
 182         SetError( SbxERR_PROP_WRITEONLY );
 183         return NULL;
 184     }
 185     SbxVariableRef& rRef = GetRef32( nIdx );
 186
 187     if ( !rRef.Is() )
 188         rRef = new SbxVariable( eType );
 189 #ifdef DBG_UTIL
 190     else
 191         DBG_CHKOBJ( rRef, SbxBase, 0 );
 192 #endif
 193
 194     return rRef;
 195 }
 196
 197 SbxVariable* SbxArray::Get( sal_uInt16 nIdx )
 198 {
 199     if( !CanRead() )
 200     {
 201         SetError( SbxERR_PROP_WRITEONLY );
 202         return NULL;
 203     }
 204     SbxVariableRef& rRef = GetRef( nIdx );
 205
 206     if ( !rRef.Is() )
 207         rRef = new SbxVariable( eType );
 208 #ifdef DBG_UTIL
 209     else
 210         DBG_CHKOBJ( rRef, SbxBase, 0 );
 211 #endif
 212
 213     return rRef;
 214 }
 215
 216 void SbxArray::Put32( SbxVariable* pVar, sal_uInt32 nIdx )
 217 {
 218     if( !CanWrite() )
 219         SetError( SbxERR_PROP_READONLY );
 220     else
 221     {
 222         if( pVar )
 223             if( eType != SbxVARIANT )
 224                 // Convert no objects
 225                 if( eType != SbxOBJECT || pVar->GetClass() != SbxCLASS_OBJECT )
 226                     pVar->Convert( eType );
 227         SbxVariableRef& rRef = GetRef32( nIdx );
 228         if( (SbxVariable*) rRef != pVar )
 229         {
 230             rRef = pVar;
 231             SetFlag( SBX_MODIFIED );
 232         }
 233     }
 234 }
 235
 236 void SbxArray::Put( SbxVariable* pVar, sal_uInt16 nIdx )
 237 {
 238     if( !CanWrite() )
 239         SetError( SbxERR_PROP_READONLY );
 240     else
 241     {
 242         if( pVar )
 243             if( eType != SbxVARIANT )
 244                 // Convert no objects
 245                 if( eType != SbxOBJECT || pVar->GetClass() != SbxCLASS_OBJECT )
 246                     pVar->Convert( eType );
 247         SbxVariableRef& rRef = GetRef( nIdx );
 248         if( (SbxVariable*) rRef != pVar )
 249         {
 250             rRef = pVar;
 251             SetFlag( SBX_MODIFIED );
 252         }
 253     }
 254 }
 255
 256 const OUString& SbxArray::GetAlias( sal_uInt16 nIdx )
 257 {
 258 static const OUString sEmpty("");
 259
 260     if( !CanRead() )
 261     {
 262         SetError( SbxERR_PROP_WRITEONLY );
 263         return sEmpty;
 264     }
 265     SbxVarEntry& rRef = (SbxVarEntry&) GetRef( nIdx );
 266
 267     if ( !rRef.pAlias )
 268     {
 269         return sEmpty;
 270     }
 271 #ifdef DBG_UTIL
 272     else
 273     {
 274         DBG_CHKOBJ( rRef, SbxBase, 0 );
 275     }
 276 #endif
 277
 278     return *rRef.pAlias;
 279 }
 280
 281 void SbxArray::PutAlias( const OUString& rAlias, sal_uInt16 nIdx )
 282 {
 283     if( !CanWrite() )
 284     {
 285         SetError( SbxERR_PROP_READONLY );
 286     }
 287     else
 288     {
 289         SbxVarEntry& rRef = (SbxVarEntry&) GetRef( nIdx );
 290         if( !rRef.pAlias )
 291         {
 292             rRef.pAlias = new OUString( rAlias );
 293         }
 294         else
 295         {
 296             *rRef.pAlias = rAlias;
 297         }
 298     }
 299 }
 300
 301 void SbxArray::Insert32( SbxVariable* pVar, sal_uInt32 nIdx )
 302 {
 303     DBG_ASSERT( pData->size() <= SBX_MAXINDEX32, "SBX: Array gets too big" );
 304     if( pData->size() > SBX_MAXINDEX32 )
 305     {
 306             return;
 307     }
 308     SbxVarEntryPtr p = new SbxVarEntry;
 309     *((SbxVariableRef*) p) = pVar;
 310     SbxVarEntryPtrVector::size_type nSize = pData->size();
 311     if( nIdx > nSize )
 312     {
 313         nIdx = nSize;
 314     }
 315     if( eType != SbxVARIANT && pVar )
 316     {
 317         (*p)->Convert( eType );
 318     }
 319     if( nIdx == nSize )
 320     {
 321         pData->push_back( p );
 322     }
 323     else
 324     {
 325         pData->insert( pData->begin() + nIdx, p );
 326     }
 327     SetFlag( SBX_MODIFIED );
 328 }
 329
 330 void SbxArray::Insert( SbxVariable* pVar, sal_uInt16 nIdx )
 331 {
 332     DBG_ASSERT( pData->size() <= 0x3FF0, "SBX: Array gets too big" );
 333     if( pData->size() > 0x3FF0 )
 334     {
 335         return;
 336     }
 337     Insert32( pVar, nIdx );
 338 }
 339
 340 void SbxArray::Remove32( sal_uInt32 nIdx )
 341 {
 342     if( nIdx < pData->size() )
 343     {
 344         SbxVariableRef* pRef = (*pData)[nIdx];
 345         pData->erase( pData->begin() + nIdx );
 346         delete pRef;
 347         SetFlag( SBX_MODIFIED );
 348     }
 349 }
 350
 351 void SbxArray::Remove( sal_uInt16 nIdx )
 352 {
 353     if( nIdx < pData->size() )
 354     {
 355         SbxVariableRef* pRef = (*pData)[nIdx];
 356         pData->erase( pData->begin() + nIdx );
 357         delete pRef;
 358         SetFlag( SBX_MODIFIED );
 359     }
 360 }
 361
 362 void SbxArray::Remove( SbxVariable* pVar )
 363 {
 364     if( pVar )
 365     {
 366         for( sal_uInt32 i = 0; i < pData->size(); i++ )
 367         {
 368             SbxVariableRef* pRef = (*pData)[i];
 369             if( *pRef == pVar )
 370             {
 371                 Remove32( i ); break;
 372             }
 373         }
 374     }
 375 }
 376
 377 // Taking over of the data from the passed array, at which
 378 // the variable of the same name will be overwritten.
 379
 380 void SbxArray::Merge( SbxArray* p )
 381 {
 382     if( p )
 383     {
 384         sal_uInt32 nSize = p->Count();
 385         for( sal_uInt32 i = 0; i < nSize; i++ )
 386         {
 387             SbxVarEntryPtr pRef1 = (*(p->pData))[i];
 388             // Is the element by name already inside?
 389             // Then overwrite!
 390             SbxVariable* pVar = *pRef1;
 391             if( pVar )
 392             {
 393                 OUString aName = pVar->GetName();
 394                 sal_uInt16 nHash = pVar->GetHashCode();
 395                 for( sal_uInt32 j = 0; j < pData->size(); j++ )
 396                 {
 397                     SbxVariableRef* pRef2 = (*pData)[j];
 398                     if( (*pRef2)->GetHashCode() == nHash
 399                         && (*pRef2)->GetName().equalsIgnoreAsciiCase( aName ) )
 400                     {
 401                         *pRef2 = pVar; pRef1 = NULL;
 402                         break;
 403                     }
 404                 }
 405                 if( pRef1 )
 406                 {
 407                     SbxVarEntryPtr pRef = new SbxVarEntry;
 408                     const SbxVarEntryPtr pTemp = pRef;
 409                     pData->push_back( pTemp );
 410                     *((SbxVariableRef*) pRef) = *((SbxVariableRef*) pRef1);
 411                     if( pRef1->pAlias )
 412                     {
 413                         pRef->pAlias = new OUString( *pRef1->pAlias );
 414                     }
 415                 }
 416             }
 417         }
 418     }
 419 }
 420
 421 // Search of an element via the user data. If the element is
 422 // object, it will also be scanned.
 423
 424 SbxVariable* SbxArray::FindUserData( sal_uInt32 nData )
 425 {
 426     SbxVariable* p = NULL;
 427     for( sal_uInt32 i = 0; i < pData->size(); i++ )
 428     {
 429         SbxVariableRef* pRef = (*pData)[i];
 430         SbxVariable* pVar = *pRef;
 431         if( pVar )
 432         {
 433             if( pVar->IsVisible() && pVar->GetUserData() == nData )
 434             {
 435                 p = pVar;
 436                 p->ResetFlag( SBX_EXTFOUND );
 437                 break;  // JSM 1995-10-06
 438             }
 439             // Did we have an array/object with extended search?
 440             else if( pVar->IsSet( SBX_EXTSEARCH ) )
 441             {
 442                 switch( pVar->GetClass() )
 443                 {
 444                     case SbxCLASS_OBJECT:
 445                     {
 446                         // Objects are not allowed to scan their parent.
 447                         sal_uInt16 nOld = pVar->GetFlags();
 448                         pVar->ResetFlag( SBX_GBLSEARCH );
 449                         p = ((SbxObject*) pVar)->FindUserData( nData );
 450                         pVar->SetFlags( nOld );
 451                         break;
 452                     }
 453                     case SbxCLASS_ARRAY:
 454                         p = ((SbxArray*) pVar)->FindUserData( nData );
 455                         break;
 456                     default: break;
 457                 }
 458                 if( p )
 459                 {
 460                     p->SetFlag( SBX_EXTFOUND );
 461                     break;
 462                 }
 463             }
 464         }
 465     }
 466     return p;
 467 }
 468
 469 // Search of an element by his name and type. If an element is an object,
 470 // it will also be scanned..
 471
 472 SbxVariable* SbxArray::Find( const OUString& rName, SbxClassType t )
 473 {
 474     SbxVariable* p = NULL;
 475     sal_uInt32 nCount = pData->size();
 476     if( !nCount )
 477         return NULL;
 478     sal_Bool bExtSearch = IsSet( SBX_EXTSEARCH );
 479     sal_uInt16 nHash = SbxVariable::MakeHashCode( rName );
 480     for( sal_uInt32 i = 0; i < nCount; i++ )
 481     {
 482         SbxVariableRef* pRef = (*pData)[i];
 483         SbxVariable* pVar = *pRef;
 484         if( pVar && pVar->IsVisible() )
 485         {
 486             // The very secure search works as well, if there is no hashcode!
 487             sal_uInt16 nVarHash = pVar->GetHashCode();
 488             if( ( !nVarHash || nVarHash == nHash )
 489                 && ( t == SbxCLASS_DONTCARE || pVar->GetClass() == t )
 490                 && ( pVar->GetName().equalsIgnoreAsciiCase( rName ) ) )
 491             {
 492                 p = pVar;
 493                 p->ResetFlag( SBX_EXTFOUND );
 494                 break;
 495             }
 496             // Did we have an array/object with extended search?
 497             else if( bExtSearch && pVar->IsSet( SBX_EXTSEARCH ) )
 498             {
 499                 switch( pVar->GetClass() )
 500                 {
 501                     case SbxCLASS_OBJECT:
 502                     {
 503                         // Objects are not allowed to scan their parent.
 504                         sal_uInt16 nOld = pVar->GetFlags();
 505                         pVar->ResetFlag( SBX_GBLSEARCH );
 506                         p = ((SbxObject*) pVar)->Find( rName, t );
 507                         pVar->SetFlags( nOld );
 508                         break;
 509                     }
 510                     case SbxCLASS_ARRAY:
 511                         p = ((SbxArray*) pVar)->Find( rName, t );
 512                         break;
 513                     default: break;
 514                 }
 515                 if( p )
 516                 {
 517                     p->SetFlag( SBX_EXTFOUND );
 518                     break;
 519                 }
 520             }
 521         }
 522     }
 523     return p;
 524 }
 525
 526 sal_Bool SbxArray::LoadData( SvStream& rStrm, sal_uInt16 nVer )
 527 {
 528     sal_uInt16 nElem;
 529     Clear();
 530     sal_Bool bRes = sal_True;
 531     sal_uInt16 f = nFlags;
 532     nFlags |= SBX_WRITE;
 533     rStrm >> nElem;
 534     nElem &= 0x7FFF;
 535     for( sal_uInt32 n = 0; n < nElem; n++ )
 536     {
 537         sal_uInt16 nIdx;
 538         rStrm >> nIdx;
 539         SbxVariable* pVar = (SbxVariable*) Load( rStrm );
 540         if( pVar )
 541         {
 542             SbxVariableRef& rRef = GetRef( nIdx );
 543             rRef = pVar;
 544         }
 545         else
 546         {
 547             bRes = sal_False; break;
 548         }
 549     }
 550     if( bRes )
 551         bRes = LoadPrivateData( rStrm, nVer );
 552     nFlags = f;
 553     return bRes;
 554 }
 555
 556 sal_Bool SbxArray::StoreData( SvStream& rStrm ) const
 557 {
 558     sal_uInt32 nElem = 0;
 559     sal_uInt32 n;
 560     // Which elements are even defined?
 561     for( n = 0; n < pData->size(); n++ )
 562     {
 563         SbxVariableRef* pRef = (*pData)[n];
 564         SbxVariable* p = *pRef;
 565         if( p && !( p->GetFlags() & SBX_DONTSTORE ) )
 566             nElem++;
 567     }
 568     rStrm << (sal_uInt16) nElem;
 569     for( n = 0; n < pData->size(); n++ )
 570     {
 571         SbxVariableRef* pRef = (*pData)[n];
 572         SbxVariable* p = *pRef;
 573         if( p && !( p->GetFlags() & SBX_DONTSTORE ) )
 574         {
 575             rStrm << (sal_uInt16) n;
 576             if( !p->Store( rStrm ) )
 577                 return sal_False;
 578         }
 579     }
 580     return StorePrivateData( rStrm );
 581 }
 582
 583 // #100883 Method to set method directly to parameter array
 584 void SbxArray::PutDirect( SbxVariable* pVar, sal_uInt32 nIdx )
 585 {
 586     SbxVariableRef& rRef = GetRef32( nIdx );
 587     rRef = pVar;
 588 }
 589
 590
 591 //  SbxArray
 592
 593 SbxDimArray::SbxDimArray( SbxDataType t ) : SbxArray( t ), mbHasFixedSize( false )
 594 {
 595     pFirst = pLast = NULL;
 596     nDim = 0;
 597 }
 598
 599 SbxDimArray::SbxDimArray( const SbxDimArray& rArray )
 600     : SvRefBase( rArray ), SbxArray( rArray.eType )
 601 {
 602     pFirst = pLast = NULL;
 603     nDim = 0;
 604     *this = rArray;
 605 }
 606
 607 SbxDimArray& SbxDimArray::operator=( const SbxDimArray& rArray )
 608 {
 609     if( &rArray != this )
 610     {
 611         SbxArray::operator=( (const SbxArray&) rArray );
 612         SbxDim* p = rArray.pFirst;
 613         while( p )
 614         {
 615             AddDim32( p->nLbound, p->nUbound );
 616             p = p->pNext;
 617         }
 618         this->mbHasFixedSize = rArray.mbHasFixedSize;
 619     }
 620     return *this;
 621 }
 622
 623 SbxDimArray::~SbxDimArray()
 624 {
 625     Clear();
 626 }
 627
 628 void SbxDimArray::Clear()
 629 {
 630     SbxDim* p = pFirst;
 631     while( p )
 632     {
 633         SbxDim* q = p->pNext;
 634         delete p;
 635         p = q;
 636     }
 637     pFirst = pLast = NULL;
 638     nDim   = 0;
 639 }
 640
 641 // Add a dimension
 642
 643 void SbxDimArray::AddDimImpl32( sal_Int32 lb, sal_Int32 ub, sal_Bool bAllowSize0 )
 644 {
 645     SbxError eRes = SbxERR_OK;
 646     if( ub < lb && !bAllowSize0 )
 647     {
 648         eRes = SbxERR_BOUNDS;
 649         ub = lb;
 650     }
 651     SbxDim* p = new SbxDim;
 652     p->nLbound = lb;
 653     p->nUbound = ub;
 654     p->nSize   = ub - lb + 1;
 655     p->pNext   = NULL;
 656     if( !pFirst )
 657         pFirst = pLast = p;
 658     else
 659         pLast->pNext = p, pLast = p;
 660     nDim++;
 661     if( eRes )
 662         SetError( eRes );
 663 }
 664
 665 short SbxDimArray::GetDims() const
 666 {
 667     return nDim;
 668 }
 669
 670 void SbxDimArray::AddDim( short lb, short ub )
 671 {
 672     AddDimImpl32( lb, ub, sal_False );
 673 }
 674
 675 void SbxDimArray::unoAddDim( short lb, short ub )
 676 {
 677     AddDimImpl32( lb, ub, sal_True );
 678 }
 679
 680 void SbxDimArray::AddDim32( sal_Int32 lb, sal_Int32 ub )
 681 {
 682     AddDimImpl32( lb, ub, sal_False );
 683 }
 684
 685 void SbxDimArray::unoAddDim32( sal_Int32 lb, sal_Int32 ub )
 686 {
 687     AddDimImpl32( lb, ub, sal_True );
 688 }
 689
 690
 691 // Readout dimension data
 692
 693 sal_Bool SbxDimArray::GetDim32( sal_Int32 n, sal_Int32& rlb, sal_Int32& rub ) const
 694 {
 695     if( n < 1 || n > nDim )
 696     {
 697         SetError( SbxERR_BOUNDS ); rub = rlb = 0; return sal_False;
 698     }
 699     SbxDim* p = pFirst;
 700     while( --n )
 701         p = p->pNext;
 702     rub = p->nUbound;
 703     rlb = p->nLbound;
 704     return sal_True;
 705 }
 706
 707 sal_Bool SbxDimArray::GetDim( short n, short& rlb, short& rub ) const
 708 {
 709     sal_Int32 rlb32, rub32;
 710     sal_Bool bRet = GetDim32( n, rlb32, rub32 );
 711     if( bRet )
 712     {
 713         if( rlb32 < -SBX_MAXINDEX || rub32 > SBX_MAXINDEX )
 714         {
 715             SetError( SbxERR_BOUNDS );
 716             return sal_False;
 717         }
 718         rub = (short)rub32;
 719         rlb = (short)rlb32;
 720     }
 721     return bRet;
 722 }
 723
 724 // Element-Ptr with the help of an index list
 725
 726 sal_uInt32 SbxDimArray::Offset32( const sal_Int32* pIdx )
 727 {
 728     sal_uInt32 nPos = 0;
 729     for( SbxDim* p = pFirst; p; p = p->pNext )
 730     {
 731         sal_Int32 nIdx = *pIdx++;
 732         if( nIdx < p->nLbound || nIdx > p->nUbound )
 733         {
 734             nPos = (sal_uInt32)SBX_MAXINDEX32 + 1; break;
 735         }
 736         nPos = nPos * p->nSize + nIdx - p->nLbound;
 737     }
 738     if( nDim == 0 || nPos > SBX_MAXINDEX32 )
 739     {
 740         SetError( SbxERR_BOUNDS ); nPos = 0;
 741     }
 742     return nPos;
 743 }
 744
 745 sal_uInt16 SbxDimArray::Offset( const short* pIdx )
 746 {
 747     long nPos = 0;
 748     for( SbxDim* p = pFirst; p; p = p->pNext )
 749     {
 750         short nIdx = *pIdx++;
 751         if( nIdx < p->nLbound || nIdx > p->nUbound )
 752         {
 753             nPos = SBX_MAXINDEX + 1; break;
 754         }
 755         nPos = nPos * p->nSize + nIdx - p->nLbound;
 756     }
 757     if( nDim == 0 || nPos > SBX_MAXINDEX )
 758     {
 759         SetError( SbxERR_BOUNDS ); nPos = 0;
 760     }
 761     return (sal_uInt16) nPos;
 762 }
 763
 764 SbxVariable* SbxDimArray::Get( const short* pIdx )
 765 {
 766     return SbxArray::Get( Offset( pIdx ) );
 767 }
 768
 769 void SbxDimArray::Put( SbxVariable* p, const short* pIdx  )
 770 {
 771     SbxArray::Put( p, Offset( pIdx ) );
 772 }
 773
 774 SbxVariable* SbxDimArray::Get32( const sal_Int32* pIdx )
 775 {
 776     return SbxArray::Get32( Offset32( pIdx ) );
 777 }
 778
 779 void SbxDimArray::Put32( SbxVariable* p, const sal_Int32* pIdx  )
 780 {
 781     SbxArray::Put32( p, Offset32( pIdx ) );
 782 }
 783
 784
 785 // Element-Number with the help of Parameter-Array
 786
 787 sal_uInt32 SbxDimArray::Offset32( SbxArray* pPar )
 788 {
 789 #ifndef DISABLE_SCRIPTING
 790     if( nDim == 0 || !pPar || ( ( nDim != ( pPar->Count() - 1 ) ) && SbiRuntime::isVBAEnabled() ) )
 791     {
 792         SetError( SbxERR_BOUNDS ); return 0;
 793     }
 794 #endif
 795     sal_uInt32 nPos = 0;
 796     sal_uInt16 nOff = 1;    // Non element 0!
 797     for( SbxDim* p = pFirst; p && !IsError(); p = p->pNext )
 798     {
 799         sal_Int32 nIdx = pPar->Get( nOff++ )->GetLong();
 800         if( nIdx < p->nLbound || nIdx > p->nUbound )
 801         {
 802             nPos = (sal_uInt32) SBX_MAXINDEX32+1; break;
 803         }
 804         nPos = nPos * p->nSize + nIdx - p->nLbound;
 805     }
 806     if( nPos > (sal_uInt32) SBX_MAXINDEX32 )
 807     {
 808         SetError( SbxERR_BOUNDS ); nPos = 0;
 809     }
 810     return nPos;
 811 }
 812
 813 SbxVariable* SbxDimArray::Get( SbxArray* pPar )
 814 {
 815     return SbxArray::Get32( Offset32( pPar ) );
 816 }
 817
 818 sal_Bool SbxDimArray::LoadData( SvStream& rStrm, sal_uInt16 nVer )
 819 {
 820     short nDimension;
 821     rStrm >> nDimension;
 822     for( short i = 0; i < nDimension && rStrm.GetError() == SVSTREAM_OK; i++ )
 823     {
 824         sal_Int16 lb, ub;
 825         rStrm >> lb >> ub;
 826         AddDim( lb, ub );
 827     }
 828     return SbxArray::LoadData( rStrm, nVer );
 829 }
 830
 831 sal_Bool SbxDimArray::StoreData( SvStream& rStrm ) const
 832 {
 833     rStrm << (sal_Int16) nDim;
 834     for( short i = 0; i < nDim; i++ )
 835     {
 836         short lb, ub;
 837         GetDim( i, lb, ub );
 838         rStrm << (sal_Int16) lb << (sal_Int16) ub;
 839     }
 840     return SbxArray::StoreData( rStrm );
 841 }
 842
 843 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */