path: root/memory/org.eclipse.cdt.debug.ui.memory.floatingpoint/src/org/eclipse/cdt/debug/ui/memory/floatingpoint/FPutilities.java

/*******************************************************************************
 * Copyright (c) 2012 Wind River Systems, Inc. and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Randy Rohrbach (Wind River Systems, Inc.) - Copied and modified to create the floating point plugin
 *******************************************************************************/
package org.eclipse.cdt.debug.ui.memory.floatingpoint;

import java.math.BigInteger;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
import java.util.Arrays;
import java.util.regex.Pattern;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.jface.dialogs.ErrorDialog;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.progress.UIJob;

public class FPutilities
{
    private static final int BYTE_MASK = 0xFF;
    
    // ANSI C "Smallest" and "largest" negative and positive float and double values 
    
    public static final float floatNegMax = -3.40282347E+38f;   // Largest negative float value; farthest from zero
    public static final float floatNegMin = -1.17549435E-38f;   // Smallest negative float value; closest to zero
    public static final float floatPosMax =  1.17549435E+38f;   // Largest positive float value; farthest from zero
    public static final float floatPosMin =  3.40282347E-38f;   // Smallest positive float value; closest to zero

    public static final double doubleNegMax = -1.7976931348623157E+308; // Largest positive double value
    public static final double doubleNegMin = -2.2250738585072014E-308; // Smallest positive double value
    public static final double doublePosMax =  1.7976931348623157E+308; // Largest positive double value
    public static final double doublePosMin =  2.2250738585072014E-308; // Smallest positive double value

    public enum FPDataType
    {
        // Value (for persisteance), Bitsize of type, Number of internal precision decimal digits, Default displayed precision 
        
        FLOAT     ( 10, 32,  7,  8),    // C/C++ single-precision "float"
        DOUBLE    ( 20, 64, 15,  8),    // C/C++ double-precision "double"
        FLOAT_80  ( 30, 80, 19, 16),    // Extended precision 
        FLOAT_96  ( 40, 96,  0,  0),    // TODO: unknown internal decimal digit precision; C/C++ extended-precision "long double"
        
        // Future work
        
        FLOAT_128 (50, 128, 33, 16),    // TODO: known values, but not currently implmented
        FLOAT_256 (60, 256,  0,  0),    // TODO: unknown internal decimal digit precision
        FLOAT_512 (70, 512,  0,  0);    // TODO: unknown internal decimal digit precision
        
        // Member variables
        
        private int value;
        private int bitsize;
        private int decimalPrecision;
        private int displayedPrecision;
        
        // Constructor

        private FPDataType(int value, int bitSize, int precisionDigits, int defaultDisplayPrecision)
        {
            this.value = value;
            this.bitsize = bitSize;
            this.decimalPrecision = precisionDigits;
            this.displayedPrecision = defaultDisplayPrecision;
        }
        
        // Getters
        
        public int getValue() { return value; }
        public int getBitsize() { return bitsize; }
        public int getDecimalPrecision() { return decimalPrecision; }
        public int getDisplayedPrecision() { return displayedPrecision; }
        public int getInternalPrecision() { return decimalPrecision; }
        
        public int getByteLength()
        {
            return bitsize/Byte.SIZE;
        }
    }
    
    // Byte ordering
    
    public enum Endian
    {
        // Value
        
        LITTLE (10),
        BIG    (20);
        
        // Member variables
        
        private int value;
        
        // Constructor

        private Endian(int value)
        {
            this.value = value;
        }
        
        // Getters
        
        public int getValue() { return value; }
    }
    
    // Justification (latent support)
    
    public enum Justification
    {
        LEFT,
        RIGHT,
        CENTER;
    }
    
    // Convert raw float bits to a byte array

    public static byte[] rawFloatBitsToByteArray(int floatBits)
    {
        int byteCount = Integer.SIZE/Byte.SIZE;
        byte[] result = new byte[byteCount];
        
        for (int index = 0; index < byteCount; index++)
        {
            int offset = (result.length - 1 - index) * 8;
            result[index] = (byte) ((floatBits >>> offset) & BYTE_MASK);
        }
        
        return result;
    }
    
    // Convert raw double bits to a byte array
    
    public static byte[] rawDoubleBitsToByteArray(long doubleBits)
    {
        int byteCount = Long.SIZE/Byte.SIZE;
        byte[] result = new byte[byteCount];
        
        for (int index = 0; index < byteCount; index++)
        {
            int offset = (result.length - 1 - index) * 8;
            result[index] = (byte) ((doubleBits >>> offset) & BYTE_MASK);
        }
        
        return result;
    }

    // Return a byte array that is in reverse order of the passed-in array parameter
    
    public static byte[] reverseByteOrder(byte[] byteArray)
    {
        if (byteArray.length == 0) return new byte[0];
        
        byte tempByte = 0;
        byte[] reversedByteArray = new byte[byteArray.length];
        
        // Copy the array that is passed in to the array that will be returned
        
        System.arraycopy(byteArray, 0, reversedByteArray, 0, byteArray.length);
        
        // Reverse the bytes
        
        for(int start = 0, end = reversedByteArray.length - 1; start < end; ++start, --end)
        {
            tempByte = reversedByteArray[start];
            reversedByteArray[start] = reversedByteArray[end];
            reversedByteArray[end] = tempByte;
        }
        
        return reversedByteArray;
    }
    
    // Convert a representation of a float or double in a byte array to a scientific notation string (Should we use BigDecimal here???)
    
    public static String byteArrayToSciNotation(FPDataType dt, boolean isLittleEndian, FPMemoryByte[] memByteArray, int maxDisplayDigits) throws ArithmeticException
    {
        int displayedDigits = 8;
        
        // If the byte array is not a 32-bit float or 64-bit double, throw an exception.
        
        if (memByteArray.length != (FPDataType.FLOAT.getByteLength()) &&
            memByteArray.length != (FPDataType.DOUBLE.getByteLength()))
                throw new ArithmeticException("Conversion of the floating point number cannot be performed; invalid data type or byte array length."); //$NON-NLS-1$
        
        // Create and initialize a DecimalFormat object for scientific notation.  Specify a space
        // for the preceding plus-sign, which lines up the first significant digit, decimal point
        // and exponent character.  Define the symbol strings for "Not a Number" and "Infinity."  
        
        DecimalFormat df = new DecimalFormat("0.0E0"); //$NON-NLS-1$
        df.setPositivePrefix(" "); //$NON-NLS-1$
        
        DecimalFormatSymbols dfSymbols = new DecimalFormatSymbols();
        dfSymbols.setNaN(" "+ FPRenderingMessages.getString("FPRendering.NAN")); //$NON-NLS-1$ //$NON-NLS-2$
        dfSymbols.setInfinity(FPRenderingMessages.getString("FPRendering.INFINITY")); //$NON-NLS-1$
        df.setDecimalFormatSymbols(dfSymbols);
        
        // Set the integer and fraction digits for normalized scientific notation.  
        
        df.setMinimumIntegerDigits(1);
        df.setMaximumIntegerDigits(1);
        
        if (dt == FPDataType.FLOAT)
            displayedDigits = Math.min(maxDisplayDigits, FPDataType.FLOAT.getInternalPrecision());
        
        if (dt == FPDataType.DOUBLE)
            displayedDigits = Math.min(maxDisplayDigits, FPDataType.DOUBLE.getInternalPrecision());
        
        df.setMinimumFractionDigits(displayedDigits - 1);
        df.setMaximumFractionDigits(displayedDigits - 1);

        // Convert the byte array to a scientific notation floating point number string (only floats and doubles currently supported)
        
        ByteOrder byteOrder = isLittleEndian ? ByteOrder.LITTLE_ENDIAN : ByteOrder.BIG_ENDIAN;
        
        return df.format(dt == FPDataType.FLOAT ?
                ByteBuffer.wrap(memoryBytesToByteArray(memByteArray)).order(byteOrder).getFloat() :
                ByteBuffer.wrap(memoryBytesToByteArray(memByteArray)).order(byteOrder).getDouble());
    }
    
    // Convert a floating point string to a byte array (*** only 'floats' and 'doubles' currently supported ***)
    
    public static byte[] floatingStringToByteArray(FPDataType dt, String valueString, int dataTypeBitCount) throws NumberFormatException
    {
        // Remove whitespace and check for non-zero length
        valueString = valueString.trim().replaceAll(" ", ""); //$NON-NLS-1$ //$NON-NLS-2$
        
        if (valueString.length() != 0)
        {
            // Float handling
            
            if (dt == FPDataType.FLOAT || FPDataType.FLOAT.getBitsize() == dataTypeBitCount)
            {
                // Convert the string to a float.  Check the range.  Convert to byte array.
                
                float floatValue = new Float(valueString).floatValue();
                floatValue = floatLimitCheck(floatValue);
                return rawFloatBitsToByteArray(Float.floatToRawIntBits(floatValue));
            }
            
            // Double handling

            if (dt == FPDataType.DOUBLE || FPDataType.DOUBLE.getBitsize() == dataTypeBitCount)
            {
                // Convert the string to a double.  Check the range.  Convert to byte array.
                
                double doubleValue = new Double(valueString).doubleValue();
                doubleValue = doubleLimitCheck(doubleValue);
                return rawDoubleBitsToByteArray(Double.doubleToRawLongBits(doubleValue));
            }
        }
        
        return new byte[0];
    }
    
    // Convert from an FPMemoryByte array to a byte array
    
    public static byte[] memoryBytesToByteArray(FPMemoryByte[] memoryByteArray)
    {
        byte[] byteArray = new byte[memoryByteArray.length];
        
        for (int index = 0; index < memoryByteArray.length; index++)
            byteArray[index] = memoryByteArray[index].getValue();
        
        return byteArray;
    }
    
    // Convert from a byte array to a MemoryByte array
    
    public static FPMemoryByte[] byteArrayToMemoryBytes(Endian endian, byte[] byteArray)
    {
        FPMemoryByte[] memoryBytes = new FPMemoryByte[byteArray.length];
        
        for (int index = 0; index < byteArray.length; index++)
        {
            memoryBytes[index] = new FPMemoryByte();
            memoryBytes[index].setBigEndian(endian == Endian.BIG);
            memoryBytes[index].setValue(byteArray[index]);
        }
        
        return memoryBytes;
    }
    
    // Check the character for being valid for number entry, both standard and scientific notation 
    
    public static boolean validEditCharacter(char character)
    {
        return  (character >= '0' && character <= '9') ||
                 character == '+' || character == '-'  ||
                 character == 'e' || character == 'E'  ||
                 character == '.' || character == ' ';
    }
    
    // Validate floating point number string
    
    public static boolean isValidFormat(String string)
    {
        // Rules:
        //  - A minimum of one digit preceding the optional exponent character is required.
        //  - Allowable characters: 0-9, a decimal point, '+' and '-' number
        //    signs, exponent characters 'e' and 'E', and spaces.
        // 
        // Strings may also have:
        //      - One [optional] decimal point
        //      - A maximum of two [optional] number signs (one before the number and one after the exponent character)
        //      - Only one [optional] exponent character is allowed
        
        boolean digit = false;
        char[] charArray = string.toCharArray();
        
        // Phase I check:
        
        String scientificNotationPattern  = "^[-+]??(\\d++[.]\\d*?|[.]?\\d+?|\\d+(?=[eE]))([eE][-+]??\\d++)?$"; //$NON-NLS-1$
        
        if (!Pattern.matches(scientificNotationPattern, string))
            return false;
        
        // Phase II check
        
        for (int index = 0; index < string.length(); index++)
        {
            // Check for a digit
            
            if (charArray[index] >= '0' && charArray[index] <= '9')
                digit = true;
            
            // Make sure it's a valid/allowable character
            
            if (!validEditCharacter(charArray[index]))
                return false;
            
            // Only one decimal point and exponent character is allowed
            
            if (FPutilities.countMatches(string.toLowerCase(), ".") > 1 || FPutilities.countMatches(string.toLowerCase(), "e") > 1) //$NON-NLS-1$ //$NON-NLS-2$
                return false;
            
            // Number signs are only allowed in the first position and following the exponent character.
            
            if (((charArray[index] == '+' || charArray[index] == '-') && index != 0) && 
                 (charArray[index-1] != 'e' && charArray[index-1] != 'E'))
                    return false;
            
            // Decimal points are not allowed after the exponent character
            
            int eIndex = string.toLowerCase().indexOf('e');
            
            if (charArray[index] == '.' && eIndex != -1 && eIndex < index)
                return false;
        }
        
        return digit;
    }
    
    // Return a string of the specified length filled with the specified character 
    
    public static String fillString(int length, char character)
    {
        if (length < 1) return ""; //$NON-NLS-1$
        char[] charArray = new char[length];
        Arrays.fill(charArray, character);
        return new String(charArray);
    }
    
