loplugin:flatten in basic

Change-Id: Icb8e3cda312b50c9a9f12f96bec1c746f41c8979
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/92483
Tested-by: Jenkins
Reviewed-by: Noel Grandin <noel.grandin@collabora.co.uk>

1 files changed, 168 insertions, 168 deletions

diff --git a/basic/source/comp/exprnode.cxx b/basic/source/comp/exprnode.cxx
index 9e4c6ea2e6b3..8fb38b44eeb6 100644
--- a/basic/source/comp/exprnode.cxx
+++ b/basic/source/comp/exprnode.cxx
@@ -232,189 +232,189 @@ void SbiExprNode::FoldConstantsBinaryNode(SbiParser* pParser)
 {
     pLeft->FoldConstants(pParser);
     pRight->FoldConstants(pParser);
-    if( pLeft->IsConstant() && pRight->IsConstant()
-        && pLeft->eNodeType == pRight->eNodeType )
+    if( !(pLeft->IsConstant() && pRight->IsConstant()
+        && pLeft->eNodeType == pRight->eNodeType) )
+        return;
+
+    CollectBits();
+    if( eTok == CAT )
+        // CAT affiliate also two numbers!
+        eType = SbxSTRING;
+    if( pLeft->eType == SbxSTRING )
+        // No Type Mismatch!
+        eType = SbxSTRING;
+    if( eType == SbxSTRING )
     {
-        CollectBits();
-        if( eTok == CAT )
-            // CAT affiliate also two numbers!
-            eType = SbxSTRING;
-        if( pLeft->eType == SbxSTRING )
-            // No Type Mismatch!
+        OUString rl( pLeft->GetString() );
+        OUString rr( pRight->GetString() );
+        pLeft.reset();
+        pRight.reset();
+        if( eTok == PLUS || eTok == CAT )
+        {
+            eTok = CAT;
+            // Linking:
+            aStrVal = rl;
+            aStrVal += rr;
             eType = SbxSTRING;
-        if( eType == SbxSTRING )
+            eNodeType = SbxSTRVAL;
+        }
+        else
         {
-            OUString rl( pLeft->GetString() );
-            OUString rr( pRight->GetString() );
-            pLeft.reset();
-            pRight.reset();
-            if( eTok == PLUS || eTok == CAT )
+            eType = SbxDOUBLE;
+            eNodeType = SbxNUMVAL;
+            int eRes = rr.compareTo( rl );
+            switch( eTok )
             {
-                eTok = CAT;
-                // Linking:
-                aStrVal = rl;
-                aStrVal += rr;
-                eType = SbxSTRING;
-                eNodeType = SbxSTRVAL;
+            case EQ:
+                nVal = ( eRes == 0 ) ? SbxTRUE : SbxFALSE;
+                break;
+            case NE:
+                nVal = ( eRes != 0 ) ? SbxTRUE : SbxFALSE;
+                break;
+            case LT:
+                nVal = ( eRes < 0 ) ? SbxTRUE : SbxFALSE;
+                break;
+            case GT:
+                nVal = ( eRes > 0 ) ? SbxTRUE : SbxFALSE;
+                break;
+            case LE:
+                nVal = ( eRes <= 0 ) ? SbxTRUE : SbxFALSE;
+                break;
+            case GE:
+                nVal = ( eRes >= 0 ) ? SbxTRUE : SbxFALSE;
+                break;
+            default:
+                pParser->Error( ERRCODE_BASIC_CONVERSION );
+                bError = true;
+                break;
             }
-            else
+        }
+    }
+    else
+    {
+        double nl = pLeft->nVal;
+        double nr = pRight->nVal;
+        long ll = 0, lr = 0;
+        long llMod = 0, lrMod = 0;
+        if( ( eTok >= AND && eTok <= IMP )
+           || eTok == IDIV || eTok == MOD )
+        {
+            // Integer operations
+            bool bErr = false;
+            if( nl > SbxMAXLNG )
             {
-                eType = SbxDOUBLE;
-                eNodeType = SbxNUMVAL;
-                int eRes = rr.compareTo( rl );
-                switch( eTok )
-                {
-                case EQ:
-                    nVal = ( eRes == 0 ) ? SbxTRUE : SbxFALSE;
-                    break;
-                case NE:
-                    nVal = ( eRes != 0 ) ? SbxTRUE : SbxFALSE;
-                    break;
-                case LT:
-                    nVal = ( eRes < 0 ) ? SbxTRUE : SbxFALSE;
-                    break;
-                case GT:
-                    nVal = ( eRes > 0 ) ? SbxTRUE : SbxFALSE;
-                    break;
-                case LE:
-                    nVal = ( eRes <= 0 ) ? SbxTRUE : SbxFALSE;
-                    break;
-                case GE:
-                    nVal = ( eRes >= 0 ) ? SbxTRUE : SbxFALSE;
-                    break;
-                default:
-                    pParser->Error( ERRCODE_BASIC_CONVERSION );
-                    bError = true;
-                    break;
-                }
+                bErr = true;
+                nl = SbxMAXLNG;
+            }
+            else if( nl < SbxMINLNG )
+            {
+                bErr = true;
+                nl = SbxMINLNG;
+            }
+            if( nr > SbxMAXLNG )
+            {
+                bErr = true;
+                nr = SbxMAXLNG;
+            }
+            else if( nr < SbxMINLNG )
+            {
+                bErr = true;
+                nr = SbxMINLNG;
+            }
+            ll = static_cast<long>(nl); lr = static_cast<long>(nr);
+            llMod = static_cast<long>(nl);
+            lrMod = static_cast<long>(nr);
+            if( bErr )
+            {
+                pParser->Error( ERRCODE_BASIC_MATH_OVERFLOW );
+                bError = true;
             }
         }
-        else
+        bool bBothInt = ( pLeft->eType < SbxSINGLE
+                           && pRight->eType < SbxSINGLE );
+        pLeft.reset();
+        pRight.reset();
+        nVal = 0;
+        eType = SbxDOUBLE;
+        eNodeType = SbxNUMVAL;
+        bool bCheckType = false;
+        switch( eTok )
         {
-            double nl = pLeft->nVal;
-            double nr = pRight->nVal;
-            long ll = 0, lr = 0;
-            long llMod = 0, lrMod = 0;
-            if( ( eTok >= AND && eTok <= IMP )
-               || eTok == IDIV || eTok == MOD )
-            {
-                // Integer operations
-                bool bErr = false;
-                if( nl > SbxMAXLNG )
-                {
-                    bErr = true;
-                    nl = SbxMAXLNG;
-                }
-                else if( nl < SbxMINLNG )
+            case EXPON:
+                nVal = pow( nl, nr ); break;
+            case MUL:
+                bCheckType = true;
+                nVal = nl * nr; break;
+            case DIV:
+                if( !nr )
                 {
-                    bErr = true;
-                    nl = SbxMINLNG;
-                }
-                if( nr > SbxMAXLNG )
-                {
-                    bErr = true;
-                    nr = SbxMAXLNG;
-                }
-                else if( nr < SbxMINLNG )
+                    pParser->Error( ERRCODE_BASIC_ZERODIV ); nVal = HUGE_VAL;
+                    bError = true;
+                } else nVal = nl / nr;
+                break;
+            case PLUS:
+                bCheckType = true;
+                nVal = nl + nr; break;
+            case MINUS:
+                bCheckType = true;
+                nVal = nl - nr; break;
+            case EQ:
+                nVal = ( nl == nr ) ? SbxTRUE : SbxFALSE;
+                eType = SbxINTEGER; break;
+            case NE:
+                nVal = ( nl != nr ) ? SbxTRUE : SbxFALSE;
+                eType = SbxINTEGER; break;
+            case LT:
+                nVal = ( nl <  nr ) ? SbxTRUE : SbxFALSE;
+                eType = SbxINTEGER; break;
+            case GT:
+                nVal = ( nl >  nr ) ? SbxTRUE : SbxFALSE;
+                eType = SbxINTEGER; break;
+            case LE:
+                nVal = ( nl <= nr ) ? SbxTRUE : SbxFALSE;
+                eType = SbxINTEGER; break;
+            case GE:
+                nVal = ( nl >= nr ) ? SbxTRUE : SbxFALSE;
+                eType = SbxINTEGER; break;
+            case IDIV:
+                if( !lr )
                 {
-                    bErr = true;
-                    nr = SbxMINLNG;
-                }
-                ll = static_cast<long>(nl); lr = static_cast<long>(nr);
-                llMod = static_cast<long>(nl);
-                lrMod = static_cast<long>(nr);
-                if( bErr )
+                    pParser->Error( ERRCODE_BASIC_ZERODIV ); nVal = HUGE_VAL;
+                    bError = true;
+                } else nVal = ll / lr;
+                eType = SbxLONG; break;
+            case MOD:
+                if( !lr )
                 {
-                    pParser->Error( ERRCODE_BASIC_MATH_OVERFLOW );
+                    pParser->Error( ERRCODE_BASIC_ZERODIV ); nVal = HUGE_VAL;
                     bError = true;
-                }
-            }
-            bool bBothInt = ( pLeft->eType < SbxSINGLE
-                               && pRight->eType < SbxSINGLE );
-            pLeft.reset();
-            pRight.reset();
-            nVal = 0;
-            eType = SbxDOUBLE;
-            eNodeType = SbxNUMVAL;
-            bool bCheckType = false;
-            switch( eTok )
-            {
-                case EXPON:
-                    nVal = pow( nl, nr ); break;
-                case MUL:
-                    bCheckType = true;
-                    nVal = nl * nr; break;
-                case DIV:
-                    if( !nr )
-                    {
-                        pParser->Error( ERRCODE_BASIC_ZERODIV ); nVal = HUGE_VAL;
-                        bError = true;
-                    } else nVal = nl / nr;
-                    break;
-                case PLUS:
-                    bCheckType = true;
-                    nVal = nl + nr; break;
-                case MINUS:
-                    bCheckType = true;
-                    nVal = nl - nr; break;
-                case EQ:
-                    nVal = ( nl == nr ) ? SbxTRUE : SbxFALSE;
-                    eType = SbxINTEGER; break;
-                case NE:
-                    nVal = ( nl != nr ) ? SbxTRUE : SbxFALSE;
-                    eType = SbxINTEGER; break;
-                case LT:
-                    nVal = ( nl <  nr ) ? SbxTRUE : SbxFALSE;
-                    eType = SbxINTEGER; break;
-                case GT:
-                    nVal = ( nl >  nr ) ? SbxTRUE : SbxFALSE;
-                    eType = SbxINTEGER; break;
-                case LE:
-                    nVal = ( nl <= nr ) ? SbxTRUE : SbxFALSE;
-                    eType = SbxINTEGER; break;
-                case GE:
-                    nVal = ( nl >= nr ) ? SbxTRUE : SbxFALSE;
-                    eType = SbxINTEGER; break;
-                case IDIV:
-                    if( !lr )
-                    {
-                        pParser->Error( ERRCODE_BASIC_ZERODIV ); nVal = HUGE_VAL;
-                        bError = true;
-                    } else nVal = ll / lr;
-                    eType = SbxLONG; break;
-                case MOD:
-                    if( !lr )
-                    {
-                        pParser->Error( ERRCODE_BASIC_ZERODIV ); nVal = HUGE_VAL;
-                        bError = true;
-                    } else nVal = llMod - lrMod * (llMod/lrMod);
-                    eType = SbxLONG; break;
-                case AND:
-                    nVal = static_cast<double>( ll & lr ); eType = SbxLONG; break;
-                case OR:
-                    nVal = static_cast<double>( ll | lr ); eType = SbxLONG; break;
-                case XOR:
-                    nVal = static_cast<double>( ll ^ lr ); eType = SbxLONG; break;
-                case EQV:
-                    nVal = static_cast<double>( ~ll ^ lr ); eType = SbxLONG; break;
-                case IMP:
-                    nVal = static_cast<double>( ~ll | lr ); eType = SbxLONG; break;
-                default: break;
-            }
+                } else nVal = llMod - lrMod * (llMod/lrMod);
+                eType = SbxLONG; break;
+            case AND:
+                nVal = static_cast<double>( ll & lr ); eType = SbxLONG; break;
+            case OR:
+                nVal = static_cast<double>( ll | lr ); eType = SbxLONG; break;
+            case XOR:
+                nVal = static_cast<double>( ll ^ lr ); eType = SbxLONG; break;
+            case EQV:
+                nVal = static_cast<double>( ~ll ^ lr ); eType = SbxLONG; break;
+            case IMP:
+                nVal = static_cast<double>( ~ll | lr ); eType = SbxLONG; break;
+            default: break;
+        }
 
-            if( !std::isfinite( nVal ) )
-                pParser->Error( ERRCODE_BASIC_MATH_OVERFLOW );
+        if( !std::isfinite( nVal ) )
+            pParser->Error( ERRCODE_BASIC_MATH_OVERFLOW );
 
-            // Recover the data type to kill rounding error
-            if( bCheckType && bBothInt
-             && nVal >= SbxMINLNG && nVal <= SbxMAXLNG )
-            {
-                // Decimal place away
-                long n = static_cast<long>(nVal);
-                nVal = n;
-                eType = ( n >= SbxMININT && n <= SbxMAXINT )
-                      ? SbxINTEGER : SbxLONG;
-            }
+        // Recover the data type to kill rounding error
+        if( bCheckType && bBothInt
+         && nVal >= SbxMINLNG && nVal <= SbxMAXLNG )
+        {
+            // Decimal place away
+            long n = static_cast<long>(nVal);
+            nVal = n;
+            eType = ( n >= SbxMININT && n <= SbxMAXINT )
+                  ? SbxINTEGER : SbxLONG;
         }
     }