FM / idlelib

/usr/lib64/python2.6/idlelib

Name	Size	Mode	Actions
Icons/	-	0755	rm
aboutDialog.py	6825	0644	edit dl rm
aboutDialog.pyc	6965	0644	edit dl rm
aboutDialog.pyo	6965	0644	edit dl rm
AutoComplete.py	9061	0644	edit dl rm
AutoComplete.pyc	8023	0644	edit dl rm
AutoComplete.pyo	8023	0644	edit dl rm
AutoCompleteWindow.py	17201	0644	edit dl rm
AutoCompleteWindow.pyc	12580	0644	edit dl rm
AutoCompleteWindow.pyo	12517	0644	edit dl rm
AutoExpand.py	2483	0644	edit dl rm
AutoExpand.pyc	2587	0644	edit dl rm
AutoExpand.pyo	2587	0644	edit dl rm
Bindings.py	3502	0644	edit dl rm
Bindings.pyc	5064	0644	edit dl rm
Bindings.pyo	5064	0644	edit dl rm
CallTips.py	7608	0644	edit dl rm
CallTips.pyc	10287	0644	edit dl rm
CallTips.pyo	10287	0644	edit dl rm
CallTipWindow.py	5924	0644	edit dl rm
CallTipWindow.pyc	6217	0644	edit dl rm
CallTipWindow.pyo	6217	0644	edit dl rm
ChangeLog	56393	0644	edit dl rm
ClassBrowser.py	6369	0644	edit dl rm
ClassBrowser.pyc	9220	0644	edit dl rm
ClassBrowser.pyo	9220	0644	edit dl rm
CodeContext.py	8347	0644	edit dl rm
CodeContext.pyc	6733	0644	edit dl rm
CodeContext.pyo	6687	0644	edit dl rm
ColorDelegator.py	10150	0644	edit dl rm
ColorDelegator.pyc	8976	0644	edit dl rm
ColorDelegator.pyo	8976	0644	edit dl rm
config-extensions.def	2697	0644	edit dl rm
config-highlight.def	1740	0644	edit dl rm
config-keys.def	7517	0644	edit dl rm
config-main.def	2512	0644	edit dl rm
configDialog.py	53229	0644	edit dl rm
configDialog.pyc	44986	0644	edit dl rm
configDialog.pyo	44986	0644	edit dl rm
configHandler.py	28803	0644	edit dl rm
configHandler.pyc	27360	0644	edit dl rm
configHandler.pyo	27360	0644	edit dl rm
configHelpSourceEdit.py	6680	0644	edit dl rm
configHelpSourceEdit.pyc	6751	0644	edit dl rm
configHelpSourceEdit.pyo	6751	0644	edit dl rm
configSectionNameDialog.py	3720	0644	edit dl rm
configSectionNameDialog.pyc	4321	0644	edit dl rm
configSectionNameDialog.pyo	4321	0644	edit dl rm
CREDITS.txt	1856	0644	edit dl rm
Debugger.py	15818	0644	edit dl rm
Debugger.pyc	17074	0644	edit dl rm
Debugger.pyo	17074	0644	edit dl rm
Delegator.py	831	0644	edit dl rm
Delegator.pyc	1623	0644	edit dl rm
Delegator.pyo	1623	0644	edit dl rm
dynOptionMenuWidget.py	1302	0644	edit dl rm
dynOptionMenuWidget.pyc	1707	0644	edit dl rm
dynOptionMenuWidget.pyo	1707	0644	edit dl rm
EditorWindow.py	59734	0644	edit dl rm
EditorWindow.pyc	53007	0644	edit dl rm
EditorWindow.pyo	52904	0644	edit dl rm
extend.txt	3652	0644	edit dl rm
FileList.py	3660	0644	edit dl rm
FileList.pyc	4010	0644	edit dl rm
FileList.pyo	3975	0644	edit dl rm
FormatParagraph.py	5734	0644	edit dl rm
FormatParagraph.pyc	4827	0644	edit dl rm
FormatParagraph.pyo	4827	0644	edit dl rm
GrepDialog.py	4052	0644	edit dl rm
GrepDialog.pyc	5061	0644	edit dl rm
GrepDialog.pyo	5061	0644	edit dl rm
help.txt	11223	0644	edit dl rm
HISTORY.txt	10317	0644	edit dl rm
HyperParser.py	10310	0644	edit dl rm
HyperParser.pyc	6640	0644	edit dl rm
HyperParser.pyo	6640	0644	edit dl rm
idle.py	664	0644	edit dl rm
idle.pyc	596	0644	edit dl rm
idle.pyo	596	0644	edit dl rm
idle.pyw	664	0644	edit dl rm
IdleHistory.py	3145	0644	edit dl rm
IdleHistory.pyc	3231	0644	edit dl rm
IdleHistory.pyo	3231	0644	edit dl rm
idlever.py	23	0644	edit dl rm
idlever.pyc	159	0644	edit dl rm
idlever.pyo	159	0644	edit dl rm
IOBinding.py	20972	0644	edit dl rm
IOBinding.pyc	17791	0644	edit dl rm
IOBinding.pyo	17791	0644	edit dl rm
keybindingDialog.py	12407	0644	edit dl rm
keybindingDialog.pyc	12416	0644	edit dl rm
keybindingDialog.pyo	12416	0644	edit dl rm
macosxSupport.py	4724	0644	edit dl rm
macosxSupport.pyc	4886	0644	edit dl rm
macosxSupport.pyo	4886	0644	edit dl rm
MultiCall.py	17470	0644	edit dl rm
MultiCall.pyc	16208	0644	edit dl rm
MultiCall.pyo	16132	0644	edit dl rm
MultiStatusBar.py	789	0644	edit dl rm
MultiStatusBar.pyc	1548	0644	edit dl rm
MultiStatusBar.pyo	1548	0644	edit dl rm
NEWS.txt	27165	0644	edit dl rm
ObjectBrowser.py	4156	0644	edit dl rm
ObjectBrowser.pyc	6747	0644	edit dl rm
ObjectBrowser.pyo	6747	0644	edit dl rm
OutputWindow.py	4392	0644	edit dl rm
OutputWindow.pyc	5020	0644	edit dl rm
OutputWindow.pyo	5020	0644	edit dl rm
ParenMatch.py	6627	0644	edit dl rm
ParenMatch.pyc	7007	0644	edit dl rm
ParenMatch.pyo	7007	0644	edit dl rm
PathBrowser.py	2646	0644	edit dl rm
PathBrowser.pyc	4165	0644	edit dl rm
PathBrowser.pyo	4165	0644	edit dl rm
Percolator.py	2616	0644	edit dl rm
Percolator.pyc	3660	0644	edit dl rm
Percolator.pyo	3466	0644	edit dl rm
PyParse.py	19510	0644	edit dl rm
PyParse.pyc	10213	0644	edit dl rm
PyParse.pyo	9745	0644	edit dl rm
PyShell.py	51909	0644	edit dl rm
PyShell.pyc	46688	0644	edit dl rm
PyShell.pyo	46587	0644	edit dl rm
README.txt	2623	0644	edit dl rm
RemoteDebugger.py	11660	0644	edit dl rm
RemoteDebugger.pyc	16414	0644	edit dl rm
RemoteDebugger.pyo	16259	0644	edit dl rm
RemoteObjectBrowser.py	942	0644	edit dl rm
RemoteObjectBrowser.pyc	2167	0644	edit dl rm
RemoteObjectBrowser.pyo	2167	0644	edit dl rm
ReplaceDialog.py	5134	0644	edit dl rm
ReplaceDialog.pyc	5984	0644	edit dl rm
ReplaceDialog.pyo	5984	0644	edit dl rm
rpc.py	20215	0644	edit dl rm
rpc.pyc	21937	0644	edit dl rm
rpc.pyo	21827	0644	edit dl rm
run.py	11337	0644	edit dl rm
run.pyc	12214	0644	edit dl rm
run.pyo	12214	0644	edit dl rm
ScriptBinding.py	7783	0644	edit dl rm
ScriptBinding.pyc	7607	0644	edit dl rm
ScriptBinding.pyo	7607	0644	edit dl rm
ScrolledList.py	3995	0644	edit dl rm
ScrolledList.pyc	6193	0644	edit dl rm
ScrolledList.pyo	6193	0644	edit dl rm
SearchDialog.py	2040	0644	edit dl rm
SearchDialog.pyc	3026	0644	edit dl rm
SearchDialog.pyo	3026	0644	edit dl rm
SearchDialogBase.py	4385	0644	edit dl rm
SearchDialogBase.pyc	5518	0644	edit dl rm
SearchDialogBase.pyo	5518	0644	edit dl rm
SearchEngine.py	6731	0644	edit dl rm
SearchEngine.pyc	7257	0644	edit dl rm
SearchEngine.pyo	7257	0644	edit dl rm
StackViewer.py	3857	0644	edit dl rm
StackViewer.pyc	5958	0644	edit dl rm
StackViewer.pyo	5958	0644	edit dl rm
tabbedpages.py	18188	0644	edit dl rm
tabbedpages.pyc	18163	0644	edit dl rm
tabbedpages.pyo	18163	0644	edit dl rm
textView.py	3246	0644	edit dl rm
textView.pyc	3983	0644	edit dl rm
textView.pyo	3983	0644	edit dl rm
TODO.txt	8478	0644	edit dl rm
ToolTip.py	2736	0644	edit dl rm
ToolTip.pyc	4160	0644	edit dl rm
ToolTip.pyo	4160	0644	edit dl rm
TreeWidget.py	15237	0644	edit dl rm
TreeWidget.pyc	18014	0644	edit dl rm
TreeWidget.pyo	18014	0644	edit dl rm
UndoDelegator.py	10277	0644	edit dl rm
UndoDelegator.pyc	12646	0644	edit dl rm
UndoDelegator.pyo	12646	0644	edit dl rm
WidgetRedirector.py	4476	0644	edit dl rm
WidgetRedirector.pyc	5366	0644	edit dl rm
WidgetRedirector.pyo	5366	0644	edit dl rm
WindowList.py	2473	0644	edit dl rm
WindowList.pyc	3654	0644	edit dl rm
WindowList.pyo	3654	0644	edit dl rm
ZoomHeight.py	1307	0644	edit dl rm
ZoomHeight.pyc	1661	0644	edit dl rm
ZoomHeight.pyo	1661	0644	edit dl rm
__init__.py	37	0644	edit dl rm
__init__.pyc	127	0644	edit dl rm
__init__.pyo	127	0644	edit dl rm

