diff options
Diffstat (limited to 'basic/source/inc')
27 files changed, 4221 insertions, 0 deletions
diff --git a/basic/source/inc/basiccharclass.hxx b/basic/source/inc/basiccharclass.hxx new file mode 100644 index 000000000..3b8109b89 --- /dev/null +++ b/basic/source/inc/basiccharclass.hxx @@ -0,0 +1,36 @@ +/* -*- 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_SOURCE_INC_BASICCHARCLASS_HXX +#define INCLUDED_BASIC_SOURCE_INC_BASICCHARCLASS_HXX + +#include <sal/types.h> + +namespace BasicCharClass +{ + bool isLetter( sal_Unicode c ); + bool isLetterUnicode( sal_Unicode c ); + bool isAlpha( sal_Unicode c, bool bCompatible ); + bool isAlphaNumeric( sal_Unicode c, bool bCompatible ); + bool isWhitespace( sal_Unicode c ); +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basic/source/inc/buffer.hxx b/basic/source/inc/buffer.hxx new file mode 100644 index 000000000..89d664453 --- /dev/null +++ b/basic/source/inc/buffer.hxx @@ -0,0 +1,53 @@ +/* -*- 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_SOURCE_INC_BUFFER_HXX +#define INCLUDED_BASIC_SOURCE_INC_BUFFER_HXX + +#include <sal/types.h> +#include <memory> + +class SbiParser; + +class SbiBuffer { + SbiParser* pParser; // for error messages + std::unique_ptr<char[]> pBuf; + char* pCur; + sal_uInt32 nOff; + sal_uInt32 nSize; + short nInc; + bool Check( sal_Int32 ); +public: + SbiBuffer( SbiParser*, short ); // increment + ~SbiBuffer(); + void Patch( sal_uInt32, sal_uInt32 ); + void Chain( sal_uInt32 ); + void operator += (sal_Int8); // save character + void operator += (sal_Int16); // save integer + bool operator += (sal_uInt8); // save character + bool operator += (sal_uInt16); // save integer + bool operator += (sal_uInt32); // save integer + void operator += (sal_Int32); // save integer + char* GetBuffer(); // give out buffer (delete yourself!) + sal_uInt32 GetSize() const { return nOff; } +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basic/source/inc/codegen.hxx b/basic/source/inc/codegen.hxx new file mode 100644 index 000000000..857968e26 --- /dev/null +++ b/basic/source/inc/codegen.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_SOURCE_INC_CODEGEN_HXX +#define INCLUDED_BASIC_SOURCE_INC_CODEGEN_HXX + +class SbiParser; +class SbModule; +#include "opcodes.hxx" +#include "buffer.hxx" + +class SbiCodeGen { + SbiParser* pParser; // for error messages, line, column etc. + SbModule& rMod; + SbiBuffer aCode; + short nLine, nCol; // for stmnt command + short nForLevel; // #29955 + bool bStmnt; // true: statement-opcode is pending + +public: + SbiCodeGen( SbModule&, SbiParser*, short ); + SbiParser* GetParser() { return pParser; } + SbModule& GetModule() { return rMod; } + sal_uInt32 Gen( SbiOpcode ); + sal_uInt32 Gen( SbiOpcode, sal_uInt32 ); + sal_uInt32 Gen( SbiOpcode, sal_uInt32, sal_uInt32 ); + void Patch( sal_uInt32 o, sal_uInt32 v ){ aCode.Patch( o, v ); } + void BackChain( sal_uInt32 off ) { aCode.Chain( off ); } + void Statement(); + void GenStmnt(); // create statement-opcode maybe + sal_uInt32 GetPC() const; + sal_uInt32 GetOffset() const { return GetPC() + 1; } + void Save(); + + // #29955 service for-loop-level + void IncForLevel() { nForLevel++; } + void DecForLevel() { nForLevel--; } + + static sal_uInt32 calcNewOffSet( sal_uInt8 const * pCode, sal_uInt16 nOffset ); + static sal_uInt16 calcLegacyOffSet( sal_uInt8 const * pCode, sal_uInt32 nOffset ); + +}; + +template < class T, class S > +class PCodeBuffConvertor +{ + T m_nSize; + sal_uInt8* m_pStart; + sal_uInt8* m_pCnvtdBuf; + S m_nCnvtdSize; + + PCodeBuffConvertor(const PCodeBuffConvertor& ) = delete; + PCodeBuffConvertor& operator = ( const PCodeBuffConvertor& ) = delete; +public: + PCodeBuffConvertor( sal_uInt8* pCode, T nSize ): m_nSize( nSize ), m_pStart( pCode ), m_pCnvtdBuf( nullptr ), m_nCnvtdSize( 0 ){ convert(); } + S GetSize(){ return m_nCnvtdSize; } + void convert(); + // Caller owns the buffer returned + sal_uInt8* GetBuffer() { return m_pCnvtdBuf; } +}; + +// #111897 PARAM_INFO flags start at 0x00010000 to not +// conflict with DefaultId in SbxParamInfo::nUserData +#define PARAM_INFO_PARAMARRAY 0x0010000 +#define PARAM_INFO_WITHBRACKETS 0x0020000 + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basic/source/inc/date.hxx b/basic/source/inc/date.hxx new file mode 100644 index 000000000..1a994ca3f --- /dev/null +++ b/basic/source/inc/date.hxx @@ -0,0 +1,61 @@ +/* -*- 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_SOURCE_INC_DATE_HXX +#define INCLUDED_BASIC_SOURCE_INC_DATE_HXX + +#include <com/sun/star/util/Date.hpp> +#include <com/sun/star/util/Time.hpp> +#include <com/sun/star/util/DateTime.hpp> + +#include <basic/sbxvar.hxx> + +enum class SbDateCorrection +{ + None, + RollOver, + TruncateToMonth +}; + +bool implDateSerial( sal_Int16 nYear, sal_Int16 nMonth, sal_Int16 nDay, bool bUseTwoDigitYear, SbDateCorrection eCorr, double& rdRet ); +double implTimeSerial( sal_Int16 nHour, sal_Int16 nMinute, sal_Int16 nSecond); +bool implDateTimeSerial( sal_Int16 nYear, sal_Int16 nMonth, sal_Int16 nDay, + sal_Int16 nHour, sal_Int16 nMinute, sal_Int16 nSecond, + double& rdRet ); + +sal_Int16 implGetWeekDay( double aDate, bool bFirstDayParam = false, sal_Int16 nFirstDay = 0 ); + +sal_Int16 implGetDateYear( double aDate ); +sal_Int16 implGetDateMonth( double aDate ); +sal_Int16 implGetDateDay( double aDate ); + +sal_Int16 implGetHour( double dDate ); +sal_Int16 implGetMinute( double dDate ); +sal_Int16 implGetSecond( double dDate ); + +css::util::Date SbxDateToUNODate( const SbxValue* ); +void SbxDateFromUNODate( SbxValue*, const css::util::Date& ); +css::util::Time SbxDateToUNOTime( const SbxValue* ); +void SbxDateFromUNOTime( SbxValue*, const css::util::Time& ); +css::util::DateTime SbxDateToUNODateTime( const SbxValue* ); +void SbxDateFromUNODateTime( SbxValue*, const css::util::DateTime& ); + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basic/source/inc/dlgcont.hxx b/basic/source/inc/dlgcont.hxx new file mode 100644 index 000000000..582e462ab --- /dev/null +++ b/basic/source/inc/dlgcont.hxx @@ -0,0 +1,152 @@ +/* -*- 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_SOURCE_INC_DLGCONT_HXX +#define INCLUDED_BASIC_SOURCE_INC_DLGCONT_HXX + +#include "namecont.hxx" + +#include <com/sun/star/resource/XStringResourceSupplier.hpp> +#include <com/sun/star/resource/XStringResourcePersistence.hpp> + +#include <cppuhelper/implbase1.hxx> +#include <comphelper/uno3.hxx> + +namespace basic +{ + + +class SfxDialogLibraryContainer : public SfxLibraryContainer +{ + // Methods to distinguish between different library types + virtual SfxLibrary* implCreateLibrary( const OUString& aName ) override; + virtual SfxLibrary* implCreateLibraryLink + ( const OUString& aName, const OUString& aLibInfoFileURL, + const OUString& StorageURL, bool ReadOnly ) override; + virtual css::uno::Any createEmptyLibraryElement() override; + virtual bool isLibraryElementValid(const css::uno::Any& rElement) const override; + virtual void writeLibraryElement + ( + const css::uno::Reference< css::container::XNameContainer>& xLibrary, + const OUString& aElementName, + const css::uno::Reference< css::io::XOutputStream >& xOutput + ) override; + + virtual css::uno::Any importLibraryElement + ( + const css::uno::Reference< css::container::XNameContainer>& xLibrary, + const OUString& aElementName, + const OUString& aFile, + const css::uno::Reference< css::io::XInputStream >& xElementStream ) override; + + virtual void importFromOldStorage( const OUString& aFile ) override; + + virtual SfxLibraryContainer* createInstanceImpl() override; + + virtual void onNewRootStorage() override; + + virtual const char* getInfoFileName() const override; + virtual const char* getOldInfoFileName() const override; + virtual const char* getLibElementFileExtension() const override; + virtual const char* getLibrariesDir() const override; + +public: + SfxDialogLibraryContainer(); + SfxDialogLibraryContainer( const css::uno::Reference< css::embed::XStorage >& xStorage ); + + // Methods XStorageBasedLibraryContainer + virtual void SAL_CALL storeLibrariesToStorage( + const css::uno::Reference< css::embed::XStorage >& RootStorage ) override; + + // Resource handling + css::uno::Reference< css::resource::XStringResourcePersistence > + implCreateStringResource( class SfxDialogLibrary* pDialog ); + + // Methods XServiceInfo + virtual OUString SAL_CALL getImplementationName( ) override; + virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames( ) override; + // XLibraryQueryExecutable + virtual sal_Bool SAL_CALL HasExecutableCode(const OUString&) override; +}; + + +typedef ::cppu::ImplHelper1 < css::resource::XStringResourceSupplier + > SfxDialogLibrary_BASE; + +class SfxDialogLibrary :public SfxLibrary + ,public SfxDialogLibrary_BASE +{ + SfxDialogLibraryContainer* m_pParent; + css::uno::Reference< css::resource::XStringResourcePersistence> m_xStringResourcePersistence; + OUString m_aName; + + // Provide modify state including resources + virtual bool isModified() override; + virtual void storeResources() override; + virtual void storeResourcesAsURL( const OUString& URL, const OUString& NewName ) override; + virtual void storeResourcesToURL( const OUString& URL, + const css::uno::Reference< css::task::XInteractionHandler >& xHandler ) override; + virtual void storeResourcesToStorage( const css::uno::Reference + < css::embed::XStorage >& xStorage ) override; + +public: + SfxDialogLibrary + ( + ModifiableHelper& _rModifiable, + const OUString& aName, + const css::uno::Reference< css::ucb::XSimpleFileAccess3 >& xSFI, + SfxDialogLibraryContainer* pParent + ); + + SfxDialogLibrary + ( + ModifiableHelper& _rModifiable, + const OUString& aName, + const css::uno::Reference< css::ucb::XSimpleFileAccess3 >& xSFI, + const OUString& aLibInfoFileURL, const OUString& aStorageURL, bool ReadOnly, + SfxDialogLibraryContainer* pParent + ); + + DECLARE_XINTERFACE() + DECLARE_XTYPEPROVIDER() + + // XStringResourceSupplier + virtual css::uno::Reference< css::resource::XStringResourceResolver > + SAL_CALL getStringResource( ) override; + + const OUString& getName() const + { return m_aName; } + + const css::uno::Reference< css::resource::XStringResourcePersistence >& + getStringResourcePersistence() const + { + return m_xStringResourcePersistence; + } + + static bool containsValidDialog( const css::uno::Any& aElement ); + +protected: + virtual bool isLibraryElementValid(const css::uno::Any& rElement) const override; +}; + +} // namespace basic + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basic/source/inc/errobject.hxx b/basic/source/inc/errobject.hxx new file mode 100644 index 000000000..65c4722e3 --- /dev/null +++ b/basic/source/inc/errobject.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_SOURCE_INC_ERROBJECT_HXX +#define INCLUDED_BASIC_SOURCE_INC_ERROBJECT_HXX +#include "sbunoobj.hxx" +#include <ooo/vba/XErrObject.hpp> + + +class SbxErrObject : public SbUnoObject +{ + class ErrObject* m_pErrObject; + css::uno::Reference< ooo::vba::XErrObject > m_xErr; + + SbxErrObject( const OUString& aName_, const css::uno::Any& aUnoObj_ ); + virtual ~SbxErrObject() override; + +public: + static SbxVariableRef const & getErrObject(); + static css::uno::Reference< ooo::vba::XErrObject > const & getUnoErrObject(); + + /// @throws css::uno::RuntimeException + void setNumberAndDescription( ::sal_Int32 _number, const OUString& _description ); +}; +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basic/source/inc/eventatt.hxx b/basic/source/inc/eventatt.hxx new file mode 100644 index 000000000..b38c83c59 --- /dev/null +++ b/basic/source/inc/eventatt.hxx @@ -0,0 +1,34 @@ +/* -*- 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_SOURCE_INC_EVENTATT_HXX +#define INCLUDED_BASIC_SOURCE_INC_EVENTATT_HXX + +#include <sal/config.h> + +class SbxArray; + +// Instantiate "com.sun.star.awt.UnoControlDialog" on basis +// of a DialogLibrary entry: Convert from XML-ByteSequence +// and attach events. +void RTL_Impl_CreateUnoDialog(SbxArray& rPar); + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basic/source/inc/expr.hxx b/basic/source/inc/expr.hxx new file mode 100644 index 000000000..d83594c49 --- /dev/null +++ b/basic/source/inc/expr.hxx @@ -0,0 +1,230 @@ +/* -*- 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_SOURCE_INC_EXPR_HXX +#define INCLUDED_BASIC_SOURCE_INC_EXPR_HXX + +#include <memory> + +#include "opcodes.hxx" +#include "token.hxx" +#include <vector> + +class SbiExprNode; +class SbiExpression; +class SbiExprList; +class SbiParser; +class SbiCodeGen; +class SbiSymDef; +class SbiProcDef; + + +typedef std::unique_ptr<SbiExprList> SbiExprListPtr; +typedef std::vector<SbiExprListPtr> SbiExprListVector; + +struct SbVar { + SbiExprNode* pNext; // next element (for structures) + SbiSymDef* pDef; // symbol definition + SbiExprList* pPar; // optional parameters (is deleted) + SbiExprListVector* pvMorePar; // Array of arrays foo(pPar)(avMorePar[0])(avMorePar[1])... +}; + +struct KeywordSymbolInfo +{ + OUString m_aKeywordSymbol; + SbxDataType m_eSbxDataType; +}; + +enum SbiExprType { // expression types: + SbSTDEXPR, // normal expression + SbLVALUE, // any lValue + SbSYMBOL, // any composite symbol + SbOPERAND // variable/function +}; + +enum SbiExprMode { // Expression context: + EXPRMODE_STANDARD, // default + EXPRMODE_STANDALONE, // a param1, param2 OR a( param1, param2 ) = 42 + EXPRMODE_LPAREN_PENDING, // start of parameter list with bracket, special handling + EXPRMODE_LPAREN_NOT_NEEDED, // pending LPAREN has not been used + EXPRMODE_ARRAY_OR_OBJECT, // '=' or '(' or '.' found after ')' on ParenLevel 0, stopping + // expression, assuming array syntax a(...)[(...)] = ? + // or a(...).b(...) + EXPRMODE_EMPTY_PAREN // It turned out that the paren don't contain anything: a() +}; + +enum SbiNodeType { + SbxNUMVAL, // nVal = value + SbxSTRVAL, // aStrVal = value, before #i59791/#i45570: nStringId = value + SbxVARVAL, // aVar = value + SbxTYPEOF, // TypeOf ObjExpr Is Type + SbxNODE, // Node + SbxNEW, // new <type> expression + SbxDUMMY +}; + +enum RecursiveMode +{ + UNDEFINED, + FORCE_CALL, + PREVENT_CALL +}; + +class SbiExprNode final { // operators (and operands) + friend class SbiExpression; + friend class SbiConstExpression; + union { + sal_uInt16 nTypeStrId; // pooled String-ID, #i59791/#i45570 Now only for TypeOf + double nVal; // numeric value + SbVar aVar; // or variable + }; + OUString aStrVal; // #i59791/#i45570 Store string directly + std::unique_ptr<SbiExprNode> pLeft; // left branch + std::unique_ptr<SbiExprNode> pRight; // right branch (NULL for unary ops) + SbiExprNode* pWithParent; // node, whose member is "this per with" + SbiNodeType eNodeType; + SbxDataType eType; + SbiToken eTok; + bool bError; // true: error + void FoldConstants(SbiParser*); + void FoldConstantsBinaryNode(SbiParser*); + void FoldConstantsUnaryNode(SbiParser*); + void CollectBits(); // converting numbers to strings + bool IsOperand() const + { return eNodeType != SbxNODE && eNodeType != SbxTYPEOF && eNodeType != SbxNEW; } + bool IsNumber() const; + bool IsLvalue() const; // true, if usable as Lvalue + void GenElement( SbiCodeGen&, SbiOpcode ); + +public: + SbiExprNode(); + SbiExprNode( double, SbxDataType ); + SbiExprNode( const OUString& ); + SbiExprNode( const SbiSymDef&, SbxDataType, SbiExprListPtr = nullptr ); + SbiExprNode( std::unique_ptr<SbiExprNode>, SbiToken, std::unique_ptr<SbiExprNode> ); + SbiExprNode( std::unique_ptr<SbiExprNode>, sal_uInt16 ); // #120061 TypeOf + SbiExprNode( sal_uInt16 ); // new <type> + ~SbiExprNode(); + + bool IsValid() const { return !bError; } + bool IsConstant() const // true: constant operand + { return eNodeType == SbxSTRVAL || eNodeType == SbxNUMVAL; } + void ConvertToIntConstIfPossible(); + bool IsVariable() const; + + void SetWithParent( SbiExprNode* p ) { pWithParent = p; } + + SbxDataType GetType() const { return eType; } + void SetType( SbxDataType eTp ) { eType = eTp; } + SbiNodeType GetNodeType() const { return eNodeType; } + SbiSymDef* GetVar(); + SbiSymDef* GetRealVar(); // last variable in x.y.z + SbiExprNode* GetRealNode(); // last node in x.y.z + const OUString& GetString() const { return aStrVal; } + short GetNumber() const { return static_cast<short>(nVal); } + SbiExprList* GetParameters() { return aVar.pPar; } + + void Optimize(SbiParser*); // tree matching + + void Gen( SbiCodeGen& rGen, RecursiveMode eRecMode = UNDEFINED ); // giving out a node +}; + +class SbiExpression { + friend class SbiExprList; +protected: + OUString aArgName; + SbiParser* pParser; + std::unique_ptr<SbiExprNode> pExpr; // expression tree + SbiExprType eCurExpr; // type of expression + SbiExprMode m_eMode; // expression context + bool bBased; // true: easy DIM-part (+BASE) + bool bError; + bool bByVal; // true: ByVal-Parameter + bool bBracket; // true: Parameter list with brackets + sal_uInt16 nParenLevel; + std::unique_ptr<SbiExprNode> Term( const KeywordSymbolInfo* pKeywordSymbolInfo = nullptr ); + std::unique_ptr<SbiExprNode> ObjTerm( SbiSymDef& ); + std::unique_ptr<SbiExprNode> Operand( bool bUsedForTypeOf = false ); + std::unique_ptr<SbiExprNode> Unary(); + std::unique_ptr<SbiExprNode> Exp(); + std::unique_ptr<SbiExprNode> MulDiv(); + std::unique_ptr<SbiExprNode> IntDiv(); + std::unique_ptr<SbiExprNode> Mod(); + std::unique_ptr<SbiExprNode> AddSub(); + std::unique_ptr<SbiExprNode> Cat(); + std::unique_ptr<SbiExprNode> Like(); + std::unique_ptr<SbiExprNode> VBA_Not(); + std::unique_ptr<SbiExprNode> Comp(); + std::unique_ptr<SbiExprNode> Boolean(); +public: + SbiExpression( SbiParser*, SbiExprType = SbSTDEXPR, + SbiExprMode eMode = EXPRMODE_STANDARD, const KeywordSymbolInfo* pKeywordSymbolInfo = nullptr ); // parsing Ctor + SbiExpression( SbiParser*, double, SbxDataType ); + SbiExpression( SbiParser*, const SbiSymDef&, SbiExprListPtr = nullptr ); + ~SbiExpression(); + OUString& GetName() { return aArgName; } + void SetBased() { bBased = true; } + bool IsBased() const { return bBased; } + void SetByVal() { bByVal = true; } + bool IsBracket() const { return bBracket; } + bool IsValid() const { return pExpr->IsValid(); } + bool IsVariable() const { return pExpr->IsVariable(); } + bool IsLvalue() const { return pExpr->IsLvalue(); } + void ConvertToIntConstIfPossible() { pExpr->ConvertToIntConstIfPossible(); } + const OUString& GetString() const { return pExpr->GetString(); } + SbiSymDef* GetRealVar() { return pExpr->GetRealVar(); } + SbiExprNode* GetExprNode() { return pExpr.get(); } + SbxDataType GetType() const { return pExpr->GetType(); } + void Gen( RecursiveMode eRecMode = UNDEFINED ); +}; + +class SbiConstExpression : public SbiExpression { + double nVal; + OUString aVal; + SbxDataType eType; +public: // numeric constant + SbiConstExpression( SbiParser* ); + SbxDataType GetType() const { return eType; } + const OUString& GetString() const { return aVal; } + double GetValue() const { return nVal; } + short GetShortValue(); +}; + +class SbiExprList final { // class for parameters and dims + std::vector<std::unique_ptr<SbiExpression>> aData; + short nDim; + bool bError; + bool bBracket; +public: + SbiExprList(); + ~SbiExprList(); + static SbiExprListPtr ParseParameters(SbiParser*, bool bStandaloneExpression = false, bool bPar = true); + static SbiExprListPtr ParseDimList( SbiParser* ); + bool IsBracket() const { return bBracket; } + bool IsValid() const { return !bError; } + short GetSize() const { return aData.size(); } + short GetDims() const { return nDim; } + SbiExpression* Get( size_t ); + void Gen( SbiCodeGen& rGen); // code generation + void addExpression( std::unique_ptr<SbiExpression>&& pExpr ); +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basic/source/inc/filefmt.hxx b/basic/source/inc/filefmt.hxx new file mode 100644 index 000000000..eb1990087 --- /dev/null +++ b/basic/source/inc/filefmt.hxx @@ -0,0 +1,192 @@ +/* -*- 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_SOURCE_INC_FILEFMT_HXX +#define INCLUDED_BASIC_SOURCE_INC_FILEFMT_HXX + +class SvStream; + +// Version 2: data type of the return value for publics +// Version 3: new opcodes +// Version 4: new opcodes +// Version 5: bug (entry of STATIC-variables in the init code) +// Version 6: new opcodes and bug (construct globals, without ending the BASIC) +// Version 7: correction concerning the WITH-Parsing +// Version 8: correction concerning the IF-Parsing +// Version 9: end init code with LEAVE, too, if no SUB/FUNCTION follows +// Version A: #36374 at DIM AS NEW... construct variable too +// Version B: #40689 reorganized static +// Version C: #41606 bug at static +// Version D: #42678 bug at RTL-function spc +// Version E: #56204 DCREATE, to also construct arrays at DIM AS NEW +// Version F: #57844 introduction of SvNumberformat::StringToDouble +// Version 10: #29955 generate for-loop-level in Statement-PCodes +// Version 11: #29955 force anew compilation because of build-inconsistences +// Version 12: aoo#64377 increase code size that basic can handle +// tdf#75973 support user defined types B_USERTYPES in password protected macros +// Version 13: tdf#94617 store methods nStart information greater than sal_Int16 limit +// tdf#57113 store UTF-16 strings after legacy 1-byte-encoded strings in pool (no +// version number bump for backward compatibility; relies on magic number) +// + +#define B_LEGACYVERSION 0x00000011 +#define B_EXT_IMG_VERSION 0x00000012 +#define B_CURVERSION 0x00000013 + +// The file contains either a module- or a library-record. +// Those records contain further records. Every record's got +// the following header: + +// sal_uInt16 identifier +// sal_uInt32 the record's length without the header +// sal_uInt16 number of sub-elements + +// all the file-offsets in records are relative to the module's start! + +enum class FileOffset { + Library = 0x4C42, // BL Library Record + Module = 0x4D42, // BM Module Record + Name = 0x4E4D, // MN module name + Comment = 0x434D, // MC comment + Source = 0x4353, // SC source code + PCode = 0x4350, // PC p-code + OldPublics = 0x7550, // Pu publics + Publics = 0x5550, // PU publics + PoolDir = 0x4450, // PD symbol pool directory + SymPool = 0x5953, // SY symbol pool + StringPool = 0x5453, // ST symbol pool + LineRanges = 0x524C, // LR line ranges for publics + ModEnd = 0x454D, // ME module end + SbxObjects = 0x5853, // SX SBX objects + ExtSource = 0x5345, // ES extended source + UserTypes = 0x4369, // UT user defined types + + LastValue = UserTypes +}; + + +// A library record contains only module records +// sal_uInt16 identifier BL +// sal_uInt32 the record's length +// sal_uInt16 number of modules + +// A module-record contains all the other record types +// sal_uInt16 identifier BM +// sal_uInt32 the record's length +// sal_uInt16 1 +// Data: +// sal_uInt32 version number +// sal_uInt32 character set +// sal_uInt32 starting address initialisation code +// sal_uInt32 starting address sub main +// sal_uInt32 reserved +// sal_uInt32 reserved + +// module name, comment and source code: +// sal_uInt16 identifier MN, MC or SC +// sal_uInt32 the record's length +// sal_uInt16 1 +// Data: +// string instance + +// P-Code: +// sal_uInt16 identifier PC +// sal_uInt32 the record's length +// sal_uInt16 1 +// Data: +// the P-Code as bytesack + +// All symbols and strings are kept in a string-pool. +// References to these strings are in this pool in the form of an index. + +// List of all publics: +// sal_uInt16 identifier PU or Pu +// sal_uInt32 the record's length +// sal_uInt16 number of publics +// Data for every public-entry: +// sal_uInt16 string index +// sal_uInt32 starting address in the p-code-image (sal_uInt16 for old publics) +// sal_uInt16 data type of the return value (from version 2) + +// Register of the symbol tables: +// sal_uInt16 identifier SP +// sal_uInt32 the record's length +// sal_uInt16 number of symbol tables +// Data for every symbol table: +// sal_uInt16 stringindex of the name +// sal_uInt16 number of symbols +// sal_uInt16 scope identifier + +// symbol table: +// sal_uInt16 identifier SY +// sal_uInt32 the record's length +// sal_uInt16 number of symbols +// Data: +// sal_uInt16 stringindex of the name +// sal_uInt16 number of symbols +// Data for every symbol: +// sal_uInt16 stringindex of the name +// sal_uInt16 data type +// sal_uInt16 length for STRING*n-symbols (0x8000: STATIC variable) + +// Stringpool: +// sal_uInt16 identifier ST +// sal_uInt32 the record's length +// sal_uInt16 number of strings +// Data for every string: +// sal_uInt32 Offset in the block of all strings +// the block of all strings (ASCIIZ) follows then + +// line ranges: +// sal_uInt16 identifier LR +// sal_uInt32 the record's length +// sal_uInt16 number of strings +// Data for every public: +// sal_uInt16 1st line (Sub XXX) +// sal_uInt16 2nd line (End Sub) + +// SBX-objects: +// sal_uInt16 number of objects +// ... object data + +// user defined types B_USERTYPES : +// sal_uInt16 identifier UT +// sal_uInt32 the record's length +// sal_uInt16 number of types +// Data for every user defined type: +// string instance type name +// sal_Int16 number of type members +// Data for every type member: +// string name +// sal_Int16 type +// sal_uInt32 flags +// sal_Int16 hasObjects (0/1) +// If hasObjects +// If member type is nested type +// string nested type name +// Else (array declaration) +// sal_Int16 isFixedSize (0/1) +// sal_Int32 number of dimensions +// Data for every dimension: +// sal_Int32 lower bound +// sal_Int32 upper bound + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basic/source/inc/image.hxx b/basic/source/inc/image.hxx new file mode 100644 index 000000000..ee1aaa416 --- /dev/null +++ b/basic/source/inc/image.hxx @@ -0,0 +1,104 @@ +/* -*- 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_SOURCE_INC_IMAGE_HXX +#define INCLUDED_BASIC_SOURCE_INC_IMAGE_HXX + +#include <basic/sbx.hxx> +#include <rtl/ustring.hxx> +#include "filefmt.hxx" +#include <o3tl/typed_flags_set.hxx> + +// This class reads in the image that's been produced by the compiler +// and manages the access to the single elements. + +enum class SbiImageFlags +{ + NONE = 0, + EXPLICIT = 0x0001, // OPTION EXPLICIT is active + COMPARETEXT = 0x0002, // OPTION COMPARE TEXT is active + INITCODE = 0x0004, // Init-Code does exist + CLASSMODULE = 0x0008, // OPTION ClassModule is active +}; +namespace o3tl +{ + template<> struct typed_flags<SbiImageFlags> : is_typed_flags<SbiImageFlags, 0xf> {}; +} + +class SbiImage { + friend class SbiCodeGen; // compiler classes, that the private- + + SbxArrayRef rTypes; // User defined types + SbxArrayRef rEnums; // Enum types + std::vector<sal_uInt32> mvStringOffsets; // StringId-Offsets + std::unique_ptr<sal_Unicode[]> pStrings; // StringPool + std::unique_ptr<char[]> pCode; // Code-Image + std::unique_ptr<char[]> pLegacyPCode; // Code-Image + bool bError; + SbiImageFlags nFlags; + sal_uInt32 nStringSize; + sal_uInt32 nCodeSize; + sal_uInt16 nLegacyCodeSize; + sal_uInt16 nDimBase; // OPTION BASE value + rtl_TextEncoding eCharSet; + // temporary management-variable: + short nStringIdx; + sal_uInt32 nStringOff; // current Pos in the stringbuffer + // routines for the compiler: + void MakeStrings( short ); // establish StringPool + void AddString( const OUString& ); + void AddCode( std::unique_ptr<char[]>, sal_uInt32 ); + void AddType(SbxObject const *); + void AddEnum(SbxObject *); + +public: + OUString aName; // macro name + OUString aOUSource; // source code + OUString aComment; + bool bInit; + bool bFirstInit; + + SbiImage(); + ~SbiImage(); + void Clear(); + bool Load( SvStream&, sal_uInt32& nVer ); + // nVer is set to version + // of image + bool Save( SvStream&, sal_uInt32 = B_CURVERSION ); + bool IsError() const { return bError; } + + const char* GetCode() const { return pCode.get(); } + sal_uInt32 GetCodeSize() const { return nCodeSize; } + sal_uInt16 GetBase() const { return nDimBase; } + OUString GetString( short nId ) const; + const SbxObject* FindType (const OUString& aTypeName) const; + + const SbxArrayRef& GetEnums() const { return rEnums; } + + void SetFlag( SbiImageFlags n ) { nFlags |= n; } + bool IsFlag( SbiImageFlags n ) const { return bool(nFlags & n); } + sal_uInt16 CalcLegacyOffset( sal_Int32 nOffset ); + sal_uInt32 CalcNewOffset( sal_Int16 nOffset ); + void ReleaseLegacyBuffer(); + bool ExceedsLegacyLimits(); +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basic/source/inc/iosys.hxx b/basic/source/inc/iosys.hxx new file mode 100644 index 000000000..4931b86a3 --- /dev/null +++ b/basic/source/inc/iosys.hxx @@ -0,0 +1,112 @@ +/* -*- 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_SOURCE_INC_IOSYS_HXX +#define INCLUDED_BASIC_SOURCE_INC_IOSYS_HXX + +#include <memory> +#include <tools/stream.hxx> +#include <o3tl/typed_flags_set.hxx> + +class SvStream; + +// Global files (channel numbers 256 to 511) are not +// implemented at the moment. + +#define CHANNELS 256 + +enum class SbiStreamFlags +{ + NONE = 0x0000, + Input = 0x0001, + Output = 0x0002, + Random = 0x0004, + Append = 0x0008, + Binary = 0x0010, +}; +namespace o3tl +{ + template<> struct typed_flags<SbiStreamFlags> : is_typed_flags<SbiStreamFlags, 0x1f> {}; +} + +class SbiStream +{ + std::unique_ptr<SvStream> pStrm; + sal_uInt64 nExpandOnWriteTo; // during writing access expand the stream to this size + OString aLine; + sal_uInt64 nLine; + short nLen; // buffer length + SbiStreamFlags nMode; + ErrCode nError; + void MapError(); + +public: + SbiStream(); + ~SbiStream(); + ErrCode const & Open( const OString&, StreamMode, SbiStreamFlags, short ); + ErrCode const & Close(); + ErrCode Read(OString&, sal_uInt16 = 0, bool bForceReadingPerByte=false); + ErrCode const & Read( char& ); + ErrCode Write( const OString& ); + + bool IsText() const { return !bool(nMode & SbiStreamFlags::Binary); } + bool IsRandom() const { return bool(nMode & SbiStreamFlags::Random); } + bool IsBinary() const { return bool(nMode & SbiStreamFlags::Binary); } + bool IsSeq() const { return !bool(nMode & SbiStreamFlags::Random); } + bool IsAppend() const { return bool(nMode & SbiStreamFlags::Append); } + short GetBlockLen() const { return nLen; } + SbiStreamFlags GetMode() const { return nMode; } + sal_uInt64 GetLine() const { return nLine; } + void SetExpandOnWriteTo( sal_uInt64 n ) { nExpandOnWriteTo = n; } + void ExpandFile(); + SvStream* GetStrm() { return pStrm.get(); } +}; + +class SbiIoSystem +{ + SbiStream* pChan[ CHANNELS ]; + OString aPrompt; + OString aIn; + OUString aOut; + short nChan; + ErrCode nError; + void ReadCon(OString&); + void WriteCon(const OUString&); +public: + SbiIoSystem(); + ~SbiIoSystem() COVERITY_NOEXCEPT_FALSE; + ErrCode GetError(); + void Shutdown(); + void SetPrompt(const OString& r) { aPrompt = r; } + void SetChannel( short n ) { nChan = n; } + short GetChannel() const { return nChan;} + void ResetChannel() { nChan = 0; } + void Open( short, const OString&, StreamMode, SbiStreamFlags, short ); + void Close(); + void Read(OString&); + char Read(); + void Write(const OUString&); + // 0 == bad channel or no SvStream (nChannel=0..CHANNELS-1) + SbiStream* GetStream( short nChannel ) const; + void CloseAll(); // JSM +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basic/source/inc/namecont.hxx b/basic/source/inc/namecont.hxx new file mode 100644 index 000000000..3a86f059c --- /dev/null +++ b/basic/source/inc/namecont.hxx @@ -0,0 +1,660 @@ +/* -*- 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_SOURCE_INC_NAMECONT_HXX +#define INCLUDED_BASIC_SOURCE_INC_NAMECONT_HXX + +#include <unordered_map> +#include <com/sun/star/uno/XComponentContext.hpp> +#include <com/sun/star/lang/XInitialization.hpp> +#include <com/sun/star/script/XStorageBasedLibraryContainer.hpp> +#include <com/sun/star/script/XLibraryContainerPassword.hpp> +#include <com/sun/star/script/XLibraryContainerExport.hpp> +#include <com/sun/star/script/XLibraryQueryExecutable.hpp> +#include <com/sun/star/script/XLibraryContainer3.hpp> +#include <com/sun/star/container/XNameContainer.hpp> +#include <com/sun/star/container/XContainer.hpp> +#include <com/sun/star/ucb/XSimpleFileAccess3.hpp> +#include <com/sun/star/io/XOutputStream.hpp> +#include <com/sun/star/io/XInputStream.hpp> +#include <com/sun/star/util/XStringSubstitution.hpp> +#include <com/sun/star/document/XStorageBasedDocument.hpp> +#include <com/sun/star/lang/XServiceInfo.hpp> +#include <com/sun/star/frame/XModel.hpp> +#include <com/sun/star/deployment/XPackage.hpp> +#include <com/sun/star/script/vba/XVBACompatibility.hpp> +#include <com/sun/star/script/vba/XVBAScriptListener.hpp> +#include <com/sun/star/util/XChangesNotifier.hpp> + +#include <osl/mutex.hxx> +#include <unotools/eventlisteneradapter.hxx> +#include <cppuhelper/implbase.hxx> +#include <cppuhelper/compbase.hxx> +#include <cppuhelper/weakref.hxx> +#include <cppuhelper/component.hxx> +#include <cppuhelper/basemutex.hxx> +#include <rtl/ref.hxx> +#include <comphelper/listenernotification.hxx> +#include <xmlscript/xmllib_imexp.hxx> + +class BasicManager; + +namespace basic +{ +typedef ::cppu::WeakImplHelper< + css::container::XNameContainer, + css::container::XContainer, + css::util::XChangesNotifier > NameContainer_BASE; + + +class NameContainer : public ::cppu::BaseMutex, public NameContainer_BASE +{ + typedef std::unordered_map < OUString, sal_Int32 > NameContainerNameMap; + + NameContainerNameMap mHashMap; + std::vector< OUString > mNames; + std::vector< css::uno::Any > mValues; + sal_Int32 mnElementCount; + + css::uno::Type mType; + css::uno::XInterface* mpxEventSource; + + ::comphelper::OInterfaceContainerHelper2 maContainerListeners; + ::comphelper::OInterfaceContainerHelper2 maChangesListeners; + +public: + NameContainer( const css::uno::Type& rType ) + : mnElementCount( 0 ) + , mType( rType ) + , mpxEventSource( nullptr ) + , maContainerListeners( m_aMutex ) + , maChangesListeners( m_aMutex ) + {} + + void setEventSource( css::uno::XInterface* pxEventSource ) + { mpxEventSource = pxEventSource; } + + /// @throws css::lang::IllegalArgumentException + /// @throws css::container::ElementExistException + /// @throws css::lang::WrappedTargetException + /// @throws css::uno::RuntimeException + void insertCheck(const OUString& aName, const css::uno::Any& aElement); + + /// @throws css::lang::IllegalArgumentException + /// @throws css::lang::WrappedTargetException + /// @throws css::uno::RuntimeException + void insertNoCheck(const OUString& aName, const css::uno::Any& aElement); + + // Methods XElementAccess + virtual css::uno::Type SAL_CALL getElementType( ) override; + virtual sal_Bool SAL_CALL hasElements( ) override; + + // Methods XNameAccess + virtual css::uno::Any SAL_CALL getByName( const OUString& aName ) override; + virtual css::uno::Sequence< OUString > SAL_CALL getElementNames( ) override; + virtual sal_Bool SAL_CALL hasByName( const OUString& aName ) override; + + // Methods XNameReplace + virtual void SAL_CALL replaceByName( const OUString& aName, const css::uno::Any& aElement ) override; + + // Methods XNameContainer + virtual void SAL_CALL insertByName( const OUString& aName, const css::uno::Any& aElement ) override; + virtual void SAL_CALL removeByName( const OUString& Name ) override; + + // Methods XContainer + virtual void SAL_CALL addContainerListener( const css::uno::Reference<css::container::XContainerListener >& xListener ) override; + virtual void SAL_CALL removeContainerListener( const css::uno::Reference<css::container::XContainerListener >& xListener ) override; + + // Methods XChangesNotifier + virtual void SAL_CALL addChangesListener( const css::uno::Reference<css::util::XChangesListener >& xListener ) override; + virtual void SAL_CALL removeChangesListener( const css::uno::Reference<css::util::XChangesListener >& xListener ) override; +}; + + +class ModifiableHelper +{ +private: + ::comphelper::OInterfaceContainerHelper2 m_aModifyListeners; + ::cppu::OWeakObject& m_rEventSource; + bool mbModified; + +public: + ModifiableHelper( ::cppu::OWeakObject& _rEventSource, ::osl::Mutex& _rMutex ) + :m_aModifyListeners( _rMutex ) + ,m_rEventSource( _rEventSource ) + ,mbModified( false ) + { + } + + bool isModified() const { return mbModified; } + void setModified( bool _bModified ); + + void addModifyListener( const css::uno::Reference< css::util::XModifyListener >& _rxListener ) + { + m_aModifyListeners.addInterface( _rxListener ); + } + + void removeModifyListener( const css::uno::Reference< css::util::XModifyListener >& _rxListener ) + { + m_aModifyListeners.removeInterface( _rxListener ); + } +}; + + +typedef ::comphelper::OListenerContainerBase< + css::script::vba::XVBAScriptListener, + css::script::vba::VBAScriptEvent > VBAScriptListenerContainer_BASE; + +class VBAScriptListenerContainer : public VBAScriptListenerContainer_BASE +{ +public: + explicit VBAScriptListenerContainer( ::osl::Mutex& rMutex ); + +private: + virtual bool implTypedNotify( + const css::uno::Reference< css::script::vba::XVBAScriptListener >& rxListener, + const css::script::vba::VBAScriptEvent& rEvent ) override; +}; + + +class SfxLibrary; + +typedef ::cppu::WeakComponentImplHelper< + css::lang::XInitialization, + css::script::XStorageBasedLibraryContainer, + css::script::XLibraryContainerPassword, + css::script::XLibraryContainerExport, + css::script::XLibraryContainer3, + css::container::XContainer, + css::script::XLibraryQueryExecutable, + css::script::vba::XVBACompatibility, + css::lang::XServiceInfo > SfxLibraryContainer_BASE; + +class SfxLibraryContainer + : public ::cppu::BaseMutex + , public SfxLibraryContainer_BASE + , public ::utl::OEventListenerAdapter +{ + VBAScriptListenerContainer maVBAScriptListeners; + sal_Int32 mnRunningVBAScripts; + bool mbVBACompat; + OUString msProjectName; +protected: + css::uno::Reference< css::uno::XComponentContext > mxContext; + css::uno::Reference< css::ucb::XSimpleFileAccess3 > mxSFI; + css::uno::Reference< css::util::XStringSubstitution > mxStringSubstitution; + css::uno::WeakReference< css::frame::XModel > mxOwnerDocument; + + ModifiableHelper maModifiable; + + rtl::Reference<NameContainer> maNameContainer; + bool mbOldInfoFormat; + bool mbOasis2OOoFormat; + + OUString maInitialDocumentURL; + OUString maInfoFileName; + OUString maOldInfoFileName; + OUString maLibElementFileExtension; + OUString maLibraryPath; + OUString maLibrariesDir; + + css::uno::Reference< css::embed::XStorage > mxStorage; + BasicManager* mpBasMgr; + bool mbOwnBasMgr; + + enum InitMode + { + DEFAULT, + CONTAINER_INIT_FILE, + LIBRARY_INIT_FILE, + OFFICE_DOCUMENT, + OLD_BASIC_STORAGE + } meInitMode; + + void implStoreLibrary( SfxLibrary* pLib, + const OUString& rName, + const css::uno::Reference< css::embed::XStorage >& rStorage ); + + // New variant for library export + void implStoreLibrary( SfxLibrary* pLib, + const OUString& rName, + const css::uno::Reference< css::embed::XStorage >& rStorage, + const OUString& rTargetURL, + const css::uno::Reference< css::ucb::XSimpleFileAccess3 >& rToUseSFI, + const css::uno::Reference< css::task::XInteractionHandler >& rHandler ); + + void implStoreLibraryIndexFile( SfxLibrary* pLib, const ::xmlscript::LibDescriptor& rLib, + const css::uno::Reference< css::embed::XStorage >& xStorage ); + + // New variant for library export + void implStoreLibraryIndexFile( SfxLibrary* pLib, const ::xmlscript::LibDescriptor& rLib, + const css::uno::Reference< css::embed::XStorage >& xStorage, + const OUString& aTargetURL, + const css::uno::Reference< css::ucb::XSimpleFileAccess3 >& rToUseSFI ); + + bool implLoadLibraryIndexFile( SfxLibrary* pLib, + ::xmlscript::LibDescriptor& rLib, + const css::uno::Reference< css::embed::XStorage >& xStorage, + const OUString& aIndexFileName ); + + void implImportLibDescriptor( SfxLibrary* pLib, ::xmlscript::LibDescriptor const & rLib ); + + // Methods to distinguish between different library types + virtual SfxLibrary* implCreateLibrary( const OUString& aName ) = 0; + virtual SfxLibrary* implCreateLibraryLink + ( const OUString& aName, const OUString& aLibInfoFileURL, + const OUString& StorageURL, bool ReadOnly ) = 0; + virtual css::uno::Any createEmptyLibraryElement() = 0; + virtual bool isLibraryElementValid(const css::uno::Any& rElement) const = 0; + /// @throws css::uno::Exception + virtual void writeLibraryElement + ( + const css::uno::Reference< css::container::XNameContainer>& xLibrary, + const OUString& aElementName, + const css::uno::Reference< css::io::XOutputStream >& xOutput + ) = 0; + + virtual css::uno::Any importLibraryElement + ( + const css::uno::Reference< css::container::XNameContainer>& xLibrary, + const OUString& aElementName, + const OUString& aFile, + const css::uno::Reference< css::io::XInputStream >& xElementStream ) = 0; + virtual void importFromOldStorage( const OUString& aFile ) = 0; + + // Password encryption + virtual bool implStorePasswordLibrary( SfxLibrary* pLib, const OUString& aName, + const css::uno::Reference< css::embed::XStorage >& xStorage, const css::uno::Reference< css::task::XInteractionHandler >& Handler ); + + // New variant for library export + virtual bool implStorePasswordLibrary( SfxLibrary* pLib, const OUString& aName, + const css::uno::Reference< css::embed::XStorage >& rStorage, + const OUString& aTargetURL, + const css::uno::Reference< css::ucb::XSimpleFileAccess3 >& rToUseSFI, const css::uno::Reference< css::task::XInteractionHandler >& Handler ); + + /// @throws css::lang::WrappedTargetException + /// @throws css::uno::RuntimeException + virtual bool implLoadPasswordLibrary( SfxLibrary* pLib, const OUString& Name, + bool bVerifyPasswordOnly=false ); + + virtual void onNewRootStorage() = 0; + + + // #56666, Creates another library container + // instance of the same derived class + virtual SfxLibraryContainer* createInstanceImpl() = 0; + + + // Interface to get the BasicManager (Hack for password implementation) + BasicManager* getBasicManager(); + OUString createAppLibraryFolder( SfxLibrary* pLib, const OUString& aName ); + + void init( const OUString& rInitialDocumentURL, + const css::uno::Reference< css::embed::XStorage >& _rxInitialStorage ); + + virtual const char* getInfoFileName() const = 0; + virtual const char* getOldInfoFileName() const = 0; + virtual const char* getLibElementFileExtension() const = 0; + virtual const char* getLibrariesDir() const = 0; + + // Handle maLibInfoFileURL and maStorageURL correctly + void checkStorageURL + ( + const OUString& aSourceURL, + OUString& aLibInfoFileURL, + OUString& aStorageURL, + OUString& aUnexpandedStorageURL + ); + /// @throws css::uno::RuntimeException + OUString expand_url( const OUString& url ); + + SfxLibrary* getImplLib( const OUString& rLibraryName ); + + void storeLibraries_Impl( + const css::uno::Reference< css::embed::XStorage >& xStorage, + bool bComplete ); + + void initializeFromDocument( const css::uno::Reference< css::document::XStorageBasedDocument >& _rxDocument ); + + // OEventListenerAdapter + virtual void _disposing( const css::lang::EventObject& _rSource ) override; + + // OComponentHelper + virtual void SAL_CALL disposing() override; + +private: + void init_Impl( const OUString& rInitialDocumentURL, + const css::uno::Reference< css::embed::XStorage >& _rxInitialStorage ); + void implScanExtensions(); + +public: + SfxLibraryContainer(); + virtual ~SfxLibraryContainer() override; + + + // Interface to set the BasicManager (Hack for password implementation) + void setBasicManager( BasicManager* pBasMgr ) + { + mpBasMgr = pBasMgr; + } + + void enterMethod(); + static void leaveMethod(); + + // Methods XElementAccess + virtual css::uno::Type SAL_CALL getElementType() override; + virtual sal_Bool SAL_CALL hasElements() override; + + // Methods XNameAccess + virtual css::uno::Any SAL_CALL getByName( const OUString& aName ) override; + virtual css::uno::Sequence< OUString > SAL_CALL getElementNames() override; + virtual sal_Bool SAL_CALL hasByName( const OUString& aName ) override; + + // Members XStorageBasedLibraryContainer + virtual css::uno::Reference< css::embed::XStorage > SAL_CALL getRootStorage() override; + virtual void SAL_CALL setRootStorage( const css::uno::Reference< css::embed::XStorage >& _rootstorage ) override; + virtual void SAL_CALL storeLibrariesToStorage( const css::uno::Reference< css::embed::XStorage >& RootStorage ) override; + + // Methods XModifiable (base of XPersistentLibraryContainer) + virtual sal_Bool SAL_CALL isModified( ) override; + virtual void SAL_CALL setModified( sal_Bool bModified ) override; + virtual void SAL_CALL addModifyListener( const css::uno::Reference< css::util::XModifyListener >& aListener ) override; + virtual void SAL_CALL removeModifyListener( const css::uno::Reference< css::util::XModifyListener >& aListener ) override; + + // Methods XPersistentLibraryContainer (base of XStorageBasedLibraryContainer) + virtual css::uno::Any SAL_CALL getRootLocation() override; + virtual OUString SAL_CALL getContainerLocationName() override; + virtual void SAL_CALL storeLibraries( ) override; + + //Methods XLibraryContainer3 + virtual OUString SAL_CALL getOriginalLibraryLinkURL( const OUString& Name ) override; + + // Methods XLibraryContainer2 (base of XPersistentLibraryContainer) + virtual sal_Bool SAL_CALL isLibraryLink( const OUString& Name ) override; + virtual OUString SAL_CALL getLibraryLinkURL( const OUString& Name ) override; + virtual sal_Bool SAL_CALL isLibraryReadOnly( const OUString& Name ) override; + virtual void SAL_CALL setLibraryReadOnly( const OUString& Name, sal_Bool bReadOnly ) override; + virtual void SAL_CALL renameLibrary( const OUString& Name, const OUString& NewName ) override; + + // Methods XLibraryContainer (base of XLibraryContainer2) + virtual css::uno::Reference< css::container::XNameContainer > SAL_CALL + createLibrary( const OUString& Name ) override; + virtual css::uno::Reference< css::container::XNameAccess > SAL_CALL createLibraryLink + ( const OUString& Name, const OUString& StorageURL, sal_Bool ReadOnly ) override; + virtual void SAL_CALL removeLibrary( const OUString& Name ) override; + virtual sal_Bool SAL_CALL isLibraryLoaded( const OUString& Name ) override; + virtual void SAL_CALL loadLibrary( const OUString& Name ) override; + + // Methods XInitialization + virtual void SAL_CALL initialize( const css::uno::Sequence< + css::uno::Any >& aArguments ) override; + + // Methods XLibraryContainerPassword + virtual sal_Bool SAL_CALL isLibraryPasswordProtected( const OUString& Name ) override; + virtual sal_Bool SAL_CALL isLibraryPasswordVerified( const OUString& Name ) override; + virtual sal_Bool SAL_CALL verifyLibraryPassword( const OUString& Name, const OUString& Password ) override; + virtual void SAL_CALL changeLibraryPassword( const OUString& Name, + const OUString& OldPassword, const OUString& NewPassword ) override; + + // Methods XContainer + virtual void SAL_CALL addContainerListener( const css::uno::Reference< + css::container::XContainerListener >& xListener ) override; + virtual void SAL_CALL removeContainerListener( const css::uno::Reference< + css::container::XContainerListener >& xListener ) override; + + // Methods XLibraryContainerExport + virtual void SAL_CALL exportLibrary( const OUString& Name, const OUString& URL, + const css::uno::Reference< css::task::XInteractionHandler >& Handler ) override; + + // Methods XServiceInfo + virtual OUString SAL_CALL getImplementationName( ) override = 0; + virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override; + virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames( ) override = 0; + // Methods XVBACompatibility + virtual sal_Bool SAL_CALL getVBACompatibilityMode() override; + virtual void SAL_CALL setVBACompatibilityMode( sal_Bool _vbacompatmodeon ) override; + virtual OUString SAL_CALL getProjectName() override { return msProjectName; } + virtual void SAL_CALL setProjectName( const OUString& _projectname ) override; + virtual sal_Int32 SAL_CALL getRunningVBAScripts() override; + virtual void SAL_CALL addVBAScriptListener( + const css::uno::Reference< css::script::vba::XVBAScriptListener >& Listener ) override; + virtual void SAL_CALL removeVBAScriptListener( + const css::uno::Reference< css::script::vba::XVBAScriptListener >& Listener ) override; + virtual void SAL_CALL broadcastVBAScriptEvent( sal_Int32 nIdentifier, const OUString& rModuleName ) override; +}; + + +class LibraryContainerMethodGuard +{ +public: + LibraryContainerMethodGuard( SfxLibraryContainer& _rContainer ) + { + _rContainer.enterMethod(); + } + + ~LibraryContainerMethodGuard() + { + basic::SfxLibraryContainer::leaveMethod(); + } +}; + + +class SfxLibrary + : public css::container::XNameContainer + , public css::container::XContainer + , public css::util::XChangesNotifier + , public ::cppu::BaseMutex + , public ::cppu::OComponentHelper +{ + friend class SfxLibraryContainer; + friend class SfxDialogLibraryContainer; + friend class SfxScriptLibraryContainer; + + css::uno::Reference< css::ucb::XSimpleFileAccess3 > mxSFI; + + ModifiableHelper& mrModifiable; + rtl::Reference<NameContainer> maNameContainer; + + bool mbLoaded; + bool mbIsModified; + bool mbInitialised; + +private: + + OUString maLibElementFileExtension; + OUString maLibInfoFileURL; + OUString maStorageURL; + OUString maUnexpandedStorageURL; + OUString maOriginalStorageURL; + + bool mbLink; + bool mbReadOnly; + bool mbReadOnlyLink; + bool mbPreload; + +protected: + bool mbPasswordProtected; +private: + bool mbPasswordVerified; + bool mbDoc50Password; + OUString maPassword; + + bool mbSharedIndexFile; + bool mbExtension; + + // Additional functionality for localisation + // Provide modify state including resources + virtual bool isModified() = 0; + virtual void storeResources() = 0; + virtual void storeResourcesAsURL( const OUString& URL, const OUString& NewName ) = 0; + virtual void storeResourcesToURL( const OUString& URL, + const css::uno::Reference< css::task::XInteractionHandler >& xHandler ) = 0; + virtual void storeResourcesToStorage( const css::uno::Reference< css::embed::XStorage >& xStorage ) = 0; + +protected: + bool implIsModified() const { return mbIsModified; } + void implSetModified( bool _bIsModified ); + +private: + /** checks whether the lib is readonly, or a readonly link, throws an IllegalArgumentException if so + */ + void impl_checkReadOnly(); + /** checks whether the library is loaded, throws a LibraryNotLoadedException (wrapped in a WrappedTargetException), + if not. + */ + void impl_checkLoaded(); + +private: + void impl_removeWithoutChecks( const OUString& _rElementName ); + +public: + SfxLibrary( + ModifiableHelper& _rModifiable, + const css::uno::Type& aType, + const css::uno::Reference< css::ucb::XSimpleFileAccess3 >& xSFI + ); + SfxLibrary( + ModifiableHelper& _rModifiable, + const css::uno::Type& aType, + const css::uno::Reference< css::ucb::XSimpleFileAccess3 >& xSFI, + const OUString& aLibInfoFileURL, + const OUString& aStorageURL, + bool ReadOnly + ); + + // Methods XInterface + virtual css::uno::Any SAL_CALL queryInterface( const css::uno::Type& rType ) override; + virtual void SAL_CALL acquire() throw() override { OComponentHelper::acquire(); } + virtual void SAL_CALL release() throw() override { OComponentHelper::release(); } + + // Methods XElementAccess + virtual css::uno::Type SAL_CALL getElementType( ) override; + virtual sal_Bool SAL_CALL hasElements( ) override; + + // Methods XNameAccess + virtual css::uno::Any SAL_CALL getByName( const OUString& aName ) override; + virtual css::uno::Sequence< OUString > SAL_CALL getElementNames( ) override; + virtual sal_Bool SAL_CALL hasByName( const OUString& aName ) override; + + // Methods XNameReplace + virtual void SAL_CALL replaceByName( const OUString& aName, const css::uno::Any& aElement ) override; + + // Methods XNameContainer + virtual void SAL_CALL insertByName( const OUString& aName, const css::uno::Any& aElement ) override; + virtual void SAL_CALL removeByName( const OUString& Name ) override; + + // XTypeProvider + css::uno::Sequence< css::uno::Type > SAL_CALL getTypes( ) override; + css::uno::Sequence<sal_Int8> SAL_CALL getImplementationId( ) override; + + // Methods XContainer + virtual void SAL_CALL addContainerListener( const css::uno::Reference< + css::container::XContainerListener >& xListener ) override; + virtual void SAL_CALL removeContainerListener( const css::uno::Reference< + css::container::XContainerListener >& xListener ) override; + + // Methods XChangesNotifier + virtual void SAL_CALL addChangesListener( const css::uno::Reference< + css::util::XChangesListener >& xListener ) override; + virtual void SAL_CALL removeChangesListener( const css::uno::Reference< + css::util::XChangesListener >& xListener ) override; + +public: + struct LibraryContainerAccess { friend class SfxLibraryContainer; private: LibraryContainerAccess() { } }; + void removeElementWithoutChecks( const OUString& _rElementName, LibraryContainerAccess ) + { + impl_removeWithoutChecks( _rElementName ); + } + +protected: + virtual bool isLoadedStorable(); + + virtual bool isLibraryElementValid(const css::uno::Any& rElement) const = 0; +}; + + +class ScriptSubPackageIterator +{ + css::uno::Reference< css::deployment::XPackage > m_xMainPackage; + + bool m_bIsValid; + bool m_bIsBundle; + + css::uno::Sequence< css::uno::Reference< css::deployment::XPackage > > m_aSubPkgSeq; + sal_Int32 m_nSubPkgCount; + sal_Int32 m_iNextSubPkg; + + static css::uno::Reference< css::deployment::XPackage > + implDetectScriptPackage( const css::uno::Reference + < css::deployment::XPackage >& rPackage, bool& rbPureDialogLib ); + +public: + ScriptSubPackageIterator( css::uno::Reference< css::deployment::XPackage > const & xMainPackage ); + + css::uno::Reference< css::deployment::XPackage > getNextScriptSubPackage( bool& rbPureDialogLib ); +}; + + +class ScriptExtensionIterator final +{ +public: + ScriptExtensionIterator(); + OUString nextBasicOrDialogLibrary( bool& rbPureDialogLib ); + +private: + css::uno::Reference< css::deployment::XPackage > + implGetNextUserScriptPackage( bool& rbPureDialogLib ); + css::uno::Reference< css::deployment::XPackage > + implGetNextSharedScriptPackage( bool& rbPureDialogLib ); + css::uno::Reference< css::deployment::XPackage > + implGetNextBundledScriptPackage( bool& rbPureDialogLib ); + + css::uno::Reference< css::uno::XComponentContext > m_xContext; + + enum IteratorState + { + USER_EXTENSIONS, + SHARED_EXTENSIONS, + BUNDLED_EXTENSIONS, + END_REACHED + } m_eState; + + css::uno::Sequence< css::uno::Reference< css::deployment::XPackage > > m_aUserPackagesSeq; + bool m_bUserPackagesLoaded; + + css::uno::Sequence< css::uno::Reference< css::deployment::XPackage > > m_aSharedPackagesSeq; + bool m_bSharedPackagesLoaded; + + css::uno::Sequence< css::uno::Reference< css::deployment::XPackage > > m_aBundledPackagesSeq; + bool m_bBundledPackagesLoaded; + + int m_iUserPackage; + int m_iSharedPackage; + int m_iBundledPackage; + + ScriptSubPackageIterator* m_pScriptSubPackageIterator; + +}; // end class ScriptExtensionIterator + + +} // namespace basic + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basic/source/inc/opcodes.hxx b/basic/source/inc/opcodes.hxx new file mode 100644 index 000000000..cb9711036 --- /dev/null +++ b/basic/source/inc/opcodes.hxx @@ -0,0 +1,159 @@ +/* -*- 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_SOURCE_INC_OPCODES_HXX +#define INCLUDED_BASIC_SOURCE_INC_OPCODES_HXX + +// An opcode can have a length of 1, 3 or 5 bytes, +// depending on its numeric value (see below). + +enum class SbiOpcode { + // all opcodes without operands + NOP_ = 0, + + SbOP0_START = NOP_, + + // operators + // the following operators are ordered + // the same way as the enum SbxVarOp + EXP_, MUL_, DIV_, MOD_, PLUS_, MINUS_, NEG_, + EQ_, NE_, LT_, GT_, LE_, GE_, + IDIV_, AND_, OR_, XOR_, EQV_, IMP_, NOT_, + CAT_, + // end of enum SbxVarOp + LIKE_, IS_, + // load/save + ARGC_, // establish new Argv + ARGV_, // TOS ==> current Argv + INPUT_, // Input ==> TOS + LINPUT_, // Line Input ==> TOS + GET_, // touch TOS + SET_, // save object TOS ==> TOS-1 + PUT_, // TOS ==> TOS-1 + PUTC_, // TOS ==> TOS-1, then ReadOnly + DIM_, // DIM + REDIM_, // REDIM + REDIMP_, // REDIM PRESERVE + ERASE_, // delete TOS + // branch + STOP_, // end of program + INITFOR_, // initialize FOR-variable + NEXT_, // increment FOR-variable + CASE_, // beginning CASE + ENDCASE_, // end CASE + STDERROR_, // standard error handling + NOERROR_, // no error handling + LEAVE_, // leave UP + // E/A + CHANNEL_, // TOS = channel number + BPRINT_, // print TOS + PRINTF_, // print TOS in field + BWRITE_, // write TOS + RENAME_, // Rename Tos+1 to Tos + PROMPT_, // TOS = Prompt for Input + RESTART_, // define restart point + CHAN0_, // I/O-channel 0 + // miscellaneous + EMPTY_, // empty expression on stack + ERROR_, // TOS = error code + LSET_, // saving object TOS ==> TOS-1 + RSET_, // saving object TOS ==> TOS-1 + REDIMP_ERASE_, // Copies array to be later used by REDIM PRESERVE before erasing it + INITFOREACH_, + VBASET_, // VBA-like Set + ERASE_CLEAR_, // Erase array and clear variable + ARRAYACCESS_, // Assign parameters to TOS and get value, used for array of arrays + BYVAL_, // byref -> byval for lvalue parameter passed in call + + SbOP0_END = BYVAL_, + + // all opcodes with one operand + + NUMBER_ = 0x40, // loading a numeric constant (+ID) + + SbOP1_START = NUMBER_, + + SCONST_, // loading a string constant (+ID) + CONST_, // Immediate Load (+ value) + ARGN_, // saving a named Arg in Argv (+StringID) + PAD_, // bring string to a firm length (+length) + // branch + JUMP_, // jump (+target) + JUMPT_, // evaluate TOS, conditional jump (+target) + JUMPF_, // evaluate TOS, conditional jump (+target) + ONJUMP_, // evaluate TOS, jump into JUMP-table (+MaxVal) + GOSUB_, // UP-call (+Target) + RETURN_, // UP-return (+0 or Target) + TESTFOR_, // test FOR-variable, increment (+Endlabel) + CASETO_, // Tos+1 <= Case <= Tos, 2xremove (+Target) + ERRHDL_, // error handler (+Offset) + RESUME_, // Resume after errors (+0 or 1 or Label) + // E/A + CLOSE_, // (+channel/0) + PRCHAR_, // (+char) + // management + SETCLASS_, // test set + class names (+StringId) + TESTCLASS_, // Check TOS class (+StringId) + LIB_, // set lib name for declare-procs (+StringId) + BASED_, // TOS is incremented by BASE, BASE is pushed before (+base) + // type adjustment in the Argv + ARGTYP_, // convert last parameter in Argv (+type) + VBASETCLASS_, // VBA-like Set + + SbOP1_END = VBASETCLASS_, + + // all opcodes with two operands + + RTL_ = 0x80, // load from the RTL (+StringID+Typ) + + SbOP2_START = RTL_, + + FIND_, // load (+StringID+Typ) + ELEM_, // load element (+StringID+Typ) + PARAM_, // parameters (+Offset+Typ) + // branch + CALL_, // call DECLARE-method (+StringID+Typ) + CALLC_, // call Cdecl-DECLARE-Method (+StringID+Typ) + CASEIS_, // case-test (+Test-Opcode+True-Target) + // management + STMNT_, // begin of a statement (+Line+Col) + // E/A + OPEN_, // (+StreamMode+Flags) + // objects + LOCAL_, // define locals variables (+StringID+Typ) + PUBLIC_, // module global variables (+StringID+Typ) + GLOBAL_, // define global variables, public command (+StringID+Typ) + CREATE_, // create object (+StringId+StringID) + STATIC_, // static variable (+StringID+Typ) JSM + TCREATE_, // create user-defined object + DCREATE_, // create object-array (+StringId+StringID) + GLOBAL_P_, // define global variable that's not overwritten on restarting + // the Basic, P=PERSIST (+StringID+Typ) + FIND_G_, // finds global variable with special treatment due to GLOBAL_P_ + DCREATE_REDIMP_, // redimension object-array (+StringId+StringID) + FIND_CM_, // Search inside a class module (CM) to enable global search in time + PUBLIC_P_, // Module global Variable (persisted between calls)(+StringID+Typ) + FIND_STATIC_, // local static var lookup (+StringID+Typ) + + SbOP2_END = FIND_STATIC_ +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basic/source/inc/parser.hxx b/basic/source/inc/parser.hxx new file mode 100644 index 000000000..88f4f34b2 --- /dev/null +++ b/basic/source/inc/parser.hxx @@ -0,0 +1,144 @@ +/* -*- 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_SOURCE_INC_PARSER_HXX +#define INCLUDED_BASIC_SOURCE_INC_PARSER_HXX + +#include "expr.hxx" +#include "codegen.hxx" +#include "symtbl.hxx" +#include <basic/sbx.hxx> + +#include <vector> + +struct SbiParseStack; + +class SbiParser : public SbiTokenizer +{ + friend class SbiExpression; + + SbiParseStack* pStack; + SbiProcDef* pProc; + SbiExprNode* pWithVar; + SbiToken eEndTok; + sal_uInt32 nGblChain; // for global DIMs + bool bGblDefs; // true: global definitions general + bool bNewGblDefs; // true: globale definitions before sub + bool bSingleLineIf; + bool bCodeCompleting; + + SbiSymDef* VarDecl( SbiExprListPtr*, bool, bool ); + SbiProcDef* ProcDecl(bool bDecl); + void DefStatic( bool bPrivate ); + void DefProc( bool bStatic, bool bPrivate ); // read in procedure + void DefVar( SbiOpcode eOp, bool bStatic ); // read in DIM/REDIM + void TypeDecl( SbiSymDef&, bool bAsNewAlreadyParsed=false ); // AS-declaration + void OpenBlock( SbiToken, SbiExprNode* = nullptr ); + void CloseBlock(); + bool Channel( bool bAlways=false ); // parse channel number + void StmntBlock( SbiToken ); + void DefType(); // Parse type declaration + void DefEnum( bool bPrivate ); // Parse enum declaration + void DefDeclare( bool bPrivate ); + void EnableCompatibility(); + static bool IsUnoInterface( const OUString& sTypeName ); +public: + SbxArrayRef rTypeArray; + SbxArrayRef rEnumArray; + SbiStringPool aGblStrings; // string-pool + SbiStringPool aLclStrings; // string-pool + SbiSymPool aGlobals; + SbiSymPool aPublics; // module global + SbiSymPool aRtlSyms; // Runtime-Library + SbiCodeGen aGen; // Code-Generator + SbiSymPool* pPool; + short nBase; // OPTION BASE-value + bool bExplicit; // true: OPTION EXPLICIT + bool bClassModule; // true: OPTION ClassModule + std::vector<OUString> aIfaceVector; // Holds all interfaces implemented by a class module + std::vector<OUString> aRequiredTypes; // Types used in Dim As New <type> outside subs +# define N_DEF_TYPES 26 + SbxDataType eDefTypes[N_DEF_TYPES]; // DEFxxx data types + + SbiParser( StarBASIC*, SbModule* ); + ~SbiParser( ); + bool Parse(); + void SetCodeCompleting( bool b ); + bool IsCodeCompleting() const { return bCodeCompleting;} + SbiExprNode* GetWithVar(); + + // from 31.3.1996, search symbol in the runtime-library + SbiSymDef* CheckRTLForSym( const OUString& rSym, SbxDataType eType ); + void AddConstants(); + + bool HasGlobalCode(); + + bool TestToken( SbiToken ); + bool TestSymbol(); + bool TestComma(); + void TestEoln(); + + void Symbol( const KeywordSymbolInfo* pKeywordSymbolInfo ); // let or call + void ErrorStmnt(); // ERROR n + void BadBlock(); // LOOP/WEND/NEXT + void NoIf(); // ELSE/ELSE IF without IF + void Assign(); // LET + void Attribute(); + void Call(); // CALL + void Close(); // CLOSE + void Declare(); // DECLARE + void DefXXX(); // DEFxxx + void Dim(); // DIM + void ReDim(); // ReDim(); + void Erase(); // ERASE + void Exit(); // EXIT + void For(); // FOR...NEXT + void Goto(); // GOTO / GOSUB + void If(); // IF + void Implements(); // IMPLEMENTS + void Input(); // INPUT, INPUT # + void Line(); // LINE -> LINE INPUT [#] (#i92642) + void LineInput(); // LINE INPUT, LINE INPUT # + void LSet(); // LSET + void Name(); // NAME .. AS .. + void On(); // ON ERROR/variable + void OnGoto(); // ON...GOTO / GOSUB + void Open(); // OPEN + void Option(); // OPTION + void Print(); // PRINT, PRINT # + void SubFunc(); // SUB / FUNCTION + void Resume(); // RESUME + void Return(); // RETURN + void RSet(); // RSET + void DoLoop(); // DO...LOOP + void Select(); // SELECT ... CASE + void Set(); // SET + void Static(); // STATIC + void Stop(); // STOP/SYSTEM + void Type(); // TYPE...AS...END TYPE + void Enum(); // TYPE...END ENUM + void While(); // WHILE/WEND + void With(); // WITH + void Write(); // WRITE +}; + + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basic/source/inc/propacc.hxx b/basic/source/inc/propacc.hxx new file mode 100644 index 000000000..c00673055 --- /dev/null +++ b/basic/source/inc/propacc.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_SOURCE_INC_PROPACC_HXX +#define INCLUDED_BASIC_SOURCE_INC_PROPACC_HXX + +#include <com/sun/star/beans/PropertyValue.hpp> +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/beans/XPropertySetInfo.hpp> +#include <com/sun/star/beans/XPropertyAccess.hpp> +#include <cppuhelper/implbase.hxx> + +#include <vector> + +typedef std::vector<css::beans::PropertyValue> SbPropertyValueArr_Impl; + +typedef ::cppu::WeakImplHelper< css::beans::XPropertySet, + css::beans::XPropertyAccess > SbPropertyValuesHelper; + + +class SbPropertyValues: public SbPropertyValuesHelper +{ + SbPropertyValueArr_Impl m_aPropVals; + css::uno::Reference< css::beans::XPropertySetInfo > m_xInfo; + +private: + size_t GetIndex_Impl( const OUString &rPropName ) const; + +public: + SbPropertyValues(); + virtual ~SbPropertyValues() override; + + // XPropertySet + virtual css::uno::Reference< css::beans::XPropertySetInfo > SAL_CALL + getPropertySetInfo() override; + virtual void SAL_CALL setPropertyValue( + const OUString& aPropertyName, + const css::uno::Any& aValue) override; + virtual css::uno::Any SAL_CALL getPropertyValue( const OUString& PropertyName ) override; + virtual void SAL_CALL addPropertyChangeListener( + const OUString& aPropertyName, + const css::uno::Reference< css::beans::XPropertyChangeListener >& ) override; + virtual void SAL_CALL removePropertyChangeListener( + const OUString& aPropertyName, + const css::uno::Reference< css::beans::XPropertyChangeListener >& ) override; + virtual void SAL_CALL addVetoableChangeListener( + const OUString& aPropertyName, + const css::uno::Reference< css::beans::XVetoableChangeListener >& ) override; + virtual void SAL_CALL removeVetoableChangeListener( + const OUString& aPropertyName, + const css::uno::Reference< css::beans::XVetoableChangeListener >& ) override; + + // XPropertyAccess + virtual css::uno::Sequence< css::beans::PropertyValue > SAL_CALL getPropertyValues() override; + virtual void SAL_CALL setPropertyValues(const css::uno::Sequence< css::beans::PropertyValue >& PropertyValues_) override; +}; + +class SbxArray; + +void RTL_Impl_CreatePropertySet( SbxArray& rPar ); + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basic/source/inc/rtlproto.hxx b/basic/source/inc/rtlproto.hxx new file mode 100644 index 000000000..6e26f9316 --- /dev/null +++ b/basic/source/inc/rtlproto.hxx @@ -0,0 +1,365 @@ +/* -*- 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_SOURCE_INC_RTLPROTO_HXX +#define INCLUDED_BASIC_SOURCE_INC_RTLPROTO_HXX + +#include <basic/sbstar.hxx> + +#define RTLNAME( name ) &SbRtl_##name + +typedef void( *RtlCall ) ( StarBASIC* p, SbxArray& rArgs, bool bWrite ); + +// Properties + +extern void SbRtl_Date(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Err(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Erl(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_False(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Empty(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Nothing(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Null(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_True(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); + +extern void SbRtl_ATTR_NORMAL(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_ATTR_READONLY(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_ATTR_HIDDEN(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_ATTR_SYSTEM(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_ATTR_VOLUME(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_ATTR_DIRECTORY(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_ATTR_ARCHIVE(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); + +extern void SbRtl_V_EMPTY(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_V_NULL(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_V_INTEGER(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_V_LONG(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_V_SINGLE(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_V_DOUBLE(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_V_CURRENCY(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_V_DATE(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_V_STRING(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); + +extern void SbRtl_MB_OK(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_MB_OKCANCEL(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_MB_ABORTRETRYIGNORE(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_MB_YESNOCANCEL(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_MB_YESNO(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_MB_RETRYCANCEL(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_MB_ICONSTOP(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_MB_ICONQUESTION(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_MB_ICONEXCLAMATION(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_MB_ICONINFORMATION(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_MB_DEFBUTTON1(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_MB_DEFBUTTON2(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_MB_DEFBUTTON3(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_MB_APPLMODAL(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_MB_SYSTEMMODAL(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); + +extern void SbRtl_IDOK(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_IDCANCEL(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_IDABORT(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_IDRETRY(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_IDYES(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_IDNO(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); + +extern void SbRtl_CF_TEXT(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_CF_BITMAP(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_CF_METAFILEPICT(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); + +extern void SbRtl_PI(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); + +extern void SbRtl_SET_OFF(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_SET_ON(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_TOGGLE(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); + +extern void SbRtl_TYP_AUTHORFLD(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_TYP_CHAPTERFLD(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_TYP_CONDTXTFLD(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_TYP_DATEFLD(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_TYP_DBFLD(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_TYP_DBNAMEFLD(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_TYP_DBNEXTSETFLD(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_TYP_DBNUMSETFLD(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_TYP_DBSETNUMBERFLD(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_TYP_DDEFLD(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_TYP_DOCINFOFLD(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_TYP_DOCSTATFLD(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_TYP_EXTUSERFLD(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_TYP_FILENAMEFLD(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_TYP_FIXDATEFLD(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_TYP_FIXTIMEFLD(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_TYP_FORMELFLD(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_TYP_GETFLD(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_TYP_GETREFFLD(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_TYP_HIDDENPARAFLD(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_TYP_HIDDENTXTFLD(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_TYP_INPUTFLD(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_TYP_MACROFLD(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_TYP_NEXTPAGEFLD(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_TYP_PAGENUMBERFLD(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_TYP_POSTITFLD(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_TYP_PREVPAGEFLD(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_TYP_SEQFLD(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_TYP_SETFLD(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_TYP_SETINPFLD(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_TYP_SETREFFLD(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_TYP_TEMPLNAMEFLD(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_TYP_TIMEFLD(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_TYP_USERFLD(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_TYP_USRINPFLD(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_TYP_SETREFPAGEFLD(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_TYP_GETREFPAGEFLD(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_TYP_INTERNETFLD(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_TYP_JUMPEDITFLD(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); + +extern void SbRtl_FRAMEANCHORPAGE(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_FRAMEANCHORPARA(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_FRAMEANCHORCHAR(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); + +extern void SbRtl_CLEAR_ALLTABS(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_CLEAR_TAB(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_SET_TAB(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); + +// Methods + +extern void SbRtl_CreateObject(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Error(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Sin(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Abs(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Asc(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Atn(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Chr(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_ChrW(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Cos(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_CurDir(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_ChDir(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); // JSM +extern void SbRtl_ChDrive(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); // JSM +extern void SbRtl_FileCopy(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); // JSM +extern void SbRtl_Kill(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); // JSM +extern void SbRtl_MkDir(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); // JSM +extern void SbRtl_RmDir(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); // JSM +extern void SbRtl_SendKeys(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); // JSM +extern void SbRtl_DDB(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_DimArray(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Dir(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_DoEvents(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Exp(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_FileLen(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Fix(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_FV(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Hex(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Input(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_InStr(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_InStrRev(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Int(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_IPmt(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_IRR(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Join(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_LCase(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Left(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Log(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_LTrim(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Mid(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_MIRR(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_NPer(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_NPV(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Oct(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Pmt(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_PPmt(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_PV(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Rate(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Replace(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Right(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_RTrim(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_RTL(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Sgn(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_SLN(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Space(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Split(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Sqr(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Str(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_StrComp(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_String(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_StrReverse(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_SYD(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Tab(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Tan(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_UCase(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Val(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Len(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Spc(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_DateSerial(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_TimeSerial(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_DateValue(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_TimeValue(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Day(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Hour(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Minute(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Month(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_MonthName(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Now(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Second(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Time(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Timer(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Weekday(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_WeekdayName(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Year(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_InputBox(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Me(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_MsgBox(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_IsArray(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_IsDate(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_IsEmpty(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_IsError(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_IsNull(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_IsNumeric(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_IsObject(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_IsUnoStruct(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); + +extern void SbRtl_FileDateTime(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Format(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_FormatNumber(StarBASIC* pBasic, SbxArray& rPar, bool bWrite); +extern void SbRtl_GetAttr(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Randomize(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); // JSM +extern void SbRtl_Round(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Frac(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Rnd(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Shell(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_VarType(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_TypeName(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_TypeLen(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); + +extern void SbRtl_EOF(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_FileAttr(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Loc(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Lof(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Seek(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_SetAttr(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); // JSM +extern void SbRtl_Reset(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); // JSM + +extern void SbRtl_DDEInitiate(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_DDETerminate(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_DDETerminateAll(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_DDERequest(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_DDEExecute(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_DDEPoke(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); + +extern void SbRtl_FreeFile(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_IsMissing(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_LBound(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_UBound(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_RGB(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_QBColor(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_StrConv(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); + +extern void SbRtl_Beep(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); + +extern void SbRtl_Load(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Unload(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_LoadPicture(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_SavePicture(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); + +extern void SbRtl_CallByName(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_CBool(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); // JSM +extern void SbRtl_CByte(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); // JSM +extern void SbRtl_CCur(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); // JSM +extern void SbRtl_CDate(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); // JSM +extern void SbRtl_CDbl(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); // JSM +extern void SbRtl_CInt(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); // JSM +extern void SbRtl_CLng(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); // JSM +extern void SbRtl_CSng(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); // JSM +extern void SbRtl_CStr(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); // JSM +extern void SbRtl_CVar(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); // JSM +extern void SbRtl_CVErr(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); // JSM + +extern void SbRtl_Iif(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); // JSM + +extern void SbRtl_DumpAllObjects(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); + +extern void SbRtl_GetSystemType(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_GetGUIType(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Red(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Green(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Blue(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); + +extern void SbRtl_Switch(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Wait(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +//i#64882# add new WaitUntil +extern void SbRtl_WaitUntil(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_FuncCaller(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); + +extern void SbRtl_GetGUIVersion(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Choose(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Trim(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); + +extern void SbRtl_DateAdd(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_DateDiff(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_DatePart(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_FormatDateTime(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_GetSolarVersion(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_TwipsPerPixelX(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_TwipsPerPixelY(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_FreeLibrary(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Array(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_FindObject(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_FindPropertyObject(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_EnableReschedule(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); + +extern void SbRtl_Put(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Get(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_Environ(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_GetDialogZoomFactorX(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_GetDialogZoomFactorY(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_GetSystemTicks(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_GetPathSeparator(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_ResolvePath(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_CreateUnoStruct(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_CreateUnoService(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_CreateUnoServiceWithArguments(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_CreateUnoValue(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_GetProcessServiceManager(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_GetDefaultContext(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_CreatePropertySet(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_CreateUnoListener(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_HasUnoInterfaces(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_EqualUnoObjects(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_CreateUnoDialog(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_GlobalScope(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_FileExists(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_ConvertToUrl(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_ConvertFromUrl(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_CDateToUnoDate(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_CDateFromUnoDate(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_CDateToUnoTime(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_CDateFromUnoTime(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_CDateToUnoDateTime(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_CDateFromUnoDateTime(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_CDateToIso(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_CDateFromIso(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_CompatibilityMode(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); +extern void SbRtl_CDec(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); + +extern void SbRtl_Partition(StarBASIC * pBasic, SbxArray & rPar, bool bWrite); // Fong + +extern double Now_Impl(); +extern void Wait_Impl( bool bDurationBased, SbxArray& rPar ); + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basic/source/inc/runtime.hxx b/basic/source/inc/runtime.hxx new file mode 100644 index 000000000..65be051e7 --- /dev/null +++ b/basic/source/inc/runtime.hxx @@ -0,0 +1,421 @@ +/* -*- 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_SOURCE_INC_RUNTIME_HXX +#define INCLUDED_BASIC_SOURCE_INC_RUNTIME_HXX + +#include <basic/sberrors.hxx> +#include <basic/sbmeth.hxx> +#include <basic/sbstar.hxx> +#include <basic/sbx.hxx> + +#include <rtl/ustring.hxx> +#include <com/sun/star/uno/Sequence.hxx> +#include <osl/file.hxx> +#include <rtl/math.hxx> +#include <i18nlangtag/lang.h> + +#include <vector> +#include <memory> +#include <com/sun/star/lang/XComponent.hpp> +#include <com/sun/star/container/XEnumeration.hpp> +#include <unotools/localedatawrapper.hxx> +#include <o3tl/deleter.hxx> +#include <o3tl/typed_flags_set.hxx> + +class SbiInstance; // active StarBASIC process +class SbiRuntime; // active StarBASIC procedure instance + +struct SbiArgv; // Argv stack element +struct SbiGosub; // GOSUB stack element +class SbiImage; // Code-Image +class SbiIoSystem; +class SbiDdeControl; +class SbiDllMgr; +class SvNumberFormatter; // time/date functions +enum class SbiImageFlags; + +enum class ForType { + To, + EachArray, + EachCollection, + EachXEnumeration, + Error, +}; + +struct SbiForStack { // for/next stack: + SbiForStack* pNext; // Chain + SbxVariableRef refVar; // loop variable + SbxVariableRef refEnd; // end expression / for each: Array/BasicCollection object + SbxVariableRef refInc; // increment expression + + // For each support + ForType eForType; + sal_Int32 nCurCollectionIndex; + std::unique_ptr<sal_Int32[]> + pArrayCurIndices; + std::unique_ptr<sal_Int32[]> + pArrayLowerBounds; + std::unique_ptr<sal_Int32[]> + pArrayUpperBounds; + css::uno::Reference< css::container::XEnumeration > xEnumeration; + + SbiForStack() + : pNext(nullptr) + , eForType(ForType::To) + , nCurCollectionIndex(0) + {} +}; + +#define MAXRECURSION 500 //to prevent dead-recursions + +enum class SbAttributes { + NONE = 0x0000, + READONLY = 0x0001, + HIDDEN = 0x0002, + DIRECTORY = 0x0010 +}; + +namespace o3tl +{ + template<> struct typed_flags<SbAttributes> : is_typed_flags<SbAttributes, 0x13> {}; +} + +class WildCard; + +class SbiRTLData +{ +public: + + std::unique_ptr<osl::Directory> pDir; + SbAttributes nDirFlags; + short nCurDirPos; + + OUString sFullNameToBeChecked; + std::unique_ptr<WildCard> pWildCard; + + css::uno::Sequence< OUString > aDirSeq; + + SbiRTLData(); + ~SbiRTLData(); +}; + +// The instance matches a running StarBASIC. Many basics running at the same +// time are managed by chained instances. There is all the data that only lives +// when the BASIC is living too, like the I/O-system. + +typedef std::vector< css::uno::Reference< css::lang::XComponent > > ComponentVector_t; + + +class SbiInstance +{ + friend class SbiRuntime; + + SbiRTLData aRTLData; + + // file system + std::unique_ptr<SbiIoSystem, o3tl::default_delete<SbiIoSystem>> pIosys; + // DDE + std::unique_ptr<SbiDdeControl> pDdeCtrl; + // DLL-Calls (DECLARE) + std::unique_ptr<SbiDllMgr> pDllMgr; + std::shared_ptr<SvNumberFormatter> pNumberFormatter; + StarBASIC* pBasic; + LanguageType meFormatterLangType; + DateOrder meFormatterDateOrder; + sal_uInt32 nStdDateIdx, nStdTimeIdx, nStdDateTimeIdx; + + ErrCode nErr; + OUString aErrorMsg; // last error message for $ARG + sal_Int32 nErl; // current error line + bool bReschedule; // Flag: sal_True = Reschedule in main loop + bool bCompatibility; // Flag: sal_True = VBA runtime compatibility mode + + ComponentVector_t ComponentVector; +public: + SbiRuntime* pRun; // Call-Stack + + // #31460 new concept for StepInto/Over/Out, + // explanation see runtime.cxx at SbiInstance::CalcBreakCallLevel() + sal_uInt16 nCallLvl; + sal_uInt16 nBreakCallLvl; + void CalcBreakCallLevel( BasicDebugFlags nFlags ); + + SbiInstance( StarBASIC* ); + ~SbiInstance(); + + void Error( ErrCode ); // trappable Error + void Error( ErrCode, const OUString& rMsg ); // trappable Error with message + void ErrorVB( sal_Int32 nVBNumber, const OUString& rMsg ); + void setErrorVB( sal_Int32 nVBNumber ); + void FatalError( ErrCode ); // non-trappable Error + void FatalError( ErrCode, const OUString& ); // non-trappable Error + void Abort(); // with current error code + + void Stop(); + ErrCode const & GetErr() const { return nErr; } + const OUString& GetErrorMsg() const { return aErrorMsg; } + sal_Int32 GetErl() const { return nErl; } + void EnableReschedule( bool bEnable ) { bReschedule = bEnable; } + bool IsReschedule() const { return bReschedule; } + void EnableCompatibility( bool bEnable ) { bCompatibility = bEnable; } + bool IsCompatibility() const { return bCompatibility; } + + ComponentVector_t& getComponentVector() { return ComponentVector; } + + SbMethod* GetCaller( sal_uInt16 ); + SbModule* GetActiveModule(); + + SbiIoSystem* GetIoSystem() { return pIosys.get(); } + SbiDdeControl* GetDdeControl() { return pDdeCtrl.get(); } + StarBASIC* GetBasic() { return pBasic; } + SbiDllMgr* GetDllMgr(); + SbiRTLData& GetRTLData() const { return const_cast<SbiRTLData&>(aRTLData); } + + std::shared_ptr<SvNumberFormatter> const & GetNumberFormatter(); + sal_uInt32 GetStdDateIdx() const { return nStdDateIdx; } + sal_uInt32 GetStdTimeIdx() const { return nStdTimeIdx; } + sal_uInt32 GetStdDateTimeIdx() const { return nStdDateTimeIdx; } + + // offer NumberFormatter also static + static std::shared_ptr<SvNumberFormatter> PrepareNumberFormatter( sal_uInt32 &rnStdDateIdx, + sal_uInt32 &rnStdTimeIdx, sal_uInt32 &rnStdDateTimeIdx, + LanguageType const * peFormatterLangType=nullptr, DateOrder const * peFormatterDateOrder=nullptr ); +}; + +// There's one instance of this class for every executed sub-program. +// This instance is the heart of the BASIC-machine and contains only local data. + +class SbiRuntime +{ + friend void SbRtl_CallByName( StarBASIC* pBasic, SbxArray& rPar, bool bWrite ); + + typedef void( SbiRuntime::*pStep0 )(); + typedef void( SbiRuntime::*pStep1 )( sal_uInt32 nOp1 ); + typedef void( SbiRuntime::*pStep2 )( sal_uInt32 nOp1, sal_uInt32 nOp2 ); + static pStep0 aStep0[]; // opcode-table group 0 + static pStep1 aStep1[]; + static pStep2 aStep2[]; + + StarBASIC& rBasic; // StarBASIC instance + SbiInstance* pInst; // current thread + SbModule* pMod; // current module + SbMethod* pMeth; // method instance + SbiIoSystem* pIosys; // I/O-System + const SbiImage* pImg; // Code-Image + SbxArrayRef refExprStk; // expression stack + SbxArrayRef refCaseStk; // CASE expression stack + SbxArrayRef refRedimpArray; // Array saved to use for REDIM PRESERVE + SbxVariableRef refRedim; // Array saved to use for REDIM + SbxVariableRef xDummyVar; // substitute for variables that weren't found + SbxVariable* mpExtCaller; // Caller ( external - e.g. button name, shape, range object etc. - only in vba mode ) + SbiForStack* pForStk; // FOR/NEXT-Stack + sal_uInt16 nExprLvl; // depth of the expr-stack + sal_uInt16 nForLvl; // #118235: Maintain for level + const sal_uInt8* pCode; // current Code-Pointer + const sal_uInt8* pStmnt; // beginning of the last statement + const sal_uInt8* pError; // address of the current error handler + const sal_uInt8* pRestart; // restart-address + const sal_uInt8* pErrCode; // restart-address RESUME NEXT + const sal_uInt8* pErrStmnt; // restart-address RESUME 0 + OUString aLibName; // Lib-name for declare-call + SbxArrayRef refParams; // current procedure parameters + SbxArrayRef refLocals; // local variable + SbxArrayRef refArgv; + // #74254, one refSaveObj is not enough! new: pRefSaveList (see above) + short nArgc; + bool bRun; + bool bError; // true: handle errors + bool bInError; // true: in an error handler + bool bBlocked; // true: blocked by next call level, #i48868 + bool bVBAEnabled; + BasicDebugFlags nFlags; // Debugging-Flags + ErrCode nError; + sal_uInt16 nOps; // opcode counter + sal_uInt32 m_nLastTime; + + std::vector<SbxVariableRef> aRefSaved; // #74254 save temporary references + std::vector<SbiGosub> pGosubStk; // GOSUB stack + std::vector<SbiArgv> pArgvStk; // ARGV-Stack + + + SbxVariable* FindElement + ( SbxObject* pObj, sal_uInt32 nOp1, sal_uInt32 nOp2, ErrCode, bool bLocal, bool bStatic = false ); + void SetupArgs( SbxVariable*, sal_uInt32 ); + SbxVariable* CheckArray( SbxVariable* ); + + void PushVar( SbxVariable* ); + SbxVariableRef PopVar(); + SbxVariable* GetTOS(); + void TOSMakeTemp(); + void ClearExprStack(); + + void PushGosub( const sal_uInt8* ); + void PopGosub(); + + void PushArgv(); + void PopArgv(); + void ClearArgvStack(); + + void PushFor(); + void PushForEach(); + void PopFor(); + void ClearForStack(); + + void StepArith( SbxOperator ); + void StepUnary( SbxOperator ); + void StepCompare( SbxOperator ); + + void SetParameters( SbxArray* ); + + // HAS TO BE IMPLEMENTED SOME TIME + void DllCall( const OUString&, const OUString&, SbxArray*, SbxDataType, bool ); + + // #56204 swap out DIM-functionality into help method (step0.cxx) + void DimImpl(const SbxVariableRef& refVar); + + static bool implIsClass( SbxObject const * pObj, const OUString& aClass ); + + void StepSETCLASS_impl( sal_uInt32 nOp1, bool bHandleDflt ); + + // the following routines are called by the single + // stepper and implement the single opcodes + void StepNOP(), StepEXP(), StepMUL(), StepDIV(); + void StepMOD(), StepPLUS(), StepMINUS(), StepNEG(); + void StepEQ(), StepNE(), StepLT(), StepGT(); + void StepLE(), StepGE(), StepIDIV(), StepAND(); + void StepOR(), StepXOR(), StepEQV(), StepIMP(); + void StepNOT(), StepCAT(), StepLIKE(), StepIS(); + void StepARGC(); + void StepARGV(), StepINPUT(), StepLINPUT(), StepSTOP(); + void StepGET(), StepSET(), StepVBASET(), StepPUT(), StepPUTC(); + void StepSET_Impl( SbxVariableRef& refVal, SbxVariableRef& refVar, bool bDefaultHandling = false ); + void StepDIM(), StepREDIM(), StepREDIMP(), StepERASE(); + void StepINITFOR(), StepNEXT(), StepERROR(), StepINITFOREACH(); + void StepCASE(), StepENDCASE(), StepSTDERROR(); + void StepNOERROR(), StepCHANNEL(), StepCHANNEL0(), StepPRINT(); + void StepPRINTF(), StepWRITE(), StepRENAME(), StepPROMPT(); + void StepRESTART(), StepEMPTY(), StepLEAVE(); + void StepLSET(), StepRSET(), StepREDIMP_ERASE(), StepERASE_CLEAR(); + void StepARRAYACCESS(), StepBYVAL(); + // all opcodes with one operand + void StepLOADNC( sal_uInt32 ), StepLOADSC( sal_uInt32 ), StepLOADI( sal_uInt32 ); + void StepARGN( sal_uInt32 ), StepBASED( sal_uInt32 ), StepPAD( sal_uInt32 ); + void StepJUMP( sal_uInt32 ), StepJUMPT( sal_uInt32 ); + void StepJUMPF( sal_uInt32 ), StepONJUMP( sal_uInt32 ); + void StepGOSUB( sal_uInt32 ), StepRETURN( sal_uInt32 ); + void StepTESTFOR( sal_uInt32 ), StepCASETO( sal_uInt32 ), StepERRHDL( sal_uInt32 ); + void StepRESUME( sal_uInt32 ), StepSETCLASS( sal_uInt32 ), StepVBASETCLASS( sal_uInt32 ), StepTESTCLASS( sal_uInt32 ), StepLIB( sal_uInt32 ); + bool checkClass_Impl( const SbxVariableRef& refVal, const OUString& aClass, bool bRaiseErrors, bool bDefault ); + void StepCLOSE( sal_uInt32 ), StepPRCHAR( sal_uInt32 ), StepARGTYP( sal_uInt32 ); + // all opcodes with two operands + void StepRTL( sal_uInt32, sal_uInt32 ), StepPUBLIC( sal_uInt32, sal_uInt32 ), StepPUBLIC_P( sal_uInt32, sal_uInt32 ); + void StepPUBLIC_Impl( sal_uInt32, sal_uInt32, bool bUsedForClassModule ); + void StepFIND_Impl( SbxObject* pObj, sal_uInt32 nOp1, sal_uInt32 nOp2, ErrCode, bool bStatic = false ); + void StepFIND( sal_uInt32, sal_uInt32 ), StepELEM( sal_uInt32, sal_uInt32 ); + void StepGLOBAL( sal_uInt32, sal_uInt32 ), StepLOCAL( sal_uInt32, sal_uInt32 ); + void StepPARAM( sal_uInt32, sal_uInt32), StepCREATE( sal_uInt32, sal_uInt32 ); + void StepCALL( sal_uInt32, sal_uInt32 ), StepCALLC( sal_uInt32, sal_uInt32 ); + void StepCASEIS( sal_uInt32, sal_uInt32 ), StepSTMNT( sal_uInt32, sal_uInt32 ); + SbxVariable* StepSTATIC_Impl( + OUString const & aName, SbxDataType t, sal_uInt32 nOp2 ); + void StepOPEN( sal_uInt32, sal_uInt32 ), StepSTATIC( sal_uInt32, sal_uInt32 ); + void StepTCREATE(sal_uInt32,sal_uInt32), StepDCREATE(sal_uInt32,sal_uInt32); + void StepGLOBAL_P( sal_uInt32, sal_uInt32 ),StepFIND_G( sal_uInt32, sal_uInt32 ); + void StepDCREATE_REDIMP(sal_uInt32,sal_uInt32), StepDCREATE_IMPL(sal_uInt32,sal_uInt32); + void StepFIND_CM( sal_uInt32, sal_uInt32 ); + void StepFIND_STATIC( sal_uInt32, sal_uInt32 ); + static void implHandleSbxFlags( SbxVariable* pVar, SbxDataType t, sal_uInt32 nOp2 ); +public: + void SetVBAEnabled( bool bEnabled ); + bool IsImageFlag( SbiImageFlags n ) const; + sal_uInt16 GetBase() const; + sal_Int32 nLine,nCol1,nCol2; + SbiRuntime* pNext; // Stack-Chain + + // tdf#79426, tdf#125180 - adds the information about a missing parameter + static void SetIsMissing( SbxVariable* ); + // tdf#79426, tdf#125180 - checks if a variable contains the information about a missing parameter + static bool IsMissing( SbxVariable*, sal_uInt16 ); + + SbiRuntime( SbModule*, SbMethod*, sal_uInt32 ); + ~SbiRuntime(); + void Error( ErrCode, bool bVBATranslationAlreadyDone = false ); // set error if != 0 + void Error( ErrCode, const OUString& ); // set error if != 0 + void FatalError( ErrCode ); // error handling = standard, set error + void FatalError( ErrCode, const OUString& ); // error handling = standard, set error + static sal_Int32 translateErrorToVba( ErrCode nError, OUString& rMsg ); + bool Step(); // single step (one opcode) + void Stop() { bRun = false; } + void block() { bBlocked = true; } + void unblock() { bBlocked = false; } + SbModule* GetModule() { return pMod; } + BasicDebugFlags GetDebugFlags() const { return nFlags; } + void SetDebugFlags( BasicDebugFlags nFl ) { nFlags = nFl; } + SbMethod* GetCaller() { return pMeth;} + SbxVariable* GetExternalCaller(){ return mpExtCaller; } + + SbiForStack* FindForStackItemForCollection( class BasicCollection const * pCollection ); + + SbxBase* FindElementExtern( const OUString& rName ); + static bool isVBAEnabled(); + +}; + +inline void checkArithmeticOverflow( double d ) +{ + if( !std::isfinite( d ) ) + StarBASIC::Error( ERRCODE_BASIC_MATH_OVERFLOW ); +} + +inline void checkArithmeticOverflow( SbxVariable const * pVar ) +{ + if( pVar->GetType() == SbxDOUBLE ) + { + double d = pVar->GetDouble(); + checkArithmeticOverflow( d ); + } +} + + +StarBASIC* GetCurrentBasic( StarBASIC* pRTBasic ); + +// Returns true if UNO is available, otherwise the old +// file system implementation has to be used +// (Implemented in iosys.cxx) +bool hasUno(); + +// Converts possibly relative paths to absolute paths +// according to the setting done by ChDir/ChDrive +// (Implemented in methods.cxx) +OUString getFullPath( const OUString& aRelPath ); + +// Implementation of StepRENAME with UCB +// (Implemented in methods.cxx, so step0.cxx +// has not to be infected with UNO) +void implStepRenameUCB( const OUString& aSource, const OUString& aDest ); + +void implStepRenameOSL( const OUString& aSource, const OUString& aDest ); +bool IsBaseIndexOne(); + +void removeDimAsNewRecoverItem( SbxVariable* pVar ); + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basic/source/inc/sbintern.hxx b/basic/source/inc/sbintern.hxx new file mode 100644 index 000000000..75e3ede9a --- /dev/null +++ b/basic/source/inc/sbintern.hxx @@ -0,0 +1,118 @@ +/* -*- 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_SOURCE_INC_SBINTERN_HXX +#define INCLUDED_BASIC_SOURCE_INC_SBINTERN_HXX + +#include <basic/basicdllapi.h> +#include <basic/sbstar.hxx> +#include <sbxfac.hxx> +#include <unotools/transliterationwrapper.hxx> +#include <vcl/errcode.hxx> + +namespace utl +{ + class TransliterationWrapper; +} +class SbUnoFactory; +class SbTypeFactory; +class SbOLEFactory; +class SbFormFactory; +class SbiInstance; +class SbModule; +class BasicManager; + +class SbiFactory : public SbxFactory +{ +public: + virtual SbxBase* Create( sal_uInt16 nSbxId, sal_uInt32 ) override; + virtual SbxObject* CreateObject( const OUString& ) override; +}; + +struct SbClassData +{ + SbxArrayRef mxIfaces; + + // types this module depends on because of use in Dim As New <type> + // needed for initialization order of class modules + std::vector< OUString > maRequiredTypes; + + SbClassData(); + ~SbClassData() + { clear(); } + void clear(); +}; + +// #115824: Factory class to create class objects (type command) +// Implementation: sb.cxx +class SbClassFactory : public SbxFactory +{ + SbxObjectRef xClassModules; + +public: + SbClassFactory(); + virtual ~SbClassFactory() override; + + void AddClassModule( SbModule* pClassModule ); + void RemoveClassModule( SbModule* pClassModule ); + + virtual SbxBase* Create( sal_uInt16 nSbxId, sal_uInt32 ) override; + virtual SbxObject* CreateObject( const OUString& ) override; + + SbModule* FindClass( const OUString& rClassName ); +}; + +struct SbiGlobals +{ + static SbiGlobals* pGlobals; + SbiInstance* pInst; // all active runtime instances + std::unique_ptr<SbiFactory> pSbFac; // StarBASIC-Factory + std::unique_ptr<SbUnoFactory> pUnoFac; // Factory for Uno-Structs at DIM AS NEW + SbTypeFactory* pTypeFac; // Factory for user defined types + SbClassFactory* pClassFac; // Factory for user defined classes (based on class modules) + SbOLEFactory* pOLEFac; // Factory for OLE types + SbFormFactory* pFormFac; // Factory for user forms + SbModule* pMod; // currently active module + SbModule* pCompMod; // currently compiled module + short nInst; // number of BASICs + Link<StarBASIC*,bool> aErrHdl; // global error handler + Link<StarBASIC*,BasicDebugFlags> aBreakHdl; // global break handler + ErrCode nCode; + sal_Int32 nLine; + sal_Int32 nCol1,nCol2; // from... to... + bool bCompilerError; // flag for compiler error + bool bGlobalInitErr; + bool bRunInit; // true, if RunInit active from the Basic + OUString aErrMsg; // buffer for GetErrorText() + std::unique_ptr<::utl::TransliterationWrapper> pTransliterationWrapper; // For StrComp + bool bBlockCompilerError; + std::unique_ptr<BasicManager> pAppBasMgr; + StarBASIC* pMSOMacroRuntimLib; // Lib containing MSO Macro Runtime API entry symbols + + SbiGlobals(); + ~SbiGlobals(); +}; + +// utility macros and routines + +SbiGlobals* GetSbData(); + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basic/source/inc/sbjsmeth.hxx b/basic/source/inc/sbjsmeth.hxx new file mode 100644 index 000000000..2e4abc509 --- /dev/null +++ b/basic/source/inc/sbjsmeth.hxx @@ -0,0 +1,42 @@ +/* -*- 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_SOURCE_INC_SBJSMETH_HXX +#define INCLUDED_BASIC_SOURCE_INC_SBJSMETH_HXX + +#include <basic/sbmeth.hxx> + +// basic module for JavaScript sources +// All the basic-specific methods must be overridden virtually and must +// be deactivated. The differentiation of normal modules is done by RTTI. + +class SbJScriptMethod : public SbMethod +{ +public: + SbJScriptMethod( SbxDataType ); + virtual ~SbJScriptMethod() override; + + SBX_DECL_PERSIST_NODATA(SBXID_JSCRIPTMETH,2); +}; + + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basic/source/inc/sbjsmod.hxx b/basic/source/inc/sbjsmod.hxx new file mode 100644 index 000000000..9d2d7d8f4 --- /dev/null +++ b/basic/source/inc/sbjsmod.hxx @@ -0,0 +1,41 @@ +/* -*- 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_SOURCE_INC_SBJSMOD_HXX +#define INCLUDED_BASIC_SOURCE_INC_SBJSMOD_HXX + +#include <basic/sbmod.hxx> + +// basic module for JavaScript sources +// All the basic-specific methods must be overridden virtually and must +// be deactivated. The differentiation of normal modules is done by RTTI. + +class SbJScriptModule : public SbModule +{ + virtual bool LoadData( SvStream&, sal_uInt16 ) override; + virtual bool StoreData( SvStream& ) const override; +public: + SBX_DECL_PERSIST_NODATA(SBXID_JSCRIPTMOD,1); + SbJScriptModule(); // hand through +}; + +#endif + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basic/source/inc/sbunoobj.hxx b/basic/source/inc/sbunoobj.hxx new file mode 100644 index 000000000..6827bf755 --- /dev/null +++ b/basic/source/inc/sbunoobj.hxx @@ -0,0 +1,395 @@ +/* -*- 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_SOURCE_INC_SBUNOOBJ_HXX +#define INCLUDED_BASIC_SOURCE_INC_SBUNOOBJ_HXX + +#include <basic/sbxobj.hxx> +#include <basic/sbxmeth.hxx> +#include <sbxprop.hxx> +#include <sbxfac.hxx> +#include <basic/sbx.hxx> +#include <com/sun/star/beans/XMaterialHolder.hpp> +#include <com/sun/star/beans/XExactName.hpp> +#include <com/sun/star/beans/XIntrospectionAccess.hpp> +#include <com/sun/star/lang/XComponent.hpp> +#include <com/sun/star/script/XInvocation.hpp> +#include <com/sun/star/reflection/XIdlClass.hpp> +#include <com/sun/star/reflection/XServiceTypeDescription2.hpp> +#include <rtl/ustring.hxx> +#include <unordered_map> +#include <vector> +#include <map> + +void registerComponentToBeDisposedForBasic( const css::uno::Reference< css::lang::XComponent >& xComponent, StarBASIC* pBasic ); + +class StructRefInfo +{ + css::uno::Any& maAny; + css::uno::Type maType; + sal_Int32 mnPos; +public: + StructRefInfo( css::uno::Any& aAny, css::uno::Type const & rType, sal_Int32 nPos ) : maAny( aAny ), maType( rType ), mnPos( nPos ) {} + + sal_Int32 getPos() const { return mnPos; } + const css::uno::Type& getType() const { return maType; } + OUString getTypeName() const; + css::uno::Any& getRootAnyRef() { return maAny; }; + + css::uno::TypeClass getTypeClass() const; + + void* getInst(); + bool isEmpty() const { return (mnPos == -1); } + + css::uno::Any getValue(); + void setValue( const css::uno::Any& ); +}; + +class SbUnoStructRefObject: public SbxObject +{ + struct caseLessComp + { + bool operator() (const OUString& rProp, const OUString& rOtherProp ) const + { + return rProp.compareToIgnoreAsciiCase( rOtherProp ) < 0; + } + }; + typedef std::map< OUString, std::unique_ptr<StructRefInfo>, caseLessComp > StructFieldInfo; + StructFieldInfo maFields; + StructRefInfo maMemberInfo; + bool mbMemberCacheInit; + void implCreateAll(); + void implCreateDbgProperties(); + void initMemberCache(); + OUString Impl_DumpProperties(); + OUString getDbgObjectName() const; +public: + StructRefInfo getStructMember( const OUString& rMember ); + const StructRefInfo& getStructInfo() const { return maMemberInfo; } + SbUnoStructRefObject( const OUString& aName_, const StructRefInfo& rMemberInfo ); + virtual ~SbUnoStructRefObject() override; + + // override Find to support e. g. NameAccess + virtual SbxVariable* Find( const OUString&, SbxClassType ) override; + + // Force creation of all properties for debugging + void createAllProperties() + { implCreateAll(); } + + // give out value + css::uno::Any getUnoAny(); + void Notify( SfxBroadcaster&, const SfxHint& rHint ) override; +}; + +class SbUnoObject: public SbxObject +{ + css::uno::Reference< css::beans::XIntrospectionAccess > mxUnoAccess; + css::uno::Reference< css::beans::XMaterialHolder > mxMaterialHolder; + css::uno::Reference< css::script::XInvocation > mxInvocation; + css::uno::Reference< css::beans::XExactName > mxExactName; + css::uno::Reference< css::beans::XExactName > mxExactNameInvocation; + bool bNeedIntrospection; + bool bNativeCOMObject; + css::uno::Any maTmpUnoObj; // Only to save obj for doIntrospection! + std::shared_ptr< SbUnoStructRefObject > maStructInfo; + // help method to establish the dbg_-properties + void implCreateDbgProperties(); + + // help method to establish all properties and methods + // (on the on-demand-mechanism required for the dbg_-properties) + void implCreateAll(); + +public: + static bool getDefaultPropName( SbUnoObject const * pUnoObj, OUString& sDfltProp ); + SbUnoObject( const OUString& aName_, const css::uno::Any& aUnoObj_ ); + virtual ~SbUnoObject() override; + + // #76470 do introspection on demand + void doIntrospection(); + + // override Find to support e. g. NameAccess + virtual SbxVariable* Find( const OUString&, SbxClassType ) override; + + // Force creation of all properties for debugging + void createAllProperties() + { implCreateAll(); } + + // give out value + css::uno::Any getUnoAny(); + const css::uno::Reference< css::beans::XIntrospectionAccess >& getIntrospectionAccess() const { return mxUnoAccess; } + const css::uno::Reference< css::script::XInvocation >& getInvocation() const { return mxInvocation; } + + void Notify( SfxBroadcaster&, const SfxHint& rHint ) override; + + bool isNativeCOMObject() const + { return bNativeCOMObject; } +}; +typedef tools::SvRef<SbUnoObject> SbUnoObjectRef; + +// #67781 delete return values of the uno-methods +void clearUnoMethods(); +void clearUnoMethodsForBasic( StarBASIC const * pBasic ); + +class SbUnoMethod : public SbxMethod +{ + friend class SbUnoObject; + friend void clearUnoMethods(); + friend void clearUnoMethodsForBasic( StarBASIC const * pBasic ); + + css::uno::Reference< css::reflection::XIdlMethod > m_xUnoMethod; + std::unique_ptr<css::uno::Sequence< css::reflection::ParamInfo >> pParamInfoSeq; + + // #67781 reference to the previous and the next method in the method list + SbUnoMethod* pPrev; + SbUnoMethod* pNext; + + bool mbInvocation; // Method is based on invocation + +public: + + SbUnoMethod( const OUString& aName_, SbxDataType eSbxType, css::uno::Reference< css::reflection::XIdlMethod > const & xUnoMethod_, + bool bInvocation ); + virtual ~SbUnoMethod() override; + virtual SbxInfo* GetInfo() override; + + const css::uno::Sequence< css::reflection::ParamInfo >& getParamInfos(); + + bool isInvocationBased() const + { return mbInvocation; } +}; + + +class SbUnoProperty : public SbxProperty +{ + friend class SbUnoObject; + friend class SbUnoStructRefObject; + + css::beans::Property aUnoProp; + sal_Int32 nId; + + bool mbInvocation; // Property is based on invocation + SbxDataType mRealType; + virtual ~SbUnoProperty() override; + bool mbUnoStruct; + SbUnoProperty( const SbUnoProperty&) = delete; + SbUnoProperty& operator = ( const SbUnoProperty&) = delete; +public: + + SbUnoProperty( const OUString& aName_, SbxDataType eSbxType, SbxDataType eRealSbxType, + const css::beans::Property& aUnoProp_, sal_Int32 nId_, bool bInvocation, bool bUnoStruct ); + + bool isUnoStruct() const { return mbUnoStruct; } + bool isInvocationBased() const + { return mbInvocation; } + SbxDataType getRealType() const { return mRealType; } +}; + +// factory class to create uno-structs per DIM AS NEW +class SbUnoFactory : public SbxFactory +{ +public: + virtual SbxBase* Create( sal_uInt16 nSbxId, sal_uInt32 ) override; + virtual SbxObject* CreateObject( const OUString& ) override; +}; + +// wrapper for a uno-class +class SbUnoClass : public SbxObject +{ + const css::uno::Reference< css::reflection::XIdlClass > m_xClass; + +public: + SbUnoClass( const OUString& aName_ ) + : SbxObject( aName_ ) + {} + SbUnoClass( const OUString& aName_, const css::uno::Reference< css::reflection::XIdlClass >& xClass_ ) + : SbxObject( aName_ ) + , m_xClass( xClass_ ) + {} + + + virtual SbxVariable* Find( const OUString&, SbxClassType ) override; + + + const css::uno::Reference< css::reflection::XIdlClass >& getUnoClass() const { return m_xClass; } + +}; + + +// function to find a global identifier in +// the UnoScope and to wrap it for Sbx +SbUnoClass* findUnoClass( const OUString& rName ); + + +// Wrapper for UNO Service +class SbUnoService : public SbxObject +{ + const css::uno::Reference< css::reflection::XServiceTypeDescription2 > m_xServiceTypeDesc; + bool m_bNeedsInit; + +public: + SbUnoService( const OUString& aName_, + const css::uno::Reference< css::reflection::XServiceTypeDescription2 >& xServiceTypeDesc ) + : SbxObject( aName_ ) + , m_xServiceTypeDesc( xServiceTypeDesc ) + , m_bNeedsInit( true ) + {} + + virtual SbxVariable* Find( const OUString&, SbxClassType ) override; + + void Notify( SfxBroadcaster&, const SfxHint& rHint ) override; +}; + +SbUnoService* findUnoService( const OUString& rName ); + + +class SbUnoServiceCtor : public SbxMethod +{ + friend class SbUnoService; + + css::uno::Reference< css::reflection::XServiceConstructorDescription > m_xServiceCtorDesc; + +public: + + SbUnoServiceCtor( const OUString& aName_, css::uno::Reference< css::reflection::XServiceConstructorDescription > const & xServiceCtorDesc ); + virtual ~SbUnoServiceCtor() override; + virtual SbxInfo* GetInfo() override; + + const css::uno::Reference< css::reflection::XServiceConstructorDescription >& getServiceCtorDesc() const + { return m_xServiceCtorDesc; } +}; + + +// Wrapper for UNO Singleton +class SbUnoSingleton : public SbxObject +{ +public: + SbUnoSingleton( const OUString& aName_ ); + + void Notify( SfxBroadcaster&, const SfxHint& rHint ) override; +}; + +SbUnoSingleton* findUnoSingleton( const OUString& rName ); + + +// #105565 Special Object to wrap a strongly typed Uno Any +class SbUnoAnyObject: public SbxObject +{ + css::uno::Any mVal; + +public: + SbUnoAnyObject( const css::uno::Any& rVal ) + : SbxObject( OUString() ) + , mVal( rVal ) + {} + + const css::uno::Any& getValue() const + { return mVal; } + +}; + + +// #112509 Special SbxArray to transport named parameters for calls +// to OLEAutomation objects through the UNO OLE automation bridge + +class AutomationNamedArgsSbxArray : public SbxArray +{ + css::uno::Sequence< OUString > maNameSeq; +public: + AutomationNamedArgsSbxArray( sal_Int32 nSeqSize ) + : maNameSeq( nSeqSize ) + {} + + css::uno::Sequence< OUString >& getNames() + { return maNameSeq; } +}; + + +class StarBASIC; + +// Impl-methods for RTL +void RTL_Impl_CreateUnoStruct( SbxArray& rPar ); +void RTL_Impl_CreateUnoService( SbxArray& rPar ); +void RTL_Impl_CreateUnoServiceWithArguments( SbxArray& rPar ); +void RTL_Impl_CreateUnoValue( SbxArray& rPar ); +void RTL_Impl_GetProcessServiceManager( SbxArray& rPar ); +void RTL_Impl_HasInterfaces( SbxArray& rPar ); +void RTL_Impl_IsUnoStruct( SbxArray& rPar ); +void RTL_Impl_EqualUnoObjects( SbxArray& rPar ); +void RTL_Impl_GetDefaultContext( SbxArray& rPar ); + +void disposeComVariablesForBasic( StarBASIC const * pBasic ); +void clearNativeObjectWrapperVector(); + + +// #118116 Collection object + +class BasicCollection : public SbxObject +{ + friend class SbiRuntime; + SbxArrayRef xItemArray; + static SbxInfoRef xAddInfo; + static SbxInfoRef xItemInfo; + + void Initialize(); + virtual ~BasicCollection() override; + virtual void Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) override; + sal_Int32 implGetIndex( SbxVariable const * pIndexVar ); + sal_Int32 implGetIndexForName( const OUString& rName ); + void CollAdd( SbxArray* pPar_ ); + void CollItem( SbxArray* pPar_ ); + void CollRemove( SbxArray* pPar_ ); + +public: + BasicCollection( const OUString& rClassname ); + virtual void Clear() override; +}; + +class VBAConstantHelper +{ +private: + std::vector< OUString > aConstCache; + std::unordered_map< OUString, css::uno::Any > aConstHash; + bool isInited; + VBAConstantHelper():isInited( false ) {} + VBAConstantHelper(const VBAConstantHelper&) = delete; + void init(); +public: + static VBAConstantHelper& instance(); + SbxVariable* getVBAConstant( const OUString& rName ); + bool isVBAConstantType( const OUString& rName ); +}; + +SbxVariable* getDefaultProp( SbxVariable* pRef ); + +css::uno::Reference< css::uno::XInterface > createComListener( const css::uno::Any& aControlAny, + const OUString& aVBAType, + const OUString& aPrefix, + const SbxObjectRef& xScopeObj ); + +bool checkUnoObjectType(SbUnoObject& refVal, const OUString& aClass); + +SbUnoObject* createOLEObject_Impl( const OUString& aType ); + +// #55226 ship additional information +bool handleToStringForCOMObjects( SbxObject* pObj, SbxValue* pVal ); + +void registerComListenerVariableForBasic( SbxVariable* pVar, StarBASIC* pBasic ); + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basic/source/inc/sbxmod.hxx b/basic/source/inc/sbxmod.hxx new file mode 100644 index 000000000..853715c4b --- /dev/null +++ b/basic/source/inc/sbxmod.hxx @@ -0,0 +1,30 @@ +/* -*- 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_SOURCE_INC_SBXMOD_HXX +#define INCLUDED_BASIC_SOURCE_INC_SBXMOD_HXX + +#include <com/sun/star/frame/XModel.hpp> +#include <basic/sbstar.hxx> + +css::uno::Reference<css::frame::XModel> getDocumentModel(StarBASIC*); + +#endif // INCLUDED_BASIC_SOURCE_INC_SBXMOD_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basic/source/inc/scanner.hxx b/basic/source/inc/scanner.hxx new file mode 100644 index 000000000..9b03b0adc --- /dev/null +++ b/basic/source/inc/scanner.hxx @@ -0,0 +1,96 @@ +/* -*- 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_SOURCE_INC_SCANNER_HXX +#define INCLUDED_BASIC_SOURCE_INC_SCANNER_HXX + +#include <basic/sbxdef.hxx> +#include <vcl/errcode.hxx> + +// The scanner is stand-alone, i. e. it can be used from everywhere. +// A BASIC-instance is necessary for error messages. Without BASIC +// the errors are only counted. Also the BASIC is necessary when an +// advanced SBX-variable shall be used for data type recognition etc. + +class StarBASIC; + +class SbiScanner +{ + OUString aBuf; // input buffer + OUString aLine; + sal_Int32 nLineIdx; + sal_Int32 nSaveLineIdx; + StarBASIC* pBasic; // instance for error callbacks + + void scanAlphanumeric(); + void scanGoto(); + bool readLine(); +protected: + OUString aSym; + OUString aError; + SbxDataType eScanType; + double nVal; // numeric value + sal_Int32 nSavedCol1; + sal_Int32 nCol; + sal_Int32 nErrors; + sal_Int32 nColLock; // lock counter for Col1 + sal_Int32 nBufPos; + sal_Int32 nLine; + sal_Int32 nCol1, nCol2; + bool bSymbol; // true: symbol scanned + bool bNumber; // true: number scanned + bool bSpaces; // true: whitespace before token + bool bAbort; + bool bHash; // true: # has been read in + bool bError; // true: generate error + bool bCompatible; // true: OPTION compatible + bool bVBASupportOn; // true: OPTION VBASupport 1 otherwise default False + bool bPrevLineExtentsComment; // true: Previous line is comment and ends on "... _" + + bool bInStatement; + void GenError( ErrCode ); +public: + SbiScanner( const OUString&, StarBASIC* = nullptr ); + + void EnableErrors() { bError = false; } + bool IsHash() const { return bHash; } + bool IsCompatible() const { return bCompatible; } + void SetCompatible( bool b ) { bCompatible = b; } // #118206 + bool IsVBASupportOn() const { return bVBASupportOn; } + bool WhiteSpace() { return bSpaces; } + sal_Int32 GetErrors() const { return nErrors; } + sal_Int32 GetLine() const { return nLine; } + sal_Int32 GetCol1() const { return nCol1; } + void SetCol1( sal_Int32 n ) { nCol1 = n; } + StarBASIC* GetBasic() { return pBasic; } + void SaveLine() { nSaveLineIdx = nLineIdx; } + void RestoreLine() { nLineIdx = nSaveLineIdx; } + void LockColumn(); + void UnlockColumn(); + bool DoesColonFollow(); + + bool NextSym(); + const OUString& GetSym() const { return aSym; } + SbxDataType GetType() const { return eScanType; } + double GetDbl() const { return nVal; } +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basic/source/inc/scriptcont.hxx b/basic/source/inc/scriptcont.hxx new file mode 100644 index 000000000..98fce14b6 --- /dev/null +++ b/basic/source/inc/scriptcont.hxx @@ -0,0 +1,163 @@ +/* -*- 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_SOURCE_INC_SCRIPTCONT_HXX +#define INCLUDED_BASIC_SOURCE_INC_SCRIPTCONT_HXX + +#include "namecont.hxx" +#include <basic/basmgr.hxx> +#include <com/sun/star/script/vba/XVBAModuleInfo.hpp> +#include <comphelper/uno3.hxx> +#include <cppuhelper/implbase1.hxx> + +namespace basic +{ + + +class SfxScriptLibraryContainer : public SfxLibraryContainer, public OldBasicPassword +{ + css::uno::Reference< css::container::XNameAccess > mxCodeNameAccess; + + // Methods to distinguish between different library types + virtual SfxLibrary* implCreateLibrary( const OUString& aName ) override; + virtual SfxLibrary* implCreateLibraryLink + ( const OUString& aName, const OUString& aLibInfoFileURL, + const OUString& StorageURL, bool ReadOnly ) override; + virtual css::uno::Any createEmptyLibraryElement() override; + virtual bool isLibraryElementValid(const css::uno::Any& rElement) const override; + virtual void writeLibraryElement + ( + const css::uno::Reference< css::container::XNameContainer>& xLibrary, + const OUString& aElementName, + const css::uno::Reference< css::io::XOutputStream >& xOutput + ) override; + + virtual css::uno::Any importLibraryElement + ( + const css::uno::Reference< css::container::XNameContainer>& xLibrary, + const OUString& aElementName, + const OUString& aFile, + const css::uno::Reference< css::io::XInputStream >& xElementStream ) override; + + virtual void importFromOldStorage( const OUString& aFile ) override; + + virtual SfxLibraryContainer* createInstanceImpl() override; + + + // Password encryption + virtual bool implStorePasswordLibrary( SfxLibrary* pLib, const OUString& aName, + const css::uno::Reference< css::embed::XStorage>& xStorage, const css::uno::Reference< css::task::XInteractionHandler >& Handler ) override; + + // New variant for library export + virtual bool implStorePasswordLibrary( SfxLibrary* pLib, const OUString& aName, + const css::uno::Reference< css::embed::XStorage >& xStorage, + const OUString& aTargetURL, + const css::uno::Reference< css::ucb::XSimpleFileAccess3 >& rToUseSFI, const css::uno::Reference< css::task::XInteractionHandler >& Handler ) override; + + virtual bool implLoadPasswordLibrary( SfxLibrary* pLib, const OUString& Name, + bool bVerifyPasswordOnly=false ) override; + + virtual void onNewRootStorage() override; + + + // OldBasicPassword interface + virtual void setLibraryPassword( const OUString& rLibraryName, const OUString& rPassword ) override; + + virtual const char* getInfoFileName() const override; + virtual const char* getOldInfoFileName() const override; + virtual const char* getLibElementFileExtension() const override; + virtual const char* getLibrariesDir() const override; + +public: + SfxScriptLibraryContainer(); + SfxScriptLibraryContainer( const css::uno::Reference< css::embed::XStorage >& xStorage ); + + + // Methods XLibraryContainerPassword + virtual sal_Bool SAL_CALL isLibraryPasswordProtected( const OUString& Name ) override; + virtual sal_Bool SAL_CALL isLibraryPasswordVerified( const OUString& Name ) override; + virtual sal_Bool SAL_CALL verifyLibraryPassword( const OUString& Name, const OUString& Password ) override; + virtual void SAL_CALL changeLibraryPassword( const OUString& Name, + const OUString& OldPassword, const OUString& NewPassword ) override; + // XLibraryQueryExecutable + virtual sal_Bool SAL_CALL HasExecutableCode(const OUString&) override; + // Methods XServiceInfo + virtual OUString SAL_CALL getImplementationName( ) override; + virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames( ) override; +}; + + +typedef std::unordered_map< OUString, css::script::ModuleInfo > ModuleInfoMap; + +typedef ::cppu::ImplHelper1< css::script::vba::XVBAModuleInfo > SfxScriptLibrary_BASE; + +class SfxScriptLibrary : public SfxLibrary, public SfxScriptLibrary_BASE +{ + friend class SfxScriptLibraryContainer; + + typedef std::unordered_map< OUString, css::script::ModuleInfo > ModuleInfoMap; + + bool mbLoadedSource; + bool mbLoadedBinary; + ModuleInfoMap mModuleInfo; + + // Provide modify state including resources + virtual bool isModified() override; + virtual void storeResources() override; + virtual void storeResourcesAsURL( const OUString& URL, const OUString& NewName ) override; + virtual void storeResourcesToURL( const OUString& URL, + const css::uno::Reference< css::task::XInteractionHandler >& xHandler ) override; + virtual void storeResourcesToStorage( const css::uno::Reference< css::embed::XStorage >& xStorage ) override; + virtual bool isLoadedStorable() override; + +public: + SfxScriptLibrary + ( + ModifiableHelper& _rModifiable, + const css::uno::Reference< css::ucb::XSimpleFileAccess3 >& xSFI + ); + + SfxScriptLibrary + ( + ModifiableHelper& _rModifiable, + const css::uno::Reference< css::ucb::XSimpleFileAccess3 >& xSFI, + const OUString& aLibInfoFileURL, const OUString& aStorageURL, bool ReadOnly + ); + + DECLARE_XINTERFACE() + DECLARE_XTYPEPROVIDER() + + // XVBAModuleInfo + virtual css::script::ModuleInfo SAL_CALL getModuleInfo( const OUString& ModuleName ) override; + virtual sal_Bool SAL_CALL hasModuleInfo( const OUString& ModuleName ) override; + virtual void SAL_CALL insertModuleInfo( const OUString& ModuleName, const css::script::ModuleInfo& ModuleInfo ) override; + virtual void SAL_CALL removeModuleInfo( const OUString& ModuleName ) override; + + static bool containsValidModule( const css::uno::Any& _rElement ); + +protected: + virtual bool isLibraryElementValid(const css::uno::Any& rElement) const override; +}; + + +} // namespace basic + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basic/source/inc/stdobj.hxx b/basic/source/inc/stdobj.hxx new file mode 100644 index 000000000..d7bc4c176 --- /dev/null +++ b/basic/source/inc/stdobj.hxx @@ -0,0 +1,44 @@ +/* -*- 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_SOURCE_INC_STDOBJ_HXX +#define INCLUDED_BASIC_SOURCE_INC_STDOBJ_HXX + +#include <basic/sbxobj.hxx> + +class StarBASIC; +class SbStdFactory; + +class SbiStdObject : public SbxObject +{ + std::unique_ptr<SbStdFactory> pStdFactory; + + virtual ~SbiStdObject() override; + using SbxVariable::GetInfo; + static SbxInfo* GetInfo( short ); + virtual void Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) override; +public: + SbiStdObject( const OUString&, StarBASIC* ); + virtual SbxVariable* Find( const OUString&, SbxClassType ) override; + virtual void SetModified( bool ) override; +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basic/source/inc/symtbl.hxx b/basic/source/inc/symtbl.hxx new file mode 100644 index 000000000..2dfc9c758 --- /dev/null +++ b/basic/source/inc/symtbl.hxx @@ -0,0 +1,222 @@ +/* -*- 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_SOURCE_INC_SYMTBL_HXX +#define INCLUDED_BASIC_SOURCE_INC_SYMTBL_HXX + +#include <memory> +#include <vector> +#include <basic/sbdef.hxx> + +class SbiConstDef; +class SbiParser; +class SbiProcDef; +class SbiStringPool; +class SbiSymDef; // base class + +enum SbiSymScope { SbLOCAL, SbPARAM, SbPUBLIC, SbGLOBAL, SbRTL }; + +// The string-pool collects string entries and +// makes sure that they don't exist twice. + +class SbiStringPool { + std::vector<OUString> aData; +public: + SbiStringPool(); + ~SbiStringPool(); + sal_uInt32 GetSize() const { return aData.size(); } + short Add( const OUString& ); + short Add( double, SbxDataType ); + OUString Find( sal_uInt32 ) const; +}; + + +class SbiSymPool final { + friend class SbiSymDef; + friend class SbiProcDef; + SbiStringPool& rStrings; + std::vector<std::unique_ptr<SbiSymDef>> m_Data; + SbiSymPool* pParent; + SbiParser* pParser; + SbiSymScope eScope; + sal_uInt16 nProcId; // for STATIC-variable + sal_uInt16 nCur; // iterator +public: + SbiSymPool( SbiStringPool&, SbiSymScope, SbiParser* pParser_ ); + ~SbiSymPool(); + + void SetParent( SbiSymPool* p ) { pParent = p; } + void SetProcId( short n ) { nProcId = n; } + sal_uInt16 GetSize() const { return m_Data.size(); } + SbiSymScope GetScope() const { return eScope; } + void SetScope( SbiSymScope s ) { eScope = s; } + SbiParser* GetParser() { return pParser; } + + SbiSymDef* AddSym( const OUString& ); + SbiProcDef* AddProc( const OUString& ); + void Add( SbiSymDef* ); + SbiSymDef* Find( const OUString&, bool bSearchInParents = true ); // variable name + SbiSymDef* Get( sal_uInt16 ); // find variable per position + SbiSymDef* First(), *Next(); // iterators + + sal_uInt32 Define( const OUString& ); + sal_uInt32 Reference( const OUString& ); + void CheckRefs(); +}; + + +class SbiSymDef { // general symbol entry + friend class SbiSymPool; +protected: + OUString aName; + SbxDataType eType; + SbiSymPool* pIn; // parent pool + std::unique_ptr<SbiSymPool> pPool; // pool for sub-elements + short nLen; // string length for STRING*n + short nDims; + sal_uInt16 nId; + sal_uInt16 nTypeId; // Dim X AS data type + sal_uInt16 nProcId; + sal_uInt16 nPos; + sal_uInt32 nChain; + bool bNew : 1; // true: Dim As New... + bool bChained : 1; // true: symbol is defined in code + bool bByVal : 1; // true: ByVal-parameter + bool bOpt : 1; // true: optional parameter + bool bStatic : 1; // true: STATIC variable + bool bAs : 1; // true: data type defined per AS XXX + bool bGlobal : 1; // true: global variable + bool bParamArray : 1; // true: ParamArray parameter + bool bWithEvents : 1; // true: Declared WithEvents + bool bWithBrackets : 1; // true: Followed by () + sal_uInt16 nDefaultId; // Symbol number of default value + short nFixedStringLength; // String length in: Dim foo As String*Length +public: + SbiSymDef( const OUString& ); + virtual ~SbiSymDef(); + virtual SbiProcDef* GetProcDef(); + virtual SbiConstDef* GetConstDef(); + + SbxDataType GetType() const { return eType; } + virtual void SetType( SbxDataType ); + const OUString& GetName(); + SbiSymScope GetScope() const; + sal_uInt32 GetAddr() const { return nChain; } + sal_uInt16 GetId() const { return nId; } + sal_uInt16 GetTypeId() const{ return nTypeId; } + void SetTypeId( sal_uInt16 n ) { nTypeId = n; eType = SbxOBJECT; } + sal_uInt16 GetPos() const { return nPos; } + void SetLen( short n ){ nLen = n; } + short GetLen() const { return nLen; } + void SetDims( short n ) { nDims = n; } + short GetDims() const { return nDims; } + bool IsDefined() const{ return bChained; } + void SetOptional() { bOpt = true; } + void SetParamArray() { bParamArray = true; } + void SetWithEvents() { bWithEvents = true; } + void SetWithBrackets(){ bWithBrackets = true; } + void SetByVal( bool bByVal_ ) { bByVal = bByVal_; } + void SetStatic( bool bAsStatic = true ) { bStatic = bAsStatic; } + void SetNew() { bNew = true; } + void SetDefinedAs() { bAs = true; } + void SetGlobal(bool b){ bGlobal = b; } + void SetDefaultId( sal_uInt16 n ) { nDefaultId = n; } + sal_uInt16 GetDefaultId() const { return nDefaultId; } + bool IsOptional() const{ return bOpt; } + bool IsParamArray() const{ return bParamArray; } + bool IsWithEvents() const{ return bWithEvents; } + bool IsWithBrackets() const{ return bWithBrackets; } + bool IsByVal() const { return bByVal; } + bool IsStatic() const { return bStatic; } + bool IsNew() const { return bNew; } + bool IsDefinedAs() const { return bAs; } + bool IsGlobal() const { return bGlobal; } + short GetFixedStringLength() const { return nFixedStringLength; } + void SetFixedStringLength( short n ) { nFixedStringLength = n; } + + SbiSymPool& GetPool(); + sal_uInt32 Define(); // define symbol in code + sal_uInt32 Reference(); // reference symbol in code + +private: + SbiSymDef( const SbiSymDef& ) = delete; + +}; + +class SbiProcDef : public SbiSymDef { // procedure definition (from basic): + SbiSymPool aParams; + SbiSymPool aLabels; // local jump targets + OUString aLibName; + OUString aAlias; + sal_uInt16 nLine1, nLine2; // line area + PropertyMode mePropMode; // Marks if this is a property procedure and which + OUString maPropName; // Property name if property procedure (!= proc name) + bool bCdecl : 1; // true: CDECL given + bool bPublic : 1; // true: proc is PUBLIC + bool mbProcDecl : 1; // true: instantiated by SbiParser::ProcDecl +public: + SbiProcDef( SbiParser*, const OUString&, bool bProcDecl=false ); + virtual ~SbiProcDef() override; + virtual SbiProcDef* GetProcDef() override; + virtual void SetType( SbxDataType ) override; + SbiSymPool& GetParams() { return aParams; } + SbiSymPool& GetLabels() { return aLabels; } + SbiSymPool& GetLocals() { return GetPool();} + OUString& GetLib() { return aLibName; } + OUString& GetAlias() { return aAlias; } + void SetPublic( bool b ) { bPublic = b; } + bool IsPublic() const { return bPublic; } + void SetCdecl( bool b ) { bCdecl = b; } + bool IsCdecl() const { return bCdecl; } + bool IsUsedForProcDecl() const { return mbProcDecl; } + void SetLine1( sal_uInt16 n ) { nLine1 = n; } + sal_uInt16 GetLine1() const { return nLine1; } + void SetLine2( sal_uInt16 n ) { nLine2 = n; } + sal_uInt16 GetLine2() const { return nLine2; } + PropertyMode getPropertyMode() const { return mePropMode; } + void setPropertyMode( PropertyMode ePropMode ); + const OUString& GetPropName() const { return maPropName; } + + // Match with a forward-declaration. The parameter names are + // compared and the forward declaration is replaced by this + void Match( SbiProcDef* pForward ); + +private: + SbiProcDef( const SbiProcDef& ) = delete; + +}; + +class SbiConstDef : public SbiSymDef +{ + double nVal; + OUString aVal; +public: + SbiConstDef( const OUString& ); + virtual ~SbiConstDef() override; + virtual SbiConstDef* GetConstDef() override; + void Set( double, SbxDataType ); + void Set( const OUString& ); + double GetValue() const { return nVal; } + const OUString& GetString() const { return aVal; } +}; + + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/basic/source/inc/token.hxx b/basic/source/inc/token.hxx new file mode 100644 index 000000000..34abfce82 --- /dev/null +++ b/basic/source/inc/token.hxx @@ -0,0 +1,140 @@ +/* -*- 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_SOURCE_INC_TOKEN_HXX +#define INCLUDED_BASIC_SOURCE_INC_TOKEN_HXX + +#include "scanner.hxx" + +// The tokenizer is stand-alone, i. e. he can be used from everywhere. +// A BASIC-instance is necessary for error messages. Without BASIC the +// errors are only counted. The BASIC is also necessary when an advanced +// SBX-variable shall be used for recognition of data types etc. + + +enum SbiToken { + NIL = 0, + // tokens between 0x20 and 0x3F are literals: + LPAREN = '(', RPAREN = ')', COMMA = ',', DOT = '.', EXCLAM = '!', + HASH = '#', SEMICOLON = ';', + + // commands: + FIRSTKWD = 0x40, + AS = FIRSTKWD, ALIAS, ASSIGN, + CALL, CASE, CLOSE, COMPARE, CONST_, + DECLARE, DIM, DO, + + // in the order of the data type enums! + DEFINT, DEFLNG, DEFSNG, DEFDBL, DEFCUR, DEFDATE, DEFSTR, DEFOBJ, + DEFERR, DEFBOOL, DEFVAR, + // in the order of the data type enums! + DATATYPE1, + TINTEGER = DATATYPE1, + TLONG, TSINGLE, TDOUBLE, TCURRENCY, TDATE, TSTRING, TOBJECT, + ERROR_, TBOOLEAN, TVARIANT, TBYTE, + DATATYPE2 = TBYTE, + + EACH, ELSE, ELSEIF, END, ERASE, EXIT, + FOR, FUNCTION, + GET, GLOBAL, GOSUB, GOTO, + IF, IN_, INPUT, + LET, LINE, LINEINPUT, LOCAL, LOOP, LPRINT, LSET, + NAME, NEW, NEXT, + ON, OPEN, OPTION, ATTRIBUTE, IMPLEMENTS, + PRINT, PRIVATE, PROPERTY, PUBLIC, + REDIM, REM, RESUME, RETURN, RSET, + SELECT, SET, SHARED, STATIC, STEP, STOP, SUB, + TEXT, THEN, TO, TYPE, ENUM, + UNTIL, + WEND, WHILE, WITH, WRITE, + ENDENUM, ENDIF, ENDFUNC, ENDPROPERTY, ENDSUB, ENDTYPE, ENDSELECT, ENDWITH, + // end of all keywords + LASTKWD = ENDWITH, + // statement end + EOS, EOLN, + // operators: + EXPON, NEG, MUL, + DIV, IDIV, MOD, PLUS, MINUS, + EQ, NE, LT, GT, LE, GE, + NOT, AND, OR, XOR, EQV, + IMP, CAT, LIKE, IS, TYPEOF, + // miscellaneous: + FIRSTEXTRA, + NUMBER=FIRSTEXTRA, FIXSTRING, SYMBOL, CDECL_, BYVAL, BYREF, + OUTPUT, RANDOM, APPEND, BINARY, ACCESS, + LOCK, READ, PRESERVE, BASE, ANY, LIB, OPTIONAL_, PTRSAFE, + BASIC_EXPLICIT, COMPATIBLE, CLASSMODULE, PARAMARRAY, WITHEVENTS, + + // from here there are JavaScript-tokens (same enum so that same type) + FIRSTJAVA, + JS_BREAK=FIRSTJAVA, JS_CONTINUE, JS_FOR, JS_FUNCTION, JS_IF, JS_NEW, + JS_RETURN, JS_THIS, JS_VAR, JS_WHILE, JS_WITH, + + // JavaScript-operators + // _ASS_ = Assignment + JS_COMMA, JS_ASSIGNMENT, JS_ASS_PLUS, JS_ASS_MINUS, JS_ASS_MUL, + JS_ASS_DIV, JS_ASS_MOD, JS_ASS_LSHIFT, JS_ASS_RSHIFT, JS_ASS_RSHIFT_Z, + JS_ASS_AND, JS_ASS_XOR, JS_ASS_OR, + JS_COND_QUEST, JS_COND_SEL, JS_LOG_OR, JS_LOG_AND, JS_BIT_OR, + JS_BIT_XOR, JS_BIT_AND, JS_EQ, JS_NE, JS_LT, JS_LE, + JS_GT, JS_GE, JS_LSHIFT, JS_RSHIFT, JS_RSHIFT_Z, + JS_PLUS, JS_MINUS, JS_MUL, JS_DIV, JS_MOD, JS_LOG_NOT, JS_BIT_NOT, + JS_INC, JS_DEC, JS_LPAREN, JS_RPAREN, JS_LINDEX, JS_RINDEX + , VBASUPPORT +}; + +class SbiTokenizer : public SbiScanner { +protected: + SbiToken eCurTok; + SbiToken ePush; + sal_uInt16 nPLine, nPCol1, nPCol2; // pushback location + bool bEof; + bool bEos; + bool bAs; // last keyword was AS + bool bErrorIsSymbol; // Handle Error token as Symbol, not keyword +public: + SbiTokenizer( const OUString&, StarBASIC* = nullptr ); + + bool IsEof() const { return bEof; } + bool IsEos() const { return bEos; } + + void Push( SbiToken ); + const OUString& Symbol( SbiToken ); // reconversion + + SbiToken Peek(); // read the next token + SbiToken Next(); // read a token + bool MayBeLabel( bool= false ); + + void Error( ErrCode c ) { GenError( c ); } + void Error( ErrCode, SbiToken ); + void Error( ErrCode, const OUString &); + + static bool IsEoln( SbiToken t ) + { return t == EOS || t == EOLN || t == REM; } + static bool IsKwd( SbiToken t ) + { return t >= FIRSTKWD && t <= LASTKWD; } + static bool IsExtra( SbiToken t ) + { return t >= FIRSTEXTRA; } + static OUString GetKeywordCase( const OUString& sKeyword ); +}; + + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |