Lib/idlelib/SearchEngine.py

   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