LCOV - code coverage report
Current view: top level - include/formula - tokenarray.hxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 48 57 84.2 %
Date: 2015-06-13 12:38:46 Functions: 33 37 89.2 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #ifndef INCLUDED_FORMULA_TOKENARRAY_HXX
      21             : #define INCLUDED_FORMULA_TOKENARRAY_HXX
      22             : 
      23             : #include <com/sun/star/sheet/FormulaToken.hpp>
      24             : #include <formula/token.hxx>
      25             : #include <formula/ExternalReferenceHelper.hxx>
      26             : #include <o3tl/underlying_type.hxx>
      27             : #include <o3tl/typed_flags_set.hxx>
      28             : 
      29             : #include <limits.h>
      30             : #include <unordered_set>
      31             : 
      32             : namespace svl {
      33             : 
      34             : class SharedString;
      35             : class SharedStringPool;
      36             : 
      37             : }
      38             : 
      39             : // RecalcMode access only via TokenArray SetRecalcMode / IsRecalcMode...
      40             : 
      41             : // Only one of the exclusive bits can be set,
      42             : // handled by TokenArray SetRecalcMode... methods
      43             : enum class ScRecalcMode : sal_uInt8
      44             : {
      45             :     NORMAL       = 0x01,    // exclusive
      46             :     ALWAYS       = 0x02,    // exclusive, always
      47             :     ONLOAD       = 0x04,    // exclusive, always after load
      48             :     ONLOAD_ONCE  = 0x08,    // exclusive, once after load
      49             :     FORCED       = 0x10,    // combined, also if cell isn't visible
      50             :     ONREFMOVE    = 0x20,    // combined, if reference was moved
      51             : };
      52             : // If new bits are to be defined, AddRecalcMode has to be adjusted!
      53             : namespace o3tl
      54             : {
      55             :     template<> struct typed_flags<ScRecalcMode> : is_typed_flags<ScRecalcMode, 0x3f> {};
      56             : }
      57             : #define RECALCMODE_EMASK (ScRecalcMode(ScRecalcMode::NORMAL | ScRecalcMode::ALWAYS | ScRecalcMode::ONLOAD | ScRecalcMode::ONLOAD_ONCE))  // mask of exclusive bits
      58             : 
      59             : namespace formula
      60             : {
      61             : 
      62             : class FormulaMissingContext;
      63             : 
      64             : class FORMULA_DLLPUBLIC MissingConvention
      65             : {
      66             : public:
      67             :     enum Convention
      68             :     {
      69             :         FORMULA_MISSING_CONVENTION_PODF,
      70             :         FORMULA_MISSING_CONVENTION_ODFF,
      71             :         FORMULA_MISSING_CONVENTION_OOXML
      72             :     };
      73        1914 :     explicit            MissingConvention( Convention eConvention ) : meConvention(eConvention) {}
      74         522 :     inline  bool        isPODF() const  { return meConvention == FORMULA_MISSING_CONVENTION_PODF; }
      75         522 :     inline  Convention  getConvention() const { return meConvention; }
      76             : private:
      77             :     Convention meConvention;
      78             : };
      79             : 
      80             : class FORMULA_DLLPUBLIC MissingConventionODF : public MissingConvention
      81             : {
      82             : public:
      83        1354 :     explicit    MissingConventionODF( bool bODFF ) :
      84             :         MissingConvention( bODFF ?
      85             :                 MissingConvention::FORMULA_MISSING_CONVENTION_ODFF :
      86        1354 :                 MissingConvention::FORMULA_MISSING_CONVENTION_PODF)
      87             :         {
      88        1354 :         }
      89             :     // Implementation and usage only in token.cxx
      90             :     inline  bool    isRewriteNeeded( OpCode eOp ) const;
      91             : };
      92             : 
      93             : class FORMULA_DLLPUBLIC MissingConventionOOXML : public MissingConvention
      94             : {
      95             : public:
      96         560 :     explicit    MissingConventionOOXML() : MissingConvention( MissingConvention::FORMULA_MISSING_CONVENTION_OOXML) {}
      97             :     // Implementation and usage only in token.cxx
      98             :     static inline bool isRewriteNeeded( OpCode eOp );
      99             : };
     100             : 
     101             : typedef std::unordered_set<OpCode, std::hash<o3tl::underlying_type<OpCode>::type> > unordered_opcode_set;
     102             : 
     103             : class FORMULA_DLLPUBLIC FormulaTokenArray
     104             : {
     105             :     friend class FormulaCompiler;
     106             :     friend class FormulaTokenIterator;
     107             :     friend class FormulaMissingContext;
     108             : 
     109             : protected:
     110             :     FormulaToken**  pCode;                  // Token code array
     111             :     FormulaToken**  pRPN;                   // RPN array
     112             :     sal_uInt16          nLen;                   // Length of token array
     113             :     sal_uInt16          nRPN;                   // Length of RPN array
     114             :     sal_uInt16          nIndex;                 // Current step index
     115             :     sal_uInt16          nError;                 // Error code
     116             :     ScRecalcMode    nMode;                  // Flags to indicate when to recalc this code
     117             :     bool            bHyperLink;             // If HYPERLINK() occurs in the formula.
     118             : 
     119             : protected:
     120             :     void                    Assign( const FormulaTokenArray& );
     121             :     void                    Assign( sal_uInt16 nCode, FormulaToken **pTokens );
     122             : 
     123             :     /// Also used by the compiler. The token MUST had been allocated with new!
     124             :     FormulaToken*           Add( FormulaToken* );
     125             :     /** Also used by the compiler. The token MUST had been allocated with new!
     126             :         @param nOffset negative offset of token, 0==last, 1==previous, ...
     127             :      */
     128             :     FormulaToken*           ReplaceToken( sal_uInt16 nOffset, FormulaToken* );
     129        1157 :     inline  void            SetCombinedBitsRecalcMode( ScRecalcMode nBits )
     130        1157 :                                 { nMode |= (nBits & ~RECALCMODE_EMASK); }
     131         203 :     inline  ScRecalcMode    GetCombinedBitsRecalcMode() const
     132         203 :                                 { return nMode & ~RECALCMODE_EMASK; }
     133             :                             /** Exclusive bits already set in nMode are
     134             :                                 zero'ed, nBits may contain combined bits, but
     135             :                                 only one exclusive bit may be set! */
     136         203 :     inline  void            SetMaskedRecalcMode( ScRecalcMode nBits )
     137         203 :                                 { nMode = GetCombinedBitsRecalcMode() | nBits; }
     138             : 
     139             : public:
     140             :     FormulaTokenArray();
     141             :     /// Assignment with references to FormulaToken entries (not copied!)
     142             :     FormulaTokenArray( const FormulaTokenArray& );
     143             :     virtual ~FormulaTokenArray();
     144             :     FormulaTokenArray* Clone() const;    /// True copy!
     145             : 
     146             :     void Clear();
     147             :     void DelRPN();
     148        5976 :     FormulaToken* First() { nIndex = 0; return Next(); }
     149             :     FormulaToken* Next();
     150             :     FormulaToken* FirstNoSpaces() { nIndex = 0; return NextNoSpaces(); }
     151             :     FormulaToken* NextNoSpaces();
     152             :     FormulaToken* GetNextName();
     153             :     FormulaToken* GetNextReference();
     154             :     FormulaToken* GetNextReferenceRPN();
     155             :     FormulaToken* GetNextReferenceOrName();
     156             :     FormulaToken* GetNextColRowName();
     157             :     /// Peek at nIdx-1 if not out of bounds, decrements nIdx if successful. Returns NULL if not.
     158             :     FormulaToken* PeekPrev( sal_uInt16 & nIdx );
     159             :     FormulaToken* PeekNext();
     160             :     FormulaToken* PeekPrevNoSpaces();    /// Only after Reset/First/Next/Last/Prev!
     161             :     FormulaToken* PeekNextNoSpaces();    /// Only after Reset/First/Next/Last/Prev!
     162         244 :     FormulaToken* FirstRPN() { nIndex = 0; return NextRPN(); }
     163             :     FormulaToken* NextRPN();
     164           0 :     FormulaToken* LastRPN() { nIndex = nRPN; return PrevRPN(); }
     165             :     FormulaToken* PrevRPN();
     166             : 
     167             :     bool HasReferences() const;
     168             : 
     169             :     bool    HasExternalRef() const;
     170             :     bool    HasOpCode( OpCode ) const;
     171             :     bool    HasOpCodeRPN( OpCode ) const;
     172             :     /// Token of type svIndex or opcode ocColRowName
     173             :     bool    HasNameOrColRowName() const;
     174             : 
     175             :     /**
     176             :      * Check if the token array contains any of specified opcode tokens.
     177             :      *
     178             :      * @param rOpCodes collection of opcodes to check against.
     179             :      *
     180             :      * @return true if the token array contains at least one of the specified
     181             :      *         opcode tokens, false otherwise.
     182             :      */
     183             :     bool HasOpCodes( const unordered_opcode_set& rOpCodes ) const;
     184             : 
     185        4726 :     FormulaToken** GetArray() const  { return pCode; }
     186       12274 :     FormulaToken** GetCode()  const  { return pRPN; }
     187       34301 :     sal_uInt16    GetLen() const     { return nLen; }
     188      108328 :     sal_uInt16    GetCodeLen() const { return nRPN; }
     189       30609 :     void      Reset()            { nIndex = 0; }
     190      240043 :     sal_uInt16    GetCodeError() const      { return nError; }
     191        1819 :     void      SetCodeError( sal_uInt16 n )  { nError = n; }
     192        1555 :     void      SetHyperLink( bool bVal ) { bHyperLink = bVal; }
     193         773 :     bool      IsHyperLink() const       { return bHyperLink; }
     194             : 
     195         768 :     inline  ScRecalcMode    GetRecalcMode() const { return nMode; }
     196             :                             /** Bits aren't set directly but validated and
     197             :                                 maybe handled according to priority if more
     198             :                                 than one exclusive bit was set. */
     199             :             void            AddRecalcMode( ScRecalcMode nBits );
     200             : 
     201       40200 :     inline  void            ClearRecalcMode() { nMode = ScRecalcMode::NORMAL; }
     202           1 :     inline  void            SetExclusiveRecalcModeNormal()
     203           1 :                                 { SetMaskedRecalcMode( ScRecalcMode::NORMAL ); }
     204          34 :     inline  void            SetExclusiveRecalcModeAlways()
     205          34 :                                 { SetMaskedRecalcMode( ScRecalcMode::ALWAYS ); }
     206         168 :     inline  void            SetExclusiveRecalcModeOnLoad()
     207         168 :                                 { SetMaskedRecalcMode( ScRecalcMode::ONLOAD ); }
     208           0 :     inline  void            SetExclusiveRecalcModeOnLoadOnce()
     209           0 :                                 { SetMaskedRecalcMode( ScRecalcMode::ONLOAD_ONCE ); }
     210           0 :     inline  void            SetRecalcModeForced()
     211           0 :                                 { nMode |= ScRecalcMode::FORCED; }
     212             :     inline  void            ClearRecalcModeForced()
     213             :                                 { nMode &= ~ScRecalcMode::FORCED; }
     214         120 :     inline  void            SetRecalcModeOnRefMove()
     215         120 :                                 { nMode |= ScRecalcMode::ONREFMOVE; }
     216             :     inline  void            ClearRecalcModeOnRefMove()
     217             :                                 { nMode &= ~ScRecalcMode::ONREFMOVE; }
     218        4308 :     inline  bool            IsRecalcModeNormal() const
     219        4308 :                                 { return bool(nMode & ScRecalcMode::NORMAL); }
     220       88415 :     inline  bool            IsRecalcModeAlways() const
     221       88415 :                                 { return bool(nMode & ScRecalcMode::ALWAYS); }
     222        1528 :     inline  bool            IsRecalcModeOnLoad() const
     223        1528 :                                 { return bool(nMode & ScRecalcMode::ONLOAD); }
     224        1376 :     inline  bool            IsRecalcModeOnLoadOnce() const
     225        1376 :                                 { return bool(nMode & ScRecalcMode::ONLOAD_ONCE); }
     226       50713 :     inline  bool            IsRecalcModeForced() const
     227       50713 :                                 { return bool(nMode & ScRecalcMode::FORCED); }
     228         507 :     inline  bool            IsRecalcModeOnRefMove() const
     229         507 :                                 { return bool(nMode & ScRecalcMode::ONREFMOVE); }
     230             : 
     231             :                             /** Get OpCode of the most outer function */
     232             :     inline OpCode           GetOuterFuncOpCode();
     233             : 
     234             :                             /** Operators +,-,*,/,^,&,=,<>,<,>,<=,>=
     235             :                                 with DoubleRef in Formula? */
     236             :     bool                    HasMatrixDoubleRefOps();
     237             : 
     238             :     virtual FormulaToken* AddOpCode(OpCode e);
     239             : 
     240             :     /** Adds the single token to array.
     241             :         Derived classes must override it when they want to support derived classes from FormulaToken.
     242             :         @return true        when an error occurs
     243             :     */
     244             :     virtual bool AddFormulaToken(
     245             :         const css::sheet::FormulaToken& rToken, svl::SharedStringPool& rSPool,
     246             :         ExternalReferenceHelper* pExtRef );
     247             : 
     248             :     /** fill the array with the tokens from the sequence.
     249             :         It calls AddFormulaToken for each token in the list.
     250             :         @param  _aSequence  the token to add
     251             :         @return true        when an error occurs
     252             :     */
     253             :     bool Fill(
     254             :         const css::uno::Sequence<css::sheet::FormulaToken>& rSequence,
     255             :         svl::SharedStringPool& rSPool, ExternalReferenceHelper* pExtRef );
     256             : 
     257             :     /**
     258             :      * Do some checking based on the individual tokens. For now, we use this
     259             :      * only to check whether we can vectorize the token array.
     260             :      */
     261             :     virtual void CheckToken( const FormulaToken& t );
     262             : 
     263             :     FormulaToken* AddToken( const FormulaToken& );
     264             :     FormulaToken* AddString( const svl::SharedString& rStr );
     265             :     FormulaToken* AddDouble( double fVal );
     266             :     FormulaToken* AddExternal( const sal_Unicode* pStr );
     267             :     /** Xcl import may play dirty tricks with OpCode!=ocExternal.
     268             :         Others don't use! */
     269             :     FormulaToken* AddExternal( const OUString& rStr, OpCode eOp = ocExternal );
     270             :     FormulaToken* AddBad( const OUString& rStr );          /// ocBad with OUString
     271             :     FormulaToken* AddStringXML( const OUString& rStr );    /// ocStringXML with OUString, temporary during import
     272             : 
     273             :     virtual FormulaToken* MergeArray( );
     274             : 
     275             :     /// Assignment with references to FormulaToken entries (not copied!)
     276             :     FormulaTokenArray& operator=( const FormulaTokenArray& );
     277             : 
     278             :     /** Determines if this formula needs any changes to convert it to something
     279             :         previous versions of OOo could consume (Plain Old Formula, pre-ODFF, or
     280             :         also ODFF) */
     281             :     bool                NeedsPodfRewrite( const MissingConventionODF & rConv );
     282             : 
     283             :     /** Determines if this formula needs any changes to convert it to OOXML. */
     284             :     bool                NeedsOoxmlRewrite();
     285             : 
     286             :     /** Rewrites to Plain Old Formula or OOXML, substituting missing parameters. The
     287             :         FormulaTokenArray* returned is new'ed. */
     288             :     FormulaTokenArray*  RewriteMissing( const MissingConvention & rConv );
     289             : 
     290             :     /** Determines if this formula may be followed by a reference. */
     291             :     bool                MayReferenceFollow();
     292             : };
     293             : 
     294           0 : inline OpCode FormulaTokenArray::GetOuterFuncOpCode()
     295             : {
     296           0 :     if ( pRPN && nRPN )
     297           0 :         return pRPN[nRPN-1]->GetOpCode();
     298           0 :     return ocNone;
     299             : }
     300             : 
     301             : class FORMULA_DLLPUBLIC FormulaTokenIterator
     302             : {
     303             :     struct Item
     304             :     {
     305             :     public:
     306             :         const FormulaTokenArray* pArr;
     307             :         short nPC;
     308             :         short nStop;
     309             : 
     310             :         Item(const FormulaTokenArray* arr, short pc, short stop);
     311             :     };
     312             : 
     313             :     std::vector<Item> *maStack;
     314             : 
     315             : public:
     316             :     FormulaTokenIterator( const FormulaTokenArray& );
     317             :    ~FormulaTokenIterator();
     318             :     void    Reset();
     319             :     const   FormulaToken* Next();
     320             :     const   FormulaToken* PeekNextOperator();
     321             :     bool    IsEndOfPath() const;    /// if a jump or subroutine path is done
     322          25 :     bool    HasStacked() const { return maStack->size() > 1; }
     323           8 :     short   GetPC() const { return maStack->back().nPC; }
     324             : 
     325             :     /** Jump or subroutine call.
     326             :         Program counter values will be incremented before code is executed =>
     327             :         positions are to be passed with -1 offset.
     328             :         @param nStart
     329             :             Start on code at position nStart+1 (yes, pass with offset -1)
     330             :         @param nNext
     331             :             After subroutine continue with instruction at position nNext+1
     332             :         @param nStop
     333             :             Stop before reaching code at position nStop. If not specified the
     334             :             default is to either run the entire code, or to stop if an ocSep or
     335             :             ocClose is encountered, which are only present in ocIf or ocChoose
     336             :             jumps.
     337             :       */
     338             :     void Jump( short nStart, short nNext, short nStop = SHRT_MAX );
     339             :     void Push( const FormulaTokenArray* );
     340             :     void Pop();
     341             : 
     342             : private:
     343             :     const FormulaToken* GetNonEndOfPathToken( short nIdx ) const;
     344             : };
     345             : } // formula
     346             : 
     347             : #endif // INCLUDED_FORMULA_TOKENARRAY_HXX
     348             : 
     349             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11