vendor/lldb/lldb-trunk-r290819

3 files changed, 218 insertions, 83 deletions

diff --git a/packages/Python/lldbsuite/test/python_api/frame/TestFrames.py b/packages/Python/lldbsuite/test/python_api/frame/TestFrames.py
index 0b1e12b08fcbf..06ca772073acb 100644
--- a/packages/Python/lldbsuite/test/python_api/frame/TestFrames.py
+++ b/packages/Python/lldbsuite/test/python_api/frame/TestFrames.py
@@ -6,14 +6,15 @@ And other SBFrame API tests.
 from __future__ import print_function
 
 
-
-import os, time
+import os
+import time
 import re
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
+
 class FrameAPITestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
@@ -37,7 +38,8 @@ class FrameAPITestCase(TestBase):
                         VALID_BREAKPOINT)
 
         # Now launch the process, and do not stop at the entry point.
-        process = target.LaunchSimple (None, None, self.get_process_working_directory())
+        process = target.LaunchSimple(
+            None, None, self.get_process_working_directory())
 
         process = target.GetProcess()
         self.assertTrue(process.GetState() == lldb.eStateStopped,
@@ -50,7 +52,8 @@ class FrameAPITestCase(TestBase):
         from six import StringIO as SixStringIO
         session = SixStringIO()
         while process.GetState() == lldb.eStateStopped:
-            thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint)
+            thread = lldbutil.get_stopped_thread(
+                process, lldb.eStopReasonBreakpoint)
             self.assertIsNotNone(thread)
             # Inspect at most 3 frames.
             numFrames = min(3, thread.GetNumFrames())
@@ -76,27 +79,35 @@ class FrameAPITestCase(TestBase):
                                                   val.GetName(),
                                                   val.GetValue()))
                 print("%s(%s)" % (name, ", ".join(argList)), file=session)
-                
+
                 # Also check the generic pc & stack pointer.  We can't test their absolute values,
-                # but they should be valid.  Uses get_GPRs() from the lldbutil module.
+                # but they should be valid.  Uses get_GPRs() from the lldbutil
+                # module.
                 gpr_reg_set = lldbutil.get_GPRs(frame)
                 pc_value = gpr_reg_set.GetChildMemberWithName("pc")
-                self.assertTrue (pc_value, "We should have a valid PC.")
+                self.assertTrue(pc_value, "We should have a valid PC.")
                 pc_value_int = int(pc_value.GetValue(), 0)
                 # Make sure on arm targets we dont mismatch PC value on the basis of thumb bit.
-                # Frame PC will not have thumb bit set in case of a thumb instruction as PC.
+                # Frame PC will not have thumb bit set in case of a thumb
+                # instruction as PC.
                 if self.getArchitecture() in ['arm']:
                     pc_value_int &= ~1
-                self.assertTrue (pc_value_int == frame.GetPC(), "PC gotten as a value should equal frame's GetPC")
+                self.assertTrue(
+                    pc_value_int == frame.GetPC(),
+                    "PC gotten as a value should equal frame's GetPC")
                 sp_value = gpr_reg_set.GetChildMemberWithName("sp")
-                self.assertTrue (sp_value, "We should have a valid Stack Pointer.")
-                self.assertTrue (int(sp_value.GetValue(), 0) == frame.GetSP(), "SP gotten as a value should equal frame's GetSP")
+                self.assertTrue(
+                    sp_value, "We should have a valid Stack Pointer.")
+                self.assertTrue(int(sp_value.GetValue(), 0) == frame.GetSP(
+                ), "SP gotten as a value should equal frame's GetSP")
 
             print("---", file=session)
             process.Continue()
 
         # At this point, the inferior process should have exited.
-        self.assertTrue(process.GetState() == lldb.eStateExited, PROCESS_EXITED)
+        self.assertTrue(
+            process.GetState() == lldb.eStateExited,
+            PROCESS_EXITED)
 
         # Expect to find 'a' on the call stacks two times.
         self.assertTrue(callsOfA == 2,
@@ -109,8 +120,8 @@ class FrameAPITestCase(TestBase):
             print(session.getvalue())
         self.expect(session.getvalue(), "Argugment values displayed correctly",
                     exe=False,
-            substrs = ["a((int)val=1, (char)ch='A')",
-                       "a((int)val=3, (char)ch='A')"])
+                    substrs=["a((int)val=1, (char)ch='A')",
+                             "a((int)val=3, (char)ch='A')"])
 
     @add_test_categories(['pyapi'])
     def test_frame_api_boundary_condition(self):
@@ -130,13 +141,15 @@ class FrameAPITestCase(TestBase):
                         VALID_BREAKPOINT)
 
         # Now launch the process, and do not stop at the entry point.
-        process = target.LaunchSimple (None, None, self.get_process_working_directory())
+        process = target.LaunchSimple(
+            None, None, self.get_process_working_directory())
 
         process = target.GetProcess()
         self.assertTrue(process.GetState() == lldb.eStateStopped,
                         PROCESS_STOPPED)
 
-        thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint)
+        thread = lldbutil.get_stopped_thread(
+            process, lldb.eStopReasonBreakpoint)
         self.assertIsNotNone(thread)
         frame = thread.GetFrameAtIndex(0)
         if self.TraceOn():
@@ -170,13 +183,15 @@ class FrameAPITestCase(TestBase):
                         VALID_BREAKPOINT)
 
         # Now launch the process, and do not stop at the entry point.
-        process = target.LaunchSimple (None, None, self.get_process_working_directory())
+        process = target.LaunchSimple(
+            None, None, self.get_process_working_directory())
 
         process = target.GetProcess()
         self.assertTrue(process.GetState() == lldb.eStateStopped,
                         PROCESS_STOPPED)
 
-        thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint)
+        thread = lldbutil.get_stopped_thread(
+            process, lldb.eStopReasonBreakpoint)
         self.assertIsNotNone(thread)
 
         frameEntered = thread.GetFrameAtIndex(0)
diff --git a/packages/Python/lldbsuite/test/python_api/frame/get-variables/TestGetVariables.py b/packages/Python/lldbsuite/test/python_api/frame/get-variables/TestGetVariables.py
index 914c3d25fd5d9..86585d8d02e22 100644
--- a/packages/Python/lldbsuite/test/python_api/frame/get-variables/TestGetVariables.py
+++ b/packages/Python/lldbsuite/test/python_api/frame/get-variables/TestGetVariables.py
@@ -5,20 +5,22 @@ Test that SBFrame::GetVariables() calls work correctly.
 from __future__ import print_function
 
 
-
-import os, time
+import os
+import time
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbplatform
 from lldbsuite.test import lldbutil
 
+
 def get_names_from_value_list(value_list):
     names = list()
     for value in value_list:
         names.append(value.GetName())
     return names
 
