memory/org.eclipse.cdt.debug.ui.memory.floatingpoint/src/org/eclipse/cdt/debug/ui/memory/floatingpoint/FPutilities.java - cdt/org.eclipse.cdt - Git at Google

 /*******************************************************************************
  * 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);
     }
 }
	/*******************************************************************************
	* 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);
	}
	}