    // Count the 'subString' matches in 'string'
    
    public static int countMatches(String string, String subString)
    {
        if (string.length() == 0 || subString.length() == 0) return 0;
        
        int count = 0;
        int index = 0;
        
        while ((index = string.indexOf(subString, index)) != -1)
        {
            count++;
            index += subString.length();
        }
        
        return count;
    }
    
    // Print out a stack trace; useful for UI operations where stopping at a breakpoint causes button press context to be lost
    
    public static void stackTrace(int depth)
    {
        int offset = 3;                 // Ignore frames contributed to the stack based on call to this method
        if (depth == 0) depth = 4;      // Default depth if zero supplied
        
        // Get the stack frames for the current thread; start at the offset  
        
        StackTraceElement[] seArray = Thread.currentThread().getStackTrace();
        
        if (seArray.length > offset)
        {    
            System.out.println("Displaying " + depth + " of " + seArray.length + " stack trace elements"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
            for (int index = offset; index < Math.min(depth + offset, seArray.length + offset); index++)
                System.out.println("   " + seArray[index].getClassName() + "." + seArray[index].getMethodName() + ": line " + seArray[index].getLineNumber()); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
        }
        else
            System.out.println("No stack frames to display"); //$NON-NLS-1$
    }
    
    // Pop up a message inside the UI thread
    
    public static void popupMessage(final String title, final String errorText, final Status status)
    {
        UIJob job = new UIJob("Floating Point Renderer") //$NON-NLS-1$
        {
            // Notify the user of some condition via a pop-up box.
            
            @Override
            public IStatus runInUIThread(IProgressMonitor monitor)
            {
                ErrorDialog.openError(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(), title, errorText, status);
                return Status.OK_STATUS;
            }
        };
        
        job.setSystem(true);
        job.schedule();
    }
    
    // Check float range.  Returns -Infinity, the original value or +Infinity
    
    public static float floatLimitCheck(float floatValue)
    {
        if (floatValue != 0.0f && floatValue != Float.NEGATIVE_INFINITY && floatValue != Float.POSITIVE_INFINITY)
        {
            if (floatValue < 0)
            {
                if (Float.compare(floatValue, floatNegMax) < 0 || Float.compare(floatValue, floatNegMin) > 0)
                    return Float.NEGATIVE_INFINITY;
            }
            else
            {
                if (Float.compare(floatValue, floatPosMin) < 0 || Float.compare(floatValue, floatPosMax) > 0)
                    return Float.POSITIVE_INFINITY;
            }
        }
        
        return floatValue;
    }
    
    // Check double range.  Returns a value of RangeCheck
    
    public static double doubleLimitCheck(double doubleValue)
    {
        if (doubleValue != 0.0 && doubleValue != Double.NEGATIVE_INFINITY && doubleValue != Double.POSITIVE_INFINITY)
        {
            if (doubleValue < 0)
            {
                if (Double.compare(doubleValue, doubleNegMax) < 0 || Double.compare(doubleValue, doubleNegMin) > 0)
                    return Double.NEGATIVE_INFINITY;
            }
            else
            {
                if (Double.compare(doubleValue, doublePosMin) < 0 || Double.compare(doubleValue, doublePosMax) > 0)
                    return Double.POSITIVE_INFINITY;
            }
        }
        
        return doubleValue;
    }
    
    // Convert a BigInteger to a hex String and return only the ending number of specified digits.
    
    public static String bi2HexStr(BigInteger bi, int lastDigits)
    {
        final int PAD_LENGTH = 12;
        String base16 = bi.toString(16);
        base16 = fillString(PAD_LENGTH - base16.length(), '0') + base16;
        return "0x" + base16.substring(PAD_LENGTH - lastDigits).toUpperCase(); //$NON-NLS-1$
    }
    
    // Convert a BigInteger to a decimal String and return only the ending number of
    // specified digits.  For example:  bi2HexStr(239248506, 5) = "48506"
    
    public static String bi2DecStr(BigInteger bi, int lastDigits)
    {
        final int PAD_LENGTH = 12;
        String base10 = bi.toString();
        base10 = fillString(PAD_LENGTH - base10.length(), '0') + base10;
        return base10.substring(PAD_LENGTH - lastDigits);
    }
}