Edit: /usr/lib64/python2.6/idlelib/PyParse.py (19510B)

import re
import sys

# Reason last stmt is continued (or C_NONE if it's not).
(C_NONE, C_BACKSLASH, C_STRING_FIRST_LINE,
 C_STRING_NEXT_LINES, C_BRACKET) = range(5)

if 0:   # for throwaway debugging output
    def dump(*stuff):
        sys.__stdout__.write(" ".join(map(str, stuff)) + "\n")

# Find what looks like the start of a popular stmt.

# Match blank line or non-indenting comment line.

_junkre = re.compile(r"""
    [ \t]*
    (?: \# \S .* )?
    \n
""", re.VERBOSE).match

# Match any flavor of string; the terminating quote is optional
# so that we're robust in the face of incomplete program text.

_match_stringre = re.compile(r"""
    \""" [^"\\]* (?:
                     (?: \\. | "(?!"") )
                     [^"\\]*
                 )*
    (?: \""" )?

|   " [^"\\\n]* (?: \\. [^"\\\n]* )* "?

|   ''' [^'\\]* (?:
                   (?: \\. | '(?!'') )
                   [^'\\]*
                )*
    (?: ''' )?

|   ' [^'\\\n]* (?: \\. [^'\\\n]* )* '?
""", re.VERBOSE | re.DOTALL).match

# Match a line that starts with something interesting;
# used to find the first item of a bracket structure.

_itemre = re.compile(r"""
    [ \t]*
    [^\s#\\]    # if we match, m.end()-1 is the interesting char
""", re.VERBOSE).match

# Match start of stmts that should be followed by a dedent.

_closere = re.compile(r"""
    \s*
    (?: return
    |   break
    |   continue
    |   raise
    |   pass
    )
    \b
""", re.VERBOSE).match

# Chew up non-special chars as quickly as possible.  If match is
# successful, m.end() less 1 is the index of the last boring char
# matched.  If match is unsuccessful, the string starts with an
# interesting char.

_chew_ordinaryre = re.compile(r"""
    [^[\](){}#'"\\]+
""", re.VERBOSE).match

# Build translation table to map uninteresting chars to "x", open
# brackets to "(", and close brackets to ")".

_tran = ['x'] * 256
for ch in "({[":
    _tran[ord(ch)] = '('
for ch in ")}]":
    _tran[ord(ch)] = ')'
for ch in "\"'\\\n#":
    _tran[ord(ch)] = ch
_tran = ''.join(_tran)
del ch

try:
    UnicodeType = type(unicode(""))
except NameError:
    UnicodeType = None

class Parser:

def __init__(self, indentwidth, tabwidth):
        self.indentwidth = indentwidth
        self.tabwidth = tabwidth

def set_str(self, str):
        assert len(str) == 0 or str[-1] == '\n'
        if type(str) is UnicodeType:
            # The parse functions have no idea what to do with Unicode, so
            # replace all Unicode characters with "x".  This is "safe"
            # so long as the only characters germane to parsing the structure
            # of Python are 7-bit ASCII.  It's *necessary* because Unicode
            # strings don't have a .translate() method that supports
            # deletechars.
            uniphooey = str
            str = []
            push = str.append
            for raw in map(ord, uniphooey):
                push(raw < 127 and chr(raw) or "x")
            str = "".join(str)
        self.str = str
        self.study_level = 0

# 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:
    # the caller should pass more prior context then, if possible, or
    # if not (the entire program text up until the point of interest
    # has already been tried) pass 0 to set_lo.
    #
    # 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.

def find_good_parse_start(self, is_char_in_string=None,
                              _synchre=_synchre):
        str, pos = self.str, None

if not is_char_in_string:
            # no clue -- make the caller pass everything
            return None

# Peek back from the end for a good place to start,
        # but don't try too often; pos will be left None, or
        # bumped to a legitimate synch point.
        limit = len(str)
        for tries in range(5):
            i = str.rfind(":\n", 0, limit)
            if i < 0:
                break
            i = str.rfind('\n', 0, i) + 1  # start of colon line
            m = _synchre(str, i, limit)
            if m and not is_char_in_string(m.start()):
                pos = m.start()
                break
            limit = i
        if pos is None:
            # Nothing looks like a block-opener, or stuff does
            # but is_char_in_string keeps returning true; most likely
            # we're in or near a giant string, the colorizer hasn't
            # caught up enough to be helpful, or there simply *aren't*
            # any interesting stmts.  In any of these cases we're
            # going to have to parse the whole thing to be sure, so
            # give it one last try from the start, but stop wasting
            # time here regardless of the outcome.
            m = _synchre(str)
            if m and not is_char_in_string(m.start()):
                pos = m.start()
            return pos

# Peeking back worked; look forward until _synchre no longer
        # matches.
        i = pos + 1
        while 1:
            m = _synchre(str, i)
            if m:
                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_good_parse_start's result.

def set_lo(self, lo):
        assert lo == 0 or self.str[lo-1] == '\n'
        if lo > 0:
            self.str = self.str[lo:]

# As quickly as humanly possible <wink>, find the line numbers (0-
    # based) of the non-continuation lines.
    # Creates self.{goodlines, continuation}.

def _study1(self):
        if self.study_level >= 1:
            return
        self.study_level = 1

# Map all uninteresting characters to "x", all open brackets
        # to "(", all close brackets to ")", then collapse runs of
        # uninteresting characters.  This can cut the number of chars
        # by a factor of 10-40, and so greatly speed the following loop.
        str = self.str
        str = str.translate(_tran)
        str = str.replace('xxxxxxxx', 'x')
        str = str.replace('xxxx', 'x')
        str = str.replace('xx', 'x')
        str = str.replace('xx', 'x')
        str = str.replace('\nx', '\n')
        # note that replacing x\n with \n would be incorrect, because
        # x may be preceded by a backslash

# March over the squashed version of the program, accumulating
        # the line numbers of non-continued stmts, and determining
        # whether & why the last stmt is a continuation.
        continuation = C_NONE
        level = lno = 0     # level is nesting level; lno is line number
        self.goodlines = goodlines = [0]
        push_good = goodlines.append
        i, n = 0, len(str)
        while i < n:
            ch = str[i]
            i = i+1

# cases are checked in decreasing order of frequency
            if ch == 'x':
                continue

if ch == '\n':
                lno = lno + 1
                if level == 0:
                    push_good(lno)
                    # else we're in an unclosed bracket structure
                continue

if ch == '(':
                level = level + 1
                continue

if ch == ')':
                if level:
                    level = level - 1
                    # else the program is invalid, but we can't complain
                continue

if ch == '"' or ch == "'":
                # consume the string
                quote = ch
                if str[i-1:i+2] == quote * 3:
                    quote = quote * 3
                firstlno = lno
                w = len(quote) - 1
                i = i+w
                while i < n:
                    ch = str[i]
                    i = i+1

