| import linecache | |
| import os.path | |
| import re | |
| import traceback # @Reimport | |
| from django_debug import find_django_render_frame | |
| from django_debug import is_django_render_call, is_django_suspended, suspend_django, is_django_resolve_call, is_django_context_get_call | |
| from django_frame import DjangoTemplateFrame | |
| from django_frame import is_django_exception_break_context | |
| from django_frame import just_raised, get_template_file_name, get_template_line | |
| import pydev_log | |
| from pydevd_breakpoints import get_exception_breakpoint, get_exception_name | |
| from pydevd_comm import CMD_ADD_DJANGO_EXCEPTION_BREAK, \ | |
| CMD_STEP_CAUGHT_EXCEPTION, CMD_STEP_RETURN, CMD_STEP_OVER, CMD_SET_BREAK, \ | |
| CMD_STEP_INTO, CMD_SMART_STEP_INTO, CMD_RUN_TO_LINE, CMD_SET_NEXT_STATEMENT | |
| from pydevd_constants import * # @UnusedWildImport | |
| from pydevd_file_utils import GetFilenameAndBase | |
| from pydevd_signature import sendSignatureCallTrace | |
| import pydevd_vars | |
| import pydevd_dont_trace | |
| basename = os.path.basename | |
| IGNORE_EXCEPTION_TAG = re.compile('[^#]*#.*@IgnoreException') | |
| #======================================================================================================================= | |
| # PyDBFrame | |
| #======================================================================================================================= | |
| class PyDBFrame: | |
| '''This makes the tracing for a given frame, so, the trace_dispatch | |
| is used initially when we enter into a new context ('call') and then | |
| is reused for the entire context. | |
| ''' | |
| #Note: class (and not instance) attributes. | |
| #Same thing in the main debugger but only considering the file contents, while the one in the main debugger | |
| #considers the user input (so, the actual result must be a join of both). | |
| filename_to_lines_where_exceptions_are_ignored = {} | |
| filename_to_stat_info = {} | |
| def __init__(self, args): | |
| #args = mainDebugger, filename, base, info, t, frame | |
| #yeap, much faster than putting in self and then getting it from self later on | |
| self._args = args[:-1] | |
| def setSuspend(self, *args, **kwargs): | |
| self._args[0].setSuspend(*args, **kwargs) | |
| def doWaitSuspend(self, *args, **kwargs): | |
| self._args[0].doWaitSuspend(*args, **kwargs) | |
| def _is_django_render_call(self, frame): | |
| try: | |
| return self._cached_is_django_render_call | |
| except: | |
| # Calculate lazily: note that a PyDBFrame always deals with the same | |
| # frame over and over, so, we can cache this. | |
| # -- although we can't cache things which change over time (such as | |
| # the breakpoints for the file). | |
| ret = self._cached_is_django_render_call = is_django_render_call(frame) | |
| return ret | |
| def trace_exception(self, frame, event, arg): | |
| if event == 'exception': | |
| flag, frame = self.should_stop_on_exception(frame, event, arg) | |
| if flag: | |
| self.handle_exception(frame, event, arg) | |
| return self.trace_dispatch | |
| return self.trace_exception | |
| def should_stop_on_exception(self, frame, event, arg): | |
| mainDebugger, _filename, info, thread = self._args | |
| flag = False | |
| if info.pydev_state != STATE_SUSPEND: #and breakpoint is not None: | |
| exception, value, trace = arg | |
| if trace is not None: #on jython trace is None on the first event | |
| exception_breakpoint = get_exception_breakpoint( | |
| exception, mainDebugger.break_on_caught_exceptions) | |
| if exception_breakpoint is not None: | |
| if not exception_breakpoint.notify_on_first_raise_only or just_raised(trace): | |
| # print frame.f_code.co_name | |
| add_exception_to_frame(frame, (exception, value, trace)) | |
| thread.additionalInfo.message = exception_breakpoint.qname | |
| flag = True | |
| else: | |
| flag = False | |
| else: | |
| try: | |
| if mainDebugger.django_exception_break and get_exception_name(exception) in [ | |
| 'VariableDoesNotExist', 'TemplateDoesNotExist', 'TemplateSyntaxError'] \ | |
| and just_raised(trace) and is_django_exception_break_context(frame): | |
| render_frame = find_django_render_frame(frame) | |
| if render_frame: | |
| suspend_frame = suspend_django( | |
| self, mainDebugger, thread, render_frame, CMD_ADD_DJANGO_EXCEPTION_BREAK) | |
| if suspend_frame: | |
| add_exception_to_frame(suspend_frame, (exception, value, trace)) | |
| flag = True | |
| thread.additionalInfo.message = 'VariableDoesNotExist' | |
| suspend_frame.f_back = frame | |
| frame = suspend_frame | |
| except : | |
| flag = False | |
| return flag, frame | |
| def handle_exception(self, frame, event, arg): | |
| try: | |
| # print 'handle_exception', frame.f_lineno, frame.f_code.co_name | |
| # We have 3 things in arg: exception type, description, traceback object | |
| trace_obj = arg[2] | |
| mainDebugger = self._args[0] | |
| if not hasattr(trace_obj, 'tb_next'): | |
| return #Not always there on Jython... | |
| initial_trace_obj = trace_obj | |
| if trace_obj.tb_next is None and trace_obj.tb_frame is frame: | |
| #I.e.: tb_next should be only None in the context it was thrown (trace_obj.tb_frame is frame is just a double check). | |
| if mainDebugger.break_on_exceptions_thrown_in_same_context: | |
| #Option: Don't break if an exception is caught in the same function from which it is thrown | |
| return | |
| else: | |
| #Get the trace_obj from where the exception was raised... | |
| while trace_obj.tb_next is not None: | |
| trace_obj = trace_obj.tb_next | |
| if mainDebugger.ignore_exceptions_thrown_in_lines_with_ignore_exception: | |
| for check_trace_obj in (initial_trace_obj, trace_obj): | |
| filename = GetFilenameAndBase(check_trace_obj.tb_frame)[0] | |
| filename_to_lines_where_exceptions_are_ignored = self.filename_to_lines_where_exceptions_are_ignored | |
| lines_ignored = filename_to_lines_where_exceptions_are_ignored.get(filename) | |
| if lines_ignored is None: | |
| lines_ignored = filename_to_lines_where_exceptions_are_ignored[filename] = {} | |
| try: | |
| curr_stat = os.stat(filename) | |
| curr_stat = (curr_stat.st_size, curr_stat.st_mtime) | |
| except: | |
| curr_stat = None | |
| last_stat = self.filename_to_stat_info.get(filename) | |
| if last_stat != curr_stat: | |
| self.filename_to_stat_info[filename] = curr_stat | |
| lines_ignored.clear() | |
| try: | |
| linecache.checkcache(filename) | |
| except: | |
| #Jython 2.1 | |
| linecache.checkcache() | |
| from_user_input = mainDebugger.filename_to_lines_where_exceptions_are_ignored.get(filename) | |
| if from_user_input: | |
| merged = {} | |
| merged.update(lines_ignored) | |
| #Override what we have with the related entries that the user entered | |
| merged.update(from_user_input) | |
| else: | |
| merged = lines_ignored | |
| exc_lineno = check_trace_obj.tb_lineno | |
| # print ('lines ignored', lines_ignored) | |
| # print ('user input', from_user_input) | |
| # print ('merged', merged, 'curr', exc_lineno) | |
| if not DictContains(merged, exc_lineno): #Note: check on merged but update lines_ignored. | |
| try: | |
| line = linecache.getline(filename, exc_lineno, check_trace_obj.tb_frame.f_globals) | |
| except: | |
| #Jython 2.1 | |
| line = linecache.getline(filename, exc_lineno) | |
| if IGNORE_EXCEPTION_TAG.match(line) is not None: | |
| lines_ignored[exc_lineno] = 1 | |
| return | |
| else: | |
| #Put in the cache saying not to ignore | |
| lines_ignored[exc_lineno] = 0 | |
| else: | |
| #Ok, dict has it already cached, so, let's check it... | |
| if merged.get(exc_lineno, 0): | |
| return | |
| thread = self._args[3] | |
| try: | |
| frame_id_to_frame = {} | |
| frame_id_to_frame[id(frame)] = frame | |
| f = trace_obj.tb_frame | |
| while f is not None: | |
| frame_id_to_frame[id(f)] = f | |
| f = f.f_back | |
| f = None | |
| thread_id = GetThreadId(thread) | |
| pydevd_vars.addAdditionalFrameById(thread_id, frame_id_to_frame) | |
| try: | |
| mainDebugger.sendCaughtExceptionStack(thread, arg, id(frame)) | |
| self.setSuspend(thread, CMD_STEP_CAUGHT_EXCEPTION) | |
| self.doWaitSuspend(thread, frame, event, arg) | |
| mainDebugger.sendCaughtExceptionStackProceeded(thread) | |
| finally: | |
| pydevd_vars.removeAdditionalFrameById(thread_id) | |
| except: | |
| traceback.print_exc() | |
| mainDebugger.SetTraceForFrameAndParents(frame) | |
| finally: | |
| #Clear some local variables... | |
| trace_obj = None | |
| initial_trace_obj = None | |
| check_trace_obj = None | |
| f = None | |
| frame_id_to_frame = None | |
| mainDebugger = None | |
| thread = None | |
| def trace_dispatch(self, frame, event, arg): | |
| main_debugger, filename, info, thread = self._args | |
| try: | |
| info.is_tracing = True | |
| if main_debugger._finishDebuggingSession: | |
| return None | |
| if getattr(thread, 'pydev_do_not_trace', None): | |
| return None | |
| if event == 'call' and main_debugger.signature_factory: | |
| sendSignatureCallTrace(main_debugger, frame, filename) | |
| is_exception_event = event == 'exception' | |
| has_exception_breakpoints = main_debugger.break_on_caught_exceptions or main_debugger.django_exception_break | |
| if is_exception_event: | |
| if has_exception_breakpoints: | |
| flag, frame = self.should_stop_on_exception(frame, event, arg) | |
| if flag: | |
| self.handle_exception(frame, event, arg) | |
| return self.trace_dispatch | |
| elif event not in ('line', 'call', 'return'): | |
| #I believe this can only happen in jython on some frontiers on jython and java code, which we don't want to trace. | |
| return None | |
| stop_frame = info.pydev_step_stop | |
| step_cmd = info.pydev_step_cmd | |
| if is_exception_event: | |
| breakpoints_for_file = None | |
| else: | |
| # If we are in single step mode and something causes us to exit the current frame, we need to make sure we break | |
| # eventually. Force the step mode to step into and the step stop frame to None. | |
| # I.e.: F6 in the end of a function should stop in the next possible position (instead of forcing the user | |
| # to make a step in or step over at that location). | |
| # Note: this is especially troublesome when we're skipping code with the | |
| # @DontTrace comment. | |
| if stop_frame is frame and event in ('return', 'exception') and step_cmd in (CMD_STEP_RETURN, CMD_STEP_OVER): | |
| info.pydev_step_cmd = CMD_STEP_INTO | |
| info.pydev_step_stop = None | |
| breakpoints_for_file = main_debugger.breakpoints.get(filename) | |
| can_skip = False | |
| if info.pydev_state == STATE_RUN: | |
| #we can skip if: | |
| #- we have no stop marked | |
| #- we should make a step return/step over and we're not in the current frame | |
| can_skip = (step_cmd is None and stop_frame is None)\ | |
| or (step_cmd in (CMD_STEP_RETURN, CMD_STEP_OVER) and stop_frame is not frame) | |
| check_stop_on_django_render_call = main_debugger.django_breakpoints and self._is_django_render_call(frame) | |
| if check_stop_on_django_render_call: | |
| can_skip = False | |
| # Let's check to see if we are in a function that has a breakpoint. If we don't have a breakpoint, | |
| # we will return nothing for the next trace | |
| #also, after we hit a breakpoint and go to some other debugging state, we have to force the set trace anyway, | |
| #so, that's why the additional checks are there. | |
| if not breakpoints_for_file: | |
| if can_skip: | |
| if has_exception_breakpoints: | |
| return self.trace_exception | |
| else: | |
| return None | |
| else: | |
| #checks the breakpoint to see if there is a context match in some function | |
| curr_func_name = frame.f_code.co_name | |
| #global context is set with an empty name | |
| if curr_func_name in ('?', '<module>'): | |
| curr_func_name = '' | |
| for breakpoint in DictIterValues(breakpoints_for_file): #jython does not support itervalues() | |
| #will match either global or some function | |
| if breakpoint.func_name in ('None', curr_func_name): | |
| break | |
| else: # if we had some break, it won't get here (so, that's a context that we want to skip) | |
| if can_skip: | |
| if has_exception_breakpoints: | |
| return self.trace_exception | |
| else: | |
| return None | |
| #We may have hit a breakpoint or we are already in step mode. Either way, let's check what we should do in this frame | |
| #print 'NOT skipped', frame.f_lineno, frame.f_code.co_name, event | |
| try: | |
| line = frame.f_lineno | |
| flag = False | |
| if event == 'call' and info.pydev_state != STATE_SUSPEND and check_stop_on_django_render_call: | |
| flag, frame = self.should_stop_on_django_breakpoint(frame, event, arg) | |
| #return is not taken into account for breakpoint hit because we'd have a double-hit in this case | |
| #(one for the line and the other for the return). | |
| if not flag and event != 'return' and info.pydev_state != STATE_SUSPEND and breakpoints_for_file is not None\ | |
| and DictContains(breakpoints_for_file, line): | |
| #ok, hit breakpoint, now, we have to discover if it is a conditional breakpoint | |
| # lets do the conditional stuff here | |
| breakpoint = breakpoints_for_file[line] | |
| stop = True | |
| if step_cmd == CMD_STEP_OVER and stop_frame is frame and event in ('line', 'return'): | |
| stop = False #we don't stop on breakpoint if we have to stop by step-over (it will be processed later) | |
| else: | |
| condition = breakpoint.condition | |
| if condition is not None: | |
| try: | |
| val = eval(condition, frame.f_globals, frame.f_locals) | |
| if not val: | |
| return self.trace_dispatch | |
| except: | |
| if type(condition) != type(''): | |
| if hasattr(condition, 'encode'): | |
| condition = condition.encode('utf-8') | |
| msg = 'Error while evaluating expression: %s\n' % (condition,) | |
| sys.stderr.write(msg) | |
| traceback.print_exc() | |
| if not main_debugger.suspend_on_breakpoint_exception: | |
| return self.trace_dispatch | |
| else: | |
| stop = True | |
| try: | |
| additional_info = None | |
| try: | |
| additional_info = thread.additionalInfo | |
| except AttributeError: | |
| pass #that's ok, no info currently set | |
| if additional_info is not None: | |
| # add exception_type and stacktrace into thread additional info | |
| etype, value, tb = sys.exc_info() | |
| try: | |
| error = ''.join(traceback.format_exception_only(etype, value)) | |
| stack = traceback.extract_stack(f=tb.tb_frame.f_back) | |
| # On self.setSuspend(thread, CMD_SET_BREAK) this info will be | |
| # sent to the client. | |
| additional_info.conditional_breakpoint_exception = \ | |
| ('Condition:\n' + condition + '\n\nError:\n' + error, stack) | |
| finally: | |
| etype, value, tb = None, None, None | |
| except: | |
| traceback.print_exc() | |
| if breakpoint.expression is not None: | |
| try: | |
| try: | |
| val = eval(breakpoint.expression, frame.f_globals, frame.f_locals) | |
| except: | |
| val = sys.exc_info()[1] | |
| finally: | |
| if val is not None: | |
| thread.additionalInfo.message = val | |
| if stop: | |
| self.setSuspend(thread, CMD_SET_BREAK) | |
| # if thread has a suspend flag, we suspend with a busy wait | |
| if info.pydev_state == STATE_SUSPEND: | |
| self.doWaitSuspend(thread, frame, event, arg) | |
| return self.trace_dispatch | |
| except: | |
| traceback.print_exc() | |
| raise | |
| #step handling. We stop when we hit the right frame | |
| try: | |
| django_stop = False | |
| should_skip = False | |
| if pydevd_dont_trace.should_trace_hook is not None: | |
| if not hasattr(self, 'should_skip'): | |
| # I.e.: cache the result on self.should_skip (no need to evaluate the same frame multiple times). | |
| # Note that on a code reload, we won't re-evaluate this because in practice, the frame.f_code | |
| # Which will be handled by this frame is read-only, so, we can cache it safely. | |
| should_skip = self.should_skip = not pydevd_dont_trace.should_trace_hook(frame, filename) | |
| else: | |
| should_skip = self.should_skip | |
| if should_skip: | |
| stop = False | |
| elif step_cmd == CMD_STEP_INTO: | |
| stop = event in ('line', 'return') | |
| if is_django_suspended(thread): | |
| #django_stop = event == 'call' and is_django_render_call(frame) | |
| stop = stop and is_django_resolve_call(frame.f_back) and not is_django_context_get_call(frame) | |
| if stop: | |
| info.pydev_django_resolve_frame = 1 #we remember that we've go into python code from django rendering frame | |
| elif step_cmd == CMD_STEP_OVER: | |
| if is_django_suspended(thread): | |
| django_stop = event == 'call' and self._is_django_render_call(frame) | |
| stop = False | |
| else: | |
| if event == 'return' and info.pydev_django_resolve_frame is not None and is_django_resolve_call(frame.f_back): | |
| #we return to Django suspend mode and should not stop before django rendering frame | |
| stop_frame = info.pydev_step_stop = info.pydev_django_resolve_frame | |
| info.pydev_django_resolve_frame = None | |
| thread.additionalInfo.suspend_type = DJANGO_SUSPEND | |
| stop = stop_frame is frame and event in ('line', 'return') | |
| elif step_cmd == CMD_SMART_STEP_INTO: | |
| stop = False | |
| if info.pydev_smart_step_stop is frame: | |
| info.pydev_func_name = None | |
| info.pydev_smart_step_stop = None | |
| if event == 'line' or event == 'exception': | |
| curr_func_name = frame.f_code.co_name | |
| #global context is set with an empty name | |
| if curr_func_name in ('?', '<module>') or curr_func_name is None: | |
| curr_func_name = '' | |
| if curr_func_name == info.pydev_func_name: | |
| stop = True | |
| elif step_cmd == CMD_STEP_RETURN: | |
| stop = event == 'return' and stop_frame is frame | |
| elif step_cmd == CMD_RUN_TO_LINE or step_cmd == CMD_SET_NEXT_STATEMENT: | |
| stop = False | |
| if event == 'line' or event == 'exception': | |
| #Yes, we can only act on line events (weird hum?) | |
| #Note: This code is duplicated at pydevd.py | |
| #Acting on exception events after debugger breaks with exception | |
| curr_func_name = frame.f_code.co_name | |
| #global context is set with an empty name | |
| if curr_func_name in ('?', '<module>'): | |
| curr_func_name = '' | |
| if curr_func_name == info.pydev_func_name: | |
| line = info.pydev_next_line | |
| if frame.f_lineno == line: | |
| stop = True | |
| else: | |
| if frame.f_trace is None: | |
| frame.f_trace = self.trace_dispatch | |
| frame.f_lineno = line | |
| frame.f_trace = None | |
| stop = True | |
| else: | |
| stop = False | |
| if django_stop: | |
| frame = suspend_django(self, main_debugger, thread, frame) | |
| if frame: | |
| self.doWaitSuspend(thread, frame, event, arg) | |
| elif stop: | |
| #event is always == line or return at this point | |
| if event == 'line': | |
| self.setSuspend(thread, step_cmd) | |
| self.doWaitSuspend(thread, frame, event, arg) | |
| else: #return event | |
| back = frame.f_back | |
| if back is not None: | |
| #When we get to the pydevd run function, the debugging has actually finished for the main thread | |
| #(note that it can still go on for other threads, but for this one, we just make it finish) | |
| #So, just setting it to None should be OK | |
| base = basename(back.f_code.co_filename) | |
| if base == 'pydevd.py' and back.f_code.co_name == 'run': | |
| back = None | |
| elif base == 'pydevd_traceproperty.py': | |
| # We dont want to trace the return event of pydevd_traceproperty (custom property for debugging) | |
| #if we're in a return, we want it to appear to the user in the previous frame! | |
| return None | |
| if back is not None: | |
| #if we're in a return, we want it to appear to the user in the previous frame! | |
| self.setSuspend(thread, step_cmd) | |
| self.doWaitSuspend(thread, back, event, arg) | |
| else: | |
| #in jython we may not have a back frame | |
| info.pydev_step_stop = None | |
| info.pydev_step_cmd = None | |
| info.pydev_state = STATE_RUN | |
| except: | |
| traceback.print_exc() | |
| info.pydev_step_cmd = None | |
| #if we are quitting, let's stop the tracing | |
| retVal = None | |
| if not main_debugger.quitting: | |
| retVal = self.trace_dispatch | |
| return retVal | |
| finally: | |
| info.is_tracing = False | |
| #end trace_dispatch | |
| if USE_PSYCO_OPTIMIZATION: | |
| try: | |
| import psyco | |
| trace_dispatch = psyco.proxy(trace_dispatch) | |
| except ImportError: | |
| if hasattr(sys, 'exc_clear'): #jython does not have it | |
| sys.exc_clear() #don't keep the traceback | |
| pass #ok, psyco not available | |
| def should_stop_on_django_breakpoint(self, frame, event, arg): | |
| mainDebugger = self._args[0] | |
| thread = self._args[3] | |
| flag = False | |
| template_frame_file = get_template_file_name(frame) | |
| #pydev_log.debug("Django is rendering a template: %s\n" % template_frame_file) | |
| django_breakpoints_for_file = mainDebugger.django_breakpoints.get(template_frame_file) | |
| if django_breakpoints_for_file: | |
| #pydev_log.debug("Breakpoints for that file: %s\n" % django_breakpoints_for_file) | |
| template_frame_line = get_template_line(frame, template_frame_file) | |
| #pydev_log.debug("Tracing template line: %d\n" % template_frame_line) | |
| if DictContains(django_breakpoints_for_file, template_frame_line): | |
| django_breakpoint = django_breakpoints_for_file[template_frame_line] | |
| if django_breakpoint.is_triggered(template_frame_file, template_frame_line): | |
| #pydev_log.debug("Breakpoint is triggered.\n") | |
| flag = True | |
| new_frame = DjangoTemplateFrame( | |
| frame, | |
| template_frame_file=template_frame_file, | |
| template_frame_line=template_frame_line, | |
| ) | |
| if django_breakpoint.condition is not None: | |
| try: | |
| val = eval(django_breakpoint.condition, new_frame.f_globals, new_frame.f_locals) | |
| if not val: | |
| flag = False | |
| pydev_log.debug("Condition '%s' is evaluated to %s. Not suspending.\n" % (django_breakpoint.condition, val)) | |
| except: | |
| pydev_log.info( | |
| 'Error while evaluating condition \'%s\': %s\n' % (django_breakpoint.condition, sys.exc_info()[1])) | |
| if django_breakpoint.expression is not None: | |
| try: | |
| try: | |
| val = eval(django_breakpoint.expression, new_frame.f_globals, new_frame.f_locals) | |
| except: | |
| val = sys.exc_info()[1] | |
| finally: | |
| if val is not None: | |
| thread.additionalInfo.message = val | |
| if flag: | |
| frame = suspend_django(self, mainDebugger, thread, frame) | |
| return flag, frame | |
| def add_exception_to_frame(frame, exception_info): | |
| frame.f_locals['__exception__'] = exception_info |