diff options
Diffstat (limited to 'sc/inc/compiler.hxx')
| -rw-r--r-- | sc/inc/compiler.hxx | 555 |
1 files changed, 555 insertions, 0 deletions
diff --git a/sc/inc/compiler.hxx b/sc/inc/compiler.hxx new file mode 100644 index 000000000..b7896c26c --- /dev/null +++ b/sc/inc/compiler.hxx @@ -0,0 +1,555 @@ +/* -*- 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 . + */ + +#pragma once + +#include <string.h> + +#include "scdllapi.h" +#include "global.hxx" +#include "refdata.hxx" +#include "token.hxx" +#include <formula/token.hxx> +#include <formula/grammar.hxx> +#include <rtl/ustrbuf.hxx> +#include <com/sun/star/sheet/ExternalLinkInfo.hpp> +#include <com/sun/star/i18n/ParseResult.hpp> +#include <queue> +#include <vector> +#include <memory> +#include <set> +#include <com/sun/star/uno/Sequence.hxx> +#include <o3tl/typed_flags_set.hxx> + +#include <formula/FormulaCompiler.hxx> + +struct ScSheetLimits; + +// constants and data types also for external modules (ScInterpreter et al) + +#define MAXSTRLEN 1024 /* maximum length of input string of one symbol */ + +// flag values of CharTable +enum class ScCharFlags : sal_uInt32 { + NONE = 0x00000000, + Illegal = 0x00000000, + Char = 0x00000001, + CharBool = 0x00000002, + CharWord = 0x00000004, + CharValue = 0x00000008, + CharString = 0x00000010, + CharDontCare = 0x00000020, + Bool = 0x00000040, + Word = 0x00000080, + WordSep = 0x00000100, + Value = 0x00000200, + ValueSep = 0x00000400, + ValueExp = 0x00000800, + ValueSign = 0x00001000, + ValueValue = 0x00002000, + StringSep = 0x00004000, + NameSep = 0x00008000, // there can be only one! '\'' + CharIdent = 0x00010000, // identifier (built-in function) or reference start + Ident = 0x00020000, // identifier or reference continuation + OdfLBracket = 0x00040000, // ODF '[' reference bracket + OdfRBracket = 0x00080000, // ODF ']' reference bracket + OdfLabelOp = 0x00100000, // ODF '!!' automatic intersection of labels + OdfNameMarker = 0x00200000, // ODF '$$' marker that starts a defined (range) name + CharName = 0x00400000, // start character of a defined name + Name = 0x00800000, // continuation character of a defined name + CharErrConst = 0x01000000, // start character of an error constant ('#') +}; +namespace o3tl { + template<> struct typed_flags<ScCharFlags> : is_typed_flags<ScCharFlags, 0x01ffffff> {}; +} + +#define SC_COMPILER_FILE_TAB_SEP '#' // 'Doc'#Tab + +class ScDocument; +class ScMatrix; +class ScRangeData; +class ScTokenArray; +struct ScInterpreterContext; +class CharClass; + +namespace sc { + +class CompileFormulaContext; + +} + +// constants and data types internal to compiler + +struct ScRawToken final +{ + friend class ScCompiler; + // Friends that use a temporary ScRawToken on the stack (and therefore need + // the private dtor) and know what they're doing... + friend class ScTokenArray; + OpCode eOp; + formula::StackVar eType; // type of data; this determines how the unions are used +public: + union { + double nValue; + struct { + sal_uInt8 nCount; + sal_Unicode cChar; + } whitespace; + struct { + sal_uInt8 cByte; + formula::ParamClass eInForceArray; + } sbyte; + ScComplexRefData aRef; + struct { + sal_uInt16 nFileId; + ScComplexRefData aRef; + } extref; + struct { + sal_uInt16 nFileId; + } extname; + struct { + sal_Int16 nSheet; + sal_uInt16 nIndex; + } name; + struct { + sal_uInt16 nIndex; + ScTableRefToken::Item eItem; + } table; + struct { + rtl_uString* mpData; + rtl_uString* mpDataIgnoreCase; + } sharedstring; + ScMatrix* pMat; + FormulaError nError; + short nJump[ FORMULA_MAXJUMPCOUNT + 1 ]; // If/Chose token + }; + OUString maExternalName; // depending on the opcode, this is either the external, or the external name, or the external table name + + // coverity[uninit_member] - members deliberately not initialized + ScRawToken() {} +private: + ~ScRawToken() {} //! only delete via Delete() +public: + formula::StackVar GetType() const { return eType; } + OpCode GetOpCode() const { return eOp; } + void NewOpCode( OpCode e ) { eOp = e; } + + // Use these methods only on tokens that are not part of a token array, + // since the reference count is cleared! + void SetOpCode( OpCode eCode ); + void SetString( rtl_uString* pData, rtl_uString* pDataIgnoreCase ); + void SetSingleReference( const ScSingleRefData& rRef ); + void SetDoubleReference( const ScComplexRefData& rRef ); + void SetDouble( double fVal ); + void SetErrorConstant( FormulaError nErr ); + + // These methods are ok to use, reference count not cleared. + void SetName(sal_Int16 nSheet, sal_uInt16 nIndex); + void SetExternalSingleRef( sal_uInt16 nFileId, const OUString& rTabName, const ScSingleRefData& rRef ); + void SetExternalDoubleRef( sal_uInt16 nFileId, const OUString& rTabName, const ScComplexRefData& rRef ); + void SetExternalName( sal_uInt16 nFileId, const OUString& rName ); + void SetExternal(const OUString& rStr); + + /** If the token is a non-external reference, determine if the reference is + valid. If the token is an external reference, return true. Else return + false. Used only in ScCompiler::NextNewToken() to preserve non-existing + sheet names in otherwise valid references. + */ + bool IsValidReference(const ScDocument& rDoc) const; + + formula::FormulaToken* CreateToken(ScSheetLimits& rLimits) const; // create typified token +}; + +class SC_DLLPUBLIC ScCompiler final : public formula::FormulaCompiler +{ +public: + + enum ExtendedErrorDetection + { + EXTENDED_ERROR_DETECTION_NONE = 0, // no error on unknown symbols, default (interpreter handles it) + EXTENDED_ERROR_DETECTION_NAME_BREAK, // name error on unknown symbols and break, pCode incomplete + EXTENDED_ERROR_DETECTION_NAME_NO_BREAK // name error on unknown symbols, don't break, continue + }; + + struct SAL_DLLPRIVATE Convention + { + const formula::FormulaGrammar::AddressConvention meConv; + + Convention( formula::FormulaGrammar::AddressConvention eConvP ); + virtual ~Convention(); + + virtual void makeRefStr( + ScSheetLimits& rLimits, + OUStringBuffer& rBuffer, + formula::FormulaGrammar::Grammar eGram, + const ScAddress& rPos, + const OUString& rErrRef, const std::vector<OUString>& rTabNames, + const ScComplexRefData& rRef, bool bSingleRef, bool bFromRangeName ) const = 0; + + virtual css::i18n::ParseResult + parseAnyToken( const OUString& rFormula, + sal_Int32 nSrcPos, + const CharClass* pCharClass, + bool bGroupSeparator) const = 0; + + /** + * Parse the symbol string and pick up the file name and the external + * range name. + * + * @return true on successful parse, or false otherwise. + */ + virtual bool parseExternalName( const OUString& rSymbol, OUString& rFile, OUString& rName, + const ScDocument& rDoc, + const css::uno::Sequence< css::sheet::ExternalLinkInfo>* pExternalLinks ) const = 0; + + virtual OUString makeExternalNameStr( sal_uInt16 nFileId, const OUString& rFile, + const OUString& rName ) const = 0; + + virtual void makeExternalRefStr( + ScSheetLimits& rLimits, + OUStringBuffer& rBuffer, const ScAddress& rPos, sal_uInt16 nFileId, const OUString& rFileName, + const OUString& rTabName, const ScSingleRefData& rRef ) const = 0; + + virtual void makeExternalRefStr( + ScSheetLimits& rLimits, + OUStringBuffer& rBuffer, const ScAddress& rPos, + sal_uInt16 nFileId, const OUString& rFileName, const std::vector<OUString>& rTabNames, + const OUString& rTabName, const ScComplexRefData& rRef ) const = 0; + + enum SpecialSymbolType + { + /** + * Character between sheet name and address. In OOO A1 this is + * '.', while XL A1 and XL R1C1 this is '!'. + */ + SHEET_SEPARATOR, + + /** + * In OOO A1, a sheet name may be prefixed with '$' to indicate an + * absolute sheet position. + */ + ABS_SHEET_PREFIX + }; + virtual sal_Unicode getSpecialSymbol( SpecialSymbolType eSymType ) const = 0; + + virtual ScCharFlags getCharTableFlags( sal_Unicode c, sal_Unicode cLast ) const = 0; + + protected: + std::unique_ptr<ScCharFlags[]> mpCharTable; + }; + friend struct Convention; + +private: + + static osl::Mutex maMutex; + static const CharClass *pCharClassEnglish; // character classification for en_US locale + static const CharClass *pCharClassLocalized; // character classification for UI locale + static const Convention *pConventions[ formula::FormulaGrammar::CONV_LAST ]; + + static const struct AddInMap + { + const char* pODFF; + const char* pEnglish; + const char* pOriginal; // programmatical name + const char* pUpper; // upper case programmatical name + } g_aAddInMap[]; + static size_t GetAddInMapCount(); + + ScDocument& rDoc; + ScAddress aPos; + + SvNumberFormatter* mpFormatter; + const ScInterpreterContext* mpInterpreterContext; + + SCTAB mnCurrentSheetTab; // indicates current sheet number parsed so far + sal_Int32 mnCurrentSheetEndPos; // position after current sheet name if parsed + + // For CONV_XL_OOX, may be set via API by MOOXML filter. + css::uno::Sequence<css::sheet::ExternalLinkInfo> maExternalLinks; + + sal_Unicode cSymbol[MAXSTRLEN+1]; // current Symbol + 0 + OUString aFormula; // formula source code + sal_Int32 nSrcPos; // tokenizer position (source code) + ScRawToken maRawToken; + + std::queue<OpCode> maPendingOpCodes; // additional opcodes generated from a single symbol + + const CharClass* pCharClass; // which character classification is used for parseAnyToken and upper/lower + bool mbCharClassesDiffer; // whether pCharClass and current system locale's CharClass differ + sal_uInt16 mnPredetectedReference; // reference when reading ODF, 0 (none), 1 (single) or 2 (double) + sal_Int32 mnRangeOpPosInSymbol; // if and where a range operator is in symbol + const Convention *pConv; + ExtendedErrorDetection meExtendedErrorDetection; + bool mbCloseBrackets; // whether to close open brackets automatically, default TRUE + bool mbRewind; // whether symbol is to be rewound to some step during lexical analysis + bool mbRefConventionChartOOXML; // whether to use special ooxml chart syntax in case of OOXML reference convention, + // when parsing a formula string. [0]!GlobalNamedRange, LocalSheet!LocalNamedRange + std::vector<sal_uInt16> maExternalFiles; + + std::vector<OUString> maTabNames; /// sheet names mangled for the current grammar for output + std::vector<OUString> &GetSetupTabNames() const; /// get or setup tab names for the current grammar + + struct TableRefEntry + { + ScTokenRef mxToken; + sal_uInt16 mnLevel; + TableRefEntry( formula::FormulaToken* p ) : mxToken(p), mnLevel(0) {} + }; + std::vector<TableRefEntry> maTableRefs; /// "stack" of currently active ocTableRef tokens + + // Optimizing implicit intersection is done only at the end of code generation, because the usage context may + // be important. Store candidate parameters and the operation they are the argument for. + struct PendingImplicitIntersectionOptimization + { + PendingImplicitIntersectionOptimization(formula::FormulaToken** p, formula::FormulaToken* o) + : parameterLocation( p ), parameter( *p ), operation( o ) {} + formula::FormulaToken** parameterLocation; + formula::FormulaTokenRef parameter; + formula::FormulaTokenRef operation; + }; + std::vector< PendingImplicitIntersectionOptimization > mPendingImplicitIntersectionOptimizations; + std::set<formula::FormulaTokenRef> mUnhandledPossibleImplicitIntersections; +#ifdef DBG_UTIL + std::set<OpCode> mUnhandledPossibleImplicitIntersectionsOpCodes; +#endif + + bool NextNewToken(bool bInArray); + bool ToUpperAsciiOrI18nIsAscii( OUString& rUpper, const OUString& rOrg ) const; + + virtual void SetError(FormulaError nError) override; + + struct Whitespace final + { + sal_Int32 nCount; + sal_Unicode cChar; + + Whitespace() : nCount(0), cChar(0x20) {} + void reset( sal_Unicode c ) { nCount = 0; cChar = c; } + }; + + static void addWhitespace( std::vector<ScCompiler::Whitespace> & rvSpaces, + ScCompiler::Whitespace & rSpace, sal_Unicode c, sal_Int32 n = 1 ); + + std::vector<Whitespace> NextSymbol(bool bInArray); + + bool ParseValue( const OUString& ); + bool ParseOpCode( const OUString&, bool bInArray ); + bool ParseOpCode2( std::u16string_view ); + bool ParseString(); + bool ParseReference( const OUString& rSymbol, const OUString* pErrRef = nullptr ); + bool ParseSingleReference( const OUString& rSymbol, const OUString* pErrRef = nullptr ); + bool ParseDoubleReference( const OUString& rSymbol, const OUString* pErrRef = nullptr ); + bool ParsePredetectedReference( const OUString& rSymbol ); + bool ParsePredetectedErrRefReference( const OUString& rName, const OUString* pErrRef ); + bool ParseMacro( const OUString& ); + bool ParseNamedRange( const OUString&, bool onlyCheck = false ); + bool ParseExternalNamedRange( const OUString& rSymbol, bool& rbInvalidExternalNameRange ); + bool ParseDBRange( const OUString& ); + bool ParseColRowName( const OUString& ); + bool ParseBoolean( const OUString& ); + void AutoCorrectParsedSymbol(); + const ScRangeData* GetRangeData( SCTAB& rSheet, const OUString& rUpperName ) const; + + void AdjustSheetLocalNameRelReferences( SCTAB nDelta ); + void SetRelNameReference(); + + /** Obtain range data for ocName token, global or sheet local. + + Prerequisite: rToken is a FormulaIndexToken so IsGlobal() and + GetIndex() can be called on it. We don't check with RTTI. + */ + ScRangeData* GetRangeData( const formula::FormulaToken& pToken ) const; + + bool HasPossibleNamedRangeConflict(SCTAB nTab) const; + +public: + static const CharClass* GetCharClassLocalized(); + static const CharClass* GetCharClassEnglish(); + +public: + ScCompiler( sc::CompileFormulaContext& rCxt, const ScAddress& rPos, + bool bComputeII = false, bool bMatrixFlag = false, const ScInterpreterContext* pContext = nullptr ); + + /** If eGrammar == GRAM_UNSPECIFIED then the grammar of rDocument is used, + */ + ScCompiler( ScDocument& rDocument, const ScAddress&, + formula::FormulaGrammar::Grammar eGrammar = formula::FormulaGrammar::GRAM_UNSPECIFIED, + bool bComputeII = false, bool bMatrixFlag = false, const ScInterpreterContext* pContext = nullptr ); + + ScCompiler( sc::CompileFormulaContext& rCxt, const ScAddress& rPos, ScTokenArray& rArr, + bool bComputeII = false, bool bMatrixFlag = false, const ScInterpreterContext* pContext = nullptr ); + + /** If eGrammar == GRAM_UNSPECIFIED then the grammar of rDocument is used, + */ + ScCompiler( ScDocument& rDocument, const ScAddress&, ScTokenArray& rArr, + formula::FormulaGrammar::Grammar eGrammar = formula::FormulaGrammar::GRAM_UNSPECIFIED, + bool bComputeII = false, bool bMatrixFlag = false, const ScInterpreterContext* pContext = nullptr ); + + virtual ~ScCompiler() override; + +public: + static void DeInit(); /// all + + // for ScAddress::Format() + static void CheckTabQuotes( OUString& aTabName, + const formula::FormulaGrammar::AddressConvention eConv = formula::FormulaGrammar::CONV_OOO ); + + /** Analyzes a string for a 'Doc'#Tab construct, or 'Do''c'#Tab etc... + + @returns the position of the unquoted # hash mark in 'Doc'#Tab, or + -1 if none. */ + static sal_Int32 GetDocTabPos( const OUString& rString ); + + static bool EnQuote( OUString& rStr ); + + // Check if it is a valid english function name + static bool IsEnglishSymbol( const OUString& rName ); + + bool ParseErrorConstant( const OUString& ); + bool ParseTableRefItem( const OUString& ); + bool ParseTableRefColumn( const OUString& ); + + /** Calls GetToken() if PeekNextNoSpaces() is of given OpCode. */ + bool GetTokenIfOpCode( OpCode eOp ); + + /** + * When auto correction is set, the jump command reorder must be enabled. + */ + void SetAutoCorrection( bool bVal ); + void SetCloseBrackets( bool bVal ) { mbCloseBrackets = bVal; } + void SetRefConventionChartOOXML( bool bVal ) { mbRefConventionChartOOXML = bVal; } + void SetRefConvention( const Convention *pConvP ); + void SetRefConvention( const formula::FormulaGrammar::AddressConvention eConv ); + + static const Convention* GetRefConvention( formula::FormulaGrammar::AddressConvention eConv ); + + /** Overwrite FormulaCompiler::GetOpCodeMap() forwarding to + GetFinalOpCodeMap(). + */ + OpCodeMapPtr GetOpCodeMap( const sal_Int32 nLanguage ) const { return GetFinalOpCodeMap(nLanguage); } + + /// Set symbol map if not empty. + void SetFormulaLanguage( const OpCodeMapPtr & xMap ); + + void SetGrammar( const formula::FormulaGrammar::Grammar eGrammar ); + + void SetNumberFormatter( SvNumberFormatter* pFormatter ); + +private: + /** Set grammar and reference convention from within SetFormulaLanguage() + or SetGrammar(). + + @param eNewGrammar + The new grammar to be set and the associated reference convention. + + @param eOldGrammar + The previous grammar that was active before SetFormulaLanguage(). + */ + void SetGrammarAndRefConvention( + const formula::FormulaGrammar::Grammar eNewGrammar, + const formula::FormulaGrammar::Grammar eOldGrammar ); +public: + + /// Set external link info for ScAddress::CONV_XL_OOX. + void SetExternalLinks( + const css::uno::Sequence< + css::sheet::ExternalLinkInfo>& rLinks ) + { + maExternalLinks = rLinks; + } + + void CreateStringFromXMLTokenArray( OUString& rFormula, OUString& rFormulaNmsp ); + + void SetExtendedErrorDetection( ExtendedErrorDetection eVal ) { meExtendedErrorDetection = eVal; } + + bool IsCorrected() const { return bCorrected; } + const OUString& GetCorrectedFormula() const { return aCorrectedFormula; } + + /** + * Tokenize formula expression string into an array of tokens. + * + * @param rFormula formula expression to tokenize. + * + * @return heap allocated token array object. The caller <i>must</i> + * manage the life cycle of this object. + */ + std::unique_ptr<ScTokenArray> CompileString( const OUString& rFormula ); + std::unique_ptr<ScTokenArray> CompileString( const OUString& rFormula, const OUString& rFormulaNmsp ); + const ScAddress& GetPos() const { return aPos; } + + void MoveRelWrap(); + static void MoveRelWrap( const ScTokenArray& rArr, const ScDocument& rDoc, const ScAddress& rPos, + SCCOL nMaxCol, SCROW nMaxRow ); + + /** If the character is allowed as tested by nFlags (SC_COMPILER_C_... + bits) for all known address conventions. If more than one bit is given + in nFlags, all bits must match. */ + static bool IsCharFlagAllConventions( + OUString const & rStr, sal_Int32 nPos, ScCharFlags nFlags ); + + /** TODO : Move this to somewhere appropriate. */ + static bool DoubleRefToPosSingleRefScalarCase(const ScRange& rRange, ScAddress& rAdr, + const ScAddress& rFormulaPos); + + bool HasUnhandledPossibleImplicitIntersections() const { return !mUnhandledPossibleImplicitIntersections.empty(); } +#ifdef DBG_UTIL + const std::set<OpCode>& UnhandledPossibleImplicitIntersectionsOpCodes() { return mUnhandledPossibleImplicitIntersectionsOpCodes; } +#endif + +private: + // FormulaCompiler + virtual OUString FindAddInFunction( const OUString& rUpperName, bool bLocalFirst ) const override; + virtual void fillFromAddInCollectionUpperName( const NonConstOpCodeMapPtr& xMap ) const override; + virtual void fillFromAddInCollectionEnglishName( const NonConstOpCodeMapPtr& xMap ) const override; + virtual void fillFromAddInMap( const NonConstOpCodeMapPtr& xMap, formula::FormulaGrammar::Grammar _eGrammar ) const override; + virtual void fillAddInToken(::std::vector< css::sheet::FormulaOpCodeMapEntry >& _rVec,bool _bIsEnglish) const override; + + virtual bool HandleExternalReference(const formula::FormulaToken& _aToken) override; + virtual bool HandleRange() override; + virtual bool HandleColRowName() override; + virtual bool HandleDbData() override; + virtual bool HandleTableRef() override; + + virtual formula::FormulaTokenRef ExtendRangeReference( formula::FormulaToken & rTok1, formula::FormulaToken & rTok2 ) override; + virtual void CreateStringFromExternal( OUStringBuffer& rBuffer, const formula::FormulaToken* pToken ) const override; + virtual void CreateStringFromSingleRef( OUStringBuffer& rBuffer, const formula::FormulaToken* pToken ) const override; + virtual void CreateStringFromDoubleRef( OUStringBuffer& rBuffer, const formula::FormulaToken* pToken ) const override; + virtual void CreateStringFromMatrix( OUStringBuffer& rBuffer, const formula::FormulaToken* pToken ) const override; + virtual void CreateStringFromIndex( OUStringBuffer& rBuffer, const formula::FormulaToken* pToken ) const override; + virtual void LocalizeString( OUString& rName ) const override; // modify rName - input: exact name + + virtual formula::ParamClass GetForceArrayParameter( const formula::FormulaToken* pToken, sal_uInt16 nParam ) const override; + + /// Access the CharTable flags + ScCharFlags GetCharTableFlags( sal_Unicode c, sal_Unicode cLast ) + { return c < 128 ? pConv->getCharTableFlags(c, cLast) : ScCharFlags::NONE; } + + virtual void HandleIIOpCode(formula::FormulaToken* token, formula::FormulaToken*** pppToken, sal_uInt8 nNumParams) override; + bool HandleIIOpCodeInternal(formula::FormulaToken* token, formula::FormulaToken*** pppToken, sal_uInt8 nNumParams); + bool SkipImplicitIntersectionOptimization(const formula::FormulaToken* token) const; + virtual void PostProcessCode() override; + virtual void AnnotateOperands() override; + static bool ParameterMayBeImplicitIntersection(const formula::FormulaToken* token, int parameter); + void ReplaceDoubleRefII(formula::FormulaToken** ppDoubleRefTok); + bool AdjustSumRangeShape(const ScComplexRefData& rBaseRange, ScComplexRefData& rSumRange); + void CorrectSumRange(const ScComplexRefData& rBaseRange, ScComplexRefData& rSumRange, formula::FormulaToken** ppSumRangeToken); + void AnnotateTrimOnDoubleRefs(); +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |