Python debugger support for Python 3 (in addition to Python 2)

- Added ord builtin compatibility to pass through int arguments
- Fixed JerryDebugger to decode bytes as utf8 strings when necessary
- Fixed WebSocket send_message method to use packed_data[0:1] bytes slice

JerryScript-DCO-1.0-Signed-off-by: Zac Medico <[email protected]>

Author: zmedico

jerry-debugger/jerry_client_main.py

@@ -149,6 +149,17 @@ def arguments_parse():
     return args
 
 
+if sys.version_info.major >= 3:
+    # pylint: disable=invalid-name
+    _ord_orig = ord
+    def _ord_compat(c):
+        if isinstance(c, int):
+            return c
+        return _ord_orig(c)
+    # pylint: disable=redefined-builtin
+    ord = _ord_compat
+
+
 class JerryBreakpoint(object):
 
     def __init__(self, line, offset, function):
@@ -400,7 +411,7 @@ def delete(self, args):
                    "to clear all the given breakpoints\n "
         elif args in ['all', 'pending', 'active']:
             if args != "pending":
-                for i in self.active_breakpoint_list.values():
+                for i in list(self.active_breakpoint_list.values()):
                     breakpoint = self.active_breakpoint_list[i.active_index]
                     del self.active_breakpoint_list[i.active_index]
                     breakpoint.active_index = -1
@@ -561,6 +572,7 @@ def memstats(self):
         self._exec_command(JERRY_DEBUGGER_MEMSTATS)
 
     def _send_string(self, args, message_type, index=0):
+        args = args.encode("utf8")
 
         # 1: length of type byte
         # 4: length of an uint32 value
@@ -738,10 +750,10 @@ def process_messages(self):
                 return DebuggerAction(DebuggerAction.TEXT, result)
 
             elif buffer_type == JERRY_DEBUGGER_EXCEPTION_STR:
-                self.exception_string += data[1:]
+                self.exception_string += data[1:].decode("utf8")
 
             elif buffer_type == JERRY_DEBUGGER_EXCEPTION_STR_END:
-                self.exception_string += data[1:]
+                self.exception_string += data[1:].decode("utf8")
 
             elif buffer_type == JERRY_DEBUGGER_BACKTRACE_TOTAL:
                 total = struct.unpack(self.byte_order + self.idx_format, data[1:])[0]
@@ -808,7 +820,7 @@ def process_messages(self):
                 return DebuggerAction(DebuggerAction.TEXT, result)
 
             elif buffer_type in [JERRY_DEBUGGER_SCOPE_VARIABLES, JERRY_DEBUGGER_SCOPE_VARIABLES_END]:
-                self.scope_vars += "".join(data[1:])
+                self.scope_vars += "".join(data[1:].decode("utf8"))
 
                 if buffer_type == JERRY_DEBUGGER_SCOPE_VARIABLES_END:
                     result = self._process_scope_variables()
@@ -864,9 +876,9 @@ def print_source(self, line_num, offset):
 
     # pylint: disable=too-many-branches,too-many-locals,too-many-statements
     def _parse_source(self, data):
