sal_Bool -> bool and cosmetics

3 files changed, 108 insertions, 109 deletions

diff --git a/formula/inc/formula/FormulaCompiler.hxx b/formula/inc/formula/FormulaCompiler.hxx
index e053c57751df..825a31e9863b 100644
--- a/formula/inc/formula/FormulaCompiler.hxx
+++ b/formula/inc/formula/FormulaCompiler.hxx
@@ -65,7 +65,7 @@ struct FormulaArrayStack
 {
     FormulaArrayStack*  pNext;
     FormulaTokenArray*  pArr;
-    sal_Bool bTemp;
+    bool bTemp;
 };
 
 
@@ -221,26 +221,26 @@ public:
      */
     OpCode GetEnglishOpCode( const String& rName ) const;
 
-    void            SetCompileForFAP( sal_Bool bVal )
+    void            SetCompileForFAP( bool bVal )
                         { bCompileForFAP = bVal; bIgnoreErrors = bVal; }
 
     static bool IsOpCodeVolatile( OpCode eOp );
 
-    static sal_Bool DeQuote( String& rStr );
+    static bool DeQuote( String& rStr );
 
 
     static const String&    GetNativeSymbol( OpCode eOp );
-    static  sal_Bool            IsMatrixFunction(OpCode _eOpCode);   // if a function _always_ returns a Matrix
+    static  bool            IsMatrixFunction(OpCode _eOpCode);   // if a function _always_ returns a Matrix
 
     short GetNumFormatType() const { return nNumFmt; }
-    sal_Bool  CompileTokenArray();
+    bool  CompileTokenArray();
 
     void CreateStringFromTokenArray( String& rFormula );
     void CreateStringFromTokenArray( rtl::OUStringBuffer& rBuffer );
     FormulaToken* CreateStringFromToken( String& rFormula, FormulaToken* pToken,
-                                    sal_Bool bAllowArrAdvance = sal_False );
+                                    bool bAllowArrAdvance = false );
     FormulaToken* CreateStringFromToken( rtl::OUStringBuffer& rBuffer, FormulaToken* pToken,
-                                    sal_Bool bAllowArrAdvance = sal_False );
+                                    bool bAllowArrAdvance = false );
 
     void AppendBoolean( rtl::OUStringBuffer& rBuffer, bool bVal );
     void AppendDouble( rtl::OUStringBuffer& rBuffer, double fVal );
@@ -254,7 +254,7 @@ public:
     static void ResetNativeSymbols();
     static void SetNativeSymbols( const OpCodeMapPtr& xMap );
 protected:
-    virtual String FindAddInFunction( const String& rUpperName, sal_Bool bLocalFirst ) const;
+    virtual String FindAddInFunction( const String& rUpperName, bool bLocalFirst ) const;
     virtual void fillFromAddInCollectionUpperName( NonConstOpCodeMapPtr xMap ) const;
     virtual void fillFromAddInMap( NonConstOpCodeMapPtr xMap, FormulaGrammar::Grammar _eGrammar ) const;
     virtual void fillFromAddInCollectionEnglishName( NonConstOpCodeMapPtr xMap ) const;
@@ -262,10 +262,10 @@ protected:
 
     virtual void SetError(sal_uInt16 nError);
     virtual FormulaTokenRef ExtendRangeReference( FormulaToken & rTok1, FormulaToken & rTok2, bool bReuseDoubleRef );
-    virtual sal_Bool HandleExternalReference(const FormulaToken& _aToken);
-    virtual sal_Bool HandleRange();
-    virtual sal_Bool HandleSingleRef();
-    virtual sal_Bool HandleDbData();
+    virtual bool HandleExternalReference(const FormulaToken& _aToken);
+    virtual bool HandleRange();
+    virtual bool HandleSingleRef();
+    virtual bool HandleDbData();
 
     virtual void CreateStringFromExternal(rtl::OUStringBuffer& rBuffer, FormulaToken* pTokenP);
     virtual void CreateStringFromSingleRef(rtl::OUStringBuffer& rBuffer,FormulaToken* pTokenP);
@@ -273,12 +273,12 @@ protected:
     virtual void CreateStringFromMatrix(rtl::OUStringBuffer& rBuffer,FormulaToken* pTokenP);
     virtual void CreateStringFromIndex(rtl::OUStringBuffer& rBuffer,FormulaToken* pTokenP);
     virtual void LocalizeString( String& rName );   // modify rName - input: exact name
-    virtual sal_Bool IsImportingXML() const;
+    virtual bool IsImportingXML() const;
 
     sal_uInt16 GetErrorConstant( const String& rName );
     void AppendErrorConstant( rtl::OUStringBuffer& rBuffer, sal_uInt16 nError );
 
-    sal_Bool   GetToken();
+    bool   GetToken();
     OpCode NextToken();
     void PutCode( FormulaTokenRef& );
     void Factor();
@@ -295,17 +295,17 @@ protected:
     void NotLine();
     OpCode Expression();
     void PopTokenArray();
-    void PushTokenArray( FormulaTokenArray*, sal_Bool = sal_False );
+    void PushTokenArray( FormulaTokenArray*, bool = false );
 
     bool MergeRangeReference( FormulaToken * * const pCode1, FormulaToken * const * const pCode2 );
 
-    String              aCorrectedFormula;          // autocorrected Formula
-    String              aCorrectedSymbol;           // autocorrected Symbol
+    String              aCorrectedFormula;      // autocorrected Formula
+    String              aCorrectedSymbol;       // autocorrected Symbol
 
-    OpCodeMapPtr        mxSymbols;                  // which symbols are used
+    OpCodeMapPtr        mxSymbols;              // which symbols are used
 
-    FormulaTokenRef     pToken;                     // current token
-    FormulaTokenRef     pCurrentFactorToken;        // current factor token (of Factor() method)
+    FormulaTokenRef     pToken;                 // current token
+    FormulaTokenRef     pCurrentFactorToken;    // current factor token (of Factor() method)
     FormulaTokenArray*  pArr;
     ExternalReferenceHelper* pExternalRef;
 
@@ -313,20 +313,19 @@ protected:
     FormulaArrayStack*  pStack;
 
     OpCode              eLastOp;
-    short               nRecursion;                 // GetToken() recursions
-    short               nNumFmt;                    // set during CompileTokenArray()
-    sal_uInt16              pc;
-
-    FormulaGrammar::Grammar
-                        meGrammar;          // The grammar used, language plus convention.
-
-    sal_Bool                bAutoCorrect;               // whether to apply AutoCorrection
-    sal_Bool                bCorrected;                 // AutoCorrection was applied
-    sal_Bool                bCompileForFAP;             //! not real RPN but names, for FunctionAutoPilot,
-                                                    // will not be resolved
-    sal_Bool                bIgnoreErrors;              // on AutoCorrect and CompileForFAP
-                                                    // ignore errors and create RPN nevertheless
-    sal_Bool                glSubTotal;                 // if code contains one or more subtotal functions
+    short               nRecursion;             // GetToken() recursions
+    short               nNumFmt;                // set during CompileTokenArray()
+    sal_uInt16          pc;                     // program counter
+
+    FormulaGrammar::Grammar meGrammar;          // The grammar used, language plus convention.
+
+    bool                bAutoCorrect;           // whether to apply AutoCorrection
+    bool                bCorrected;             // AutoCorrection was applied
+    bool                bCompileForFAP;         //! not real RPN but names, for FunctionAutoPilot
+                                                // will not be resolved
+    bool                bIgnoreErrors;          // on AutoCorrect and CompileForFAP
+                                                // ignore errors and create RPN nevertheless
+    bool                glSubTotal;             // if code contains one or more subtotal functions
 private:
     void InitSymbolsNative() const;    /// only SymbolsNative, on first document creation
     void InitSymbolsEnglish() const;   /// only SymbolsEnglish, maybe later
diff --git a/formula/source/core/api/FormulaCompiler.cxx b/formula/source/core/api/FormulaCompiler.cxx
index c1b4e5f9ae3b..346c8e3bd235 100644
--- a/formula/source/core/api/FormulaCompiler.cxx
+++ b/formula/source/core/api/FormulaCompiler.cxx
@@ -299,7 +299,7 @@ uno::Sequence< sheet::FormulaToken > FormulaCompiler::OpCodeMap::createSequenceO
                 // interest.
             }
             if (!aIntName.getLength())
-                aIntName = _rCompiler.FindAddInFunction(*pName, !isEnglish());    // bLocalFirst=sal_False for english
+                aIntName = _rCompiler.FindAddInFunction(*pName, !isEnglish());    // bLocalFirst=false for english
             if (!aIntName.getLength())
                 pToken->OpCode = getOpCodeUnknown();
             else
