/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

#include "FloatingPointParser.h"
#include <decaf/lang/Math.h>
#include <decaf/lang/Integer.h>
#include <decaf/lang/Long.h>
#include <decaf/lang/Float.h>
#include <decaf/lang/Double.h>
#include <decaf/lang/Character.h>
#include <decaf/internal/util/HexStringParser.h>
#include <decaf/internal/util/BigInt.h>
#include <decaf/internal/util/BitOps.h>
#include <decaf/lang/exceptions/NumberFormatException.h>
#include <apr_lib.h>
#include <errno.h>

using namespace std;
using namespace decaf;
using namespace decaf::lang;
using namespace decaf::internal;
using namespace decaf::internal::util;

////////////////////////////////////////////////////////////////////////////////
const int FloatingPointParser::tens[11] = {
  0x3f800000,
  0x41200000,
  0x42c80000,
  0x447a0000,
  0x461c4000,
  0x47c35000,
  0x49742400,
  0x4b189680,
  0x4cbebc20,
  0x4e6e6b28,
  0x501502f9                    /* 10 ^ 10 in float */
};

////////////////////////////////////////////////////////////////////////////////
double FloatingPointParser::parseDblImpl( const std::string& value, int exp )
    throw ( exceptions::NumberFormatException ) {

    // assumes s is a null terminated string with at least one
    // character in it
    unsigned long long def[17] = {0};
    unsigned long long defBackup[17] = {0};
    unsigned long long* f = def;
    unsigned long long* fNoOverflow = defBackup;
    unsigned long long* tempBackup = NULL;
    unsigned int overflow = 0;
    unsigned long long result = 0;
    int index = 1;
    int unprocessedDigits = 0;
    std::string::const_iterator valItr = value.begin();

    do {

        if( Character::isDigit( *valItr ) ) {

            // Make a back up of f before appending, so that we can
            // back out of it if there is no more room, i.e. index >
            // MAX_ACCURACY_WIDTH.

            memcpy( fNoOverflow, f, sizeof(unsigned long long) * index );
            overflow = BigInt::simpleAppendDecimalDigitHighPrecision(
                    f, index, *valItr - '0' );

            if( overflow ) {
                f[index++] = overflow;
                /* There is an overflow, but there is no more room
                 * to store the result. We really only need the top 52
                 * bits anyway, so we must back out of the overflow,
                 * and ignore the rest of the string.
                 */
                if( index >= MAX_ACCURACY_WIDTH ) {
                    index--;
                    memcpy( f, fNoOverflow, sizeof(unsigned long long) * index);
                    break;
                }

                if( tempBackup ) {
                    fNoOverflow = tempBackup;
                }
            }
        } else {
            // Bad chars in the string
            BitOps::LOW_I32_FROM_LONG64( result ) = -1;
            BitOps::HIGH_I32_FROM_LONG64( result ) = -1;
            return Double::longBitsToDouble( result );
        }

    } while( ++valItr != value.end() );

    // We've broken out of the parse loop either because we've reached
    // the end of the string or we've overflowed the maximum accuracy
    // limit of a double. If we still have unprocessed digits in the
    // given string, then there are three possible results:
    //   1. (unprocessed digits + e) == 0, in which case we simply
    //      convert the existing bits that are already parsed
    //   2. (unprocessed digits + e) < 0, in which case we simply
    //      convert the existing bits that are already parsed along
    //      with the given e
    //   3. (unprocessed digits + e) > 0 indicates that the value is
    //      simply too big to be stored as a double, so return Infinity
    if( ( unprocessedDigits = value.length() ) > 0 ) {

        exp += unprocessedDigits;
        if( exp == 0 ) {
            return BigInt::toDoubleHighPrecision( f, index );
        } else if( exp < 0 ) {
            return BitOps::CREATE_DOUBLE_BITS( f, index, exp );
        } else {
            result = BitOps::INFINITE_LONGBITS;
        }

    } else {

        if( exp == 0 ) {
            return BigInt::toDoubleHighPrecision( f, index );
        } else {
            return BitOps::CREATE_DOUBLE_BITS( f, index, exp );
        }
    }

    return Double::longBitsToDouble( result );
}

