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