diff --git a/kmime/kmime_charfreq.cpp b/kmime/kmime_charfreq.cpp
index 926048ede..def2174b1 100644
--- a/kmime/kmime_charfreq.cpp
+++ b/kmime/kmime_charfreq.cpp
@@ -1,252 +1,252 @@
 /*
   kmime_charfreq.cpp
 
   KMime, the KDE internet mail/usenet news message library.
   Copyright (c) 2001-2002 Marc Mutz <mutz@kde.org>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 /**
   @file
   This file is part of the API for handling MIME data and
   defines the CharFreq class.
 
   @brief
   Defines the CharFreq class.
 
   @authors Marc Mutz \<mutz@kde.org\>
 */
 
 #include "kmime_charfreq.h"
 
 using namespace KMime;
 
 /**
  * Private class that helps to provide binary compatibility between releases.
  * @internal
  */
 //@cond PRIVATE
 //class KMime::CharFreq::Private
 //{
 //  public:
 //};
 //@endcond
 
 CharFreq::CharFreq( const QByteArray &buf )
   : mNUL( 0 ),
     mCTL( 0 ),
     mCR( 0 ), mLF( 0 ),
     mCRLF( 0 ),
     mPrintable( 0 ),
     mEightBit( 0 ),
     mTotal( 0 ),
     mLineMin( 0xffffffff ),
     mLineMax( 0 ),
     mTrailingWS( false ),
     mLeadingFrom( false )
 {
   if ( !buf.isEmpty() ) {
     count( buf.data(), buf.size() );
   }
 }
 
 CharFreq::CharFreq( const char *buf, size_t len )
   : mNUL( 0 ),
     mCTL( 0 ),
     mCR( 0 ), mLF( 0 ),
     mCRLF( 0 ),
     mPrintable( 0 ),
     mEightBit( 0 ),
     mTotal( 0 ),
     mLineMin( 0xffffffff ),
     mLineMax( 0 ),
     mTrailingWS( false ),
     mLeadingFrom( false )
 {
   if ( buf && len > 0 ) {
     count( buf, len );
   }
 }
 
 //@cond PRIVATE
 static inline bool isWS( char ch )
 {
   return ( ch == '\t' || ch == ' ' );
 }
 //@endcond
 
 void CharFreq::count( const char *it, size_t len )
 {
   const char *end = it + len;
   uint currentLineLength = 0;
   // initialize the prevChar with LF so that From_ detection works w/o
   // special-casing:
   char prevChar = '\n';
   char prevPrevChar = 0;
 
   for ( ; it != end ; ++it ) {
     ++currentLineLength;
     switch ( *it ) {
     case '\0': ++mNUL; break;
     case '\r': ++mCR;  break;
     case '\n': ++mLF;
       if ( prevChar == '\r' ) {
         --currentLineLength; ++mCRLF;
       }
       if ( currentLineLength >= mLineMax ) {
         mLineMax = currentLineLength-1;
       }
       if ( currentLineLength <= mLineMin ) {
         mLineMin = currentLineLength-1;
       }
       if ( !mTrailingWS ) {
         if ( isWS( prevChar ) ||
              ( prevChar == '\r' && isWS( prevPrevChar ) ) ) {
           mTrailingWS = true;
         }
       }
       currentLineLength = 0;
       break;
     case 'F': // check for lines starting with From_ if not found already:
       if ( !mLeadingFrom ) {
         if ( prevChar == '\n' && end - it >= 5 &&
              !qstrncmp( "From ", it, 5 ) ) {
           mLeadingFrom = true;
         }
       }
       ++mPrintable;
       break;
     default:
     {
       uchar c = *it;
-      if ( c == '\t' || c >= ' ' && c <= '~' ) {
+      if ( c == '\t' || ( c >= ' ' && c <= '~' ) ) {
         ++mPrintable;
       } else if ( c == 127 || c < ' ' ) {
         ++mCTL;
       } else {
         ++mEightBit;
       }
     }
     }
     prevPrevChar = prevChar;
     prevChar = *it;
   }
 
   // consider the length of the last line
   if ( currentLineLength >= mLineMax ) {
     mLineMax = currentLineLength;
   }
   if ( currentLineLength <= mLineMin ) {
     mLineMin = currentLineLength;
   }
 
   // check whether the last character is tab or space
   if ( isWS( prevChar ) ) {
     mTrailingWS = true;
   }
 
   mTotal = len;
 }
 
 bool CharFreq::isEightBitData() const
 {
   return type() == EightBitData;
 }
 
 bool CharFreq::isEightBitText() const
 {
   return type() == EightBitText;
 }
 
 bool CharFreq::isSevenBitData() const
 {
   return type() == SevenBitData;
 }
 
 bool CharFreq::isSevenBitText() const
 {
   return type() == SevenBitText;
 }
 
 bool CharFreq::hasTrailingWhitespace() const
 {
   return mTrailingWS;
 }
 
 bool CharFreq::hasLeadingFrom() const
 {
   return mLeadingFrom;
 }
 
 CharFreq::Type CharFreq::type() const
 {
 #if 0
   qDebug( "Total: %d; NUL: %d; CTL: %d;\n"
           "CR: %d; LF: %d; CRLF: %d;\n"
           "lineMin: %d; lineMax: %d;\n"
           "printable: %d; eightBit: %d;\n"
           "trailing whitespace: %s;\n"
           "leading 'From ': %s;\n",
           total, NUL, CTL, CR, LF, CRLF, lineMin, lineMax,
           printable, eightBit,
           mTrailingWS ? "yes" : "no" , mLeadingFrom ? "yes" : "no" );
 #endif
   if ( mNUL ) { // must be binary
     return Binary;
   }
 
   // doesn't contain NUL's:
   if ( mEightBit ) {
     if ( mLineMax > 988 ) {
       return EightBitData; // not allowed in 8bit
     }
     if ( mCR != mCRLF || controlCodesRatio() > 0.2 ) {
       return EightBitData;
     }
     return EightBitText;
   }
 
   // doesn't contain NUL's, nor 8bit chars:
   if ( mLineMax > 988 ) {
     return SevenBitData;
   }
   if ( mCR != mCRLF || controlCodesRatio() > 0.2 ) {
     return SevenBitData;
   }
 
   // no NUL, no 8bit chars, no excessive CTLs and no lines > 998 chars:
   return SevenBitText;
 }
 
 float CharFreq::printableRatio() const
 {
   if ( mTotal ) {
     return float(mPrintable) / float(mTotal);
   } else {
     return 0;
   }
 }
 
 float CharFreq::controlCodesRatio() const
 {
   if ( mTotal ) {
     return float(mCTL) / float(mTotal);
   } else {
     return 0;
   }
 }