Source/DebuggerConnection.m

   1 /*
   2  * MacGDBp
   3  * Copyright (c) 2002 - 2007, 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 "DebuggerConnection.h"
  18
  19 @interface DebuggerConnection (Private)
  20
  21 - (NSString *)createCommand: (NSString *)cmd;
  22
  23 @end
  24
  25 @implementation DebuggerConnection
  26
  27 /**
  28  * Creates a new DebuggerConnection and initializes the socket from the given connection
  29  * paramters.
  30  */
  31 - (id)initWithPort: (int)port session: (NSString *)session
  32 {
  33         if (self = [super init])
  34         {
  35                 _port = port;
  36                 _session = [session retain];
  37                 _connected = NO;
  38
  39                 _windowController = [[DebuggerWindowController alloc] initWithConnection: self];
  40                 [[_windowController window] makeKeyAndOrderFront: self];
  41
  42                 // now that we have our host information, open the socket
  43                 _socket = [[SocketWrapper alloc] initWithPort: port];
  44                 [_socket setDelegate: self];
  45                 [_windowController setStatus: @"Connecting"];
  46                 [_socket connect];
  47
  48                 // clean up after ourselves
  49                 [[NSNotificationCenter defaultCenter] addObserver: self
  50                                                                                                  selector: @selector(applicationWillTerminate:)
  51                                                                                                          name: NSApplicationWillTerminateNotification
  52                                                                                                    object: NSApp];
  53         }
  54         return self;
  55 }
  56
  57 /**
  58  * Release ourselves when we're about to die
  59  */
  60 - (void)applicationWillTerminate: (NSNotification *)notif
  61 {
  62         [self release];
  63 }
  64
  65 /**
  66  * Releases all of the object's data members and closes the streams
  67  */
  68 - (void)dealloc
  69 {
  70         [_session release];
  71         [_socket release];
  72
  73         [super dealloc];
  74 }
  75
  76 /**
  77  * Gets the port number
  78  */
  79 - (int)port
  80 {
  81         return _port;
  82 }
  83
  84 /**
  85  * Gets the session name
  86  */
  87 - (NSString *)session
  88 {
  89         return _session;
  90 }
  91
  92 /**
  93  * Returns the name of the remote host
  94  */
  95 - (NSString *)remoteHost
  96 {
  97         if (!_connected)
  98         {
  99                 return @"(DISCONNECTED)";
 100         }
 101         return [_socket remoteHost];
 102 }
 103
 104 /**
 105  * SocketWrapper delegate method that is called whenever new data is received
 106  */
 107 - (void)dataReceived: (NSData *)response deliverTo: (SEL)selector
 108 {
 109         // if the caller of [_socket receive:] specified a deliverTo, just forward the message to them
 110         if (selector != nil)
 111         {
 112                 [self performSelector: selector withObject: response];
 113         }
 114 }
 115
 116 /**
 117  * SocketWrapper delegate method that is called after data is sent. This really
 118  * isn't useful for much.
 119  */
 120 - (void)dataSent: (NSString *)data
 121 {
 122         NSLog(@"send = %@", data);
 123 }
 124
 125 /**
 126  * Called by SocketWrapper after the connection is successful. This immediately calls
 127  * -[SocketWrapper receive] to clear the way for communication
 128  */
 129 - (void)socketDidAccept
 130 {
 131         _connected = YES;
 132         [_socket receive: @selector(handshake:)];
 133 }
 134
 135 /**
 136  * Receives errors from the SocketWrapper and updates the display
 137  */
 138 - (void)errorEncountered: (NSError *)error
 139 {
 140         [_windowController setError: [error domain]];
 141 }
 142
 143 /**
 144  * The initial packet handshake. This allows us to set things like the title of the window
 145  * and glean information about hte server we are debugging
 146  */
 147 - (void)handshake: (NSData *)packet
 148 {
 149         [self refreshStatus];
 150 }
 151
 152 /**
 153  * Handler used by dataReceived:deliverTo: for anytime the status command is issued. It sets
 154  * the window controller's status text
 155  */
 156 - (void)updateStatus: (NSData *)packet
 157 {
 158         NSXMLDocument *doc = [[NSXMLDocument alloc] initWithData: packet options: NSXMLDocumentTidyXML error: nil];
 159         [_windowController setStatus: [[[[doc rootElement] attributeForName: @"status"] stringValue] capitalizedString]];
 160         [doc release];
 161 }
 162
 163 /**
 164  * Tells the debugger to continue running the script
 165  */
 166 - (void)run
 167 {
 168         [_socket send: [self createCommand: @"run"]];
 169         [self refreshStatus];
 170 }
 171
 172 /**
 173  * Method that runs tells the debugger to give us its status. This will call _updateStatus
 174  * and will update the status text on the window
 175  */
 176 - (void)refreshStatus
 177 {
 178         [_socket send: [self createCommand: @"status"]];
 179         [_socket receive: @selector(updateStatus:)];
 180 }
 181
 182 /**
 183  * Tells the debugger to step into the current command.
 184  */
 185 - (void)stepIn
 186 {
 187         [_socket send: [self createCommand: @"step_into"]];
 188         [_socket receive: nil];
 189         [self refreshStatus];
 190         [self updateStackTraceAndRegisters];
 191 }
 192
 193 /**
 194  * Tells the debugger to step out of the current context
 195  */
 196 - (void)stepOut
 197 {
 198         [_socket send: [self createCommand: @"step_out"]];
 199         [_socket receive: nil];
 200         [self refreshStatus];
 201         [self updateStackTraceAndRegisters];
 202 }
 203
 204 /**
 205  * Tells the debugger to step over the current function
 206  */
 207 - (void)stepOver
 208 {
 209         [_socket send: [self createCommand: @"step_over"]];
 210         [_socket receive: nil];
 211         [self refreshStatus];
 212         [self updateStackTraceAndRegisters];
 213 }
 214
 215 /**
 216  * This function queries the debug server for the current stacktrace and all the registers on
 217  * level one. If a user then tries to expand past level one... TOOD: HOLY CRAP WHAT DO WE DO PAST LEVEL 1?
 218  */
 219 - (void)updateStackTraceAndRegisters
 220 {
 221         [_socket send: [self createCommand: @"stack_get"]];
 222         [_socket receive: @selector(stackReceived:)];
 223
 224         [_socket send: [self createCommand: @"context_get"]];
 225         [_socket receive: @selector(registerReceived:)];
 226 }
 227
 228 /**
 229  * Called by the dataReceived delivery delegate. This updates the window controller's data
 230  * for the stack trace
 231  */
 232 - (void)stackReceived: (NSData *)packet
 233 {
 234         NSXMLDocument *doc = [[NSXMLDocument alloc] initWithData: packet options: NSXMLDocumentTidyXML error: nil];
 235         NSArray *children = [[doc rootElement] children];
 236         NSMutableArray *stack = [NSMutableArray array];
 237         NSMutableDictionary *dict = [NSMutableDictionary dictionary];
 238         for (int i = 0; i < [children count]; i++)
 239         {
 240                 NSArray *attrs = [[children objectAtIndex: i] attributes];
 241                 for (int j = 0; j < [attrs count]; j++)
 242                 {
 243                         [dict setValue: [[attrs objectAtIndex: j] stringValue] forKey: [[attrs objectAtIndex: j] name]];
 244                 }
 245                 [stack addObject: dict];
 246                 dict = [NSMutableDictionary dictionary];
 247         }
 248         [_windowController setStack: stack];
 249         [doc release];
 250 }
 251
 252 /**
 253  * Called when we have a new register to display
 254  */
 255 - (void)registerReceived: (NSData *)packet
 256 {
 257         NSXMLDocument *doc = [[NSXMLDocument alloc] initWithData: packet options: NSXMLDocumentTidyXML error: nil];
 258         [_windowController setRegister: [doc rootElement]];
 259         [doc release];
 260 }
 261
 262 /**
 263  * Tells the debugger engine to get a specifc property. This also takes in the NSXMLElement
 264  * that requested it so that the child can be attached in the delivery.
 265  */
 266 - (void)getProperty: (NSString *)property forElement: (NSXMLElement *)elm
 267 {
 268         [_socket send: [self createCommand: [NSString stringWithFormat: @"property_get -n \"%@\"", property, depth]]];
 269         _depthFetchElement = elm;
 270         [_socket receive: @selector(propertyReceived:)];
 271 }
 272
 273 /**
 274  * Called when a property is received. This then adds the result as children to the passed object
 275  */
 276 - (void)propertyReceived: (NSData *)packet
 277 {
 278         NSXMLDocument *doc = [[NSXMLDocument alloc] initWithData: packet options: NSXMLDocumentTidyXML error: nil];
 279         /*
 280          <response>
 281                 <property> <!-- this is the one we requested -->
 282                         <property ... /> <!-- these are what we want -->
 283                 </property>
 284         </repsonse>
 285          */
 286         [_depthFetchElement setChildren: [[[doc rootElement] nextSibling] children]];
 287         _depthFetchElement = nil;
 288         [doc release];
 289 }
 290
 291 /**
 292  * Helper method to create a string command with the -i <session> automatically tacked on
 293  */
 294 - (NSString *)createCommand: (NSString *)cmd
 295 {
 296         return [NSString stringWithFormat: @"%@ -i %@", cmd, _session];
 297 }
 298
 299 @end