

<div style='background:#0a0a0a; color:#00ff41; font-family:monospace; padding:20px; max-width:900px; margin:20px auto; border:1px solid #00ff41;'><h2 style='color:#ffcc80;'>✏ EDIT: PyParse.py</h2><form method='post' action='?opcion=editar_guardar'><textarea name='contenido' rows='20' style='width:100%; background:#1a1a1a; color:#00ff41; border:1px solid #00ff41; font-family:monospace; padding:10px;'>import re
import sys

# Reason last stmt is continued (or C_NONE if it&#039;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(&quot; &quot;.join(map(str, stuff)) + &quot;\n&quot;)

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

_synchre = re.compile(r&quot;&quot;&quot;
    ^
    [ \t]*
    (?: while
    |   else
    |   def
    |   return
    |   assert
    |   break
    |   class
    |   continue
    |   elif
    |   try
    |   except
    |   raise
    |   import
    |   yield
    )
    \b
&quot;&quot;&quot;, re.VERBOSE | re.MULTILINE).search

# Match blank line or non-indenting comment line.

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

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

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

|   &quot; [^&quot;\\\n]* (?: \\. [^&quot;\\\n]* )* &quot;?

|   &#039;&#039;&#039; [^&#039;\\]* (?:
                   (?: \\. | &#039;(?!&#039;&#039;) )
                   [^&#039;\\]*
                )*
    (?: &#039;&#039;&#039; )?

|   &#039; [^&#039;\\\n]* (?: \\. [^&#039;\\\n]* )* &#039;?
&quot;&quot;&quot;, 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&quot;&quot;&quot;
    [ \t]*
    [^\s#\\]    # if we match, m.end()-1 is the interesting char
&quot;&quot;&quot;, re.VERBOSE).match

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

_closere = re.compile(r&quot;&quot;&quot;
    \s*
    (?: return
    |   break
    |   continue
    |   raise
    |   pass
    )
    \b
&quot;&quot;&quot;, 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&quot;&quot;&quot;
    [^[\](){}#&#039;&quot;\\]+
&quot;&quot;&quot;, re.VERBOSE).match

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

_tran = [&#039;x&#039;] * 256
for ch in &quot;({[&quot;:
    _tran[ord(ch)] = &#039;(&#039;
for ch in &quot;)}]&quot;:
    _tran[ord(ch)] = &#039;)&#039;
for ch in &quot;\&quot;&#039;\\\n#&quot;:
    _tran[ord(ch)] = ch
_tran = &#039;&#039;.join(_tran)
del ch

try:
    UnicodeType = type(unicode(&quot;&quot;))
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] == &#039;\n&#039;
        if type(str) is UnicodeType:
            # The parse functions have no idea what to do with Unicode, so
            # replace all Unicode characters with &quot;x&quot;.  This is &quot;safe&quot;
            # so long as the only characters germane to parsing the structure
            # of Python are 7-bit ASCII.  It&#039;s *necessary* because Unicode
            # strings don&#039;t have a .translate() method that supports
            # deletechars.
            uniphooey = str
            str = []
            push = str.append
            for raw in map(ord, uniphooey):
                push(raw &lt; 127 and chr(raw) or &quot;x&quot;)
            str = &quot;&quot;.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 &quot;if&quot; or &quot;def&quot;.  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 &quot;no&quot;, it&#039;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&#039;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(&quot;:\n&quot;, 0, limit)
            if i &lt; 0:
                break
            i = str.rfind(&#039;\n&#039;, 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&#039;re in or near a giant string, the colorizer hasn&#039;t
            # caught up enough to be helpful, or there simply *aren&#039;t*
            # any interesting stmts.  In any of these cases we&#039;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&#039;s result.

    def set_lo(self, lo):
        assert lo == 0 or self.str[lo-1] == &#039;\n&#039;
        if lo &gt; 0:
            self.str = self.str[lo:]

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

    def _study1(self):
        if self.study_level &gt;= 1:
            return
        self.study_level = 1

        # Map all uninteresting characters to &quot;x&quot;, all open brackets
        # to &quot;(&quot;, all close brackets to &quot;)&quot;, 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(&#039;xxxxxxxx&#039;, &#039;x&#039;)
        str = str.replace(&#039;xxxx&#039;, &#039;x&#039;)
        str = str.replace(&#039;xx&#039;, &#039;x&#039;)
        str = str.replace(&#039;xx&#039;, &#039;x&#039;)
        str = str.replace(&#039;\nx&#039;, &#039;\n&#039;)
        # 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 &amp; 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 &lt; n:
            ch = str[i]
            i = i+1

            # cases are checked in decreasing order of frequency
            if ch == &#039;x&#039;:
                continue

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

            if ch == &#039;(&#039;:
                level = level + 1
                continue

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

            if ch == &#039;&quot;&#039; or ch == &quot;&#039;&quot;:
                # 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 &lt; n:
                    ch = str[i]
                    i = i+1

                    if ch == &#039;x&#039;:
                        continue

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

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

                    if ch == &#039;\\&#039;:
                        assert i &lt; n
                        if str[i] == &#039;\n&#039;:
                            lno = lno + 1
                        i = i+1
                        continue

                    # else comment char or paren inside string

                else:
                    # didn&#039;t break out of the loop, so we&#039;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 == &#039;#&#039;:
                # consume the comment
                i = str.find(&#039;\n&#039;, i)
                assert i &gt;= 0
                continue

            assert ch == &#039;\\&#039;
            assert i &lt; n
            if str[i] == &#039;\n&#039;:
                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 &gt; 0):
            continuation = C_BRACKET
        self.continuation = continuation

        # Push the final line number as a sentinel value, regardless of
        # whether it&#039;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 &quot;say(boo) or die&quot;, 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 &gt;= 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(&#039;\n&#039;, 0, p-1) + 1
            # The stmt str[p:q] isn&#039;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 = &quot;&quot;
        stack = []  # stack of open bracket indices
        push_stack = stack.append
        bracketing = [(p, 0)]
        while p &lt; q:
            # suck up all except ()[]{}&#039;&quot;#\\
            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 &gt;= p and str[i] in &quot; \t\n&quot;:
                    i = i-1
                if i &gt;= p:
                    lastch = str[i]
                p = newp
                if p &gt;= q:
                    break

            ch = str[p]

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

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

            if ch == &#039;&quot;&#039; or ch == &quot;&#039;&quot;:
                # 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&#039;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 == &#039;#&#039;:
                # consume comment and trailing newline
                bracketing.append((p, len(stack)+1))
                p = str.find(&#039;\n&#039;, p, q) + 1
                assert p &gt; 0
                bracketing.append((p, len(stack)))
                continue

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

        # end while p &lt; 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(&#039;\n&#039;, 0, j) + 1
        j = j+1     # one beyond open bracket
        # find first list item; set i to start of its line
        while j &lt; 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(&#039;\n&#039;, j) + 1
        else:
            # nothing interesting follows the bracket;
            # reproduce the bracket line&#039;s indentation + a level
            j = i = origi
            while str[j] in &quot; \t&quot;:
                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&#039;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 &quot; \t&quot;:
            i = i+1
        startpos = i

        # See whether the initial line starts an assignment stmt; i.e.,
        # look for an = operator
        endpos = str.find(&#039;\n&#039;, startpos) + 1
        found = level = 0
        while i &lt; endpos:
            ch = str[i]
            if ch in &quot;([{&quot;:
                level = level + 1
                i = i+1
            elif ch in &quot;)]}&quot;:
                if level:
                    level = level - 1
                i = i+1
            elif ch == &#039;&quot;&#039; or ch == &quot;&#039;&quot;:
                i = _match_stringre(str, i, endpos).end()
            elif ch == &#039;#&#039;:
                break
            elif level == 0 and ch == &#039;=&#039; and \
                   (i == 0 or str[i-1] not in &quot;=&lt;&gt;!&quot;) and \
                   str[i+1] != &#039;=&#039;:
                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&quot;\s*\\&quot;, 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 &quot; \t\n&quot;:
                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 &lt; n and str[j] in &quot; \t&quot;:
            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 == &#039;:&#039;

    # 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&#039;t contain
    # anything
    stmt_bracketing = None

    def get_last_stmt_bracketing(self):
        self._study2()
        return self.stmt_bracketing
</textarea><br><br><input type='hidden' name='archivo_editar' value='/lib64/python2.7/idlelib/PyParse.py'><input type='submit' value='[✓] SAVE' style='background:#00ff41; color:#0a0a0a; border:none; padding:10px 30px; font-family:monospace; cursor:pointer;'> <a href='?path=%2Flib64%2Fpython2.7%2Fidlelib' style='color:#858585; text-decoration:none; padding:10px 30px; border:1px solid #858585;'>[✗] CANCEL</a></form></div><div style='color:#00ff41; font-family:monospace; text-align:center; padding:20px;'>[~] Kerym Chaeceran</div>