Source/GDBpConnection.m

   1 /*
   2  * MacGDBp
   3  * Copyright (c) 2007 - 2010, Blue Static <http://www.bluestatic.org>
   4  *
   5  * This program is free software; you can redistribute it and/or modify it under the terms of the GNU
   6  * General Public License as published by the Free Software Foundation; either version 2 of the
   7  * License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
  10  * even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11  * General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License along with this program; if not,
  14  * write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
  15  */
  16
  17 #import <sys/socket.h>
  18 #import <netinet/in.h>
  19
  20 #import "GDBpConnection.h"
  21
  22 #import "AppDelegate.h"
  23
  24
  25 typedef enum _StackFrameComponents
  26 {
  27         kStackFrameContexts,
  28         kStackFrameSource,
  29         kStackFrameVariables
  30 } StackFrameComponent;
  31
  32 // GDBpConnection (Private) ////////////////////////////////////////////////////
  33
  34 @interface GDBpConnection ()
  35 @property (readwrite, copy) NSString* status;
  36 @property (assign) CFSocketRef socket;
  37 @property (assign) CFReadStreamRef readStream;
  38 @property int lastReadTransaction;
  39 @property (retain) NSMutableString* currentPacket;
  40 @property (assign) CFWriteStreamRef writeStream;
  41 @property int lastWrittenTransaction;
  42 @property (retain) NSMutableArray* queuedWrites;
  43
  44 - (void)connect;
  45 - (void)close;
  46 - (void)socketDidAccept;
  47 - (void)socketDisconnected;
  48 - (void)readStreamHasData;
  49 - (void)send:(NSString*)command;
  50 - (void)performSend:(NSString*)command;
  51 - (void)errorEncountered:(NSString*)error;
  52
  53 - (void)handleResponse:(NSXMLDocument*)response;
  54 - (void)initReceived:(NSXMLDocument*)response;
  55 - (void)updateStatus:(NSXMLDocument*)response;
  56 - (void)debuggerStep:(NSXMLDocument*)response;
  57 - (void)rebuildStack:(NSXMLDocument*)response;
  58 - (void)getStackFrame:(NSXMLDocument*)response;
  59 - (void)handleRouted:(NSArray*)path response:(NSXMLDocument*)response;
  60
  61 - (NSString*)createCommand:(NSString*)cmd, ...;
  62 - (NSString*)createRouted:(NSString*)routingID command:(NSString*)cmd, ...;
  63
  64 - (void)sendQueuedWrites;
  65
  66 - (StackFrame*)createStackFrame:(int)depth;
  67 - (NSString*)escapedURIPath:(NSString*)path;
  68 @end
  69
  70 // CFNetwork Callbacks /////////////////////////////////////////////////////////
  71
  72 void ReadStreamCallback(CFReadStreamRef stream, CFStreamEventType eventType, void* connectionRaw)
  73 {
  74         GDBpConnection* connection = (GDBpConnection*)connectionRaw;
  75         switch (eventType)
  76         {
  77                 case kCFStreamEventHasBytesAvailable:
  78                         NSLog(@"About to read.");
  79                         [connection readStreamHasData];
  80                         break;
  81
  82                 case kCFStreamEventErrorOccurred:
  83                 {
  84                         CFErrorRef error = CFReadStreamCopyError(stream);
  85                         CFReadStreamUnscheduleFromRunLoop(stream, CFRunLoopGetCurrent(), kCFRunLoopCommonModes);
  86                         CFReadStreamClose(stream);
  87                         CFRelease(stream);
  88                         [connection errorEncountered:[[(NSError*)error autorelease] description]];
  89                         break;
  90                 }
  91
  92                 case kCFStreamEventEndEncountered:
  93                         CFReadStreamUnscheduleFromRunLoop(stream, CFRunLoopGetCurrent(), kCFRunLoopCommonModes);
  94                         CFReadStreamClose(stream);
  95                         CFRelease(stream);
  96                         [connection socketDisconnected];
  97                         break;
  98         };
  99 }
 100
 101 void WriteStreamCallback(CFWriteStreamRef stream, CFStreamEventType eventType, void* connectionRaw)
 102 {
 103         GDBpConnection* connection = (GDBpConnection*)connectionRaw;
 104         switch (eventType)
 105         {
 106                 case kCFStreamEventCanAcceptBytes:
 107                         [connection sendQueuedWrites];
 108                         break;
 109
 110                 case kCFStreamEventErrorOccurred:
 111                 {
 112                         CFErrorRef error = CFWriteStreamCopyError(stream);
 113                         CFWriteStreamUnscheduleFromRunLoop(stream, CFRunLoopGetCurrent(), kCFRunLoopCommonModes);
 114                         CFWriteStreamClose(stream);
 115                         CFRelease(stream);
 116                         [connection errorEncountered:[[(NSError*)error autorelease] description]];
 117                         break;
 118                 }
 119
 120                 case kCFStreamEventEndEncountered:
 121                         CFWriteStreamUnscheduleFromRunLoop(stream, CFRunLoopGetCurrent(), kCFRunLoopCommonModes);
 122                         CFWriteStreamClose(stream);
 123                         CFRelease(stream);
 124                         [connection socketDisconnected];
 125                         break;
 126         }
 127 }
 128
 129 void SocketAcceptCallback(CFSocketRef socket,
 130                                                   CFSocketCallBackType callbackType,
 131                                                   CFDataRef address,
 132                                                   const void* data,
 133                                                   void* connectionRaw)
 134 {
 135         assert(callbackType == kCFSocketAcceptCallBack);
 136         NSLog(@"SocketAcceptCallback()");
 137
 138         GDBpConnection* connection = (GDBpConnection*)connectionRaw;
 139
 140         CFReadStreamRef readStream;
 141         CFWriteStreamRef writeStream;
 142
 143         // Create the streams on the socket.
 144         CFStreamCreatePairWithSocket(kCFAllocatorDefault,
 145                                                                  *(CFSocketNativeHandle*)data,  // Socket handle.
 146                                                                  &readStream,  // Read stream in-pointer.
 147                                                                  &writeStream);  // Write stream in-pointer.
 148
 149         // Create struct to register callbacks for the stream.
 150         CFStreamClientContext context;
 151         context.version = 0;
 152         context.info = connection;
 153         context.retain = NULL;
 154         context.release = NULL;
 155         context.copyDescription = NULL;
 156
 157         // Set the client of the read stream.
 158         CFOptionFlags readFlags =
 159                 kCFStreamEventOpenCompleted |
 160                 kCFStreamEventHasBytesAvailable |
 161                 kCFStreamEventErrorOccurred |
 162                 kCFStreamEventEndEncountered;
 163         if (CFReadStreamSetClient(readStream, readFlags, ReadStreamCallback, &context))
 164                 // Schedule in run loop to do asynchronous communication with the engine.
 165                 CFReadStreamScheduleWithRunLoop(readStream, CFRunLoopGetCurrent(), kCFRunLoopCommonModes);
 166         else
 167                 return;
 168
 169         // Open the stream now that it's scheduled on the run loop.
 170         if (!CFReadStreamOpen(readStream))
 171         {
 172                 CFStreamError error = CFReadStreamGetError(readStream);
 173                 NSLog(@"error! %@", error);
 174                 return;
 175         }
 176
 177         // Set the client of the write stream.
 178         CFOptionFlags writeFlags =
 179                 kCFStreamEventOpenCompleted |
 180                 kCFStreamEventCanAcceptBytes |
 181                 kCFStreamEventErrorOccurred |
 182                 kCFStreamEventEndEncountered;
 183         if (CFWriteStreamSetClient(writeStream, writeFlags, WriteStreamCallback, &context))
 184                 // Schedule it in the run loop to receive error information.
 185                 CFWriteStreamScheduleWithRunLoop(writeStream, CFRunLoopGetCurrent(), kCFRunLoopCommonModes);
 186         else
 187                 return;
 188
 189         // Open the write stream.
 190         if (!CFWriteStreamOpen(writeStream))
 191         {
 192                 CFStreamError error = CFWriteStreamGetError(writeStream);
 193                 NSLog(@"error! %@", error);
 194                 return;
 195         }
 196
 197         connection.readStream = readStream;
 198         connection.writeStream = writeStream;
 199         [connection socketDidAccept];
 200 }
 201
 202 // GDBpConnection //////////////////////////////////////////////////////////////
 203
 204 @implementation GDBpConnection
 205 @synthesize socket = socket_;
 206 @synthesize readStream = readStream_;
 207 @synthesize lastReadTransaction = lastReadTransaction_;
 208 @synthesize currentPacket = currentPacket_;
 209 @synthesize writeStream = writeStream_;
 210 @synthesize lastWrittenTransaction = lastWrittenTransaction_;
 211 @synthesize queuedWrites = queuedWrites_;
 212 @synthesize status;
 213 @synthesize delegate;
 214
 215 /**
 216  * Creates a new DebuggerConnection and initializes the socket from the given connection
 217  * paramters.
 218  */
 219 - (id)initWithPort:(int)aPort
 220 {
 221         if (self = [super init])
 222         {
 223                 port = aPort;
 224                 connected = NO;
 225
 226                 [[BreakpointManager sharedManager] setConnection:self];
 227
 228                 [self connect];
 229         }
 230         return self;
 231 }
 232
 233 /**
 234  * Deallocates the object
 235  */
 236 - (void)dealloc
 237 {
 238         [self close];
 239         self.currentPacket = nil;
 240
 241         [super dealloc];
 242 }
 243
 244 /**
 245  * Gets the port number
 246  */
 247 - (int)port
 248 {
 249         return port;
 250 }
 251
 252 /**
 253  * Returns the name of the remote host
 254  */
 255 - (NSString*)remoteHost
 256 {
 257         if (!connected)
 258         {
 259                 return @"(DISCONNECTED)";
 260         }
 261         // TODO: Either impl or remove.
 262         return @"";
 263 }
 264
 265 /**
 266  * Returns whether or not we have an active connection
 267  */
 268 - (BOOL)isConnected
 269 {
 270         return connected;
 271 }
 272
 273 /**
 274  * Called by SocketWrapper after the connection is successful. This immediately calls
 275  * -[SocketWrapper receive] to clear the way for communication, though the information
 276  * could be useful server information that we don't use right now.
 277  */
 278 - (void)socketDidAccept
 279 {
 280         connected = YES;
 281         transactionID = 1;
 282         stackFrames_ = [[NSMutableDictionary alloc] init];
 283         self.queuedWrites = [NSMutableArray array];
 284 }
 285
 286 /**
 287  * Receives errors from the SocketWrapper and updates the display
 288  */
 289 - (void)errorEncountered:(NSString*)error
 290 {
 291         [delegate errorEncountered:error];
 292 }
 293
 294 /**
 295  * Reestablishes communication with the remote debugger so that a new connection doesn't have to be
 296  * created every time you want to debug a page
 297  */
 298 - (void)reconnect
 299 {
 300         [self close];
 301         self.status = @"Connecting";
 302         [self connect];
 303 }
 304
 305 /**
 306  * Creates an entirely new stack and returns it as an array of StackFrame objects.
 307  */
 308 - (NSArray*)getCurrentStack
 309 {
 310         NSMutableArray* stack = [NSMutableArray array];
 311         NSLog(@"NOTIMPLEMENTED(): %s", _cmd);
 312         return stack;
 313 }
 314
 315 /**
 316  * Tells the debugger to continue running the script. Returns the current stack frame.
 317  */
 318 - (void)run
 319 {
 320         [self send:[self createCommand:@"run"]];
 321 }
 322
 323 /**
 324  * Tells the debugger to step into the current command.
 325  */
 326 - (void)stepIn
 327 {
 328         [self send:[self createCommand:@"step_into"]];
 329 }
 330
 331 /**
 332  * Tells the debugger to step out of the current context
 333  */
 334 - (void)stepOut
 335 {
 336         [self send:[self createCommand:@"step_out"]];
 337 }
 338
 339 /**
 340  * Tells the debugger to step over the current function
 341  */
 342 - (void)stepOver
 343 {
 344         [self send:[self createCommand:@"step_over"]];
 345 }
 346
 347 /**
 348  * Tells the debugger engine to get a specifc property. This also takes in the NSXMLElement
 349  * that requested it so that the child can be attached.
 350  */
 351 - (NSArray*)getProperty:(NSString*)property
 352 {
 353         [socket send:[self createCommand:[NSString stringWithFormat:@"property_get -n \"%@\"", property]]];
 354
 355         NSXMLDocument* doc = [self processData:[socket receive]];
 356
 357         /*
 358          <response>
 359                 <property> <!-- this is the one we requested -->
 360                         <property ... /> <!-- these are what we want -->
 361                 </property>
 362          </repsonse>
 363          */
 364
 365         // we now have to detach all the children so we can insert them into another document
 366         NSXMLElement* parent = (NSXMLElement*)[[doc rootElement] childAtIndex:0];
 367         NSArray* children = [parent children];
 368         [parent setChildren:nil];
 369         return children;
 370 }
 371
 372 #pragma mark Breakpoints
 373
 374 /**
 375  * Send an add breakpoint command
 376  */
 377 - (void)addBreakpoint:(Breakpoint*)bp
 378 {
 379         if (!connected)
 380                 return;
 381
 382         NSString* file = [self escapedURIPath:[bp transformedPath]];
 383         NSString* cmd = [self createCommand:[NSString stringWithFormat:@"breakpoint_set -t line -f %@ -n %i", file, [bp line]]];
 384         [socket send:cmd];
 385         NSXMLDocument* info = [self processData:[socket receive]];
 386         [bp setDebuggerId:[[[[info rootElement] attributeForName:@"id"] stringValue] intValue]];
 387 }
 388
 389 /**
 390  * Removes a breakpoint
 391  */
 392 - (void)removeBreakpoint:(Breakpoint*)bp
 393 {
 394         if (!connected)
 395         {
 396                 return;
 397         }
 398
 399         [socket send:[self createCommand:[NSString stringWithFormat:@"breakpoint_remove -d %i", [bp debuggerId]]]];
 400         [socket receive];
 401 }
 402
 403 #pragma mark Socket and Stream Callbacks
 404
 405 /**
 406  * Creates, connects to, and schedules a CFSocket.
 407  */
 408 - (void)connect
 409 {
 410         // Pass ourselves to the callback so we don't have to use ugly globals.
 411         CFSocketContext context;
 412         context.version = 0;
 413         context.info = self;
 414         context.retain = NULL;
 415         context.release = NULL;
 416         context.copyDescription = NULL;
 417
 418         // Create the address structure.
 419         struct sockaddr_in address;
 420         memset(&address, 0, sizeof(address));
 421         address.sin_len = sizeof(address);
 422         address.sin_family = AF_INET;
 423         address.sin_port = htons(port);
 424         address.sin_addr.s_addr = htonl(INADDR_ANY);
 425
 426         // Create the socket signature.
 427         CFSocketSignature signature;
 428         signature.protocolFamily = PF_INET;
 429         signature.socketType = SOCK_STREAM;
 430         signature.protocol = IPPROTO_TCP;
 431         signature.address = (CFDataRef)[NSData dataWithBytes:&address length:sizeof(address)];
 432
 433         socket_ = CFSocketCreateWithSocketSignature(kCFAllocatorDefault,
 434                                                                                                 &signature,  // Socket signature.
 435                                                                                                 kCFSocketAcceptCallBack,  // Callback types.
 436                                                                                                 SocketAcceptCallback,  // Callout function pointer.
 437                                                                                                 &context);  // Context to pass to callout.
 438         if (!socket_)
 439         {
 440                 [self errorEncountered:@"Could not open socket."];
 441                 return;
 442         }
 443
 444         // Allow old, yet-to-be recycled sockets to be reused.
 445         BOOL yes = YES;
 446         setsockopt(CFSocketGetNative(socket_), SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(BOOL));
 447
 448         // Schedule the socket on the run loop.
 449         CFRunLoopSourceRef source = CFSocketCreateRunLoopSource(kCFAllocatorDefault, socket_, 0);
 450         CFRunLoopAddSource(CFRunLoopGetCurrent(), source, kCFRunLoopCommonModes);
 451         CFRelease(source);
 452
 453         self.status = @"Connecting";
 454 }
 455
 456 /**
 457  * Closes a socket and releases the ref.
 458  */
 459 - (void)close
 460 {
 461         // The socket goes down, so do the streams, which clean themselves up.
 462         CFSocketInvalidate(socket_);
 463         CFRelease(socket_);
 464         [stackFrames_ release];
 465         self.queuedWrites = nil;
 466 }
 467
 468 /**
 469  * Notification that the socket disconnected.
 470  */
 471 - (void)socketDisconnected
 472 {
 473         [self close];
 474         [delegate debuggerDisconnected];
 475 }
 476
 477 /**
 478  * Callback from the CFReadStream that there is data waiting to be read.
 479  */
 480 - (void)readStreamHasData
 481 {
 482         UInt8 buffer[1024];
 483         CFIndex bytesRead = CFReadStreamRead(readStream_, buffer, 1024);
 484         const char* charBuffer = (const char*)buffer;
 485
 486         // We haven't finished reading a packet, so just read more data in.
 487         if (currentPacketIndex_ < packetSize_)
 488         {
 489                 [currentPacket_ appendFormat:@"%s", buffer];
 490                 currentPacketIndex_ += bytesRead;
 491         }
 492         // Time to read a new packet.
 493         else
 494         {
 495                 // Read the message header: the size.
 496                 packetSize_ = atoi(charBuffer);
 497                 currentPacketIndex_ = bytesRead - strlen(charBuffer);
 498                 self.currentPacket = [NSMutableString stringWithFormat:@"%s", buffer + strlen(charBuffer) + 1];
 499         }
 500
 501         // We have finished reading the packet.
 502         if (currentPacketIndex_ >= packetSize_)
 503         {
 504                 packetSize_ = 0;
 505                 currentPacketIndex_ = 0;
 506
 507                 // Test if we can convert it into an NSXMLDocument.
 508                 NSError* error = nil;
 509                 NSXMLDocument* xmlTest = [[NSXMLDocument alloc] initWithXMLString:currentPacket_ options:NSXMLDocumentTidyXML error:&error];
 510                 if (error)
 511                 {
 512                         NSLog(@"Could not parse XML? --- %@", error);
 513                         NSLog(@"Error UserInfo: %@", [error userInfo]);
 514                         NSLog(@"This is the XML Document: %@", currentPacket_);
 515                         return;
 516                 }
 517                 [self handleResponse:[xmlTest autorelease]];
 518         }
 519 }
 520
 521 /**
 522  * Writes a command into the write stream. If the stream is ready for writing,
 523  * we do so immediately. If not, the command is queued and will be written
 524  * when the stream is ready.
 525  */
 526 - (void)send:(NSString*)command
 527 {
 528         if (lastReadTransaction_ >= lastWrittenTransaction_ && CFWriteStreamCanAcceptBytes(writeStream_))
 529                 [self performSend:command];
 530         else
 531                 [queuedWrites_ addObject:command];
 532 }
 533
 534 /**
 535  * This performs a blocking send. This should ONLY be called when we know we
 536  * have write access to the stream. We will busy wait in case we don't do a full
 537  * send.
 538  */
 539 - (void)performSend:(NSString*)command
 540 {
 541         BOOL done = NO;
 542
 543         char* string = (char*)[command UTF8String];
 544         int stringLength = strlen(string);
 545
 546         // Log the command if TransportDebug is enabled.
 547         if ([[[[NSProcessInfo processInfo] environment] objectForKey:@"TransportDebug"] boolValue])
 548                 NSLog(@"--> %@", command);
 549
 550         // Busy wait while writing. BAADD. Should background this operation.
 551         while (!done)
 552         {
 553                 if (CFWriteStreamCanAcceptBytes(writeStream_))
 554                 {
 555                         // Include the NULL byte in the string when we write.
 556                         int bytesWritten = CFWriteStreamWrite(writeStream_, (UInt8*)string, stringLength + 1);
 557                         if (bytesWritten < 0)
 558                         {
 559                                 NSLog(@"write error");
 560                         }
 561                         // Incomplete write.
 562                         else if (bytesWritten < strlen(string))
 563                         {
 564                                 // Adjust the buffer and wait for another chance to write.
 565                                 stringLength -= bytesWritten;
 566                                 memmove(string, string + bytesWritten, stringLength);
 567                         }
 568                         else
 569                         {
 570                                 done = YES;
 571
 572                                 // We need to scan the string to find the transactionID.
 573                                 NSRange occurrence = [command rangeOfString:@"-i "];
 574                                 if (occurrence.location == NSNotFound)
 575                                 {
 576                                         NSLog(@"sent %@ without a transaction ID", command);
 577                                         continue;
 578                                 }
 579                                 NSString* transaction = [command substringFromIndex:occurrence.location + occurrence.length];
 580                                 lastWrittenTransaction_ = [transaction intValue];
 581                                 NSLog(@"command = %@", command);
 582                                 NSLog(@"read=%d, write=%d", lastReadTransaction_, lastWrittenTransaction_);
 583                         }
 584                 }
 585         }
 586 }
 587
 588 #pragma mark Response Handlers
 589
 590 - (void)handleResponse:(NSXMLDocument*)response
 591 {
 592         // Check and see if there's an error.
 593         NSArray* error = [[response rootElement] elementsForName:@"error"];
 594         if ([error count] > 0)
 595         {
 596                 NSLog(@"Xdebug error: %@", error);
 597                 [delegate errorEncountered:[[[[error objectAtIndex:0] children] objectAtIndex:0] stringValue]];
 598         }
 599
 600         // If TransportDebug is enabled, log the response.
 601         if ([[[[NSProcessInfo processInfo] environment] objectForKey:@"TransportDebug"] boolValue])
 602                 NSLog(@"<-- %@", response);
 603
 604         // Get the name of the command from the engine's response.
 605         NSString* command = [[[response rootElement] attributeForName:@"command"] stringValue];
 606         NSString* transaction = [[[response rootElement] attributeForName:@"transaction_id"] stringValue];
 607         NSArray* routingPath = [transaction componentsSeparatedByString:@"."];
 608
 609         NSInteger txnID = [[routingPath objectAtIndex:0] intValue];
 610         if (txnID < lastReadTransaction_)
 611                 NSLog(@"out of date transaction %@", response);
 612
 613         if (txnID != lastWrittenTransaction_)
 614                 NSLog(@"txn doesn't match last written %@", response);
 615
 616         NSLog(@"read=%d, write=%d", lastReadTransaction_, lastWrittenTransaction_);
 617
 618         // Dispatch the command response to an appropriate handler.
 619         if ([command isEqualToString:@"status"])
 620                 [self updateStatus:response];
 621         else if ([command isEqualToString:@"run"] || [command isEqualToString:@"step_into"] ||
 622                          [command isEqualToString:@"step_over"] || [command isEqualToString:@"step_out"])
 623                 [self debuggerStep:response];
 624         else if ([command isEqualToString:@"stack_depth"])
 625                 [self rebuildStack:response];
 626         else if ([command isEqualToString:@"stack_get"])
 627                 [self getStackFrame:response];
 628         else if ([routingPath count] > 1)
 629                 [self handleRouted:routingPath response:response];
 630         else if ([[[response rootElement] name] isEqualToString:@"init"])
 631                 [self initReceived:response];
 632
 633         [self sendQueuedWrites];
 634 }
 635
 636 /**
 637  * Initial packet received. We've started a brand-new connection to the engine.
 638  */
 639 - (void)initReceived:(NSXMLDocument*)response
 640 {
 641         // Register any breakpoints that exist offline.
 642         for (Breakpoint* bp in [[BreakpointManager sharedManager] breakpoints])
 643                 [self addBreakpoint:bp];
 644
 645         // Load the debugger to make it look active.
 646         [delegate debuggerConnected];
 647
 648         [self send:[self createCommand:@"status"]];
 649 }
 650
 651 /**
 652  * Receiver for status updates. This just freshens up the UI.
 653  */
 654 - (void)updateStatus:(NSXMLDocument*)response
 655 {
 656         self.status = [[[[response rootElement] attributeForName:@"status"] stringValue] capitalizedString];
 657         if (status == nil || [status isEqualToString:@"Stopped"] || [status isEqualToString:@"Stopping"])
 658         {
 659                 connected = NO;
 660                 [self close];
 661                 [delegate debuggerDisconnected];
 662
 663                 self.status = @"Stopped";
 664         }
 665 }
 666
 667 /**
 668  * Step in/out/over and run all take this path. We first get the status of the
 669  * debugger and then request fresh stack information.
 670  */
 671 - (void)debuggerStep:(NSXMLDocument*)response
 672 {
 673         [self send:[self createCommand:@"status"]];
 674         NSString* command = [[[response rootElement] attributeForName:@"command"] stringValue];
 675         NSUInteger routingID = [[[[response rootElement] attributeForName:@"transaction_id"] stringValue] intValue];
 676
 677         // If this is the run command, tell the delegate that a bunch of updates
 678         // are coming. Also remove all existing stack routes and request a new stack.
 679         if ([command isEqualToString:@"run"])
 680         {
 681                 [delegate clobberStack];
 682                 [stackFrames_ removeAllObjects];
 683                 [self send:[self createCommand:@"stack_depth"]];
 684         }
 685
 686         [self send:[self createRouted:[NSString stringWithFormat:@"%u", routingID] command:@"stack_get -d 0"]];
 687 }
 688
 689 /**
 690  * We ask for the stack_depth and now we clobber the stack and start rebuilding
 691  * it.
 692  */
 693 - (void)rebuildStack:(NSXMLDocument*)response
 694 {
 695         NSInteger depth = [[[[response rootElement] attributeForName:@"depth"] stringValue] intValue];
 696
 697         // We now need to alloc a bunch of stack frames and get the basic information
 698         // for them.
 699         for (NSInteger i = 0; i < depth; i++)
 700         {
 701                 NSString* command = [self createCommand:@"stack_get -d %d", i];
 702
 703                 // Use the transaction ID to create a routing path.
 704                 NSNumber* routingID = [NSNumber numberWithInt:transactionID - 1];
 705                 [stackFrames_ setObject:[StackFrame alloc] forKey:routingID];
 706
 707                 [self send:command];
 708         }
 709 }
 710
 711 /**
 712  * The initial rebuild of the stack frame. We now have enough to initialize
 713  * a StackFrame object.
 714  */
 715 - (void)getStackFrame:(NSXMLDocument*)response
 716 {
 717         // Get the routing information.
 718         NSUInteger routingID = [[[[response rootElement] attributeForName:@"transaction_id"] stringValue] intValue];
 719         NSNumber* routingNumber = [NSNumber numberWithInt:routingID];
 720
 721         // Make sure we initialized this frame in our last |-rebuildStack:|.
 722         StackFrame* frame = [stackFrames_ objectForKey:routingNumber];
 723         if (!frame)
 724                 return;
 725
 726         NSXMLElement* xmlframe = [[[response rootElement] children] objectAtIndex:0];
 727
 728         // Initialize the stack frame.
 729         [frame initWithIndex:[[[xmlframe attributeForName:@"level"] stringValue] intValue]
 730                         withFilename:[[xmlframe attributeForName:@"filename"] stringValue]
 731                           withSource:nil
 732                                   atLine:[[[xmlframe attributeForName:@"lineno"] stringValue] intValue]
 733                           inFunction:[[xmlframe attributeForName:@"where"] stringValue]
 734                    withVariables:nil];
 735
 736         // Now that we have an initialized frame, request additional information.
 737         NSString* routingFormat = @"%u.%d";
 738         NSString* routingPath = nil;
 739
 740         // Get the source code of the file. Escape % in URL chars.
 741         NSString* escapedFilename = [frame.filename stringByReplacingOccurrencesOfString:@"%" withString:@"%%"];
 742         routingPath = [NSString stringWithFormat:routingFormat, routingID, kStackFrameSource];
 743         [self send:[self createRouted:routingPath command:[NSString stringWithFormat:@"source -f %@", escapedFilename]]];
 744
 745         // Get the names of all the contexts.
 746         routingPath = [NSString stringWithFormat:routingFormat, routingID, kStackFrameContexts];
 747         [self send:[self createRouted:routingPath command:@"context_names -d %d", frame.index]];
 748 }
 749
 750 /**
 751  * Routed responses are currently only used in getting all the stack frame data.
 752  */
 753 - (void)handleRouted:(NSArray*)path response:(NSXMLDocument*)response
 754 {
 755         NSLog(@"routed %@ = %@", path, response);
 756
 757         // Format of |path|: transactionID.routingID.component
 758         StackFrameComponent component = [[path objectAtIndex:2] intValue];
 759
 760         // See if we can find the stack frame based on routingID.
 761         NSNumber* routingNumber = [NSNumber numberWithInt:[[path objectAtIndex:1] intValue]];
 762         StackFrame* frame = [stackFrames_ objectForKey:routingNumber];
 763         if (!frame)
 764                 return;
 765
 766         if (component == kStackFrameSource)
 767                 frame.source = [[response rootElement] value];
 768 }
 769
 770 #pragma mark Private
 771
 772 /**
 773  * Helper method to create a string command with the -i <transaction id> automatically tacked on. Takes
 774  * a variable number of arguments and parses the given command with +[NSString stringWithFormat:]
 775  */
 776 - (NSString*)createCommand:(NSString*)cmd, ...
 777 {
 778         // collect varargs
 779         va_list argList;
 780         va_start(argList, cmd);
 781         NSString* format = [[NSString alloc] initWithFormat:cmd arguments:argList]; // format the command
 782         va_end(argList);
 783
 784         return [NSString stringWithFormat:@"%@ -i %d", [format autorelease], transactionID++];
 785 }
 786
 787 /**
 788  * Helper to create a command string. This works a lot like |-createCommand:| but
 789  * it also takes a routing ID, which is used to route response data to specific
 790  * objects.
 791  */
 792 - (NSString*)createRouted:(NSString*)routingID command:(NSString*)cmd, ...
 793 {
 794         va_list argList;
 795         va_start(argList, cmd);
 796         NSString* format = [[NSString alloc] initWithFormat:cmd arguments:argList];
 797         va_end(argList);
 798
 799         return [NSString stringWithFormat:@"%@ -i %d.%@", [format autorelease], transactionID++, routingID];
 800 }
 801
 802 /**
 803  * Checks if there are unsent commands in the |queuedWrites_| queue and sends
 804  * them if it's OK to do so. This will not block.
 805  */
 806 - (void)sendQueuedWrites
 807 {
 808         if (lastReadTransaction_ >= lastWrittenTransaction_ && [queuedWrites_ count] > 0)
 809         {
 810                 NSString* command = [queuedWrites_ objectAtIndex:0];
 811                 NSLog(@"Sending queued write: %@", command);
 812
 813                 // We don't want to block because this is called from the main thread.
 814                 // |-performSend:| busy waits when the stream is not ready. Bail out
 815                 // before we do that becuase busy waiting is BAD.
 816                 if (!CFWriteStreamCanAcceptBytes(writeStream_))
 817                         return;
 818
 819                 [self performSend:command];
 820                 [queuedWrites_ removeObjectAtIndex:0];
 821         }
 822 }
 823
 824 /**
 825  * Generates a stack frame for the given depth
 826  */
 827 - (StackFrame*)createStackFrame:(int)stackDepth
 828 {
 829         // get the names of all the contexts
 830         [socket send:[self createCommand:@"context_names -d 0"]];
 831         NSXMLElement* contextNames = [[self processData:[socket receive]] rootElement];
 832         NSMutableArray* variables = [NSMutableArray array];
 833         for (NSXMLElement* context in [contextNames children])
 834         {
 835                 NSString* name = [[context attributeForName:@"name"] stringValue];
 836                 int cid = [[[context attributeForName:@"id"] stringValue] intValue];
 837
 838                 // fetch the contexts
 839                 [socket send:[self createCommand:[NSString stringWithFormat:@"context_get -d %d -c %d", stackDepth, cid]]];
 840                 NSArray* addVars = [[[self processData:[socket receive]] rootElement] children];
 841                 if (addVars != nil && name != nil)
 842                         [variables addObjectsFromArray:addVars];
 843         }
 844
 845         return nil;
 846 }
 847
 848 /**
 849  * Given a file path, this returns a file:// URI and escapes any spaces for the
 850  * debugger engine.
 851  */
 852 - (NSString*)escapedURIPath:(NSString*)path
 853 {
 854         // Custon GDBp paths are fine.
 855         if ([[path substringToIndex:4] isEqualToString:@"gdbp"])
 856                 return path;
 857
 858         // Create a temporary URL that will escape all the nasty characters.
 859         NSURL* url = [NSURL fileURLWithPath:path];
 860         NSString* urlString = [url absoluteString];
 861
 862         // Remove the host because this is a file:// URL;
 863         urlString = [urlString stringByReplacingOccurrencesOfString:[url host] withString:@""];
 864
 865         // Escape % for use in printf-style NSString formatters.
 866         urlString = [urlString stringByReplacingOccurrencesOfString:@"%" withString:@"%%"];
 867         return urlString;
 868 }
 869
 870 @end