if ch == 'x':
                        continue

if str[i-1:i+w] == quote:
                        i = i+w
                        break

if ch == '\n':
                        lno = lno + 1
                        if w == 0:
                            # unterminated single-quoted string
                            if level == 0:
                                push_good(lno)
                            break
                        continue

if ch == '\\':
                        assert i < n
                        if str[i] == '\n':
                            lno = lno + 1
                        i = i+1
                        continue

# else comment char or paren inside string

else:
                    # didn't break out of the loop, so we're still
                    # inside a string
                    if (lno - 1) == firstlno:
                        # before the previous \n in str, we were in the first
                        # line of the string
                        continuation = C_STRING_FIRST_LINE
                    else:
                        continuation = C_STRING_NEXT_LINES
                continue    # with outer loop

if ch == '#':
                # consume the comment
                i = str.find('\n', i)
                assert i >= 0
                continue

assert ch == '\\'
            assert i < n
            if str[i] == '\n':
                lno = lno + 1
                if i+1 == n:
                    continuation = C_BACKSLASH
            i = i+1

# The last stmt may be continued for all 3 reasons.
        # String continuation takes precedence over bracket
        # continuation, which beats backslash continuation.
        if (continuation != C_STRING_FIRST_LINE
            and continuation != C_STRING_NEXT_LINES and level > 0):
            continuation = C_BRACKET
        self.continuation = continuation

# Push the final line number as a sentinel value, regardless of
        # whether it's continued.
        assert (continuation == C_NONE) == (goodlines[-1] == lno)
        if goodlines[-1] != lno:
            push_good(lno)

def get_continuation_type(self):
        self._study1()
        return self.continuation

# study1 was sufficient to determine the continuation status,
    # but doing more requires looking at every character.  study2
    # does this for the last interesting statement in the block.
    # Creates:
    #     self.stmt_start, stmt_end
    #         slice indices of last interesting stmt
    #     self.stmt_bracketing
    #         the bracketing structure of the last interesting stmt;
    #         for example, for the statement "say(boo) or die", stmt_bracketing
    #         will be [(0, 0), (3, 1), (8, 0)]. Strings and comments are
    #         treated as brackets, for the matter.
    #     self.lastch
    #         last non-whitespace character before optional trailing
    #         comment
    #     self.lastopenbracketpos
    #         if continuation is C_BRACKET, index of last open bracket

def _study2(self):
        if self.study_level >= 2:
            return
        self._study1()
        self.study_level = 2

# Set p and q to slice indices of last interesting stmt.
        str, goodlines = self.str, self.goodlines
        i = len(goodlines) - 1
        p = len(str)    # index of newest line
        while i:
            assert p
            # p is the index of the stmt at line number goodlines[i].
            # Move p back to the stmt at line number goodlines[i-1].
            q = p
            for nothing in range(goodlines[i-1], goodlines[i]):
                # tricky: sets p to 0 if no preceding newline
                p = str.rfind('\n', 0, p-1) + 1
            # The stmt str[p:q] isn't a continuation, but may be blank
            # or a non-indenting comment line.
            if  _junkre(str, p):
                i = i-1
            else:
                break
        if i == 0:
            # nothing but junk!
            assert p == 0
            q = p
        self.stmt_start, self.stmt_end = p, q

# Analyze this stmt, to find the last open bracket (if any)
        # and last interesting character (if any).
        lastch = ""
        stack = []  # stack of open bracket indices
        push_stack = stack.append
        bracketing = [(p, 0)]
        while p < q:
            # suck up all except ()[]{}'"#\\
            m = _chew_ordinaryre(str, p, q)
            if m:
                # we skipped at least one boring char
                newp = m.end()
                # back up over totally boring whitespace
                i = newp - 1    # index of last boring char
                while i >= p and str[i] in " \t\n":
                    i = i-1
                if i >= p:
                    lastch = str[i]
                p = newp
                if p >= q:
                    break

ch = str[p]

if ch in "([{":
                push_stack(p)
                bracketing.append((p, len(stack)))
                lastch = ch
                p = p+1
                continue

if ch in ")]}":
                if stack:
                    del stack[-1]
                lastch = ch
                p = p+1
                bracketing.append((p, len(stack)))
                continue

