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