CWS-TOOLING: integrate CWS ab72

2009-08-03 14:57:25 +0200 jsk  r274581 : #i103969 - fixed f_windowfunctions.bas
2009-08-03 13:29:21 +0200 jsk  r274577 : #i103969 - minor stability improvements and a rewrite to use GUI function to install extension (CLI version fails for some unknown reason)
2009-07-16 10:43:48 +0200 ab  r274033 : #i82918# Added support to pass context explicitely to service ctors
2009-07-08 16:24:05 +0200 ab  r273839 : CWS-TOOLING: rebase CWS ab72 to trunk@273468 (milestone: DEV300:m51)
2009-07-02 13:09:22 +0200 ab  r273641 : #i89740# Fixed resource typos
2009-07-02 12:21:49 +0200 ab  r273635 : #i99461# Applied patch
2009-06-23 15:56:08 +0200 ab  r273284 : #i100578# applied patch
2009-06-23 11:52:45 +0200 ab  r273271 : #i100600# applied patch
2009-06-22 14:35:15 +0200 ab  r273231 : #i101603# applied patch
2009-06-22 13:24:22 +0200 ab  r273227 : #i100540# applied patch to remove unused code
2009-06-10 13:33:20 +0200 ab  r272806 : #i82918# New style service ctor support

12 files changed, 411 insertions, 90 deletions

diff --git a/basic/inc/basic/sbstar.hxx b/basic/inc/basic/sbstar.hxx
index 9bc79b7b08..f71d1ff2fd 100644
--- a/basic/inc/basic/sbstar.hxx
+++ b/basic/inc/basic/sbstar.hxx
@@ -121,6 +121,7 @@ public:
     static void 	Error( SbError );
     static void 	Error( SbError, const String& rMsg );
     static void 	FatalError( SbError );
+    static void 	FatalError( SbError, const String& rMsg );
     static BOOL 	IsRunning();
     static SbError 	GetErrBasic();
     // #66536 make additional message accessible by RTL function Error
diff --git a/basic/source/classes/sb.cxx b/basic/source/classes/sb.cxx
index 6dedae6bdc..4f123c2e23 100644
--- a/basic/source/classes/sb.cxx
+++ b/basic/source/classes/sb.cxx
@@ -1357,6 +1357,12 @@ void StarBASIC::FatalError( SbError n )
         pINST->FatalError( n );
 }
 