////////////////////////////////////////////////////////////////////////////////
float FloatingPointParser::parseFltImpl( const std::string& value, int exp )
    throw ( exceptions::NumberFormatException ) {

    float result = FloatingPointParser::createFloat( value, exp );

std::cout << std::endl
          << "DEBUG - FloatingPointParser::parseFltImpl - "
          << "createFloat returned = " << result << std::endl;

    if( Float::floatToIntBits( result ) >= 0 ) {
        return result;
    } else if( Float::floatToIntBits( result ) == -1 ) {
      throw exceptions::NumberFormatException(
          __FILE__, __LINE__,
          "FloatingPointParser::parseFltImpl - Not a valid float string",
          value.c_str() );
    }

    return result;
}

////////////////////////////////////////////////////////////////////////////////
FloatingPointParser::StringExponentPair FloatingPointParser::initialParse(
    const std::string& value, int length ) throw ( exceptions::NumberFormatException ){

    std::string newValue = value;
    bool negative = false;
    char c;
    int start = 0;
    int end = 0;
    int decimal = 0;
    int e = 0;

    if( length == 0 ) {
        throw exceptions::NumberFormatException(
            __FILE__, __LINE__,
            "FloatingPointParser::initialParse - Invalid zero length string");
    }

    c = newValue[length - 1];
    if( c == 'D' || c == 'd' || c == 'F' || c == 'f') {
        length--;
        if( length == 0 ) {
            throw exceptions::NumberFormatException(
                __FILE__, __LINE__,
                "FloatingPointParser::initialParse - Invalid zero length string");
        }
    }

    end = Math::max( (int)newValue.find_first_of( 'E' ),
                     (int)newValue.find_first_of( 'e' ) );

    if( (std::size_t)end != string::npos ) {

        if( end + 1 == length ) {
            if( length == 0 ) {
                throw exceptions::NumberFormatException(
                    __FILE__, __LINE__,
                    "FloatingPointParser::initialParse - Invalid no data after e",
                    newValue.c_str() );
            }
        }

        int exponent_offset = end + 1;

        if( newValue[exponent_offset] == '+' ) {
            if( newValue[exponent_offset + 1] == '-' ) {
                if( length == 0 ) {
                    throw exceptions::NumberFormatException(
                        __FILE__, __LINE__,
                        "FloatingPointParser::initialParse - "
                        "Invalid length string");
                }
            }
            exponent_offset++; // skip the plus sign
        }

        try {
            e = Integer::parseInt( newValue.substr( exponent_offset, length ) );
        } catch( exceptions::NumberFormatException ex ) {
            // ex contains the exponent substring only so throw a
            // new exception with the correct string
            throw exceptions::NumberFormatException(
                __FILE__, __LINE__,
                "FloatingPointParser::initialParse - "
                "exponent string is not valid" );
        }

    } else {
        end = length;
    }

    if( length == 0 ) {
        throw exceptions::NumberFormatException(
            __FILE__, __LINE__,
            "FloatingPointParser::initialParse - "
            "invalid length string", newValue.c_str() );
    }

    c = newValue[start];

    if( c == '-') {
        ++start;
        --length;
        negative = true;
    } else if( c == '+' ) {
        ++start;
        --length;
    }

    if( length == 0 ) {
        throw exceptions::NumberFormatException(
            __FILE__, __LINE__,
            "FloatingPointParser::initialParse - "
            "invalid length string", newValue.c_str() );
    }

    decimal = newValue.find_first_of( '.' );
    if( decimal > -1 ) {
        e -= end - decimal - 1;
        newValue = newValue.substr( start, decimal ) + newValue.substr( decimal + 1, end );
    } else {
        newValue = newValue.substr( start, end );
    }

    if( ( length = newValue.length() ) == 0 ) {
        throw exceptions::NumberFormatException(
            __FILE__, __LINE__,
            "FloatingPointParser::initialParse - "
            "invalid length string", newValue.c_str() );
    }

    end = length;
    while( end > 1 && newValue[end - 1] == '0' ) {
        --end;
    }

    start = 0;
    while( start < end - 1 && newValue[start] == '0' ) {
        start++;
    }

    if( end != length || start != 0 ) {
        e += length - end;
        newValue = newValue.substr( start, end );
    }

    return StringExponentPair( newValue, e, negative );
}

////////////////////////////////////////////////////////////////////////////////
double FloatingPointParser::parseDblName(
    const std::string& namedDouble, int length )
        throw( exceptions::NumberFormatException ) {

    // Valid strings are only +Nan, NaN, -Nan, +Infinity, Infinity,
    // -Infinity.
    if( (length != 3) && ( length != 4) && ( length != 8) && ( length != 9 ) ) {
        throw exceptions::NumberFormatException(
            __FILE__, __LINE__,
            "FloatingPointParser::parseDblName - "
            "invalid name string", namedDouble.c_str() );
    }

    bool negative = namedDouble.at(0) == '-' ? true : false;

    if( namedDouble.find( "Infinity" ) != string::npos ) {
        return negative ? Double::NEGATIVE_INFINITY : Float::POSITIVE_INFINITY;
    }

    if( namedDouble.find( "NaN" ) != string::npos ) {
        return Double::NaN;
    }

    throw exceptions::NumberFormatException(
        __FILE__, __LINE__,
        "FloatingPointParser::parseDblName - "
        "invalid name string", namedDouble.c_str() );
}

////////////////////////////////////////////////////////////////////////////////
float FloatingPointParser::parseFltName(
    const std::string& namedFloat, int length )
        throw( exceptions::NumberFormatException ) {

    // Valid strings are only +Nan, NaN, -Nan, +Infinity, Infinity,
    // -Infinity.
    if( ( length != 3 ) && ( length != 4 ) && ( length != 8 ) && ( length != 9 ) ) {
        throw exceptions::NumberFormatException(
            __FILE__, __LINE__,
            "FloatingPointParser::parseFltName - "
            "invalid name string", namedFloat.c_str() );
    }

    bool negative = namedFloat.at(0) == '-' ? true : false;

    if( namedFloat.find( "Infinitiy" ) != string::npos ) {
        return negative ? Float::NEGATIVE_INFINITY : Float::POSITIVE_INFINITY;
    }

    if( namedFloat.find( "NaN" ) != string::npos ) {
        return Float::NaN;
    }

    throw exceptions::NumberFormatException(
        __FILE__, __LINE__,
        "FloatingPointParser::parseFltName - "
        "invalid name string", namedFloat.c_str() );
}

////////////////////////////////////////////////////////////////////////////////
double FloatingPointParser::parseDouble( const std::string& value )
    throw( exceptions::NumberFormatException ) {

    std::string newValue = value;
    FloatingPointParser::trim( newValue );
    int length = newValue.length();

    if( length == 0 ) {
        throw exceptions::NumberFormatException(
            __FILE__, __LINE__,
            "FloatingPointParser::parseDouble - "
            "invalid length string", value.c_str() );
    }

    // See if this could be a named double
    char last = newValue[length - 1];

    if( (last == 'y') || (last == 'N') ) {
        return parseDblName( newValue, length );
    }

    // See if it could be a hexadecimal representation
    if( toLowerCase( newValue ).find( "0x" ) != string::npos ) {
        return HexStringParser::parseDouble(value);
    }

    StringExponentPair info = initialParse(value, length);

    double result = parseDblImpl( info.value, info.exp );

    if( info.negative ) {
        result = -result;
    }

    return result;
}

