tabwidth = TK_TABWIDTH_DEFAULT
# If context_use_ps1 is true, parsing searches back for a ps1 line;
- # else searches back for closest preceding def or class.
+ # else searches for a popular (if, def, ...) Python stmt.
context_use_ps1 = 0
- # When searching backwards for the closest preceding def or class,
+ # When searching backwards for a reliable place to begin parsing,
# first start num_context_lines[0] lines back, then
# num_context_lines[1] lines back if that didn't work, and so on.
# The last value should be huge (larger than the # of lines in a
# conceivable file).
# Making the initial values larger slows things down more often.
- # OTOH, if you happen to find a line that looks like a def or class
- # in a multiline string, the parsing is utterly hosed. Can't think
- # of a way to stop that without always reparsing from the start
- # of the file. doctest.py is a killer example of this (IDLE is
- # useless for editing that!).
num_context_lines = 50, 500, 5000000
def __init__(self, editwin):
text.delete("insert")
# start new line
text.insert("insert", '\n')
+
# adjust indentation for continuations and block open/close
+ # first need to find the last stmt
lno = index2line(text.index('insert'))
y = PyParse.Parser(self.indentwidth, self.tabwidth)
for context in self.num_context_lines:
startat = max(lno - context, 1)
- rawtext = text.get(`startat` + ".0", "insert")
+ startatindex = `startat` + ".0"
+ rawtext = text.get(startatindex, "insert")
y.set_str(rawtext)
- bod = y.find_last_def_or_class(self.context_use_ps1)
+ bod = y.find_good_parse_start(
+ self.context_use_ps1,
+ self._build_char_in_string_func(startatindex))
if bod is not None or startat == 1:
break
y.set_lo(bod or 0)
auto_indent = newline_and_indent_event
+ # Our editwin provides a is_char_in_string function that works with
+ # a Tk text index, but PyParse only knows about offsets into a string.
+ # This builds a function for PyParse that accepts an offset.
+
+ def _build_char_in_string_func(self, startindex):
+ def inner(offset, _startindex=startindex,
+ _icis=self.editwin.is_char_in_string):
+ return _icis(_startindex + "+%dc" % offset)
+ return inner
+
def indent_region_event(self, event):
head, tail, chars, lines = self.get_region()
for pos in range(len(lines)):
self.vars[name] = var = vartype(self.text)
return var
+ # Tk implementations of "virtual text methods" -- each platform
+ # reusing IDLE's support code needs to define these for its GUI's
+ # flavor of widget.
+
+ # Is character at text_index in a Python string? Return 0 for
+ # "guaranteed no", true for anything else. This info is expensive to
+ # compute ab initio, but is probably already known by the platform's
+ # colorizer.
+
+ def is_char_in_string(self, text_index):
+ if self.color:
+ # return true iff colorizer hasn't (re)gotten this far yet, or
+ # the character is tagged as being in a string
+ return self.text.tag_prevrange("TODO", text_index) or \
+ "STRING" in self.text.tag_names(text_index)
+ else:
+ # the colorizer is missing: assume the worst
+ return 1
+
def prepstr(s):
# Helper to extract the underscore from a string,
# e.g. prepstr("Co_py") returns (2, "Copy").
def dump(*stuff):
sys.__stdout__.write(string.join(map(str, stuff), " ") + "\n")
-# Find a def or class stmt.
+# Find what looks like the start of a popular stmt.
-_defclassre = re.compile(r"""
+_synchre = re.compile(r"""
^
[ \t]*
- (?:
- def [ \t]+ [a-zA-Z_]\w* [ \t]* \(
- | class [ \t]+ [a-zA-Z_]\w* [ \t]*
- (?: \( .* \) )?
- [ \t]* :
- )
+ (?: if | else | elif | while | def | class )
+ \b
""", re.VERBOSE | re.MULTILINE).search
# Match blank line or non-indenting comment line.
self.str = str
self.study_level = 0
- # Return index of start of last (probable!) def or class stmt, or
- # None if none found. It's only probable because we can't know
- # whether we're in a string without reparsing from the start of
- # the file -- and that's too slow in large files for routine use.
+ # Return index of a good place to begin parsing, as close to the
+ # end of the string as possible. This will be the start of some
+ # popular stmt like "if" or "def". Return None if none found.
+ #
+ # This will be reliable iff given a reliable is_char_in_string
+ # function, meaning that when it says "no", it's absolutely guaranteed
+ # that the char is not in a string.
#
# Ack, hack: in the shell window this kills us, because there's
# no way to tell the differences between output, >>> etc and
# look like it's in an unclosed paren!:
# Python 1.5.2 (#0, Apr 13 1999, ...
- def find_last_def_or_class(self, use_ps1, _defclassre=_defclassre):
+ def find_good_parse_start(self, use_ps1,
+ is_char_in_string=None,
+ _synchre=_synchre):
str, pos = self.str, None
if use_ps1:
# hack for shell window
if i >= 0:
pos = i + len(ps1)
self.str = str[:pos-1] + '\n' + str[pos:]
- else:
+ elif is_char_in_string:
+ # otherwise we can't be sure, so leave pos at None
i = 0
while 1:
- m = _defclassre(str, i)
+ m = _synchre(str, i)
if m:
- pos, i = m.span()
+ s, i = m.span()
+ if not is_char_in_string(s):
+ pos = s
else:
break
return pos
# Throw away the start of the string. Intended to be called with
- # find_last_def_or_class's result.
+ # find_good_parse_start's result.
def set_lo(self, lo):
assert lo == 0 or self.str[lo-1] == '\n'
def is_block_closer(self):
self._study2()
return _closere(self.str, self.stmt_start) is not None
+
+ # index of last open bracket ({[, or None if none
+ lastopenbracketpos = None
+
+ def get_last_open_bracket_pos(self):
+ self._study2()
+ return self.lastopenbracketpos
projects / python / commitdiff