-        source_code = ""
-        source_code_name = ""
-        function_name = ""
+        source_code = b""
+        source_code_name = b""
+        function_name = b""
         stack = [{"line": 1,
                   "column": 1,
                   "name": "",
@@ -903,14 +915,14 @@ def _parse_source(self, data):
                 position = struct.unpack(self.byte_order + self.idx_format + self.idx_format,
                                          data[1: 1 + 4 + 4])
 
-                stack.append({"source": source_code,
-                              "source_name": source_code_name,
+                stack.append({"source": source_code.decode("utf8"),
+                              "source_name": source_code_name.decode("utf8"),
                               "line": position[0],
                               "column": position[1],
-                              "name": function_name,
+                              "name": function_name.decode("utf8"),
                               "lines": [],
                               "offsets": []})
-                function_name = ""
+                function_name = b""
 
             elif buffer_type in [JERRY_DEBUGGER_BREAKPOINT_LIST, JERRY_DEBUGGER_BREAKPOINT_OFFSET_LIST]:
                 name = "lines"
@@ -937,8 +949,8 @@ def _parse_source(self, data):
 
                 # We know the last item in the list is the general byte code.
                 if not stack:
-                    func_desc["source"] = source_code
-                    func_desc["source_name"] = source_code_name
+                    func_desc["source"] = source_code.decode("utf8")
+                    func_desc["source_name"] = source_code_name.decode("utf8")
 
                 function = JerryFunction(stack,
                                          byte_code_cp,
@@ -989,7 +1001,7 @@ def _parse_source(self, data):
             logging.debug("Pending breakpoints available")
             bp_list = self.pending_breakpoint_list
 
-            for breakpoint_index, breakpoint in bp_list.items():
+            for breakpoint_index, breakpoint in list(bp_list.items()):
                 source_lines = 0
                 for src in new_function_list.values():
                     if (src.source_name == breakpoint.source_name or
@@ -1151,20 +1163,21 @@ def _process_incoming_text(self, buffer_type, data):
                 log_type = "%sout:%s " % (self.blue, self.nocolor)
 
                 message = self.current_out + message
-                lines = message.split("\n")
-                self.current_out = lines.pop()
+                lines = message.decode("utf8").split("\n")
+                self.current_out = lines.pop().encode("utf8")
 
                 return "".join(["%s%s\n" % (log_type, line) for line in lines])
 
             if subtype == JERRY_DEBUGGER_OUTPUT_DEBUG:
                 log_type = "%slog:%s " % (self.yellow, self.nocolor)
 
                 message = self.current_log + message
-                lines = message.split("\n")
-                self.current_log = lines.pop()
+                lines = message.decode("utf8").split("\n")
+                self.current_log = lines.pop().encode("utf8")
 
                 return "".join(["%s%s\n" % (log_type, line) for line in lines])
 
+            message = message.decode("utf8")
             if not message.endswith("\n"):
                 message += "\n"
 
@@ -1174,6 +1187,9 @@ def _process_incoming_text(self, buffer_type, data):
                 return "%serr: %s%s" % (self.red, self.nocolor, message)
             elif subtype == JERRY_DEBUGGER_OUTPUT_TRACE:
                 return "%strace: %s%s" % (self.blue, self.nocolor, message)
+        else:
+            message = message.decode("utf8")
+
 
         # Subtypes of eval
         self.prompt = True

jerry-debugger/jerry_client_rawpacket.py

@@ -15,9 +15,21 @@
 # limitations under the License.
 
 import struct
+import sys
 
 MAX_BUFFER_SIZE = 256
 
+if sys.version_info.major >= 3:
+    # pylint: disable=invalid-name
+    _ord_orig = ord
+    def _ord_compat(c):
+        if isinstance(c, int):
+            return c
+        return _ord_orig(c)
+    # pylint: disable=redefined-builtin
+    ord = _ord_compat
+
+
 class RawPacket(object):
     """ Simplified transmission layer. """
     def __init__(self, protocol):

jerry-debugger/jerry_client_websocket.py

@@ -15,11 +15,24 @@
 # limitations under the License.
 
 import struct
+import sys
 
 MAX_BUFFER_SIZE = 128
 WEBSOCKET_BINARY_FRAME = 2
 WEBSOCKET_FIN_BIT = 0x80
 
+
+if sys.version_info.major >= 3:
+    # pylint: disable=invalid-name
+    _ord_orig = ord
+    def _ord_compat(c):
+        if isinstance(c, int):
+            return c
+        return _ord_orig(c)
+    # pylint: disable=redefined-builtin
+    ord = _ord_compat
+
+
 class WebSocket(object):
     def __init__(self, protocol):
 
@@ -92,7 +105,7 @@ def send_message(self, byte_order, packed_data):
         """ Send message. """
         message = struct.pack(byte_order + "BBI",
                               WEBSOCKET_BINARY_FRAME | WEBSOCKET_FIN_BIT,
-                              WEBSOCKET_FIN_BIT + struct.unpack(byte_order + "B", packed_data[0])[0],
+                              WEBSOCKET_FIN_BIT + struct.unpack(byte_order + "B", packed_data[0:1])[0],
                               0) + packed_data[1:]
 
         self.__send_data(message)