mirror of
https://github.com/jerryscript-project/jerryscript.git
synced 2025-12-15 16:29:21 +00:00
1bd1a36a81
Ubuntu 14.04 reached its end of life on April 30m 2019. Let's bump the reference to the latest LTS, which is 18.04. Ubuntu 18.04 has newer Pylint and Cppcheck, the necessary fixes and suppresses are also included in this PR. JerryScript-DCO-1.0-Signed-off-by: Csaba Osztrogonác oszi@inf.u-szeged.hu
1269 lines
46 KiB
Python
1269 lines
46 KiB
Python
#!/usr/bin/env python
|
|
|
|
# Copyright JS Foundation and other contributors, http://js.foundation
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
|
|
from __future__ import print_function
|
|
import argparse
|
|
import logging
|
|
import re
|
|
import select
|
|
import struct
|
|
import sys
|
|
|
|
# Expected debugger protocol version.
|
|
JERRY_DEBUGGER_VERSION = 9
|
|
|
|
# Messages sent by the server to client.
|
|
JERRY_DEBUGGER_CONFIGURATION = 1
|
|
JERRY_DEBUGGER_PARSE_ERROR = 2
|
|
JERRY_DEBUGGER_BYTE_CODE_CP = 3
|
|
JERRY_DEBUGGER_PARSE_FUNCTION = 4
|
|
JERRY_DEBUGGER_BREAKPOINT_LIST = 5
|
|
JERRY_DEBUGGER_BREAKPOINT_OFFSET_LIST = 6
|
|
JERRY_DEBUGGER_SOURCE_CODE = 7
|
|
JERRY_DEBUGGER_SOURCE_CODE_END = 8
|
|
JERRY_DEBUGGER_SOURCE_CODE_NAME = 9
|
|
JERRY_DEBUGGER_SOURCE_CODE_NAME_END = 10
|
|
JERRY_DEBUGGER_FUNCTION_NAME = 11
|
|
JERRY_DEBUGGER_FUNCTION_NAME_END = 12
|
|
JERRY_DEBUGGER_WAITING_AFTER_PARSE = 13
|
|
JERRY_DEBUGGER_RELEASE_BYTE_CODE_CP = 14
|
|
JERRY_DEBUGGER_MEMSTATS_RECEIVE = 15
|
|
JERRY_DEBUGGER_BREAKPOINT_HIT = 16
|
|
JERRY_DEBUGGER_EXCEPTION_HIT = 17
|
|
JERRY_DEBUGGER_EXCEPTION_STR = 18
|
|
JERRY_DEBUGGER_EXCEPTION_STR_END = 19
|
|
JERRY_DEBUGGER_BACKTRACE_TOTAL = 20
|
|
JERRY_DEBUGGER_BACKTRACE = 21
|
|
JERRY_DEBUGGER_BACKTRACE_END = 22
|
|
JERRY_DEBUGGER_EVAL_RESULT = 23
|
|
JERRY_DEBUGGER_EVAL_RESULT_END = 24
|
|
JERRY_DEBUGGER_WAIT_FOR_SOURCE = 25
|
|
JERRY_DEBUGGER_OUTPUT_RESULT = 26
|
|
JERRY_DEBUGGER_OUTPUT_RESULT_END = 27
|
|
JERRY_DEBUGGER_SCOPE_CHAIN = 28
|
|
JERRY_DEBUGGER_SCOPE_CHAIN_END = 29
|
|
JERRY_DEBUGGER_SCOPE_VARIABLES = 30
|
|
JERRY_DEBUGGER_SCOPE_VARIABLES_END = 31
|
|
JERRY_DEBUGGER_CLOSE_CONNECTION = 32
|
|
|
|
# Debugger option flags
|
|
JERRY_DEBUGGER_LITTLE_ENDIAN = 0x1
|
|
|
|
# Subtypes of eval
|
|
JERRY_DEBUGGER_EVAL_EVAL = "\0"
|
|
JERRY_DEBUGGER_EVAL_THROW = "\1"
|
|
JERRY_DEBUGGER_EVAL_ABORT = "\2"
|
|
|
|
# Subtypes of eval result
|
|
JERRY_DEBUGGER_EVAL_OK = 1
|
|
JERRY_DEBUGGER_EVAL_ERROR = 2
|
|
|
|
# Subtypes of output
|
|
JERRY_DEBUGGER_OUTPUT_OK = 1
|
|
JERRY_DEBUGGER_OUTPUT_ERROR = 2
|
|
JERRY_DEBUGGER_OUTPUT_WARNING = 3
|
|
JERRY_DEBUGGER_OUTPUT_DEBUG = 4
|
|
JERRY_DEBUGGER_OUTPUT_TRACE = 5
|
|
|
|
|
|
# Messages sent by the client to server.
|
|
JERRY_DEBUGGER_FREE_BYTE_CODE_CP = 1
|
|
JERRY_DEBUGGER_UPDATE_BREAKPOINT = 2
|
|
JERRY_DEBUGGER_EXCEPTION_CONFIG = 3
|
|
JERRY_DEBUGGER_PARSER_CONFIG = 4
|
|
JERRY_DEBUGGER_MEMSTATS = 5
|
|
JERRY_DEBUGGER_STOP = 6
|
|
JERRY_DEBUGGER_PARSER_RESUME = 7
|
|
JERRY_DEBUGGER_CLIENT_SOURCE = 8
|
|
JERRY_DEBUGGER_CLIENT_SOURCE_PART = 9
|
|
JERRY_DEBUGGER_NO_MORE_SOURCES = 10
|
|
JERRY_DEBUGGER_CONTEXT_RESET = 11
|
|
JERRY_DEBUGGER_CONTINUE = 12
|
|
JERRY_DEBUGGER_STEP = 13
|
|
JERRY_DEBUGGER_NEXT = 14
|
|
JERRY_DEBUGGER_FINISH = 15
|
|
JERRY_DEBUGGER_GET_BACKTRACE = 16
|
|
JERRY_DEBUGGER_EVAL = 17
|
|
JERRY_DEBUGGER_EVAL_PART = 18
|
|
JERRY_DEBUGGER_GET_SCOPE_CHAIN = 19
|
|
JERRY_DEBUGGER_GET_SCOPE_VARIABLES = 20
|
|
|
|
JERRY_DEBUGGER_SCOPE_WITH = 1
|
|
JERRY_DEBUGGER_SCOPE_LOCAL = 2
|
|
JERRY_DEBUGGER_SCOPE_CLOSURE = 3
|
|
JERRY_DEBUGGER_SCOPE_GLOBAL = 4
|
|
JERRY_DEBUGGER_SCOPE_NON_CLOSURE = 5
|
|
|
|
JERRY_DEBUGGER_VALUE_NONE = 1
|
|
JERRY_DEBUGGER_VALUE_UNDEFINED = 2
|
|
JERRY_DEBUGGER_VALUE_NULL = 3
|
|
JERRY_DEBUGGER_VALUE_BOOLEAN = 4
|
|
JERRY_DEBUGGER_VALUE_NUMBER = 5
|
|
JERRY_DEBUGGER_VALUE_STRING = 6
|
|
JERRY_DEBUGGER_VALUE_FUNCTION = 7
|
|
JERRY_DEBUGGER_VALUE_ARRAY = 8
|
|
JERRY_DEBUGGER_VALUE_OBJECT = 9
|
|
|
|
def arguments_parse():
|
|
parser = argparse.ArgumentParser(description="JerryScript debugger client")
|
|
|
|
parser.add_argument("address", action="store", nargs="?", default="localhost:5001",
|
|
help="specify a unique network address for tcp connection (default: %(default)s)")
|
|
parser.add_argument("-v", "--verbose", action="store_true", default=False,
|
|
help="increase verbosity (default: %(default)s)")
|
|
parser.add_argument("--non-interactive", action="store_true", default=False,
|
|
help="disable stop when newline is pressed (default: %(default)s)")
|
|
parser.add_argument("--color", action="store_true", default=False,
|
|
help="enable color highlighting on source commands (default: %(default)s)")
|
|
parser.add_argument("--display", action="store", default=None, type=int,
|
|
help="set display range")
|
|
parser.add_argument("--exception", action="store", default=None, type=int, choices=[0, 1],
|
|
help="set exception config, usage 1: [Enable] or 0: [Disable]")
|
|
parser.add_argument("--client-source", action="store", default=[], type=str, nargs="+",
|
|
help="specify a javascript source file to execute")
|
|
parser.add_argument("--channel", choices=["websocket", "rawpacket"], default="websocket",
|
|
help="specify the communication channel (default: %(default)s)")
|
|
parser.add_argument("--protocol", choices=["tcp", "serial"], default="tcp",
|
|
help="specify the transmission protocol over the communication channel (default: %(default)s)")
|
|
parser.add_argument("--serial-config", metavar="CONFIG_STRING", default="/dev/ttyUSB0,115200,8,N,1",
|
|
help="Configure parameters for serial port (default: %(default)s)")
|
|
args = parser.parse_args()
|
|
|
|
if args.verbose:
|
|
logging.basicConfig(format="%(levelname)s: %(message)s", level=logging.DEBUG)
|
|
logging.debug("Debug logging mode: ON")
|
|
|
|
return args
|
|
|
|
|
|
class JerryBreakpoint(object):
|
|
|
|
def __init__(self, line, offset, function):
|
|
self.line = line
|
|
self.offset = offset
|
|
self.function = function
|
|
self.active_index = -1
|
|
|
|
def __str__(self):
|
|
result = self.function.source_name or "<unknown>"
|
|
result += ":%d" % (self.line)
|
|
|
|
if self.function.is_func:
|
|
result += " (in "
|
|
result += self.function.name or "function"
|
|
result += "() at line:%d, col:%d)" % (self.function.line, self.function.column)
|
|
return result
|
|
|
|
def __repr__(self):
|
|
return ("Breakpoint(line:%d, offset:%d, active_index:%d)"
|
|
% (self.line, self.offset, self.active_index))
|
|
|
|
class JerryPendingBreakpoint(object):
|
|
def __init__(self, line=None, source_name=None, function=None):
|
|
self.function = function
|
|
self.line = line
|
|
self.source_name = source_name
|
|
|
|
self.index = -1
|
|
|
|
def __str__(self):
|
|
result = self.source_name or ""
|
|
if self.line:
|
|
result += ":%d" % (self.line)
|
|
else:
|
|
result += "%s()" % (self.function)
|
|
return result
|
|
|
|
|
|
class JerryFunction(object):
|
|
# pylint: disable=too-many-instance-attributes,too-many-arguments
|
|
def __init__(self, is_func, byte_code_cp, source, source_name, line, column, name, lines, offsets):
|
|
self.is_func = bool(is_func)
|
|
self.byte_code_cp = byte_code_cp
|
|
self.source = re.split("\r\n|[\r\n]", source)
|
|
self.source_name = source_name
|
|
self.name = name
|
|
self.lines = {}
|
|
self.offsets = {}
|
|
self.line = line
|
|
self.column = column
|
|
self.first_breakpoint_line = lines[0]
|
|
self.first_breakpoint_offset = offsets[0]
|
|
|
|
if len(self.source) > 1 and not self.source[-1]:
|
|
self.source.pop()
|
|
|
|
for i, _line in enumerate(lines):
|
|
offset = offsets[i]
|
|
breakpoint = JerryBreakpoint(_line, offset, self)
|
|
self.lines[_line] = breakpoint
|
|
self.offsets[offset] = breakpoint
|
|
|
|
def __repr__(self):
|
|
result = ("Function(byte_code_cp:0x%x, source_name:%r, name:%r, line:%d, column:%d { "
|
|
% (self.byte_code_cp, self.source_name, self.name, self.line, self.column))
|
|
|
|
result += ','.join([str(breakpoint) for breakpoint in self.lines.values()])
|
|
|
|
return result + " })"
|
|
|
|
|
|
class Multimap(object):
|
|
|
|
def __init__(self):
|
|
self.map = {}
|
|
|
|
def get(self, key):
|
|
if key in self.map:
|
|
return self.map[key]
|
|
return []
|
|
|
|
def insert(self, key, value):
|
|
if key in self.map:
|
|
self.map[key].append(value)
|
|
else:
|
|
self.map[key] = [value]
|
|
|
|
def delete(self, key, value):
|
|
items = self.map[key]
|
|
|
|
if len(items) == 1:
|
|
del self.map[key]
|
|
else:
|
|
del items[items.index(value)]
|
|
|
|
def __repr__(self):
|
|
return "Multimap(%r)" % (self.map)
|
|
|
|
|
|
class DebuggerAction(object):
|
|
END = 0
|
|
WAIT = 1
|
|
TEXT = 2
|
|
PROMPT = 3
|
|
|
|
def __init__(self, action_type, action_text):
|
|
self.action_type = action_type
|
|
self.action_text = action_text
|
|
|
|
def get_type(self):
|
|
return self.action_type
|
|
|
|
def get_text(self):
|
|
return self.action_text
|
|
|
|
|
|
class JerryDebugger(object):
|
|
# pylint: disable=too-many-instance-attributes,too-many-statements,too-many-public-methods,no-self-use
|
|
def __init__(self, channel):
|
|
self.prompt = False
|
|
self.function_list = {}
|
|
self.source = ''
|
|
self.source_name = ''
|
|
self.exception_string = ''
|
|
self.frame_index = 0
|
|
self.scope_vars = ""
|
|
self.scopes = ""
|
|
self.client_sources = []
|
|
self.last_breakpoint_hit = None
|
|
self.next_breakpoint_index = 0
|
|
self.active_breakpoint_list = {}
|
|
self.pending_breakpoint_list = {}
|
|
self.line_list = Multimap()
|
|
self.display = 0
|
|
self.green = ''
|
|
self.red = ''
|
|
self.yellow = ''
|
|
self.green_bg = ''
|
|
self.yellow_bg = ''
|
|
self.blue = ''
|
|
self.nocolor = ''
|
|
self.src_offset = 0
|
|
self.src_offset_diff = 0
|
|
self.non_interactive = False
|
|
self.current_out = b""
|
|
self.current_log = b""
|
|
self.channel = channel
|
|
|
|
config_size = 8
|
|
# The server will send the configuration message after connection established
|
|
# type [1]
|
|
# configuration [1]
|
|
# version [4]
|
|
# max_message_size [1]
|
|
# cpointer_size [1]
|
|
result = self.channel.connect(config_size)
|
|
|
|
if len(result) != config_size or ord(result[0]) != JERRY_DEBUGGER_CONFIGURATION:
|
|
raise Exception("Unexpected configuration")
|
|
|
|
self.little_endian = ord(result[1]) & JERRY_DEBUGGER_LITTLE_ENDIAN
|
|
self.max_message_size = ord(result[6])
|
|
self.cp_size = ord(result[7])
|
|
|
|
if self.little_endian:
|
|
self.byte_order = "<"
|
|
logging.debug("Little-endian machine")
|
|
else:
|
|
self.byte_order = ">"
|
|
logging.debug("Big-endian machine")
|
|
|
|
if self.cp_size == 2:
|
|
self.cp_format = "H"
|
|
else:
|
|
self.cp_format = "I"
|
|
|
|
self.idx_format = "I"
|
|
|
|
self.version = struct.unpack(self.byte_order + self.idx_format, result[2:6])[0]
|
|
if self.version != JERRY_DEBUGGER_VERSION:
|
|
raise Exception("Incorrect debugger version from target: %d expected: %d" %
|
|
(self.version, JERRY_DEBUGGER_VERSION))
|
|
|
|
logging.debug("Compressed pointer size: %d", self.cp_size)
|
|
|
|
def __del__(self):
|
|
if self.channel is not None:
|
|
self.channel.close()
|
|
|
|
def _exec_command(self, command_id):
|
|
message = struct.pack(self.byte_order + "BB",
|
|
1,
|
|
command_id)
|
|
self.channel.send_message(self.byte_order, message)
|
|
|
|
def quit(self):
|
|
self.prompt = False
|
|
self._exec_command(JERRY_DEBUGGER_CONTINUE)
|
|
|
|
def stop(self):
|
|
self._exec_command(JERRY_DEBUGGER_STOP)
|
|
|
|
def do_continue(self):
|
|
self.prompt = False
|
|
self._exec_command(JERRY_DEBUGGER_CONTINUE)
|
|
|
|
def finish(self):
|
|
self.prompt = False
|
|
self._exec_command(JERRY_DEBUGGER_FINISH)
|
|
|
|
def next(self):
|
|
self.prompt = False
|
|
self._exec_command(JERRY_DEBUGGER_NEXT)
|
|
|
|
def step(self):
|
|
self.prompt = False
|
|
self._exec_command(JERRY_DEBUGGER_STEP)
|
|
|
|
def memstats(self):
|
|
self.prompt = False
|
|
self._exec_command(JERRY_DEBUGGER_MEMSTATS)
|
|
|
|
def scope_chain(self):
|
|
self.prompt = False
|
|
self._exec_command(JERRY_DEBUGGER_GET_SCOPE_CHAIN)
|
|
|
|
def set_break(self, args):
|
|
if not args:
|
|
return "Error: Breakpoint index expected"
|
|
|
|
if ':' in args:
|
|
try:
|
|
if int(args.split(':', 1)[1]) <= 0:
|
|
return "Error: Positive breakpoint index expected"
|
|
|
|
return self._set_breakpoint(args, False)
|
|
|
|
except ValueError as val_errno:
|
|
return "Error: Positive breakpoint index expected: %s" % (val_errno)
|
|
|
|
return self._set_breakpoint(args, False)
|
|
|
|
def delete(self, args):
|
|
if not args:
|
|
return "Error: Breakpoint index expected\n" \
|
|
"Delete the given breakpoint, use 'delete all|active|pending' " \
|
|
"to clear all the given breakpoints\n "
|
|
elif args in ['all', 'pending', 'active']:
|
|
if args == "all":
|
|
self.delete_active()
|
|
self.delete_pending()
|
|
elif args == "pending":
|
|
self.delete_pending()
|
|
elif args == "active":
|
|
self.delete_active()
|
|
return ""
|
|
|
|
try:
|
|
breakpoint_index = int(args)
|
|
except ValueError as val_errno:
|
|
return "Error: Integer number expected, %s\n" % (val_errno)
|
|
|
|
if breakpoint_index in self.active_breakpoint_list:
|
|
breakpoint = self.active_breakpoint_list[breakpoint_index]
|
|
del self.active_breakpoint_list[breakpoint_index]
|
|
breakpoint.active_index = -1
|
|
self.send_breakpoint(breakpoint)
|
|
return "Breakpoint %d deleted\n" % (breakpoint_index)
|
|
elif breakpoint_index in self.pending_breakpoint_list:
|
|
del self.pending_breakpoint_list[breakpoint_index]
|
|
if not self.pending_breakpoint_list:
|
|
self.send_parser_config(0)
|
|
return "Pending breakpoint %d deleted\n" % (breakpoint_index)
|
|
else:
|
|
return "Error: Breakpoint %d not found\n" % (breakpoint_index)
|
|
|
|
def breakpoint_list(self):
|
|
result = ''
|
|
if self.active_breakpoint_list:
|
|
result += "=== %sActive breakpoints %s ===\n" % (self.green_bg, self.nocolor)
|
|
for breakpoint in self.active_breakpoint_list.values():
|
|
result += " %d: %s\n" % (breakpoint.active_index, breakpoint)
|
|
if self.pending_breakpoint_list:
|
|
result += "=== %sPending breakpoints%s ===\n" % (self.yellow_bg, self.nocolor)
|
|
for breakpoint in self.pending_breakpoint_list.values():
|
|
result += " %d: %s (pending)\n" % (breakpoint.index, breakpoint)
|
|
|
|
if not self.active_breakpoint_list and not self.pending_breakpoint_list:
|
|
result += "No breakpoints\n"
|
|
|
|
return result
|
|
|
|
def backtrace(self, args):
|
|
max_depth = 0
|
|
min_depth = 0
|
|
get_total = 0
|
|
|
|
if args:
|
|
args = args.split(" ")
|
|
try:
|
|
if "t" in args:
|
|
get_total = 1
|
|
args.remove("t")
|
|
|
|
if len(args) >= 2:
|
|
min_depth = int(args[0])
|
|
max_depth = int(args[1])
|
|
if max_depth <= 0 or min_depth < 0:
|
|
return "Error: Positive integer number expected\n"
|
|
if min_depth > max_depth:
|
|
return "Error: Start depth needs to be lower than or equal to max depth\n"
|
|
elif len(args) >= 1:
|
|
max_depth = int(args[0])
|
|
if max_depth <= 0:
|
|
return "Error: Positive integer number expected\n"
|
|
|
|
except ValueError as val_errno:
|
|
return "Error: Positive integer number expected, %s\n" % (val_errno)
|
|
|
|
self.frame_index = min_depth
|
|
|
|
message = struct.pack(self.byte_order + "BB" + self.idx_format + self.idx_format + "B",
|
|
1 + 4 + 4 + 1,
|
|
JERRY_DEBUGGER_GET_BACKTRACE,
|
|
min_depth,
|
|
max_depth,
|
|
get_total)
|
|
|
|
self.channel.send_message(self.byte_order, message)
|
|
|
|
self.prompt = False
|
|
return ""
|
|
|
|
def scope_variables(self, args):
|
|
index = 0
|
|
if args:
|
|
try:
|
|
index = int(args)
|
|
if index < 0:
|
|
print ("Error: A non negative integer number expected")
|
|
return ""
|
|
|
|
except ValueError as val_errno:
|
|
return "Error: Non negative integer number expected, %s\n" % (val_errno)
|
|
|
|
message = struct.pack(self.byte_order + "BB" + self.idx_format,
|
|
1 + 4,
|
|
JERRY_DEBUGGER_GET_SCOPE_VARIABLES,
|
|
index)
|
|
|
|
self.channel.send_message(self.byte_order, message)
|
|
|
|
self.prompt = False
|
|
return ""
|
|
|
|
def eval(self, code):
|
|
self._send_string(JERRY_DEBUGGER_EVAL_EVAL + code, JERRY_DEBUGGER_EVAL)
|
|
self.prompt = False
|
|
|
|
def eval_at(self, code, index):
|
|
self._send_string(JERRY_DEBUGGER_EVAL_EVAL + code, JERRY_DEBUGGER_EVAL, index)
|
|
self.prompt = False
|
|
|
|
def throw(self, code):
|
|
self._send_string(JERRY_DEBUGGER_EVAL_THROW + code, JERRY_DEBUGGER_EVAL)
|
|
self.prompt = False
|
|
|
|
def abort(self, args):
|
|
self.delete("all")
|
|
self.exception("0") # disable the exception handler
|
|
self._send_string(JERRY_DEBUGGER_EVAL_ABORT + args, JERRY_DEBUGGER_EVAL)
|
|
self.prompt = False
|
|
|
|
def restart(self):
|
|
self._send_string(JERRY_DEBUGGER_EVAL_ABORT + "\"r353t\"", JERRY_DEBUGGER_EVAL)
|
|
self.prompt = False
|
|
|
|
def exception(self, args):
|
|
try:
|
|
enabled = int(args)
|
|
except (ValueError, TypeError):
|
|
enabled = -1
|
|
|
|
if enabled not in [0, 1]:
|
|
return "Error: Invalid input! Usage 1: [Enable] or 0: [Disable]\n"
|
|
|
|
if enabled:
|
|
logging.debug("Stop at exception enabled")
|
|
self.send_exception_config(enabled)
|
|
|
|
return "Stop at exception enabled\n"
|
|
|
|
logging.debug("Stop at exception disabled")
|
|
self.send_exception_config(enabled)
|
|
|
|
return "Stop at exception disabled\n"
|
|
|
|
def _send_string(self, args, message_type, index=0):
|
|
|
|
# 1: length of type byte
|
|
# 4: length of an uint32 value
|
|
message_header = 1 + 4
|
|
|
|
# Add scope chain index
|
|
if message_type == JERRY_DEBUGGER_EVAL:
|
|
args = struct.pack(self.byte_order + "I", index) + args
|
|
|
|
size = len(args)
|
|
|
|
max_fragment = min(self.max_message_size - message_header, size)
|
|
|
|
message = struct.pack(self.byte_order + "BBI",
|
|
max_fragment + message_header,
|
|
message_type,
|
|
size)
|
|
|
|
if size == max_fragment:
|
|
self.channel.send_message(self.byte_order, message + args)
|
|
return
|
|
|
|
self.channel.send_message(self.byte_order, message + args[0:max_fragment])
|
|
offset = max_fragment
|
|
|
|
if message_type == JERRY_DEBUGGER_EVAL:
|
|
message_type = JERRY_DEBUGGER_EVAL_PART
|
|
else:
|
|
message_type = JERRY_DEBUGGER_CLIENT_SOURCE_PART
|
|
|
|
# 1: length of type byte
|
|
message_header = 1
|
|
|
|
max_fragment = self.max_message_size - message_header
|
|
while offset < size:
|
|
next_fragment = min(max_fragment, size - offset)
|
|
|
|
message = struct.pack(self.byte_order + "BB",
|
|
next_fragment + message_header,
|
|
message_type)
|
|
|
|
prev_offset = offset
|
|
offset += next_fragment
|
|
|
|
self.channel.send_message(self.byte_order, message + args[prev_offset:offset])
|
|
|
|
def delete_active(self):
|
|
for i in 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
|
|
self.send_breakpoint(breakpoint)
|
|
|
|
def delete_pending(self):
|
|
if self.pending_breakpoint_list:
|
|
self.pending_breakpoint_list.clear()
|
|
self.send_parser_config(0)
|
|
|
|
def breakpoint_pending_exists(self, breakpoint):
|
|
for existing_bp in self.pending_breakpoint_list.values():
|
|
if (breakpoint.line and existing_bp.source_name == breakpoint.source_name and \
|
|
existing_bp.line == breakpoint.line) \
|
|
or (not breakpoint.line and existing_bp.function == breakpoint.function):
|
|
return True
|
|
|
|
return False
|
|
|
|
def send_breakpoint(self, breakpoint):
|
|
message = struct.pack(self.byte_order + "BBB" + self.cp_format + self.idx_format,
|
|
1 + 1 + self.cp_size + 4,
|
|
JERRY_DEBUGGER_UPDATE_BREAKPOINT,
|
|
int(breakpoint.active_index >= 0),
|
|
breakpoint.function.byte_code_cp,
|
|
breakpoint.offset)
|
|
self.channel.send_message(self.byte_order, message)
|
|
|
|
def send_bytecode_cp(self, byte_code_cp):
|
|
message = struct.pack(self.byte_order + "BB" + self.cp_format,
|
|
1 + self.cp_size,
|
|
JERRY_DEBUGGER_FREE_BYTE_CODE_CP,
|
|
byte_code_cp)
|
|
self.channel.send_message(self.byte_order, message)
|
|
|
|
def send_exception_config(self, enable):
|
|
message = struct.pack(self.byte_order + "BBB",
|
|
1 + 1,
|
|
JERRY_DEBUGGER_EXCEPTION_CONFIG,
|
|
enable)
|
|
self.channel.send_message(self.byte_order, message)
|
|
|
|
def send_parser_config(self, enable):
|
|
message = struct.pack(self.byte_order + "BBB",
|
|
1 + 1,
|
|
JERRY_DEBUGGER_PARSER_CONFIG,
|
|
enable)
|
|
self.channel.send_message(self.byte_order, message)
|
|
|
|
def set_colors(self):
|
|
self.nocolor = '\033[0m'
|
|
self.green = '\033[92m'
|
|
self.red = '\033[31m'
|
|
self.yellow = '\033[93m'
|
|
self.green_bg = '\033[42m\033[30m'
|
|
self.yellow_bg = '\033[43m\033[30m'
|
|
self.blue = '\033[94m'
|
|
|
|
def store_client_sources(self, args):
|
|
self.client_sources = args
|
|
|
|
def send_client_source(self):
|
|
# Send no more source message if there is no source
|
|
if not self.client_sources:
|
|
self.send_no_more_source()
|
|
return
|
|
|
|
path = self.client_sources.pop(0)
|
|
if not path.lower().endswith('.js'):
|
|
sys.exit("Error: Javascript file expected!")
|
|
return
|
|
|
|
with open(path, 'r') as src_file:
|
|
content = path + "\0" + src_file.read()
|
|
self._send_string(content, JERRY_DEBUGGER_CLIENT_SOURCE)
|
|
|
|
def send_no_more_source(self):
|
|
self._exec_command(JERRY_DEBUGGER_NO_MORE_SOURCES)
|
|
|
|
# pylint: disable=too-many-branches,too-many-locals,too-many-statements,too-many-return-statements
|
|
def process_messages(self):
|
|
result = ""
|
|
while True:
|
|
data = self.channel.get_message(False)
|
|
if not self.non_interactive:
|
|
if sys.stdin in select.select([sys.stdin], [], [], 0)[0]:
|
|
sys.stdin.readline()
|
|
self.stop()
|
|
|
|
if data == b'':
|
|
action_type = DebuggerAction.PROMPT if self.prompt else DebuggerAction.WAIT
|
|
return DebuggerAction(action_type, "")
|
|
|
|
if not data: # Break the while loop if there is no more data.
|
|
return DebuggerAction(DebuggerAction.END, "")
|
|
|
|
buffer_type = ord(data[0])
|
|
buffer_size = len(data) -1
|
|
|
|
logging.debug("Main buffer type: %d, message size: %d", buffer_type, buffer_size)
|
|
|
|
if buffer_type in [JERRY_DEBUGGER_PARSE_ERROR,
|
|
JERRY_DEBUGGER_BYTE_CODE_CP,
|
|
JERRY_DEBUGGER_PARSE_FUNCTION,
|
|
JERRY_DEBUGGER_BREAKPOINT_LIST,
|
|
JERRY_DEBUGGER_SOURCE_CODE,
|
|
JERRY_DEBUGGER_SOURCE_CODE_END,
|
|
JERRY_DEBUGGER_SOURCE_CODE_NAME,
|
|
JERRY_DEBUGGER_SOURCE_CODE_NAME_END,
|
|
JERRY_DEBUGGER_FUNCTION_NAME,
|
|
JERRY_DEBUGGER_FUNCTION_NAME_END]:
|
|
result = self._parse_source(data)
|
|
if result:
|
|
return DebuggerAction(DebuggerAction.TEXT, result)
|
|
|
|
elif buffer_type == JERRY_DEBUGGER_WAITING_AFTER_PARSE:
|
|
self._exec_command(JERRY_DEBUGGER_PARSER_RESUME)
|
|
|
|
elif buffer_type == JERRY_DEBUGGER_RELEASE_BYTE_CODE_CP:
|
|
self._release_function(data)
|
|
|
|
elif buffer_type in [JERRY_DEBUGGER_BREAKPOINT_HIT, JERRY_DEBUGGER_EXCEPTION_HIT]:
|
|
breakpoint_data = struct.unpack(self.byte_order + self.cp_format + self.idx_format, data[1:])
|
|
|
|
breakpoint = self._get_breakpoint(breakpoint_data)
|
|
self.last_breakpoint_hit = breakpoint[0]
|
|
|
|
if buffer_type == JERRY_DEBUGGER_EXCEPTION_HIT:
|
|
result += "Exception throw detected (to disable automatic stop type exception 0)\n"
|
|
if self.exception_string:
|
|
result += "Exception hint: %s\n" % (self.exception_string)
|
|
self.exception_string = ""
|
|
|
|
if breakpoint[1]:
|
|
breakpoint_info = "at"
|
|
else:
|
|
breakpoint_info = "around"
|
|
|
|
if breakpoint[0].active_index >= 0:
|
|
breakpoint_info += " breakpoint:%s%d%s" % (self.red, breakpoint[0].active_index, self.nocolor)
|
|
|
|
result += "Stopped %s %s\n" % (breakpoint_info, breakpoint[0])
|
|
|
|
if self.display > 0:
|
|
result += self.print_source(self.display, self.src_offset)
|
|
|
|
self.prompt = True
|
|
return DebuggerAction(DebuggerAction.TEXT, result)
|
|
|
|
elif buffer_type == JERRY_DEBUGGER_EXCEPTION_STR:
|
|
self.exception_string += data[1:]
|
|
|
|
elif buffer_type == JERRY_DEBUGGER_EXCEPTION_STR_END:
|
|
self.exception_string += data[1:]
|
|
|
|
elif buffer_type == JERRY_DEBUGGER_BACKTRACE_TOTAL:
|
|
total = struct.unpack(self.byte_order + self.idx_format, data[1:])[0]
|
|
result += "Total number of frames: %d\n" % (total)
|
|
return DebuggerAction(DebuggerAction.TEXT, result)
|
|
|
|
elif buffer_type in [JERRY_DEBUGGER_BACKTRACE, JERRY_DEBUGGER_BACKTRACE_END]:
|
|
frame_index = self.frame_index
|
|
|
|
buffer_pos = 1
|
|
while buffer_size > 0:
|
|
breakpoint_data = struct.unpack(self.byte_order + self.cp_format + self.idx_format,
|
|
data[buffer_pos: buffer_pos + self.cp_size + 4])
|
|
|
|
breakpoint = self._get_breakpoint(breakpoint_data)
|
|
|
|
result += "Frame %d: %s\n" % (frame_index, breakpoint[0])
|
|
|
|
frame_index += 1
|
|
buffer_pos += 6
|
|
buffer_size -= 6
|
|
|
|
if buffer_type == JERRY_DEBUGGER_BACKTRACE_END:
|
|
self.prompt = True
|
|
else:
|
|
self.frame_index = frame_index
|
|
|
|
return DebuggerAction(DebuggerAction.TEXT, result)
|
|
|
|
elif buffer_type in [JERRY_DEBUGGER_EVAL_RESULT,
|
|
JERRY_DEBUGGER_EVAL_RESULT_END,
|
|
JERRY_DEBUGGER_OUTPUT_RESULT,
|
|
JERRY_DEBUGGER_OUTPUT_RESULT_END]:
|
|
|
|
result = self._process_incoming_text(buffer_type, data)
|
|
return DebuggerAction(DebuggerAction.TEXT, result)
|
|
|
|
elif buffer_type == JERRY_DEBUGGER_MEMSTATS_RECEIVE:
|
|
|
|
memory_stats = struct.unpack(self.byte_order + self.idx_format * 5,
|
|
data[1: 1 + 4 * 5])
|
|
|
|
result += "Allocated bytes: %s\n" % memory_stats[0]
|
|
result += "Byte code bytes: %s\n" % memory_stats[1]
|
|
result += "String bytes: %s\n" % memory_stats[2]
|
|
result += "Object bytes: %s\n" % memory_stats[3]
|
|
result += "Property bytes: %s\n" % memory_stats[4]
|
|
|
|
self.prompt = True
|
|
return DebuggerAction(DebuggerAction.TEXT, result)
|
|
|
|
elif buffer_type == JERRY_DEBUGGER_WAIT_FOR_SOURCE:
|
|
self.send_client_source()
|
|
|
|
elif buffer_type in [JERRY_DEBUGGER_SCOPE_CHAIN, JERRY_DEBUGGER_SCOPE_CHAIN_END]:
|
|
self.scopes = data[1:]
|
|
|
|
if buffer_type == JERRY_DEBUGGER_SCOPE_CHAIN_END:
|
|
result = self._process_scopes()
|
|
self.scopes = ""
|
|
|
|
self.prompt = True
|
|
|
|
return DebuggerAction(DebuggerAction.TEXT, result)
|
|
|
|
elif buffer_type in [JERRY_DEBUGGER_SCOPE_VARIABLES, JERRY_DEBUGGER_SCOPE_VARIABLES_END]:
|
|
self.scope_vars += "".join(data[1:])
|
|
|
|
if buffer_type == JERRY_DEBUGGER_SCOPE_VARIABLES_END:
|
|
result = self._process_scope_variables()
|
|
self.scope_vars = ""
|
|
|
|
self.prompt = True
|
|
|
|
return DebuggerAction(DebuggerAction.TEXT, result)
|
|
|
|
elif JERRY_DEBUGGER_CLOSE_CONNECTION:
|
|
return DebuggerAction(DebuggerAction.END, "")
|
|
|
|
else:
|
|
raise Exception("Unknown message")
|
|
|
|
def print_source(self, line_num, offset):
|
|
msg = ""
|
|
last_bp = self.last_breakpoint_hit
|
|
|
|
if not last_bp:
|
|
return ""
|
|
|
|
lines = last_bp.function.source
|
|
if last_bp.function.source_name:
|
|
msg += "Source: %s\n" % (last_bp.function.source_name)
|
|
|
|
if line_num == 0:
|
|
start = 0
|
|
end = len(last_bp.function.source)
|
|
else:
|
|
start = max(last_bp.line - line_num, 0)
|
|
end = min(last_bp.line + line_num - 1, len(last_bp.function.source))
|
|
if offset:
|
|
if start + offset < 0:
|
|
self.src_offset += self.src_offset_diff
|
|
offset += self.src_offset_diff
|
|
elif end + offset > len(last_bp.function.source):
|
|
self.src_offset -= self.src_offset_diff
|
|
offset -= self.src_offset_diff
|
|
|
|
start = max(start + offset, 0)
|
|
end = min(end + offset, len(last_bp.function.source))
|
|
|
|
for i in range(start, end):
|
|
if i == last_bp.line - 1:
|
|
msg += "%s%4d%s %s>%s %s\n" % (self.green, i + 1, self.nocolor, self.red, \
|
|
self.nocolor, lines[i])
|
|
else:
|
|
msg += "%s%4d%s %s\n" % (self.green, i + 1, self.nocolor, lines[i])
|
|
|
|
return msg
|
|
|
|
|
|
# pylint: disable=too-many-branches,too-many-locals,too-many-statements
|
|
def _parse_source(self, data):
|
|
source_code = ""
|
|
source_code_name = ""
|
|
function_name = ""
|
|
stack = [{"line": 1,
|
|
"column": 1,
|
|
"name": "",
|
|
"lines": [],
|
|
"offsets": []}]
|
|
new_function_list = {}
|
|
result = ""
|
|
|
|
while True:
|
|
if data is None:
|
|
return "Error: connection lost during source code receiving"
|
|
|
|
buffer_type = ord(data[0])
|
|
buffer_size = len(data) - 1
|
|
|
|
logging.debug("Parser buffer type: %d, message size: %d", buffer_type, buffer_size)
|
|
|
|
if buffer_type == JERRY_DEBUGGER_PARSE_ERROR:
|
|
logging.error("Syntax error found")
|
|
return ""
|
|
|
|
elif buffer_type in [JERRY_DEBUGGER_SOURCE_CODE, JERRY_DEBUGGER_SOURCE_CODE_END]:
|
|
source_code += data[1:]
|
|
|
|
elif buffer_type in [JERRY_DEBUGGER_SOURCE_CODE_NAME, JERRY_DEBUGGER_SOURCE_CODE_NAME_END]:
|
|
source_code_name += data[1:]
|
|
|
|
elif buffer_type in [JERRY_DEBUGGER_FUNCTION_NAME, JERRY_DEBUGGER_FUNCTION_NAME_END]:
|
|
function_name += data[1:]
|
|
|
|
elif buffer_type == JERRY_DEBUGGER_PARSE_FUNCTION:
|
|
logging.debug("Source name: %s, function name: %s", source_code_name, function_name)
|
|
|
|
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,
|
|
"line": position[0],
|
|
"column": position[1],
|
|
"name": function_name,
|
|
"lines": [],
|
|
"offsets": []})
|
|
function_name = ""
|
|
|
|
elif buffer_type in [JERRY_DEBUGGER_BREAKPOINT_LIST, JERRY_DEBUGGER_BREAKPOINT_OFFSET_LIST]:
|
|
name = "lines"
|
|
if buffer_type == JERRY_DEBUGGER_BREAKPOINT_OFFSET_LIST:
|
|
name = "offsets"
|
|
|
|
logging.debug("Breakpoint %s received", name)
|
|
|
|
buffer_pos = 1
|
|
while buffer_size > 0:
|
|
line = struct.unpack(self.byte_order + self.idx_format,
|
|
data[buffer_pos: buffer_pos + 4])
|
|
stack[-1][name].append(line[0])
|
|
buffer_pos += 4
|
|
buffer_size -= 4
|
|
|
|
elif buffer_type == JERRY_DEBUGGER_BYTE_CODE_CP:
|
|
byte_code_cp = struct.unpack(self.byte_order + self.cp_format,
|
|
data[1: 1 + self.cp_size])[0]
|
|
|
|
logging.debug("Byte code cptr received: {0x%x}", byte_code_cp)
|
|
|
|
func_desc = stack.pop()
|
|
|
|
# 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
|
|
|
|
function = JerryFunction(stack,
|
|
byte_code_cp,
|
|
func_desc["source"],
|
|
func_desc["source_name"],
|
|
func_desc["line"],
|
|
func_desc["column"],
|
|
func_desc["name"],
|
|
func_desc["lines"],
|
|
func_desc["offsets"])
|
|
|
|
new_function_list[byte_code_cp] = function
|
|
|
|
if not stack:
|
|
logging.debug("Parse completed.")
|
|
break
|
|
|
|
elif buffer_type == JERRY_DEBUGGER_RELEASE_BYTE_CODE_CP:
|
|
# Redefined functions are dropped during parsing.
|
|
byte_code_cp = struct.unpack(self.byte_order + self.cp_format,
|
|
data[1: 1 + self.cp_size])[0]
|
|
|
|
if byte_code_cp in new_function_list:
|
|
del new_function_list[byte_code_cp]
|
|
self.send_bytecode_cp(byte_code_cp)
|
|
else:
|
|
self._release_function(data)
|
|
|
|
elif buffer_type in [JERRY_DEBUGGER_OUTPUT_RESULT,
|
|
JERRY_DEBUGGER_OUTPUT_RESULT_END]:
|
|
result += self._process_incoming_text(buffer_type, data)
|
|
|
|
else:
|
|
logging.error("Parser error!")
|
|
raise Exception("Unexpected message")
|
|
|
|
data = self.channel.get_message(True)
|
|
|
|
# Copy the ready list to the global storage.
|
|
self.function_list.update(new_function_list)
|
|
|
|
for function in new_function_list.values():
|
|
for line, breakpoint in function.lines.items():
|
|
self.line_list.insert(line, breakpoint)
|
|
|
|
# Try to set the pending breakpoints
|
|
if self.pending_breakpoint_list:
|
|
logging.debug("Pending breakpoints available")
|
|
bp_list = self.pending_breakpoint_list
|
|
|
|
for breakpoint_index, breakpoint in bp_list.items():
|
|
source_lines = 0
|
|
for src in new_function_list.values():
|
|
if src.source_name == breakpoint.source_name:
|
|
source_lines = len(src.source)
|
|
break
|
|
|
|
if breakpoint.line:
|
|
if breakpoint.line <= source_lines:
|
|
command = breakpoint.source_name + ":" + str(breakpoint.line)
|
|
set_result = self._set_breakpoint(command, True)
|
|
|
|
if set_result:
|
|
result += set_result
|
|
del bp_list[breakpoint_index]
|
|
elif breakpoint.function:
|
|
command = breakpoint.function
|
|
set_result = self._set_breakpoint(command, True)
|
|
|
|
if set_result:
|
|
result += set_result
|
|
del bp_list[breakpoint_index]
|
|
|
|
if not bp_list:
|
|
self.send_parser_config(0)
|
|
return result
|
|
|
|
logging.debug("No pending breakpoints")
|
|
return result
|
|
|
|
|
|
def _release_function(self, data):
|
|
byte_code_cp = struct.unpack(self.byte_order + self.cp_format,
|
|
data[1: 1 + self.cp_size])[0]
|
|
|
|
function = self.function_list[byte_code_cp]
|
|
|
|
for line, breakpoint in function.lines.items():
|
|
self.line_list.delete(line, breakpoint)
|
|
if breakpoint.active_index >= 0:
|
|
del self.active_breakpoint_list[breakpoint.active_index]
|
|
|
|
del self.function_list[byte_code_cp]
|
|
self.send_bytecode_cp(byte_code_cp)
|
|
logging.debug("Function {0x%x} byte-code released", byte_code_cp)
|
|
|
|
|
|
def _enable_breakpoint(self, breakpoint):
|
|
if isinstance(breakpoint, JerryPendingBreakpoint):
|
|
if self.breakpoint_pending_exists(breakpoint):
|
|
return "%sPending breakpoint%s already exists\n" % (self.yellow, self.nocolor)
|
|
|
|
self.next_breakpoint_index += 1
|
|
breakpoint.index = self.next_breakpoint_index
|
|
self.pending_breakpoint_list[self.next_breakpoint_index] = breakpoint
|
|
return ("%sPending breakpoint %d%s at %s\n" % (self.yellow,
|
|
breakpoint.index,
|
|
self.nocolor,
|
|
breakpoint))
|
|
|
|
if breakpoint.active_index < 0:
|
|
self.next_breakpoint_index += 1
|
|
self.active_breakpoint_list[self.next_breakpoint_index] = breakpoint
|
|
breakpoint.active_index = self.next_breakpoint_index
|
|
self.send_breakpoint(breakpoint)
|
|
|
|
return "%sBreakpoint %d%s at %s\n" % (self.green,
|
|
breakpoint.active_index,
|
|
self.nocolor,
|
|
breakpoint)
|
|
|
|
|
|
def _set_breakpoint(self, string, pending):
|
|
line = re.match("(.*):(\\d+)$", string)
|
|
result = ""
|
|
|
|
if line:
|
|
source_name = line.group(1)
|
|
new_line = int(line.group(2))
|
|
|
|
for breakpoint in self.line_list.get(new_line):
|
|
func_source = breakpoint.function.source_name
|
|
if (source_name == func_source or
|
|
func_source.endswith("/" + source_name) or
|
|
func_source.endswith("\\" + source_name)):
|
|
|
|
result += self._enable_breakpoint(breakpoint)
|
|
|
|
else:
|
|
functions_to_enable = []
|
|
for function in self.function_list.values():
|
|
if function.name == string:
|
|
functions_to_enable.append(function)
|
|
|
|
functions_to_enable.sort(key=lambda x: x.line)
|
|
|
|
for function in functions_to_enable:
|
|
result += self._enable_breakpoint(function.lines[function.first_breakpoint_line])
|
|
|
|
if not result and not pending:
|
|
print("No breakpoint found, do you want to add a %spending breakpoint%s? (y or [n])" % \
|
|
(self.yellow, self.nocolor))
|
|
|
|
ans = sys.stdin.readline()
|
|
if ans in ['yes\n', 'y\n']:
|
|
if not self.pending_breakpoint_list:
|
|
self.send_parser_config(1)
|
|
|
|
if line:
|
|
breakpoint = JerryPendingBreakpoint(int(line.group(2)), line.group(1))
|
|
else:
|
|
breakpoint = JerryPendingBreakpoint(function=string)
|
|
result += self._enable_breakpoint(breakpoint)
|
|
|
|
return result
|
|
|
|
|
|
def _get_breakpoint(self, breakpoint_data):
|
|
function = self.function_list[breakpoint_data[0]]
|
|
offset = breakpoint_data[1]
|
|
|
|
if offset in function.offsets:
|
|
return (function.offsets[offset], True)
|
|
|
|
if offset < function.first_breakpoint_offset:
|
|
return (function.offsets[function.first_breakpoint_offset], False)
|
|
|
|
nearest_offset = -1
|
|
|
|
for current_offset in function.offsets:
|
|
if current_offset <= offset and current_offset > nearest_offset:
|
|
nearest_offset = current_offset
|
|
|
|
return (function.offsets[nearest_offset], False)
|
|
|
|
def _process_incoming_text(self, buffer_type, data):
|
|
message = b""
|
|
msg_type = buffer_type
|
|
while True:
|
|
if buffer_type in [JERRY_DEBUGGER_EVAL_RESULT_END,
|
|
JERRY_DEBUGGER_OUTPUT_RESULT_END]:
|
|
subtype = ord(data[-1])
|
|
message += data[1:-1]
|
|
break
|
|
else:
|
|
message += data[1:]
|
|
|
|
data = self.channel.get_message(True)
|
|
buffer_type = ord(data[0])
|
|
# Checks if the next frame would be an invalid data frame.
|
|
# If it is not the message type, or the end type of it, an exception is thrown.
|
|
if buffer_type not in [msg_type, msg_type + 1]:
|
|
raise Exception("Invalid data caught")
|
|
|
|
# Subtypes of output
|
|
if buffer_type == JERRY_DEBUGGER_OUTPUT_RESULT_END:
|
|
if subtype == JERRY_DEBUGGER_OUTPUT_OK:
|
|
log_type = "%sout:%s " % (self.blue, self.nocolor)
|
|
|
|
message = self.current_out + message
|
|
lines = message.split("\n")
|
|
self.current_out = lines.pop()
|
|
|
|
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()
|
|
|
|
return "".join(["%s%s\n" % (log_type, line) for line in lines])
|
|
|
|
if not message.endswith("\n"):
|
|
message += "\n"
|
|
|
|
if subtype == JERRY_DEBUGGER_OUTPUT_WARNING:
|
|
return "%swarning: %s%s" % (self.yellow, self.nocolor, message)
|
|
elif subtype == JERRY_DEBUGGER_OUTPUT_ERROR:
|
|
return "%serr: %s%s" % (self.red, self.nocolor, message)
|
|
elif subtype == JERRY_DEBUGGER_OUTPUT_TRACE:
|
|
return "%strace: %s%s" % (self.blue, self.nocolor, message)
|
|
|
|
# Subtypes of eval
|
|
self.prompt = True
|
|
|
|
if not message.endswith("\n"):
|
|
message += "\n"
|
|
|
|
if subtype == JERRY_DEBUGGER_EVAL_ERROR:
|
|
return "Uncaught exception: %s" % (message)
|
|
return message
|
|
|
|
def _process_scope_variables(self):
|
|
buff_size = len(self.scope_vars)
|
|
buff_pos = 0
|
|
|
|
table = [['name', 'type', 'value']]
|
|
|
|
while buff_pos != buff_size:
|
|
# Process name
|
|
name_length = ord(self.scope_vars[buff_pos:buff_pos + 1])
|
|
buff_pos += 1
|
|
name = self.scope_vars[buff_pos:buff_pos + name_length]
|
|
buff_pos += name_length
|
|
|
|
# Process type
|
|
value_type = ord(self.scope_vars[buff_pos:buff_pos + 1])
|
|
|
|
buff_pos += 1
|
|
|
|
value_length = ord(self.scope_vars[buff_pos:buff_pos + 1])
|
|
buff_pos += 1
|
|
value = self.scope_vars[buff_pos: buff_pos + value_length]
|
|
buff_pos += value_length
|
|
|
|
if value_type == JERRY_DEBUGGER_VALUE_UNDEFINED:
|
|
table.append([name, 'undefined', value])
|
|
elif value_type == JERRY_DEBUGGER_VALUE_NULL:
|
|
table.append([name, 'Null', value])
|
|
elif value_type == JERRY_DEBUGGER_VALUE_BOOLEAN:
|
|
table.append([name, 'Boolean', value])
|
|
elif value_type == JERRY_DEBUGGER_VALUE_NUMBER:
|
|
table.append([name, 'Number', value])
|
|
elif value_type == JERRY_DEBUGGER_VALUE_STRING:
|
|
table.append([name, 'String', value])
|
|
elif value_type == JERRY_DEBUGGER_VALUE_FUNCTION:
|
|
table.append([name, 'Function', value])
|
|
elif value_type == JERRY_DEBUGGER_VALUE_ARRAY:
|
|
table.append([name, 'Array', '[' + value + ']'])
|
|
elif value_type == JERRY_DEBUGGER_VALUE_OBJECT:
|
|
table.append([name, 'Object', value])
|
|
|
|
result = self._form_table(table)
|
|
|
|
return result
|
|
|
|
def _process_scopes(self):
|
|
result = ""
|
|
table = [['level', 'type']]
|
|
|
|
for i, level in enumerate(self.scopes):
|
|
if ord(level) == JERRY_DEBUGGER_SCOPE_WITH:
|
|
table.append([str(i), 'with'])
|
|
elif ord(level) == JERRY_DEBUGGER_SCOPE_GLOBAL:
|
|
table.append([str(i), 'global'])
|
|
elif ord(level) == JERRY_DEBUGGER_SCOPE_NON_CLOSURE:
|
|
# Currently it is only marks the catch closure.
|
|
table.append([str(i), 'catch'])
|
|
elif ord(level) == JERRY_DEBUGGER_SCOPE_LOCAL:
|
|
table.append([str(i), 'local'])
|
|
elif ord(level) == JERRY_DEBUGGER_SCOPE_CLOSURE:
|
|
table.append([str(i), 'closure'])
|
|
else:
|
|
raise Exception("Unexpected scope chain element")
|
|
|
|
result = self._form_table(table)
|
|
|
|
return result
|
|
|
|
def _form_table(self, table):
|
|
result = ""
|
|
col_width = [max(len(x) for x in col) for col in zip(*table)]
|
|
for line in table:
|
|
result += " | ".join("{:{}}".format(x, col_width[i])
|
|
for i, x in enumerate(line)) + " \n"
|
|
|
|
return result
|