Debugger Transport APIs and Zephyr port

jerry-core/api/jerry-debugger.c

@@ -93,16 +93,44 @@ jerry_debugger_stop_at_breakpoint (bool enable_stop_at_breakpoint) /**< enable/d
  * Debugger server initialization. Must be called after jerry_init.
  */
 void
-jerry_debugger_init (uint16_t port) /**< server port number */
+jerry_debugger_init (jerry_debugger_transport_t *transport_p) /**< transport */
 {
 #ifdef JERRY_DEBUGGER
-  JERRY_CONTEXT (debugger_port) = port;
+  JERRY_CONTEXT (debugger_transport_p) = transport_p;
+  JERRY_ASSERT (JERRY_CONTEXT (debugger_transport_p) != NULL);
+  JERRY_ASSERT (JERRY_CONTEXT (debugger_transport_p)->accept_connection != NULL);
+  JERRY_ASSERT (JERRY_CONTEXT (debugger_transport_p)->close_connection != NULL);
+  JERRY_ASSERT (JERRY_CONTEXT (debugger_transport_p)->send != NULL);
+  JERRY_ASSERT (JERRY_CONTEXT (debugger_transport_p)->receive != NULL);
   jerry_debugger_accept_connection ();
 #else /* !JERRY_DEBUGGER */
-  JERRY_UNUSED (port);
+  JERRY_UNUSED (transport_p);
 #endif /* JERRY_DEBUGGER */
 } /* jerry_debugger_init */
 
+/**
+ * Debugger transport transmission sizes, each transport will need to set these.
+ */
+void
+jerry_debugger_set_transmit_sizes (size_t send_header_size, /**< transport send header size */
+                                   size_t max_send_size, /**< transport max send size */
+                                   size_t receive_header_size, /**< transport receive header size */
+                                   size_t max_receive_size) /**< transport max receive size */
+{
+#ifdef JERRY_DEBUGGER
+  JERRY_CONTEXT (debugger_send_header_size) = (uint8_t) send_header_size;
+  JERRY_CONTEXT (debugger_max_send_size) = (uint8_t) max_send_size;
+  JERRY_CONTEXT (debugger_receive_header_size) = (uint8_t) receive_header_size;
+  JERRY_CONTEXT (debugger_max_receive_size) = (uint8_t) max_receive_size;
+#else /* !JERRY_DEBUGGER */
+  JERRY_UNUSED (send_header_size);
+  JERRY_UNUSED (max_send_size);
+  JERRY_UNUSED (receive_header_size);
+  JERRY_UNUSED (max_receive_size);
+#endif /* JERRY_DEBUGGER */
+} /* jerry_debugger_set_transmit_sizes */
+
+
 /**
  * Sets whether the engine should wait and run a source.
  *

jerry-core/debugger/debugger-ws.h

@@ -38,18 +38,12 @@ typedef struct
 /**
  * Byte data for evaluating expressions and receiving client source.
  */
-typedef struct
+typedef struct jerry_debugger_uint8_data_t
 {
   uint32_t uint8_size; /**< total size of the client source */
   uint32_t uint8_offset; /**< current offset in the client source */
 } jerry_debugger_uint8_data_t;
 
-bool jerry_debugger_accept_connection (void);
-void jerry_debugger_close_connection (void);
-
-bool jerry_debugger_send (size_t data_size);
-bool jerry_debugger_receive (jerry_debugger_uint8_data_t **message_data_p);
-
 void jerry_debugger_compute_sha1 (const uint8_t *input1, size_t input1_len,
                                   const uint8_t *input2, size_t input2_len,
                                   uint8_t output[20]);

jerry-core/debugger/debugger.c

@@ -1068,4 +1068,166 @@ jerry_debugger_send_exception_string (void)
   return result;
 } /* jerry_debugger_send_exception_string */
 
