Fix PEP8 in lldb_batchmode.py

1 files changed, 112 insertions, 106 deletions

diff --git a/src/etc/lldb_batchmode.py b/src/etc/lldb_batchmode.py
index 25e5661ca49..b1506285b3a 100644
--- a/src/etc/lldb_batchmode.py
+++ b/src/etc/lldb_batchmode.py
@@ -30,36 +30,35 @@ import sys
 import threading
 import thread
 import re
-import atexit
 import time
 
 # Set this to True for additional output
 DEBUG_OUTPUT = False
 
+
 def print_debug(s):
-  "Print something if DEBUG_OUTPUT is True"
-  global DEBUG_OUTPUT
-  if DEBUG_OUTPUT:
-    print("DEBUG: " + str(s))
+    "Print something if DEBUG_OUTPUT is True"
+    global DEBUG_OUTPUT
+    if DEBUG_OUTPUT:
+        print("DEBUG: " + str(s))
 
 
 def normalize_whitespace(s):
-  "Replace newlines, tabs, multiple spaces, etc with exactly one space"
-  return re.sub("\s+", " ", s)
+    "Replace newlines, tabs, multiple spaces, etc with exactly one space"
+    return re.sub("\s+", " ", s)
 
 
-# This callback is registered with every breakpoint and makes sure that the frame containing the
-# breakpoint location is selected
 def breakpoint_callback(frame, bp_loc, dict):
-  "Called whenever a breakpoint is hit"
-  print("Hit breakpoint " + str(bp_loc))
+    """This callback is registered with every breakpoint and makes sure that the
+    frame containing the breakpoint location is selected"""
+    print("Hit breakpoint " + str(bp_loc))
 
-  # Select the frame and the thread containing it
-  frame.thread.process.SetSelectedThread(frame.thread)
-  frame.thread.SetSelectedFrame(frame.idx)
+    # Select the frame and the thread containing it
+    frame.thread.process.SetSelectedThread(frame.thread)
+    frame.thread.SetSelectedFrame(frame.idx)
 
-  # Returning True means that we actually want to stop at this breakpoint
-  return True
+    # Returning True means that we actually want to stop at this breakpoint
+    return True
 
 
 # This is a list of breakpoints that are not registered with the breakpoint callback. The list is
@@ -70,91 +69,99 @@ new_breakpoints = []
 # used to avoid hooking callbacks into breakpoints more than once
 registered_breakpoints = set()
 
+
 def execute_command(command_interpreter, command):
-  "Executes a single CLI command"
-  global new_breakpoints
-  global registered_breakpoints
-
-  res = lldb.SBCommandReturnObject()
-  print(command)
-  command_interpreter.HandleCommand(command, res)
-
-  if res.Succeeded():
-      if res.HasResult():
-          print(normalize_whitespace(res.GetOutput()), end = '\n')
-
-      # If the command introduced any breakpoints, make sure to register them with the breakpoint
-      # callback
-      while len(new_breakpoints) > 0:
-        res.Clear()
-        breakpoint_id = new_breakpoints.pop()
-
-        if breakpoint_id in registered_breakpoints:
-          print_debug("breakpoint with id %s is already registered. Ignoring." % str(breakpoint_id))
-        else:
-          print_debug("registering breakpoint callback, id = " + str(breakpoint_id))
-          callback_command = "breakpoint command add -F breakpoint_callback " + str(breakpoint_id)
-          command_interpreter.HandleCommand(callback_command, res)
-          if res.Succeeded():
-            print_debug("successfully registered breakpoint callback, id = " + str(breakpoint_id))
-            registered_breakpoints.add(breakpoint_id)
-          else:
-            print("Error while trying to register breakpoint callback, id = " + str(breakpoint_id))
-  else:
-      print(res.GetError())
+    "Executes a single CLI command"
+    global new_breakpoints
+    global registered_breakpoints
+
+    res = lldb.SBCommandReturnObject()
+    print(command)
+    command_interpreter.HandleCommand(command, res)
+
+    if res.Succeeded():
+        if res.HasResult():
+            print(normalize_whitespace(res.GetOutput()), end='\n')
+
+        # If the command introduced any breakpoints, make sure to register
+        # them with the breakpoint
+        # callback
+        while len(new_breakpoints) > 0:
+            res.Clear()
+            breakpoint_id = new_breakpoints.pop()
+
+            if breakpoint_id in registered_breakpoints:
+                print_debug("breakpoint with id %s is already registered. Ignoring." %
+                            str(breakpoint_id))
+            else:
+                print_debug("registering breakpoint callback, id = " + str(breakpoint_id))
+                callback_command = ("breakpoint command add -F breakpoint_callback " +
+                                    str(breakpoint_id))
+                command_interpreter.HandleCommand(callback_command, res)
+                if res.Succeeded():
+                    print_debug("successfully registered breakpoint callback, id = " +
+                                str(breakpoint_id))
+                    registered_breakpoints.add(breakpoint_id)
+                else:
+                    print("Error while trying to register breakpoint callback, id = " +
+                          str(breakpoint_id))
+    else:
+        print(res.GetError())
 
 
 def start_breakpoint_listener(target):
-  "Listens for breakpoints being added and adds new ones to the callback registration list"
-  listener = lldb.SBListener("breakpoint listener")
-
-  def listen():
-    event = lldb.SBEvent()
-    try:
-      while True:
-        if listener.WaitForEvent(120, event):
-          if lldb.SBBreakpoint.EventIsBreakpointEvent(event) and \
-             lldb.SBBreakpoint.GetBreakpointEventTypeFromEvent(event) == \
-             lldb.eBreakpointEventTypeAdded:
-            global new_breakpoints
-            breakpoint = lldb.SBBreakpoint.GetBreakpointFromEvent(event)
-            print_debug("breakpoint added, id = " + str(breakpoint.id))
-            new_breakpoints.append(breakpoint.id)
-    except:
-      print_debug("breakpoint listener shutting down")
-
-  # Start the listener and let it run as a daemon
-  listener_thread = threading.Thread(target = listen)
-  listener_thread.daemon = True
-  listener_thread.start()
-
-  # Register the listener with the target
-  target.GetBroadcaster().AddListener(listener, lldb.SBTarget.eBroadcastBitBreakpointChanged)
+    """Listens for breakpoints being added and adds new ones to the callback
+    registration list"""
+    listener = lldb.SBListener("breakpoint listener")
+
+    def listen():
+        event = lldb.SBEvent()
+        try:
+            while True:
+                if listener.WaitForEvent(120, event):
+                    if lldb.SBBreakpoint.EventIsBreakpointEvent(event) and \
+                            lldb.SBBreakpoint.GetBreakpointEventTypeFromEvent(event) == \
+                            lldb.eBreakpointEventTypeAdded:
+                        global new_breakpoints
+                        breakpoint = lldb.SBBreakpoint.GetBreakpointFromEvent(event)
+                        print_debug("breakpoint added, id = " + str(breakpoint.id))
+                        new_breakpoints.append(breakpoint.id)
+        except:
+            print_debug("breakpoint listener shutting down")
+
+    # Start the listener and let it run as a daemon
+    listener_thread = threading.Thread(target=listen)
+    listener_thread.daemon = True
+    listener_thread.start()
+
+    # Register the listener with the target
+    target.GetBroadcaster().AddListener(listener, lldb.SBTarget.eBroadcastBitBreakpointChanged)
 
 
 def start_watchdog():
-  "Starts a watchdog thread that will terminate the process after a certain period of time"
-  watchdog_start_time = time.clock()
-  watchdog_max_time = watchdog_start_time + 30
-
-  def watchdog():
-    while time.clock() < watchdog_max_time:
-      time.sleep(1)
-    print("TIMEOUT: lldb_batchmode.py has been running for too long. Aborting!")
-    thread.interrupt_main()
-
-  # Start the listener and let it run as a daemon
-  watchdog_thread = threading.Thread(target = watchdog)
-  watchdog_thread.daemon = True
-  watchdog_thread.start()
+    """Starts a watchdog thread that will terminate the process after a certain
+    period of time"""
+    watchdog_start_time = time.clock()
+    watchdog_max_time = watchdog_start_time + 30
+
+    def watchdog():
+        while time.clock() < watchdog_max_time:
+            time.sleep(1)
+        print("TIMEOUT: lldb_batchmode.py has been running for too long. Aborting!")
+        thread.interrupt_main()
+
+    # Start the listener and let it run as a daemon
+    watchdog_thread = threading.Thread(target=watchdog)
+    watchdog_thread.daemon = True
+    watchdog_thread.start()
 
 ####################################################################################################
 # ~main
 ####################################################################################################
 
 if len(sys.argv) != 3:
-  print("usage: python lldb_batchmode.py target-path script-path")
-  sys.exit(1)
+    print("usage: python lldb_batchmode.py target-path script-path")
+    sys.exit(1)
 
 target_path = sys.argv[1]
 script_path = sys.argv[2]
@@ -181,9 +188,9 @@ target_error = lldb.SBError()
 target = debugger.CreateTarget(target_path, None, None, True, target_error)
 
 if not target:
-  print("Could not create debugging target '" + target_path + "': " + str(target_error) +
-        ". Aborting.", file=sys.stderr)
-  sys.exit(1)
+    print("Could not create debugging target '" + target_path + "': " +
+          str(target_error) + ". Aborting.", file=sys.stderr)
+    sys.exit(1)
 
 
 # Register the breakpoint callback for every breakpoint
@@ -192,22 +199,21 @@ start_breakpoint_listener(target)
 command_interpreter = debugger.GetCommandInterpreter()
 
 try:
-  script_file = open(script_path, 'r')
+    script_file = open(script_path, 'r')
 
-  for line in script_file:
-    command = line.strip()
-    if command == "run" or command == "r" or re.match("^process\s+launch.*", command):
-      # Before starting to run the program, let the thread sleep a bit, so all
-      # breakpoint added events can be processed
-      time.sleep(0.5)
-    if command != '':
-      execute_command(command_interpreter, command)
+    for line in script_file:
+        command = line.strip()
+        if command == "run" or command == "r" or re.match("^process\s+launch.*", command):
+            # Before starting to run the program, let the thread sleep a bit, so all
+            # breakpoint added events can be processed
+            time.sleep(0.5)
+        if command != '':
+            execute_command(command_interpreter, command)
 
 except IOError as e:
-  print("Could not read debugging script '%s'." % script_path, file = sys.stderr)
-  print(e, file = sys.stderr)
-  print("Aborting.", file = sys.stderr)
-  sys.exit(1)
+    print("Could not read debugging script '%s'." % script_path, file=sys.stderr)
+    print(e, file=sys.stderr)
+    print("Aborting.", file=sys.stderr)
+    sys.exit(1)
 finally:
-  script_file.close()
-
+    script_file.close()