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