FCL/sftools/dev/eclipseenv/eclipse: comparison cdt/cdt_6_0_x/org.eclipse.cdt.dsf/src/org/eclipse/cdt/dsf/debug/service/IExpressions.java

equal deleted inserted replaced

-:b32168b846ac
+:723898599d35
 *     Wind River Systems - initial API and implementation
 *     Ericsson           - Update for GDB/MI
 *******************************************************************************/
 package org.eclipse.cdt.dsf.debug.service;
+import java.math.BigInteger;
 import java.util.Map;
+import org.eclipse.cdt.core.IAddress;
 import org.eclipse.cdt.dsf.concurrent.DataRequestMonitor;
 import org.eclipse.cdt.dsf.concurrent.RequestMonitor;
 import org.eclipse.cdt.dsf.datamodel.IDMContext;
 import org.eclipse.cdt.dsf.datamodel.IDMData;
 import org.eclipse.cdt.dsf.datamodel.IDMEvent;
 * expression string is the same as the string that is sent to the debug engine to be
 * evaluated in context of a stack frame, thread, or a symbol context.
 */
 String getExpression();
 }
 /**
 * The address and size of an expression.
 */
 public interface IExpressionDMAddress {
-	Object getAddress();
+/**
+* Returns the address of the expression.
+*/
+	IAddress getAddress();
+	/**
+	 * Returns the size of the address.
+	 */
 	int getSize();
 }
+/**
+* A representation of an expression location that does not correspond to
+* an address.
+*
+* @since 2.1
+*/
+public interface IExpressionDMLocation extends IExpressionDMAddress {
+/**
+* A constant that can be returned by {@link IExpressionDMAddress#getAddress()}
+* to represent an invalid address.  Implementations of
+* <code>IExpressionDMLocation</code> can return this constant if no
+* valid address can be returned for a given expression location.
+*/
+public static final IAddress INVALID_ADDRESS = new IAddress() {
+public IAddress add(BigInteger offset) { return this; }
+public IAddress add(long offset) { return this; }
+public BigInteger getMaxOffset() { return BigInteger.ZERO; }
+public BigInteger distanceTo(IAddress other) { return BigInteger.ZERO; }
+public BigInteger getValue() { return BigInteger.ZERO; }
+public boolean isZero() { return false; }
+public boolean isMax() { return false; }
+public String toString(int radix) { return "INVALID"; }
+public String toHexAddressString() { return toString(); }
+public String toBinaryAddressString()  { return toString(); }
+public int getCharsNum() { return 0; }
+public int getSize() { return 0; }
+public int compareTo(Object o) { return 0; }
+};
+/**
+* Returns a string representation of the expression location.
+*/
+	public String getLocation();
+}
 /**
 * This is the model data interface that corresponds to IExpressionDMContext.
 */
 public interface IExpressionDMData extends IDMData {
 void getExpressionData(IExpressionDMContext dmc, DataRequestMonitor<IExpressionDMData> rm);
 /**
 * Retrieves the address and size of an expression given by the expression context(<tt>dmc</tt>).
 * Non-lvalues do not have an addresses (e.g., "x + 5").  When the expression
--    * has no address, the data request monitor will contain null.
+-    * has no address, the request monitor will have an error with code
+* <code>IDsfStatusConstants.REQUEST_FAILED</code> and the data request
+* monitor will contain null.
 *
 * @param dmc
 *            The ExpressionDMC for the expression
 * @param rm
 *            The data request monitor that will contain the requested data
 * @param ctx: Context in which to evaluate the expression.  This context could include the
 * PC location, stack frame, thread, or just a symbol context.
 *
 * @param expression: The expression to evaluate.
 *
-* @return  An expression data model context object that must be passed to
+* @return  An expression data model context object that must be passed to the appropriate
-* getModelData() to obtain the value of the expression.
+*          data retrieval routine to obtain the value of the expression.
 */
 IExpressionDMContext createExpression(IDMContext ctx, String expression);
 /**
 * Retrieves the sub-expressions of the given expression.  Sub-expressions are fields of a struct, union,
 * or class, the enumerators of an enumeration, and the element of an array.
+* <br>
+* Note: Clients may call this method on any valid expression context, and before calling any other
+* method to evaluate the expression value.  It is up to the implementation to internally evaluate the
+* expression if needed, in order to calculate sub expressions.
 *
 * @param exprCtx: The data model context representing an expression.
 *
 * @param rm: Request completion monitor containing an array of all sub-expressions
 */
 /**
 * Retrieves a particular range of sub-expressions of the given expression.
 * Sub-expressions are fields of a struct, union, or class, the enumerators
 * of an enumeration, and the element of an array.
+* <br>
+* Note: Clients may call this method on any valid expression context, and before calling any other
+* method to evaluate the expression value.  It is up to the implementation to internally evaluate the
+* expression if needed, in order to calculate sub expressions.
 *
 * @param exprCtx: The data model context representing an expression.
 *        startIndex: Index of the first sub-expression to retrieve
 *        length: Total number of sub-expressions to retrieve
 *
 		DataRequestMonitor<IExpressionDMContext[]> rm);
 /**
 * Retrieves the number of sub-expressions of the given expression.  Sub-expressions are fields of a struct, union,
 * or class, the enumerators of an enumeration, and the element of an array.
+* <br>
+* Note: Clients may call this method on any valid expression context, and before calling any other
+* method to evaluate the expression value.  It is up to the implementation to internally evaluate the
+* expression if needed, in order to calculate sub expressions.
 *
 * @param exprCtx: The data model context representing an expression.
 *
 * @param rm: Request completion monitor containing the number of sub-expressions
 *            of the specified expression
 void getSubExpressionCount(IExpressionDMContext exprCtx, DataRequestMonitor<Integer> rm);
 /**
 * For object oriented languages, this method returns the expressions representing base types of
 * the given expression type.
+* <br>
+* Note: Clients may call this method on any valid expression context, and before calling any other
+* method to evaluate the expression value.  It is up to the implementation to internally evaluate the
+* expression if needed, in order to calculate sub expressions.
 *
 * @param exprContext: The data model context representing an expression.
 *
 * @param rm: Request completion monitor.
 */

changeset 129	723898599d35
parent 105	fbceb3d6fb44