+/**
+ * Initialize the debugger connection.
+ *
+ * @return true - if the connection succeeded
+ *         false - otherwise
+ */
+bool
+jerry_debugger_accept_connection (void)
+{
+  uint8_t *payload_p = JERRY_CONTEXT (debugger_send_buffer) + JERRY_CONTEXT (debugger_send_header_size);
+  JERRY_CONTEXT (debugger_send_buffer_payload_p) = payload_p;
+
+  uint8_t max_send_size = (uint8_t) (JERRY_DEBUGGER_MAX_BUFFER_SIZE -
+                                     JERRY_CONTEXT (debugger_send_header_size));
+  if (max_send_size <= JERRY_CONTEXT (debugger_max_send_size))
+  {
+    JERRY_CONTEXT (debugger_max_send_size) = max_send_size;
+  }
+
+  uint8_t max_receive_size = (uint8_t) (JERRY_DEBUGGER_MAX_BUFFER_SIZE -
+                                        JERRY_CONTEXT (debugger_receive_header_size));
+  if (max_receive_size <= JERRY_CONTEXT (debugger_max_send_size))
+  {
+    JERRY_CONTEXT (debugger_max_receive_size) = max_receive_size;
+  }
+
+  if (!JERRY_CONTEXT (debugger_transport_p)->accept_connection (JERRY_CONTEXT (debugger_transport_p)))
+  {
+    return false;
+  }
+
+  JERRY_DEBUGGER_SET_FLAGS (JERRY_DEBUGGER_CONNECTED);
+
+  if (!jerry_debugger_send_configuration (max_receive_size))
+  {
+    return false;
+  }
+
+  JERRY_DEBUGGER_SET_FLAGS (JERRY_DEBUGGER_VM_STOP);
+  JERRY_CONTEXT (debugger_stop_context) = NULL;
+  return true;
+} /* jerry_debugger_accept_connection */
+
+/**
+ * Close the connection to the client.
+ */
+void
+jerry_debugger_close_connection (void)
+{
+  JERRY_ASSERT (JERRY_CONTEXT (debugger_flags) & JERRY_DEBUGGER_CONNECTED);
+  JERRY_CONTEXT (debugger_flags) = JERRY_DEBUGGER_VM_IGNORE;
+
+  JERRY_CONTEXT (debugger_transport_p)->close_connection (JERRY_CONTEXT (debugger_transport_p));
+  jerry_debugger_free_unreferenced_byte_code ();
+} /* jerry_debugger_close_connection */
+
+/**
+ * Send message to the client side
+ *
+ * @return true - if the data was sent successfully to the debugger client,
+ *         false - otherwise
+ */
+bool
+jerry_debugger_send (size_t data_size) /**< data size */
+{
+  JERRY_ASSERT (JERRY_CONTEXT (debugger_flags) & JERRY_DEBUGGER_CONNECTED);
+  JERRY_ASSERT (data_size <= JERRY_CONTEXT (debugger_max_send_size));
+
+  if (!JERRY_CONTEXT (debugger_transport_p)->send (JERRY_CONTEXT (debugger_transport_p),
+                                                   JERRY_CONTEXT (debugger_send_buffer),
+                                                   data_size))
+  {
+    jerry_debugger_close_connection ();
+    return false;
+  }
+
+  return true;
+} /* jerry_debugger_send */
+
+/**
+ * Receive message from the client.
+ *
+ * Note:
+ *   If the function returns with true, the value of
+ *   JERRY_DEBUGGER_VM_STOP flag should be ignored.
+ *
+ * @return true - if execution should be resumed,
+ *         false - otherwise
+ */
+bool
+jerry_debugger_receive (jerry_debugger_uint8_data_t **message_data_p) /**< [out] data received from client */
+{
+  JERRY_ASSERT (JERRY_CONTEXT (debugger_flags) & JERRY_DEBUGGER_CONNECTED);
+  JERRY_ASSERT (message_data_p != NULL ? !!(JERRY_CONTEXT (debugger_flags) & JERRY_DEBUGGER_RECEIVE_DATA_MODE)
+                                       : !(JERRY_CONTEXT (debugger_flags) & JERRY_DEBUGGER_RECEIVE_DATA_MODE));
+
+  JERRY_CONTEXT (debugger_message_delay) = JERRY_DEBUGGER_MESSAGE_FREQUENCY;
+
+  bool resume_exec = false;
+  uint8_t expected_message_type = 0;
+  size_t message_size;
+
+  while (true)
+  {
+    uint32_t offset = JERRY_CONTEXT (debugger_receive_buffer_offset);
+    bool success = JERRY_CONTEXT (debugger_transport_p)->receive (JERRY_CONTEXT (debugger_transport_p),
+                                                                  JERRY_CONTEXT (debugger_receive_buffer),
+                                                                  &message_size,
+                                                                  &offset);
+
+    if (!success)
+    {
+      jerry_debugger_close_connection ();
+      return true;
+    }
+
+    if (offset < JERRY_CONTEXT (debugger_receive_header_size))
+    {
+      if (expected_message_type != 0)
+      {
+        continue;
+      }
+
+      return resume_exec;
+    }
+
+    uint32_t message_total_size = (uint32_t) (message_size +
+                                              JERRY_CONTEXT (debugger_receive_header_size));
+
+    if (offset < message_total_size)
+    {
+      if (expected_message_type != 0)
+      {
+        continue;
+      }
+
+      return resume_exec;
+    }
+
+    /* The jerry_debugger_process_message function is inlined
+      * so passing these arguments is essentially free. */
+    if (!jerry_debugger_process_message (JERRY_CONTEXT (debugger_receive_buffer) +
+                                         JERRY_CONTEXT (debugger_receive_header_size),
+                                         (uint32_t) message_size,
+                                         &resume_exec,
+                                         &expected_message_type,
+                                         (jerry_debugger_uint8_data_t**) message_data_p))
+    {
+      return true;
+    }
+
+    if (message_total_size < offset)
+    {
+      memmove (JERRY_CONTEXT (debugger_receive_buffer),
+               JERRY_CONTEXT (debugger_receive_buffer) + message_total_size,
+               offset - message_total_size);
+    }
+
+    JERRY_CONTEXT (debugger_receive_buffer_offset) = (uint16_t) (offset - message_total_size);
+  }
+} /* jerry_debugger_receive */
+
 #endif /* JERRY_DEBUGGER */

jerry-core/debugger/debugger.h

@@ -107,6 +107,12 @@ typedef enum
   JERRY_DEBUGGER_CONTEXT_RESET_MODE = 1u << 10, /**< debugger and engine reinitialization mode */
 } jerry_debugger_flags_t;
 
+/**
+ * Waiting for data from the client.
+ */
+#define JERRY_DEBUGGER_RECEIVE_DATA_MODE \
+  (JERRY_DEBUGGER_BREAKPOINT_MODE | JERRY_DEBUGGER_CLIENT_SOURCE_MODE)
+
 /**
  * Set debugger flags.
  */
@@ -415,6 +421,11 @@ bool jerry_debugger_send_parse_function (uint32_t line, uint32_t column);
 void jerry_debugger_send_memstats (void);
 bool jerry_debugger_send_exception_string (void);
 
+bool jerry_debugger_accept_connection (void);
+void jerry_debugger_close_connection (void);
+bool jerry_debugger_send (size_t data_size);
+bool jerry_debugger_receive (jerry_debugger_uint8_data_t **message_data_p);
+
 #endif /* JERRY_DEBUGGER */
 
 #endif /* !DEBUGGER_H */

jerry-core/include/jerryscript-debugger.h

@@ -53,7 +53,13 @@ typedef jerry_value_t (*jerry_debugger_wait_for_source_callback_t) (const jerry_
 /**
  * Engine debugger functions.
  */
-void jerry_debugger_init (uint16_t port);
+typedef struct jerry_debugger_transport_t jerry_debugger_transport_t;
+
+void jerry_debugger_init (jerry_debugger_transport_t *transport_p);
+void jerry_debugger_set_transmit_sizes (size_t send_header_size,
+                                        size_t max_send_size,
+                                        size_t receive_header_size,
+                                        size_t max_receive_size);
 bool jerry_debugger_is_connected (void);
 void jerry_debugger_stop (void);
 void jerry_debugger_continue (void);

jerry-core/include/jerryscript-port.h

@@ -150,6 +150,30 @@ double jerry_port_get_current_time (void);
  */
 struct jerry_instance_t *jerry_port_get_current_instance (void);
 
+/*
+ * Debugger Port API
+ */
+
+/* forward declaration */
+struct jerry_debugger_uint8_data_t;
+
+/**
+ * Transport APIs, different transport will define
+ * the real implementation of these APIs
+ */
+struct jerry_debugger_transport_t
+{
+  bool (*accept_connection) (struct jerry_debugger_transport_t *transport_p);
+  void (*close_connection) (struct jerry_debugger_transport_t *transport_p);
+  bool (*send) (struct jerry_debugger_transport_t *transport_p,
+                uint8_t *message_data_p,
+                size_t data_size);
+  bool (*receive) (struct jerry_debugger_transport_t *transport_p,
+                   uint8_t *message_data_p,
+                   size_t *data_size,
+                   uint32_t *buffer_offset);
+};
+
 /**
  * Makes the process sleep for a given time.
  *

jerry-core/jcontext/jcontext.h

@@ -117,11 +117,12 @@ typedef struct
   jmem_cpointer_t debugger_byte_code_free_tail; /**< tail of byte code free linked list */
   uint32_t debugger_flags; /**< debugger flags */
   uint16_t debugger_receive_buffer_offset; /**< receive buffer offset */
-  uint16_t debugger_port; /**< debugger socket communication port */
   uint8_t debugger_message_delay; /**< call receive message when reaches zero */
+  uint8_t debugger_send_header_size; /**< header size reserved when sending */
+  uint8_t debugger_receive_header_size; /**< header size reserved when receiving */
   uint8_t debugger_max_send_size; /**< maximum amount of data that can be written */
   uint8_t debugger_max_receive_size; /**< maximum amount of data that can be received */
-  int debugger_connection; /**< holds the file descriptor of the socket communication */
+  jerry_debugger_transport_t *debugger_transport_p; /**< holds the pointer to the debugger transport */
 #endif /* JERRY_DEBUGGER */
 
 #ifdef JERRY_ENABLE_LINE_INFO

jerry-main/main-unix.c

@@ -592,7 +592,7 @@ main (int argc,
   jerry_init (flags);
   if (start_debug_server)
   {
-    jerry_debugger_init (debug_port);
+    jerry_debugger_init (jerry_port_default_init_socket_transport (debug_port));
   }
 
   register_js_function ("assert", jerryx_handler_assert);
@@ -710,7 +710,7 @@ main (int argc,
         jerry_cleanup ();
 
         jerry_init (flags);
-        jerry_debugger_init (debug_port);
+        jerry_debugger_init (jerry_port_default_init_socket_transport (debug_port));
 
         register_js_function ("assert", jerryx_handler_assert);
         register_js_function ("gc", jerryx_handler_gc);