Commit | Line | Data |
---|---|---|
86530b38 AT |
1 | import _hotshot |
2 | import os.path | |
3 | import parser | |
4 | import symbol | |
5 | import sys | |
6 | ||
7 | from _hotshot import \ | |
8 | WHAT_ENTER, \ | |
9 | WHAT_EXIT, \ | |
10 | WHAT_LINENO, \ | |
11 | WHAT_DEFINE_FILE, \ | |
12 | WHAT_DEFINE_FUNC, \ | |
13 | WHAT_ADD_INFO | |
14 | ||
15 | ||
16 | __all__ = ["LogReader", "ENTER", "EXIT", "LINE"] | |
17 | ||
18 | ||
19 | ENTER = WHAT_ENTER | |
20 | EXIT = WHAT_EXIT | |
21 | LINE = WHAT_LINENO | |
22 | ||
23 | ||
24 | class LogReader: | |
25 | def __init__(self, logfn): | |
26 | # fileno -> filename | |
27 | self._filemap = {} | |
28 | # (fileno, lineno) -> filename, funcname | |
29 | self._funcmap = {} | |
30 | ||
31 | self._reader = _hotshot.logreader(logfn) | |
32 | self._nextitem = self._reader.next | |
33 | self._info = self._reader.info | |
34 | if self._info.has_key('current-directory'): | |
35 | self.cwd = self._info['current-directory'] | |
36 | else: | |
37 | self.cwd = None | |
38 | ||
39 | # This mirrors the call stack of the profiled code as the log | |
40 | # is read back in. It contains tuples of the form: | |
41 | # | |
42 | # (file name, line number of function def, function name) | |
43 | # | |
44 | self._stack = [] | |
45 | self._append = self._stack.append | |
46 | self._pop = self._stack.pop | |
47 | ||
48 | def close(self): | |
49 | self._reader.close() | |
50 | ||
51 | def fileno(self): | |
52 | """Return the file descriptor of the log reader's log file.""" | |
53 | return self._reader.fileno() | |
54 | ||
55 | def addinfo(self, key, value): | |
56 | """This method is called for each additional ADD_INFO record. | |
57 | ||
58 | This can be overridden by applications that want to receive | |
59 | these events. The default implementation does not need to be | |
60 | called by alternate implementations. | |
61 | ||
62 | The initial set of ADD_INFO records do not pass through this | |
63 | mechanism; this is only needed to receive notification when | |
64 | new values are added. Subclasses can inspect self._info after | |
65 | calling LogReader.__init__(). | |
66 | """ | |
67 | pass | |
68 | ||
69 | def get_filename(self, fileno): | |
70 | try: | |
71 | return self._filemap[fileno] | |
72 | except KeyError: | |
73 | raise ValueError, "unknown fileno" | |
74 | ||
75 | def get_filenames(self): | |
76 | return self._filemap.values() | |
77 | ||
78 | def get_fileno(self, filename): | |
79 | filename = os.path.normcase(os.path.normpath(filename)) | |
80 | for fileno, name in self._filemap.items(): | |
81 | if name == filename: | |
82 | return fileno | |
83 | raise ValueError, "unknown filename" | |
84 | ||
85 | def get_funcname(self, fileno, lineno): | |
86 | try: | |
87 | return self._funcmap[(fileno, lineno)] | |
88 | except KeyError: | |
89 | raise ValueError, "unknown function location" | |
90 | ||
91 | # Iteration support: | |
92 | # This adds an optional (& ignored) parameter to next() so that the | |
93 | # same bound method can be used as the __getitem__() method -- this | |
94 | # avoids using an additional method call which kills the performance. | |
95 | ||
96 | def next(self, index=0): | |
97 | while 1: | |
98 | # This call may raise StopIteration: | |
99 | what, tdelta, fileno, lineno = self._nextitem() | |
100 | ||
101 | # handle the most common cases first | |
102 | ||
103 | if what == WHAT_ENTER: | |
104 | filename, funcname = self._decode_location(fileno, lineno) | |
105 | t = (filename, lineno, funcname) | |
106 | self._append(t) | |
107 | return what, t, tdelta | |
108 | ||
109 | if what == WHAT_EXIT: | |
110 | return what, self._pop(), tdelta | |
111 | ||
112 | if what == WHAT_LINENO: | |
113 | filename, firstlineno, funcname = self._stack[-1] | |
114 | return what, (filename, lineno, funcname), tdelta | |
115 | ||
116 | if what == WHAT_DEFINE_FILE: | |
117 | filename = os.path.normcase(os.path.normpath(tdelta)) | |
118 | self._filemap[fileno] = filename | |
119 | elif what == WHAT_DEFINE_FUNC: | |
120 | filename = self._filemap[fileno] | |
121 | self._funcmap[(fileno, lineno)] = (filename, tdelta) | |
122 | elif what == WHAT_ADD_INFO: | |
123 | # value already loaded into self.info; call the | |
124 | # overridable addinfo() handler so higher-level code | |
125 | # can pick up the new value | |
126 | if tdelta == 'current-directory': | |
127 | self.cwd = lineno | |
128 | self.addinfo(tdelta, lineno) | |
129 | else: | |
130 | raise ValueError, "unknown event type" | |
131 | ||
132 | def __iter__(self): | |
133 | return self | |
134 | ||
135 | # | |
136 | # helpers | |
137 | # | |
138 | ||
139 | def _decode_location(self, fileno, lineno): | |
140 | try: | |
141 | return self._funcmap[(fileno, lineno)] | |
142 | except KeyError: | |
143 | # | |
144 | # This should only be needed when the log file does not | |
145 | # contain all the DEFINE_FUNC records needed to allow the | |
146 | # function name to be retrieved from the log file. | |
147 | # | |
148 | if self._loadfile(fileno): | |
149 | filename = funcname = None | |
150 | try: | |
151 | filename, funcname = self._funcmap[(fileno, lineno)] | |
152 | except KeyError: | |
153 | filename = self._filemap.get(fileno) | |
154 | funcname = None | |
155 | self._funcmap[(fileno, lineno)] = (filename, funcname) | |
156 | return filename, funcname | |
157 | ||
158 | def _loadfile(self, fileno): | |
159 | try: | |
160 | filename = self._filemap[fileno] | |
161 | except KeyError: | |
162 | print "Could not identify fileId", fileno | |
163 | return 1 | |
164 | if filename is None: | |
165 | return 1 | |
166 | absname = os.path.normcase(os.path.join(self.cwd, filename)) | |
167 | ||
168 | try: | |
169 | fp = open(absname) | |
170 | except IOError: | |
171 | return | |
172 | st = parser.suite(fp.read()) | |
173 | fp.close() | |
174 | ||
175 | # Scan the tree looking for def and lambda nodes, filling in | |
176 | # self._funcmap with all the available information. | |
177 | funcdef = symbol.funcdef | |
178 | lambdef = symbol.lambdef | |
179 | ||
180 | stack = [st.totuple(1)] | |
181 | ||
182 | while stack: | |
183 | tree = stack.pop() | |
184 | try: | |
185 | sym = tree[0] | |
186 | except (IndexError, TypeError): | |
187 | continue | |
188 | if sym == funcdef: | |
189 | self._funcmap[(fileno, tree[2][2])] = filename, tree[2][1] | |
190 | elif sym == lambdef: | |
191 | self._funcmap[(fileno, tree[1][2])] = filename, "<lambda>" | |
192 | stack.extend(list(tree[1:])) |