scripting/source/basprov/basscript.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 "basscript.hxx"
  21 #include <vcl/svapp.hxx>
  22 #include <basic/sbx.hxx>
  23 #include <basic/sbstar.hxx>
  24 #include <basic/sbmod.hxx>
  25 #include <basic/sbmeth.hxx>
  26 #include <basic/sbuno.hxx>
  27 #include <basic/basmgr.hxx>
  28 #include <com/sun/star/script/provider/ScriptFrameworkErrorException.hpp>
  29 #include <com/sun/star/script/provider/ScriptFrameworkErrorType.hpp>
  30 #include <bcholder.hxx>
  31 #include <comphelper/proparrhlp.hxx>
  32 #include <comphelper/propertycontainer.hxx>
  33 #include <com/sun/star/beans/PropertyAttribute.hpp>
  34 #include <map>
  35
  36
  37 using namespace ::com::sun::star;
  38 using namespace ::com::sun::star::lang;
  39 using namespace ::com::sun::star::uno;
  40 using namespace ::com::sun::star::script;
  41 using namespace ::com::sun::star::document;
  42 using namespace ::com::sun::star::beans;
  43
  44
  45 namespace basprov
  46 {
  47
  48 #define BASSCRIPT_PROPERTY_ID_CALLER         1
  49 #define BASSCRIPT_PROPERTY_CALLER            "Caller"
  50
  51 #define BASSCRIPT_DEFAULT_ATTRIBS()       PropertyAttribute::BOUND | PropertyAttribute::TRANSIENT
  52
  53     typedef ::std::map< sal_Int16, Any > OutParamMap;
  54
  55
  56     // BasicScriptImpl
  57
  58
  59     BasicScriptImpl::BasicScriptImpl( const OUString& funcName, SbMethodRef const & xMethod )
  60         : ::scripting_helper::OBroadcastHelperHolder( m_aMutex )
  61         ,OPropertyContainer( GetBroadcastHelper() )
  62         ,m_xMethod( xMethod )
  63         ,m_funcName( funcName )
  64         ,m_documentBasicManager( nullptr )
  65         ,m_xDocumentScriptContext()
  66     {
  67         registerProperty( BASSCRIPT_PROPERTY_CALLER, BASSCRIPT_PROPERTY_ID_CALLER, BASSCRIPT_DEFAULT_ATTRIBS(), &m_caller, cppu::UnoType<decltype(m_caller)>::get() );
  68     }
  69
  70
  71     BasicScriptImpl::BasicScriptImpl( const OUString& funcName, SbMethodRef const & xMethod,
  72         BasicManager& documentBasicManager, const Reference< XScriptInvocationContext >& documentScriptContext ) : ::scripting_helper::OBroadcastHelperHolder( m_aMutex )
  73         ,OPropertyContainer( GetBroadcastHelper() )
  74         ,m_xMethod( xMethod )
  75         ,m_funcName( funcName )
  76         ,m_documentBasicManager( &documentBasicManager )
  77         ,m_xDocumentScriptContext( documentScriptContext )
  78     {
  79         StartListening( *m_documentBasicManager );
  80         registerProperty( BASSCRIPT_PROPERTY_CALLER, BASSCRIPT_PROPERTY_ID_CALLER, BASSCRIPT_DEFAULT_ATTRIBS(), &m_caller, cppu::UnoType<decltype(m_caller)>::get() );
  81     }
  82
  83
  84     BasicScriptImpl::~BasicScriptImpl()
  85     {
  86         SolarMutexGuard g;
  87
  88         if ( m_documentBasicManager )
  89             EndListening( *m_documentBasicManager );
  90     }
  91
  92
  93     // SfxListener
  94
  95     void BasicScriptImpl::Notify( SfxBroadcaster& rBC, const SfxHint& rHint )
  96     {
  97         if ( &rBC != m_documentBasicManager )
  98         {
  99             OSL_ENSURE( false, "BasicScriptImpl::Notify: where does this come from?" );
 100             // not interested in
 101             return;
 102         }
 103         if ( rHint.GetId() == SfxHintId::Dying )
 104         {
 105             m_documentBasicManager = nullptr;
 106             EndListening( rBC );    // prevent multiple notifications
 107         }
 108     }
 109
 110
 111     // XInterface
 112
 113
 114     IMPLEMENT_FORWARD_XINTERFACE2( BasicScriptImpl, BasicScriptImpl_BASE, OPropertyContainer )
 115
 116
 117     // XTypeProvider
 118
 119
 120     IMPLEMENT_FORWARD_XTYPEPROVIDER2( BasicScriptImpl, BasicScriptImpl_BASE, OPropertyContainer )
 121
 122
 123     // OPropertySetHelper
 124
 125
 126     ::cppu::IPropertyArrayHelper& BasicScriptImpl::getInfoHelper(  )
 127     {
 128         return *getArrayHelper();
 129     }
 130
 131
 132     // OPropertyArrayUsageHelper
 133
 134
 135     ::cppu::IPropertyArrayHelper* BasicScriptImpl::createArrayHelper(  ) const
 136     {
 137         Sequence< Property > aProps;
 138         describeProperties( aProps );
 139         return new ::cppu::OPropertyArrayHelper( aProps );
 140     }
 141
 142
 143     // XPropertySet
 144
 145
 146     Reference< XPropertySetInfo > BasicScriptImpl::getPropertySetInfo(  )
 147     {
 148         Reference< XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
 149         return xInfo;
 150     }
 151
 152
 153     // XScript
 154
 155
 156     Any BasicScriptImpl::invoke( const Sequence< Any >& aParams, Sequence< sal_Int16 >& aOutParamIndex, Sequence< Any >& aOutParam )
 157     {
 158         // TODO: throw CannotConvertException
 159         // TODO: check length of aOutParamIndex, aOutParam
 160
 161         SolarMutexGuard aGuard;
 162
 163         Any aReturn;
 164
 165         if ( m_xMethod.is() )
 166         {
 167             // check if compiled
 168             SbModule* pModule = static_cast< SbModule* >( m_xMethod->GetParent() );
 169             if ( pModule && !pModule->IsCompiled() )
 170                 pModule->Compile();
 171
 172             // check number of parameters
 173             sal_Int32 nParamsCount = aParams.getLength();
 174             SbxInfo* pInfo = m_xMethod->GetInfo();
 175             if ( pInfo )
 176             {
 177                 sal_Int32 nSbxOptional = 0;
 178                 sal_uInt16 n = 1;
 179                 for ( const SbxParamInfo* pParamInfo = pInfo->GetParam( n ); pParamInfo; pParamInfo = pInfo->GetParam( ++n ) )
 180                 {
 181                     if ( pParamInfo->nFlags & SbxFlagBits::Optional )
 182                         ++nSbxOptional;
 183                     else
 184                         nSbxOptional = 0;
 185                 }
 186                 sal_Int32 nSbxCount = n - 1;
 187                 if ( nParamsCount < nSbxCount - nSbxOptional )
 188                 {
 189                     throw provider::ScriptFrameworkErrorException(
 190                          "wrong number of parameters!",
 191                          Reference< XInterface >(),
 192                          m_funcName,
 193                          "Basic",
 194                          provider::ScriptFrameworkErrorType::NO_SUCH_SCRIPT  );
 195                 }
 196             }
 197
 198             // set parameters
 199             SbxArrayRef xSbxParams;
 200             if ( nParamsCount > 0 )
 201             {
 202                 xSbxParams = new SbxArray;
 203                 const Any* pParams = aParams.getConstArray();
 204                 for ( sal_Int32 i = 0; i < nParamsCount; ++i )
 205                 {
 206                     SbxVariableRef xSbxVar = new SbxVariable( SbxVARIANT );
 207                     unoToSbxValue( xSbxVar.get(), pParams[i] );
 208                     xSbxParams->Put( xSbxVar.get(), static_cast< sal_uInt16 >( i ) + 1 );
 209
 210                     // Enable passing by ref
 211                     if ( xSbxVar->GetType() != SbxVARIANT )
 212                         xSbxVar->SetFlag( SbxFlagBits::Fixed );
 213                  }
 214             }
 215             if ( xSbxParams.is() )
 216                 m_xMethod->SetParameters( xSbxParams.get() );
 217
 218             // call method
 219             SbxVariableRef xReturn = new SbxVariable;
 220             ErrCode nErr = ERRCODE_NONE;
 221
 222             // if it's a document-based script, temporarily reset ThisComponent to the script invocation context
 223             Any aOldThisComponent;
 224             if ( m_documentBasicManager && m_xDocumentScriptContext.is() )
 225                 aOldThisComponent = m_documentBasicManager->SetGlobalUNOConstant( "ThisComponent", makeAny( m_xDocumentScriptContext ) );
 226
 227             if ( m_caller.hasElements() && m_caller[ 0 ].hasValue()  )
 228             {
 229                 SbxVariableRef xCallerVar = new SbxVariable( SbxVARIANT );
 230                 unoToSbxValue( xCallerVar.get(), m_caller[ 0 ] );
 231                 nErr = m_xMethod->Call( xReturn.get(), xCallerVar.get() );
 232             }
 233             else
 234                 nErr = m_xMethod->Call( xReturn.get() );
 235
 236             if ( m_documentBasicManager && m_xDocumentScriptContext.is() )
 237                 m_documentBasicManager->SetGlobalUNOConstant( "ThisComponent", aOldThisComponent );
 238
 239             if ( nErr != ERRCODE_NONE )
 240             {
 241                 // TODO: throw InvocationTargetException ?
 242             }
 243
 244             // get output parameters
 245             if ( xSbxParams.is() )
 246             {
 247                 SbxInfo* pInfo_ = m_xMethod->GetInfo();
 248                 if ( pInfo_ )
 249                 {
 250                     OutParamMap aOutParamMap;
 251                     for ( sal_uInt16 n = 1, nCount = xSbxParams->Count(); n < nCount; ++n )
 252                     {
 253                         const SbxParamInfo* pParamInfo = pInfo_->GetParam( n );
 254                         if ( pParamInfo && ( pParamInfo->eType & SbxBYREF ) != 0 )
 255                         {
 256                             SbxVariable* pVar = xSbxParams->Get( n );
 257                             if ( pVar )
 258                             {
 259                                 SbxVariableRef xVar = pVar;
 260                                 aOutParamMap.emplace( n - 1, sbxToUnoValue( xVar.get() ) );
 261                             }
 262                         }
 263                     }
 264                     sal_Int32 nOutParamCount = aOutParamMap.size();
 265                     aOutParamIndex.realloc( nOutParamCount );
 266                     aOutParam.realloc( nOutParamCount );
 267                     sal_Int16* pOutParamIndex = aOutParamIndex.getArray();
 268                     Any* pOutParam = aOutParam.getArray();
 269                     for ( const auto& rEntry : aOutParamMap )
 270                     {
 271                         *pOutParamIndex = rEntry.first;
 272                         ++pOutParamIndex;
 273                         *pOutParam = rEntry.second;
 274                         ++pOutParam;
 275                     }
 276                 }
 277             }
 278
 279             // get return value
 280             aReturn = sbxToUnoValue( xReturn.get() );
 281
 282             // reset parameters
 283             m_xMethod->SetParameters( nullptr );
 284         }
 285
 286         return aReturn;
 287     }
 288
 289
 290 }   // namespace basprov
 291
 292
 293 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */