Lines Matching refs:self
154 def __init__(self, line, offset, function):
155 self.line = line
156 self.offset = offset
157 self.function = function
158 self.active_index = -1
160 def __str__(self):
161 result = self.function.source_name or "<unknown>"
162 result += ":%d" % (self.line)
164 if self.function.is_func:
166 result += self.function.name or "function"
167 result += "() at line:%d, col:%d)" % (self.function.line, self.function.column)
170 def __repr__(self):
172 % (self.line, self.offset, self.active_index))
175 def __init__(self, line=None, source_name=None, function=None):
176 self.function = function
177 self.line = line
178 self.source_name = source_name
180 self.index = -1
182 def __str__(self):
183 result = self.source_name or ""
184 if self.line:
185 result += ":%d" % (self.line)
187 result += "%s()" % (self.function)
193 def __init__(self, is_func, byte_code_cp, source, source_name, line, column, name, lines, offsets):
194 self.is_func = bool(is_func)
195 self.byte_code_cp = byte_code_cp
196 self.source = re.split("\r\n|[\r\n]", source)
197 self.source_name = source_name
198 self.name = name
199 self.lines = {}
200 self.offsets = {}
201 self.line = line
202 self.column = column
203 self.first_breakpoint_line = lines[0]
204 self.first_breakpoint_offset = offsets[0]
206 if len(self.source) > 1 and not self.source[-1]:
207 self.source.pop()
211 breakpoint = JerryBreakpoint(_line, offset, self)
212 self.lines[_line] = breakpoint
213 self.offsets[offset] = breakpoint
215 def __repr__(self):
217 % (self.byte_code_cp, self.source_name, self.name, self.line, self.column))
219 result += ','.join([str(breakpoint) for breakpoint in self.lines.values()])
226 def __init__(self):
227 self.map = {}
229 def get(self, key):
230 if key in self.map:
231 return self.map[key]
234 def insert(self, key, value):
235 if key in self.map:
236 self.map[key].append(value)
238 self.map[key] = [value]
240 def delete(self, key, value):
241 items = self.map[key]
244 del self.map[key]
248 def __repr__(self):
249 return "Multimap(%r)" % (self.map)
258 def __init__(self, action_type, action_text):
259 self.action_type = action_type
260 self.action_text = action_text
262 def get_type(self):
263 return self.action_type
265 def get_text(self):
266 return self.action_text
270 # pylint: disable=too-many-instance-attributes,too-many-statements,too-many-public-methods,no-self-use
271 def __init__(self, channel):
272 self.prompt = False
273 self.function_list = {}
274 self.source = ''
275 self.source_name = ''
276 self.exception_string = ''
277 self.frame_index = 0
278 self.scope_vars = ""
279 self.scope_data = ""
280 self.client_sources = []
281 self.last_breakpoint_hit = None
282 self.next_breakpoint_index = 0
283 self.active_breakpoint_list = {}
284 self.pending_breakpoint_list = {}
285 self.line_list = Multimap()
286 self.display = 0
287 self.green = ''
288 self.red = ''
289 self.yellow = ''
290 self.green_bg = ''
291 self.yellow_bg = ''
292 self.blue = ''
293 self.nocolor = ''
294 self.src_offset = 0
295 self.src_offset_diff = 0
296 self.non_interactive = False
297 self.current_out = b""
298 self.current_log = b""
299 self.channel = channel
308 result = self.channel.connect(config_size)
313 self.little_endian = ord(result[1]) & JERRY_DEBUGGER_LITTLE_ENDIAN
314 self.max_message_size = ord(result[6])
315 self.cp_size = ord(result[7])
317 if self.little_endian:
318 self.byte_order = "<"
321 self.byte_order = ">"
324 if self.cp_size == 2:
325 self.cp_format = "H"
327 self.cp_format = "I"
329 self.idx_format = "I"
331 self.version = struct.unpack(self.byte_order + self.idx_format, result[2:6])[0]
332 if self.version != JERRY_DEBUGGER_VERSION:
334 (self.version, JERRY_DEBUGGER_VERSION))
336 logging.debug("Compressed pointer size: %d", self.cp_size)
338 def __del__(self):
339 if self.channel is not None:
340 self.channel.close()
342 def _exec_command(self, command_id):
343 message = struct.pack(self.byte_order + "BB",
346 self.channel.send_message(self.byte_order, message)
348 def quit(self):
349 self.prompt = False
350 self._exec_command(JERRY_DEBUGGER_CONTINUE)
352 def set_colors(self):
353 self.nocolor = '\033[0m'
354 self.green = '\033[92m'
355 self.red = '\033[31m'
356 self.yellow = '\033[93m'
357 self.green_bg = '\033[42m\033[30m'
358 self.yellow_bg = '\033[43m\033[30m'
359 self.blue = '\033[94m'
361 def stop(self):
362 self._exec_command(JERRY_DEBUGGER_STOP)
364 def set_break(self, args):
373 return self._set_breakpoint(args, False)
378 return self._set_breakpoint(args, False)
380 def breakpoint_list(self):
382 if self.active_breakpoint_list:
383 result += "=== %sActive breakpoints %s ===\n" % (self.green_bg, self.nocolor)
384 for breakpoint in self.active_breakpoint_list.values():
386 if self.pending_breakpoint_list:
387 result += "=== %sPending breakpoints%s ===\n" % (self.yellow_bg, self.nocolor)
388 for breakpoint in self.pending_breakpoint_list.values():
391 if not self.active_breakpoint_list and not self.pending_breakpoint_list:
396 def delete(self, args):
403 for i in self.active_breakpoint_list.values():
404 breakpoint = self.active_breakpoint_list[i.active_index]
405 del self.active_breakpoint_list[i.active_index]
407 self._send_breakpoint(breakpoint)
410 if self.pending_breakpoint_list:
411 self.pending_breakpoint_list.clear()
412 self._send_parser_config(0)
420 if breakpoint_index in self.active_breakpoint_list:
421 breakpoint = self.active_breakpoint_list[breakpoint_index]
422 del self.active_breakpoint_list[breakpoint_index]
424 self._send_breakpoint(breakpoint)
426 elif breakpoint_index in self.pending_breakpoint_list:
427 del self.pending_breakpoint_list[breakpoint_index]
428 if not self.pending_breakpoint_list:
429 self._send_parser_config(0)
434 def next(self):
435 self.prompt = False
436 self._exec_command(JERRY_DEBUGGER_NEXT)
438 def step(self):
439 self.prompt = False
440 self._exec_command(JERRY_DEBUGGER_STEP)
442 def do_continue(self):
443 self.prompt = False
444 self._exec_command(JERRY_DEBUGGER_CONTINUE)
446 def finish(self):
447 self.prompt = False
448 self._exec_command(JERRY_DEBUGGER_FINISH)
450 def backtrace(self, args):
477 self.frame_index = min_depth
479 message = struct.pack(self.byte_order + "BB" + self.idx_format + self.idx_format + "B",
486 self.channel.send_message(self.byte_order, message)
488 self.prompt = False
491 def eval(self, code):
492 self._send_string(JERRY_DEBUGGER_EVAL_EVAL + code, JERRY_DEBUGGER_EVAL)
493 self.prompt = False
495 def eval_at(self, code, index):
496 self._send_string(JERRY_DEBUGGER_EVAL_EVAL + code, JERRY_DEBUGGER_EVAL, index)
497 self.prompt = False
499 def throw(self, code):
500 self._send_string(JERRY_DEBUGGER_EVAL_THROW + code, JERRY_DEBUGGER_EVAL)
501 self.prompt = False
503 def abort(self, args):
504 self.delete("all")
505 self.exception("0") # disable the exception handler
506 self._send_string(JERRY_DEBUGGER_EVAL_ABORT + args, JERRY_DEBUGGER_EVAL)
507 self.prompt = False
509 def restart(self):
510 self._send_string(JERRY_DEBUGGER_EVAL_ABORT + "\"r353t\"", JERRY_DEBUGGER_EVAL)
511 self.prompt = False
513 def exception(self, args):
524 self._send_exception_config(enabled)
529 self._send_exception_config(enabled)
533 def scope_chain(self):
534 self.prompt = False
535 self._exec_command(JERRY_DEBUGGER_GET_SCOPE_CHAIN)
537 def scope_variables(self, args):
549 message = struct.pack(self.byte_order + "BB" + self.idx_format,
554 self.channel.send_message(self.byte_order, message)
556 self.prompt = False
559 def memstats(self):
560 self.prompt = False
561 self._exec_command(JERRY_DEBUGGER_MEMSTATS)
563 def _send_string(self, args, message_type, index=0):
571 args = struct.pack(self.byte_order + "I", index) + args
575 max_fragment = min(self.max_message_size - message_header, size)
577 message = struct.pack(self.byte_order + "BBI",
583 self.channel.send_message(self.byte_order, message + args)
586 self.channel.send_message(self.byte_order, message + args[0:max_fragment])
597 max_fragment = self.max_message_size - message_header
601 message = struct.pack(self.byte_order + "BB",
608 self.channel.send_message(self.byte_order, message + args[prev_offset:offset])
610 def _breakpoint_pending_exists(self, breakpoint):
611 for existing_bp in self.pending_breakpoint_list.values():
619 def _send_breakpoint(self, breakpoint):
620 message = struct.pack(self.byte_order + "BBB" + self.cp_format + self.idx_format,
621 1 + 1 + self.cp_size + 4,
626 self.channel.send_message(self.byte_order, message)
628 def _send_bytecode_cp(self, byte_code_cp):
629 message = struct.pack(self.byte_order + "BB" + self.cp_format,
630 1 + self.cp_size,
633 self.channel.send_message(self.byte_order, message)
635 def _send_exception_config(self, enable):
636 message = struct.pack(self.byte_order + "BBB",
640 self.channel.send_message(self.byte_order, message)
642 def _send_parser_config(self, enable):
643 message = struct.pack(self.byte_order + "BBB",
647 self.channel.send_message(self.byte_order, message)
649 def store_client_sources(self, args):
650 self.client_sources = args
652 def send_client_source(self):
654 if not self.client_sources:
655 self.send_no_more_source()
658 path = self.client_sources.pop(0)
665 self._send_string(content, JERRY_DEBUGGER_CLIENT_SOURCE)
667 def send_no_more_source(self):
668 self._exec_command(JERRY_DEBUGGER_NO_MORE_SOURCES)
671 def process_messages(self):
674 data = self.channel.get_message(False)
675 if not self.non_interactive:
678 self.stop()
681 action_type = DebuggerAction.PROMPT if self.prompt else DebuggerAction.WAIT
702 result = self._parse_source(data)
707 self._exec_command(JERRY_DEBUGGER_PARSER_RESUME)
710 self._release_function(data)
713 breakpoint_data = struct.unpack(self.byte_order + self.cp_format + self.idx_format, data[1:])
715 breakpoint = self._get_breakpoint(breakpoint_data)
716 self.last_breakpoint_hit = breakpoint[0]
720 if self.exception_string:
721 result += "Exception hint: %s\n" % (self.exception_string)
722 self.exception_string = ""
730 breakpoint_info += " breakpoint:%s%d%s" % (self.red, breakpoint[0].active_index, self.nocolor)
734 if self.display > 0:
735 result += self.print_source(self.display, self.src_offset)
737 self.prompt = True
741 self.exception_string += data[1:]
744 self.exception_string += data[1:]
747 total = struct.unpack(self.byte_order + self.idx_format, data[1:])[0]
752 frame_index = self.frame_index
756 breakpoint_data = struct.unpack(self.byte_order + self.cp_format + self.idx_format,
757 data[buffer_pos: buffer_pos + self.cp_size + 4])
759 breakpoint = self._get_breakpoint(breakpoint_data)
768 self.prompt = True
770 self.frame_index = frame_index
779 result = self._process_incoming_text(buffer_type, data)
784 memory_stats = struct.unpack(self.byte_order + self.idx_format * 5,
793 self.prompt = True
797 self.send_client_source()
800 self.scope_data = data[1:]
803 result = self._process_scope()
804 self.scope_data = ""
806 self.prompt = True
811 self.scope_vars += "".join(data[1:])
814 result = self._process_scope_variables()
815 self.scope_vars = ""
817 self.prompt = True
827 def print_source(self, line_num, offset):
829 last_bp = self.last_breakpoint_hit
846 self.src_offset += self.src_offset_diff
847 offset += self.src_offset_diff
849 self.src_offset -= self.src_offset_diff
850 offset -= self.src_offset_diff
857 msg += "%s%4d%s %s>%s %s\n" % (self.green, i + 1, self.nocolor, self.red, \
858 self.nocolor, lines[i])
860 msg += "%s%4d%s %s\n" % (self.green, i + 1, self.nocolor, lines[i])
866 def _parse_source(self, data):
903 position = struct.unpack(self.byte_order + self.idx_format + self.idx_format,
924 line = struct.unpack(self.byte_order + self.idx_format,
931 byte_code_cp = struct.unpack(self.byte_order + self.cp_format,
932 data[1: 1 + self.cp_size])[0]
961 byte_code_cp = struct.unpack(self.byte_order + self.cp_format,
962 data[1: 1 + self.cp_size])[0]
966 self._send_bytecode_cp(byte_code_cp)
968 self._release_function(data)
972 result += self._process_incoming_text(buffer_type, data)
978 data = self.channel.get_message(True)
981 self.function_list.update(new_function_list)
985 self.line_list.insert(line, breakpoint)
988 if self.pending_breakpoint_list:
990 bp_list = self.pending_breakpoint_list
1002 set_result = self._set_breakpoint(command, True)
1009 set_result = self._set_breakpoint(command, True)
1016 self._send_parser_config(0)
1023 def _release_function(self, data):
1024 byte_code_cp = struct.unpack(self.byte_order + self.cp_format,
1025 data[1: 1 + self.cp_size])[0]
1027 function = self.function_list[byte_code_cp]
1030 self.line_list.delete(line, breakpoint)
1032 del self.active_breakpoint_list[breakpoint.active_index]
1034 del self.function_list[byte_code_cp]
1035 self._send_bytecode_cp(byte_code_cp)
1039 def _enable_breakpoint(self, breakpoint):
1041 if self._breakpoint_pending_exists(breakpoint):
1042 return "%sPending breakpoint%s already exists\n" % (self.yellow, self.nocolor)
1044 self.next_breakpoint_index += 1
1045 breakpoint.index = self.next_breakpoint_index
1046 self.pending_breakpoint_list[self.next_breakpoint_index] = breakpoint
1047 return ("%sPending breakpoint %d%s at %s\n" % (self.yellow,
1049 self.nocolor,
1053 self.next_breakpoint_index += 1
1054 self.active_breakpoint_list[self.next_breakpoint_index] = breakpoint
1055 breakpoint.active_index = self.next_breakpoint_index
1056 self._send_breakpoint(breakpoint)
1058 return "%sBreakpoint %d%s at %s\n" % (self.green,
1060 self.nocolor,
1064 def _set_breakpoint(self, string, pending):
1072 for breakpoint in self.line_list.get(new_line):
1078 result += self._enable_breakpoint(breakpoint)
1082 for function in self.function_list.values():
1089 result += self._enable_breakpoint(function.lines[function.first_breakpoint_line])
1093 (self.yellow, self.nocolor))
1097 if not self.pending_breakpoint_list:
1098 self._send_parser_config(1)
1104 result += self._enable_breakpoint(breakpoint)
1109 def _get_breakpoint(self, breakpoint_data):
1110 function = self.function_list[breakpoint_data[0]]
1127 def _process_incoming_text(self, buffer_type, data):
1139 data = self.channel.get_message(True)
1149 log_type = "%sout:%s " % (self.blue, self.nocolor)
1151 message = self.current_out + message
1153 self.current_out = lines.pop()
1158 log_type = "%slog:%s " % (self.yellow, self.nocolor)
1160 message = self.current_log + message
1162 self.current_log = lines.pop()
1170 return "%swarning: %s%s" % (self.yellow, self.nocolor, message)
1172 return "%serr: %s%s" % (self.red, self.nocolor, message)
1174 return "%strace: %s%s" % (self.blue, self.nocolor, message)
1177 self.prompt = True
1186 def _process_scope_variables(self):
1187 buff_size = len(self.scope_vars)
1194 name_length = ord(self.scope_vars[buff_pos:buff_pos + 1])
1196 name = self.scope_vars[buff_pos:buff_pos + name_length]
1200 value_type = ord(self.scope_vars[buff_pos:buff_pos + 1])
1204 value_length = ord(self.scope_vars[buff_pos:buff_pos + 1])
1206 value = self.scope_vars[buff_pos: buff_pos + value_length]
1226 result = self._form_table(table)
1230 def _process_scope(self):
1234 for i, level in enumerate(self.scope_data):
1249 result = self._form_table(table)
1253 def _form_table(self, table):