<change>

        <api name="DebuggerCoreAPI"/>

        <summary>Support for stepping over operations.</summary>

        <version major="1" minor="9"/>

        <date day="1" month="2" year="2007"/>

        <author login="mentlicher"/>

        <compatibility>

            <p>

                Compatile change.

            </p>

        </compatibility>

        <description>

            <p>

                Added fields:

                <code>ActionsManager.ACTION_STEP_OPERATION</code>, 

                This constant is used in action performer which implements an operation step.

            </p>

        </description>

    </change>

    /** Action constant for Step Operation Action. */

    public static final Object              ACTION_STEP_OPERATION = "stepOperation";

    <change>

        <api name="JPDADebuggerAPI"/>

        <summary>Support for stepping over operations.</summary>

        <version major="2" minor="9"/>

        <date day="1" month="2" year="2007"/>

        <author login="mentlicher"/>

        <compatibility addition="yes" source="compatible" binary="compatible"/>

        <description>

            <p>

                In order to be able to provide stepping over operations,

                we need a representation of an operation and some way how to

                retrieve the operation(s) from a Thread and a CallStackFrame.

            </p>

            <p>

                Added fields:<br/>

                <code>JPDAStep.STEP_OPERATION</code>,

                <code>EditorContext.CURRENT_LAST_OPERATION_ANNOTATION_TYPE</code>,

                <code>EditorContext.CURRENT_EXPRESSION_SECONDARY_LINE_ANNOTATION_TYPE</code>,

                <code>EditorContext.CURRENT_EXPRESSION_CURRENT_LINE_ANNOTATION_TYPE</code>

            </p>

            <p>

                Added methods:<br/>

                <code>CallStackFrame.getCurrentOperation()</code>,

                <code>JPDAThread.getCurrentOperation()</code>,

                <code>JPDAThread.getLastOperations()</code>,

                <code>EditorContext.createMethodOperation()</code>,

                <code>EditorContext.addNextOperationTo()</code>,

                <code>EditorContext.createPosition()</code>,

                <code>EditorContext.getOperations()</code>

            </p>

            <p>

                Added classes:<br/>

                <code>EditorContext.BytecodeProvider</code>,

                <code>EditorContext.Operation</code>,

                <code>EditorContext.Position</code>

            </p>

        </description>

        <class package="org.netbeans.api.debugger.jpda" name="JPDAStep" />

        <class package="org.netbeans.api.debugger.jpda" name="CallStackFrame" />

        <class package="org.netbeans.api.debugger.jpda" name="JPDAThread" />

        <class package="org.netbeans.spi.debugger.jpda" name="EditorContext" />

        <issue number="93842"/>

    </change>

import org.netbeans.spi.debugger.jpda.EditorContext.Operation;

    /**

     * Returns the current operation (if any) at the location of this call stack frame.

     *

     * @param struts a language name or null for default language

     * @return  The operation at the frame location if available and this frame does not

     *          represent a native method invocation; <CODE>null</CODE> otherwise

     */

    public abstract Operation getCurrentOperation(String struts);

    /** Step to the next available operation */

    public static final int STEP_OPERATION = 10;

import java.util.List;

import org.netbeans.spi.debugger.jpda.EditorContext;

import org.netbeans.spi.debugger.jpda.EditorContext.Operation;

    /**

     * Returns the operation that is being currently executed on this thread.

     * @return The current operation, or <CODE>null</CODE>.

     * @see {@link CallStackFrame#getCurrentOperation}

     */

    public abstract Operation getCurrentOperation();

    /**

     * Returns the list of the last operations, that were performed on this thread.

     * Typically just operations from the current expression are stored.

     * The thread should be suspended at the moment this method is called.

     *

     * @return  The list of last operations if available, the thread is suspended,

     *          contains at least one frame and the topmost frame does not

     *          represent a native method invocation; <CODE>null</CODE> otherwise

     * @see CallStackFrame

     */

    public abstract List<Operation> getLastOperations();

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.Iterator;

import java.util.List;

import org.netbeans.api.debugger.jpda.Variable;

    /** Annotation type constant. */

    public static final String CURRENT_LAST_OPERATION_ANNOTATION_TYPE = "LastOperation";

    /** Annotation type constant. */

    public static final String CURRENT_EXPRESSION_SECONDARY_LINE_ANNOTATION_TYPE = "CurrentExpression";

    /** Annotation type constant. */

    public static final String CURRENT_EXPRESSION_CURRENT_LINE_ANNOTATION_TYPE = "CurrentExpressionLine";

     * Adds annotation to given url on given character range.

     *

     * @param url a url of source annotation should be set into

     * @param startPosition the offset of the starting position of the annotation

     * @param endPosition the offset of the ending position of the annotation

     * @param annotationType a type of annotation to be set

     * @return annotation or <code>null</code>, when the annotation can not be

     *         created at the given URL or line number.

     */

    public Object annotate (

        String url, 

        int startPosition, 

        int endPosition, 

        String annotationType,

        Object timeStamp

    ) {

        return null;

    }

    /**

     * Creates an operation which is determined by starting and ending position.

     *

    protected final Operation createOperation(Position startPosition,

                                              Position endPosition,

                                              int bytecodeIndex) {

        return new Operation(startPosition, endPosition, bytecodeIndex);

    }

     */

    /**

     * Creates a method operation.

     * @param startPosition The starting position of the operation

     * @param endPosition The ending position of the operation

     * @param methodStartPosition The starting position of the method name

     * @param methodEndPosition The ending position of the method name

     * @param methodName The string representation of the method name

     * @param methodClassType The class type, which defines this method

     * @param bytecodeIndex The bytecode index of this method call

     */

    protected final Operation createMethodOperation(Position startPosition,

                                                    Position endPosition,

                                                    Position methodStartPosition,

                                                    Position methodEndPosition,

                                                    String methodName,

                                                    String methodClassType,

                                                    int bytecodeIndex) {

        return new Operation(startPosition, endPosition,

                             methodStartPosition, methodEndPosition,

                             methodName, methodClassType, bytecodeIndex);

    }

    /**

     * Assign a next operation, concatenates operations.

     * @param operation The first operation

     * @param next The next operation

     */

    protected final void addNextOperationTo(Operation operation, Operation next) {

        operation.addNextOperation(next);

    }

    /**

     * Creates a new {@link Position} object.

     * @param offset The offset

     * @param line The line number

     * @param column The column number

     */

    protected final Position createPosition(

            int offset, int line, int column) {

        return new Position(offset, line, column);

    }

    /**

     * Get the list of operations that are in expression(s) located at the given line.

     * @param url The file's URL

     * @param lineNumber The line number

     * @param bytecodeProvider The provider of method bytecodes.

     */

    public Operation[] getOperations(String url, int lineNumber,

                                     BytecodeProvider bytecodeProvider) {

        throw new UnsupportedOperationException("This method is not implemented.");

    }

    /**

    /**

     * A provider of method bytecode information.

     */

    public interface BytecodeProvider {

        /**

         * Retrieve the class' constant pool.

         */

        byte[] constantPool();

        /**

         * Retrieve the bytecodes of the method.

         */

        byte[] byteCodes();

        /**

         * Get an array of bytecode indexes of operations between the starting

         * and ending line.

         * @param startLine The starting line

         * @param endLine The ending line

         */

        int[] indexAtLines(int startLine, int endLine);

    }

    /**

     * The operation definition.

     */

    public static final class Operation {

        private final Position startPosition;

        private final Position endPosition;

        private final int bytecodeIndex;

        private Position methodStartPosition;

        private Position methodEndPosition;

        private String methodName;

        private String methodClassType;

        private Variable returnValue;

        private List<Operation> nextOperations;

        /*

        Operation(Position startPosition, Position endPosition,

                  int bytecodeIndex) {

            this.startPosition = startPosition;

            this.endPosition = endPosition;

            this.bytecodeIndex = bytecodeIndex;

        }

         */

        /**

         * Creates a new method operation.

         */

        Operation(Position startPosition, Position endPosition,

                  Position methodStartPosition, Position methodEndPosition,

                  String methodName, String methodClassType,

                  int bytecodeIndex) {

            this.startPosition = startPosition;

            this.endPosition = endPosition;

            this.bytecodeIndex = bytecodeIndex;

            this.methodStartPosition = methodStartPosition;

            this.methodEndPosition = methodEndPosition;

            this.methodName = methodName;

            this.methodClassType = methodClassType;

        }

        synchronized void addNextOperation(Operation next) {

            if (nextOperations == null) {

                nextOperations = new ArrayList<Operation>();

            }

            nextOperations.add(next);

        }

        /**

         * Get the starting position of this operation.

         */

        public Position getStartPosition() {

            return startPosition;

        }

        /**

         * Get the ending position of this operation.

         */

        public Position getEndPosition() {

            return endPosition;

        }

        /**

         * Get the starting position of the method call of this operation.

         */

        public Position getMethodStartPosition() {

            return methodStartPosition;

        }

        /**

         * Get the ending position of the method call of this operation.

         */

        public Position getMethodEndPosition() {

            return methodEndPosition;

        }

        /**

         * Get the method name.

         */

        public String getMethodName() {

            return methodName;

        }

        /**

         * Get the class type declaring the method.

         */

        public String getMethodClassType() {

            return methodClassType;

        }

        /**

         * Get the bytecode index of this operation.

         */

        public int getBytecodeIndex() {

            return bytecodeIndex;

        }

        /**

         * Set the return value of this operation.

         */

        public void setReturnValue(Variable returnValue) {

            this.returnValue = returnValue;

        }

        /**

         * Get the return value of this operation.

         */

        public Variable getReturnValue() {

            return returnValue;

        }

        /**

         * Get the list of following operations.

         */

        public List<Operation> getNextOperations() {

            if (nextOperations == null) {

                return Collections.emptyList();

            } else {

                synchronized (this) {

                    return Collections.unmodifiableList(nextOperations);

                }

            }

        }

        public boolean equals(Object obj) {

            if (obj instanceof Operation) {

                Operation op2 = (Operation) obj;

                return bytecodeIndex == op2.bytecodeIndex &&

                        ((startPosition == null) ?

                            op2.startPosition == null :

                            startPosition.equals(op2.startPosition)) &&

                        ((endPosition == null) ?

                            op2.endPosition == null :

                            endPosition.equals(op2.endPosition));

            }

            return false;

        }

        public int hashCode() {

            return bytecodeIndex;

        }

    }

    /**

     * Representation of a position in a source code.

     */

    public static final class Position {

        private final int offset;

        private final int line;

        private final int column;

        Position(int offset, int line, int column) {

            this.offset = offset;

            this.line = line;

            this.column = column;

        }

        /**

         * Get the offset of this position.

         */

        public int getOffset() {

            return offset;

        }

        /**

         * Get the line number of this position.

         */

        public int getLine() {

            return line;

        }

        /**

         * Get the column number of this position.

         */

        public int getColumn() {

            return column;

        }

        public boolean equals(Object obj) {

            if (obj instanceof Position) {

                Position pos = (Position) obj;

                return pos.offset == offset;

            }

            return false;

        }

        public int hashCode() {

            return offset;

        }

    }