+
 class TestGetVariables(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
@@ -35,12 +37,16 @@ class TestGetVariables(TestBase):
             if name in copy_names:
                 copy_names.remove(name)
             else:
-                self.assertTrue(False, "didn't find '%s' in %s" % (name, copy_names))
-        self.assertEqual(len(copy_names), 0, "%s: we didn't find variables: %s in value list (%s)" % (description, copy_names, actual_names))
+                self.assertTrue(
+                    False, "didn't find '%s' in %s" %
+                    (name, copy_names))
+        self.assertEqual(
+            len(copy_names), 0, "%s: we didn't find variables: %s in value list (%s)" %
+            (description, copy_names, actual_names))
+
+    def test(self):
+        self.build()
 
-    def test (self):
-        self.build ()
-        
         # Set debugger into synchronous mode
         self.dbg.SetAsync(False)
 
@@ -48,36 +54,42 @@ class TestGetVariables(TestBase):
         exe = os.path.join(os.getcwd(), "a.out")
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
-                                                                              
+
         line1 = line_number(self.source, '// breakpoint 1')
         line2 = line_number(self.source, '// breakpoint 2')
         line3 = line_number(self.source, '// breakpoint 3')
 
-        breakpoint1 = target.BreakpointCreateByLocation (self.source, line1);
-        breakpoint2 = target.BreakpointCreateByLocation (self.source, line2);
-        breakpoint3 = target.BreakpointCreateByLocation (self.source, line3);
+        breakpoint1 = target.BreakpointCreateByLocation(self.source, line1)
+        breakpoint2 = target.BreakpointCreateByLocation(self.source, line2)
+        breakpoint3 = target.BreakpointCreateByLocation(self.source, line3)
 
         self.assertTrue(breakpoint1.GetNumLocations() >= 1, PROCESS_IS_VALID)
         self.assertTrue(breakpoint2.GetNumLocations() >= 1, PROCESS_IS_VALID)
         self.assertTrue(breakpoint3.GetNumLocations() >= 1, PROCESS_IS_VALID)
 
-        # Register our shared libraries for remote targets so they get automatically uploaded
+        # Register our shared libraries for remote targets so they get
+        # automatically uploaded
         arguments = None
-        environment = None 
+        environment = None
 
         # Now launch the process, and do not stop at entry point.
-        process = target.LaunchSimple (arguments, environment, self.get_process_working_directory())
+        process = target.LaunchSimple(
+            arguments, environment, self.get_process_working_directory())
         self.assertTrue(process, PROCESS_IS_VALID)
-        
-        threads = lldbutil.get_threads_stopped_at_breakpoint (process, breakpoint1)
-        self.assertEqual(len(threads), 1, "There should be a thread stopped at breakpoint 1")
-                        
+
+        threads = lldbutil.get_threads_stopped_at_breakpoint(
+            process, breakpoint1)
+        self.assertEqual(
+            len(threads),
+            1,
+            "There should be a thread stopped at breakpoint 1")
+
         thread = threads[0]
         self.assertTrue(thread.IsValid(), "Thread must be valid")
         frame = thread.GetFrameAtIndex(0)
         self.assertTrue(frame.IsValid(), "Frame must be valid")
-        
-        arg_names = ['argc', 'argv']   
+
+        arg_names = ['argc', 'argv']
         local_names = ['i', 'j', 'k']
         static_names = ['static_var', 'g_global_var', 'g_static_var']
         breakpoint1_locals = ['i']
@@ -95,96 +107,190 @@ class TestGetVariables(TestBase):
         ignore_scope = False
 
         # Verify if we ask for only arguments that we got what we expect
-        vars = frame.GetVariables(args_yes, locals_no, statics_no, ignore_scope)
-        self.assertEqual(vars.GetSize(), num_args, "There should be %i arguments, but we are reporting %i" % (num_args, vars.GetSize()))    
+        vars = frame.GetVariables(
+            args_yes, locals_no, statics_no, ignore_scope)
+        self.assertEqual(
+            vars.GetSize(),
+            num_args,
+            "There should be %i arguments, but we are reporting %i" %
+            (num_args,
+             vars.GetSize()))
         self.verify_variable_names("check names of arguments", vars, arg_names)
-        self.assertEqual(len(arg_names), num_args, "make sure verify_variable_names() didn't mutate list")
+        self.assertEqual(
+            len(arg_names),
+            num_args,
+            "make sure verify_variable_names() didn't mutate list")
 
         # Verify if we ask for only locals that we got what we expect
-        vars = frame.GetVariables(args_no, locals_yes, statics_no, ignore_scope)   
-        self.assertEqual(vars.GetSize(), num_locals, "There should be %i local variables, but we are reporting %i" % (num_locals, vars.GetSize()))    
+        vars = frame.GetVariables(
+            args_no, locals_yes, statics_no, ignore_scope)
+        self.assertEqual(
+            vars.GetSize(),
+            num_locals,
+            "There should be %i local variables, but we are reporting %i" %
+            (num_locals,
+             vars.GetSize()))
         self.verify_variable_names("check names of locals", vars, local_names)
 
         # Verify if we ask for only statics that we got what we expect
-        vars = frame.GetVariables(args_no, locals_no, statics_yes, ignore_scope)   
+        vars = frame.GetVariables(
+            args_no, locals_no, statics_yes, ignore_scope)
         print('statics: ', str(vars))
-        self.assertEqual(vars.GetSize(), num_statics, "There should be %i static variables, but we are reporting %i" % (num_statics, vars.GetSize()))    
-        self.verify_variable_names("check names of statics", vars, static_names)
+        self.assertEqual(
+            vars.GetSize(),
+            num_statics,
+            "There should be %i static variables, but we are reporting %i" %
+            (num_statics,
+             vars.GetSize()))
+        self.verify_variable_names(
+            "check names of statics", vars, static_names)
 
         # Verify if we ask for arguments and locals that we got what we expect
-        vars = frame.GetVariables(args_yes, locals_yes, statics_no, ignore_scope)
+        vars = frame.GetVariables(
+            args_yes, locals_yes, statics_no, ignore_scope)
         desc = 'arguments + locals'
         names = arg_names + local_names
         count = len(names)
-        self.assertEqual(vars.GetSize(), count, "There should be %i %s (%s) but we are reporting %i (%s)" % (count, desc, names, vars.GetSize(), get_names_from_value_list(vars)))    
+        self.assertEqual(
+            vars.GetSize(),
+            count,
+            "There should be %i %s (%s) but we are reporting %i (%s)" %
+            (count,
+             desc,
+             names,
+             vars.GetSize(),
+             get_names_from_value_list(vars)))
         self.verify_variable_names("check names of %s" % (desc), vars, names)
 
         # Verify if we ask for arguments and statics that we got what we expect
-        vars = frame.GetVariables(args_yes, locals_no, statics_yes, ignore_scope)
+        vars = frame.GetVariables(
+            args_yes, locals_no, statics_yes, ignore_scope)
         desc = 'arguments + statics'
         names = arg_names + static_names
         count = len(names)
-        self.assertEqual(vars.GetSize(), count, "There should be %i %s (%s) but we are reporting %i (%s)" % (count, desc, names, vars.GetSize(), get_names_from_value_list(vars)))    
+        self.assertEqual(
+            vars.GetSize(),
+            count,
+            "There should be %i %s (%s) but we are reporting %i (%s)" %
+            (count,
+             desc,
+             names,
+             vars.GetSize(),
+             get_names_from_value_list(vars)))
         self.verify_variable_names("check names of %s" % (desc), vars, names)
 
         # Verify if we ask for locals and statics that we got what we expect
-        vars = frame.GetVariables(args_no, locals_yes, statics_yes, ignore_scope)
+        vars = frame.GetVariables(
+            args_no, locals_yes, statics_yes, ignore_scope)
         desc = 'locals + statics'
         names = local_names + static_names
         count = len(names)
-        self.assertEqual(vars.GetSize(), count, "There should be %i %s (%s) but we are reporting %i (%s)" % (count, desc, names, vars.GetSize(), get_names_from_value_list(vars)))    
+        self.assertEqual(
+            vars.GetSize(),
+            count,
+            "There should be %i %s (%s) but we are reporting %i (%s)" %
+            (count,
+             desc,
+             names,
+             vars.GetSize(),
+             get_names_from_value_list(vars)))
         self.verify_variable_names("check names of %s" % (desc), vars, names)
 
-        # Verify if we ask for arguments, locals and statics that we got what we expect
-        vars = frame.GetVariables(args_yes, locals_yes, statics_yes, ignore_scope)
+        # Verify if we ask for arguments, locals and statics that we got what
+        # we expect
+        vars = frame.GetVariables(
+            args_yes, locals_yes, statics_yes, ignore_scope)
         desc = 'arguments + locals + statics'
         names = arg_names + local_names + static_names
         count = len(names)
-        self.assertEqual(vars.GetSize(), count, "There should be %i %s (%s) but we are reporting %i (%s)" % (count, desc, names, vars.GetSize(), get_names_from_value_list(vars)))    
+        self.assertEqual(
+            vars.GetSize(),
+            count,
+            "There should be %i %s (%s) but we are reporting %i (%s)" %
+            (count,
+             desc,
+             names,
+             vars.GetSize(),
+             get_names_from_value_list(vars)))
         self.verify_variable_names("check names of %s" % (desc), vars, names)
 
         # Verify if we ask for in scope locals that we got what we expect
-        vars = frame.GetVariables(args_no, locals_yes, statics_no, in_scopy_only)   
+        vars = frame.GetVariables(
+            args_no, locals_yes, statics_no, in_scopy_only)
         desc = 'in scope locals at breakpoint 1'
         names = ['i']
         count = len(names)
-        self.assertEqual(vars.GetSize(), count, "There should be %i %s (%s) but we are reporting %i (%s)" % (count, desc, names, vars.GetSize(), get_names_from_value_list(vars)))    
+        self.assertEqual(
+            vars.GetSize(),
+            count,
+            "There should be %i %s (%s) but we are reporting %i (%s)" %
+            (count,
+             desc,
+             names,
+             vars.GetSize(),
+             get_names_from_value_list(vars)))
         self.verify_variable_names("check names of %s" % (desc), vars, names)
-                             
+
         # Continue to breakpoint 2
         process.Continue()
-                                     
-        threads = lldbutil.get_threads_stopped_at_breakpoint (process, breakpoint2)
-        self.assertEqual(len(threads), 1, "There should be a thread stopped at breakpoint 2")
-                        
+
+        threads = lldbutil.get_threads_stopped_at_breakpoint(
+            process, breakpoint2)
+        self.assertEqual(
+            len(threads),
+            1,
+            "There should be a thread stopped at breakpoint 2")
+
         thread = threads[0]
         self.assertTrue(thread.IsValid(), "Thread must be valid")
         frame = thread.GetFrameAtIndex(0)
         self.assertTrue(frame.IsValid(), "Frame must be valid")
 
         # Verify if we ask for in scope locals that we got what we expect
-        vars = frame.GetVariables(args_no, locals_yes, statics_no, in_scopy_only)   
+        vars = frame.GetVariables(
+            args_no, locals_yes, statics_no, in_scopy_only)
         desc = 'in scope locals at breakpoint 2'
         names = ['i', 'j']
         count = len(names)
-        self.assertEqual(vars.GetSize(), count, "There should be %i %s (%s) but we are reporting %i (%s)" % (count, desc, names, vars.GetSize(), get_names_from_value_list(vars)))    
+        self.assertEqual(
+            vars.GetSize(),
+            count,
+            "There should be %i %s (%s) but we are reporting %i (%s)" %
+            (count,
+             desc,
+             names,
+             vars.GetSize(),
+             get_names_from_value_list(vars)))
         self.verify_variable_names("check names of %s" % (desc), vars, names)
 
         # Continue to breakpoint 3
         process.Continue()
-                                     
-        threads = lldbutil.get_threads_stopped_at_breakpoint (process, breakpoint3)
-        self.assertEqual(len(threads), 1, "There should be a thread stopped at breakpoint 3")
-                        
+
+        threads = lldbutil.get_threads_stopped_at_breakpoint(
+            process, breakpoint3)
+        self.assertEqual(
+            len(threads),
+            1,
+            "There should be a thread stopped at breakpoint 3")
+
         thread = threads[0]
         self.assertTrue(thread.IsValid(), "Thread must be valid")
         frame = thread.GetFrameAtIndex(0)
         self.assertTrue(frame.IsValid(), "Frame must be valid")
 
         # Verify if we ask for in scope locals that we got what we expect
-        vars = frame.GetVariables(args_no, locals_yes, statics_no, in_scopy_only)   
+        vars = frame.GetVariables(
+            args_no, locals_yes, statics_no, in_scopy_only)
         desc = 'in scope locals at breakpoint 3'
         names = ['i', 'j', 'k']
         count = len(names)
-        self.assertEqual(vars.GetSize(), count, "There should be %i %s (%s) but we are reporting %i (%s)" % (count, desc, names, vars.GetSize(), get_names_from_value_list(vars)))    
+        self.assertEqual(
+            vars.GetSize(),
+            count,
+            "There should be %i %s (%s) but we are reporting %i (%s)" %
+            (count,
+             desc,
+             names,
+             vars.GetSize(),
+             get_names_from_value_list(vars)))
         self.verify_variable_names("check names of %s" % (desc), vars, names)
diff --git a/packages/Python/lldbsuite/test/python_api/frame/inlines/TestInlinedFrame.py b/packages/Python/lldbsuite/test/python_api/frame/inlines/TestInlinedFrame.py
index ee6c33f54314c..caa2696be7cdb 100644
--- a/packages/Python/lldbsuite/test/python_api/frame/inlines/TestInlinedFrame.py
+++ b/packages/Python/lldbsuite/test/python_api/frame/inlines/TestInlinedFrame.py
@@ -5,14 +5,15 @@ Testlldb Python SBFrame APIs IsInlined() and GetFunctionName().
 from __future__ import print_function
 
 
-
-import os, time
+import os
+import time
 import re
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
+
 class InlinedFrameAPITestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
@@ -22,8 +23,10 @@ class InlinedFrameAPITestCase(TestBase):
         TestBase.setUp(self)
         # Find the line number to of function 'c'.
         self.source = 'inlines.c'
-        self.first_stop = line_number(self.source, '// This should correspond to the first break stop.')
-        self.second_stop = line_number(self.source, '// This should correspond to the second break stop.')
+        self.first_stop = line_number(
+            self.source, '// This should correspond to the first break stop.')
+        self.second_stop = line_number(
+            self.source, '// This should correspond to the second break stop.')
 
     @add_test_categories(['pyapi'])
     def test_stop_at_outer_inline(self):
@@ -43,7 +46,8 @@ class InlinedFrameAPITestCase(TestBase):
                         VALID_BREAKPOINT)
 
         # Now launch the process, and do not stop at the entry point.
-        process = target.LaunchSimple (None, None, self.get_process_working_directory())
+        process = target.LaunchSimple(
+            None, None, self.get_process_working_directory())
 
         process = target.GetProcess()
         self.assertTrue(process.GetState() == lldb.eStateStopped,
@@ -52,7 +56,8 @@ class InlinedFrameAPITestCase(TestBase):
         import lldbsuite.test.lldbutil as lldbutil
         stack_traces1 = lldbutil.print_stacktraces(process, string_buffer=True)
         if self.TraceOn():
-            print("Full stack traces when first stopped on the breakpoint 'inner_inline':")
+            print(
+                "Full stack traces when first stopped on the breakpoint 'inner_inline':")
             print(stack_traces1)
 
         # The first breakpoint should correspond to an inlined call frame.
@@ -61,23 +66,32 @@ class InlinedFrameAPITestCase(TestBase):
         #
         #     outer_inline (argc);
         #
-        thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint)
+        thread = lldbutil.get_stopped_thread(
+            process, lldb.eStopReasonBreakpoint)
         self.assertIsNotNone(thread)
 
         frame0 = thread.GetFrameAtIndex(0)
         if frame0.IsInlined():
             filename = frame0.GetLineEntry().GetFileSpec().GetFilename()
             self.assertTrue(filename == self.source)
-            self.expect(stack_traces1, "First stop at %s:%d" % (self.source, self.first_stop), exe=False,
-                        substrs = ['%s:%d' % (self.source, self.first_stop)])
+            self.expect(
+                stack_traces1, "First stop at %s:%d" %
+                (self.source, self.first_stop), exe=False, substrs=[
+                    '%s:%d' %
+                    (self.source, self.first_stop)])
 
             # Expect to break again for the second time.
             process.Continue()
             self.assertTrue(process.GetState() == lldb.eStateStopped,
                             PROCESS_STOPPED)
-            stack_traces2 = lldbutil.print_stacktraces(process, string_buffer=True)
+            stack_traces2 = lldbutil.print_stacktraces(
+                process, string_buffer=True)
             if self.TraceOn():
-                print("Full stack traces when stopped on the breakpoint 'inner_inline' for the second time:")
+                print(
+                    "Full stack traces when stopped on the breakpoint 'inner_inline' for the second time:")
                 print(stack_traces2)
-                self.expect(stack_traces2, "Second stop at %s:%d" % (self.source, self.second_stop), exe=False,
-                            substrs = ['%s:%d' % (self.source, self.second_stop)])
+                self.expect(
+                    stack_traces2, "Second stop at %s:%d" %
+                    (self.source, self.second_stop), exe=False, substrs=[
+                        '%s:%d' %
+                        (self.source, self.second_stop)])