| /******************************************************************************* |
| * Copyright (c) 2004, 2006 IBM Corporation 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: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.debug.core.model; |
| |
| |
| /** |
| * A byte of memory in a memory block. Each byte of memory has a value and |
| * attributes indicating if the byte is read-only, valid, or if its value has |
| * changed. |
| * <p> |
| * Clients may instantiate this class. Clients may subclass this class to |
| * add other attributes to a memory byte, as required. |
| * </p> |
| * @since 3.1 |
| * @see org.eclipse.debug.core.model.IMemoryBlockExtension |
| */ |
| public class MemoryByte { |
| |
| /** |
| * Bit mask used to indicate a byte is writable. |
| */ |
| public static final byte WRITABLE = 0x01; |
| |
| /** |
| * Bit mask used to indicate a byte is readable. |
| * A memory byte is readable when its value and attributes are retrievable. |
| * Otherwise, a byte is considered non-readable. |
| */ |
| public static final byte READABLE = 0x02; |
| |
| /** |
| * Bit mask used to indicate a byte has changed since the last |
| * suspend event. |
| * |
| * @see org.eclipse.debug.core.DebugEvent#SUSPEND |
| */ |
| public static final byte CHANGED = 0x04; |
| |
| /** |
| * Bit mask used to indicate a memory byte has history to |
| * determine if its value has changed. When a memory byte's |
| * history is unknown, the change state has no meaning. |
| */ |
| public static final byte HISTORY_KNOWN = 0x08; |
| |
| /** |
| * Bit mask used to indicate a this byte of memory |
| * is big endian. If this byte of memory is little endian, |
| * turn this bit mask to off. |
| */ |
| public static final byte BIG_ENDIAN = 0x10; |
| |
| /** |
| * Bit mask used to indicate that the endianess of this byte |
| * of memory is known. When a memory byte's endianess is |
| * unknown, the endianess of this byte has no meaning. |
| */ |
| public static final byte ENDIANESS_KNOWN = 0x20; |
| |
| /** |
| * Value of this byte. |
| */ |
| protected byte value; |
| |
| /** |
| * Attribute flags. |
| * <p> |
| * To specify READABLE: flags |= MemoryByte.READABLE; |
| * To specify WRITABLE: flags |= MemoryByte.WRITABLE; |
| * </p> |
| */ |
| protected byte flags; |
| |
| /** |
| * Constructs a readable, writable memory byte without a change history, |
| * and a value of 0. The byte's endianess is known and is little endian |
| * by default. |
| */ |
| public MemoryByte() { |
| this((byte)0, (byte)(WRITABLE | READABLE | ENDIANESS_KNOWN)); |
| } |
| |
| /** |
| * Constructs a readable, writable memory byte without a change history, |
| * with the given value. The byte's endianess is known and is little endian |
| * by default. |
| * |
| * @param byteValue value of this memory byte |
| * |
| */ |
| public MemoryByte(byte byteValue) { |
| this(byteValue, (byte)(WRITABLE | READABLE | ENDIANESS_KNOWN)); |
| } |
| |
| /** |
| * Constructs a memory byte with the given value and attributes. |
| * |
| * @param byteValue value of this memory byte |
| * @param byteFlags attributes of the byte specified as a bit mask |
| */ |
| public MemoryByte(byte byteValue, byte byteFlags) { |
| value = byteValue; |
| flags = byteFlags; |
| } |
| |
| /** |
| * Returns this memory byte's attribute as a bit mask. |
| * |
| * @return this memory byte's attribute as a bit mask |
| */ |
| public byte getFlags() { |
| return flags; |
| } |
| /** |
| * Sets this memory byte's attributes based on the given bit mask. |
| * |
| * @param flags bit mask of attributes |
| */ |
| public void setFlags(byte flags) { |
| this.flags = flags; |
| } |
| |
| /** |
| * Returns the value of this memory byte. |
| * |
| * @return the value of this memory byte |
| */ |
| public byte getValue() { |
| return value; |
| } |
| |
| /** |
| * Sets the value of this memory byte. |
| * |
| * @param value the new value of this memory byte |
| */ |
| public void setValue(byte value) { |
| this.value = value; |
| } |
| |
| /** |
| * Sets whether this memory byte is readable. A memory byte |
| * is considered readable when its value and attributes are |
| * retrievable. |
| * |
| * @param readable whether this memory byte is readable |
| */ |
| public void setReadable(boolean readable) { |
| flags |= MemoryByte.READABLE; |
| if (!readable) |
| flags ^= MemoryByte.READABLE; |
| } |
| |
| /** |
| * Returns whether this memory byte is readable. A memory byte |
| * is considered readable when its value and attributes are |
| * retrievable. |
| * |
| * @return whether this memory byte is readable |
| */ |
| public boolean isReadable() { |
| return ((flags & MemoryByte.READABLE) == MemoryByte.READABLE); |
| } |
| |
| /** |
| * Sets whether this memory byte is writable. |
| * |
| * @param writable whether this memory byte is writable. |
| */ |
| public void setWritable(boolean writable) { |
| flags |= MemoryByte.WRITABLE; |
| if (!writable) |
| flags ^= MemoryByte.WRITABLE; |
| } |
| |
| /** |
| * Returns whether this memory byte is writable. |
| * |
| * @return whether this memory byte is writable |
| */ |
| public boolean isWritable() { |
| return ((flags & MemoryByte.WRITABLE) == MemoryByte.WRITABLE); |
| } |
| |
| /** |
| * Sets whether this memory byte has changed. |
| * |
| * @param changed whether this memory byte has changed |
| */ |
| public void setChanged(boolean changed) { |
| flags |= MemoryByte.CHANGED; |
| if (!changed) |
| flags ^= MemoryByte.CHANGED; |
| } |
| |
| /** |
| * Returns whether this memory byte has changed. |
| * |
| * @return whether this memory byte has changed |
| */ |
| public boolean isChanged() { |
| return ((flags & MemoryByte.CHANGED) == MemoryByte.CHANGED); |
| } |
| |
| /** |
| * Sets whether the history of this byte is known. When history |
| * is unknown, the change state of a memory byte has no meaning. |
| * |
| * @param known whether the change state of this byte is known |
| */ |
| public void setHistoryKnown(boolean known) { |
| flags |= MemoryByte.HISTORY_KNOWN; |
| if (!known) |
| flags ^= MemoryByte.HISTORY_KNOWN; |
| } |
| |
| /** |
| * Returns whether the history of this byte is known. When history |
| * is unknown, the change state of a memory byte has no meaning. |
| * |
| * @return whether the change state of this byte is known |
| */ |
| public boolean isHistoryKnown() { |
| return ((flags & MemoryByte.HISTORY_KNOWN) == MemoryByte.HISTORY_KNOWN); |
| } |
| |
| /** |
| * Sets whether this byte of memory is big endian. |
| * |
| * @param isBigEndian whether the byte of memory is big endian. |
| */ |
| public void setBigEndian(boolean isBigEndian) |
| { |
| flags |= MemoryByte.BIG_ENDIAN; |
| if (!isBigEndian) |
| flags ^= MemoryByte.BIG_ENDIAN; |
| } |
| |
| /** |
| * Returns whether this byte of memory is big endian. |
| * |
| * @return whether the byte of memory is big endian. |
| */ |
| public boolean isBigEndian() |
| { |
| return ((flags & MemoryByte.BIG_ENDIAN) == MemoryByte.BIG_ENDIAN); |
| } |
| |
| /** |
| * Sets whether the endianess of this byte of memory is known. |
| * If the endianess is unknown, the endianess of this byte |
| * has no meaning. |
| * |
| * @param isEndianessKnown whether the endianess of this byte is known. |
| */ |
| public void setEndianessKnown(boolean isEndianessKnown) |
| { |
| flags |= MemoryByte.ENDIANESS_KNOWN; |
| if (!isEndianessKnown) |
| flags ^= MemoryByte.ENDIANESS_KNOWN; |
| } |
| |
| /** |
| * Returns whether the endianess of this byte of memory is known. |
| * If the endianess is unknown, the endianess of this byte |
| * has no meaning. |
| * |
| * @return whether the endianess of this byte of memory is known. |
| */ |
| public boolean isEndianessKnown() |
| { |
| return ((flags & MemoryByte.ENDIANESS_KNOWN) == MemoryByte.ENDIANESS_KNOWN); |
| } |
| |
| } |