1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
|
;;; python-components-pdb.el --- pdb help functions -*- lexical-binding: t; -*-
;; Copyright (C) 2015-2016 Andreas Röhler
;; Author: Andreas Röhler <andreas.roehler@online.de>
;; Keywords: languages, processes
;; This program is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.
;; This program is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;; Commentary:
;;
;;; Code:
;; pdbtrack constants
(defconst py-pdbtrack-stack-entry-regexp
(concat ".*\\("py-shell-input-prompt-1-regexp">\\|>\\) *\\(.*\\)(\\([0-9]+\\))\\([?a-zA-Z0-9_<>()]+\\)()")
"Regular expression pdbtrack uses to find a stack trace entry.")
(defconst py-pdbtrack-marker-regexp-file-group 2
"Group position in gud-pydb-marker-regexp that matches the file name.")
(defconst py-pdbtrack-marker-regexp-line-group 3
"Group position in gud-pydb-marker-regexp that matches the line number.")
(defconst py-pdbtrack-marker-regexp-funcname-group 4
"Group position in gud-pydb-marker-regexp that matches the function name.")
(defconst py-pdbtrack-track-range 10000
"Max number of characters from end of buffer to search for stack entry.")
(defvar py-pdbtrack-is-tracking-p nil)
(defun py--pdbtrack-overlay-arrow (activation)
"Activate or de arrow at beginning-of-line in current buffer."
;; This was derived/simplified from edebug-overlay-arrow
(cond (activation
(setq overlay-arrow-position (make-marker))
(setq overlay-arrow-string "=>")
(set-marker overlay-arrow-position (line-beginning-position) (current-buffer))
(setq py-pdbtrack-is-tracking-p t))
(overlay-arrow-position
(setq overlay-arrow-position nil)
(setq py-pdbtrack-is-tracking-p nil))))
(defun py--pdbtrack-track-stack-file (text)
"Show the file indicated by the pdb stack entry line, in a separate window.
Activity is disabled if the buffer-local variable
`py-pdbtrack-do-tracking-p' is nil.
We depend on the pdb input prompt matching `py-pdbtrack-input-prompt'
at the beginning of the line.
If the traceback target file path is invalid, we look for the most
recently visited python-mode buffer which either has the name of the
current function \(or class) or which defines the function \(or
class). This is to provide for remote scripts, eg, Zope's 'Script
\(Python)' - put a _copy_ of the script in a buffer named for the
script, and set to python-mode, and pdbtrack will find it.)"
;; Instead of trying to piece things together from partial text
;; (which can be almost useless depending on Emacs version), we
;; monitor to the point where we have the next pdb prompt, and then
;; check all text from comint-last-input-end to process-mark.
;;
;; Also, we're very conservative about clearing the overlay arrow,
;; to minimize residue. This means, for instance, that executing
;; other pdb commands wipe out the highlight. You can always do a
;; 'where' (aka 'w') command to reveal the overlay arrow.
(let* ((origbuf (current-buffer))
(currproc (get-buffer-process origbuf)))
(if (not (and currproc py-pdbtrack-do-tracking-p))
(py--pdbtrack-overlay-arrow nil)
(let* ((procmark (process-mark currproc))
(block (buffer-substring (max comint-last-input-end
(- procmark
py-pdbtrack-track-range))
procmark))
target target_fname target_lineno target_buffer)
(if (not (string-match (concat py-pdbtrack-input-prompt "$") block))
(py--pdbtrack-overlay-arrow nil)
(setq target (py--pdbtrack-get-source-buffer block))
(if (stringp target)
(message "pdbtrack: %s" target)
(setq target_lineno (car target))
(setq target_buffer (cadr target))
(setq target_fname
(py--buffer-filename-remote-maybe target_buffer))
(switch-to-buffer-other-window target_buffer)
(goto-char (point-min))
(forward-line (1- target_lineno))
(message "pdbtrack: line %s, file %s" target_lineno target_fname)
(py--pdbtrack-overlay-arrow t)
(pop-to-buffer origbuf t)))))))
(defun py--pdbtrack-map-filename (filename)
(let
((replacement-val (assoc-default
filename py-pdbtrack-filename-mapping
(lambda (mapkey path)
(string-match
(concat "^" (regexp-quote mapkey))
path)))
))
(if (not (eq replacement-val nil))
(replace-match replacement-val 't 't filename)
filename)))
(defun py--pdbtrack-get-source-buffer (block)
"Return line number and buffer of code indicated by block's traceback text.
We look first to visit the file indicated in the trace.
Failing that, we look for the most recently visited python-mode buffer
with the same name or having the named function.
If we're unable find the source code we return a string describing the
problem as best as we can determine."
(if (and (not (string-match py-pdbtrack-stack-entry-regexp block))
;; pydb integration still to be done
;; (not (string-match py-pydbtrack-stack-entry-regexp block))
)
"Traceback cue not found"
(let* ((filename (match-string
py-pdbtrack-marker-regexp-file-group block))
(lineno (string-to-number (match-string
py-pdbtrack-marker-regexp-line-group
block)))
(funcname (match-string py-pdbtrack-marker-regexp-funcname-group
block))
funcbuffer)
(cond ((file-exists-p filename)
(list lineno (find-file-noselect filename)))
((file-exists-p (py--pdbtrack-map-filename filename))
(list lineno (find-file-noselect (py--pdbtrack-map-filename filename))))
((setq funcbuffer (py--pdbtrack-grub-for-buffer funcname lineno))
(if (string-match "/Script (Python)$" filename)
;; Add in number of lines for leading '##' comments:
(setq lineno
(+ lineno
(save-excursion
(with-current-buffer funcbuffer
(count-lines
(point-min)
(max (point-min)
(string-match "^\\([^#]\\|#[^#]\\|#$\\)"
(buffer-substring (point-min)
(point-max))))))))))
(list lineno funcbuffer))
((= (elt filename 0) ?\<)
(format "(Non-file source: '%s')" filename))
(t (format "Not found: %s(), %s" funcname filename))))))
(defun py--pdbtrack-grub-for-buffer (funcname lineno)
"Find most recent buffer itself named or having function funcname.
We walk the buffer-list history for python-mode buffers that are
named for funcname or define a function funcname."
(let ((buffers (buffer-list))
buf
got)
(while (and buffers (not got))
(setq buf (car buffers)
buffers (cdr buffers))
(if (and (save-excursion
(with-current-buffer buf
(string= major-mode "python-mode")))
(or (string-match funcname (buffer-name buf))
(string-match (concat "^\\s-*\\(def\\|class\\)\\s-+"
funcname "\\s-*(")
(save-excursion
(with-current-buffer buf
(buffer-substring (point-min)
(point-max)))))))
(setq got buf)))
got))
;; pdbtrack functions
(defun py-pdbtrack-toggle-stack-tracking (arg)
"Set variable `py-pdbtrack-do-tracking-p'. "
(interactive "P")
;; (if (not (get-buffer-process (current-buffer)))
;; (error "No process associated with buffer '%s'" (current-buffer)))
;; missing or 0 is toggle, >0 turn on, <0 turn off
(cond ((not arg)
(setq py-pdbtrack-do-tracking-p (not py-pdbtrack-do-tracking-p)))
((zerop (prefix-numeric-value arg))
(setq py-pdbtrack-do-tracking-p nil))
((> (prefix-numeric-value arg) 0)
(setq py-pdbtrack-do-tracking-p t)))
(if py-pdbtrack-do-tracking-p
(progn
(add-hook 'comint-output-filter-functions 'py--pdbtrack-track-stack-file t)
(remove-hook 'comint-output-filter-functions 'python-pdbtrack-track-stack-file t))
(remove-hook 'comint-output-filter-functions 'py--pdbtrack-track-stack-file t)
)
(message "%sabled Python's pdbtrack"
(if py-pdbtrack-do-tracking-p "En" "Dis")))
(defun turn-on-pdbtrack ()
(interactive)
(py-pdbtrack-toggle-stack-tracking 1))
(defun turn-off-pdbtrack ()
(interactive)
(py-pdbtrack-toggle-stack-tracking 0))
(defun py-execute-statement-pdb ()
"Execute statement running pdb. "
(interactive)
(let ((py-python-command-args "-i -m pdb"))
(py-execute-statement)))
(defun py-execute-region-pdb (beg end)
(interactive "r")
(let ((py-python-command-args "-i -m pdb")))
(py-execute-region beg end))
(defun py-pdb-execute-statement ()
(interactive)
(let ((stm (progn (py-statement) (car kill-ring))))
(py-execute-string (concat "import pdb;pdb.run('" stm "')"))))
(defun py-pdb-help ()
"Print generic pdb.help() message "
(interactive)
(py-execute-string "import pdb;pdb.help()"))
(defun py-pdb-break (&optional line file condition)
(interactive)
(py-execute-string (concat "import pdb;pdb.break('" stm "')")))
(defun py--pdb-versioned ()
"Guess existing pdb version from py-shell-name
Return \"pdb[VERSION]\" if executable found, just \"pdb\" otherwise"
(interactive)
(let ((erg (when (string-match "[23]" py-shell-name)
;; versions-part
(substring py-shell-name (string-match "[23]" py-shell-name)))))
(if erg
(cond ((executable-find (concat "pdb" erg))
(concat "pdb" erg))
((and (string-match "\\." erg)
(executable-find (concat "pdb" (substring erg 0 (string-match "\\." erg)))))
(concat "pdb" (substring erg 0 (string-match "\\." erg)))))
"pdb")))
(defun py-pdb (command-line)
"Run pdb on program FILE in buffer `*gud-FILE*'.
The directory containing FILE becomes the initial working directory
and source-file directory for your debugger.
At GNU Linux systems required pdb version should be detected by `py--pdb-version', at Windows configure `py-python-ms-pdb-command'
lp:963253"
(interactive
(progn
(require 'gud)
(list (gud-query-cmdline
(if (or (eq system-type 'ms-dos)(eq system-type 'windows-nt))
(car (read-from-string py-python-ms-pdb-command))
;; sys.version_info[0]
;; (car (read-from-string (py--pdb-version)))
'pdb)
(py--buffer-filename-remote-maybe)))))
(pdb command-line))
(defun py--pdb-current-executable ()
"When py-pdb-executable is set, return it.
Otherwise return resuslt from `executable-find' "
(or py-pdb-executable
(executable-find "pdb")))
(defun py-update-gud-pdb-history ()
"If pdb is called at a Python buffer, put it's file name at the head of `gud-pdb-history'. "
(interactive)
(let* (;; PATH/TO/pdb
(first (cond ((and gud-pdb-history (ignore-errors (car gud-pdb-history)))
(replace-regexp-in-string "^\\([^ ]+\\) +.+$" "\\1" (car gud-pdb-history)))
(py-pdb-executable
py-pdb-executable)
((or (eq system-type 'ms-dos)(eq system-type 'windows-nt))
;; lp:963253
"c:/python27/python\ -i\ c:/python27/Lib/pdb.py")
(t
(py--pdb-current-executable))))
;; file to debug
(second (cond ((not (ignore-errors
(py--buffer-filename-remote-maybe)))
(error "%s" "Buffer must be saved first."))
((py--buffer-filename-remote-maybe))
(t (and gud-pdb-history (stringp (car gud-pdb-history)) (replace-regexp-in-string "^\\([^ ]+\\) +\\(.+\\)$" "\\2" (car gud-pdb-history))))))
(erg (and first second (concat first " " second))))
(when erg
(push erg gud-pdb-history))))
(defadvice pdb (before gud-query-cmdline activate)
"Provide a better default command line when called interactively."
(interactive
(list (gud-query-cmdline py-pdb-path
;; (file-name-nondirectory buffer-file-name)
(file-name-nondirectory (py--buffer-filename-remote-maybe))
))))
(provide 'python-components-pdb)
;;; python-components-pdb.el ends here
|