rename FormulaToken HasForceArray to IsInForceArray

... to name it was it does and to distinguish from
ScParameterClassification::HasForceArray(OpCode) which IS about a
function having ForceArray parameters.

Change-Id: I8af4e1d0353cdb5ad0a9b837ae0763dc77242734

7 files changed, 36 insertions, 36 deletions

diff --git a/formula/source/core/api/FormulaCompiler.cxx b/formula/source/core/api/FormulaCompiler.cxx
index 421e829e7e14..c4ca443ffef9 100644
--- a/formula/source/core/api/FormulaCompiler.cxx
+++ b/formula/source/core/api/FormulaCompiler.cxx
@@ -2262,15 +2262,15 @@ void FormulaCompiler::ForceArrayOperator( FormulaTokenRef& rCurr )
     if (!(rCurr->GetOpCode() != ocPush && (rCurr->GetType() == svByte || rCurr->GetType() == svJump)))
         return;
 
-    if (pCurrentFactorToken->HasForceArray())
+    if (pCurrentFactorToken->IsInForceArray())
     {
-        rCurr->SetForceArray( true);
+        rCurr->SetInForceArray( true);
         return;
     }
 
     if (nCurrentFactorParam && IsForceArrayParameter( pCurrentFactorToken.get(),
                 static_cast<sal_uInt8>(nCurrentFactorParam - 1)))
-        rCurr->SetForceArray( true);
+        rCurr->SetInForceArray( true);
 }
 
 void FormulaCompiler::CheckSetForceArrayParameter( FormulaTokenRef& rCurr, sal_uInt8 nParam )
diff --git a/formula/source/core/api/token.cxx b/formula/source/core/api/token.cxx
index e7da2bd7d6ff..27162715303b 100644
--- a/formula/source/core/api/token.cxx
+++ b/formula/source/core/api/token.cxx
@@ -174,15 +174,15 @@ void FormulaToken::SetByte( sal_uInt8 )
     SAL_WARN( "formula.core", "FormulaToken::SetByte: virtual dummy called" );
 }
 
-bool FormulaToken::HasForceArray() const
+bool FormulaToken::IsInForceArray() const
 {
     // ok to be called for any derived class
     return false;
 }
 
-void FormulaToken::SetForceArray( bool )
+void FormulaToken::SetInForceArray( bool )
 {
-    SAL_WARN( "formula.core", "FormulaToken::SetForceArray: virtual dummy called" );
+    SAL_WARN( "formula.core", "FormulaToken::SetInForceArray: virtual dummy called" );
 }
 
 double FormulaToken::GetDouble() const
@@ -333,12 +333,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::HasForceArray() const                 { return bHasForceArray; }
-void FormulaByteToken::SetForceArray( bool b )               { bHasForceArray = b; }
+bool FormulaByteToken::IsInForceArray() const                { return bIsInForceArray; }
+void FormulaByteToken::SetInForceArray( bool b )             { bIsInForceArray = b; }
 bool FormulaByteToken::operator==( const FormulaToken& r ) const
 {
     return FormulaToken::operator==( r ) && nByte == r.GetByte() &&
-        bHasForceArray == r.HasForceArray();
+        bIsInForceArray == r.IsInForceArray();
 }
 
 
@@ -350,13 +350,13 @@ bool FormulaFAPToken::operator==( const FormulaToken& r ) const
 
 
 short* FormulaJumpToken::GetJump() const                     { return pJump; }
-bool FormulaJumpToken::HasForceArray() const                 { return bHasForceArray; }
-void FormulaJumpToken::SetForceArray( bool b )               { bHasForceArray = b; }
+bool FormulaJumpToken::IsInForceArray() const                { return bIsInForceArray; }
+void FormulaJumpToken::SetInForceArray( bool b )             { bIsInForceArray = b; }
 bool FormulaJumpToken::operator==( const FormulaToken& r ) const
 {
     return FormulaToken::operator==( r ) && pJump[0] == r.GetJump()[0] &&
         memcmp( pJump+1, r.GetJump()+1, pJump[0] * sizeof(short) ) == 0 &&
-        bHasForceArray == r.HasForceArray();
+        bIsInForceArray == r.IsInForceArray();
 }
 FormulaJumpToken::~FormulaJumpToken()
 {
diff --git a/include/formula/token.hxx b/include/formula/token.hxx
index 23d978757771..2dd8f8c16c9a 100644
--- a/include/formula/token.hxx
+++ b/include/formula/token.hxx
@@ -138,16 +138,16 @@ public:
           which of course is 0 on non-functions. FormulaByteToken and ScExternal do
           override it.
 
-        - HasForceArray() since also this is only used for operators and
-          functions and is 0 for other tokens.
+        - IsInForceArray() since also this is only used for operators and
+          functions and is false 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                HasForceArray() const;
-    virtual void                SetForceArray( bool b );
+    virtual bool                IsInForceArray() const;
+    virtual void                SetInForceArray( bool b );
     virtual double              GetDouble() const;
     virtual double&             GetDoubleAsReference();
     virtual svl::SharedString GetString() const;
@@ -207,30 +207,30 @@ class FORMULA_DLLPUBLIC FormulaByteToken : public FormulaToken
 {
 private:
             sal_uInt8           nByte;
-            bool                bHasForceArray;
+            bool                bIsInForceArray;
 protected:
                                 FormulaByteToken( OpCode e, sal_uInt8 n, StackVar v, bool b ) :
                                     FormulaToken( v,e ), nByte( n ),
-                                    bHasForceArray( b ) {}
+                                    bIsInForceArray( b ) {}
 public:
                                 FormulaByteToken( OpCode e, sal_uInt8 n, bool b ) :
                                     FormulaToken( svByte,e ), nByte( n ),
-                                    bHasForceArray( b ) {}
+                                    bIsInForceArray( b ) {}
                                 FormulaByteToken( OpCode e, sal_uInt8 n ) :
                                     FormulaToken( svByte,e ), nByte( n ),
-                                    bHasForceArray( false ) {}
+                                    bIsInForceArray( false ) {}
                                 FormulaByteToken( OpCode e ) :
                                     FormulaToken( svByte,e ), nByte( 0 ),
-                                    bHasForceArray( false ) {}
+                                    bIsInForceArray( false ) {}
                                 FormulaByteToken( const FormulaByteToken& r ) :
                                     FormulaToken( r ), nByte( r.nByte ),
-                                    bHasForceArray( r.bHasForceArray ) {}
+                                    bIsInForceArray( r.bIsInForceArray ) {}
 
     virtual FormulaToken*       Clone() const override { return new FormulaByteToken(*this); }
     virtual sal_uInt8           GetByte() const override;
     virtual void                SetByte( sal_uInt8 n ) override;
-    virtual bool                HasForceArray() const override;
-    virtual void                SetForceArray( bool b ) override;
+    virtual bool                IsInForceArray() const override;
+    virtual void                SetInForceArray( bool b ) override;
     virtual bool                operator==( const FormulaToken& rToken ) const override;
 
     DECL_FIXEDMEMPOOL_NEWDEL_DLL( FormulaByteToken )
@@ -365,18 +365,18 @@ class FORMULA_DLLPUBLIC FormulaJumpToken : public FormulaToken
 {
 private:
             short*              pJump;
-            bool                bHasForceArray;
+            bool                bIsInForceArray;
 public:
                                 FormulaJumpToken( OpCode e, short* p ) :
                                     FormulaToken( formula::svJump , e),
-                                    bHasForceArray( false)
+                                    bIsInForceArray( false)
                                 {
                                     pJump = new short[ p[0] + 1 ];
                                     memcpy( pJump, p, (p[0] + 1) * sizeof(short) );
                                 }
                                 FormulaJumpToken( const FormulaJumpToken& r ) :
                                     FormulaToken( r ),
-                                    bHasForceArray( r.bHasForceArray)
+                                    bIsInForceArray( r.bIsInForceArray)
                                 {
                                     pJump = new short[ r.pJump[0] + 1 ];
                                     memcpy( pJump, r.pJump, (r.pJump[0] + 1) * sizeof(short) );
@@ -385,8 +385,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                HasForceArray() const override;
-    virtual void                SetForceArray( bool b ) override;
+    virtual bool                IsInForceArray() const override;
+    virtual void                SetInForceArray( bool b ) override;
 };
 
 
diff --git a/sc/inc/compiler.hxx b/sc/inc/compiler.hxx
index c563323157af..3c8a12e84375 100644
--- a/sc/inc/compiler.hxx
+++ b/sc/inc/compiler.hxx
@@ -104,7 +104,7 @@ public:
         double      nValue;
         struct {
             sal_uInt8        cByte;
-            bool        bHasForceArray;
+            bool        bIsInForceArray;
         } sbyte;
     };
                 DECL_FIXEDMEMPOOL_NEWDEL( ScDoubleRawToken );
@@ -121,7 +121,7 @@ public:
         double       nValue;
         struct {
             sal_uInt8        cByte;
-            bool        bHasForceArray;
+            bool        bIsInForceArray;
         } sbyte;
         ScComplexRefData aRef;
         struct {
diff --git a/sc/source/core/inc/interpre.hxx b/sc/source/core/inc/interpre.hxx
index c35248d57f8f..9bdb46135506 100644
--- a/sc/source/core/inc/interpre.hxx
+++ b/sc/source/core/inc/interpre.hxx
@@ -910,7 +910,7 @@ public:
 
 inline void ScInterpreter::MatrixDoubleRefToMatrix()
 {
-    if ( (bMatrixFormula || pCur->HasForceArray()) && GetStackType() == formula::svDoubleRef )
+    if ( (bMatrixFormula || pCur->IsInForceArray()) && GetStackType() == formula::svDoubleRef )
     {
         GetTokenMatrixMap();    // make sure it exists, create if not.
         PopDoubleRefPushMatrix();
@@ -919,7 +919,7 @@ inline void ScInterpreter::MatrixDoubleRefToMatrix()
 
 inline bool ScInterpreter::MatrixParameterConversion()
 {
-    if ( (bMatrixFormula || pCur->HasForceArray() || ScParameterClassification::HasForceArray( pCur->GetOpCode())) &&
+    if ( (bMatrixFormula || pCur->IsInForceArray() || ScParameterClassification::HasForceArray( pCur->GetOpCode())) &&
             !pJumpMatrix && sp > 0 )
         return ConvertMatrixParameters();
     return false;
diff --git a/sc/source/core/tool/interpr4.cxx b/sc/source/core/tool/interpr4.cxx
index a5f5982a854e..d84142290f8c 100644
--- a/sc/source/core/tool/interpr4.cxx
+++ b/sc/source/core/tool/interpr4.cxx
@@ -1400,7 +1400,7 @@ bool ScInterpreter::ConvertMatrixParameters()
                             // has ForceArray or ReferenceOrForceArray
                             // parameter *somewhere else*) pick a normal
                             // position dependent implicit intersection later.
-                            (eType != ScParameterClassification::Value || bMatrixFormula || pCur->HasForceArray()))
+                            (eType != ScParameterClassification::Value || bMatrixFormula || pCur->IsInForceArray()))
                     {
                         SCCOL nCol1, nCol2;
                         SCROW nRow1, nRow2;
diff --git a/sc/source/core/tool/token.cxx b/sc/source/core/tool/token.cxx
index ea66456679c8..7c43d37be37e 100644
--- a/sc/source/core/tool/token.cxx
+++ b/sc/source/core/tool/token.cxx
@@ -252,7 +252,7 @@ void ScRawToken::SetOpCode( OpCode e )
         default:
             eType = svByte;
             sbyte.cByte = 0;
-            sbyte.bHasForceArray = false;
+            sbyte.bIsInForceArray = false;
     }
 }
 
@@ -381,7 +381,7 @@ FormulaToken* ScRawToken::CreateToken() const
     switch ( GetType() )
     {
         case svByte :
-            return new FormulaByteToken( eOp, sbyte.cByte, sbyte.bHasForceArray );
+            return new FormulaByteToken( eOp, sbyte.cByte, sbyte.bIsInForceArray );
         case svDouble :
             IF_NOT_OPCODE_ERROR( ocPush, FormulaDoubleToken);
             return new FormulaDoubleToken( nValue );