Hold ParamClass at FormulaByteToken instead of bool, tdf#107724 prep

* change IsInForceArray() to GetInForceArray()
* add IsInForceArray() to keep previous functionality

Change-Id: I64c891486e548a66539646846a4691a213c783ac

5 files changed, 50 insertions, 41 deletions

diff --git a/formula/source/core/api/FormulaCompiler.cxx b/formula/source/core/api/FormulaCompiler.cxx
index 039b41a0d3ea..60ad7927c327 100644
--- a/formula/source/core/api/FormulaCompiler.cxx
+++ b/formula/source/core/api/FormulaCompiler.cxx
@@ -2552,18 +2552,18 @@ void FormulaCompiler::ForceArrayOperator( FormulaTokenRef& rCurr )
     if (!(rCurr->GetOpCode() != ocPush && (rCurr->GetType() == svByte || rCurr->GetType() == svJump)))
         return;
 
-    if (pCurrentFactorToken->IsInForceArray())
+    formula::ParamClass eType = pCurrentFactorToken->GetInForceArray();
+    if (eType == formula::ParamClass::ForceArray || eType == formula::ParamClass::ReferenceOrForceArray)
     {
-        rCurr->SetInForceArray( true);
+        rCurr->SetInForceArray( eType);
         return;
     }
 
     if (nCurrentFactorParam > 0)
     {
-        formula::ParamClass eType = GetForceArrayParameter( pCurrentFactorToken.get(),
-                static_cast<sal_uInt8>(nCurrentFactorParam - 1));
+        eType = GetForceArrayParameter( pCurrentFactorToken.get(), static_cast<sal_uInt8>(nCurrentFactorParam - 1));
         if (eType == ParamClass::ForceArray || eType == ParamClass::ReferenceOrForceArray)
-            rCurr->SetInForceArray( true);
+            rCurr->SetInForceArray( eType);
     }
 }
 
diff --git a/formula/source/core/api/token.cxx b/formula/source/core/api/token.cxx
index 2ecec86c1b2e..cc5a93573fe5 100644
--- a/formula/source/core/api/token.cxx
+++ b/formula/source/core/api/token.cxx
@@ -158,6 +158,12 @@ bool FormulaToken::IsRef() const
     return false;
 }
 
+bool FormulaToken::IsInForceArray() const
+{
+    ParamClass eParam = GetInForceArray();
+    return eParam == ParamClass::ForceArray || eParam == ParamClass::ReferenceOrForceArray;
+}
+
 bool FormulaToken::operator==( const FormulaToken& rToken ) const
 {
     // don't compare reference count!
@@ -178,13 +184,13 @@ void FormulaToken::SetByte( sal_uInt8 )
     SAL_WARN( "formula.core", "FormulaToken::SetByte: virtual dummy called" );
 }
 
-bool FormulaToken::IsInForceArray() const
+ParamClass FormulaToken::GetInForceArray() const
 {
     // ok to be called for any derived class
-    return false;
+    return ParamClass::Unknown;
 }
 
-void FormulaToken::SetInForceArray( bool )
+void FormulaToken::SetInForceArray( ParamClass )
 {
     SAL_WARN( "formula.core", "FormulaToken::SetInForceArray: virtual dummy called" );
 }
@@ -348,12 +354,12 @@ bool FormulaToken::TextEqual( const FormulaToken& rToken ) const
 
 sal_uInt8   FormulaByteToken::GetByte() const           { return nByte; }
 void        FormulaByteToken::SetByte( sal_uInt8 n )    { nByte = n; }
-bool        FormulaByteToken::IsInForceArray() const    { return bIsInForceArray; }
-void        FormulaByteToken::SetInForceArray( bool b ) { bIsInForceArray = b; }
+ParamClass  FormulaByteToken::GetInForceArray() const    { return eInForceArray; }
+void        FormulaByteToken::SetInForceArray( ParamClass c ) { eInForceArray = c; }
 bool FormulaByteToken::operator==( const FormulaToken& r ) const
 {
     return FormulaToken::operator==( r ) && nByte == r.GetByte() &&
-        bIsInForceArray == r.IsInForceArray();
+        eInForceArray == r.GetInForceArray();
 }
 
 
@@ -364,14 +370,14 @@ bool FormulaFAPToken::operator==( const FormulaToken& r ) const
 }
 
 