////////////////////////////////////////////////////////////////////////////////
float FloatingPointParser::parseFloat( const std::string& value )
    throw( exceptions::NumberFormatException ) {

    std::string newValue = value;
    FloatingPointParser::trim( newValue );

    int length = newValue.length();

    if( length == 0 ) {
        throw exceptions::NumberFormatException(
            __FILE__, __LINE__,
            "FloatingPointParser::parseFloat - "
            "invalid length string", value.c_str() );
    }

    // See if this could be a named float
    char last = newValue[length - 1];
    if( (last == 'y') || (last == 'N') ) {
        return parseFltName( value, length );
    }

    // See if it could be a hexadecimal representation
    if( toLowerCase( newValue ).find( "0x" ) != string::npos ) {
        return HexStringParser::parseFloat( newValue );
    }

    StringExponentPair info = initialParse( newValue, length );

std::cout << std::endl
          << "DEBUG - FloatingPointParser::parseFloat - "
          << "newValue = " << newValue << ", length = " << length;

    float result = parseFltImpl( info.value, info.exp );
    if( info.negative ) {
        result = -result;
    }

    return result;
}

////////////////////////////////////////////////////////////////////////////////
std::string& FloatingPointParser::trim( std::string& value ) {

    // trim leading whitespace
    string::size_type notwhite = value.find_first_not_of( " \t\r\n" );
    value.erase( 0, notwhite );

    // trim trailing whitespace
    notwhite = value.find_last_not_of( " \t\r\n" );
    value.erase( notwhite+1 );

    return value;
}

////////////////////////////////////////////////////////////////////////////////
std::string& FloatingPointParser::toLowerCase( std::string& value ) {

    string::size_type index = 0;

    for( ; index < value.size(); ++index ) {
        if( Character::isLetter( value[index] ) ) {
            value[index] = apr_tolower( value[index] );
        }
    }

    return value;
}

////////////////////////////////////////////////////////////////////////////////
float FloatingPointParser::createFloat( const std::string&s, int exp ) {

    // assumes s is a null terminated string with at least one
    // character in it
    unsigned long long def[DEFAULT_WIDTH] = {0};
    unsigned long long defBackup[DEFAULT_WIDTH] = {0};
    unsigned long long* f = def;
    unsigned long long* fNoOverflow = defBackup;
    unsigned long long* tempBackup = NULL;
    unsigned int overflow = 0;
    unsigned int result = 0;
    int index = 1;
    int unprocessedDigits = 0;
    std::string::const_iterator sIter = s.begin();

    do {

        if( Character::isDigit( *sIter ) ) {

std::cout << std::endl
          << "DEBUG - FloatingPointParser::createFloat - "
          << "current digint ASCII = " << *sIter
          << ", value = " << *sIter - '0';

            // Make a back up of f before appending, so that we can
            // back out of it if there is no more room, i.e. index >
            // MAX_ACCURACY_WIDTH.
            memcpy( fNoOverflow, f, sizeof(unsigned long long) * index );
            overflow = BigInt::simpleAppendDecimalDigitHighPrecision(
                    f, index, *sIter - '0' );

std::cout << std::endl
          << "DEBUG - FloatingPointParser::createFloat - "
          << "f[index] = " << f[index]
          << ", overflow ? = " << overflow;

            if( overflow ) {

                f[index++] = overflow;

                // There is an overflow, but there is no more room
                // to store the result. We really only need the top 52
                // bits anyway, so we must back out of the overflow,
                // and ignore the rest of the string.
                if( index >= MAX_ACCURACY_WIDTH ) {
                    index--;
                    memcpy( f, fNoOverflow, sizeof(unsigned long long)* index );
                    break;
                }

                if( tempBackup ) {
                  fNoOverflow = tempBackup;
                }
            }
        } else {
            // String contained invalid characters
            return -1;
        }
    } while( ++sIter != s.end() );

    // We've broken out of the parse loop either because we've reached
    // the end of the string or we've overflowed the maximum accuracy
    // limit of a double. If we still have unprocessed digits in the
    // given string, then there are three possible results:
    //   1. (unprocessed digits + e) == 0, in which case we simply
    //      convert the existing bits that are already parsed
    //   2. (unprocessed digits + e) < 0, in which case we simply
    //      convert the existing bits that are already parsed along
    //      with the given e
    //   3. (unprocessed digits + e) > 0 indicates that the value is
    //      simply too big to be stored as a double, so return Infinity
    if( ( unprocessedDigits = std::distance( sIter, s.end() ) ) > 0 ) {

        exp += unprocessedDigits;

        if( exp <= 0 ) {
            return createFloat1( f, index, exp );
        } else {
            result = BitOps::INFINITE_INTBITS;
        }

    } else {
        return createFloat1( f, index, exp );
    }

    return Float::intBitsToFloat( result );
}

////////////////////////////////////////////////////////////////////////////////
float FloatingPointParser::createFloat1( unsigned long long* f, int length, int exp ) {

    int numBits = BigInt::highestSetBitHighPrecision( f, length ) + 1;
    double dresult = 0.0;
    int result = 0;

    numBits -= BigInt::lowestSetBitHighPrecision( f, length );

    if( numBits < 25 && exp >= 0 && exp < LOG5_OF_TWO_TO_THE_N ) {
        return Float::intBitsToFloat( BitOps::LOW_I32_FROM_LONG64_PTR( f ) ) *
               Float::intBitsToFloat( tenToTheE( exp ) );
    } else if( numBits < 25 && exp < 0 && (-exp) < LOG5_OF_TWO_TO_THE_N ) {
        return Float::intBitsToFloat( BitOps::LOW_I32_FROM_LONG64_PTR( f ) ) *
               Float::intBitsToFloat( tenToTheE( -exp ) );
    } else if (exp >= 0 && exp < 39) {
        result = Float::floatToIntBits(
            (float)( BigInt::toDoubleHighPrecision( f, length ) * Math::pow( 10.0, exp ) ) );
    } else if( exp >= 39 ) {
        // Convert the partial result to make sure that the
        // non-exponential part is not zero. This check fixes the case
        // where the user enters 0.0e309!
        dresult = BigInt::toDoubleHighPrecision( f, length );

        if( dresult == 0.0 ) {
            result = BitOps::MINIMUM_INTBITS;
        } else {
            result = BitOps::INFINITE_INTBITS;
        }

    } else if( exp > -309 ) {

        int dexp;
        unsigned int fmant, fovfl;
        unsigned long long dmant;
        dresult = BigInt::toDoubleHighPrecision( f, length ) / Math::pow( 10.0, -exp );

        if( BitOps::IS_DENORMAL_DBL( dresult ) ) {
            return 0.0f;
        }

        dexp = BigInt::doubleExponent( dresult ) + 51;
        dmant = BigInt::doubleMantissa( dresult );

        // Is it too small to be represented by a single-precision
        // float?
        if( dexp <= -155 ) {
            return 0.0f;
        }

        // Is it a denormalized single-precision float?
        if( (dexp <= -127) && (dexp > -155) ) {

            // Only interested in 24 msb bits of the 53-bit double mantissa
            fmant = (unsigned int) (dmant >> 29);
            fovfl = ((unsigned int) (dmant & 0x1FFFFFFF)) << 3;

            while( (dexp < -127) && ((fmant | fovfl) != 0) ) {
                if( (fmant & 1) != 0 ) {
                    fovfl |= 0x80000000;
                }
                fovfl >>= 1;
                fmant >>= 1;
                dexp++;
            }

            if( (fovfl & 0x80000000) != 0) {
                if( (fovfl & 0x7FFFFFFC) != 0 ) {
                    fmant++;
                } else if( (fmant & 1) != 0 ) {
                    fmant++;
                }
            } else if( (fovfl & 0x40000000) != 0 ) {

                if( (fovfl & 0x3FFFFFFC) != 0 ) {
                    fmant++;
                }
            }

            result = fmant;
        } else {
            result = Float::floatToIntBits( (float)dresult );
        }
    }

    // Don't go straight to zero as the fact that x*0 = 0 independent
    // of x might cause the algorithm to produce an incorrect result.
    // Instead try the min  value first and let it fall to zero if need be.
    if( exp <= -309 || result == 0 ) {
        result = BitOps::MINIMUM_INTBITS;
    }

    return floatAlgorithm( f, length, exp, Float::intBitsToFloat( result ) );
}