+void StarBASIC::FatalError( SbError _errCode, const String& _details )
+{
+    if( pINST )
+        pINST->FatalError( _errCode, _details );
+}
+
 SbError StarBASIC::GetErrBasic()
 {
     if( pINST )
diff --git a/basic/source/classes/sb.src b/basic/source/classes/sb.src
index 4daa8e0eac..5b1454d654 100644
--- a/basic/source/classes/sb.src
+++ b/basic/source/classes/sb.src
@@ -341,7 +341,7 @@ Resource RID_BASIC_START
     };
     String SbERR_NO_METHOD & ERRCODE_RES_MASK
     {
-        Text [ en-US ] = "Property or method not found." ;
+        Text [ en-US ] = "Property or method not found: $(ARG1)." ;
     };
     String SbERR_NEEDS_OBJECT & ERRCODE_RES_MASK
     {
diff --git a/basic/source/classes/sbunoobj.cxx b/basic/source/classes/sbunoobj.cxx
index dcd51ceb28..96794c067f 100644
--- a/basic/source/classes/sbunoobj.cxx
+++ b/basic/source/classes/sbunoobj.cxx
@@ -68,7 +68,7 @@
 #include <com/sun/star/reflection/XIdlArray.hpp>
 #include <com/sun/star/reflection/XIdlReflection.hpp>
 #include <com/sun/star/reflection/XIdlClassProvider.hpp>
-#include <com/sun/star/reflection/XTypeDescription.hpp>
+#include <com/sun/star/reflection/XServiceConstructorDescription.hpp>
 #include <com/sun/star/bridge/oleautomation/NamedArgument.hpp>
 #include <com/sun/star/bridge/oleautomation/Date.hpp>
 #include <com/sun/star/bridge/oleautomation/Decimal.hpp>
@@ -104,6 +104,8 @@ TYPEINIT1(SbUnoMethod,SbxMethod)
 TYPEINIT1(SbUnoProperty,SbxProperty)
 TYPEINIT1(SbUnoObject,SbxObject)
 TYPEINIT1(SbUnoClass,SbxObject)
+TYPEINIT1(SbUnoService,SbxObject)
+TYPEINIT1(SbUnoServiceCtor,SbxMethod)
 
 typedef WeakImplHelper1< XAllListener > BasicAllListenerHelper;
 
@@ -2496,35 +2498,7 @@ SbUnoProperty::~SbUnoProperty()
 {}
 
 
-// #72732 Spezielle SbxVariable, die beim put/get prueft,
-// ob der Kontext fuer eine UnoClass sinnvoll ist. Sonst
-// liegt eventuell ein Schreibfehler im Basic-Source vor.
-BOOL UnoClassMemberVariable::Get( SbxValues& rRes ) const
-{
-    // Zugriff auf den Member einer UnoClass mit Parametern ist unsinnig
-    if( GetParameters() )
-    {
-        if( mpRuntime )
-            mpRuntime->Error( SbERR_NO_METHOD );
-    }
-    return SbxVariable::Get( rRes );
-}
-
-BOOL UnoClassMemberVariable::Put( const SbxValues& rRes )
-{
-    if( bInternalUse )
-    {
-        return SbxVariable::Put( rRes );
-    }
-    // Schreibzugriff auf den Member einer UnoClass ist immer falsch
-    mpRuntime->Error( SbERR_NO_METHOD );
-    return FALSE;
-}
-
-TYPEINIT1(UnoClassMemberVariable,SbxVariable)
-
-
-SbxVariable* SbUnoObject::Find( const XubString& rName, SbxClassType t )
+SbxVariable* SbUnoObject::Find( const String& rName, SbxClassType t )
 {
     static Reference< XIdlMethod > xDummyMethod;
     static Property aDummyProp;
@@ -3201,16 +3175,16 @@ SbxVariable* getVBAConstant( const String& rName )
 
 // Funktion, um einen globalen Bezeichner im
 // UnoScope zu suchen und fuer Sbx zu wrappen
-SbxVariable* findUnoClass( const String& rName )
+SbUnoClass* findUnoClass( const String& rName )
 {
     // #105550 Check if module exists
     SbUnoClass* pUnoClass = NULL;
 
     Reference< XHierarchicalNameAccess > xTypeAccess = getTypeProvider_Impl();
-    Reference< XTypeDescription > xTypeDesc;
     if( xTypeAccess->hasByHierarchicalName( rName ) )
     {
         Any aRet = xTypeAccess->getByHierarchicalName( rName );
+        Reference< XTypeDescription > xTypeDesc;
         aRet >>= xTypeDesc;
 
         if( xTypeDesc.is() )
@@ -3287,7 +3261,6 @@ SbxVariable* SbUnoClass::Find( const XubString& rName, SbxClassType t )
                                 pRes = new SbxVariable( SbxVARIANT );
                                 SbxObjectRef xWrapper = (SbxObject*)new SbUnoClass( aNewName, xClass );
                                 pRes->PutObject( xWrapper );
-
                             }
                         }
                         else
@@ -3305,15 +3278,26 @@ SbxVariable* SbUnoClass::Find( const XubString& rName, SbxClassType t )
                 // Sonst wieder als Klasse annehmen
                 if( !pRes )
                 {
-                    SbxVariable* pNewClass = findUnoClass( aNewName );
+                    SbUnoClass* pNewClass = findUnoClass( aNewName );
                     if( pNewClass )
                     {
-                        Reference< XIdlClass > xClass;
                         pRes = new SbxVariable( SbxVARIANT );
                         SbxObjectRef xWrapper = (SbxObject*)pNewClass;
                         pRes->PutObject( xWrapper );
                     }
                 }
+
+                // An UNO service?
+                if( !pRes )
+                {
+                    SbUnoService* pUnoService = findUnoService( aNewName );
+                    if( pUnoService )
+                    {
+                        pRes = new SbxVariable( SbxVARIANT );
+                        SbxObjectRef xWrapper = (SbxObject*)pUnoService;
+                        pRes->PutObject( xWrapper );
+                    }
+                }
             }
         }
 
@@ -3334,6 +3318,266 @@ SbxVariable* SbUnoClass::Find( const XubString& rName, SbxClassType t )
 }
 
 
