|
1 import re |
|
2 from Tkinter import * |
|
3 import tkMessageBox |
|
4 |
|
5 def get(root): |
|
6 if not hasattr(root, "_searchengine"): |
|
7 root._searchengine = SearchEngine(root) |
|
8 # XXX This will never garbage-collect -- who cares |
|
9 return root._searchengine |
|
10 |
|
11 class SearchEngine: |
|
12 |
|
13 def __init__(self, root): |
|
14 self.root = root |
|
15 # State shared by search, replace, and grep; |
|
16 # the search dialogs bind these to UI elements. |
|
17 self.patvar = StringVar(root) # search pattern |
|
18 self.revar = BooleanVar(root) # regular expression? |
|
19 self.casevar = BooleanVar(root) # match case? |
|
20 self.wordvar = BooleanVar(root) # match whole word? |
|
21 self.wrapvar = BooleanVar(root) # wrap around buffer? |
|
22 self.wrapvar.set(1) # (on by default) |
|
23 self.backvar = BooleanVar(root) # search backwards? |
|
24 |
|
25 # Access methods |
|
26 |
|
27 def getpat(self): |
|
28 return self.patvar.get() |
|
29 |
|
30 def setpat(self, pat): |
|
31 self.patvar.set(pat) |
|
32 |
|
33 def isre(self): |
|
34 return self.revar.get() |
|
35 |
|
36 def iscase(self): |
|
37 return self.casevar.get() |
|
38 |
|
39 def isword(self): |
|
40 return self.wordvar.get() |
|
41 |
|
42 def iswrap(self): |
|
43 return self.wrapvar.get() |
|
44 |
|
45 def isback(self): |
|
46 return self.backvar.get() |
|
47 |
|
48 # Higher level access methods |
|
49 |
|
50 def getcookedpat(self): |
|
51 pat = self.getpat() |
|
52 if not self.isre(): |
|
53 pat = re.escape(pat) |
|
54 if self.isword(): |
|
55 pat = r"\b%s\b" % pat |
|
56 return pat |
|
57 |
|
58 def getprog(self): |
|
59 pat = self.getpat() |
|
60 if not pat: |
|
61 self.report_error(pat, "Empty regular expression") |
|
62 return None |
|
63 pat = self.getcookedpat() |
|
64 flags = 0 |
|
65 if not self.iscase(): |
|
66 flags = flags | re.IGNORECASE |
|
67 try: |
|
68 prog = re.compile(pat, flags) |
|
69 except re.error, what: |
|
70 try: |
|
71 msg, col = what |
|
72 except: |
|
73 msg = str(what) |
|
74 col = -1 |
|
75 self.report_error(pat, msg, col) |
|
76 return None |
|
77 return prog |
|
78 |
|
79 def report_error(self, pat, msg, col=-1): |
|
80 # Derived class could overrid this with something fancier |
|
81 msg = "Error: " + str(msg) |
|
82 if pat: |
|
83 msg = msg + "\np\Pattern: " + str(pat) |
|
84 if col >= 0: |
|
85 msg = msg + "\nOffset: " + str(col) |
|
86 tkMessageBox.showerror("Regular expression error", |
|
87 msg, master=self.root) |
|
88 |
|
89 def setcookedpat(self, pat): |
|
90 if self.isre(): |
|
91 pat = re.escape(pat) |
|
92 self.setpat(pat) |
|
93 |
|
94 def search_text(self, text, prog=None, ok=0): |
|
95 """Search a text widget for the pattern. |
|
96 |
|
97 If prog is given, it should be the precompiled pattern. |
|
98 Return a tuple (lineno, matchobj); None if not found. |
|
99 |
|
100 This obeys the wrap and direction (back) settings. |
|
101 |
|
102 The search starts at the selection (if there is one) or |
|
103 at the insert mark (otherwise). If the search is forward, |
|
104 it starts at the right of the selection; for a backward |
|
105 search, it starts at the left end. An empty match exactly |
|
106 at either end of the selection (or at the insert mark if |
|
107 there is no selection) is ignored unless the ok flag is true |
|
108 -- this is done to guarantee progress. |
|
109 |
|
110 If the search is allowed to wrap around, it will return the |
|
111 original selection if (and only if) it is the only match. |
|
112 |
|
113 """ |
|
114 if not prog: |
|
115 prog = self.getprog() |
|
116 if not prog: |
|
117 return None # Compilation failed -- stop |
|
118 wrap = self.wrapvar.get() |
|
119 first, last = get_selection(text) |
|
120 if self.isback(): |
|
121 if ok: |
|
122 start = last |
|
123 else: |
|
124 start = first |
|
125 line, col = get_line_col(start) |
|
126 res = self.search_backward(text, prog, line, col, wrap, ok) |
|
127 else: |
|
128 if ok: |
|
129 start = first |
|
130 else: |
|
131 start = last |
|
132 line, col = get_line_col(start) |
|
133 res = self.search_forward(text, prog, line, col, wrap, ok) |
|
134 return res |
|
135 |
|
136 def search_forward(self, text, prog, line, col, wrap, ok=0): |
|
137 wrapped = 0 |
|
138 startline = line |
|
139 chars = text.get("%d.0" % line, "%d.0" % (line+1)) |
|
140 while chars: |
|
141 m = prog.search(chars[:-1], col) |
|
142 if m: |
|
143 if ok or m.end() > col: |
|
144 return line, m |
|
145 line = line + 1 |
|
146 if wrapped and line > startline: |
|
147 break |
|
148 col = 0 |
|
149 ok = 1 |
|
150 chars = text.get("%d.0" % line, "%d.0" % (line+1)) |
|
151 if not chars and wrap: |
|
152 wrapped = 1 |
|
153 wrap = 0 |
|
154 line = 1 |
|
155 chars = text.get("1.0", "2.0") |
|
156 return None |
|
157 |
|
158 def search_backward(self, text, prog, line, col, wrap, ok=0): |
|
159 wrapped = 0 |
|
160 startline = line |
|
161 chars = text.get("%d.0" % line, "%d.0" % (line+1)) |
|
162 while 1: |
|
163 m = search_reverse(prog, chars[:-1], col) |
|
164 if m: |
|
165 if ok or m.start() < col: |
|
166 return line, m |
|
167 line = line - 1 |
|
168 if wrapped and line < startline: |
|
169 break |
|
170 ok = 1 |
|
171 if line <= 0: |
|
172 if not wrap: |
|
173 break |
|
174 wrapped = 1 |
|
175 wrap = 0 |
|
176 pos = text.index("end-1c") |
|
177 line, col = map(int, pos.split(".")) |
|
178 chars = text.get("%d.0" % line, "%d.0" % (line+1)) |
|
179 col = len(chars) - 1 |
|
180 return None |
|
181 |
|
182 # Helper to search backwards in a string. |
|
183 # (Optimized for the case where the pattern isn't found.) |
|
184 |
|
185 def search_reverse(prog, chars, col): |
|
186 m = prog.search(chars) |
|
187 if not m: |
|
188 return None |
|
189 found = None |
|
190 i, j = m.span() |
|
191 while i < col and j <= col: |
|
192 found = m |
|
193 if i == j: |
|
194 j = j+1 |
|
195 m = prog.search(chars, j) |
|
196 if not m: |
|
197 break |
|
198 i, j = m.span() |
|
199 return found |
|
200 |
|
201 # Helper to get selection end points, defaulting to insert mark. |
|
202 # Return a tuple of indices ("line.col" strings). |
|
203 |
|
204 def get_selection(text): |
|
205 try: |
|
206 first = text.index("sel.first") |
|
207 last = text.index("sel.last") |
|
208 except TclError: |
|
209 first = last = None |
|
210 if not first: |
|
211 first = text.index("insert") |
|
212 if not last: |
|
213 last = first |
|
214 return first, last |
|
215 |
|
216 # Helper to parse a text index into a (line, col) tuple. |
|
217 |
|
218 def get_line_col(index): |
|
219 line, col = map(int, index.split(".")) # Fails on invalid index |
|
220 return line, col |