////////////////////////////////////////////////////////////////////////////////
float FloatingPointParser::floatAlgorithm(
    unsigned long long* f, int length, int exp, float z ) {

    unsigned long long m = 0;
    int k = 0;
    int comparison = 0;
    int comparison2 = 0;
    unsigned long long* x = NULL;
    unsigned long long* y = NULL;
    unsigned long long* D = NULL;
    unsigned long long* D2 = NULL;
    int xLength = 0;
    int yLength = 0;
    int DLength = 0;
    int D2Length = 0;
    int decApproxCount = 0;
    int incApproxCount = 0;
    int result = Float::floatToIntBits( z );

    do {

        m = BigInt::floatMantissa( z );
        k = BigInt::floatExponent( z );

        if( exp >= 0 && k >= 0 ) {

            xLength = sizeOfTenToTheE( exp ) + length;
            x = new unsigned long long[xLength];
            memset( x + length, 0, sizeof(unsigned long long) * (xLength - length) );
            memcpy( x, f, sizeof(unsigned long long) * length );
            BigInt::timesTenToTheEHighPrecision( x, xLength, exp );

            yLength = (k >> 6) + 2;
            y = new unsigned long long[yLength];
            memset( y + 1, 0, sizeof(unsigned long long) * (yLength - 1) );
            *y = m;
            BigInt::simpleShiftLeftHighPrecision (y, yLength, k);

        } else if( exp >= 0 ) {

            xLength = sizeOfTenToTheE (exp) + length + ((-k) >> 6) + 1;
            x = new unsigned long long[xLength];
            memset( x + length, 0, sizeof(unsigned long long) * (xLength - length) );
            memcpy( x, f, sizeof(unsigned long long) * length );
            BigInt::timesTenToTheEHighPrecision( x, xLength, exp );
            BigInt::simpleShiftLeftHighPrecision( x, xLength, -k );

            yLength = 1;
            y = new unsigned long long[yLength];
            *y = m;

        } else if( k >= 0 ) {

            xLength = length;
            x = f;

            yLength = sizeOfTenToTheE( -exp ) + 2 + ( k >> 6 );
            y = new unsigned long long[yLength];
            memset( y + 1, 0, sizeof(unsigned long long) * (yLength - 1)) ;
            *y = m;
            BigInt::timesTenToTheEHighPrecision( y, yLength, -exp );
            BigInt::simpleShiftLeftHighPrecision( y, yLength, k );

        } else {

            xLength = length + ((-k) >> 6) + 1;
            x = new unsigned long long[xLength];
            memset( x + length, 0, sizeof(unsigned long long) * (xLength - length) );
            memcpy( x, f, sizeof(unsigned long long) * length );
            BigInt::simpleShiftLeftHighPrecision( x, xLength, -k );

            yLength = sizeOfTenToTheE( -exp ) + 1;
            y = new unsigned long long[yLength];
            memset( y + 1, 0, sizeof(unsigned long long) * (yLength - 1) );
            *y = m;
            BigInt::timesTenToTheEHighPrecision( y, yLength, -exp );
        }

        comparison = BigInt::compareHighPrecision( x, xLength, y, yLength );
        if( comparison > 0 ) {
            // x > y
            DLength = xLength;
            D = new unsigned long long[DLength];
            memcpy( D, x, DLength * sizeof(unsigned long long) );
            BigInt::subtractHighPrecision( D, DLength, y, yLength );
        } else if( comparison ) {
            // y > x
            DLength = yLength;
            D = new unsigned long long[DLength];
            memcpy (D, y, DLength * sizeof (unsigned long long));
            BigInt::subtractHighPrecision( D, DLength, x, xLength );
        } else {
            /* y == x */
            DLength = 1;
            D = new unsigned long long[DLength];
            *D = 0;
        }

        D2Length = DLength + 1;
        D = new unsigned long long[DLength];
        m <<= 1;
        BigInt::multiplyHighPrecision( D, DLength, &m, 1, D2, D2Length );
        m >>= 1;

        comparison2 = BigInt::compareHighPrecision( D2, D2Length, y, yLength );
        if( comparison2 < 0 ) {
            if( comparison < 0 && m == BitOps::NORMAL_MASK ) {

                BigInt::simpleShiftLeftHighPrecision( D2, D2Length, 1 );
                if( BigInt::compareHighPrecision( D2, D2Length, y, yLength) > 0 ) {
                    --result;
                    decApproxCount++;
                    if( ( incApproxCount > 2 ) && ( decApproxCount > 2 ) ) {
                        if( decApproxCount > incApproxCount ) {
                            result += decApproxCount - incApproxCount;
                        } else if( incApproxCount > decApproxCount ) {
                            result -= incApproxCount - decApproxCount;
                        }
                        break;
                    }
                } else {
                    break;
                }
            } else {
                break;
            }
        } else if( comparison2 == 0 ) {

            if( (m & 1) == 0 ) {
                if( comparison < 0 && m == BitOps::NORMAL_MASK ) {
                    --result;
                    decApproxCount++;
                    if( ( incApproxCount > 2 ) && ( decApproxCount > 2 ) ) {
                        if( decApproxCount > incApproxCount ) {
                            result += decApproxCount - incApproxCount;
                        } else if( incApproxCount > decApproxCount ) {
                            result -= incApproxCount - decApproxCount;
                        }
                        break;
                    }
                } else {
                    break;
                }
            } else if( comparison < 0 ) {
                --result;
                decApproxCount++;
                if( ( incApproxCount > 2 ) && ( decApproxCount > 2 ) ) {
                    if( decApproxCount > incApproxCount ) {
                        result += decApproxCount - incApproxCount;
                    } else if( incApproxCount > decApproxCount ) {
                        result -= incApproxCount - decApproxCount;
                    }
                    break;
                }
                break;
            } else {
                ++result;
                incApproxCount++;
                if( ( incApproxCount > 2 ) && ( decApproxCount > 2 ) ) {
                    if( decApproxCount > incApproxCount ) {
                        result += decApproxCount - incApproxCount;
                    } else if( incApproxCount > decApproxCount ) {
                        result -= incApproxCount - decApproxCount;
                    }
                }
                break;
            }
        } else if( comparison < 0 ) {
            --result;
            decApproxCount++;
            if( ( incApproxCount > 2 ) && ( decApproxCount > 2 ) ) {
                if( decApproxCount > incApproxCount ) {
                    result += decApproxCount - incApproxCount;
                } else if( incApproxCount > decApproxCount ) {
                    result -= incApproxCount - decApproxCount;
                }
                break;
            }
        } else {
              if( (unsigned int)result == BitOps::FLOAT_EXPONENT_MASK ) {
                  break;
              }

              if( ( incApproxCount > 2 ) && ( decApproxCount > 2 ) ) {
                  if( decApproxCount > incApproxCount ) {
                      result += decApproxCount - incApproxCount;
                  } else if( incApproxCount > decApproxCount ) {
                      result -= incApproxCount - decApproxCount;
                  }
                  break;
              }
        }
    }
    while( true );

    delete x;
    delete y;
    delete D;
    delete D2;

    return Float::intBitsToFloat( result );
}