001: /*
002: * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
003: *
004: * Copyright 1997-2007 Sun Microsystems, Inc. All rights reserved.
005: *
006: * The contents of this file are subject to the terms of either the GNU
007: * General Public License Version 2 only ("GPL") or the Common
008: * Development and Distribution License("CDDL") (collectively, the
009: * "License"). You may not use this file except in compliance with the
010: * License. You can obtain a copy of the License at
011: * http://www.netbeans.org/cddl-gplv2.html
012: * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
013: * specific language governing permissions and limitations under the
014: * License. When distributing the software, include this License Header
015: * Notice in each file and include the License file at
016: * nbbuild/licenses/CDDL-GPL-2-CP. Sun designates this
017: * particular file as subject to the "Classpath" exception as provided
018: * by Sun in the GPL Version 2 section of the License file that
019: * accompanied this code. If applicable, add the following below the
020: * License Header, with the fields enclosed by brackets [] replaced by
021: * your own identifying information:
022: * "Portions Copyrighted [year] [name of copyright owner]"
023: *
024: * Contributor(s):
025: *
026: * The Original Software is NetBeans. The Initial Developer of the Original
027: * Software is Sun Microsystems, Inc. Portions Copyright 1997-2007 Sun
028: * Microsystems, Inc. All Rights Reserved.
029: *
030: * If you wish your version of this file to be governed by only the CDDL
031: * or only the GPL Version 2, indicate your decision by adding
032: * "[Contributor] elects to include this software in this distribution
033: * under the [CDDL or GPL Version 2] license." If you do not indicate a
034: * single choice of license, a recipient has the option to distribute
035: * your version of this file under either the CDDL, the GPL Version 2 or
036: * to extend the choice of license to its licensees as provided above.
037: * However, if you add GPL Version 2 code and therefore, elected the GPL
038: * Version 2 license, then the option applies only if the new code is
039: * made subject to such option by the copyright holder.
040: */
041:
042: package org.netbeans.modules.debugger.jpda.models;
043:
044: import com.sun.jdi.AbsentInformationException;
045: import com.sun.jdi.ClassNotLoadedException;
046: import com.sun.jdi.Field;
047: import com.sun.jdi.InvalidTypeException;
048: import com.sun.jdi.ObjectReference;
049: import com.sun.jdi.Value;
050:
051: import org.netbeans.api.debugger.Watch;
052: import org.netbeans.api.debugger.jpda.InvalidExpressionException;
053: import org.netbeans.api.debugger.jpda.JPDAWatch;
054: import org.netbeans.api.debugger.jpda.LocalVariable;
055: import org.netbeans.api.debugger.jpda.ObjectVariable;
056: import org.netbeans.modules.debugger.jpda.JPDADebuggerImpl;
057:
058: /**
059: * Represents watch in JPDA debugger.
060: *
061: * @author Jan Jancura
062: */
063:
064: class JPDAObjectWatchImpl extends AbstractObjectVariable implements
065: JPDAWatch, ObjectVariable {
066:
067: private JPDADebuggerImpl debugger;
068: private Watch watch;
069: private String exceptionDescription;
070:
071: JPDAObjectWatchImpl(JPDADebuggerImpl debugger, Watch watch, Value v) {
072: super (debugger, v, "" + watch
073: + (v instanceof ObjectReference ? "^" : ""));
074: this .debugger = debugger;
075: this .watch = watch;
076: }
077:
078: JPDAObjectWatchImpl(JPDADebuggerImpl debugger, Watch watch,
079: String exceptionDescription) {
080: super (debugger, null, "" + watch);
081: this .debugger = debugger;
082: this .watch = watch;
083: this .exceptionDescription = exceptionDescription;
084: }
085:
086: /**
087: * Watched expression.
088: *
089: * @return watched expression
090: */
091: public String getExpression() {
092: return watch.getExpression();
093: }
094:
095: /**
096: * Sets watched expression.
097: *
098: * @param expression a expression to be watched
099: */
100: public void setExpression(String expression) {
101: watch.setExpression(expression);
102: }
103:
104: /**
105: * Remove the watch from the list of all watches in the system.
106: */
107: public void remove() {
108: watch.remove();
109: }
110:
111: /**
112: * Returns description of problem is this watch can not be evaluated
113: * in current context.
114: *
115: * @return description of problem
116: */
117: public String getExceptionDescription() {
118: return exceptionDescription;
119: }
120:
121: /**
122: * Sets string representation of value of this variable.
123: *
124: * @param value string representation of value of this variable.
125: *
126: public void setValue (String expression) throws InvalidExpressionException {
127: // evaluate expression to Value
128: Value value = model.getDebugger ().evaluateIn (expression);
129: // set new value to remote veriable
130: setValue (value);
131: // set new value to this model
132: setInnerValue (value);
133: // refresh tree
134: model.fireTableValueChangedChanged (this, null);
135: }
136: */
137:
138: protected void setValue(final Value value)
139: throws InvalidExpressionException {
140:
141: // 1) get frame
142: CallStackFrameImpl frame = (CallStackFrameImpl) debugger
143: .getCurrentCallStackFrame();
144: if (frame == null)
145: throw new InvalidExpressionException("No curent frame.");
146:
147: // 2) try to set as a local variable value
148: try {
149: LocalVariable local = frame
150: .getLocalVariable(getExpression());
151: if (local != null) {
152: if (local instanceof Local) {
153: ((Local) local).setValue(value);
154: } else {
155: ((ObjectLocalVariable) local).setValue(value);
156: }
157: return;
158: }
159: } catch (AbsentInformationException ex) {
160: // no local variable visible in this case
161: }
162:
163: // 3) try tu set as a field
164: ObjectReference this Object = frame.getStackFrame().this Object();
165: if (this Object == null)
166: throw new InvalidExpressionException(
167: "Can not set value to expression.");
168: Field field = this Object.referenceType().fieldByName(
169: getExpression());
170: if (field == null)
171: throw new InvalidExpressionException(
172: "Can not set value to expression.");
173: try {
174: this Object.setValue(field, value);
175: } catch (InvalidTypeException ex) {
176: throw new InvalidExpressionException(ex);
177: } catch (ClassNotLoadedException ex) {
178: throw new InvalidExpressionException(ex);
179: }
180: }
181:
182: protected void setInnerValue(Value v) {
183: super .setInnerValue(v);
184: exceptionDescription = null;
185: }
186:
187: void setException(String exceptionDescription) {
188: super .setInnerValue(null);
189: this .exceptionDescription = exceptionDescription;
190: }
191:
192: boolean isPrimitive() {
193: return !(getInnerValue() instanceof ObjectReference);
194: }
195:
196: public JPDAObjectWatchImpl clone() {
197: JPDAObjectWatchImpl clon;
198: if (exceptionDescription == null) {
199: clon = new JPDAObjectWatchImpl(getDebugger(), watch,
200: getJDIValue());
201: } else {
202: clon = new JPDAObjectWatchImpl(getDebugger(), watch,
203: exceptionDescription);
204: }
205: return clon;
206: }
207:
208: }
|