@@ -514,10 +514,10 @@ FormulaCompiler::FormulaCompiler(FormulaTokenArray& _rArr)
         nRecursion(0),
         nNumFmt( NUMBERFORMAT_UNDEFINED ),
         meGrammar( formula::FormulaGrammar::GRAM_UNSPECIFIED ),
-        bAutoCorrect( sal_False ),
-        bCorrected( sal_False ),
-        bCompileForFAP( sal_False ),
-        bIgnoreErrors( sal_False )
+        bAutoCorrect( false ),
+        bCorrected( false ),
+        bCompileForFAP( false ),
+        bIgnoreErrors( false )
 
 {
     DBG_CTOR(FormulaCompiler,NULL);
@@ -530,10 +530,10 @@ FormulaCompiler::FormulaCompiler()
         nRecursion(0),
         nNumFmt( NUMBERFORMAT_UNDEFINED ),
         meGrammar( formula::FormulaGrammar::GRAM_UNSPECIFIED ),
-        bAutoCorrect( sal_False ),
-        bCorrected( sal_False ),
-        bCompileForFAP( sal_False ),
-        bIgnoreErrors( sal_False )
+        bAutoCorrect( false ),
+        bCorrected( false ),
+        bCompileForFAP( false ),
+        bIgnoreErrors( false )
 
 {
     DBG_CTOR(FormulaCompiler,NULL);
@@ -581,7 +581,7 @@ FormulaCompiler::OpCodeMapPtr FormulaCompiler::GetOpCodeMap( const sal_Int32 nLa
 }
 // -----------------------------------------------------------------------------
 
-String FormulaCompiler::FindAddInFunction( const String& /*rUpperName*/, sal_Bool /*bLocalFirst*/ ) const
+String FormulaCompiler::FindAddInFunction( const String& /*rUpperName*/, bool /*bLocalFirst*/ ) const
 {
     return String();
 }
@@ -755,7 +755,7 @@ bool FormulaCompiler::IsOpCodeVolatile( OpCode eOp )
 }
 
 // Remove quotes, escaped quotes are unescaped.
-sal_Bool FormulaCompiler::DeQuote( String& rStr )
+bool FormulaCompiler::DeQuote( String& rStr )
 {
     xub_StrLen nLen = rStr.Len();
     if ( nLen > 1 && rStr.GetChar(0) == '\'' && rStr.GetChar( nLen-1 ) == '\'' )
@@ -768,16 +768,16 @@ sal_Bool FormulaCompiler::DeQuote( String& rStr )
             rStr.Erase( nPos, 1 );
             ++nPos;
         }
-        return sal_True;
+        return true;
     }
-    return sal_False;
+    return false;
 }
 // -----------------------------------------------------------------------------
 void FormulaCompiler::fillAddInToken(::std::vector< sheet::FormulaOpCodeMapEntry >& /*_rVec*/,bool /*_bIsEnglish*/) const
 {
 }
 // -----------------------------------------------------------------------------
-sal_Bool FormulaCompiler::IsMatrixFunction(OpCode _eOpCode)
+bool FormulaCompiler::IsMatrixFunction(OpCode _eOpCode)
 {
     switch ( _eOpCode )
     {
@@ -791,13 +791,13 @@ sal_Bool FormulaCompiler::IsMatrixFunction(OpCode _eOpCode)
         case ocMatMult :
         case ocMatInv :
         case ocMatrixUnit :
-            return sal_True;
+            return true;
         default:
         {
             // added to avoid warnings
         }
     }
-    return sal_False;
+    return false;
 }
 
 // -----------------------------------------------------------------------------
@@ -903,7 +903,7 @@ sal_Int32 FormulaCompiler::OpCodeMap::getOpCodeUnknown()
     return kOpCodeUnknown;
 }
 // -----------------------------------------------------------------------------