+SbUnoService* findUnoService( const String& rName )
+{
+    SbUnoService* pSbUnoService = NULL;
+
+    Reference< XHierarchicalNameAccess > xTypeAccess = getTypeProvider_Impl();
+    if( xTypeAccess->hasByHierarchicalName( rName ) )
+    {
+        Any aRet = xTypeAccess->getByHierarchicalName( rName );
+        Reference< XTypeDescription > xTypeDesc;
+        aRet >>= xTypeDesc;
+
+        if( xTypeDesc.is() )
+        {
+            TypeClass eTypeClass = xTypeDesc->getTypeClass();
+            if( eTypeClass == TypeClass_SERVICE )
+            {
+                Reference< XServiceTypeDescription2 > xServiceTypeDesc( xTypeDesc, UNO_QUERY );
+                if( xServiceTypeDesc.is() )
+                    pSbUnoService = new SbUnoService( rName, xServiceTypeDesc );
+            }
+        }
+    }
+    return pSbUnoService;
+}
+
+SbxVariable* SbUnoService::Find( const String& rName, SbxClassType )
+{
+    SbxVariable* pRes = SbxObject::Find( rName, SbxCLASS_METHOD );
+
+    if( !pRes )
+    {
+        // Wenn es schon eine Klasse ist, nach einen Feld fragen
+        if( m_bNeedsInit && m_xServiceTypeDesc.is() )
+        {
+            m_bNeedsInit = false;
+
+            Sequence< Reference< XServiceConstructorDescription > > aSCDSeq = m_xServiceTypeDesc->getConstructors();
+            const Reference< XServiceConstructorDescription >* pCtorSeq = aSCDSeq.getConstArray();
+            int nCtorCount = aSCDSeq.getLength();
+            for( int i = 0 ; i < nCtorCount ; ++i )
+            {
+                Reference< XServiceConstructorDescription > xCtor = pCtorSeq[i];
+                
+                String aName( xCtor->getName() );
+                if( !aName.Len() )
+                {
+                    if( xCtor->isDefaultConstructor() )
+                        aName = String::CreateFromAscii( "create" );
+                }
+
+                if( aName.Len() )
+                {
+                    // Create and insert SbUnoServiceCtor
+                    SbxVariableRef xSbCtorRef = new SbUnoServiceCtor( aName, xCtor );
+                    QuickInsert( (SbxVariable*)xSbCtorRef );
+                    pRes = xSbCtorRef;
+                }
+            }
+        }
+    }
+
+    return pRes;
+}
+
+void SbUnoService::SFX_NOTIFY( SfxBroadcaster& rBC, const TypeId& rBCType,
+                           const SfxHint& rHint, const TypeId& rHintType )
+{
+    const SbxHint* pHint = PTR_CAST(SbxHint,&rHint);
+    if( pHint )
+    {
+        SbxVariable* pVar = pHint->GetVar();
+        SbxArray* pParams = pVar->GetParameters();
+        SbUnoServiceCtor* pUnoCtor = PTR_CAST(SbUnoServiceCtor,pVar);
+        if( pUnoCtor && pHint->GetId() == SBX_HINT_DATAWANTED )
+        {
+            // Parameter count -1 because of Param0 == this
+            UINT32 nParamCount = pParams ? ((UINT32)pParams->Count() - 1) : 0;
+            Sequence<Any> args;
+            BOOL bOutParams = FALSE;
+
+            Reference< XServiceConstructorDescription > xCtor = pUnoCtor->getServiceCtorDesc();
+            Sequence< Reference< XParameter > > aParameterSeq = xCtor->getParameters();
+            const Reference< XParameter >* pParameterSeq = aParameterSeq.getConstArray();
+            UINT32 nUnoParamCount = aParameterSeq.getLength();
+
+            // Default: Ignore not needed parameters
+            bool bParameterError = false;
+
+            // Is the last parameter a rest parameter?
+            bool bRestParameterMode = false;
+            if( nUnoParamCount > 0 )
+            {
+                Reference< XParameter > xLastParam = pParameterSeq[ nUnoParamCount - 1 ];
+                if( xLastParam.is() )
+                {
+                    if( xLastParam->isRestParameter() )
+                        bRestParameterMode = true;
+                }
+            }
+
+            // Too many parameters with context as first parameter?
+            USHORT nSbxParameterOffset = 1;
+            USHORT nParameterOffsetByContext = 0;
+            Reference < XComponentContext > xFirstParamContext;
+            if( nParamCount > nUnoParamCount )
+            {
+                // Check if first parameter is a context and use it
+                // then in createInstanceWithArgumentsAndContext
+                Any aArg0 = sbxToUnoValue( pParams->Get( nSbxParameterOffset ) );
+                if( (aArg0 >>= xFirstParamContext) && xFirstParamContext.is() )
+                    nParameterOffsetByContext = 1;
+            }
+
+            UINT32 nEffectiveParamCount = nParamCount - nParameterOffsetByContext;
+            UINT32 nAllocParamCount = nEffectiveParamCount;
+            if( nEffectiveParamCount > nUnoParamCount )
+            {
+                if( !bRestParameterMode )
+                {
+                    nEffectiveParamCount = nUnoParamCount;
+                    nAllocParamCount = nUnoParamCount;
+                }
+            }
+            // Not enough parameters?
+            else if( nUnoParamCount > nEffectiveParamCount )
+            {
+                // RestParameterMode only helps if one (the last) parameter is missing
+                int nDiff = nUnoParamCount - nEffectiveParamCount;
+                if( !bRestParameterMode || nDiff > 1 )
+                {
+                    bParameterError = true;
+                    StarBASIC::Error( SbERR_NOT_OPTIONAL );
+                }
+            }
+
+            if( !bParameterError )
+            {
+                if( nAllocParamCount > 0 )
+                {
+                    args.realloc( nAllocParamCount );
+                    Any* pAnyArgs = args.getArray();
+                    for( UINT32 i = 0 ; i < nEffectiveParamCount ; i++ )
+                    {
+                        USHORT iSbx = (USHORT)(i + nSbxParameterOffset + nParameterOffsetByContext);
+
+                        // bRestParameterMode allows nEffectiveParamCount > nUnoParamCount
+                        Reference< XParameter > xParam;
+                        if( i < nUnoParamCount )
+                        {
+                            xParam = pParameterSeq[i];
+                            if( !xParam.is() )
+                                continue;
+
+                            Reference< XTypeDescription > xParamTypeDesc = xParam->getType();
+                            if( !xParamTypeDesc.is() )
+                                continue;
+                            com::sun::star::uno::Type aType( xParamTypeDesc->getTypeClass(), xParamTypeDesc->getName() );
+
+                            // sbx paramter needs offset 1
+                            pAnyArgs[i] = sbxToUnoValue( pParams->Get( iSbx ), aType );
+
+                            // Check for out parameter if not already done
+                            if( !bOutParams )
+                            {
+                                if( xParam->isOut() )
+                                    bOutParams = TRUE;
+                            }
+                        }
+                        else
+                        {
+                            pAnyArgs[i] = sbxToUnoValue( pParams->Get( iSbx ) );
+                        }
+                    }
+                }
+
+                // "Call" ctor using createInstanceWithArgumentsAndContext
+                Reference < XComponentContext > xContext;
+                if( xFirstParamContext.is() )
+                {
+                    xContext = xFirstParamContext;
+                }
+                else
+                {
+                    Reference < XPropertySet > xProps( ::comphelper::getProcessServiceFactory(), UNO_QUERY_THROW );
+                    xContext.set( xProps->getPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "DefaultContext" )) ), UNO_QUERY_THROW );
+                }
+                Reference< XMultiComponentFactory > xServiceMgr( xContext->getServiceManager() ); 
+
+                Any aRetAny;
+                if( xServiceMgr.is() )
+                {
+                    String aServiceName = GetName();
+                    Reference < XInterface > xRet;
+                    try
+                    {
+                        xRet = xServiceMgr->createInstanceWithArgumentsAndContext( aServiceName, args, xContext );
+                    }
+                    catch( const Exception& )
+                    {
+                        implHandleAnyException( ::cppu::getCaughtException() );
+                    }
+                    aRetAny <<= xRet;
+                }
+                unoToSbxValue( pVar, aRetAny );
+
+                // Copy back out parameters?
+                if( bOutParams )
+                {
+                    const Any* pAnyArgs = args.getConstArray();
+
+                    for( UINT32 j = 0 ; j < nUnoParamCount ; j++ )
+                    {
+                        Reference< XParameter > xParam = pParameterSeq[j];
+                        if( !xParam.is() )
+                            continue;
+
+                        if( xParam->isOut() )
+                            unoToSbxValue( (SbxVariable*)pParams->Get( (USHORT)(j+1) ), pAnyArgs[ j ] );
+                    }
+                }
+            }
+        }
+        else
+            SbxObject::SFX_NOTIFY( rBC, rBCType, rHint, rHintType );
+    }
+}
+
+
+
+static SbUnoServiceCtor* pFirstCtor = NULL;
+
+void clearUnoServiceCtors( void )
+{
+    SbUnoServiceCtor* pCtor = pFirstCtor;
+    while( pCtor )
+    {
+        pCtor->SbxValue::Clear();
+        pCtor = pCtor->pNext;
+    }
+}
+
+SbUnoServiceCtor::SbUnoServiceCtor( const String& aName_, Reference< XServiceConstructorDescription > xServiceCtorDesc )
+    : SbxMethod( aName_, SbxOBJECT )
+    , m_xServiceCtorDesc( xServiceCtorDesc )
+{
+}
+
+SbUnoServiceCtor::~SbUnoServiceCtor()
+{
+}
+
+SbxInfo* SbUnoServiceCtor::GetInfo()
+{
+    SbxInfo* pRet = NULL;
+
+    return pRet;
+}
+
+
+ 
 //========================================================================
 //========================================================================
 //========================================================================
@@ -3703,7 +3947,6 @@ void RTL_Impl_GetDefaultContext( StarBASIC* pBasic, SbxArray& rPar, BOOL bWrite
 //========================================================================
 // Creates a Basic wrapper object for a strongly typed Uno value
 // 1. parameter: Uno type as full qualified type name, e.g. "byte[]"
-// void RTL_Impl_GetDefaultContext( StarBASIC* pBasic, SbxArray& rPar, BOOL bWrite )
 void RTL_Impl_CreateUnoValue( StarBASIC* pBasic, SbxArray& rPar, BOOL bWrite )
 {
     (void)pBasic;
diff --git a/basic/source/classes/sbxmod.cxx b/basic/source/classes/sbxmod.cxx
index 0d16dedf1f..21b31020f9 100644
--- a/basic/source/classes/sbxmod.cxx
+++ b/basic/source/classes/sbxmod.cxx
@@ -531,6 +531,7 @@ void ClearUnoObjectsInRTL_Impl( StarBASIC* pBasic )
 {
     // #67781 Rueckgabewerte der Uno-Methoden loeschen
     clearUnoMethods();
+    clearUnoServiceCtors();

 
     ClearUnoObjectsInRTL_Impl_Rek( pBasic );
 
diff --git a/basic/source/comp/exprtree.cxx b/basic/source/comp/exprtree.cxx
index f22ef6cede..b40ae4d1df 100644
--- a/basic/source/comp/exprtree.cxx
+++ b/basic/source/comp/exprtree.cxx
@@ -701,12 +701,6 @@ SbiExprNode* SbiExpression::Comp()
             pNd = new SbiExprNode( pParser, pNd, eTok, Cat() );
             nCount++;
         }
-        // Mehrere Operatoren hintereinander gehen nicht
-        if( nCount > 1 )
-        {
-            pParser->Error( SbERR_SYNTAX );
-            bError = TRUE;
-        }
     }
     return pNd;
 }
diff --git a/basic/source/comp/scanner.cxx b/basic/source/comp/scanner.cxx
index ee487baaa9..07033cd7ea 100644
--- a/basic/source/comp/scanner.cxx
+++ b/basic/source/comp/scanner.cxx
@@ -479,7 +479,17 @@ PrevLineCommentLbl:
 eoln:
     if( nCol && *--pLine == '_' )
     {
-        pLine = NULL; return NextSym();
+        pLine = NULL; 

+        bool bRes = NextSym();

+        if( bVBASupportOn && aSym.GetBuffer()[0] == '.' )

+        {

+            // object _

+            //    .Method

+            // ^^^  <- spaces is legal in MSO VBA

+            OSL_TRACE("*** resetting bSpaces***"); 

+            bSpaces = FALSE; 

+        }

+        return bRes;

     }
     else
     {
diff --git a/basic/source/inc/runtime.hxx b/basic/source/inc/runtime.hxx
index 2564f83d6b..409f0d76d6 100644
--- a/basic/source/inc/runtime.hxx
+++ b/basic/source/inc/runtime.hxx
@@ -220,10 +220,11 @@ public:
     SbiInstance( StarBASIC* );
    ~SbiInstance();
 
-    void Error( SbError );			// trappable Error
+    void Error( SbError );			            // trappable Error
     void Error( SbError, const String& rMsg );	// trappable Error mit Message
-    void FatalError( SbError );		// non-trappable Error
-    void Abort();					// Abbruch mit aktuellem Fehlercode
+    void FatalError( SbError );		            // non-trappable Error
+    void FatalError( SbError, const String& );  // non-trappable Error
+    void Abort();					            // Abbruch mit aktuellem Fehlercode
 
     void    Stop();
     SbError GetErr()				{ return nErr; }
@@ -270,30 +271,6 @@ struct RefSaveItem
 };
 
 
-// #72732 Spezielle SbxVariable, die beim put/get prueft,
-// ob der Kontext fuer eine UnoClass sinnvoll ist. Sonst
-// liegt eventuell ein Schreibfehler im Basic-Source vor.
-class UnoClassMemberVariable : public SbxVariable
-{
-    SbiRuntime* mpRuntime;
-    BOOL bInternalUse;
-
-public:
-    UnoClassMemberVariable( SbiRuntime* pRuntime_, const SbxObjectRef& xWrapper )
-        : SbxVariable( SbxVARIANT ), mpRuntime( pRuntime_ )
-    {
-        bInternalUse = TRUE;
-        PutObject( xWrapper );
-        bInternalUse = FALSE;
-    }
-
-    virtual BOOL Get( SbxValues& ) const;
-    virtual BOOL Put( const SbxValues& );
-
-    TYPEINFO();
-};
-
-
 // Eine Instanz dieser Klasse wird fuer jedes ausgefuehrte Unterprogramm
 // aufgesetzt. Diese Instanz ist das Herz der BASIC-Maschine und enthaelt
 // nur lokale Daten.
@@ -467,8 +444,10 @@ public:
 
     SbiRuntime( SbModule*, SbMethod*, UINT32 );
    ~SbiRuntime();
-    void Error( SbError );			// Fehler setzen, falls != 0
-    void FatalError( SbError );		// Fehlerbehandlung=Standard, Fehler setzen
+    void Error( SbError );			            // Fehler setzen, falls != 0
+    void Error( SbError, const String& );       // Fehler setzen, falls != 0
+    void FatalError( SbError );		            // Fehlerbehandlung=Standard, Fehler setzen
+    void FatalError( SbError, const String& );  // Fehlerbehandlung=Standard, Fehler setzen
     void DumpPCode();
     BOOL Step();                    // Einzelschritt (ein Opcode)
     void Stop()     	   { bRun = FALSE;   }
diff --git a/basic/source/inc/sbunoobj.hxx b/basic/source/inc/sbunoobj.hxx
index dc2cfefbee..5780113482 100644
--- a/basic/source/inc/sbunoobj.hxx
+++ b/basic/source/inc/sbunoobj.hxx
@@ -43,6 +43,7 @@
 #include <com/sun/star/beans/XIntrospection.hpp>
 #include <com/sun/star/script/XInvocation.hpp>
 #include <com/sun/star/reflection/XIdlClass.hpp>
+#include <com/sun/star/reflection/XServiceTypeDescription2.hpp> 
 #include <rtl/ustring.hxx>
 
 class SbUnoObject: public SbxObject
@@ -149,7 +150,7 @@ public:
 };
 
 // Wrapper fuer eine Uno-Klasse
-class SbUnoClass: public SbxObject
+class SbUnoClass : public SbxObject
 {
     const ::com::sun::star::uno::Reference< ::com::sun::star::reflection::XIdlClass >	m_xClass;
 
@@ -177,9 +178,57 @@ SV_DECL_IMPL_REF(SbUnoClass);
 
 // Funktion, um einen globalen Bezeichner im
 // UnoScope zu suchen und fuer Sbx zu wrappen
-SbxVariable* findUnoClass( const String& rName );
+SbUnoClass* findUnoClass( const String& rName );
 
 
+// Wrapper for UNO Service
+class SbUnoService : public SbxObject
+{
+    const ::com::sun::star::uno::Reference< ::com::sun::star::reflection::XServiceTypeDescription2 >	m_xServiceTypeDesc;
+    bool																								m_bNeedsInit;
+
+public:
+    TYPEINFO();
+    SbUnoService( const String& aName_,
+        const ::com::sun::star::uno::Reference< ::com::sun::star::reflection::XServiceTypeDescription2 >& xServiceTypeDesc )
+            : SbxObject( aName_ )
+            , m_xServiceTypeDesc( xServiceTypeDesc )
+            , m_bNeedsInit( true )
+    {}
+
+    virtual SbxVariable* Find( const String&, SbxClassType );
+
+    void SFX_NOTIFY( SfxBroadcaster&, const TypeId&, const SfxHint& rHint, const TypeId& );
+};
+SV_DECL_IMPL_REF(SbUnoService);
+
+SbUnoService* findUnoService( const String& rName );
+
+
+void clearUnoServiceCtors( void );
+
+class SbUnoServiceCtor : public SbxMethod
+{
+    friend class SbUnoService;
+    friend void clearUnoServiceCtors( void );
+
+    ::com::sun::star::uno::Reference< ::com::sun::star::reflection::XServiceConstructorDescription > m_xServiceCtorDesc;
+
+    SbUnoServiceCtor* pPrev;
+    SbUnoServiceCtor* pNext;
+
+public:
+    TYPEINFO();
+
+    SbUnoServiceCtor( const String& aName_, ::com::sun::star::uno::Reference< ::com::sun::star::reflection::XServiceConstructorDescription > xServiceCtorDesc );
+    virtual ~SbUnoServiceCtor();
+    virtual SbxInfo* GetInfo();
+
+    ::com::sun::star::uno::Reference< ::com::sun::star::reflection::XServiceConstructorDescription > getServiceCtorDesc( void )
+        { return m_xServiceCtorDesc; }
+};
+
+ 
 // #105565 Special Object to wrap a strongly typed Uno Any
 class SbUnoAnyObject: public SbxObject
 {
diff --git a/basic/source/runtime/runtime.cxx b/basic/source/runtime/runtime.cxx
index aee7bc2d69..87f88ea9e6 100644
--- a/basic/source/runtime/runtime.cxx
+++ b/basic/source/runtime/runtime.cxx
@@ -430,6 +430,11 @@ void SbiInstance::FatalError( SbError n )
     pRun->FatalError( n );
 }
 
+void SbiInstance::FatalError( SbError _errCode, const String& _details )
+{
+    pRun->FatalError( _errCode, _details );
+}
+
 void SbiInstance::Abort()
 {
     // Basic suchen, in dem der Fehler auftrat
@@ -721,7 +726,7 @@ BOOL SbiRuntime::Step()
                     pCode = pError;
                 else 
                     bLetParentHandleThis = true;
-                         }
+            }
             else
             {
                 bLetParentHandleThis = true;
@@ -795,12 +800,35 @@ void SbiRuntime::Error( SbError n )
         nError = n;
 }
 
+void SbiRuntime::Error( SbError _errCode, const String& _details )
+{
+    if ( _errCode )
+    {
+        OSL_ENSURE( pInst->pRun == this, "SbiRuntime::Error: can't propagate the error message details!" );
+        if ( pInst->pRun == this )
+        {
+            pInst->Error( _errCode, _details );
+            OSL_POSTCOND( nError == _errCode, "SbiRuntime::Error: the instance is expecte to propagate the error code back to me!" );
+        }
+        else
+        {
+            nError = _errCode;
+        }
+    }
+}
+
 void SbiRuntime::FatalError( SbError n )
 {
     StepSTDERROR();
     Error( n );
 }
 
+void SbiRuntime::FatalError( SbError _errCode, const String& _details )
+{
+    StepSTDERROR();
+    Error( _errCode, _details );
+}
+
 //////////////////////////////////////////////////////////////////////////
 //
 //	Parameter, Locals, Caller
@@ -859,21 +887,13 @@ SbxVariableRef SbiRuntime::PopVar()
 
 BOOL SbiRuntime::ClearExprStack()
 {
-    // #74732 Hier kann ein Fehler gesetzt werden
-    BOOL bErrorSet = FALSE;
-
     // Achtung: Clear() reicht nicht, da Methods geloescht werden muessen
     while ( nExprLvl )
     {
-        SbxVariableRef xVar = PopVar();
-        if( !nError && xVar->ISA( UnoClassMemberVariable ) )
-        {
-            Error( SbERR_NO_METHOD );
-            bErrorSet = TRUE;
-        }
+        PopVar();
     }
     refExprStk->Clear();
-    return bErrorSet;
+    return FALSE;
 }
 
 // Variable auf dem Expression-Stack holen, ohne sie zu entfernen
diff --git a/basic/source/runtime/step2.cxx b/basic/source/runtime/step2.cxx
index 097712a576..2589207ac9 100644
--- a/basic/source/runtime/step2.cxx
+++ b/basic/source/runtime/step2.cxx
@@ -199,7 +199,7 @@ SbxVariable* SbiRuntime::FindElement
                 }
                 // #72382 VORSICHT! Liefert jetzt wegen unbekannten
                 // Modulen IMMER ein Ergebnis!
-                SbxVariable* pUnoClass = findUnoClass( aName );
+                SbUnoClass* pUnoClass = findUnoClass( aName );
                 if( pUnoClass )
                 {
                     pElem = new SbxVariable( t );
@@ -255,7 +255,7 @@ SbxVariable* SbiRuntime::FindElement
                     ClearArgvStack();
 
                     // Normalen Error setzen
-                    Error( nNotFound );
+                    Error( nNotFound, aName );
                 }
                 else
                 {
@@ -832,6 +832,7 @@ void SbiRuntime::StepSTMNT( UINT32 nOp1, UINT32 nOp2 )
     // Wenn der Expr-Stack am Anfang einen Statements eine Variable enthaelt,
     // hat ein Trottel X als Funktion aufgerufen, obwohl es eine Variable ist!
     BOOL bFatalExpr = FALSE;
+    String sUnknownMethodName;
     if( nExprLvl > 1 )
         bFatalExpr = TRUE;
     else if( nExprLvl )
@@ -839,7 +840,10 @@ void SbiRuntime::StepSTMNT( UINT32 nOp1, UINT32 nOp2 )
         SbxVariable* p = refExprStk->Get( 0 );
         if( p->GetRefCount() > 1
          && refLocals.Is() && refLocals->Find( p->GetName(), p->GetClass() ) )
+        {
+            sUnknownMethodName = p->GetName();
             bFatalExpr = TRUE;
+        }
     }
     // Der Expr-Stack ist nun nicht mehr notwendig
     ClearExprStack();
@@ -854,7 +858,7 @@ void SbiRuntime::StepSTMNT( UINT32 nOp1, UINT32 nOp2 )
     // stimmen!
     if( bFatalExpr)
     {
-        StarBASIC::FatalError( SbERR_NO_METHOD );
+        StarBASIC::FatalError( SbERR_NO_METHOD, sUnknownMethodName );
         return;
     }
     pStmnt = pCode - 9;
diff --git a/basic/source/sbx/sbxvalue.cxx b/basic/source/sbx/sbxvalue.cxx
index 5c2105d89d..e746f3d115 100644
--- a/basic/source/sbx/sbxvalue.cxx
+++ b/basic/source/sbx/sbxvalue.cxx
@@ -1572,7 +1572,10 @@ BOOL SbxValue::Compare( SbxOperator eOp, const SbxValue& rOp ) const
         else
         {
             aL.eType = aR.eType = SbxDOUBLE;
-            if( Get( aL ) && rOp.Get( aR ) )
+            //if( Get( aL ) && rOp.Get( aR ) )
+            bool bGetL = Get( aL );

+            bool bGetR = rOp.Get( aR );

+            if( bGetL && bGetR )

               switch( eOp )
             {
                 case SbxEQ:
@@ -1590,6 +1593,17 @@ BOOL SbxValue::Compare( SbxOperator eOp, const SbxValue& rOp ) const
                 default:
                     SetError( SbxERR_NOTIMP );
             }
+            // at least one value was got

+            // if this is VBA then a conversion error for one

+            // side will yield a false result of an equality test

+            else if ( bGetR || bGetL )

+            {

+                if ( bVBAInterop && eOp == SbxEQ && GetError() == SbxERR_CONVERSION )

+                {

+                    ResetError();

+                    bRes = FALSE;

+                }

+            }

         }
     }
     if( eOld != SbxERR_OK )