git.phpeclipse.com Git - phpeclipse.git/blob

   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         Vicente Fernando - www.alfersoft.com.ar - Initial implementation
  10         Christian Perkonig - remote debug
  11 **********************************************************************/
  12 package net.sourceforge.phpdt.internal.debug.core;
  13
  14 import java.io.BufferedReader;
  15 import java.io.IOException;
  16 import java.io.OutputStream;
  17 import java.util.Vector;
  18 import java.util.Collections;
  19
  20 import net.sourceforge.phpdt.internal.debug.core.model.PHPDBGEvalString;
  21 import net.sourceforge.phpdt.internal.debug.core.model.PHPStackFrame;
  22 import net.sourceforge.phpdt.internal.debug.core.model.PHPVariable;
  23 import net.sourceforge.phpdt.internal.debug.core.model.PHPValue;
  24
  25 import org.eclipse.core.runtime.IStatus;
  26 import org.eclipse.core.runtime.Status;
  27 import org.eclipse.debug.core.DebugException;
  28
  29 /**
  30  * The interface object are created by the proxy
  31  *
  32  */
  33 public class PHPDBGInterface {
  34
  35         public boolean                  sessionEnded = false;
  36         public int                              sessType         = -1;
  37         public int                              BPUnderHit       = 0;
  38         public String                   sessID           = new String ();
  39
  40         private int[]                   LastBPRead   = new int[10];
  41         private Vector                  DBGBPList    = new Vector ();
  42         private Vector          DBGVarList   = new Vector ();
  43         private PHPStackFrame[] DBGStackList;
  44         private Vector                  DBGMods          = new Vector ();                       // The module names and their numbers
  45         private Vector          stackListOld = new Vector ();
  46         private BufferedReader  in;
  47         private OutputStream    os;                                                                             // The stream which goes to DBG
  48         private boolean                 shouldStop       = false;
  49         private String                  evalRet          = new String ("");
  50         private String                  serGlobals       = new String ("");
  51         private int                     rawCounter       = 1000;                                        // An rawData frame ID counter
  52         private PHPDBGProxy     proxy            = null;
  53         private int                     lastCmd          = -1;
  54         private int                     sid                      = 0;
  55         private boolean                 stopOnError      = false;
  56         private char[]                  lastCommand      = new char[4];
  57
  58         /**
  59          * @param in    The input stream (communication from DBG).
  60          * @param os    The output stream (communication to DBG).
  61          * @param proxy The proxy to which this interface belongs.
  62          */
  63         public PHPDBGInterface (BufferedReader in, OutputStream os, PHPDBGProxy proxy) {
  64                 DBGBPList.clear ();
  65
  66                 this.in         = in;
  67                 this.os         = os;
  68                 this.proxy      = proxy;
  69         }
  70
  71         /**
  72          *
  73          * @param mod_name The module (source file) to which we add the breakpoint.
  74          * @param line     The line where the breakpoint is set.
  75          * @return         Breakpoint ID ???.
  76          */
  77         public int addBreakpoint (String mod_name, int line) throws IOException {
  78                 return setBreakpoint (mod_name, "", line, PHPDBGBase.BPS_ENABLED + PHPDBGBase.BPS_UNRESOLVED, 0, 0, 0, 0, 0);
  79         }
  80
  81         /**
  82          *
  83          * @param mod_name The module (source file) to which we add the breakpoint.
  84          * @param line     The line where the breakpoint is set.
  85          * @param bpNo     The breakpoint ID ???.
  86          */
  87         public void removeBreakpoint (String mod_name, int line, int bpNo) throws IOException {
  88                 setBreakpoint (mod_name, "", line, PHPDBGBase.BPS_DISABLED, 0, 0, 0, bpNo, 0);
  89         }
  90
  91         /**
  92          * Is this method used anywhere?
  93          *
  94          */
  95         public void requestDBGVersion () throws IOException {
  96                 PHPDBGPacket DBGPacket;                                     // A DBG message packet
  97                 PHPDBGFrame  DBGFrame;                                      // A frame within a DBG packet
  98
  99                 DBGPacket = new PHPDBGPacket (PHPDBGBase.DBGA_REQUEST);     // A request for DBG
 100                 DBGFrame  = new PHPDBGFrame (PHPDBGBase.FRAME_VER);         // We want the version of DBG
 101
 102                 DBGPacket.addFrame (DBGFrame);                              // Add the 'what we want' to the DBG packet
 103
 104                 if (proxy.getSocket ().isClosed ()) {                                           // Can we communiate with DBG?
 105                         return;                                                 //  No
 106                 }
 107
 108                 DBGPacket.sendPacket (os);                                                                      // Send the request to DBG
 109         }
 110
 111         /**
 112          * Called by the proxy
 113          *
 114          */
 115         public void getSourceTree () throws IOException {
 116                 PHPDBGPacket DBGPacket;                                     // A DBG message packet
 117                 PHPDBGFrame  DBGFrame;                                      // A frame within a DBG packet
 118
 119                 DBGPacket = new PHPDBGPacket (PHPDBGBase.DBGA_REQUEST);     // A request for DBG
 120                 DBGFrame  = new PHPDBGFrame (PHPDBGBase.FRAME_SRC_TREE);        // We want a source tree from DBG
 121
 122                 DBGPacket.addFrame (DBGFrame);                              // Add the 'what we want' to the DBG packet
 123
 124                 if (proxy.getSocket ().isClosed ()) {                                           // Can we communiate with DBG?
 125                         return;                                                                                                 //  No
 126                 }
 127
 128                 DBGPacket.sendPacket (os);                                  // Send the request to DBG
 129
 130                 waitResponse (1000);                                        // Wait for the DBG response (1 second)
 131                 flushAllPackets ();                                                                             // Read and process the response from DBG
 132         }
 133
 134         /**
 135          * Is this method called from anywhere?
 136          *
 137          * @param modName The modul (filename).
 138          */
 139         public void addDBGModName (String modName) throws IOException {
 140                 PHPDBGPacket DBGPacket;                                     // A DBG message packet
 141                 PHPDBGFrame  DBGFrame;                                      // A frame within a DBG packet
 142
 143                 DBGPacket = new PHPDBGPacket (PHPDBGBase.DBGA_REQUEST);     // A request for DBG
 144                 DBGFrame  = new PHPDBGFrame (PHPDBGBase.FRAME_RAWDATA);     // We want Module name from DBG
 145
 146                 rawCounter++;                                               // Increment the rawData ID counter
 147                 DBGFrame.addInt (rawCounter);                                                           // FRAME_RAWDATA ID
 148                 DBGFrame.addInt (modName.length () + 1);                                        // The length of rawdata string (incl. null char termination)
 149                 DBGFrame.addString (modName);                                                           // The file name (module name)
 150                 DBGFrame.addChar ('\0');                                                                        // Add the C-String null termination
 151
 152                 DBGPacket.addFrame (DBGFrame);
 153
 154                 if (proxy.getSocket ().isClosed ()) {                                           // Can we communiate with DBG?
 155                         return;                                                                                                 //  No
 156                 }
 157
 158                 DBGPacket.sendPacket (os);
 159         }
 160
 161         /**
 162          * This method is called for adding or removing breakpoints.
 163          *
 164          * @param mod_name      The module name (file name).
 165          * @param condition     Info about the condition when to break (not used at the moment).
 166          * @param line          The breakpoints line.
 167          * @param state         Info whether this breakpoint has to be dis- or enabled.
 168          * @param istep         Always 0.
 169          * @param hitcount      Always 0.
 170          * @param skiphits      Always 0.
 171          * @param bpno          The breakpoint ID.
 172          * @param isunderhit    ???
 173          * @return
 174          */
 175         private int setBreakpoint (String mod_name, String condition, int line, int state, int istemp, int hitcount, int skiphits, int bpno, int isunderhit) throws IOException {
 176                 PHPDBGPacket    DBGPacket;
 177                 PHPDBGFrame     DBGFrame1;
 178                 PHPDBGFrame     DBGFrame2;
 179                 int                     modNo;
 180
 181                 DBGPacket       = new PHPDBGPacket (PHPDBGBase.DBGA_REQUEST);
 182                 DBGFrame1       = new PHPDBGFrame (PHPDBGBase.FRAME_BPS);
 183                 DBGFrame2       = new PHPDBGFrame (PHPDBGBase.FRAME_RAWDATA);
 184
 185                 modNo           = getModByName (mod_name);                                              // Get the module ID by name
 186
 187                 if (modNo >= 0) {                                           // Did we find a module ID for the module name?
 188                         DBGFrame1.addInt (modNo);                                                               // Add the module ID to frame 1
 189                 } else {
 190                         DBGFrame1.addInt (0);                                                                   // mod number (0 use file name)
 191                 }
 192
 193                 DBGFrame1.addInt (line);                                                                        // line number
 194
 195                 if (modNo >= 0) {                                           // Did we find a module ID for the module name?
 196                         DBGFrame1.addInt (0);                                                                   // use mod number
 197                 } else {
 198                         rawCounter++;
 199                         DBGFrame1.addInt (rawCounter);                                                  // ID of FRAME_RAWDATA to send file name
 200                 }
 201
 202                 DBGFrame1.addInt (state);                                       // state BPS_*
 203                 DBGFrame1.addInt (istemp);                                      // istep
 204                 DBGFrame1.addInt (hitcount);                                // hit count
 205                 DBGFrame1.addInt (skiphits);                                // skip hits
 206                 DBGFrame1.addInt (0);                                           // ID of condition
 207                 DBGFrame1.addInt (bpno);                                            // breakpoint number
 208                 DBGFrame1.addInt (isunderhit);                                  // is under hit
 209
 210                 if (modNo < 0) {                                            // Did we find a module ID for the module name?
 211                         DBGFrame2.addInt (rawCounter);                                      // FRAME_RAWDATA ID
 212                         DBGFrame2.addInt (mod_name.length() + 1);                   // length of rawdata (+ null char)
 213                         DBGFrame2.addString (mod_name);                                     // file name
 214                         DBGFrame2.addChar ('\0');                                                   // null char
 215
 216                         DBGPacket.addFrame (DBGFrame2);                         // First add file name data
 217                 }
 218
 219                 DBGPacket.addFrame (DBGFrame1);                                                         // Second add command data
 220
 221                 if (proxy.getSocket ().isClosed ()) {                                           // Can we communiate with DBG?
 222                         return 0;                                               //  No
 223                 }
 224
 225                 DBGPacket.sendPacket (os);                                  // Send the request to DBG
 226
 227                 clearLastBP ();
 228
 229                 waitResponse (1000);                                        // Wait for the DBG response (1 second)
 230                 flushAllPackets ();                                         // Read and process the response from DBG
 231
 232                 return LastBPRead[8];                                                                           // Return what ???
 233         }
 234
 235         /**
 236          *
 237          */
 238         private void clearLastBP () {
 239                 int i;
 240
 241                 for (i = 0; i < LastBPRead.length; i++) {
 242                         LastBPRead[i] = 0;
 243                 }
 244         }
 245
 246         /**
 247          *
 248          */
 249         private void copyToLastBP (int[] BPBody) {
 250                 int i;
 251
 252                 for (i = 0; i < LastBPRead.length; i++) {
 253                         LastBPRead[i] = BPBody[i];
 254                 }
 255         }
 256
 257         /**
 258          *
 259          */
 260         public void continueExecution () throws IOException {
 261                 PHPDBGPacket DBGPacket;
 262
 263                 BPUnderHit = 0;
 264                 DBGPacket  = new PHPDBGPacket (PHPDBGBase.DBGA_CONTINUE);
 265
 266                 if (proxy.getSocket ().isClosed ()) {                                           // Can we communiate with DBG?
 267                         return;                                                 //  No
 268                 }
 269
 270                 DBGPacket.sendPacket (os);                                  // Send the request to DBG
 271
 272                 lastCommand = PHPDBGBase.DBGA_CONTINUE;                     // Store the info about the command we sent
 273         }
 274
 275         /**
 276          *
 277          */
 278         public void pauseExecution () throws IOException {
 279                 PHPDBGPacket DBGPacket;
 280
 281                 DBGPacket = new PHPDBGPacket (PHPDBGBase.IntToChar4 (PHPDBGBase.DBGC_PAUSE));
 282
 283                 if (proxy.getSocket ().isClosed ()) {                                           // Can we communiate with DBG?
 284                          return;                                                //  No
 285                 }
 286
 287                 DBGPacket.sendPacket (os);                                  // Send the request to DBG
 288         }
 289
 290         /**
 291          *
 292          */
 293         private int getBPUnderHit () {
 294                 int i;
 295                 int BPUnder             = 0;
 296                 int[] dbg_bpl_body      = new int[10];
 297
 298                 for (i = 0; i < DBGBPList.size (); i++) {                               // look for bp under hit
 299                         dbg_bpl_body = (int[]) DBGBPList.get (i);
 300
 301                         if (dbg_bpl_body[9] == 1) {
 302                                 BPUnder = dbg_bpl_body[8];
 303                         }
 304                 }
 305
 306                 return BPUnder;
 307         }
 308
 309         public int getLastCmd()
 310         {
 311                 return lastCmd;
 312         }
 313
 314         public int getSID()
 315         {
 316           return sid;
 317         }
 318
 319         public void setLastCmd (int cmd)
 320         {
 321                 lastCmd = cmd;
 322         }
 323
 324         /**
 325          *
 326          */
 327         public void stepInto () throws IOException {
 328                 PHPDBGPacket DBGPacket;
 329
 330                 BPUnderHit = 0;
 331                 DBGPacket  = new PHPDBGPacket (PHPDBGBase.DBGA_STEPINTO);
 332
 333                 if (proxy.getSocket ().isClosed ()) {                                           // Can we communiate with DBG?
 334                         return;                                                 //  No
 335                 }
 336
 337                 DBGPacket.sendPacket (os);                                  // Send the request to DBG
 338
 339                 lastCommand = PHPDBGBase.DBGA_STEPINTO;                                         // Store the info about the command we sent
 340         }
 341
 342         /**
 343          *
 344          */
 345         public void stepOver () throws IOException {
 346                 PHPDBGPacket DBGPacket;
 347
 348                 BPUnderHit = 0;
 349                 DBGPacket  = new PHPDBGPacket (PHPDBGBase.DBGA_STEPOVER);
 350
 351                 if (proxy.getSocket ().isClosed ()) {                                           // Can we communiate with DBG?
 352                         return;                                                 //  No
 353                 }
 354
 355                 DBGPacket.sendPacket (os);                                  // Send the request to DBG
 356
 357                 lastCommand = PHPDBGBase.DBGA_STEPOVER;                     // Store the info about the command we sent
 358         }
 359
 360         /**
 361          *
 362          */
 363         public void stepOut () throws IOException {
 364                 PHPDBGPacket DBGPacket;
 365
 366                 BPUnderHit = 0;
 367                 DBGPacket  = new PHPDBGPacket (PHPDBGBase.DBGA_STEPOUT);
 368
 369                 if (proxy.getSocket ().isClosed ()) {                                           // Can we communiate with DBG?
 370                         return;                                                 //  No
 371                 }
 372
 373                 DBGPacket.sendPacket (os);                                  // Send the request to DBG
 374
 375                 lastCommand = PHPDBGBase.DBGA_STEPOUT;                      // Store the info about the command we sent
 376         }
 377
 378         /**
 379          *
 380          */
 381         public void stopExecution () throws IOException {
 382                 PHPDBGPacket DBGPacket;
 383
 384                 BPUnderHit = 0;
 385                 DBGPacket  = new PHPDBGPacket (PHPDBGBase.DBGA_STOP);
 386
 387                 if (proxy.getSocket ().isClosed ()) {                                           // Can we communiate with DBG?
 388                         return;                                                 //  No
 389                 }
 390
 391                 DBGPacket.sendPacket (os);                                  // Send the request to DBG
 392         }
 393
 394         /**
 395          * This method is called by the proxy.
 396          * It sends a request to DBG to get the current variables
 397          * with their values. It waits for the response and processes
 398          * the input from DBG.
 399          *
 400          * @param stack The stackframe for which we want the variables.
 401          * @return      The array of variables
 402          */
 403         public Vector getVariables (PHPStackFrame stack) throws IOException, DebugException  {
 404                 PHPDBGPacket            DBGPacket;
 405                 PHPDBGFrame             DBGFrame1;
 406                 PHPDBGEvalString        evalStr;
 407
 408                 DBGPacket = new PHPDBGPacket (PHPDBGBase.DBGA_REQUEST);     //
 409             DBGFrame1 = new PHPDBGFrame (PHPDBGBase.FRAME_EVAL);        //
 410
 411                 DBGFrame1.addInt (0);                                                                           // istr = raw data ID
 412                 DBGFrame1.addInt (1);                                                                           // scope_id = -1 means current location, 0 never used, +1 first depth
 413
 414                 DBGPacket.addFrame (DBGFrame1);                             // Add command data
 415
 416                 if (proxy.getSocket ().isClosed ()) {                       // Do we have a socket for DBG communication?
 417                         return null;                                                                                    //  No, then leave here
 418                 }
 419
 420                 DBGPacket.sendPacket (os);                                  // Send the request to DBG
 421
 422                 waitResponse (1000);                                        // Wait for the DBG response (1 second)
 423                 flushAllPackets ();                                         // Read and process the response from DBG
 424
 425                 evalStr         = new PHPDBGEvalString (stack, serGlobals); // Process serialized variables
 426                 DBGVarList      = evalStr.getVariables ();
 427
 428                 if (DBGVarList.size () > 0) {                                                           // Did we get back variables?
 429                         PHPVariable var = (PHPVariable) DBGVarList.get (0);             // Yes, then get the first PHPVariable
 430
 431                         if (var.getName ().equals ("")) {                                               // The eclipse variable view cannot handle Variables which have an empty name
 432                                                                                                                                         // when it comes to variable tree restore operation. Without a name, no restore!
 433                                 var.setName (" ");                                                              // Give a name to the variable root node. Even if it is only a space :-)
 434                         }                                                                                                               // TODO the best would be to remove the empty root node, but this would
 435                                                                                                                                         // require a understanding and reworking of the PHPDBGEvalstring class.
 436                 }
 437
 438                 return DBGVarList;                                                                                      // Return the variables as list
 439         }
 440
 441         /**
 442          *
 443          * @param logString
 444          */
 445         public void log(String logString) throws IOException, DebugException  {
 446                 PHPDBGPacket DBGPacket= new PHPDBGPacket(PHPDBGBase.DBGA_REQUEST);
 447                 PHPDBGFrame DBGFrame1= new PHPDBGFrame(PHPDBGBase.FRAME_LOG);
 448                 PHPDBGFrame DBGFrame2= new PHPDBGFrame(PHPDBGBase.FRAME_RAWDATA);
 449
 450                 rawCounter++;
 451                 DBGFrame1.addInt(rawCounter);                           // ilog
 452                 DBGFrame1.addInt(1);                                            // type
 453                 DBGFrame1.addInt(0);                                            // mod_no
 454                 DBGFrame1.addInt(0);                                            // line_no
 455                 DBGFrame1.addInt(0);                                            // imod_name
 456                 DBGFrame1.addInt(0);                                            // ext_info
 457
 458                 DBGFrame2.addInt(rawCounter);                           // FRAME_RAWDATA ID
 459                 DBGFrame2.addInt(logString.length() + 1);       // length of rawdata (+ null char)
 460                 DBGFrame2.addString(logString);                         // log string
 461                 DBGFrame2.addChar('\0');                                        // null char
 462
 463                 // Add raw data first
 464                 DBGPacket.addFrame(DBGFrame2);
 465                 // Add command data
 466                 DBGPacket.addFrame(DBGFrame1);
 467
 468                 if(proxy.getSocket().isClosed()) return;
 469                 DBGPacket.sendPacket(os);
 470
 471                 waitResponse(1000);
 472                 flushAllPackets();
 473         }
 474
 475         public PHPVariable[] evalBlock(PHPStackFrame stack, String evalString) throws IOException, DebugException  {
 476                 PHPDBGPacket DBGPacket= new PHPDBGPacket(PHPDBGBase.DBGA_REQUEST);
 477                 PHPDBGFrame DBGFrame1= new PHPDBGFrame(PHPDBGBase.FRAME_EVAL);
 478                 PHPDBGFrame DBGFrame2= new PHPDBGFrame(PHPDBGBase.FRAME_RAWDATA);
 479
 480                 rawCounter++;
 481                 DBGFrame1.addInt(rawCounter);                           // istr = raw data ID
 482                 DBGFrame1.addInt(1);                                            // scope_id = -1 means current location, 0 never used, +1 first depth
 483
 484                 DBGFrame2.addInt(rawCounter);                           // FRAME_RAWDATA ID
 485                 DBGFrame2.addInt(evalString.length() + 1);      // length of rawdata (+ null char)
 486                 DBGFrame2.addString(evalString);                        // eval block
 487                 DBGFrame2.addChar('\0');                                        // null char
 488
 489                 // Add raw data first
 490                 DBGPacket.addFrame(DBGFrame2);
 491                 // Add command data
 492                 DBGPacket.addFrame(DBGFrame1);
 493
 494                 if(proxy.getSocket().isClosed()) return null;
 495                 DBGPacket.sendPacket(os);
 496
 497                 waitResponse(1000);
 498                 flushAllPackets();
 499
 500                 PHPDBGEvalString evalStr=new PHPDBGEvalString(stack,evalRet);
 501
 502                 return evalStr.getVars();
 503
 504         }
 505
 506         /**
 507          * Read and process everthing we got from DBG
 508          */
 509         public void flushAllPackets () throws IOException {
 510                 while (readResponse() != 0);
 511         }
 512
 513         /**
 514          * Get the modules name by its number
 515          *
 516          * @param modNo The number (id) of the module
 517          * @return      The name of the module
 518          */
 519         public String getModByNo (int modNo) {
 520                 int             i;
 521                 PHPDBGMod       dbg_mod;
 522
 523                 for (i = 0; i < DBGMods.size (); i++) {                         // For all the modules we have within the array
 524                         dbg_mod = (PHPDBGMod) DBGMods.get (i);                      // Get the module
 525
 526                         if (dbg_mod.getNo () == modNo) {                            // Is the module from the array the module we want?
 527                                 return dbg_mod.getName ();                              //  Yes, return the name of the module
 528                         }
 529                 }
 530
 531                 return "";                                                      // If nothing was found return emtpy string
 532         }
 533
 534         /**
 535          *
 536          * @param  modName The name of the module for which we want the ID
 537          * @return
 538          * - The ID of the module
 539          * - -1 if nothing was found
 540          */
 541         private int getModByName (String modName) {
 542                 int             i;
 543                 PHPDBGMod       dbg_mod;
 544
 545                 for (i = 0; i < DBGMods.size (); i++) {                         // For all the modules we have within the array
 546                         dbg_mod = (PHPDBGMod) DBGMods.get (i);                      // Get the module
 547
 548                         if (dbg_mod.getName ().equalsIgnoreCase (modName)) {            // Is the module from the array the module we want?
 549                                 return dbg_mod.getNo ();                                //  Yes, return the name of the module
 550                         }
 551                 }
 552
 553                 return -1;                                                      // If nothing was found return -1
 554         }
 555
 556         /**
 557          * Return the string for the given frame number
 558          *
 559          * @param framesInfo The buffer which is to read
 560          * @param frameNo    The frame number
 561          * @return
 562          */
 563         private String getRawFrameData (char[] framesInfo, int frameNo) {
 564                 int   nextFrame = 0;                                                    // The current read position within the buffer
 565                 int[] dbg_frame = new int[2];                                           // The two frame header numbers
 566
 567                 while (nextFrame < framesInfo.length) {                                 // As long we have something within the buffer
 568                         dbg_frame[0] = PHPDBGBase.Char4ToInt (framesInfo, nextFrame);           // The frame type
 569                         dbg_frame[1] = PHPDBGBase.Char4ToInt (framesInfo, nextFrame + 4);       // The frame size
 570
 571                         nextFrame   += 8;                                                   // The current read position
 572
 573                         if (dbg_frame[1] == 0) {                                            // If frame size is 0
 574                                 return "";                                                      //  return an emtpy string
 575                         }
 576
 577                         switch (dbg_frame[0]) {                                                     // Switch for the frame type
 578                                 case PHPDBGBase.FRAME_RAWDATA:                                                  // The only frame type we are interrested in
 579                                         if (frameNo == PHPDBGBase.Char4ToInt (framesInfo, nextFrame)) {         // Is it correct  number of the frame
 580                                                 int toRead;                                                     //
 581
 582                                                 toRead = PHPDBGBase.Char4ToInt (framesInfo, nextFrame + 4);     // The size of the string
 583
 584                                                 return String.copyValueOf (framesInfo, nextFrame + 8, toRead);  // Copy frame content to String and return
 585                                         }
 586                                         break;
 587                         }
 588
 589                         nextFrame += dbg_frame[1];                                                                      // Go for the next frame (add the length of the current one)
 590                 }
 591
 592                 return "";                                                                                                                                              // We did not found any FRAM_RAWDATA, so return an emtpy strin
 593         }
 594
 595         /**
 596          *
 597          * The stackList contains the currently read stackframes which were sent
 598          * from DBG. The DBG interface holds a list of the active stack frames.
 599          * This method replicates the 'static' stackframe list with the DBG stackframe list
 600          * Replication is done in the following way:
 601          * <ul>
 602          * <li> It looks for new stackframes within the DBG stackframe list and
 603          *      adds them to the 'static' list.
 604          * <li> It looks for stackframes within the 'static' list, and removes them
 605          *              from the 'static' list in case the do not appear within the DBG list.
 606          * <li> It looks for stackframes which are already existent and replicates the
 607          *              line number and the index number.
 608          * <li> At the end the 'static' stackfram list has to be sorted by the stackframes
 609          *              index numbers.
 610          * </ul>
 611          *
 612          * Removes the unused stackframes from the list, or adds stackframes which
 613          * are not yet in the list.
 614          *
 615          *
 616          * @param stackList
 617          */
 618         private void updateStackFrameList (Vector stackList) {
 619                 int                     i;
 620                 int             n;
 621                 PHPStackFrame   stackFrameNew;
 622                 PHPStackFrame   stackFrameOld;
 623                 PHPStackFrame[] newStackList;
 624
 625                 for (i = 0; i < stackList.size (); i++) {                                                               // For all stackList entries
 626                         stackFrameNew = (PHPStackFrame) stackList.get(i);
 627
 628                         for (n = 0; n < stackListOld.size (); n++) {                                    // For all StackFrames in the StackFrame list
 629                                 stackFrameOld = (PHPStackFrame) stackListOld.get (n);                   //
 630
 631                                 if (stackFrameNew.getDescription ().equals (stackFrameOld.getDescription ())) { // Did we find the sent stackframe within the list of old stackframes?
 632                                         stackFrameOld.setLineNumber (stackFrameNew.getLineNumber ());
 633                                         stackFrameOld.setIndex (stackFrameNew.getIndex ());
 634
 635                                         break;                                                                  //  Yes, then break;
 636                                 }
 637                         }
 638
 639                         if (n == stackListOld.size ()) {                                    // Did not find the new stackframe within the list
 640                                  stackListOld.add (stackFrameNew);                              //  then add the new stackframe
 641                         }
 642                 }
 643
 644                 // And now for removing unused stackframes from list
 645
 646                 for (n = 0; n < stackListOld.size (); n++) {                                            // For all StackFrames in the StackFrame list
 647                         stackFrameOld = (PHPStackFrame) stackListOld.get (n);                           //
 648
 649                         for (i = 0; i < stackList.size (); i++) {                                                       // For all stackList entries
 650                                 stackFrameNew = (PHPStackFrame) stackList.get (i);
 651
 652                                 if (stackFrameNew.getDescription ().equals (stackFrameOld.getDescription ())) { // Did we find the sent stackframe within the list of old stackframes?
 653                                         break;                                                                  //  Yes, then break;
 654                                 }
 655                         }
 656
 657                         if (i == stackList.size ()) {                                           // Did not find the old stackframe within the list of new ones
 658                                  stackListOld.remove (n);                                       //  then remove the old stackframe from list
 659                                  n -= 1;                                                        // Adjust the stack list index
 660                         }
 661                 }
 662
 663                 Collections.sort (stackListOld);                                                                                // Sort the 'static' stackframe list by the stackframe index numbers.
 664                                                                                                                                                                 //
 665                 newStackList = new PHPStackFrame[stackListOld.size ()];
 666                 newStackList = (PHPStackFrame[]) stackListOld.toArray (newStackList);
 667                 DBGStackList = newStackList;
 668         }
 669
 670     /**
 671      * Read the response from DBG and process the frame
 672      *
 673          * @return
 674          * - The received command
 675          * - or 0 if something was wrong
 676      */
 677         public int readResponse () throws IOException {
 678         int     bytesToRead            = 0;                         // The number of byte to read for the current DBG block
 679         int     nextFrame              = 0;                         // The current read position within entirePack
 680         int     i                      = 0;
 681         int     cmdReceived            = 0;
 682         int     stackIndex             = 0;
 683         boolean errorStack             = false;
 684         char[]  dbg_header_struct_read = new char[16];              // The buffer for the first 16 bytes of a block
 685         int[]   dbg_header_struct      = new int[4];                // The first four numbers (long) of a block
 686         int[]   dbg_bpl_tmp            = new int[10];
 687         int[]   dbg_frame              = new int[2];
 688         int[]   dbg_eval_tmp           = new int[3];
 689         int[]   dbg_src_tree_tmp       = new int[4];                //
 690         int[]   dbg_error_tmp          = new int[2];
 691         Vector  rawList                = new Vector();
 692         Vector  stackList              = new Vector();              // Intermediate stacklist which is build up in FRAME_STACK frame
 693
 694         rawList.clear ();
 695         stackList.clear ();
 696
 697                 // Read from input
 698         while (readInput (dbg_header_struct_read, 16) != 0) {                               // Read 16 byte from input stream
 699                         dbg_header_struct[0] = PHPDBGBase.Char4ToInt (dbg_header_struct_read, 0);               // Debug sync header
 700             dbg_header_struct[1] = PHPDBGBase.Char4ToInt (dbg_header_struct_read, 4);           // Command
 701             dbg_header_struct[2] = PHPDBGBase.Char4ToInt (dbg_header_struct_read, 8);       //
 702             dbg_header_struct[3] = PHPDBGBase.Char4ToInt (dbg_header_struct_read, 12);      // Bytes within this block
 703
 704             if (dbg_header_struct[0] != 0x5953) {                                           // Check DBG sync bytes
 705                 return 0;                                                                   // Wrong header
 706             }
 707
 708             cmdReceived = dbg_header_struct[1];                                             // Get the command
 709             setLastCmd (cmdReceived);                                                                                                           // Store the info about the current command
 710             bytesToRead = dbg_header_struct[3];                                                                                         // Get the number of bytes to read for this block
 711
 712                         //System.out.println("Response Received: " + cmdReceived);
 713                         char[] entirePack = new char[bytesToRead];                                      // Store the block data into buffer 'entirePack'
 714
 715             if (bytesToRead > 0) {                                                          // If there is something within the frame
 716                 if (readInput (entirePack, bytesToRead) < bytesToRead) {                    // Read the frame into the buffer
 717                     return 0;                                                               // We did not read enough bytes, error
 718                 }
 719                         }
 720
 721                         nextFrame = 0;                                                                  // Start with the first frame
 722
 723                         while (nextFrame < bytesToRead) {                                               // As long as we have something within this block
 724                                 dbg_frame[0] = PHPDBGBase.Char4ToInt (entirePack, nextFrame);                           // The name of the frame
 725                                 dbg_frame[1] = PHPDBGBase.Char4ToInt (entirePack, nextFrame + 4);               // The size of the frame
 726                                 nextFrame   += 8;                                                           // The next read position
 727
 728                                 if (dbg_frame[1] == 0) {                                                    // Something within the frame?
 729                                         return 0;                                                               //  Nothing to read, error
 730                                 }
 731
 732                                 switch (dbg_frame[0]) {
 733                                         case PHPDBGBase.FRAME_STACK:
 734                                                 int[] dbg_stack_new = new int[4];                                       //
 735
 736                                                 dbg_stack_new[0] = PHPDBGBase.Char4ToInt (entirePack, nextFrame + 0);   // Source line number
 737                                                 dbg_stack_new[1] = PHPDBGBase.Char4ToInt (entirePack, nextFrame + 4);   // Module number
 738                                                 dbg_stack_new[2] = PHPDBGBase.Char4ToInt (entirePack, nextFrame + 8);   // Scope id
 739                                                 dbg_stack_new[3] = PHPDBGBase.Char4ToInt (entirePack, nextFrame + 12);  // ID of description string
 740
 741                                                 if ((dbg_stack_new[1] != 0) && !errorStack) {
 742                                                         PHPStackFrame newStack;
 743
 744                                                         stackIndex++;
 745                                                         newStack = new PHPStackFrame (null,                                 // The thread
 746                                                                                       getModByNo (dbg_stack_new[1]),        // The name of the module (file)
 747                                                                                       dbg_stack_new[0],                     // The source line number
 748                                                                                                                   stackIndex,
 749                                                                                                                   getRawFrameData (entirePack,          // Get the string from this packet
 750                                                                                                                                    dbg_stack_new[3]),   // The frame ID for which we want the string
 751                                                                                                                   dbg_stack_new[1]);                                    // The module number
 752                                                         stackList.add (newStack);
 753                                                 }
 754
 755                                                 errorStack = false;
 756                                                 break;
 757
 758                                         case PHPDBGBase.FRAME_SOURCE:                                                   // Nothing to be done here
 759                                                 break;                                                                      // TODO: what's with that frame? Something interesting
 760
 761                                         case PHPDBGBase.FRAME_SRC_TREE:                                                 //
 762                                                 dbg_src_tree_tmp[0] = PHPDBGBase.Char4ToInt (entirePack, nextFrame + 0);        // The parent module number
 763                                                 dbg_src_tree_tmp[1] = PHPDBGBase.Char4ToInt (entirePack, nextFrame + 4);        // The parent line number (not used)
 764                                                 dbg_src_tree_tmp[2] = PHPDBGBase.Char4ToInt (entirePack, nextFrame + 8);        // The module number
 765                                                 dbg_src_tree_tmp[3] = PHPDBGBase.Char4ToInt (entirePack, nextFrame + 12);       // The filename number
 766
 767                                                 if (getModByNo (dbg_src_tree_tmp[2]).equals ("")) {
 768                                                         String fileName;
 769
 770                                                         fileName = new String (getRawFrameData (entirePack, dbg_src_tree_tmp[3]));      // Get the filename
 771
 772                                                         if (fileName.length () > 0) {                                               // If we have a filename
 773                                                                 fileName = fileName.substring (0, fileName.length () - 1);              // Remove '\0' char
 774                                                         }
 775
 776                                                         if (dbg_src_tree_tmp[2] != 0) {                                             // If there is a module number
 777                                                                 PHPDBGMod modNew;
 778
 779                                                                 modNew = new PHPDBGMod (dbg_src_tree_tmp[2], fileName);                 // Create a module object
 780
 781                                                                 DBGMods.add (modNew);                                                   // And store it to array
 782                                                         }
 783                                                 }
 784                                                 break;
 785
 786                                         case PHPDBGBase.FRAME_RAWDATA:                                                      // Nothing to be done here
 787                                                 break;                                                                          //  FRAME_RAWDATA are processed within getRawFrameData
 788
 789                                         case PHPDBGBase.FRAME_ERROR:                                                                                                            // An error frame
 790                                                 errorStack       = true;                                                                                                                // Yes, we have an error stack
 791                                                 dbg_error_tmp[0] = PHPDBGBase.Char4ToInt (entirePack, nextFrame + 0);                   // Error type
 792                                                 dbg_error_tmp[1] = PHPDBGBase.Char4ToInt (entirePack, nextFrame + 4);                   // Error message ID
 793
 794                                                 String error = "\n";                                                            //
 795
 796                                                 switch (dbg_error_tmp[0]) {                                                                                                             // Switch on error type
 797                                                         case PHPDBGBase.E_ERROR:                        error += "[Error]";                     break;
 798                                                         case PHPDBGBase.E_WARNING:                      error += "[Warning]";                   break;
 799                                                         case PHPDBGBase.E_PARSE:                        error += "[Parse Error]";               break;
 800                                                         case PHPDBGBase.E_NOTICE:                       error += "[Notice]";                    break;
 801                                                         case PHPDBGBase.E_CORE_ERROR:           error += "[Core Error]";                break;
 802                                                         case PHPDBGBase.E_CORE_WARNING:         error += "[Core Warning]";              break;
 803                                                         case PHPDBGBase.E_COMPILE_ERROR:        error += "[Compile Error]";             break;
 804                                                         case PHPDBGBase.E_COMPILE_WARNING:      error += "[Compile Warning]";   break;
 805                                                         case PHPDBGBase.E_USER_ERROR:           error += "[User Error]";                break;
 806                                                         case PHPDBGBase.E_USER_WARNING:         error += "[User Warning]";              break;
 807                                                         case PHPDBGBase.E_USER_NOTICE:          error += "[User Notice]";               break;
 808                                                         default:                                                        error += "[Unexpected Error]";  break;
 809                                                 }
 810
 811                                                 error += ": ";
 812                                                 error += new String (getRawFrameData (entirePack, dbg_error_tmp[1]));                   // Add the error string for this error message ID
 813
 814                                                 if (error.length () > 0) {                                                                                                              // If we have a error message
 815                                                          error = error.substring (0, error.length () - 1);                                                      //  Remove '\0' char
 816                                                 }
 817
 818                                                 error += "\n";                                                                  // Append a CR
 819
 820                                                 PHPDebugCorePlugin.log (new DebugException (new Status (IStatus.WARNING,
 821                                                                                                         PHPDebugCorePlugin.PLUGIN_ID,
 822                                                                                                                                                                 IStatus.OK,
 823                                                                                                                                                                 error, null)));
 824
 825                                                 // To print errors on the console, I must execute a code in the
 826                                                 // php context, that write the stderr... I didn't found a better way
 827                                                 // TODO: Find a better way????
 828
 829 //                                              String codeExec= "";
 830 //                                              codeExec= "fwrite(fopen('php://stderr', 'w'),\\\"" + error + "\\\");";
 831 //                                              try {
 832 //                                                      evalBlock("eval(\"" + codeExec + "\");");
 833 //                                              } catch (DebugException e) {
 834 //                                                      PHPDebugCorePlugin.log(e);
 835 //                                              }
 836 //
 837                                                 if (!stopOnError) {                                                             // Is always false (Did not see where this is set to true!?)
 838                                                         if (lastCommand.equals (PHPDBGBase.DBGA_CONTINUE)) {                        // If last command for PHP was a 'continue',
 839                                                                 continueExecution ();                                                   //  send continue again
 840                                                         } else if (lastCommand.equals (PHPDBGBase.DBGA_STEPINTO)) {                 // If last command for PHP was a 'step into',
 841                                                                 stepInto ();                                                            //  send 'step into' again
 842                                                         } else if (lastCommand.equals (PHPDBGBase.DBGA_STEPOUT)) {                  // If last command for PHP was a 'step out',
 843                                                                 stepOut ();                                                             //  send 'step out' again
 844                                                         } else if (lastCommand.equals (PHPDBGBase.DBGA_STEPOVER)) {                 // If last command for PHP was a 'step over',
 845                                                                 stepOver ();                                                            //  send 'step over' again
 846                                                         }
 847                                                 }
 848                                                 break;
 849
 850                                         case PHPDBGBase.FRAME_EVAL:
 851                                                 String evalString;
 852
 853                                                 evalString      = new String ("");
 854                                                 dbg_eval_tmp[0] = PHPDBGBase.Char4ToInt (entirePack, nextFrame + 0);                    // istr
 855                                                 dbg_eval_tmp[1] = PHPDBGBase.Char4ToInt (entirePack, nextFrame + 4);                    // iresult
 856                                                 dbg_eval_tmp[2] = PHPDBGBase.Char4ToInt (entirePack, nextFrame + 8);                    // ierror
 857
 858                                                 evalRet                 = getRawFrameData (entirePack, dbg_eval_tmp[1]);                //
 859                                                 evalString              = getRawFrameData (entirePack, dbg_eval_tmp[0]);                //
 860                                                 serGlobals              = evalRet;                                                      //
 861                                                 break;
 862
 863                                         case PHPDBGBase.FRAME_BPS:                                                          //
 864                                                 break;                                                                          //
 865
 866                                         case PHPDBGBase.FRAME_BPL:
 867                                                 int[] dbg_bpl_new;
 868
 869                                                 dbg_bpl_new        = new int[10];
 870                                                 dbg_bpl_new[0] = PHPDBGBase.Char4ToInt (entirePack, nextFrame + 0);
 871                                                 dbg_bpl_new[1] = PHPDBGBase.Char4ToInt (entirePack, nextFrame + 4);
 872                                                 dbg_bpl_new[2] = PHPDBGBase.Char4ToInt (entirePack, nextFrame + 8);
 873                                                 dbg_bpl_new[3] = PHPDBGBase.Char4ToInt (entirePack, nextFrame + 12);
 874                                                 dbg_bpl_new[4] = PHPDBGBase.Char4ToInt (entirePack, nextFrame + 16);
 875                                                 dbg_bpl_new[5] = PHPDBGBase.Char4ToInt (entirePack, nextFrame + 20);
 876                                                 dbg_bpl_new[6] = PHPDBGBase.Char4ToInt (entirePack, nextFrame + 24);
 877                                                 dbg_bpl_new[7] = PHPDBGBase.Char4ToInt (entirePack, nextFrame + 28);
 878                                                 dbg_bpl_new[8] = PHPDBGBase.Char4ToInt (entirePack, nextFrame + 32);
 879                                                 dbg_bpl_new[9] = PHPDBGBase.Char4ToInt (entirePack, nextFrame + 36);
 880
 881                                                 // look if breakpoint already exists in vector
 882                                                 for (i = 0; i < DBGBPList.size (); i++) {
 883                                                         dbg_bpl_tmp = (int[]) DBGBPList.get (i);
 884
 885                                                         if (dbg_bpl_tmp[8] == dbg_bpl_new[8]) {
 886                                                                 DBGBPList.remove (i);
 887
 888                                                                 break;
 889                                                         }
 890                                                 }
 891
 892                                                 // add breakpoint to vector
 893                                                 DBGBPList.add (dbg_bpl_new);
 894                                                 copyToLastBP (dbg_bpl_new);
 895
 896                                                 // mod no returned?
 897                                                 if (getModByNo (dbg_bpl_new[0]).equals ("")) {
 898                                                         String fileName;
 899
 900                                                         fileName = new String (getRawFrameData (entirePack, dbg_bpl_new[2]));
 901
 902                                                         if (fileName.length () > 0) {                                               // If we have filename
 903                                                                 fileName = fileName.substring (0, fileName.length () - 1);                              //  Remove '\0' char
 904                                                         }
 905
 906                                                         if (dbg_bpl_new[0] != 0) {
 907                                                                 PHPDBGMod modNew;
 908
 909                                                                 modNew = new PHPDBGMod (dbg_bpl_new[0], fileName);
 910
 911                                                                 DBGMods.add (modNew);
 912                                                         }
 913                                                 }
 914                                                 break;
 915
 916                                         case PHPDBGBase.FRAME_VER:
 917                                                 break;
 918
 919                                         case PHPDBGBase.FRAME_SID:
 920                                                 sid = PHPDBGBase.Char4ToInt(entirePack, nextFrame + 0);
 921                                                 break;
 922
 923                                         case PHPDBGBase.FRAME_SRCLINESINFO:
 924                                                 break;
 925
 926                                         case PHPDBGBase.FRAME_SRCCTXINFO:
 927                                                 break;
 928
 929                                         case PHPDBGBase.FRAME_LOG:
 930                                                 break;
 931
 932                                         case PHPDBGBase.FRAME_PROF:
 933                                                 break;
 934
 935                                         case PHPDBGBase.FRAME_PROF_C:
 936                                                 break;
 937
 938                                         case PHPDBGBase.FRAME_SET_OPT:
 939                                                 break;
 940                                 }
 941
 942                                 nextFrame += dbg_frame[1];                                                      // go to next frame
 943                         }
 944
 945                         // Now process command
 946                         switch(cmdReceived) {
 947                                 case PHPDBGBase.DBGC_REPLY:
 948                                         break;
 949
 950                                 case PHPDBGBase.DBGC_STARTUP:
 951                                         break;
 952
 953                                 case PHPDBGBase.DBGC_END:
 954                                         sessionEnded = true;
 955                                         break;
 956
 957                                 case PHPDBGBase.DBGC_BREAKPOINT:
 958                                         BPUnderHit   = getBPUnderHit ();
 959                                         updateStackFrameList (stackList);
 960                                         break;
 961
 962                                 case PHPDBGBase.DBGC_STEPINTO_DONE:
 963                                 case PHPDBGBase.DBGC_STEPOVER_DONE:
 964                                 case PHPDBGBase.DBGC_STEPOUT_DONE:
 965                                 case PHPDBGBase.DBGC_EMBEDDED_BREAK:
 966                                 case PHPDBGBase.DBGC_PAUSE:
 967                                         BPUnderHit   = 1;
 968                                         updateStackFrameList (stackList);
 969                                         break;
 970
 971                                 case PHPDBGBase.DBGC_ERROR:
 972                                         stackList.clear ();
 973                                         updateStackFrameList (stackList);
 974                                         break;
 975
 976                                 case PHPDBGBase.DBGC_LOG:
 977                                         break;
 978
 979                                 case PHPDBGBase.DBGC_SID:
 980                                         break;
 981                         }
 982                 }
 983
 984                 return cmdReceived;                                         // Return the command we received with this block
 985         }
 986
 987     /**
 988      *
 989      */
 990
 991         public PHPStackFrame[] getStackList() {
 992                 return DBGStackList;
 993         }
 994
 995         /**
 996          * Reads from input buffer (response sent from DBG) the given number of chars
 997          * into frame buffer.
 998          *
 999          * @param buffer  The frame buffer where to store the read data from DBG.
1000          * @param bytes   The number of bytes (chars) which are to read from input stream.
1001          * @return        The number of bytes actually read.
1002          */
1003         private int readInput (char[] buffer, int bytes) throws IOException {
1004                 int bytesRead = 0;                                                                                      // Reset the bytes read counter
1005
1006                 for (int i = 0; i < bytes; i++) {                           // For the number of bytes we should read
1007                         if (in.ready ()) {                                                                              // If input stream is ready for reading
1008                                 buffer[i] = (char) (in.read () & 0x00FF);           // Read a char and store only the least significant 8-bits
1009                                 bytesRead++;                                        // Increment the bytes read counter
1010                         }
1011                         else {                                                  // Input stream is not ready
1012                                 break;                                              // Break the loop
1013                         }
1014                 }
1015
1016                 return bytesRead;                                                                                       // Return the number of bytes actually read
1017         }
1018
1019         /**
1020          * PHPProxy could stop the waiting for a response with this method.
1021          *
1022          */
1023         public void setShouldStop () {
1024                 this.shouldStop = true;
1025         }
1026
1027         /**
1028          * @param milliseconds The maximum time in milliseconds we wait for something
1029          *                     to be send from DBG.
1030          * @return             - true if something was received from DBG
1031          *                                         - false if nothing was send from DBG within the given time
1032          *
1033          */
1034         public boolean waitResponse (long milliseconds) throws IOException {
1035                 long timeout;
1036
1037                 timeout = System.currentTimeMillis () + milliseconds;           // Calculate the system time till we wait.
1038
1039                 while (System.currentTimeMillis () < timeout) {             // Is waiting time running out?
1040                         if (in.ready () || shouldStop) {                        //  No, so did we get something or should we stop now
1041                                 break;                                              //   Yes, break the waiting
1042                         }
1043                 }
1044
1045                 return in.ready ();                                         // true if we got something from DBG
1046         }
1047 }