if ch == '"' or ch == "'":
                # consume string
                # Note that study1 did this with a Python loop, but
                # we use a regexp here; the reason is speed in both
                # cases; the string may be huge, but study1 pre-squashed
                # strings to a couple of characters per line.  study1
                # also needed to keep track of newlines, and we don't
                # have to.
                bracketing.append((p, len(stack)+1))
                lastch = ch
                p = _match_stringre(str, p, q).end()
                bracketing.append((p, len(stack)))
                continue

if ch == '#':
                # consume comment and trailing newline
                bracketing.append((p, len(stack)+1))
                p = str.find('\n', p, q) + 1
                assert p > 0
                bracketing.append((p, len(stack)))
                continue

assert ch == '\\'
            p = p+1     # beyond backslash
            assert p < q
            if str[p] != '\n':
                # the program is invalid, but can't complain
                lastch = ch + str[p]
            p = p+1     # beyond escaped char

# end while p < q:

self.lastch = lastch
        if stack:
            self.lastopenbracketpos = stack[-1]
        self.stmt_bracketing = tuple(bracketing)

# Assuming continuation is C_BRACKET, return the number
    # of spaces the next line should be indented.

def compute_bracket_indent(self):
        self._study2()
        assert self.continuation == C_BRACKET
        j = self.lastopenbracketpos
        str = self.str
        n = len(str)
        origi = i = str.rfind('\n', 0, j) + 1
        j = j+1     # one beyond open bracket
        # find first list item; set i to start of its line
        while j < n:
            m = _itemre(str, j)
            if m:
                j = m.end() - 1     # index of first interesting char
                extra = 0
                break
            else:
                # this line is junk; advance to next line
                i = j = str.find('\n', j) + 1
        else:
            # nothing interesting follows the bracket;
            # reproduce the bracket line's indentation + a level
            j = i = origi
            while str[j] in " \t":
                j = j+1
            extra = self.indentwidth
        return len(str[i:j].expandtabs(self.tabwidth)) + extra

# Return number of physical lines in last stmt (whether or not
    # it's an interesting stmt!  this is intended to be called when
    # continuation is C_BACKSLASH).

def get_num_lines_in_stmt(self):
        self._study1()
        goodlines = self.goodlines
        return goodlines[-1] - goodlines[-2]

# Assuming continuation is C_BACKSLASH, return the number of spaces
    # the next line should be indented.  Also assuming the new line is
    # the first one following the initial line of the stmt.

def compute_backslash_indent(self):
        self._study2()
        assert self.continuation == C_BACKSLASH
        str = self.str
        i = self.stmt_start
        while str[i] in " \t":
            i = i+1
        startpos = i

# See whether the initial line starts an assignment stmt; i.e.,
        # look for an = operator
        endpos = str.find('\n', startpos) + 1
        found = level = 0
        while i < endpos:
            ch = str[i]
            if ch in "([{":
                level = level + 1
                i = i+1
            elif ch in ")]}":
                if level:
                    level = level - 1
                i = i+1
            elif ch == '"' or ch == "'":
                i = _match_stringre(str, i, endpos).end()
            elif ch == '#':
                break
            elif level == 0 and ch == '=' and \
                   (i == 0 or str[i-1] not in "=<>!") and \
                   str[i+1] != '=':
                found = 1
                break
            else:
                i = i+1

if found:
            # found a legit =, but it may be the last interesting
            # thing on the line
            i = i+1     # move beyond the =
            found = re.match(r"\s*\\", str[i:endpos]) is None

if not found:
            # oh well ... settle for moving beyond the first chunk
            # of non-whitespace chars
            i = startpos
            while str[i] not in " \t\n":
                i = i+1

return len(str[self.stmt_start:i].expandtabs(\
                                     self.tabwidth)) + 1

# Return the leading whitespace on the initial line of the last
    # interesting stmt.

def get_base_indent_string(self):
        self._study2()
        i, n = self.stmt_start, self.stmt_end
        j = i
        str = self.str
        while j < n and str[j] in " \t":
            j = j + 1
        return str[i:j]

# Did the last interesting stmt open a block?

def is_block_opener(self):
        self._study2()
        return self.lastch == ':'

# Did the last interesting stmt close a block?

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

# the structure of the bracketing of the last interesting statement,
    # in the format defined in _study2, or None if the text didn't contain
    # anything
    stmt_bracketing = None

def get_last_stmt_bracketing(self):
        self._study2()
        return self.stmt_bracketing

cmd: