[WIP] [gdb] Using pty for stdout (#50)

* Fix exception occuring in case of illigal stack_frame string.

* Refactor to use pty for capturing output.

* [CD] Upload package to PyPI when creating a release (#48)

* enable running the script without installing as a package

While developing, we can test out changes without pip install

* [CD] Upload package to PyPI when creating a release

* fix according to code review

* fix permissions

* Fix buffer.

* Include stdout and stdin as subwindows.

* Add debugee stdout and stdin windows.

* Intercept gdb output even if it appears with delays.

* Remove " as they may break the json format.

* Fix parsing of the speacial commands to follow the new approach.

* Disable not implemented function call.

* Reduce timeout so that commands are completed quickley.

* Add default values.

* Use full path of the file.

* Use parallel and non blocking calls to speed command execution.

* Fix issuing single commands

* Fix receiving of debuggee output.

* Remove " from the stack, args and locals output.

Prevents from violating the json generated.

* Disable debuginfod.

* Ensure debuggee output is flused before a ywrite.

* Disable stdout flush as it discards debuggee stdout.

* remove additional panels used while developing (#58)

---------

Co-authored-by: Vipul Cariappa <[email protected]>

Author: mvassilev

src/idd/cli.py

@@ -2,6 +2,8 @@
 
 import argparse
 import sys
+import os
+from asyncio import sleep
 
 from textual import on
 from textual import events
@@ -18,7 +20,7 @@
 
 
 class DiffDebug(App):
-    CSS_PATH = "layout.tcss"
+    CSS_PATH = os.path.join(os.path.dirname(__file__), "layout.tcss")
 
     current_index: Reactive[int] = Reactive(-1)
     tab_index = ["parallel_command_bar", "base_command_bar", "regressed_command_bar"]
@@ -41,6 +43,9 @@ class DiffDebug(App):
     diff_asm2 = TextScrollView(title="Regression Asm", component_id = "diff-asm2")
     diff_reg1 = TextScrollView(title="Base Registers", component_id = "diff-reg1")
     diff_reg2 = TextScrollView(title="Regression Registers", component_id = "diff-reg2")
+    base_input_bar = Input(placeholder="Input for base debuggee...", id="base-input-bar")
+    regressed_input_bar = Input(placeholder="Input for regression debuggee...", id="regressed-input-bar")
+
     #executable_path1 = DiffArea(title="base executable and arguments", value="")
     #executable_path2 = DiffArea(title="regression executable and arguments", value="")
 
@@ -60,6 +65,13 @@ def __init__(self, disable_asm=False, disable_registers=False, only_base=False):
         self.base_history_index = 0
         self.regressed_history = [""]
         self.regressed_history_index = 0
+        self.base_awaiting_shown = False
+        self.regressed_awaiting_shown = False
+        
+    async def on_mount(self) -> None:
+        #self.set_interval(0.1, self.refresh_debuggee_status)
+        self.set_interval(0.25, self.watch_debuggee_output)
+
 
     async def set_command_result(self, version) -> None:
         state = Debugger.get_state(version)
@@ -215,6 +227,29 @@ async def set_pregisters_command_result(self, state) -> None:
         diff2 = self.diff_driver.get_diff(regressed_file_contents, base_file_contents, "regressed")
         self.diff_reg2.text(diff2)
 
+    async def watch_debuggee_output(self) -> None:
+        if hasattr(Debugger, "base_gdb_instance"):
+            base_output = Debugger.base_gdb_instance.pop_debuggee_output()
+            if base_output:
+                self.diff_area1.append(base_output)
+            if Debugger.base_gdb_instance.is_waiting_for_input():
+                if not self.base_awaiting_shown:
+                    self.diff_area1.append("[awaiting input]")
+                    self.base_awaiting_shown = True
+            else:
+                self.base_awaiting_shown = False
+
+        if hasattr(Debugger, "regressed_gdb_instance"):
+            regressed_output = Debugger.regressed_gdb_instance.pop_debuggee_output()
+            if regressed_output:
+                self.diff_area2.append(regressed_output)
+            if Debugger.regressed_gdb_instance.is_waiting_for_input():
+                if not self.regressed_awaiting_shown:
+                    self.diff_area2.append("[awaiting input]")
+                    self.regressed_awaiting_shown = True
+            else:
+                self.regressed_awaiting_shown = False
+
     def compose(self) -> ComposeResult:
         """Compose the layout of the application."""
         if self.only_base:
@@ -313,11 +348,14 @@ async def execute_debugger_command(self, event: Input.Changed) -> None:
                 self.parallel_command_bar.value == "exit":
                 Debugger.terminate()
                 exit(0)
-            
+
             if self.parallel_command_bar.value.startswith("stdin "):
-                Debugger.insert_stdin(self.parallel_command_bar.value[6:] + "\n")
+                content = self.parallel_command_bar.value[6:]
+                Debugger.insert_stdin(content + "\n")
+                self.diff_area1.append([content])
+                self.diff_area2.append([content])
                 result = {}
-            
+
             elif self.parallel_command_bar.value != "":
                 result = Debugger.run_parallel_command(self.parallel_command_bar.value)
 
@@ -347,6 +385,7 @@ async def execute_debugger_command(self, event: Input.Changed) -> None:
 
             if self.base_command_bar.value.startswith("stdin "):
                 Debugger.insert_stdin_single(self.base_command_bar.value[6:] + "\n", "base")
+                self.diff_area1.append([self.base_command_bar.value[6:]])
 
             elif self.base_command_bar.value != "":
                 result = Debugger.run_single_command(self.base_command_bar.value, "base")
@@ -371,6 +410,7 @@ async def execute_debugger_command(self, event: Input.Changed) -> None:
         elif event.control.id == 'regressed-command-bar':
             if self.regressed_command_bar.value.startswith("stdin "):
                 Debugger.insert_stdin_single(self.regressed_command_bar.value[6:] + "\n", "regressed")
+                self.diff_area1.append([self.base_command_bar.value[6:]])
 
             elif self.regressed_command_bar.value != "":
                 result = Debugger.run_single_command(self.regressed_command_bar.value, "regressed")
@@ -391,6 +431,12 @@ async def execute_debugger_command(self, event: Input.Changed) -> None:
 
             self.regressed_command_bar.value = ""
 
+        elif event.input.id == "base-input-bar":
+            Debugger.base_gdb_instance.send_input_to_debuggee(event.value)
+
+        elif event.input.id == "regressed-input-bar":
+            Debugger.regressed_gdb_instance.send_input_to_debuggee(event.value)
+
     async def on_key(self, event: events.Key) -> None:
         if self.focused is None:
             return
@@ -484,6 +530,5 @@ def main() -> None:
     dd = DiffDebug(disable_assembly, disable_registers, base_only)
     dd.run()
 
-
 if __name__ == "__main__":
     main()

src/idd/debuggers/gdb/gdb_commands.py

@@ -21,6 +21,22 @@ class PrintState (gdb.Command):
   def __init__ (self):
     super (PrintState, self).__init__ ("pstate", gdb.COMMAND_USER)
 
+  def trim_middle_quotes(input_string):
+      # Ensure the string starts and ends with quotes
+      if input_string.startswith('"') and input_string.endswith('"'):
+          # Remove the first and last quotes temporarily
+          trimmed = input_string[1:-1]
+          # Remove all remaining quotes
+          trimmed = trimmed.replace('"', '')
+          # Add back the starting and ending quotes
+          # print(trimmed)
+          return f'"{trimmed}"'
+      return input_string  # Return as-is if it doesn't start and end with quotes
+
+  def trim_quotes(self, input_string):
+      trimmed = input_string.replace('"','')
+      return trimmed
+
   def invoke (self, arg, from_tty):
     result = {}
 
@@ -33,8 +49,12 @@ def invoke (self, arg, from_tty):
 
     # get stack frame
     command_result = gdb.execute("bt", to_string=True)
-    stack_frames = command_result.split('\n')
-    result['stack_frames'] = stack_frames
+
+    # leave only the starting and ending quotes
+    # ensures correct parsing of the stack frames as
+    stack_frames = [line for line in (command_result or "").split('\n') if line.strip()]
+    trimmed_stack_frames = [self.trim_quotes(frame) for frame in stack_frames]
+    result['stack_frames'] = trimmed_stack_frames or []
 
     frame = gdb.selected_frame()
     block = frame.block()
@@ -45,13 +65,13 @@ def invoke (self, arg, from_tty):
             if (symbol.is_variable):
                 name = symbol.name
                 if not name in names:
-                    locals.append('{} = {}'.format(name, symbol.value(frame)))
+                    locals.append('{} = {}'.format(name, symbol.value(frame)).replace('"',''))
 
             # get args
             if (symbol.is_argument):
                 name = symbol.name
                 if not name in names:
-                    args.append('{} = {}\n'.format(name, symbol.value(frame)))
+                    args.append('{} = {}\n'.format(name, symbol.value(frame)).replace('"',''))
         block = block.superblock
 
     # get instructions
@@ -86,22 +106,23 @@ def invoke (self, arg, from_tty):
       except Exception as e:
         registers.append(str(e))
 
-    result['locals'] = locals
-    result['args'] = args
-    result['instructions'] = instructions
-    result['registers'] = registers
+    result['locals'] = locals or []
+    result['args'] = args or []
+    result['instructions'] = instructions or []
+    result['registers'] = registers or []
 
     json_result = json.dumps(result)
 
-    print(json_result)
+    gdb.write(f'{json_result}\n', gdb.STDOUT)
+
 
 class PrintFrame (gdb.Command):
   def __init__ (self):
     super (PrintFrame, self).__init__ ("pframe", gdb.COMMAND_USER)
 
   def invoke (self, arg, from_tty):
     result = gdb.execute("bt", to_string=True)
-    print(result)
+    gdb.write(result, gdb.STDOUT)
 
 class PrintLocals (gdb.Command):
   def __init__ (self):