-short*  FormulaJumpToken::GetJump() const               { return pJump.get(); }
-bool    FormulaJumpToken::IsInForceArray() const        { return bIsInForceArray; }
-void    FormulaJumpToken::SetInForceArray( bool b )     { bIsInForceArray = b; }
+short*      FormulaJumpToken::GetJump() const                   { return pJump.get(); }
+ParamClass  FormulaJumpToken::GetInForceArray() const           { return eInForceArray; }
+void        FormulaJumpToken::SetInForceArray( ParamClass c )   { eInForceArray = c; }
 bool FormulaJumpToken::operator==( const FormulaToken& r ) const
 {
     return FormulaToken::operator==( r ) && pJump[0] == r.GetJump()[0] &&
         memcmp( pJump.get()+1, r.GetJump()+1, pJump[0] * sizeof(short) ) == 0 &&
-        bIsInForceArray == r.IsInForceArray();
+        eInForceArray == r.GetInForceArray();
 }
 FormulaJumpToken::~FormulaJumpToken()
 {
@@ -1620,7 +1626,7 @@ FormulaToken* FormulaTokenArray::AddOpCode( OpCode eOp )
             }
             break;
         default:
-            pRet = new FormulaByteToken( eOp, 0, false );
+            pRet = new FormulaByteToken( eOp, 0, ParamClass::Unknown );
             break;
     }
     return Add( pRet );
@@ -1797,7 +1803,7 @@ bool FormulaStringToken::operator==( const FormulaToken& r ) const
 }
 
 FormulaStringOpToken::FormulaStringOpToken( OpCode e, const svl::SharedString& r ) :
-    FormulaByteToken( e, 0, svString, false ), maString( r ) {}
+    FormulaByteToken( e, 0, svString, ParamClass::Unknown ), maString( r ) {}
 
 FormulaStringOpToken::FormulaStringOpToken( const FormulaStringOpToken& r ) :
     FormulaByteToken( r ), maString( r.maString ) {}
diff --git a/include/formula/token.hxx b/include/formula/token.hxx
index 7c0b062abe6f..99e99bf374ca 100644
--- a/include/formula/token.hxx
+++ b/include/formula/token.hxx
@@ -30,6 +30,7 @@
 #include <formula/IFunctionDescription.hxx>
 #include <formula/opcode.hxx>
 #include <formula/types.hxx>
+#include <formula/paramclass.hxx>
 #include <osl/interlck.h>
 #include <rtl/ustring.hxx>
 #include <sal/types.h>
@@ -156,6 +157,8 @@ public:
     oslInterlockedCount GetRef() const       { return mnRefCnt; }
     OpCode              GetOpCode() const    { return eOp; }
 
+    bool                IsInForceArray() const;
+
     /**
         Dummy methods to avoid switches and casts where possible,
         the real token classes have to override the appropriate method[s].
@@ -165,16 +168,16 @@ public:
           which of course is 0 on non-functions. FormulaByteToken and ScExternal do
           override it.
 
-        - IsInForceArray() since also this is only used for operators and
-          functions and is false for other tokens.
+        - GetInForceArray() since also this is only used for operators and
+          functions and is ParamClass::Unknown for other tokens.
 
         Any other non-overridden method pops up an assertion.
      */
 
     virtual sal_uInt8           GetByte() const;
     virtual void                SetByte( sal_uInt8 n );
-    virtual bool                IsInForceArray() const;
-    virtual void                SetInForceArray( bool b );
+    virtual ParamClass          GetInForceArray() const;
+    virtual void                SetInForceArray( ParamClass c );
     virtual double              GetDouble() const;
     virtual double&             GetDoubleAsReference();
     virtual short               GetDoubleType() const;
@@ -236,30 +239,30 @@ class FORMULA_DLLPUBLIC FormulaByteToken : public FormulaToken
 {
 private:
             sal_uInt8           nByte;
-            bool                bIsInForceArray;
+            ParamClass          eInForceArray;
 protected:
-                                FormulaByteToken( OpCode e, sal_uInt8 n, StackVar v, bool b ) :
+                                FormulaByteToken( OpCode e, sal_uInt8 n, StackVar v, ParamClass c ) :
                                     FormulaToken( v,e ), nByte( n ),
-                                    bIsInForceArray( b ) {}
+                                    eInForceArray( c ) {}
 public:
-                                FormulaByteToken( OpCode e, sal_uInt8 n, bool b ) :
+                                FormulaByteToken( OpCode e, sal_uInt8 n, ParamClass c ) :
                                     FormulaToken( svByte,e ), nByte( n ),
-                                    bIsInForceArray( b ) {}
+                                    eInForceArray( c ) {}
                                 FormulaByteToken( OpCode e, sal_uInt8 n ) :
                                     FormulaToken( svByte,e ), nByte( n ),
-                                    bIsInForceArray( false ) {}
+                                    eInForceArray( ParamClass::Unknown ) {}
                                 FormulaByteToken( OpCode e ) :
                                     FormulaToken( svByte,e ), nByte( 0 ),
-                                    bIsInForceArray( false ) {}
+                                    eInForceArray( ParamClass::Unknown ) {}
                                 FormulaByteToken( const FormulaByteToken& r ) :
                                     FormulaToken( r ), nByte( r.nByte ),
-                                    bIsInForceArray( r.bIsInForceArray ) {}
+                                    eInForceArray( r.eInForceArray ) {}
 
     virtual FormulaToken*       Clone() const override { return new FormulaByteToken(*this); }
     virtual sal_uInt8           GetByte() const override;
     virtual void                SetByte( sal_uInt8 n ) override;
-    virtual bool                IsInForceArray() const override;
-    virtual void                SetInForceArray( bool b ) override;
+    virtual ParamClass          GetInForceArray() const override;
+    virtual void                SetInForceArray( ParamClass c ) override;
     virtual bool                operator==( const FormulaToken& rToken ) const override;
 
     DECL_FIXEDMEMPOOL_NEWDEL_DLL( FormulaByteToken )
@@ -274,7 +277,7 @@ private:
             FormulaTokenRef     pOrigToken;
 public:
                                 FormulaFAPToken( OpCode e, sal_uInt8 n, FormulaToken* p ) :
-                                    FormulaByteToken( e, n, svFAP, false ),
+                                    FormulaByteToken( e, n, svFAP, ParamClass::Unknown ),
                                     pOrigToken( p ) {}
                                 FormulaFAPToken( const FormulaFAPToken& r ) :
                                     FormulaByteToken( r ), pOrigToken( r.pOrigToken ) {}
@@ -418,18 +421,18 @@ class FORMULA_DLLPUBLIC FormulaJumpToken : public FormulaToken
 private:
             std::unique_ptr<short[]>
                                 pJump;
-            bool                bIsInForceArray;
+            ParamClass          eInForceArray;
 public:
                                 FormulaJumpToken( OpCode e, short* p ) :
                                     FormulaToken( formula::svJump , e),
-                                    bIsInForceArray( false)
+                                    eInForceArray( ParamClass::Unknown)
                                 {
                                     pJump.reset( new short[ p[0] + 1 ] );
                                     memcpy( pJump.get(), p, (p[0] + 1) * sizeof(short) );
                                 }
                                 FormulaJumpToken( const FormulaJumpToken& r ) :
                                     FormulaToken( r ),
-                                    bIsInForceArray( r.bIsInForceArray)
+                                    eInForceArray( r.eInForceArray)
                                 {
                                     pJump.reset( new short[ r.pJump[0] + 1 ] );
                                     memcpy( pJump.get(), r.pJump.get(), (r.pJump[0] + 1) * sizeof(short) );
@@ -438,8 +441,8 @@ public:
     virtual short*              GetJump() const override;
     virtual bool                operator==( const formula::FormulaToken& rToken ) const override;
     virtual FormulaToken*       Clone() const override { return new FormulaJumpToken(*this); }
-    virtual bool                IsInForceArray() const override;
-    virtual void                SetInForceArray( bool b ) override;
+    virtual ParamClass          GetInForceArray() const override;
+    virtual void                SetInForceArray( ParamClass c ) override;
 };
 
 
diff --git a/sc/inc/compiler.hxx b/sc/inc/compiler.hxx
index 30a064da457a..7f3f30e798aa 100644
--- a/sc/inc/compiler.hxx
+++ b/sc/inc/compiler.hxx
@@ -104,8 +104,8 @@ public:
     union {
         double       nValue;
         struct {
-            sal_uInt8   cByte;
-            bool        bIsInForceArray;
+            sal_uInt8           cByte;
+            formula::ParamClass eInForceArray;
         } sbyte;
         ScComplexRefData aRef;
         struct {
diff --git a/sc/source/core/tool/token.cxx b/sc/source/core/tool/token.cxx
index e511d98de1aa..99cf86f266ba 100644
--- a/sc/source/core/tool/token.cxx
+++ b/sc/source/core/tool/token.cxx
@@ -259,7 +259,7 @@ void ScRawToken::SetOpCode( OpCode e )
         default:
             eType = svByte;
             sbyte.cByte = 0;
-            sbyte.bIsInForceArray = false;
+            sbyte.eInForceArray = ParamClass::Unknown;
     }
 }
 
@@ -388,7 +388,7 @@ FormulaToken* ScRawToken::CreateToken() const
     switch ( GetType() )
     {
         case svByte :
-            return new FormulaByteToken( eOp, sbyte.cByte, sbyte.bIsInForceArray );
+            return new FormulaByteToken( eOp, sbyte.cByte, sbyte.eInForceArray );
         case svDouble :
             IF_NOT_OPCODE_ERROR( ocPush, FormulaDoubleToken);
             return new FormulaDoubleToken( nValue );