dcd372e0438b12e5f3bd668a21a2152258289c4d
[phpeclipse.git] /
1 /**********************************************************************
2 Copyright (c) 2000, 2002 IBM Corp. and others.
3 All rights reserved. This program and the accompanying materials
4 are made available under the terms of the Common Public License v1.0
5 which accompanies this distribution, and is available at
6 http://www.eclipse.org/legal/cpl-v10.html
7
8 Contributors:
9         IBM Corporation - Initial implementation
10         Vicente Fernando - www.alfersoft.com.ar
11 **********************************************************************/
12 package net.sourceforge.phpdt.internal.debug.core.model;
13
14 import java.util.Arrays;
15 import java.util.Vector;
16
17 import net.sourceforge.phpdt.internal.debug.core.PHPDBGProxy;
18
19 import org.eclipse.debug.core.DebugEvent;
20 import org.eclipse.debug.core.DebugException;
21 import org.eclipse.debug.core.DebugPlugin;
22 import org.eclipse.debug.core.ILaunch;
23 import org.eclipse.debug.core.model.IDebugTarget;
24 import org.eclipse.debug.core.model.IRegisterGroup;
25 import org.eclipse.debug.core.model.IStackFrame;
26 import org.eclipse.debug.core.model.IThread;
27 import org.eclipse.debug.core.model.IVariable;
28
29 /**
30  *
31  * TODO Remove the variables array and use only the varList vector
32  *      Have also to change hasVariables
33  */
34 public class PHPStackFrame extends PHPDebugElement implements IStackFrame, Comparable{
35
36         private PHPThread               thread;                         // The thread to which this stackframe belongs
37         private String                  file;               // The file name???
38         private int                     lineNumber;         //
39         private int                     index;              //
40         private int                     modno;              //
41         private PHPVariable[]   variables;          // The array of variables TODO: better introduce a vector?
42         private Vector          varList  = new Vector ();
43         private String                  description;        // The source file name with the full path on target/remote system
44         private boolean         fUpToDate;          // Indicates whether the variable list within this stackframe is
45                                                                                                 // up-to-date
46         private boolean         fAvailable;         // Needed when updating the stackframe list, shows whether the stackframe
47                                                                                                 // is within the list which was received from dbg
48
49         /**
50          *
51          * @param thread
52          * @param file
53          * @param line
54          * @param index
55          * @param desc
56          * @param modno
57          */
58         public PHPStackFrame (PHPThread thread, String file, int line, int index, String desc, int modno) {
59                 super (null);
60
61                 this.lineNumber  = line;
62                 this.index           = index;
63                 this.file            = file;
64                 this.thread      = thread;
65                 this.description = desc;
66                 this.modno               = modno;
67                 this.fUpToDate   = false;
68         }
69
70         /**
71          *
72          * @param thread
73          * @param file
74          * @param line
75          * @param index
76          */
77         public PHPStackFrame (PHPThread thread, String file, int line, int index) {
78                 super (null);
79
80                 this.lineNumber = line;
81                 this.index              = index;
82                 this.file               = file;
83                 this.thread     = thread;
84                 this.fUpToDate  = false;
85         }
86
87         /**
88          *
89          */
90         public IThread getThread () {
91                 return thread;
92         }
93
94         /**
95          * @param thread
96          */
97         public void setThread (PHPThread thread) {
98                 this.thread = thread;
99         }
100
101         /**
102          *
103          */
104         private void setUpToDate (boolean upToDate) {
105                 fUpToDate = upToDate;
106         }
107
108         /**
109          *
110          */
111         private boolean isUpToDate () {
112                 return fUpToDate;
113         }
114
115         /**
116          *
117          */
118         public void setAvailable (boolean available) {
119                 fAvailable = available;
120         }
121
122         /**
123          *
124          */
125         public boolean isAvailable () {
126                 return fAvailable;
127         }
128
129
130         /**
131          * @see IAdaptable#getAdapter(Class)
132          */
133         public Object getAdapter(Class adapter) {
134                 if (adapter == PHPStackFrame.class) {
135                         return this;
136                 }
137
138                 return super.getAdapter(adapter);
139         }
140
141         /**
142          *
143          *
144          */
145         private void resetHasChangedInfo (Vector varList) {
146                 int             n;
147                 PHPVariable var;
148                 PHPValue    val;
149
150                 for (n = 0; n < varList.size (); n++) {                  // For every variable in 'DBG list'
151                         var = (PHPVariable) varList.get (n);                    // Get the variable
152                         val = (PHPValue) var.getValue ();                       // Get the variable's value
153
154                         try {
155                                 if (val.hasVariables ()) {                              // Do we have other variables within the value
156                                         if (!hasRecursion (var)) {                          // Is this variable (value) branch recursive?
157                                                 resetHasChangedInfo (val.getChildVariables ()); //  No, go into branch
158                                         }
159                                 }
160                         }
161                         catch (DebugException e) {                                                  // That's, because of the hasVariables method
162                         }
163
164                         var.setValueChanged (false);                            // Reset the 'has changed' flag
165                 }
166         }
167
168         /**
169          * Go up the tree of PHPVariables
170          * look whether the PHPValue is a reference to a parent PHPValue
171          *
172          * TODO Check where this recursion can come from.
173          * Whether this back reference is legal or a bug.
174          *
175          * @param var
176          * @return
177          * <ul>
178          * <li> false if the PHPValue is not a child of itself
179          * <li> true if the PHPValue is
180          * </ul>
181          */
182         private boolean hasRecursion (PHPVariable var) {
183                 PHPVariable parentVar;
184                 PHPValue    val;
185
186                 val = (PHPValue) var.getValue ();                                                       // Get the PHPValue from the current PHPVariable
187
188                 while (var != null) {                                                                           // As long as we have PHPVariable
189                         parentVar = var.getParent ();                                                   // Get the parent PHPVariable
190
191                         if (parentVar != null) {                                // Is there a parent?
192                                 if (parentVar.getValue ().equals (val)) {                       // Get the PHPValue for the parent PHPVariable and check
193                                                                                                                                         // whether it is the same
194                                         return true;                                                                    // Return, if we have recursion
195                                 }
196                         }
197
198                         var = parentVar;
199                 }
200
201                 return false;                                                                                           // No recursion found
202         }
203
204         /**
205          * This method updates the 'static' variables list.
206          * It does a replication between the 'static' list (the variable list which
207          * is a member of this DBG interface object) and the DBG variable list
208          * (the list of variables which is received from PHP via DBG with the current suspend)
209          * Replication is done in the following way:
210          * <ul>
211          * <li> It looks for new variables within the DBG variables list and
212          *      adds them to the 'static' list.
213          * <li> It looks for changed variables copies the current value to the variable within
214          *              the 'static list' and mark these variables as 'hasChanged' (which uses the UI
215          *              for showing the variable with a different color).
216          * <li> It looks for variables within the 'static' list, and removes them
217          *              from the 'static' list in case the do not appear within the DBG list.
218          * </ul>
219          *
220          * @param varListOld The 'static' list of variables which are to be updated.
221          * @param varListNew The new list of (current) variables from DBG.
222          */
223         private void updateVariableList (Vector varListOld, Vector varListNew)
224         {
225                 PHPVariable     varOld;                                                                                 // The variable from the 'static' list
226                 PHPVariable varNew;                                                                                     // The variable from the DBG list
227                 PHPValue    valOld;                                                                                     // The value of the current variable from 'static' list
228                 PHPValue    valNew;                                                                                     // The value of the current variable from DBG list
229                 int         n;                                                                                          // Index for the DBG list
230                 int         o;                                                                                          // Index for the static list
231
232                 // Add the variables (and childs) to the static list if they are new
233                 //  and update the values of variables which are already existend within
234                 //  the 'static' list.
235
236                 for (n = 0; n < varListNew.size (); n++) {                  // For every variable in 'DBG list'
237                         varNew = (PHPVariable) varListNew.get (n);                              // Get the DBG variable
238
239                         for (o = 0; o < varListOld.size (); o++) {                              // For every variable in static list
240                                 varOld = (PHPVariable) varListOld.get (o);                      // Get the static variable
241
242                                 if (varNew.getName ().equals (varOld.getName ())) { // Did we found the variable within the 'static' list?
243                                         valOld = (PHPValue) varOld.getValue ();         // Get the value from 'static'
244                                         valNew = (PHPValue) varNew.getValue ();         // Get the value from DBG
245
246                                         try {
247                                                 if (valOld.hasVariables () ||                           // If the 'static' value has child variables
248                                                         valNew.hasVariables ()) {                               //  or if the DBG value has child variables
249                                                         if (!hasRecursion (varOld) &&
250                                                                 !hasRecursion (varNew)) {                       // Both branches should not have a recursion
251                                                                 updateVariableList (valOld.getChildVariables (),        // Update the variable list for the child variables
252                                                                                                         valNew.getChildVariables ());
253                                                         }
254                                                 }
255                                                 else if (!valOld.getValueString ().equals (valNew.getValueString ())) { // Has the value changed?
256                                                         valOld.setValueString (valNew.getValueString ());                   // Yes, set the 'static' value (variable) to the new value
257                                                         varOld.setValueChanged (true);                                                                          // and set the 'has changed' flag, so that the variable view
258                                                                                                                                                                                                 // could show the user the changed status with a different
259                                                                                                                                                                                                 // color
260                                                 }
261                                                 //else {
262                                                 //      varOld.setValueChanged (false);                                     // Reset the 'has changed' flag
263                                                 //}
264                                         }
265                                         catch (DebugException e) {                                                  // That's, because of the hasVariables method
266                                         }
267
268                                         break;                                          // Found the variable,
269                                 }
270                         }
271
272                         if (o == varListOld.size ()) {                          // Did we found the variable within the static list?
273                                 varListOld.add (varNew);                                                        //  No, then add the DBG variable to the static list
274                         }
275                 }
276
277                 // Look for the variables we can remove from the 'static' list
278
279                 for (o = 0; o < varListOld.size (); o++) {                                              // For every variable in 'static' list
280                         varOld = (PHPVariable) varListOld.get (o);                                                      // Get the static variable
281
282                         for (n = 0; n < varListNew.size (); n++) {                                                      // For all variables in 'DBG' list
283                                 varNew = (PHPVariable) varListNew.get (n);                                              // Get the variable from the 'DBG' list
284
285                                 if (varNew.getName ().equals (varOld.getName ())) {                     // Did we found the 'static' list variable within the 'DBG' list?
286                                         break;                                                                                                          // Yes we found the variable, then leave the loop
287                                 }
288                         }
289
290                         if (n == varListNew.size ()) {                                          // Did not find the 'static' list variable within the 'DBG' list?
291                                  varListOld.remove (o);                                         // then remove the 'static' list variable from list
292                                  o -= 1;                                                        // Adjust the 'static' list index
293                         }
294                 }
295         }
296
297
298         /**
299          *
300          * This function returns the array of PHPVariables for this stackframe
301          * The PHPVariables should not change (newly build up) between two steps
302          * (or breaks).
303          * A PHPVariable with the same name but with different object ID is
304          * handled as a new variable.
305          *
306          * TODO Remove the intermediate storage array
307          *
308          * @return The array of PHPVariables for this stackframe.
309          */
310         public IVariable[] getVariables() throws DebugException {
311                 if (!isUpToDate ()) {
312                         resetHasChangedInfo (varList);
313                         updateVariableList (varList, this.getPHPDBGProxy ().readVariables (this));
314                         setUpToDate (true);
315
316                         variables = (PHPVariable[]) varList.toArray (new PHPVariable[varList.size ()]);
317                         Arrays.sort(variables, new PHPVariableComparator());
318                 }
319
320                 return variables;                                           // Give the array back to user interface
321         }
322
323         /**
324          *
325          */
326         private PHPVariable findVariable (Vector varList, String varname) {
327                 PHPVariable     variable;
328                 PHPValue        value;
329                 int                     i;
330
331                 for (i = 0; i < varList.size (); i++) {                                         // For all variables
332                         variable = (PHPVariable) varList.get (i);                               // Get the variable
333                         value    = (PHPValue) variable.getValue ();                             // Get the value of the variable
334
335                         try {
336                                 if (value.hasVariables ()) {                                            // Does the variable/value have children
337                                         if (!hasRecursion (variable)) {                                 // Don't follow recursive variable/values
338                                                 variable = findVariable (value.getChildVariables (), varname);
339
340                                                 if (variable != null) {
341                                                         return variable;
342                                                 }
343                                         }
344                                 }
345                                 else if ((variable.getName ()).equals (varname)) {      //
346                                         return variable;                                                                //
347                                 }
348                         }
349                         catch (DebugException e) {                                                              // That's, because of the hasVariables method
350                         }
351                 }
352
353                 return null;
354         }
355
356         /**
357          * This method is called from the UI (e.g. from PHPDebugHover
358          * to find the variable the mouse is pointing to)
359          *
360          * @param s The variable name we are looking for.
361          * @return
362          */
363         public IVariable findVariable (String s) throws DebugException {
364                 if (!isUpToDate ()) {
365                         resetHasChangedInfo (varList);
366                         updateVariableList (varList, this.getPHPDBGProxy ().readVariables (this));
367                         setUpToDate (true);
368
369                         variables = (PHPVariable[]) varList.toArray (new PHPVariable[varList.size ()]);
370                 }
371
372                 return (findVariable (varList, s));                                                     // Prefix the variable name with $
373         }
374
375         /**
376          *
377          */
378         public boolean hasVariables () throws DebugException {
379                 return true;
380                 // return (varList.size () > 0);
381         }
382
383         public int getLineNumber() {
384                 return lineNumber;
385         }
386
387         public void setLineNumber(int line) {
388                 lineNumber = line;
389         }
390
391         public int getCharStart() throws DebugException {
392                 // not supported
393                 return -1;
394         }
395
396         public int getCharEnd() throws DebugException {
397                 // not supported
398                 return -1;
399         }
400
401         public String getName() {
402                 StringBuffer name = new StringBuffer();
403
404                 if (!this.getDescription().equals ("")) {
405                         name.append (this.getDescription ());
406                 }
407                 else {
408                         name.append (this.getFileName ());
409                 }
410
411                 name.append (" [line ");
412                 name.append (this.getLineNumber ());
413                 name.append ("]");
414
415                 return name.toString();
416         }
417
418         public String getFileName() {
419                 return file;
420         }
421
422         public void setDescription(String desc) {
423                 this.description= desc;
424         }
425
426         public String getDescription() {
427                 return this.description;
428         }
429
430         public IRegisterGroup[] getRegisterGroups() throws DebugException {
431                 return null;
432         }
433
434         public boolean hasRegisterGroups() throws DebugException {
435                 return false;
436         }
437
438         public String getModelIdentifier() {
439                 return this.getThread().getModelIdentifier();
440         }
441
442         public IDebugTarget getDebugTarget() {
443                 return this.getThread().getDebugTarget();
444         }
445
446         public ILaunch getLaunch() {
447                 return this.getDebugTarget().getLaunch();
448         }
449
450         public boolean canStepInto() {
451                 return canResume();
452         }
453
454         public boolean canStepOver() {
455                 return canResume();
456         }
457
458         public boolean canStepReturn() {
459                 return canResume();
460         }
461
462         public boolean isStepping() {
463                 return false;
464         }
465
466         /**
467          *
468          */
469         public void stepInto () throws DebugException {
470                 DebugEvent      ev;
471
472                 setUpToDate (false);
473
474                 thread.prepareForResume (DebugEvent.STEP_INTO);             // Don't know why, but this is necessary
475                 this.getPHPDBGProxy ().readStepIntoEnd (PHPStackFrame.this);
476                 
477         // Commented out sending the RESUME event because it was already sent by prepareForResume.
478         // The second RESUME event leads only to a little flickering within the variables view.
479         // It is also not clear why this event was necessary in eclipse < 3.2
480         // Also sending a SUSPEND event here leads to a total rebuild of the variables view.
481         // (eclipse 3.2 has a build in timeout of 500 ms which leads to a auto suspend, with
482         // no flickering... but why???)
483         // 
484                 //ev = new DebugEvent (this.getThread (), DebugEvent.RESUME, DebugEvent.STEP_INTO);
485                 //DebugPlugin.getDefault().fireDebugEventSet (new DebugEvent[] { ev });
486         }
487
488         /**
489          *
490          */
491         public void stepOver () throws DebugException {
492                 DebugEvent      ev;
493
494                 setUpToDate (false);
495
496                 thread.prepareForResume (DebugEvent.STEP_OVER);
497                 this.getPHPDBGProxy ().readStepOverEnd (PHPStackFrame.this) ;
498
499         // See comment within the previous stepInto method.
500         // 
501                 //ev = new DebugEvent (this.getThread (), DebugEvent.RESUME, DebugEvent.STEP_OVER);
502                 //DebugPlugin.getDefault ().fireDebugEventSet (new DebugEvent[] { ev });
503         }
504
505         /**
506          *
507          */
508         public void stepReturn () throws DebugException {
509                 DebugEvent      ev;
510
511                 setUpToDate (false);
512
513                 thread.prepareForResume (DebugEvent.STEP_RETURN);
514                 this.getPHPDBGProxy ().readStepReturnEnd (PHPStackFrame.this) ;
515
516                 ev = new DebugEvent (this.getThread (), DebugEvent.RESUME, DebugEvent.STEP_RETURN);
517                 DebugPlugin.getDefault ().fireDebugEventSet (new DebugEvent[] { ev });
518         }
519
520
521         public boolean canResume() {
522                 return this.getThread().canResume();
523         }
524
525         public boolean canSuspend() {
526                 return this.getThread().canSuspend();
527         }
528
529         public boolean isSuspended() {
530                 return this.getThread().isSuspended();
531         }
532
533         public void resume() throws DebugException {
534                 setUpToDate (false);
535                 this.getThread().resume();
536         }
537
538         public void suspend() throws DebugException {
539         }
540
541         public boolean canTerminate() {
542                 return this.getThread().canTerminate();
543         }
544
545         public boolean isTerminated() {
546                 return this.getThread().isTerminated();
547         }
548
549         public void terminate() throws DebugException {
550                 getPHPDBGProxy().stop();
551         }
552
553         public int getIndex() {
554                 return index;
555         }
556
557         public void setIndex (int index) {
558                 this.index = index;
559         }
560
561         public PHPDBGProxy getPHPDBGProxy() {
562                 PHPDebugTarget DebugTarget;
563
564                 DebugTarget = (PHPDebugTarget) thread.getDebugTarget ();
565
566                 return DebugTarget.getPHPDBGProxy ();
567         }
568
569         public void setFile(String file) {
570                 this.file = file;
571         }
572
573         public int getModNo() {
574                 return modno;
575         }
576
577         /**
578          * This function is needed when sorting the stackframes by their index numbers.
579          *
580          * @param obj The stackframe which this one is compared to.
581          * @return
582          * <ul>
583          * <li> -1 if the index of this stackframe is less.
584          * <li> 0 if the index of both stackfream is equal (should no happen).
585          * <li> 1 if the index of this stackfram is greater.
586          * </ul>
587          */
588         public int compareTo (Object obj)
589         {
590                 if (index < ((PHPStackFrame) obj).getIndex ()) {
591                         return -1;
592                 }
593                 else if (index > ((PHPStackFrame) obj).getIndex ()) {
594                         return 1;
595                 }
596
597                 return 0;
598         }
599 }