-sal_Bool FormulaCompiler::GetToken()
+bool FormulaCompiler::GetToken()
 {
     static const short nRecursionMax = 42;
     FormulaCompilerRecursionGuard aRecursionGuard( nRecursion );
@@ -911,16 +911,16 @@ sal_Bool FormulaCompiler::GetToken()
     {
         SetError( errStackOverflow );
         pToken = new FormulaByteToken( ocStop );
-        return sal_False;
+        return false;
     }
     if ( bAutoCorrect && !pStack )
     {   // don't merge stacked subroutine code into entered formula
         aCorrectedFormula += aCorrectedSymbol;
         aCorrectedSymbol.Erase();
     }
-    sal_Bool bStop = sal_False;
+    bool bStop = false;
     if( pArr->GetCodeError() && !bIgnoreErrors )
-        bStop = sal_True;
+        bStop = true;
     else
     {
         short nWasColRowName;
@@ -948,7 +948,7 @@ sal_Bool FormulaCompiler::GetToken()
                 return GetToken();
             }
             else
-                bStop = sal_True;
+                bStop = true;
         }
         else
         {
@@ -962,10 +962,10 @@ sal_Bool FormulaCompiler::GetToken()
     if( bStop )
     {
         pToken = new FormulaByteToken( ocStop );
-        return sal_False;
+        return false;
     }
     if( pToken->GetOpCode() == ocSubTotal )
-        glSubTotal = sal_True;
+        glSubTotal = true;
     else if ( pToken->IsExternalRef() )
     {
         return HandleExternalReference(*pToken);
@@ -990,7 +990,7 @@ sal_Bool FormulaCompiler::GetToken()
     {
         pArr->nRefs++;
     }
-    return sal_True;
+    return true;
 }
 //---------------------------------------------------------------------------
 // RPN creation by recursion
@@ -1022,7 +1022,7 @@ void FormulaCompiler::Factor()
             if ( bAutoCorrect && !pStack )
             {   // assume multiplication
                 aCorrectedFormula += mxSymbols->getSymbol(ocMul);
-                bCorrected = sal_True;
+                bCorrected = true;
                 NextToken();
                 eOp = Expression();
                 if( eOp != ocClose )
@@ -1079,7 +1079,7 @@ void FormulaCompiler::Factor()
                     pArr->SetRecalcModeOnRefMove();
                 break;
                 case ocHyperLink :
-                pArr->SetHyperLink(sal_True);
+                pArr->SetHyperLink(true);
                 break;
                 default:
                     ;   // nothing
@@ -1245,7 +1245,7 @@ void FormulaCompiler::Factor()
             if ( bAutoCorrect && !pStack )
             {
                 aCorrectedSymbol.Erase();
-                bCorrected = sal_True;
+                bCorrected = true;
             }
         }
         else if ( pToken->IsExternalRef() )
@@ -1264,7 +1264,7 @@ void FormulaCompiler::Factor()
                     if ( nLen )
                         aCorrectedFormula.Erase( nLen - 1 );
                     aCorrectedSymbol.Erase();
-                    bCorrected = sal_True;
+                    bCorrected = true;
                 }
             }
         }
@@ -1484,10 +1484,10 @@ bool FormulaCompiler::MergeRangeReference(FormulaToken * * const pCode1, Formula
     return true;
 }
 // -----------------------------------------------------------------------------
-sal_Bool FormulaCompiler::CompileTokenArray()
+bool FormulaCompiler::CompileTokenArray()
 {
-    glSubTotal = sal_False;
-    bCorrected = sal_False;
+    glSubTotal = false;
+    bCorrected = false;
     if( !pArr->GetCodeError() || bIgnoreErrors )
     {
         if ( bAutoCorrect )
@@ -1500,7 +1500,7 @@ sal_Bool FormulaCompiler::CompileTokenArray()
         pStack = NULL;
         FormulaToken* pData[ MAXCODE ];
         pCode = pData;
-        sal_Bool bWasForced = pArr->IsRecalcModeForced();
+        bool bWasForced = pArr->IsRecalcModeForced();
         if ( bWasForced )
         {
             if ( bAutoCorrect )
@@ -1534,7 +1534,7 @@ sal_Bool FormulaCompiler::CompileTokenArray()
         if( pArr->GetCodeError() && !bIgnoreErrors )
         {
             pArr->DelRPN();
-            pArr->SetHyperLink(sal_False);
+            pArr->SetHyperLink(false);
         }
 
         if ( bWasForced )
@@ -1596,7 +1596,7 @@ void FormulaCompiler::CreateStringFromTokenArray( rtl::OUStringBuffer& rBuffer )
         rBuffer.append(sal_Unicode('='));
     FormulaToken* t = pArr->First();
     while( t )
-        t = CreateStringFromToken( rBuffer, t, sal_True );
+        t = CreateStringFromToken( rBuffer, t, true );
 
     if (pSaveArr != pArr)
     {
@@ -1605,7 +1605,7 @@ void FormulaCompiler::CreateStringFromTokenArray( rtl::OUStringBuffer& rBuffer )
     }
 }
 // -----------------------------------------------------------------------------
-FormulaToken* FormulaCompiler::CreateStringFromToken( String& rFormula, FormulaToken* pTokenP,sal_Bool bAllowArrAdvance )
+FormulaToken* FormulaCompiler::CreateStringFromToken( String& rFormula, FormulaToken* pTokenP,bool bAllowArrAdvance )
 {
     rtl::OUStringBuffer aBuffer;
     FormulaToken* p = CreateStringFromToken( aBuffer, pTokenP, bAllowArrAdvance );
@@ -1613,10 +1613,10 @@ FormulaToken* FormulaCompiler::CreateStringFromToken( String& rFormula, FormulaT
     return p;
 }
 
-FormulaToken* FormulaCompiler::CreateStringFromToken( rtl::OUStringBuffer& rBuffer, FormulaToken* pTokenP,sal_Bool bAllowArrAdvance )
+FormulaToken* FormulaCompiler::CreateStringFromToken( rtl::OUStringBuffer& rBuffer, FormulaToken* pTokenP,bool bAllowArrAdvance )
 {
-    sal_Bool bNext = sal_True;
-    sal_Bool bSpaces = sal_False;
+    bool bNext = true;
+    bool bSpaces = false;
     FormulaToken* t = pTokenP;
     OpCode eOp = t->GetOpCode();
     if( eOp >= ocAnd && eOp <= ocOr )
@@ -1626,7 +1626,7 @@ FormulaToken* FormulaCompiler::CreateStringFromToken( rtl::OUStringBuffer& rBuff
             t = pArr->Next();
         else
             t = pArr->PeekNext();
-        bNext = sal_False;
+        bNext = false;
         bSpaces = ( !t || t->GetOpCode() != ocOpen );
     }
     if( bSpaces )
@@ -1750,7 +1750,7 @@ void FormulaCompiler::AppendDouble( rtl::OUStringBuffer& rBuffer, double fVal )
     {
         ::rtl::math::doubleToUStringBuffer( rBuffer, fVal,
                 rtl_math_StringFormat_Automatic,
-                rtl_math_DecimalPlaces_Max, '.', sal_True );
+                rtl_math_DecimalPlaces_Max, '.', true );
     }
     else
     {
@@ -1759,7 +1759,7 @@ void FormulaCompiler::AppendDouble( rtl::OUStringBuffer& rBuffer, double fVal )
                 rtl_math_StringFormat_Automatic,
                 rtl_math_DecimalPlaces_Max,
                 aSysLocale.GetLocaleDataPtr()->getNumDecimalSep().GetChar(0),
-                sal_True );
+                true );
     }
 }
 // -----------------------------------------------------------------------------
@@ -1768,9 +1768,9 @@ void FormulaCompiler::AppendBoolean( rtl::OUStringBuffer& rBuffer, bool bVal )
     rBuffer.append( mxSymbols->getSymbol(static_cast<OpCode>(bVal ? ocTrue : ocFalse)) );
 }
 // -----------------------------------------------------------------------------
-sal_Bool FormulaCompiler::IsImportingXML() const
+bool FormulaCompiler::IsImportingXML() const
 {
-    return sal_False;
+    return false;
 }
 // -----------------------------------------------------------------------------
 void FormulaCompiler::AppendString( rtl::OUStringBuffer& rBuffer, const String & rStr )
@@ -1846,7 +1846,7 @@ OpCode FormulaCompiler::NextToken()
                 if ( eOp == eLastOp || eLastOp == ocOpen )
                 {   // throw away duplicated operator
                     aCorrectedSymbol.Erase();
-                    bCorrected = sal_True;
+                    bCorrected = true;
                 }
                 else
                 {
@@ -1863,7 +1863,7 @@ OpCode FormulaCompiler::NextToken()
                                     aCorrectedFormula.SetChar( nPos,
                                         mxSymbols->getSymbol(ocGreater).GetChar(0) );
                                     aCorrectedSymbol = c;
-                                    bCorrected = sal_True;
+                                    bCorrected = true;
                                 }
                             break;
                             case ocLess:
@@ -1872,14 +1872,14 @@ OpCode FormulaCompiler::NextToken()
                                     aCorrectedFormula.SetChar( nPos,
                                         mxSymbols->getSymbol(ocLess).GetChar(0) );
                                     aCorrectedSymbol = c;
-                                    bCorrected = sal_True;
+                                    bCorrected = true;
                                 }
                                 else if ( c == mxSymbols->getSymbol(ocGreater).GetChar(0) )
                                 {   // <> instead of ><
                                     aCorrectedFormula.SetChar( nPos,
                                         mxSymbols->getSymbol(ocLess).GetChar(0) );
                                     aCorrectedSymbol = c;
-                                    bCorrected = sal_True;
+                                    bCorrected = true;
                                 }
                             break;
                             case ocMul:
@@ -1888,7 +1888,7 @@ OpCode FormulaCompiler::NextToken()
                                     aCorrectedFormula.SetChar( nPos,
                                         mxSymbols->getSymbol(ocMul).GetChar(0) );
                                     aCorrectedSymbol = c;
-                                    bCorrected = sal_True;
+                                    bCorrected = true;
                                 }
                             break;
                             case ocDiv:
@@ -1897,7 +1897,7 @@ OpCode FormulaCompiler::NextToken()
                                     aCorrectedFormula.SetChar( nPos,
                                         mxSymbols->getSymbol(ocDiv).GetChar(0) );
                                     aCorrectedSymbol = c;
-                                    bCorrected = sal_True;
+                                    bCorrected = true;
                                 }
                             break;
                             default:
@@ -1934,24 +1934,24 @@ void FormulaCompiler::PutCode( FormulaTokenRef& p )
 }
 
 // -----------------------------------------------------------------------------
-sal_Bool FormulaCompiler::HandleExternalReference(const FormulaToken& /*_aToken*/)
+bool FormulaCompiler::HandleExternalReference(const FormulaToken& /*_aToken*/)
 {
-    return sal_True;
+    return true;
 }
 // -----------------------------------------------------------------------------
-sal_Bool FormulaCompiler::HandleRange()
+bool FormulaCompiler::HandleRange()
 {
-    return sal_True;
+    return true;
 }
 // -----------------------------------------------------------------------------
-sal_Bool FormulaCompiler::HandleSingleRef()
+bool FormulaCompiler::HandleSingleRef()
 {
-    return sal_True;
+    return true;
 }
 // -----------------------------------------------------------------------------
-sal_Bool FormulaCompiler::HandleDbData()
+bool FormulaCompiler::HandleDbData()
 {
-    return sal_True;
+    return true;
 }
 // -----------------------------------------------------------------------------
 void FormulaCompiler::CreateStringFromSingleRef(rtl::OUStringBuffer& /*rBuffer*/,FormulaToken* /*pTokenP*/)
@@ -1977,7 +1977,7 @@ void FormulaCompiler::CreateStringFromExternal(rtl::OUStringBuffer& /*rBuffer*/,
 void FormulaCompiler::LocalizeString( String& /*rName*/ )
 {
 }
-void FormulaCompiler::PushTokenArray( FormulaTokenArray* pa, sal_Bool bTemp )
+void FormulaCompiler::PushTokenArray( FormulaTokenArray* pa, bool bTemp )
 {
     if ( bAutoCorrect && !pStack )
         {   // don't merge stacked subroutine code into entered formula
diff --git a/formula/source/core/api/token.cxx b/formula/source/core/api/token.cxx
index 703c5d6bb6b2..8703fd8ba5fc 100644
--- a/formula/source/core/api/token.cxx
+++ b/formula/source/core/api/token.cxx
@@ -64,7 +64,7 @@ IMPL_FIXEDMEMPOOL_NEWDEL_DLL( FormulaStringToken, nMemPoolStringToken, nMemPoolS
 
 // --- helpers --------------------------------------------------------------
 
-inline sal_Bool lcl_IsReference( OpCode eOp, StackVar eType )
+inline bool lcl_IsReference( OpCode eOp, StackVar eType )
 {
     return
         (eOp == ocPush && (eType == svSingleRef || eType == svDoubleRef))
@@ -81,7 +81,7 @@ FormulaToken::~FormulaToken()
 
 bool FormulaToken::Is3DRef() const
 {
-    return sal_False;
+    return false;
 }
 
 bool FormulaToken::IsFunction() const
@@ -108,7 +108,7 @@ sal_uInt8 FormulaToken::GetParamCount() const
             eOp != ocIf && eOp != ocChose && eOp != ocPercentSign )
         return 0;       // parameters and specials
                         // ocIf and ocChose not for FAP, have cByte then
-//2do: sal_Bool parameter whether FAP or not?
+//2do: bool parameter whether FAP or not?
     else if ( GetByte() )
         return GetByte();   // all functions, also ocExternal and ocMacro
     else if (SC_OPCODE_START_BIN_OP <= eOp && eOp < SC_OPCODE_STOP_BIN_OP)
@@ -570,9 +570,9 @@ bool FormulaTokenArray::HasOpCode( OpCode eOp ) const
     for ( sal_uInt16 j=0; j < nLen; j++ )
     {
         if ( pCode[j]->GetOpCode() == eOp )
-            return sal_True;
+            return true;
     }
-    return sal_False;
+    return false;
 }
 
 bool FormulaTokenArray::HasOpCodeRPN( OpCode eOp ) const
@@ -580,9 +580,9 @@ bool FormulaTokenArray::HasOpCodeRPN( OpCode eOp ) const
     for ( sal_uInt16 j=0; j < nRPN; j++ )
     {
         if ( pRPN[j]->GetOpCode() == eOp )
-            return sal_True;
+            return true;
     }
-    return sal_False;
+    return false;
 }
 
 bool FormulaTokenArray::HasNameOrColRowName() const
@@ -590,9 +590,9 @@ bool FormulaTokenArray::HasNameOrColRowName() const
     for ( sal_uInt16 j=0; j < nLen; j++ )
     {
         if( pCode[j]->GetType() == svIndex || pCode[j]->GetOpCode() == ocColRowName )
-            return sal_True;
+            return true;
     }
-    return sal_False;
+    return false;
 }
 
 
@@ -600,7 +600,7 @@ FormulaTokenArray::FormulaTokenArray()
 {
     pCode = NULL; pRPN = NULL;
     nError = nLen = nIndex = nRPN = nRefs = 0;
-    bHyperLink = sal_False;
+    bHyperLink = false;
     ClearRecalcMode();
 }
 
@@ -714,7 +714,7 @@ void FormulaTokenArray::Clear()
     }
     pCode = NULL; pRPN = NULL;
     nError = nLen = nIndex = nRPN = nRefs = 0;
-    bHyperLink = sal_False;
+    bHyperLink = false;
     ClearRecalcMode();
 }
 
@@ -851,7 +851,7 @@ bool FormulaTokenArray::HasMatrixDoubleRefOps()
                         {
                             pResult->Delete();
                             delete [] pStack;
-                            return sal_True;
+                            return true;
                         }
                     }
                 }
@@ -883,7 +883,7 @@ bool FormulaTokenArray::HasMatrixDoubleRefOps()
         delete [] pStack;
     }
 
-    return sal_False;
+    return false;
 }
 
 
@@ -932,21 +932,21 @@ void FormulaMissingContext::AddMoreArgs( FormulaTokenArray *pNewArr, const Missi
             if (mnCurArg == 2)
             {
                 pNewArr->AddOpCode( ocSep );
-                pNewArr->AddDouble( 1.0 );      // 4th, Cumulative=sal_True()
+                pNewArr->AddDouble( 1.0 );      // 4th, Cumulative=true()
             }
             break;
         case ocPoissonDist:
             if (mnCurArg == 1)
             {
                 pNewArr->AddOpCode( ocSep );
-                pNewArr->AddDouble( 1.0 );      // 3rd, Cumulative=sal_True()
+                pNewArr->AddDouble( 1.0 );      // 3rd, Cumulative=true()
             }
             break;
         case ocNormDist:
             if ( mnCurArg == 2 )
             {
                 pNewArr->AddOpCode( ocSep );
-                pNewArr->AddDouble( 1.0 );      // 4th, Cumulative=sal_True()
+                pNewArr->AddDouble( 1.0 );      // 4th, Cumulative=true()
             }
             break;
         case ocLogNormDist:
@@ -1207,7 +1207,7 @@ FormulaToken* FormulaTokenArray::AddOpCode( OpCode eOp )
             }
             break;
         default:
-            pRet = new FormulaByteToken( eOp, 0, sal_False );
+            pRet = new FormulaByteToken( eOp, 0, false );
             break;
     }
     return AddToken( *pRet );