basic/source/sbx/sbxvar.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/stream.hxx>
  23 #include <svl/SfxBroadcaster.hxx>
  24
  25 #include <basic/sbx.hxx>
  26 #include <runtime.hxx>
  27 #include "sbxres.hxx"
  28 #include "sbxconv.hxx"
  29 #include <sbunoobj.hxx>
  30 #include <rtl/character.hxx>
  31 #include <sal/log.hxx>
  32
  33 #include <com/sun/star/uno/XInterface.hpp>
  34 using namespace com::sun::star::uno;
  35
  36 // SbxVariable
  37
  38
  39 // SbxVariableImpl
  40
  41 class SbxVariableImpl
  42 {
  43     friend class SbxVariable;
  44     OUString                    m_aDeclareClassName;
  45     Reference< XInterface >     m_xComListener;
  46     StarBASIC*                  m_pComListenerParentBasic;
  47
  48     SbxVariableImpl()
  49         : m_pComListenerParentBasic( nullptr )
  50     {}
  51 };
  52
  53
  54 // Constructors
  55
  56 SbxVariable::SbxVariable() : SbxValue()
  57 {
  58     pParent = nullptr;
  59     nUserData = 0;
  60     nHash = 0;
  61 }
  62
  63 SbxVariable::SbxVariable( const SbxVariable& r )
  64     : SvRefBase( r ),
  65       SbxValue( r ),
  66       mpPar( r.mpPar ),
  67       pInfo( r.pInfo )
  68 {
  69     if( r.mpImpl != nullptr )
  70     {
  71         mpImpl.reset( new SbxVariableImpl( *r.mpImpl ) );
  72 #if HAVE_FEATURE_SCRIPTING
  73         if( mpImpl->m_xComListener.is() )
  74         {
  75             registerComListenerVariableForBasic( this, mpImpl->m_pComListenerParentBasic );
  76         }
  77 #endif
  78     }
  79     if( r.CanRead() )
  80     {
  81         pParent = r.pParent;
  82         nUserData = r.nUserData;
  83         maName = r.maName;
  84         nHash = r.nHash;
  85     }
  86     else
  87     {
  88         pParent = nullptr;
  89         nUserData = 0;
  90         nHash = 0;
  91     }
  92 }
  93
  94 SbxEnsureParentVariable::SbxEnsureParentVariable(const SbxVariable& r)
  95     : SbxVariable(r)
  96     , xParent(const_cast<SbxVariable&>(r).GetParent())
  97 {
  98     assert(GetParent() == xParent.get());
  99 }
 100
 101 void SbxEnsureParentVariable::SetParent(SbxObject* p)
 102 {
 103     assert(GetParent() == xParent.get());
 104     SbxVariable::SetParent(p);
 105     xParent = SbxObjectRef(p);
 106     assert(GetParent() == xParent.get());
 107 }
 108
 109 SbxVariable::SbxVariable( SbxDataType t ) : SbxValue( t )
 110 {
 111     pParent = nullptr;
 112     nUserData = 0;
 113     nHash = 0;
 114 }
 115
 116 SbxVariable::~SbxVariable()
 117 {
 118 #if HAVE_FEATURE_SCRIPTING
 119     if( IsSet( SbxFlagBits::DimAsNew ))
 120     {
 121         removeDimAsNewRecoverItem( this );
 122     }
 123 #endif
 124     mpBroadcaster.reset();
 125 }
 126
 127 // Broadcasting
 128
 129 SfxBroadcaster& SbxVariable::GetBroadcaster()
 130 {
 131     if( !mpBroadcaster )
 132     {
 133         mpBroadcaster.reset( new SfxBroadcaster );
 134     }
 135     return *mpBroadcaster;
 136 }
 137
 138 SbxArray* SbxVariable::GetParameters() const
 139 {
 140     return mpPar.get();
 141 }
 142
 143
 144 // Perhaps some day one could cut the parameter 0.
 145 // Then the copying will be dropped...
 146
 147 void SbxVariable::Broadcast( SfxHintId nHintId )
 148 {
 149     if( mpBroadcaster && !IsSet( SbxFlagBits::NoBroadcast ) )
 150     {
 151         // Because the method could be called from outside, check the
 152         // rights here again
 153         if( nHintId == SfxHintId::BasicDataWanted )
 154         {
 155             if( !CanRead() )
 156             {
 157                 return;
 158             }
 159         }
 160         if( nHintId == SfxHintId::BasicDataChanged )
 161         {
 162             if( !CanWrite() )
 163             {
 164                 return;
 165             }
 166         }
 167
 168         //fdo#86843 Add a ref during the following block to guard against
 169         //getting deleted before completing this method
 170         SbxVariableRef aBroadcastGuard(this);
 171
 172         // Avoid further broadcasting
 173         std::unique_ptr<SfxBroadcaster> pSave = std::move(mpBroadcaster);
 174         SbxFlagBits nSaveFlags = GetFlags();
 175         SetFlag( SbxFlagBits::ReadWrite );
 176         if( mpPar.is() )
 177         {
 178             // Register this as element 0, but don't change over the parent!
 179             mpPar->GetRef( 0 ) = this;
 180         }
 181         pSave->Broadcast( SbxHint( nHintId, this ) );
 182         mpBroadcaster = std::move(pSave);
 183         SetFlags( nSaveFlags );
 184     }
 185 }
 186
 187 SbxInfo* SbxVariable::GetInfo()
 188 {
 189     if( !pInfo.is() )
 190     {
 191         Broadcast( SfxHintId::BasicInfoWanted );
 192         if( pInfo.is() )
 193         {
 194             SetModified( true );
 195         }
 196     }
 197     return pInfo.get();
 198 }
 199
 200 void SbxVariable::SetInfo( SbxInfo* p )
 201 {
 202     pInfo = p;
 203 }
 204
 205 void SbxVariable::SetParameters( SbxArray* p )
 206 {
 207     mpPar = p;
 208 }
 209
 210
 211 // Name of the variables
 212
 213 void SbxVariable::SetName( const OUString& rName )
 214 {
 215     maName = rName;
 216     nHash = MakeHashCode( rName );
 217 }
 218
 219 const OUString& SbxVariable::GetName( SbxNameType t ) const
 220 {
 221     static const OUString cSuffixes { "  %&!#@ $" };
 222     if( t == SbxNameType::NONE )
 223     {
 224         return maName;
 225     }
 226     // Request parameter-information (not for objects)
 227     const_cast<SbxVariable*>(this)->GetInfo();
 228     // Append nothing, if it is a simple property (no empty brackets)
 229     if (!pInfo.is() || (pInfo->m_Params.empty() && GetClass() == SbxClassType::Property))
 230     {
 231         return maName;
 232     }
 233     sal_Unicode cType = ' ';
 234     OUStringBuffer aTmp( maName );
 235     // short type? Then fetch it, possible this is 0.
 236     SbxDataType et = GetType();
 237     if( t == SbxNameType::ShortTypes )
 238     {
 239         if( et <= SbxSTRING )
 240         {
 241             cType = cSuffixes[ et ];
 242         }
 243         if( cType != ' ' )
 244         {
 245             aTmp.append(cType);
 246         }
 247     }
 248     aTmp.append("(");
 249
 250     for (SbxParams::const_iterator iter = pInfo->m_Params.begin(); iter != pInfo->m_Params.end(); ++iter)
 251     {
 252         auto const& i = *iter;
 253         int nt = i->eType & 0x0FFF;
 254         if (iter != pInfo->m_Params.begin())
 255         {
 256             aTmp.append(",");
 257         }
 258         if( i->nFlags & SbxFlagBits::Optional )
 259         {
 260             aTmp.append( GetSbxRes( StringId::Optional ) );
 261         }
 262         if( i->eType & SbxBYREF )
 263         {
 264             aTmp.append( GetSbxRes( StringId::ByRef ) );
 265         }
 266         aTmp.append( i->aName );
 267         cType = ' ';
 268         // short type? Then fetch it, possible this is 0.
 269         if( t == SbxNameType::ShortTypes )
 270         {
 271             if( nt <= SbxSTRING )
 272             {
 273                 cType = cSuffixes[ nt ];
 274             }
 275         }
 276         if( cType != ' ' )
 277         {
 278             aTmp.append(cType);
 279             if( i->eType & SbxARRAY )
 280             {
 281                 aTmp.append("()");
 282             }
 283         }
 284         else
 285         {
 286             if( i->eType & SbxARRAY )
 287             {
 288                 aTmp.append("()");
 289             }
 290             // long type?
 291             aTmp.append(GetSbxRes( StringId::As ));
 292             if( nt < 32 )
 293             {
 294                 aTmp.append(GetSbxRes( static_cast<StringId>( static_cast<int>( StringId::Types ) + nt ) ));
 295             }
 296             else
 297             {
 298                 aTmp.append(GetSbxRes( StringId::Any ));
 299             }
 300         }
 301     }
 302     aTmp.append(")");
 303     const_cast<SbxVariable*>(this)->aToolString = aTmp.makeStringAndClear();
 304     return aToolString;
 305 }
 306
 307 // Create a simple hashcode: the first six characters are evaluated.
 308
 309 sal_uInt16 SbxVariable::MakeHashCode( const OUString& rName )
 310 {
 311     sal_uInt16 n = 0;
 312     sal_Int32 nLen = rName.getLength();
 313     if( nLen > 6 )
 314     {
 315         nLen = 6;
 316     }
 317     for( sal_Int32 i=0; i<nLen; ++i )
 318     {
 319         sal_uInt8 c = static_cast<sal_uInt8>(rName[i]);
 320         // If we have a comment sign break!!
 321         if( c >= 0x80 )
 322         {
 323             return 0;
 324         }
 325         n = sal::static_int_cast< sal_uInt16 >( ( n << 3 ) + rtl::toAsciiUpperCase( c ) );
 326     }
 327     return n;
 328 }
 329
 330 // Operators
 331
 332 SbxVariable& SbxVariable::operator=( const SbxVariable& r )
 333 {
 334     if (this != &r)
 335     {
 336         SbxValue::operator=( r );
 337         mpImpl.reset();
 338         if( r.mpImpl != nullptr )
 339         {
 340             mpImpl.reset( new SbxVariableImpl( *r.mpImpl ) );
 341 #if HAVE_FEATURE_SCRIPTING
 342             if( mpImpl->m_xComListener.is() )
 343             {
 344                 registerComListenerVariableForBasic( this, mpImpl->m_pComListenerParentBasic );
 345             }
 346 #endif
 347         }
 348     }
 349     return *this;
 350 }
 351
 352 // Conversion
 353
 354 SbxDataType SbxVariable::GetType() const
 355 {
 356     if( aData.eType == SbxOBJECT )
 357     {
 358         return aData.pObj ? aData.pObj->GetType() : SbxOBJECT;
 359     }
 360     else if( aData.eType == SbxVARIANT )
 361     {
 362         return aData.pObj ? aData.pObj->GetType() : SbxVARIANT;
 363     }
 364     else
 365     {
 366         return aData.eType;
 367     }
 368 }
 369
 370 SbxClassType SbxVariable::GetClass() const
 371 {
 372     return SbxClassType::Variable;
 373 }
 374
 375 void SbxVariable::SetModified( bool b )
 376 {
 377     if( IsSet( SbxFlagBits::NoModify ) )
 378     {
 379         return;
 380     }
 381     SbxBase::SetModified( b );
 382     if( pParent && pParent != this ) //??? HotFix: Recursion out here MM
 383     {
 384         pParent->SetModified( b );
 385     }
 386 }
 387
 388 void SbxVariable::SetParent( SbxObject* p )
 389 {
 390 #ifdef DBG_UTIL
 391     // Will the parent of a SbxObject be set?
 392     if (p && dynamic_cast<SbxObject*>(this))
 393     {
 394         // then this had to be a child of the new parent
 395         bool bFound = false;
 396         SbxArray *pChildren = p->GetObjects();
 397         if ( pChildren )
 398         {
 399             for ( sal_uInt16 nIdx = 0; !bFound && nIdx < pChildren->Count(); ++nIdx )
 400             {
 401                 bFound = ( this == pChildren->Get(nIdx) );
 402             }
 403         }
 404         SAL_INFO_IF(
 405             !bFound, "basic.sbx",
 406             "dangling: [" << GetName() << "].SetParent([" << p->GetName()
 407                 << "])");
 408     }
 409 #endif
 410
 411     pParent = p;
 412 }
 413
 414 SbxVariableImpl* SbxVariable::getImpl()
 415 {
 416     if(!mpImpl)
 417     {
 418         mpImpl.reset(new SbxVariableImpl);
 419     }
 420     return mpImpl.get();
 421 }
 422
 423 const OUString& SbxVariable::GetDeclareClassName()
 424 {
 425     SbxVariableImpl* pImpl = getImpl();
 426     return pImpl->m_aDeclareClassName;
 427 }
 428
 429 void SbxVariable::SetDeclareClassName( const OUString& rDeclareClassName )
 430 {
 431     SbxVariableImpl* pImpl = getImpl();
 432     pImpl->m_aDeclareClassName = rDeclareClassName;
 433 }
 434
 435 void SbxVariable::SetComListener( const css::uno::Reference< css::uno::XInterface >& xComListener,
 436                                   StarBASIC* pParentBasic )
 437 {
 438     SbxVariableImpl* pImpl = getImpl();
 439     pImpl->m_xComListener = xComListener;
 440     pImpl->m_pComListenerParentBasic = pParentBasic;
 441 #if HAVE_FEATURE_SCRIPTING
 442     registerComListenerVariableForBasic( this, pParentBasic );
 443 #endif
 444 }
 445
 446 void SbxVariable::ClearComListener()
 447 {
 448     SbxVariableImpl* pImpl = getImpl();
 449     pImpl->m_xComListener.clear();
 450 }
 451
 452
 453 // Loading/Saving
 454
 455 bool SbxVariable::LoadData( SvStream& rStrm, sal_uInt16 nVer )
 456 {
 457     sal_uInt8 cMark;
 458     rStrm.ReadUChar( cMark );
 459     if( cMark == 0xFF )
 460     {
 461         if( !SbxValue::LoadData( rStrm, nVer ) )
 462         {
 463             return false;
 464         }
 465         maName = read_uInt16_lenPrefixed_uInt8s_ToOUString(rStrm,
 466                                                                 RTL_TEXTENCODING_ASCII_US);
 467         sal_uInt32 nTemp;
 468         rStrm.ReadUInt32( nTemp );
 469         nUserData = nTemp;
 470     }
 471     else
 472     {
 473         sal_uInt16 nType;
 474         rStrm.SeekRel( -1 );
 475         rStrm.ReadUInt16( nType );
 476         maName = read_uInt16_lenPrefixed_uInt8s_ToOUString(rStrm,
 477                                                                 RTL_TEXTENCODING_ASCII_US);
 478         sal_uInt32 nTemp;
 479         rStrm.ReadUInt32( nTemp );
 480         nUserData = nTemp;
 481         // correction: old methods have instead of SbxNULL now SbxEMPTY
 482         if( nType == SbxNULL && GetClass() == SbxClassType::Method )
 483         {
 484             nType = SbxEMPTY;
 485         }
 486         SbxValues aTmp;
 487         OUString aTmpString;
 488         OUString aVal;
 489         aTmp.eType = aData.eType = static_cast<SbxDataType>(nType);
 490         aTmp.pOUString = &aVal;
 491         switch( nType )
 492         {
 493         case SbxBOOL:
 494         case SbxERROR:
 495         case SbxINTEGER:
 496             rStrm.ReadInt16( aTmp.nInteger ); break;
 497         case SbxLONG:
 498             rStrm.ReadInt32( aTmp.nLong ); break;
 499         case SbxSINGLE:
 500         {
 501             // Floats as ASCII
 502             aTmpString = read_uInt16_lenPrefixed_uInt8s_ToOUString(
 503                     rStrm, RTL_TEXTENCODING_ASCII_US);
 504             double d;
 505             SbxDataType t;
 506             if( ImpScan( aTmpString, d, t, nullptr, false ) != ERRCODE_NONE || t == SbxDOUBLE )
 507             {
 508                 aTmp.nSingle = 0;
 509                 return false;
 510             }
 511             aTmp.nSingle = static_cast<float>(d);
 512             break;
 513         }
 514         case SbxDATE:
 515         case SbxDOUBLE:
 516         {
 517             // Floats as ASCII
 518             aTmpString = read_uInt16_lenPrefixed_uInt8s_ToOUString(rStrm,
 519                                                                         RTL_TEXTENCODING_ASCII_US);
 520             SbxDataType t;
 521             if( ImpScan( aTmpString, aTmp.nDouble, t, nullptr, false ) != ERRCODE_NONE )
 522             {
 523                 aTmp.nDouble = 0;
 524                 return false;
 525             }
 526             break;
 527         }
 528         case SbxSTRING:
 529             aVal = read_uInt16_lenPrefixed_uInt8s_ToOUString(rStrm,
 530                                                                   RTL_TEXTENCODING_ASCII_US);
 531             break;
 532         case SbxEMPTY:
 533         case SbxNULL:
 534             break;
 535         default:
 536             aData.eType = SbxNULL;
 537             SAL_WARN( "basic.sbx", "Loaded a non-supported data type" );
 538             return false;
 539         }
 540         // putt value
 541         if( nType != SbxNULL && nType != SbxEMPTY && !Put( aTmp ) )
 542         {
 543             return false;
 544         }
 545     }
 546     rStrm.ReadUChar( cMark );
 547     // cMark is also a version number!
 548     // 1: initial version
 549     // 2: with nUserData
 550     if( cMark )
 551     {
 552         if( cMark > 2 )
 553         {
 554             return false;
 555         }
 556         pInfo = new SbxInfo;
 557         pInfo->LoadData( rStrm, static_cast<sal_uInt16>(cMark) );
 558     }
 559     Broadcast( SfxHintId::BasicDataChanged );
 560     nHash =  MakeHashCode( maName );
 561     SetModified( true );
 562     return true;
 563 }
 564
 565 bool SbxVariable::StoreData( SvStream& rStrm ) const
 566 {
 567     rStrm.WriteUChar( 0xFF );      // Marker
 568     bool bValStore;
 569     if( dynamic_cast<const SbxMethod *>(this) != nullptr )
 570     {
 571         // #50200 Avoid that objects , which during the runtime
 572         // as return-value are saved in the method as a value were saved
 573         SbxVariable* pThis = const_cast<SbxVariable*>(this);
 574         SbxFlagBits nSaveFlags = GetFlags();
 575         pThis->SetFlag( SbxFlagBits::Write );
 576         pThis->SbxValue::Clear();
 577         pThis->SetFlags( nSaveFlags );
 578
 579         // So that the method will not be executed in any case!
 580         // CAST, to avoid const!
 581         pThis->SetFlag( SbxFlagBits::NoBroadcast );
 582         bValStore = SbxValue::StoreData( rStrm );
 583         pThis->ResetFlag( SbxFlagBits::NoBroadcast );
 584     }
 585     else
 586     {
 587         bValStore = SbxValue::StoreData( rStrm );
 588     }
 589     if( !bValStore )
 590     {
 591         return false;
 592     }
 593     write_uInt16_lenPrefixed_uInt8s_FromOUString(rStrm, maName,
 594                                                       RTL_TEXTENCODING_ASCII_US);
 595     rStrm.WriteUInt32( nUserData );
 596     if( pInfo.is() )
 597     {
 598         rStrm.WriteUChar( 2 );     // Version 2: with UserData!
 599         pInfo->StoreData( rStrm );
 600     }
 601     else
 602     {
 603         rStrm.WriteUChar( 0 );
 604     }
 605     return true;
 606 }
 607
 608 // SbxInfo
 609
 610 SbxInfo::SbxInfo()
 611         : aHelpFile(), nHelpId(0)
 612 {}
 613
 614 SbxInfo::SbxInfo( const OUString& r, sal_uInt32 n )
 615        : aHelpFile( r ), nHelpId( n )
 616 {}
 617
 618 void SbxVariable::Dump( SvStream& rStrm, bool bFill )
 619 {
 620     OString aBNameStr(OUStringToOString(GetName( SbxNameType::ShortTypes ), RTL_TEXTENCODING_ASCII_US));
 621     rStrm.WriteCharPtr( "Variable( " )
 622          .WriteOString( OString::number(reinterpret_cast<sal_Int64>(this)) ).WriteCharPtr( "==" )
 623          .WriteOString( aBNameStr );
 624     OString aBParentNameStr(OUStringToOString(GetParent()->GetName(), RTL_TEXTENCODING_ASCII_US));
 625     if ( GetParent() )
 626     {
 627         rStrm.WriteCharPtr( " in parent '" ).WriteOString( aBParentNameStr ).WriteCharPtr( "'" );
 628     }
 629     else
 630     {
 631         rStrm.WriteCharPtr( " no parent" );
 632     }
 633     rStrm.WriteCharPtr( " ) " );
 634
 635     // output also the object at object-vars
 636     if ( GetValues_Impl().eType == SbxOBJECT &&
 637             GetValues_Impl().pObj &&
 638             GetValues_Impl().pObj != this &&
 639             GetValues_Impl().pObj != GetParent() )
 640     {
 641         rStrm.WriteCharPtr( " contains " );
 642         static_cast<SbxObject*>(GetValues_Impl().pObj)->Dump( rStrm, bFill );
 643     }
 644     else
 645     {
 646         rStrm << endl;
 647     }
 648 }
 649
 650 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */