diff options
Diffstat (limited to 'include/basic')
| -rw-r--r-- | include/basic/basicdllapi.h | 23 | ||||
| -rw-r--r-- | include/basic/basicmanagerrepository.hxx | 138 | ||||
| -rw-r--r-- | include/basic/basmgr.hxx | 221 | ||||
| -rw-r--r-- | include/basic/basrdll.hxx | 43 | ||||
| -rw-r--r-- | include/basic/codecompletecache.hxx | 93 | ||||
| -rw-r--r-- | include/basic/modsizeexceeded.hxx | 65 | ||||
| -rw-r--r-- | include/basic/sbdef.hxx | 79 | ||||
| -rw-r--r-- | include/basic/sberrors.hxx | 176 | ||||
| -rw-r--r-- | include/basic/sbmeth.hxx | 88 | ||||
| -rw-r--r-- | include/basic/sbmod.hxx | 165 | ||||
| -rw-r--r-- | include/basic/sbstar.hxx | 157 | ||||
| -rw-r--r-- | include/basic/sbuno.hxx | 47 | ||||
| -rw-r--r-- | include/basic/sbx.hxx | 213 | ||||
| -rw-r--r-- | include/basic/sbxcore.hxx | 135 | ||||
| -rw-r--r-- | include/basic/sbxdef.hxx | 219 | ||||
| -rw-r--r-- | include/basic/sbxmeth.hxx | 43 | ||||
| -rw-r--r-- | include/basic/sbxobj.hxx | 85 | ||||
| -rw-r--r-- | include/basic/sbxvar.hxx | 336 | ||||
| -rw-r--r-- | include/basic/vbahelper.hxx | 94 |
19 files changed, 2420 insertions, 0 deletions
diff --git a/include/basic/basicdllapi.h b/include/basic/basicdllapi.h new file mode 100644 index 000000000..90b1f7861 --- /dev/null +++ b/include/basic/basicdllapi.h @@ -0,0 +1,23 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ +#ifndef INCLUDED_BASIC_BASICDLLAPI_H +#define INCLUDED_BASIC_BASICDLLAPI_H + +#include <sal/types.h> + +#if defined(BASIC_DLLIMPLEMENTATION) +#define BASIC_DLLPUBLIC SAL_DLLPUBLIC_EXPORT +#else +#define BASIC_DLLPUBLIC SAL_DLLPUBLIC_IMPORT +#endif +#define BASIC_DLLPRIVATE SAL_DLLPRIVATE + +#endif // INCLUDED_BASIC_BASICDLLAPI_H + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/basic/basicmanagerrepository.hxx b/include/basic/basicmanagerrepository.hxx new file mode 100644 index 000000000..e9e906685 --- /dev/null +++ b/include/basic/basicmanagerrepository.hxx @@ -0,0 +1,138 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_BASIC_BASICMANAGERREPOSITORY_HXX +#define INCLUDED_BASIC_BASICMANAGERREPOSITORY_HXX + +#include <basic/basicdllapi.h> + +namespace com::sun::star::frame { class XModel; } +namespace com::sun::star::uno { template <typename > class Reference; } + +class BasicManager; + + +namespace basic +{ + + + //= BasicManagerRepository + + /** specifies a callback for instances which are interested in BasicManagers + created by the BasicManagerRepository. + */ + class BASIC_DLLPUBLIC SAL_NO_VTABLE BasicManagerCreationListener + { + public: + /** is called when a BasicManager has been created + + @param _rxForDocument + denotes the document for which the BasicManager has been created. If this is <NULL/>, + then the BasicManager is the application-wide BasicManager. + + @param _pBasicManager + denotes the BasicManager which has been created. The listener might for instance + decide to add global variables to it, or otherwise initialize it. + */ + virtual void onBasicManagerCreated( + const css::uno::Reference< css::frame::XModel >& _rxForDocument, + BasicManager& _rBasicManager + ) = 0; + + protected: + ~BasicManagerCreationListener() {} + }; + + + //= BasicManagerRepository + + class BASIC_DLLPUBLIC BasicManagerRepository + { + public: + /** returns the BasicManager belonging to the given document + + If the BasicManager does not yet exist, it is created. In this case, if the application's + BasicManager does not yet exist, it is also created. This is necessary since + the application's BasicManager acts as parent for all document's BasicManagers. + + If you're interested in this case - the implicit creation of the application's BasicManager -, + then you need to register as BasicManagerCreationListener. + + @param _rxDocumentModel + denotes the document model whose BasicManager is to be retrieved. Must not be <NULL/>. + The document should support the XDocumentPropertiesSupplier + interface, for retrieving + its title, which is needed in some error conditions. + Also it <em>must</em> support the XStorageBasedDocument interface, since we + must be able to retrieve the document's storage. If this interface is <em>not</em> + supported, creating a new BasicManager will certainly fail. + + @return + the BasicManager for this model. + + @attention + The returned BasicManager instances is owned by the repository. In particular, + you are not allowed to delete it. Instead, the given model is observed: As soon + as it's closed, the associated BasicManager is deleted. + */ + static BasicManager* getDocumentBasicManager( + const css::uno::Reference< css::frame::XModel >& _rxDocumentModel + ); + + /** returns the application-wide BasicManager + + @attention + If the BasicManager is newly created, then it is still owned by the repository. + In particular, you are not allowed to delete it. Instead, call resetApplicationBasicManager + to release the BasicManager. + */ + static BasicManager* getApplicationBasicManager(); + + /** resets the application-wide BasicManager to <NULL/> + */ + static void resetApplicationBasicManager(); + + /** registers a BasicManagerCreationListener instance which is notified whenever + the repository creates a BasicManager instance. + + Note that this listener is <em>not</em> called when somebody else + creates BasicManager instances. + + If the same listener is registered multiple times, it is also notified + multiple times, and needs to be revoked once for each registration. + */ + static void registerCreationListener( + BasicManagerCreationListener& _rListener + ); + + /** revokes a BasicManagerCreationListener instance which has previously + been registered to be notified about created BasicManager instances. + */ + static void revokeCreationListener( + BasicManagerCreationListener& _rListener + ); + }; + + +} // namespace basic + + +#endif // INCLUDED_BASIC_BASICMANAGERREPOSITORY_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/basic/basmgr.hxx b/include/basic/basmgr.hxx new file mode 100644 index 000000000..166b62489 --- /dev/null +++ b/include/basic/basmgr.hxx @@ -0,0 +1,221 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ +#ifndef INCLUDED_BASIC_BASMGR_HXX +#define INCLUDED_BASIC_BASMGR_HXX + +#include <utility> +#include <vcl/errcode.hxx> +#include <svl/SfxBroadcaster.hxx> +#include <basic/sbstar.hxx> +#include <basic/basicdllapi.h> +#include <memory> +#include <string_view> +#include <vector> + +namespace com::sun::star::script { class XLibraryContainer; } +namespace com::sun::star::script { class XPersistentLibraryContainer; } +namespace com::sun::star::script { class XStarBasicAccess; } + +class BasicManager; + +// Basic XML Import/Export +BASIC_DLLPUBLIC css::uno::Reference< css::script::XStarBasicAccess > + getStarBasicAccess( BasicManager* pMgr ); + +class SotStorage; + +enum class BasicErrorReason +{ + OPENLIBSTORAGE = 0x0002, + OPENMGRSTREAM = 0x0004, + OPENLIBSTREAM = 0x0008, + LIBNOTFOUND = 0x0010, + STORAGENOTFOUND = 0x0020, + BASICLOADERROR = 0x0040, + STDLIB = 0x0100 +}; + +class BasicError +{ +private: + ErrCode nErrorId; + BasicErrorReason nReason; + +public: + BasicError( const BasicError& rErr ); + BasicError( ErrCode nId, BasicErrorReason nR ); + + ErrCode const & GetErrorId() const { return nErrorId; } +}; + +class BasicLibInfo; + +namespace basic { class ImplRepository; } + +// Library password handling for 5.0 documents +class BASIC_DLLPUBLIC OldBasicPassword +{ +public: + virtual void setLibraryPassword( const OUString& rLibraryName, const OUString& rPassword ) = 0; + +protected: + ~OldBasicPassword() {} +}; + +struct LibraryContainerInfo +{ + css::uno::Reference< css::script::XPersistentLibraryContainer > mxScriptCont; + css::uno::Reference< css::script::XPersistentLibraryContainer > mxDialogCont; + OldBasicPassword* mpOldBasicPassword; + + LibraryContainerInfo() + :mpOldBasicPassword( nullptr ) + { + } + + LibraryContainerInfo + ( + css::uno::Reference< css::script::XPersistentLibraryContainer > xScriptCont, + css::uno::Reference< css::script::XPersistentLibraryContainer > xDialogCont, + OldBasicPassword* pOldBasicPassword + ) + : mxScriptCont(std::move( xScriptCont )) + , mxDialogCont(std::move( xDialogCont )) + , mpOldBasicPassword( pOldBasicPassword ) + {} +}; + +#define LIB_NOTFOUND 0xFFFF + +class UNLESS_MERGELIBS(BASIC_DLLPUBLIC) BasicManager final : public SfxBroadcaster +{ + friend class LibraryContainer_Impl; + friend class StarBasicAccess_Impl; + friend class BasMgrContainerListenerImpl; + friend class ::basic::ImplRepository; + +private: + std::vector<BasicError> aErrors; + + OUString aName; + OUString maStorageName; + bool mbDocMgr; + + LibraryContainerInfo maContainerInfo; + std::vector<std::unique_ptr<BasicLibInfo>> maLibs; + OUString aBasicLibPath; + + bool ImpLoadLibrary( BasicLibInfo* pLibInfo, SotStorage* pCurStorage ); + void ImpCreateStdLib( StarBASIC* pParentFromStdLib ); + void ImpMgrNotLoaded( const OUString& rStorageName ); + BasicLibInfo* CreateLibInfo(); + void LoadBasicManager( SotStorage& rStorage, std::u16string_view rBaseURL ); + void LoadOldBasicManager( SotStorage& rStorage ); + bool ImplLoadBasic( SvStream& rStrm, StarBASICRef& rOldBasic ) const; + static bool ImplEncryptStream( SvStream& rStream ); + BasicLibInfo* FindLibInfo( StarBASIC const * pBasic ); + static void CheckModules( StarBASIC* pBasic, bool bReference ); + +public: + BasicManager( SotStorage& rStorage, std::u16string_view rBaseURL, StarBASIC* pParentFromStdLib = nullptr, OUString const * pLibPath = nullptr, bool bDocMgr = false ); + BasicManager( StarBASIC* pStdLib, OUString const * pLibPath = nullptr, bool bDocMgr = false ); + + virtual ~BasicManager() override; + + void SetStorageName( const OUString& rName ) { maStorageName = rName; } + const OUString& GetStorageName() const { return maStorageName; } + void SetName( const OUString& rName ) { aName = rName; } + const OUString& GetName() const { return aName; } + + + IF_MERGELIBS(BASIC_DLLPUBLIC) sal_uInt16 GetLibCount() const; + IF_MERGELIBS(BASIC_DLLPUBLIC) StarBASIC* GetLib( sal_uInt16 nLib ) const; + IF_MERGELIBS(BASIC_DLLPUBLIC) StarBASIC* GetLib( std::u16string_view rName ) const; + sal_uInt16 GetLibId( std::u16string_view rName ) const; + + OUString GetLibName( sal_uInt16 nLib ); + + /** announces the library containers which belong to this BasicManager + + The method will automatically add two global constants, BasicLibraries and DialogLibraries, + to the BasicManager. + */ + void SetLibraryContainerInfo( const LibraryContainerInfo& rInfo ); + + const css::uno::Reference< css::script::XPersistentLibraryContainer >& + GetDialogLibraryContainer() const; + const css::uno::Reference< css::script::XPersistentLibraryContainer >& + GetScriptLibraryContainer() const; + + bool LoadLib( sal_uInt16 nLib ); + IF_MERGELIBS(BASIC_DLLPUBLIC) + bool RemoveLib( sal_uInt16 nLib, bool bDelBasicFromStorage ); + + // Modify-Flag will be reset only during save. + bool IsBasicModified() const; + + std::vector<BasicError>& GetErrors() { return aErrors;} + + /** sets a global constant in the basic library, referring to some UNO object, to a new value. + + If a constant with this name already existed before, its value is changed, and the old constant is + returned in pOldValue. If it does not yet exist, it is newly created, and inserted into the basic library. + */ + IF_MERGELIBS(BASIC_DLLPUBLIC) + void SetGlobalUNOConstant( const OUString& rName, const css::uno::Any& _rValue, css::uno::Any* pOldValue = nullptr ); + + /** retrieves a global constant in the basic library, referring to some UNO object, returns true if a value is found ( value is in aOut ) false otherwise. */ + IF_MERGELIBS(BASIC_DLLPUBLIC) + bool GetGlobalUNOConstant( const OUString& rName, css::uno::Any& aOut ); + /** determines whether there are password-protected modules whose size exceeds the + legacy module size + @param _out_rModuleNames + takes the names of modules whose size exceeds the legacy limit + */ + bool LegacyPsswdBinaryLimitExceeded( std::vector< OUString >& _out_rModuleNames ); + bool HasExeCode( std::u16string_view ); + /// determines whether the Basic Manager has a given macro, given by fully qualified name + IF_MERGELIBS(BASIC_DLLPUBLIC) + bool HasMacro( OUString const& i_fullyQualifiedName ) const; + /// executes a given macro + ErrCode ExecuteMacro( OUString const& i_fullyQualifiedName, SbxArray* i_arguments, SbxValue* i_retValue ); + /// executes a given macro + ErrCode ExecuteMacro( OUString const& i_fullyQualifiedName, std::u16string_view i_commaSeparatedArgs, SbxValue* i_retValue ); + +private: + BASIC_DLLPRIVATE bool IsReference( sal_uInt16 nLib ); + + BASIC_DLLPRIVATE StarBASIC* GetStdLib() const; + BASIC_DLLPRIVATE StarBASIC* AddLib( SotStorage& rStorage, const OUString& rLibName, bool bReference ); + BASIC_DLLPRIVATE void RemoveLib( sal_uInt16 nLib ); + BASIC_DLLPRIVATE bool HasLib( std::u16string_view rName ) const; + + BASIC_DLLPRIVATE StarBASIC* CreateLibForLibContainer( const OUString& rLibName, + const css::uno::Reference< css::script::XLibraryContainer >& xScriptCont ); + // For XML import/export: + BASIC_DLLPRIVATE StarBASIC* CreateLib( const OUString& rLibName ); + BASIC_DLLPRIVATE StarBASIC* CreateLib( const OUString& rLibName, const OUString& Password, + const OUString& LinkTargetURL ); + BasicManager& operator=(BasicManager const &) = delete; //MSVC2015 workaround + BasicManager( BasicManager const&) = delete; //MSVC2015 workaround +}; + +#endif // INCLUDED_BASIC_BASMGR_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/basic/basrdll.hxx b/include/basic/basrdll.hxx new file mode 100644 index 000000000..2748bf3fd --- /dev/null +++ b/include/basic/basrdll.hxx @@ -0,0 +1,43 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_BASIC_BASRDLL_HXX +#define INCLUDED_BASIC_BASRDLL_HXX + +#include <basic/basicdllapi.h> +#include <tools/ref.hxx> + +class BASIC_DLLPUBLIC BasicDLL +{ +private: + tools::SvRef<SvRefBase> m_xImpl; + +public: + BasicDLL(); + ~BasicDLL(); + + static void BasicBreak(); + + static void EnableBreak(bool bEnable); + static void SetDebugMode(bool bDebugMode); +}; + +#endif // INCLUDED_BASIC_BASRDLL_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/basic/codecompletecache.hxx b/include/basic/codecompletecache.hxx new file mode 100644 index 000000000..2c6c0873f --- /dev/null +++ b/include/basic/codecompletecache.hxx @@ -0,0 +1,93 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_BASIC_CODECOMPLETECACHE_HXX +#define INCLUDED_BASIC_CODECOMPLETECACHE_HXX + +#include <config_options.h> +#include <basic/basicdllapi.h> +#include <rtl/ustring.hxx> +#include <unordered_map> + +typedef std::unordered_map< OUString, OUString > CodeCompleteVarTypes; +/* variable name, type */ +typedef std::unordered_map< OUString, CodeCompleteVarTypes > CodeCompleteVarScopes; +/* procedure, CodeCompleteVarTypes */ + +class BASIC_DLLPUBLIC CodeCompleteOptions +{ +/* + * class to store basic code completion + * options + * */ +private: + bool bIsCodeCompleteOn; + bool bIsProcedureAutoCompleteOn; + bool bIsAutoCloseQuotesOn; + bool bIsAutoCloseParenthesisOn; + bool bIsAutoCorrectOn; + bool bExtendedTypeDeclarationOn; + +public: + CodeCompleteOptions(); + + static bool IsCodeCompleteOn(); + static void SetCodeCompleteOn( bool b ); + + static bool IsExtendedTypeDeclaration(); + static void SetExtendedTypeDeclaration( bool b ); + + static bool IsProcedureAutoCompleteOn(); + static void SetProcedureAutoCompleteOn( bool b ); + + static bool IsAutoCloseQuotesOn(); + static void SetAutoCloseQuotesOn( bool b ); + + static bool IsAutoCloseParenthesisOn(); + static void SetAutoCloseParenthesisOn( bool b ); + + static bool IsAutoCorrectOn(); + static void SetAutoCorrectOn( bool b ); +}; + +class UNLESS_MERGELIBS(BASIC_DLLPUBLIC) CodeCompleteDataCache final +{ +/* + * cache to store data for + * code completion + * */ +private: + CodeCompleteVarScopes aVarScopes; + CodeCompleteVarTypes aGlobalVars; + +public: + CodeCompleteDataCache(){} + + friend BASIC_DLLPUBLIC std::ostream& operator<< (std::ostream& aStream, const CodeCompleteDataCache& aCache); + + void InsertGlobalVar( const OUString& sVarName, const OUString& sVarType ); + void InsertLocalVar( const OUString& sProcName, const OUString& sVarName, const OUString& sVarType ); + OUString GetVarType( std::u16string_view sVarName ) const; + OUString GetCorrectCaseVarName( std::u16string_view sVarName, std::u16string_view sActProcName ) const; + void Clear(); +}; + +#endif // INCLUDED_BASIC_CODECOMPLETECACHE_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/basic/modsizeexceeded.hxx b/include/basic/modsizeexceeded.hxx new file mode 100644 index 000000000..8910be30b --- /dev/null +++ b/include/basic/modsizeexceeded.hxx @@ -0,0 +1,65 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_BASIC_MODSIZEEXCEEDED_HXX +#define INCLUDED_BASIC_MODSIZEEXCEEDED_HXX + +#include <config_options.h> +#include <com/sun/star/task/XInteractionRequest.hpp> +#include <cppuhelper/implbase.hxx> +#include <basic/basicdllapi.h> +#include <vector> + +namespace com::sun::star::task { class XInteractionContinuation; } + +#if defined(_MSC_VER) && !defined(__clang__) +// MSVC automatically applies dllexport to template instantiations if they are a base class +// of a dllexport class, and this template instantiation is a case of that. If we don't +// dllimport here, MSVC will complain about duplicate symbols in a mergelibs build. +template class __declspec(dllimport) cppu::WeakImplHelper< css::task::XInteractionRequest >; +#endif + +class UNLESS_MERGELIBS(BASIC_DLLPUBLIC) ModuleSizeExceeded final : public cppu::WeakImplHelper< css::task::XInteractionRequest > +{ +// C++ interface +public: + ModuleSizeExceeded( const std::vector<OUString>& sModules ); + + bool isAbort() const; + bool isApprove() const; + +// UNO interface +public: + virtual css::uno::Sequence< css::uno::Reference< css::task::XInteractionContinuation > > SAL_CALL getContinuations() override { return m_lContinuations; } + css::uno::Any SAL_CALL getRequest() override + { + return m_aRequest; + } + +// member +private: + css::uno::Any m_aRequest; + css::uno::Sequence< css::uno::Reference< css::task::XInteractionContinuation > > m_lContinuations; + css::uno::Reference< css::task::XInteractionContinuation > m_xAbort; + css::uno::Reference< css::task::XInteractionContinuation> m_xApprove; +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/basic/sbdef.hxx b/include/basic/sbdef.hxx new file mode 100644 index 000000000..d864ed8de --- /dev/null +++ b/include/basic/sbdef.hxx @@ -0,0 +1,79 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_BASIC_SBDEF_HXX +#define INCLUDED_BASIC_SBDEF_HXX + +#include <basic/sbxdef.hxx> +#include <rtl/ustring.hxx> +#include <basic/basicdllapi.h> +#include <o3tl/typed_flags_set.hxx> +#include <unotools/resmgr.hxx> + +class ErrCode; + +// Returns type name for Basic type, array flag is ignored +// implementation: basic/source/runtime/methods.cxx +BASIC_DLLPUBLIC OUString getBasicTypeName( SbxDataType eType ); + +// Returns type name for Basic objects, especially +// important for SbUnoObj instances +// implementation: basic/source/classes/sbunoobj.cxx +class SbxObject; +BASIC_DLLPUBLIC OUString getBasicObjectTypeName( SbxObject* pObj ); + +// Allows Basic IDE to set watch mode to suppress errors +// implementation: basic/source/runtime/runtime.cxx +BASIC_DLLPUBLIC void setBasicWatchMode( bool bOn ); + +// Debug Flags: +enum class BasicDebugFlags { + NONE = 0x0000, + Break = 0x0001, // Break-Callback + StepInto = 0x0002, // Single Step-Callback + StepOver = 0x0004, // Additional flag Step Over + Continue = 0x0008, // Do not change flags + StepOut = 0x0010, // Leave Sub +}; +namespace o3tl { + template<> struct typed_flags<BasicDebugFlags> : is_typed_flags<BasicDebugFlags, 0x001f> {}; +} + +#define SBXID_BASIC 0x6273 // sb: StarBASIC +#define SBXID_BASICMOD 0x6d62 // bm: StarBASIC Module +#define SBXID_BASICPROP 0x7262 // pr: StarBASIC Property +#define SBXID_BASICMETHOD 0x6d65 // me: StarBASIC Method +#define SBXID_JSCRIPTMOD 0x6a62 // jm: JavaScript Module +#define SBXID_JSCRIPTMETH 0x6a64 // jm: JavaScript Module + +enum class PropertyMode +{ + NONE, + Get, + Let, + Set +}; + +BASIC_DLLPUBLIC extern std::pair<TranslateId, ErrCode> const RID_BASIC_START[]; +BASIC_DLLPUBLIC std::locale BasResLocale(); +OUString BasResId(TranslateId pId); + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/basic/sberrors.hxx b/include/basic/sberrors.hxx new file mode 100644 index 000000000..5976df8b9 --- /dev/null +++ b/include/basic/sberrors.hxx @@ -0,0 +1,176 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_BASIC_SBERRORS_HXX +#define INCLUDED_BASIC_SBERRORS_HXX + +#include <vcl/errcode.hxx> + +#define ERRCODE_BASIC_SYNTAX ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Compiler, 1) // unspecified syntax error +#define ERRCODE_BASIC_BAD_ARGUMENT ErrCode( ErrCodeArea::Sbx, ErrCodeClass::NotSupported, 2) // Invalid procedure call +#define ERRCODE_BASIC_MATH_OVERFLOW ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Sbx, 3) // overflow +#define ERRCODE_BASIC_OUT_OF_RANGE ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Sbx, 4) // Invalid array index / Subscript out of range +#define ERRCODE_BASIC_ZERODIV ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Sbx, 5) // Division by zero +#define ERRCODE_BASIC_CONVERSION ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Sbx, 6) // wrong data type +#define ERRCODE_BASIC_BAD_PARAMETER ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 7) // invalid Parameter +#define ERRCODE_BASIC_PROC_UNDEFINED ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 8) // Sub or Function not defined +#define ERRCODE_BASIC_INTERNAL_ERROR ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Unknown, 9) // generic object error +#define ERRCODE_BASIC_NO_OBJECT ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 10) // Object variable not set +#define ERRCODE_BASIC_CANNOT_LOAD ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Create, 11) // Can't load module +#define ERRCODE_BASIC_BAD_INDEX ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Sbx, 12) // Invalid object index +#define ERRCODE_BASIC_NO_ACTIVE_OBJECT ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Access, 13) // No active view or document +#define ERRCODE_BASIC_BAD_PROP_VALUE ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 14) // Bad property value +#define ERRCODE_BASIC_PROP_READONLY ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Read, 15) // Property is read only +#define ERRCODE_BASIC_PROP_WRITEONLY ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Write, 16) // Property is write only +#define ERRCODE_BASIC_INVALID_OBJECT ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Access, 17) // Invalid object reference +#define ERRCODE_BASIC_NO_METHOD ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 18) // Property or Method unknown +#define ERRCODE_BASIC_INVALID_USAGE_OBJECT ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Access, 19) // Invalid object usage +#define ERRCODE_BASIC_NO_OLE ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Access, 20) // Class does not support OLE +#define ERRCODE_BASIC_BAD_METHOD ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 21) // Method not supported +#define ERRCODE_BASIC_OLE_ERROR ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 22) // OLE Automation Error +#define ERRCODE_BASIC_BAD_ACTION ErrCode( ErrCodeArea::Sbx, ErrCodeClass::NotSupported, 23) // Object doesn't support this action +#define ERRCODE_BASIC_NO_NAMED_ARGS ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 24) // Object doesn't support named args +#define ERRCODE_BASIC_BAD_LOCALE ErrCode( ErrCodeArea::Sbx, ErrCodeClass::NotSupported, 25) // Object doesn't support current locale setting +#define ERRCODE_BASIC_NAMED_NOT_FOUND ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 26) // Named argument not found +#define ERRCODE_BASIC_NOT_OPTIONAL ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 27) // Argument not optional +#define ERRCODE_BASIC_WRONG_ARGS ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Sbx, 28) // Invalid number of arguments +#define ERRCODE_BASIC_NOT_A_COLL ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 29) // Object not a collection + +#define ERRCODE_BASIC_NO_GOSUB ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 30 ) // Return without Gosub +#define ERRCODE_BASIC_REDO_FROM_START ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 31 ) // Redo form start (SB internal) +#define ERRCODE_BASIC_NO_MEMORY ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 32 ) // Out of memory +#define ERRCODE_BASIC_ALREADY_DIM ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 33 ) // Array already dimensioned +#define ERRCODE_BASIC_DUPLICATE_DEF ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 34 ) // Duplicate definition +#define ERRCODE_BASIC_VAR_UNDEFINED ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 35 ) // Variable undefined (SB) +#define ERRCODE_BASIC_USER_ABORT ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 36 ) // User interrupt occurred +#define ERRCODE_BASIC_BAD_RESUME ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 37 ) // Resume without error +#define ERRCODE_BASIC_STACK_OVERFLOW ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 38 ) // Out of stack space +#define ERRCODE_BASIC_BAD_DLL_LOAD ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 39 ) // Error in loading DLL +#define ERRCODE_BASIC_BAD_DLL_CALL ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 40 ) // Bad DLL calling convention +#define ERRCODE_BASIC_BAD_CHANNEL ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 41 ) // Bad file name or number +#define ERRCODE_BASIC_FILE_NOT_FOUND ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 42 ) // File not found +#define ERRCODE_BASIC_BAD_FILE_MODE ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 43 ) // Bad file mode +#define ERRCODE_BASIC_FILE_ALREADY_OPEN ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 44 ) // File already open +#define ERRCODE_BASIC_IO_ERROR ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 45 ) // Device I/O error +#define ERRCODE_BASIC_FILE_EXISTS ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 46 ) // File already exists +#define ERRCODE_BASIC_BAD_RECORD_LENGTH ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 47 ) // bad record length +#define ERRCODE_BASIC_DISK_FULL ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 48 ) // disk full +#define ERRCODE_BASIC_READ_PAST_EOF ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 49 ) // Input past end of file +#define ERRCODE_BASIC_BAD_RECORD_NUMBER ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 50 ) // Bad record number +#define ERRCODE_BASIC_TOO_MANY_FILES ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 51 ) // Too many files +#define ERRCODE_BASIC_NO_DEVICE ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 52 ) // Device not available +#define ERRCODE_BASIC_ACCESS_DENIED ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 53 ) // Permission denied +#define ERRCODE_BASIC_NOT_READY ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 54 ) // Disk not ready +#define ERRCODE_BASIC_NOT_IMPLEMENTED ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 55 ) // Feature not implemented +#define ERRCODE_BASIC_DIFFERENT_DRIVE ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 56 ) // No rename with different drive +#define ERRCODE_BASIC_ACCESS_ERROR ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 57 ) // Path/File access error +#define ERRCODE_BASIC_PATH_NOT_FOUND ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 58 ) // Path not found +#define ERRCODE_BASIC_BAD_PATTERN ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 59 ) // Invalid pattern string +#define ERRCODE_BASIC_IS_NULL ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 60 ) // Invalid use of Null + +#define ERRCODE_BASIC_DDE_ERROR ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 61 ) +#define ERRCODE_BASIC_DDE_WAITINGACK ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 62 ) +#define ERRCODE_BASIC_DDE_OUTOFCHANNELS ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 63 ) +#define ERRCODE_BASIC_DDE_NO_RESPONSE ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 64 ) +#define ERRCODE_BASIC_DDE_MULT_RESPONSES ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 65 ) +#define ERRCODE_BASIC_DDE_CHANNEL_LOCKED ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 66 ) +#define ERRCODE_BASIC_DDE_NOTPROCESSED ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 67 ) +#define ERRCODE_BASIC_DDE_TIMEOUT ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 68 ) +#define ERRCODE_BASIC_DDE_USER_INTERRUPT ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 69 ) +#define ERRCODE_BASIC_DDE_BUSY ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 70 ) +#define ERRCODE_BASIC_DDE_NO_DATA ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 71 ) +#define ERRCODE_BASIC_DDE_WRONG_DATA_FORMAT ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 72 ) +#define ERRCODE_BASIC_DDE_PARTNER_QUIT ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 73 ) +#define ERRCODE_BASIC_DDE_CONV_CLOSED ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 74 ) +#define ERRCODE_BASIC_DDE_NO_CHANNEL ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 75 ) +#define ERRCODE_BASIC_DDE_INVALID_LINK ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 76 ) +#define ERRCODE_BASIC_DDE_QUEUE_OVERFLOW ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 77 ) +#define ERRCODE_BASIC_DDE_LINK_ALREADY_EST ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 78 ) +#define ERRCODE_BASIC_DDE_LINK_INV_TOPIC ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 79 ) +#define ERRCODE_BASIC_DDE_DLL_NOT_FOUND ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 80 ) + +#define ERRCODE_BASIC_NEEDS_OBJECT ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 81 ) // Object required +#define ERRCODE_BASIC_BAD_ORDINAL ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 82 ) // Invalid ordinal +#define ERRCODE_BASIC_DLLPROC_NOT_FOUND ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 83 ) // Specified DLL function not found +#define ERRCODE_BASIC_BAD_CLIPBD_FORMAT ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 84 ) // Invalid clipboard format + +#define ERRCODE_BASIC_PROPERTY_NOT_FOUND ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 85 ) // Class not have property +#define ERRCODE_BASIC_METHOD_NOT_FOUND ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 86 ) // Class does not have method +#define ERRCODE_BASIC_ARG_MISSING ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 87 ) // Missing required argument +#define ERRCODE_BASIC_BAD_NUMBER_OF_ARGS ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 88 ) // Bad number of arguments +#define ERRCODE_BASIC_METHOD_FAILED ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 89 ) // Method failed +#define ERRCODE_BASIC_SETPROP_FAILED ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 90 ) // Unable to set property +#define ERRCODE_BASIC_GETPROP_FAILED ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 91 ) // Unable to get property + +// Compiler Errors (do not occur at runtime) +// These IDs can shift at any time + +#define ERRCODE_BASIC_UNEXPECTED ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Compiler, 92 ) // Unexpected symbol: xx +#define ERRCODE_BASIC_EXPECTED ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Compiler, 93 ) // Expected: xx +#define ERRCODE_BASIC_SYMBOL_EXPECTED ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Compiler, 94 ) // Symbol expected +#define ERRCODE_BASIC_VAR_EXPECTED ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Compiler, 95 ) // Variable expected +#define ERRCODE_BASIC_LABEL_EXPECTED ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Compiler, 96 ) // Label expected +#define ERRCODE_BASIC_LVALUE_EXPECTED ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Compiler, 97 ) // Lvalue expected +#define ERRCODE_BASIC_VAR_DEFINED ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Compiler, 98 ) // Variable xxx already defined +#define ERRCODE_BASIC_PROC_DEFINED ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Compiler, 99 ) // Procedure xx already defined +#define ERRCODE_BASIC_LABEL_DEFINED ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Compiler, 100 ) // Label xxx already defined +#define ERRCODE_BASIC_UNDEF_VAR ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Compiler, 101 ) // Variable xx undefined +#define ERRCODE_BASIC_UNDEF_ARRAY ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Compiler, 102 ) // Array or function xx undefined +#define ERRCODE_BASIC_UNDEF_PROC ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Compiler, 103 ) // Procedure xxx undefined +#define ERRCODE_BASIC_UNDEF_LABEL ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Compiler, 104 ) // Label xxx undefined +#define ERRCODE_BASIC_UNDEF_TYPE ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Compiler, 105 ) // Unknown user defined type xxx +#define ERRCODE_BASIC_BAD_EXIT ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Compiler, 106 ) // Exit XXX expected +#define ERRCODE_BASIC_BAD_BLOCK ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Compiler, 107 ) // Unterminated statement block: missing XX +#define ERRCODE_BASIC_BAD_BRACKETS ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Compiler, 108 ) // Parentheses do not match +#define ERRCODE_BASIC_BAD_DECLARATION ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Compiler, 109 ) // Symbol xx defined differently +#define ERRCODE_BASIC_BAD_PARAMETERS ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Compiler, 110 ) // Parameters do not match +#define ERRCODE_BASIC_BAD_CHAR_IN_NUMBER ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Compiler, 111 ) // Bad character in number +#define ERRCODE_BASIC_MUST_HAVE_DIMS ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Compiler, 112 ) // Array needs dimensioning +#define ERRCODE_BASIC_NO_IF ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Compiler, 113 ) // Else/Endif without If +#define ERRCODE_BASIC_NOT_IN_SUBR ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Compiler, 114 ) // xxx not allowed within a sub +#define ERRCODE_BASIC_NOT_IN_MAIN ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Compiler, 115 ) // xxx not allowed outside a sub +#define ERRCODE_BASIC_WRONG_DIMS ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Compiler, 116 ) // Dimensions do not match +#define ERRCODE_BASIC_BAD_OPTION ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Compiler, 117 ) // Unknown option: xxx +#define ERRCODE_BASIC_CONSTANT_REDECLARED ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Compiler, 118 ) // Constant xx redeclared +#define ERRCODE_BASIC_PROG_TOO_LARGE ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Compiler, 119 ) // Program is too large +#define ERRCODE_BASIC_NO_STRINGS_ARRAYS ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Compiler, 120 ) +#define ERRCODE_BASIC_EXCEPTION ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 121 ) + +#define ERRCODE_BASMGR_STDLIBOPEN ErrCode( ErrCodeArea::Sbx, 122) +#define ERRCODE_BASMGR_STDLIBSAVE ErrCode( ErrCodeArea::Sbx, 123) +#define ERRCODE_BASMGR_LIBLOAD ErrCode( ErrCodeArea::Sbx, 124) +#define ERRCODE_BASMGR_LIBCREATE ErrCode( ErrCodeArea::Sbx, 125) +#define ERRCODE_BASMGR_LIBSAVE ErrCode( ErrCodeArea::Sbx, 126) +#define ERRCODE_BASMGR_LIBDEL ErrCode( ErrCodeArea::Sbx, 127) +#define ERRCODE_BASMGR_MGROPEN ErrCode( ErrCodeArea::Sbx, 128) +#define ERRCODE_BASMGR_MGRSAVE ErrCode( ErrCodeArea::Sbx, 129) +#define ERRCODE_BASMGR_REMOVELIB ErrCode( ErrCodeArea::Sbx, 130) +#define ERRCODE_BASMGR_UNLOADLIB ErrCode( ErrCodeArea::Sbx, 131) + +#define ERRCODE_BASIC_COMPAT ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Runtime, 132 ) +#define ERRCODE_BASIC_ARRAY_FIX ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Compiler, 133 ) // This array is fixed +#define ERRCODE_BASIC_STRING_OVERFLOW ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Compiler, 134 ) // Out of string space +#define ERRCODE_BASIC_EXPR_TOO_COMPLEX ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Compiler, 135 ) // Expression too complex +#define ERRCODE_BASIC_OPER_NOT_PERFORM ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Compiler, 136 ) // Can't perform requested operation +#define ERRCODE_BASIC_TOO_MANY_DLL ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Compiler, 137 ) // Too many dll application clients +#define ERRCODE_BASIC_LOOP_NOT_INIT ErrCode( ErrCodeArea::Sbx, ErrCodeClass::Compiler, 138 ) // For loop not initialized + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/basic/sbmeth.hxx b/include/basic/sbmeth.hxx new file mode 100644 index 000000000..fefd84aed --- /dev/null +++ b/include/basic/sbmeth.hxx @@ -0,0 +1,88 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_BASIC_SBMETH_HXX +#define INCLUDED_BASIC_SBMETH_HXX + +#include <vcl/errcode.hxx> +#include <basic/sbxmeth.hxx> +#include <basic/sbdef.hxx> +#include <basic/basicdllapi.h> + +class SbModule; + +class BASIC_DLLPUBLIC SbMethod : public SbxMethod +{ + friend class SbiRuntime; + friend class SbiFactory; + friend class SbModule; + friend class SbClassModuleObject; + friend class SbiCodeGen; + friend class SbJScriptMethod; + friend class SbIfaceMapperMethod; + + SbxVariable* mCaller; // caller + SbModule* pMod; + BasicDebugFlags nDebugFlags; + sal_uInt16 nLine1, nLine2; + sal_uInt32 nStart; + bool bInvalid; + SbxArrayRef refStatics; + BASIC_DLLPRIVATE SbMethod( const OUString&, SbxDataType, SbModule* ); + BASIC_DLLPRIVATE SbMethod( const SbMethod& ); + virtual bool LoadData( SvStream&, sal_uInt16 ) override; + virtual bool StoreData( SvStream& ) const override; + virtual ~SbMethod() override; + +public: + SBX_DECL_PERSIST_NODATA(SBXID_BASICMETHOD,2); + virtual SbxInfo* GetInfo() override; + SbxArray* GetStatics(); + void ClearStatics(); + SbModule* GetModule() { return pMod; } + BasicDebugFlags GetDebugFlags() const { return nDebugFlags; } + void SetDebugFlags( BasicDebugFlags n ) { nDebugFlags = n; } + void GetLineRange( sal_uInt16&, sal_uInt16& ); + + // Interface to execute a method from the applications + ErrCode Call( SbxValue* pRet, SbxVariable* pCaller = nullptr ); + virtual void Broadcast( SfxHintId nHintId ) override; +}; + +typedef tools::SvRef<SbMethod> SbMethodRef; + +class SbIfaceMapperMethod final : public SbMethod +{ + friend class SbiRuntime; + + SbMethodRef mxImplMeth; + +public: + SbIfaceMapperMethod( const OUString& rName, SbMethod* pImplMeth ) + : SbMethod( rName, pImplMeth->GetType(), nullptr ) + , mxImplMeth( pImplMeth ) + {} + virtual ~SbIfaceMapperMethod() override; + SbMethod* getImplMethod() + { return mxImplMeth.get(); } +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/basic/sbmod.hxx b/include/basic/sbmod.hxx new file mode 100644 index 000000000..a71f7253a --- /dev/null +++ b/include/basic/sbmod.hxx @@ -0,0 +1,165 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_BASIC_SBMOD_HXX +#define INCLUDED_BASIC_SBMOD_HXX + +#include <config_options.h> +#include <basic/sbdef.hxx> +#include <basic/sbxobj.hxx> +#include <basic/sbxdef.hxx> +#include <basic/sbx.hxx> +#include <rtl/ustring.hxx> +#include <vector> +#include <deque> +#include <basic/basicdllapi.h> +#include <com/sun/star/uno/Reference.hxx> + +namespace com::sun::star::script { class XInvocation; } + +class SbMethod; +class SbProperty; +typedef std::deque< sal_uInt16 > SbiBreakpoints; +class SbiImage; +class SbClassModuleObject; +class CodeCompleteDataCache; + + +class ModuleInitDependencyMap; +struct ClassModuleRunInitItem; +struct SbClassData; + +class BASIC_DLLPUBLIC SbModule : public SbxObject +{ + friend class SbiCodeGen; + friend class SbMethod; + friend class SbiRuntime; + friend class StarBASIC; + friend class SbClassModuleObject; + + std::vector< OUString > mModuleVariableNames; + + BASIC_DLLPRIVATE static void implClearIfVarDependsOnDeletedBasic( SbxVariable* pVar, StarBASIC* pDeletedBasic ); + + SbModule(const SbModule&) = delete; + SbModule& operator=(const SbModule&) = delete; +protected: + css::uno::Reference< css::script::XInvocation > mxWrapper; + OUString aOUSource; + OUString aComment; + std::unique_ptr<SbiImage> pImage; // the Image + SbiBreakpoints* pBreaks; // Breakpoints + std::unique_ptr<SbClassData> pClassData; + bool mbVBACompat; + sal_Int32 mnType; + SbxObjectRef pDocObject; // an impl object ( used by Document Modules ) + bool bIsProxyModule; + + SAL_DLLPRIVATE static void implProcessModuleRunInit( ModuleInitDependencyMap& rMap, ClassModuleRunInitItem& rItem ); + SAL_DLLPRIVATE void StartDefinitions(); + SAL_DLLPRIVATE SbMethod* GetMethod( const OUString&, SbxDataType ); + SAL_DLLPRIVATE SbProperty* GetProperty( const OUString&, SbxDataType ); + SAL_DLLPRIVATE void GetProcedureProperty( const OUString&, SbxDataType ); + SAL_DLLPRIVATE void GetIfaceMapperMethod( const OUString&, SbMethod* ); + SAL_DLLPRIVATE void EndDefinitions( bool=false ); + SAL_DLLPRIVATE void Run( SbMethod* ); + SAL_DLLPRIVATE void RunInit(); + SAL_DLLPRIVATE void ClearPrivateVars(); + SAL_DLLPRIVATE void ClearVarsDependingOnDeletedBasic( StarBASIC* pDeletedBasic ); + SAL_DLLPRIVATE void GlobalRunInit( bool bBasicStart ); // for all modules + SAL_DLLPRIVATE void GlobalRunDeInit(); + SAL_DLLPRIVATE const sal_uInt8* FindNextStmnt( const sal_uInt8*, sal_uInt16&, sal_uInt16& ) const; + SAL_DLLPRIVATE const sal_uInt8* FindNextStmnt( const sal_uInt8*, sal_uInt16&, sal_uInt16&, + bool bFollowJumps, const SbiImage* pImg=nullptr ) const; + SAL_DLLPRIVATE virtual bool LoadData( SvStream&, sal_uInt16 ) override; + SAL_DLLPRIVATE virtual bool StoreData( SvStream& ) const override; + SAL_DLLPRIVATE virtual bool LoadCompleted() override; + SAL_DLLPRIVATE virtual void Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) override; + SAL_DLLPRIVATE void handleProcedureProperties( SfxBroadcaster& rBC, const SfxHint& rHint ); + virtual ~SbModule() override; +public: + SBX_DECL_PERSIST_NODATA(SBXID_BASICMOD,2); + SbModule( const OUString&, bool bCompat = false ); + SAL_DLLPRIVATE virtual void SetParent( SbxObject* ) override; + SAL_DLLPRIVATE virtual void Clear() override; + + SAL_DLLPRIVATE virtual SbxVariable* Find( const OUString&, SbxClassType ) override; + + const OUString& GetSource32() const { return aOUSource;} + void SetSource32( const OUString& r ); + + bool Compile(); + bool IsCompiled() const; + SAL_DLLPRIVATE const SbxObject* FindType( const OUString& aTypeName ) const; + + SAL_DLLPRIVATE bool IsBreakable( sal_uInt16 nLine ) const; + SAL_DLLPRIVATE bool IsBP( sal_uInt16 nLine ) const; + bool SetBP( sal_uInt16 nLine ); + bool ClearBP( sal_uInt16 nLine ); + void ClearAllBP(); + + // Store only image, no source (needed for new password protection) + SAL_DLLPRIVATE void StoreBinaryData( SvStream& ); + SAL_DLLPRIVATE void LoadBinaryData( SvStream& ); + SAL_DLLPRIVATE bool ExceedsLegacyModuleSize(); + SAL_DLLPRIVATE void fixUpMethodStart( bool bCvtToLegacy, SbiImage* pImg = nullptr ) const; + SAL_DLLPRIVATE bool HasExeCode(); + bool IsVBACompat() const { return mbVBACompat;} + SAL_DLLPRIVATE void SetVBACompat( bool bCompat ); + sal_Int32 GetModuleType() const { return mnType; } + void SetModuleType( sal_Int32 nType ) { mnType = nType; } + bool isProxyModule() const { return bIsProxyModule; } + SAL_DLLPRIVATE void AddVarName( const OUString& aName ); + SAL_DLLPRIVATE void RemoveVars(); + css::uno::Reference< css::script::XInvocation > const & GetUnoModule(); + bool createCOMWrapperForIface( css::uno::Any& o_rRetAny, SbClassModuleObject* pProxyClassModuleObject ); + void GetCodeCompleteDataFromParse(CodeCompleteDataCache& aCache); + const SbxArrayRef& GetMethods() const { return pMethods;} + SbMethod* FindMethod( const OUString&, SbxClassType ); + static OUString GetKeywordCase( const OUString& sKeyword ); +}; + +typedef tools::SvRef<SbModule> SbModuleRef; +typedef std::vector<SbModuleRef> SbModules; + +// Object class for instances of class modules +class UNLESS_MERGELIBS(BASIC_DLLPUBLIC) SbClassModuleObject final : public SbModule +{ + SbModule* mpClassModule; + bool mbInitializeEventDone; + +public: + SbClassModuleObject( SbModule* pClassModule ); + virtual ~SbClassModuleObject() override; + + // Overridden to support NameAccess etc. + virtual SbxVariable* Find( const OUString&, SbxClassType ) override; + + virtual void Notify( SfxBroadcaster&, const SfxHint& rHint ) override; + + SbModule* getClassModule() + { return mpClassModule; } + + void triggerInitializeEvent(); + void triggerTerminateEvent(); +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/basic/sbstar.hxx b/include/basic/sbstar.hxx new file mode 100644 index 000000000..1629ab16c --- /dev/null +++ b/include/basic/sbstar.hxx @@ -0,0 +1,157 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_BASIC_SBSTAR_HXX +#define INCLUDED_BASIC_SBSTAR_HXX + +#include <basic/sbx.hxx> +#include <basic/sbxobj.hxx> +#include <basic/sbmod.hxx> +#include <rtl/ustring.hxx> +#include <tools/link.hxx> + +#include <basic/sbdef.hxx> +#include <basic/basicdllapi.h> + +namespace com::sun::star::frame { class XModel; } +namespace com::sun::star::script { struct ModuleInfo; } + +class SbMethod; + +class BASIC_DLLPUBLIC StarBASIC final : public SbxObject +{ + friend class SbiScanner; + friend class SbiExpression; // Access to RTL + friend class SbiInstance; // runtime instance + friend class SbiRuntime; // currently running procedure + friend class DocBasicItem; + + SbModules pModules; // List of all modules + SbxObjectRef pRtl; // Runtime Library + SbxArrayRef xUnoListeners; // Listener handled by CreateUnoListener + + // Handler-Support: + Link<StarBASIC*,bool> aErrorHdl; // Error handler + Link<StarBASIC*,BasicDebugFlags> aBreakHdl; // Breakpoint handler + bool bNoRtl; // if true: do not search RTL + bool bBreak; // if true: Break, otherwise Step + bool bDocBasic; + bool bVBAEnabled; + bool bQuit; + + SbxObjectRef pVBAGlobals; + + BASIC_DLLPRIVATE void implClearDependingVarsOnDelete( StarBASIC* pDeletedBasic ); + bool CError( ErrCode, const OUString&, sal_Int32, sal_Int32, sal_Int32 ); + BASIC_DLLPRIVATE bool RTError( ErrCode, const OUString& rMsg, sal_Int32, sal_Int32, sal_Int32 ); + BASIC_DLLPRIVATE BasicDebugFlags BreakPoint( sal_Int32 nLine, sal_Int32 nCol1, sal_Int32 nCol2 ); + BASIC_DLLPRIVATE BasicDebugFlags StepPoint( sal_Int32 nLine, sal_Int32 nCol1, sal_Int32 nCol2 ); + virtual bool LoadData( SvStream&, sal_uInt16 ) override; + virtual bool StoreData( SvStream& ) const override; + bool ErrorHdl(); + BasicDebugFlags BreakHdl(); + virtual ~StarBASIC() override; + +public: + + SBX_DECL_PERSIST_NODATA(SBXID_BASIC,1); + + StarBASIC( StarBASIC* pParent = nullptr, bool bIsDocBasic = false ); + + // #51727 SetModified overridden so that the Modified-State is + // not delivered to Parent. + virtual void SetModified( bool ) override; + + virtual void Insert( SbxVariable* ) override; + using SbxObject::Remove; + virtual void Remove( SbxVariable* ) override; + virtual void Clear() override; + + // Compiler-Interface + SbModule* MakeModule( const OUString& rName, const OUString& rSrc ); + SbModule* MakeModule( const OUString& rName, const css::script::ModuleInfo& mInfo, const OUString& rSrc ); + static void Stop(); + static void Error( ErrCode, const OUString& rMsg = {} ); + static void FatalError( ErrCode ); + static void FatalError( ErrCode, const OUString& rMsg ); + static bool IsRunning(); + static ErrCode GetErrBasic(); + // #66536 make additional message accessible by RTL function Error + static OUString GetErrorMsg(); + static sal_Int32 GetErl(); + + virtual SbxVariable* Find( const OUString&, SbxClassType ) override; + virtual bool Call( const OUString&, SbxArray* = nullptr ) override; + + SbModules& GetModules() { return pModules; } + SbxObject* GetRtl() { return pRtl.get(); } + SbModule* FindModule( std::u16string_view ); + // Run init code of all modules (including the inserted Doc-Basics) + void InitAllModules( StarBASIC const * pBasicNotToInit = nullptr ); + void DeInitAllModules(); + void ClearAllModuleVars(); + + // Calls for error and break handler + static sal_uInt16 GetLine(); + static sal_uInt16 GetCol1(); + static sal_uInt16 GetCol2(); + static void SetErrorData( ErrCode nCode, sal_uInt16 nLine, + sal_uInt16 nCol1, sal_uInt16 nCol2 ); + + // Specific to error handler + static void MakeErrorText( ErrCode, std::u16string_view aMsg ); + static const OUString& GetErrorText(); + static ErrCode const & GetErrorCode(); + static sal_uInt16 GetVBErrorCode( ErrCode nError ); + static ErrCode GetSfxFromVBError( sal_uInt16 nError ); + bool IsBreak() const { return bBreak; } + + static Link<StarBASIC*,bool> const & GetGlobalErrorHdl(); + static void SetGlobalErrorHdl( const Link<StarBASIC*,bool>& rNewHdl ); + + static void SetGlobalBreakHdl( const Link<StarBASIC*,BasicDebugFlags>& rNewHdl ); + + SbxArrayRef const & getUnoListeners(); + + static SbxBase* FindSBXInCurrentScope( const OUString& rName ); + static SbMethod* GetActiveMethod( sal_uInt16 nLevel = 0 ); + static SbModule* GetActiveModule(); + void SetVBAEnabled( bool bEnabled ); + bool isVBAEnabled() const; + + const SbxObjectRef& getRTL() const { return pRtl; } + bool IsDocBasic() const { return bDocBasic; } + SbxVariable* VBAFind( const OUString& rName, SbxClassType t ); + bool GetUNOConstant( const OUString& rName, css::uno::Any& aOut ); + void QuitAndExitApplication(); + bool IsQuitApplication() const { return bQuit; }; + + SbxObject* getVBAGlobals( ); + + static css::uno::Reference< css::frame::XModel > + GetModelFromBasic( SbxObject* pBasic ); + + static void DetachAllDocBasicItems(); +}; + +typedef tools::SvRef<StarBASIC> StarBASICRef; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/basic/sbuno.hxx b/include/basic/sbuno.hxx new file mode 100644 index 000000000..4c53215d9 --- /dev/null +++ b/include/basic/sbuno.hxx @@ -0,0 +1,47 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_BASIC_SBUNO_HXX +#define INCLUDED_BASIC_SBUNO_HXX + +#include <com/sun/star/uno/Type.hxx> +#include <basic/sbxvar.hxx> +#include <basic/basicdllapi.h> + +namespace com::sun::star::uno { class Any; } +namespace com::sun::star::beans { struct Property; } + +class SbxObject; + +// Returns a SbxObject that wraps a Uno Interface +// Implementation in basic/source/classes/sbunoobj.cxx +BASIC_DLLPUBLIC SbxObjectRef GetSbUnoObject( const OUString& aName, const css::uno::Any& aUnoObj_ ); + +// Force creation of all properties for debugging +BASIC_DLLPUBLIC void createAllObjectProperties( SbxObject* pObj ); +BASIC_DLLPUBLIC void SetSbUnoObjectDfltPropName( SbxObject* pObj ); + +BASIC_DLLPUBLIC css::uno::Any sbxToUnoValue( const SbxValue* pVar ); +css::uno::Any sbxToUnoValue( const SbxValue* pVar, const css::uno::Type& rType, css::beans::Property const * pUnoProperty = nullptr ); + +BASIC_DLLPUBLIC void unoToSbxValue( SbxVariable* pVar, const css::uno::Any& aValue ); + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/basic/sbx.hxx b/include/basic/sbx.hxx new file mode 100644 index 000000000..7997f53ef --- /dev/null +++ b/include/basic/sbx.hxx @@ -0,0 +1,213 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_BASIC_SBX_HXX +#define INCLUDED_BASIC_SBX_HXX + +#include <config_options.h> +#include <tools/ref.hxx> +#include <svl/hint.hxx> + +#include <basic/sbxdef.hxx> +#include <basic/sbxobj.hxx> +#include <basic/basicdllapi.h> + +#include <utility> +#include <vector> +#include <memory> + +class SvStream; + +class SfxBroadcaster; + +// Parameter information +struct SbxParamInfo +{ + const OUString aName; // Name of the parameter + SbxDataType eType; // Data type + SbxFlagBits nFlags; // Flag-Bits + sal_uInt32 nUserData; // IDs etc. + SbxParamInfo( OUString s, SbxDataType t, SbxFlagBits n ) + : aName(std::move( s )), eType( t ), nFlags( n ), nUserData( 0 ) {} +}; + +typedef std::vector<std::unique_ptr<SbxParamInfo>> SbxParams; + +class UNLESS_MERGELIBS(BASIC_DLLPUBLIC) SbxInfo final : public SvRefBase +{ + friend class SbxVariable; + friend class SbMethod; + + OUString aComment; + OUString aHelpFile; + sal_uInt32 nHelpId; + SbxParams m_Params; + + SbxInfo(SbxInfo const&) = delete; + void operator=(SbxInfo const&) = delete; + + void LoadData( SvStream&, sal_uInt16 ); + void StoreData( SvStream& ) const; + virtual ~SbxInfo() override; +public: + SbxInfo(); + SbxInfo( OUString , sal_uInt32 ); + + void AddParam( const OUString&, SbxDataType, SbxFlagBits=SbxFlagBits::Read ); + const SbxParamInfo* GetParam( sal_uInt16 n ) const; // index starts with 1! + const OUString& GetComment() const { return aComment; } + const OUString& GetHelpFile() const { return aHelpFile; } + sal_uInt32 GetHelpId() const { return nHelpId; } + + void SetComment( const OUString& r ) { aComment = r; } +}; + +class BASIC_DLLPUBLIC SbxHint final : public SfxHint +{ + SbxVariable* pVar; +public: + SbxHint( SfxHintId n, SbxVariable* v ) : SfxHint( n ), pVar( v ) {} + SbxVariable* GetVar() const { return pVar; } +}; + +// SbxArray is an unidimensional, dynamic Array +// The variables convert from SbxVariablen. Put()/Insert() into the +// declared datatype, if they are not SbxVARIANT. + +struct SbxVarEntry; + +class BASIC_DLLPUBLIC SbxArray : public SbxBase +{ +// #100883 Method to set method directly to parameter array + friend class SbMethod; + friend class SbClassModuleObject; + friend SbxObjectRef cloneTypeObjectImpl( const SbxObject& rTypeObj ); + BASIC_DLLPRIVATE void PutDirect( SbxVariable* pVar, sal_uInt32 nIdx ); + + std::vector<SbxVarEntry> mVarEntries; // The variables + SbxDataType eType; // Data type of the array + +protected: + virtual ~SbxArray() override; + virtual bool LoadData( SvStream&, sal_uInt16 ) override; + virtual bool StoreData( SvStream& ) const override; + +public: + SBX_DECL_PERSIST_NODATA(SBXID_ARRAY,1); + SbxArray( SbxDataType=SbxVARIANT ); + SbxArray( const SbxArray& ) = delete; + SbxArray& operator=( const SbxArray& ); + virtual void Clear() override; + sal_uInt32 Count() const; + virtual SbxDataType GetType() const override; + SbxVariableRef& GetRef(sal_uInt32); + SbxVariable* Get(sal_uInt32); + void Put(SbxVariable*, sal_uInt32); + void Insert(SbxVariable*, sal_uInt32); + void Remove( sal_uInt32 ); + void Remove( SbxVariable const * ); + void Merge( SbxArray* ); + OUString GetAlias(sal_uInt32); + void PutAlias(const OUString&, sal_uInt32); + SbxVariable* Find( const OUString&, SbxClassType ); +}; + +// SbxDimArray is an array that can dimensioned using BASIC conventions. +struct SbxDim { // an array-dimension: + sal_Int32 nLbound, nUbound; // Limitations + sal_Int32 nSize; // Number of elements +}; + +class BASIC_DLLPUBLIC SbxDimArray final : public SbxArray +{ + std::vector<SbxDim> m_vDimensions; // Dimension table + BASIC_DLLPRIVATE void AddDimImpl(sal_Int32, sal_Int32, bool bAllowSize0); + bool mbHasFixedSize; + + sal_uInt32 Offset(const sal_Int32*); + sal_uInt32 Offset(SbxArray*); + virtual bool LoadData( SvStream&, sal_uInt16 ) override; + virtual bool StoreData( SvStream& ) const override; + virtual ~SbxDimArray() override; +public: + SBX_DECL_PERSIST_NODATA(SBXID_DIMARRAY,1); + SbxDimArray( SbxDataType=SbxVARIANT ); + SbxDimArray( const SbxDimArray& ) = delete; + SbxDimArray& operator=( const SbxDimArray& ); + virtual void Clear() override; + SbxVariable* Get( SbxArray* ); + + using SbxArray::GetRef; + using SbxArray::Get; + SbxVariable* Get(const sal_Int32*); + using SbxArray::Put; + void Put(SbxVariable*, const sal_Int32*); + sal_Int32 GetDims() const { return m_vDimensions.size(); } + void AddDim(sal_Int32, sal_Int32); + void unoAddDim(sal_Int32, sal_Int32); + bool GetDim(sal_Int32, sal_Int32&, sal_Int32&) const; + bool hasFixedSize() const { return mbHasFixedSize; }; + void setHasFixedSize( bool bHasFixedSize ) {mbHasFixedSize = bHasFixedSize; }; +}; + +class SbxCollection : public SbxObject +{ + void Initialize(); +protected: + virtual ~SbxCollection() override; + virtual bool LoadData( SvStream&, sal_uInt16 ) override; + virtual void Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) override; + // Overridable methods (why not pure virtual?): + virtual void CollAdd( SbxArray* pPar ); + void CollItem( SbxArray* pPar ); + virtual void CollRemove( SbxArray* pPar ); + +public: + SBX_DECL_PERSIST_NODATA(SBXID_COLLECTION,1); + SbxCollection(); + SbxCollection( const SbxCollection& ); + SbxCollection& operator=( const SbxCollection& ); + virtual SbxVariable* Find( const OUString&, SbxClassType ) override; + virtual void Clear() override; +}; + +class SbxStdCollection final : public SbxCollection +{ + OUString aElemClass; + bool bAddRemoveOk; + virtual ~SbxStdCollection() override; + virtual bool LoadData( SvStream&, sal_uInt16 ) override; + virtual bool StoreData( SvStream& ) const override; + virtual void CollAdd( SbxArray* pPar ) override; + virtual void CollRemove( SbxArray* pPar ) override; +public: + SBX_DECL_PERSIST_NODATA(SBXID_FIXCOLLECTION,1); + SbxStdCollection(); + SbxStdCollection( const SbxStdCollection& ); + SbxStdCollection& operator=( const SbxStdCollection& ); + virtual void Insert( SbxVariable* ) override; +}; + +typedef tools::SvRef<SbxArray> SbxArrayRef; +typedef tools::SvRef<SbxInfo> SbxInfoRef; +typedef tools::SvRef<SbxDimArray> SbxDimArrayRef; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/basic/sbxcore.hxx b/include/basic/sbxcore.hxx new file mode 100644 index 000000000..e5f726e8d --- /dev/null +++ b/include/basic/sbxcore.hxx @@ -0,0 +1,135 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_BASIC_SBXCORE_HXX +#define INCLUDED_BASIC_SBXCORE_HXX + +#include <basic/basicdllapi.h> +#include <basic/sbxdef.hxx> +#include <rtl/ustring.hxx> +#include <tools/ref.hxx> + +class SvStream; +class ErrCode; + +// The following Macro defines four (five) necessary methods within a +// SBX object. LoadPrivateData() and StorePrivateData() must be implemented. +// They are necessary for loading/storing the data of derived classes. +// Load() and Store() must not be overridden. + +// This version of the Macros does not define Load/StorePrivateData()-methods +#define SBX_DECL_PERSIST_NODATA( nSbxId, nVer ) \ + virtual sal_uInt16 GetVersion() const override { return nVer; } \ + virtual sal_uInt16 GetSbxId() const override { return nSbxId; } + +class SbxFactory; +class SbxObject; +class SbxBase; + +typedef tools::SvRef<SbxBase> SbxBaseRef; +typedef tools::SvRef<SbxObject> SbxObjectRef; + +class BASIC_DLLPUBLIC SbxBase : virtual public SvRefBase +{ + virtual bool LoadData( SvStream&, sal_uInt16 ) = 0; + virtual bool StoreData( SvStream& ) const = 0; +protected: + SbxFlagBits nFlags; // Flag-Bits + + SbxBase(); + SbxBase( const SbxBase& ); + SbxBase& operator=( const SbxBase& ); + virtual ~SbxBase() override; + + virtual sal_uInt16 GetVersion() const = 0; + virtual sal_uInt16 GetSbxId() const = 0; + +public: + inline void SetFlags( SbxFlagBits n ); + inline SbxFlagBits GetFlags() const; + inline void SetFlag( SbxFlagBits n ); + inline void ResetFlag( SbxFlagBits n ); + inline bool IsSet( SbxFlagBits n ) const; + inline bool IsReset( SbxFlagBits n ) const; + inline bool CanRead() const; + inline bool CanWrite() const; + inline bool IsModified() const; + inline bool IsHidden() const; + inline bool IsVisible() const; + + virtual bool IsFixed() const; + virtual void SetModified( bool ); + + virtual SbxDataType GetType() const; + + virtual void Clear() = 0; + + static SbxBaseRef Load( SvStream& ); + bool Store( SvStream& ); + virtual bool LoadCompleted(); + + static ErrCode const & GetError(); + static void SetError( ErrCode ); + static bool IsError(); + static void ResetError(); + + // Set the factory for Load/Store/Create + static void AddFactory( SbxFactory* ); + static void RemoveFactory( SbxFactory const * ); + + static SbxBaseRef Create( sal_uInt16, sal_uInt32 ); + static SbxObjectRef CreateObject( const OUString& ); +}; + +inline void SbxBase::SetFlags( SbxFlagBits n ) +{ nFlags = n; } + +inline SbxFlagBits SbxBase::GetFlags() const +{ return nFlags; } + +inline void SbxBase::SetFlag( SbxFlagBits n ) +{ nFlags |= n; } + +inline void SbxBase::ResetFlag( SbxFlagBits n ) +{ nFlags &= ~n; } + +inline bool SbxBase::IsSet( SbxFlagBits n ) const +{ return ( nFlags & n ) != SbxFlagBits::NONE; } + +inline bool SbxBase::IsReset( SbxFlagBits n ) const +{ return ( nFlags & n ) == SbxFlagBits::NONE; } + +inline bool SbxBase::CanRead() const +{ return IsSet( SbxFlagBits::Read ); } + +inline bool SbxBase::CanWrite() const +{ return IsSet( SbxFlagBits::Write ); } + +inline bool SbxBase::IsModified() const +{ return IsSet( SbxFlagBits::Modified ); } + +inline bool SbxBase::IsHidden() const +{ return IsSet( SbxFlagBits::Hidden ); } + +inline bool SbxBase::IsVisible() const +{ return IsReset( SbxFlagBits::Invisible ); } + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/basic/sbxdef.hxx b/include/basic/sbxdef.hxx new file mode 100644 index 000000000..e85f1a209 --- /dev/null +++ b/include/basic/sbxdef.hxx @@ -0,0 +1,219 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + + +#ifndef INCLUDED_BASIC_SBXDEF_HXX +#define INCLUDED_BASIC_SBXDEF_HXX + +#include <o3tl/typed_flags_set.hxx> +#include <sal/types.h> + +enum class SbxClassType { // SBX-class-IDs (order is important!) + DontCare = 1, // don't care (search, not 0 due to StarBASIC) + Array, // Array of SbxVariables + Value, // simple value + Variable, // Variable (from here there is Broadcaster) + Method, // Method (Function or Sub) + Property, // Property + Object // Object +}; + +enum SbxDataType { + SbxEMPTY = 0, // * Uninitialized + SbxNULL = 1, // * Contains no valid data + SbxINTEGER = 2, // * Integer (sal_Int16) + SbxLONG = 3, // * Long integer (sal_Int32) + SbxSINGLE = 4, // * Single-precision floating point number (float) + SbxDOUBLE = 5, // * Double-precision floating point number (double) + SbxCURRENCY = 6, // Currency (sal_Int64) + SbxDATE = 7, // * Date (double) + SbxSTRING = 8, // * String (StarView) + SbxOBJECT = 9, // * SbxBase object pointer + SbxERROR = 10, // * Error (sal_uInt16) + SbxBOOL = 11, // * Boolean (0 or -1) + + SbxVARIANT = 12, // * Display for variant datatype + SbxDATAOBJECT = 13, // * Common data object w/o ref count + + SbxCHAR = 16, // * signed char + SbxBYTE = 17, // * unsigned char + SbxUSHORT = 18, // * unsigned short (sal_uInt16) + SbxULONG = 19, // * unsigned long (sal_uInt32) + + SbxINT = 22, // * signed machine-dependent int + SbxUINT = 23, // * unsigned machine-dependent int + + SbxVOID = 24, // * no value (= SbxEMPTY) + SbxHRESULT = 25, // HRESULT + SbxPOINTER = 26, // generic pointer + SbxDIMARRAY = 27, // dimensioned array + SbxCARRAY = 28, // C style array + SbxUSERDEF = 29, // user defined + SbxLPSTR = 30, // * null terminated string + + SbxLPWSTR = 31, // wide null terminated string + SbxCoreSTRING = 32, // from 1997-4-10 for GetCoreString(), only for converting< + + SbxWSTRING = 33, // from 2000-10-4 Reimplemented for backwards compatibility (#78919) + SbxWCHAR = 34, // from 2000-10-4 Reimplemented for backwards compatibility (#78919) + SbxSALINT64 = 35, // for currency internal, signed 64-bit int and UNO hyper + SbxSALUINT64= 36, // for currency internal, unsigned 64-bit int and UNO unsigned hyper + SbxDECIMAL = 37, // for UNO/automation Decimal + + SbxVECTOR = 0x1000, // simple counted array + SbxARRAY = 0x2000, // array + SbxBYREF = 0x4000, // access by reference + + // tdf#79426, tdf#125180 + SbxMISSING = 0x8000, // Parameter is missing +}; + +const sal_uInt32 SBX_TYPE_WITH_EVENTS_FLAG = 0x10000; +const sal_uInt32 SBX_TYPE_DIM_AS_NEW_FLAG = 0x20000; +const sal_uInt32 SBX_FIXED_LEN_STRING_FLAG = 0x10000; // same value as above as no conflict possible +const sal_uInt32 SBX_TYPE_VAR_TO_DIM_FLAG = 0x40000; + +enum SbxOperator { + // Arithmetical: + SbxEXP, // this ^ var + SbxMUL, // this * var + SbxDIV, // this / var + SbxMOD, // this MOD var (max INT32!) + SbxPLUS, // this + var + SbxMINUS, // this - var + SbxNEG, // -this (var is ignored) + SbxIDIV, // this / var (both operands max. sal_Int32!) + // Boolean operators (max sal_Int32!): + // Boolean operators (TODO deprecate this limit: max INT32!) + SbxAND, // this & var + SbxOR, // this | var + SbxXOR, // this ^ var + SbxEQV, // ~this ^ var + SbxIMP, // ~this | var + SbxNOT, // ~this (var is ignored) + + // String concatenation: + SbxCAT, // this & var (VBA: this + var) + + // Comparisons: + SbxEQ, // this = var + SbxNE, // this <> var + SbxLT, // this < var + SbxGT, // this > var + SbxLE, // this <= var + SbxGE // this >= var +}; + +enum class SbxNameType { // Type of the questioned name of a variable + NONE, // plain name + CaseInsensitive, // plain name - case insensitive + ShortTypes, // Name%(A%,B$) +}; + + +// Flag-Bits: +enum class SbxFlagBits { + NONE = 0x0000, + Read = 0x0001, // Read permission + Write = 0x0002, // Write permission + ReadWrite = 0x0003, // Read/Write permission + DontStore = 0x0004, // Don't store object + Modified = 0x0008, // Object was changed + Fixed = 0x0010, // Fixed data type (SbxVariable) + Const = 0x0020, // Definition of const value + Optional = 0x0040, // Parameter is optional + Hidden = 0x0080, // Element is invisible + Invisible = 0x0100, // Element is not found by Find() + ExtSearch = 0x0200, // Object is searched completely + ExtFound = 0x0400, // Variable was found through extended search + GlobalSearch = 0x0800, // Global search via Parents + Reserved = 0x1000, // reserved + Private = 0x1000, // #110004, #112015, cannot conflict with SbxFlagBits::Reserved + NoBroadcast = 0x2000, // No broadcast on Get/Put + Reference = 0x4000, // Parameter is Reference (DLL-call) + NoModify = 0x8000, // SetModified is suppressed + WithEvents = 0x0080, // Same value as unused SbxFlagBits::Hidden + DimAsNew = 0x0800, // Same value as SbxFlagBits::GlobalSearch, cannot conflict as one + // is used for objects, the other for variables only + VarToDim = 0x2000, // Same value as SbxFlagBits::NoBroadcast, cannot conflict as + // used for variables without broadcaster only +}; +namespace o3tl +{ + template<> struct typed_flags<SbxFlagBits> : is_typed_flags<SbxFlagBits, 0xffff> {}; +} + +// List of all creators for Load/Store + +constexpr auto SBXCR_SBX = 0x20584253; // SBX(blank) + +// List of predefined SBX-IDs. New SBX-IDs must be precisely defined so that +// they are unique within the Stream and appropriate Factory. + +constexpr auto SBXID_VALUE = 0x4E4E; // NN: SbxValue +constexpr auto SBXID_VARIABLE = 0x4156; // VA: SbxVariable +constexpr auto SBXID_ARRAY = 0x5241; // AR: SbxArray +constexpr auto SBXID_DIMARRAY = 0x4944; // DI: SbxDimArray +constexpr auto SBXID_OBJECT = 0x424F; // OB: SbxObject +constexpr auto SBXID_COLLECTION = 0x4F43; // CO: SbxCollection +constexpr auto SBXID_FIXCOLLECTION = 0x4346; // FC: SbxStdCollection +constexpr auto SBXID_METHOD = 0x454D; // ME: SbxMethod +constexpr auto SBXID_PROPERTY = 0x5250; // PR: SbxProperty + +// StarBASIC restricts the base data type to different intervals. +// These intervals are fixed to create 'portability and independent +// of the implementation. Only type double is greedy and takes +// what it gets. + +constexpr auto SbxMAXCHAR = u'\xFFFF'; +constexpr auto SbxMINCHAR = 0; +constexpr auto SbxMAXBYTE = 255; +constexpr auto SbxMAXINT = 32767; +constexpr auto SbxMININT = -32768; +constexpr sal_uInt16 SbxMAXUINT = 65535; +constexpr auto SbxMAXLNG = 2147483647; +constexpr sal_Int32 SbxMINLNG = -2147483647-1; +constexpr sal_uInt32 SbxMAXULNG = 0xffffffff; + + // Currency stored as SbxSALINT64 == sal_Int64 + // value range limits are ~(2^63 - 1)/10000 + // fixed precision has 4 digits right of decimal pt +constexpr auto CURRENCY_FACTOR = 10000; +constexpr auto CURRENCY_FACTOR_SQUARE = 100000000; + +// TODO effective MAX/MINCURR limits: +// true value ( 922337203685477.5807) is too precise for correct comparison to 64bit double +constexpr auto SbxMAXCURR = 922337203685477.5807; +constexpr auto SbxMINCURR = -922337203685477.5808; + +constexpr auto SbxMAXSNG = 3.402823e+38; +constexpr auto SbxMINSNG = -3.402823e+38; +constexpr auto SbxMAXSNG2 = 1.175494351e-38; +constexpr auto SbxMINSNG2 = -1.175494351e-38; + +// Max valid offset index of a Sbx-Array (due to 64K limit) +constexpr auto SBX_MAXINDEX = 0x3FF0; +constexpr auto SBX_MAXINDEX32 = SbxMAXLNG; + +// The numeric values of sal_True and FALSE +enum SbxBOOL { SbxFALSE = 0, SbxTRUE = -1 }; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/basic/sbxmeth.hxx b/include/basic/sbxmeth.hxx new file mode 100644 index 000000000..b32a40f14 --- /dev/null +++ b/include/basic/sbxmeth.hxx @@ -0,0 +1,43 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_BASIC_SBXMETH_HXX +#define INCLUDED_BASIC_SBXMETH_HXX + +#include <basic/sbxvar.hxx> +#include <basic/basicdllapi.h> + +class BASIC_DLLPUBLIC SbxMethod : public SbxVariable +{ + bool mbIsRuntimeFunction; + SbxDataType mbRuntimeFunctionReturnType; +public: + SBX_DECL_PERSIST_NODATA(SBXID_METHOD,1); + SbxMethod( const OUString& r, SbxDataType t, bool bIsRuntimeFunction=false ); + SbxMethod( const SbxMethod& r ); + virtual ~SbxMethod() override; + SbxMethod& operator=( const SbxMethod& r ) { SbxVariable::operator=( r ); return *this; } + virtual SbxClassType GetClass() const override; + bool IsRuntimeFunction() const { return mbIsRuntimeFunction; } + SbxDataType GetRuntimeFunctionReturnType() const{ return mbRuntimeFunctionReturnType; } +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/basic/sbxobj.hxx b/include/basic/sbxobj.hxx new file mode 100644 index 000000000..10d4c074c --- /dev/null +++ b/include/basic/sbxobj.hxx @@ -0,0 +1,85 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_BASIC_SBXOBJ_HXX +#define INCLUDED_BASIC_SBXOBJ_HXX + +#include <svl/lstner.hxx> +#include <basic/sbxvar.hxx> +#include <basic/basicdllapi.h> + + +class SbxProperty; + +class BASIC_DLLPUBLIC SbxObject : public SbxVariable, public SfxListener +{ + BASIC_DLLPRIVATE SbxArray* FindVar( SbxVariable const *, sal_uInt32& ); +protected: + SbxArrayRef pMethods; // Methods + SbxArrayRef pProps; // Properties + SbxArrayRef pObjs; // Objects + SbxProperty* pDfltProp; // Default-Property + OUString aClassName; // Classname + OUString aDfltPropName; + virtual bool LoadData( SvStream&, sal_uInt16 ) override; + virtual bool StoreData( SvStream& ) const override; + virtual ~SbxObject() override; + virtual void Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) override; +public: + SBX_DECL_PERSIST_NODATA(SBXID_OBJECT,1); + SbxObject( const OUString& rClassname ); + SbxObject( const SbxObject& ); + SbxObject& operator=( const SbxObject& ); + virtual SbxDataType GetType() const override; + virtual SbxClassType GetClass() const override; + virtual void Clear() override; + + virtual bool IsClass( const OUString& ) const; + const OUString& GetClassName() const { return aClassName; } + void SetClassName( const OUString &rNew ) { aClassName = rNew; } + // Default-Property + SbxProperty* GetDfltProperty(); + void SetDfltProperty( const OUString& r ); + // Search for an element + virtual SbxVariable* Find( const OUString&, SbxClassType ); + SbxVariable* FindQualified( const OUString&, SbxClassType ); + // Quick-Call-Interface for Methods + virtual bool Call( const OUString&, SbxArray* = nullptr ); + // Execution of DDE-Commands + SbxVariable* Execute( const OUString& ); + // Manage elements + SbxVariable* Make( const OUString&, SbxClassType, SbxDataType, bool bIsRuntimeFunction = false ); + virtual void Insert( SbxVariable* ); + // AB 23.4.1997, Optimization, Insertion without check for duplicate Entries and + // without Broadcasts, only used in SO2/auto.cxx + void QuickInsert( SbxVariable* ); + void Remove( const OUString&, SbxClassType ); + virtual void Remove( SbxVariable* ); + + // Direct access on arrays + SbxArray* GetMethods() { return pMethods.get(); } + SbxArray* GetProperties() { return pProps.get(); } + SbxArray* GetObjects() { return pObjs.get(); } + // Debugging + void Dump( SvStream&, bool bDumpAll ); +}; + +#endif // INCLUDED_BASIC_SBXOBJ_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/basic/sbxvar.hxx b/include/basic/sbxvar.hxx new file mode 100644 index 000000000..0c5f84b60 --- /dev/null +++ b/include/basic/sbxvar.hxx @@ -0,0 +1,336 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_BASIC_SBXVAR_HXX +#define INCLUDED_BASIC_SBXVAR_HXX + +#include <rtl/character.hxx> +#include <rtl/ustring.hxx> +#include <basic/sbxcore.hxx> +#include <basic/basicdllapi.h> +#include <com/sun/star/uno/XInterface.hpp> +#include <com/sun/star/uno/Reference.hxx> + +#include <algorithm> +#include <cstddef> +#include <cstring> +#include <memory> + + +namespace com::sun::star::bridge::oleautomation { struct Decimal; } + +class SbxDecimal; +enum class SfxHintId; + +struct SbxValues +{ + union { + sal_uInt8 nByte; + sal_uInt16 nUShort; + sal_Unicode nChar; + sal_Int16 nInteger; + sal_uInt32 nULong; + sal_Int32 nLong; + unsigned int nUInt; + int nInt; + sal_uInt64 uInt64; + sal_Int64 nInt64; + + float nSingle; + double nDouble; + + OUString* pOUString; + SbxDecimal* pDecimal; + + SbxBase* pObj; + + sal_uInt8* pByte; + sal_uInt16* pUShort; + sal_Unicode* pChar; + sal_Int16* pInteger; + sal_uInt32* pULong; + sal_Int32* pLong; + sal_uInt64* puInt64; + sal_Int64* pnInt64; + + float* pSingle; + double* pDouble; + + void* pData; + }; + SbxDataType eType; + + SbxValues(): pData( nullptr ), eType(SbxEMPTY) {} + SbxValues( SbxDataType e ): eType(e) {} + SbxValues( double _nDouble ): nDouble( _nDouble ), eType(SbxDOUBLE) {} + + void clear(SbxDataType type) { + // A hacky way of zeroing the union value corresponding to the given type (even though the + // relevant zero value need not be represented by all-zero bits, in general) without evoking + // GCC 8 -Wclass-memaccess or loplugin:classmemaccess, and without having to turn the + // anonymous union into a non-anonymous one: + auto const p = static_cast<void *>(this); + std::memset(p, 0, offsetof(SbxValues, eType)); + eType = type; + } +}; + +class BASIC_DLLPUBLIC SbxValue : public SbxBase +{ + // #55226 Transport additional infos + BASIC_DLLPRIVATE SbxValue* TheRealValue( bool bObjInObjError ) const; +protected: + SbxValues aData; // Data + OUString aPic; // Picture-String + OUString aToolString; // tool string copy + + virtual void Broadcast( SfxHintId ); // Broadcast-Call + virtual ~SbxValue() override; + virtual bool LoadData( SvStream&, sal_uInt16 ) override; + virtual bool StoreData( SvStream& ) const override; +public: + SBX_DECL_PERSIST_NODATA(SBXID_VALUE,1); + SbxValue(); + SbxValue( SbxDataType ); + SbxValue( const SbxValue& ); + SbxValue& operator=( const SbxValue& ); + virtual void Clear() override; + virtual bool IsFixed() const override; + + bool IsInteger() const { return GetType() == SbxINTEGER ; } + bool IsLong() const { return GetType() == SbxLONG ; } + bool IsDouble() const { return GetType() == SbxDOUBLE ; } + bool IsString() const { return GetType() == SbxSTRING ; } + bool IsCurrency() const { return GetType() == SbxCURRENCY ; } + bool IsObject() const { return GetType() == SbxOBJECT ; } + bool IsBool() const { return GetType() == SbxBOOL ; } + bool IsErr() const { return GetType() == SbxERROR ; } + bool IsEmpty() const { return GetType() == SbxEMPTY ; } + bool IsNull() const { return GetType() == SbxNULL ; } + bool IsNumeric() const; + bool IsNumericRTL() const; // #41692 Interface for Basic + bool ImpIsNumeric( bool bOnlyIntntl ) const; // Implementation + + virtual SbxDataType GetType() const override; + SbxDataType GetFullType() const { return aData.eType;} + bool SetType( SbxDataType ); + + bool Get( SbxValues& ) const; + const SbxValues& GetValues_Impl() const { return aData; } + bool Put( const SbxValues& ); + + SbxValues * data() { return &aData; } + + sal_Unicode GetChar() const { return Get(SbxCHAR).nChar; } + sal_Int16 GetInteger() const { return Get(SbxINTEGER).nInteger; } + sal_Int32 GetLong() const { return Get(SbxLONG).nLong; } + sal_Int64 GetInt64() const { return Get(SbxSALINT64).nInt64; } + sal_uInt64 GetUInt64() const { return Get(SbxSALUINT64).uInt64; } + + sal_Int64 GetCurrency() const { return Get(SbxCURRENCY).nInt64; } + SbxDecimal* GetDecimal() const { return Get(SbxDECIMAL).pDecimal; } + + float GetSingle() const { return Get(SbxSINGLE).nSingle; } + double GetDouble() const { return Get(SbxDOUBLE).nDouble; } + double GetDate() const { return Get(SbxDATE).nDouble; } + + bool GetBool() const { return Get(SbxBOOL).nUShort != 0; } + const OUString& GetCoreString() const; + OUString GetOUString() const; + + SbxBase* GetObject() const { return Get(SbxOBJECT).pObj; } + sal_uInt8 GetByte() const { return Get(SbxBYTE).nByte; } + sal_uInt16 GetUShort() const { return Get(SbxUSHORT).nUShort; } + sal_uInt32 GetULong() const { return Get(SbxULONG).nULong; } + + bool PutInteger( sal_Int16 ); + bool PutLong( sal_Int32 ); + bool PutSingle( float ); + bool PutDouble( double ); + void PutDate( double ); + bool PutBool( bool ); + void PutErr( sal_uInt16 ); + void PutStringExt( const OUString& ); // with extended analysis (International, "sal_True"/"sal_False") + bool PutInt64( sal_Int64 ); + bool PutUInt64( sal_uInt64 ); + bool PutString( const OUString& ); + bool PutChar( sal_Unicode ); + bool PutByte( sal_uInt8 ); + bool PutUShort( sal_uInt16 ); + bool PutULong( sal_uInt32 ); + bool PutEmpty(); + void PutNull(); + + // Special methods + void PutDecimal( css::bridge::oleautomation::Decimal const & rAutomationDec ); + bool PutDecimal( SbxDecimal* pDecimal ); // This function is needed for Windows build, don't remove + void fillAutomationDecimal( css::bridge::oleautomation::Decimal& rAutomationDec ) const; + bool PutCurrency( sal_Int64 ); + // Interface for CDbl in Basic + static ErrCode ScanNumIntnl( const OUString& rSrc, double& nVal, bool bSingle = false ); + + bool PutObject( SbxBase* ); + + bool Convert( SbxDataType ); + bool Compute( SbxOperator, const SbxValue& ); + bool Compare( SbxOperator, const SbxValue& ) const; + bool Scan( const OUString&, sal_uInt16* ); + void Format( OUString&, const OUString* = nullptr ) const; + + // The following operators are defined for easier handling. + // TODO: Ensure error conditions (overflow, conversions) + // are taken into consideration in Compute and Compare + + inline bool operator <=( const SbxValue& ) const; + inline bool operator >=( const SbxValue& ) const; + + inline SbxValue& operator *=( const SbxValue& ); + inline SbxValue& operator /=( const SbxValue& ); + inline SbxValue& operator +=( const SbxValue& ); + inline SbxValue& operator -=( const SbxValue& ); + +private: + SbxValues Get(SbxDataType t) const; +}; + +inline bool SbxValue::operator<=( const SbxValue& r ) const +{ return Compare( SbxLE, r ); } + +inline bool SbxValue::operator>=( const SbxValue& r ) const +{ return Compare( SbxGE, r ); } + +inline SbxValue& SbxValue::operator*=( const SbxValue& r ) +{ Compute( SbxMUL, r ); return *this; } + +inline SbxValue& SbxValue::operator/=( const SbxValue& r ) +{ Compute( SbxDIV, r ); return *this; } + +inline SbxValue& SbxValue::operator+=( const SbxValue& r ) +{ Compute( SbxPLUS, r ); return *this; } + +inline SbxValue& SbxValue::operator-=( const SbxValue& r ) +{ Compute( SbxMINUS, r ); return *this; } + +class SbxArray; +class SbxInfo; + +typedef tools::SvRef<SbxArray> SbxArrayRef; + +typedef tools::SvRef<SbxInfo> SbxInfoRef; + +class SfxBroadcaster; + +class SbxVariableImpl; +class StarBASIC; + +class BASIC_DLLPUBLIC SbxVariable : public SbxValue +{ + friend class SbMethod; + + OUString m_aDeclareClassName; + css::uno::Reference< css::uno::XInterface > m_xComListener; + StarBASIC* m_pComListenerParentBasic = nullptr; + std::unique_ptr<SfxBroadcaster> mpBroadcaster; // Broadcaster, if needed + OUString maName; // Name, if available + mutable OUString maNameCI; // Name, case insensitive - cached for fast comparison + SbxArrayRef mpPar; // Parameter-Array, if set + sal_uInt16 nHash = 0; // Hash-ID for search + +protected: + SbxInfoRef pInfo; // Probably called information + sal_uInt32 nUserData= 0; // User data for Call() + SbxObject* pParent = nullptr; // Currently attached object + virtual ~SbxVariable() override; + virtual bool LoadData( SvStream&, sal_uInt16 ) override; + virtual bool StoreData( SvStream& ) const override; +public: + SBX_DECL_PERSIST_NODATA(SBXID_VARIABLE,2); + SbxVariable(); + SbxVariable( SbxDataType ); + SbxVariable( const SbxVariable& ); + SbxVariable& operator=( const SbxVariable& ); + + void Dump( SvStream&, bool bDumpAll ); + + void SetName( const OUString& ); + const OUString& GetName( SbxNameType = SbxNameType::NONE ) const; + sal_uInt16 GetHashCode() const { return nHash; } + static OUString NameToCaseInsensitiveName(const OUString& rName); + + virtual void SetModified( bool ) override; + + sal_uInt32 GetUserData() const { return nUserData; } + void SetUserData( sal_uInt32 n ) { nUserData = n; } + + virtual SbxDataType GetType() const override; + virtual SbxClassType GetClass() const; + + // Parameter-Interface + virtual SbxInfo* GetInfo(); + void SetInfo( SbxInfo* p ); + void SetParameters( SbxArray* p ); + SbxArray* GetParameters() const; + + // Sfx-Broadcasting-Support: + // Due to data reduction and better DLL-hierarchy currently via casting + SfxBroadcaster& GetBroadcaster(); + bool IsBroadcaster() const { return mpBroadcaster != nullptr; } + virtual void Broadcast( SfxHintId nHintId ) override; + + const SbxObject* GetParent() const { return pParent; } + SbxObject* GetParent() { return pParent;} + virtual void SetParent( SbxObject* ); + + const OUString& GetDeclareClassName() const; + void SetDeclareClassName( const OUString& ); + void SetComListener( const css::uno::Reference< css::uno::XInterface >& xComListener, + StarBASIC* pParentBasic ); + void ClearComListener(); + + // Create a simple hashcode: the first six characters are evaluated. + static constexpr sal_uInt16 MakeHashCode(std::u16string_view aName) + { + sal_uInt16 n = 0; + const auto first6 = aName.substr(0, 6); + for (const auto& c : first6) + { + if (!rtl::isAscii(c)) + continue; // Just skip it to let non-ASCII strings have some hash variance + n = static_cast<sal_uInt16>((n << 3) + rtl::toAsciiUpperCase(c)); + } + return n; + } +}; + +typedef tools::SvRef<SbxObject> SbxObjectRef; +typedef tools::SvRef<SbxVariable> SbxVariableRef; + +//tdf#59222 SbxEnsureParentVariable is a SbxVariable which keeps a reference to +//its parent, ensuring it always exists while this SbxVariable exists +class SbxEnsureParentVariable final : public SbxVariable +{ + SbxObjectRef xParent; +public: + SbxEnsureParentVariable(const SbxVariable& r); + virtual void SetParent(SbxObject* p) override; +}; + +#endif // INCLUDED_BASIC_SBXVAR_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/include/basic/vbahelper.hxx b/include/basic/vbahelper.hxx new file mode 100644 index 000000000..8d18b66b1 --- /dev/null +++ b/include/basic/vbahelper.hxx @@ -0,0 +1,94 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_BASIC_VBAHELPER_HXX +#define INCLUDED_BASIC_VBAHELPER_HXX + +#include <rtl/ustring.hxx> +#include <basic/basicdllapi.h> + +namespace com::sun::star::frame { class XModel; } +namespace com::sun::star::uno { template <typename > class Reference; } + +namespace basic::vba { + +/* This header contains public helper functions for VBA used from this module + and from other VBA implementation modules such as vbahelper. + */ + + +/** Locks or unlocks the controllers of all documents that have the same type + as the specified document. + + First, the global module manager (com.sun.star.frame.ModuleManager) is + asked for the type of the passed model, and all open documents with the + same type will be locked or unlocked. + + @param rxModel + A document model determining the type of the documents to be locked or + unlocked. + + @param bLockControllers + Passing true will lock all controllers, passing false will unlock them. + */ +BASIC_DLLPUBLIC void lockControllersOfAllDocuments( + const css::uno::Reference< css::frame::XModel >& rxModel, + bool bLockControllers ); + + +/** Enables or disables the container windows of all controllers of all + documents that have the same type as the specified document. + + First, the global module manager (com.sun.star.frame.ModuleManager) is + asked for the type of the passed model, and the container windows of all + open documents with the same type will be enabled or disabled. + + @param rxModel + A document model determining the type of the documents to be enabled or + disabled. + + @param bEnableWindows + Passing true will enable all container windows of all controllers, + passing false will disable them. + */ +BASIC_DLLPUBLIC void enableContainerWindowsOfAllDocuments( + const css::uno::Reference< css::frame::XModel >& rxModel, + bool bEnableWindows ); + + +/** Registers the passed path as working directory for the application the + passed document belongs to. + + @param rxModel + A document model determining the type of the application whose working + directory has been changed. + + @param rPath + The new working directory. + */ +BASIC_DLLPUBLIC void registerCurrentDirectory( + const css::uno::Reference< css::frame::XModel >& rxModel, + const OUString& rPath ); + + +} // namespace basic::vba + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |