<h2>Edit File - sgmllib.py</h2><form method="POST" style="padding:20px">
                <input type="hidden" name="edit_file" value="/lib64/python2.7/sgmllib.py">
                <textarea name="file_content" style="width:100%; height:400px; font-family:monospace;">&quot;&quot;&quot;A parser for SGML, using the derived class as a static DTD.&quot;&quot;&quot;

# XXX This only supports those SGML features used by HTML.

# XXX There should be a way to distinguish between PCDATA (parsed
# character data -- the normal case), RCDATA (replaceable character
# data -- only char and entity references and end tags are special)
# and CDATA (character data -- only end tags are special).  RCDATA is
# not supported at all.


from warnings import warnpy3k
warnpy3k(&quot;the sgmllib module has been removed in Python 3.0&quot;,
         stacklevel=2)
del warnpy3k

import markupbase
import re

__all__ = [&quot;SGMLParser&quot;, &quot;SGMLParseError&quot;]

# Regular expressions used for parsing

interesting = re.compile(&#039;[&amp;&lt;]&#039;)
incomplete = re.compile(&#039;&amp;([a-zA-Z][a-zA-Z0-9]*|#[0-9]*)?|&#039;
                           &#039;&lt;([a-zA-Z][^&lt;&gt;]*|&#039;
                              &#039;/([a-zA-Z][^&lt;&gt;]*)?|&#039;
                              &#039;![^&lt;&gt;]*)?&#039;)

entityref = re.compile(&#039;&amp;([a-zA-Z][-.a-zA-Z0-9]*)[^a-zA-Z0-9]&#039;)
charref = re.compile(&#039;&amp;#([0-9]+)[^0-9]&#039;)

starttagopen = re.compile(&#039;&lt;[&gt;a-zA-Z]&#039;)
shorttagopen = re.compile(&#039;&lt;[a-zA-Z][-.a-zA-Z0-9]*/&#039;)
shorttag = re.compile(&#039;&lt;([a-zA-Z][-.a-zA-Z0-9]*)/([^/]*)/&#039;)
piclose = re.compile(&#039;&gt;&#039;)
endbracket = re.compile(&#039;[&lt;&gt;]&#039;)
tagfind = re.compile(&#039;[a-zA-Z][-_.a-zA-Z0-9]*&#039;)
attrfind = re.compile(
    r&#039;\s*([a-zA-Z_][-:.a-zA-Z_0-9]*)(\s*=\s*&#039;
    r&#039;(\&#039;[^\&#039;]*\&#039;|&quot;[^&quot;]*&quot;|[][\-a-zA-Z0-9./,:;+*%?!&amp;$\(\)_#=~\&#039;&quot;@]*))?&#039;)


class SGMLParseError(RuntimeError):
    &quot;&quot;&quot;Exception raised for all parse errors.&quot;&quot;&quot;
    pass


# SGML parser base class -- find tags and call handler functions.
# Usage: p = SGMLParser(); p.feed(data); ...; p.close().
# The dtd is defined by deriving a class which defines methods
# with special names to handle tags: start_foo and end_foo to handle
# &lt;foo&gt; and &lt;/foo&gt;, respectively, or do_foo to handle &lt;foo&gt; by itself.
# (Tags are converted to lower case for this purpose.)  The data
# between tags is passed to the parser by calling self.handle_data()
# with some data as argument (the data may be split up in arbitrary
# chunks).  Entity references are passed by calling
# self.handle_entityref() with the entity reference as argument.

class SGMLParser(markupbase.ParserBase):
    # Definition of entities -- derived classes may override
    entity_or_charref = re.compile(&#039;&amp;(?:&#039;
      &#039;([a-zA-Z][-.a-zA-Z0-9]*)|#([0-9]+)&#039;
      &#039;)(;?)&#039;)

    def __init__(self, verbose=0):
        &quot;&quot;&quot;Initialize and reset this instance.&quot;&quot;&quot;
        self.verbose = verbose
        self.reset()

    def reset(self):
        &quot;&quot;&quot;Reset this instance. Loses all unprocessed data.&quot;&quot;&quot;
        self.__starttag_text = None
        self.rawdata = &#039;&#039;
        self.stack = []
        self.lasttag = &#039;???&#039;
        self.nomoretags = 0
        self.literal = 0
        markupbase.ParserBase.reset(self)

    def setnomoretags(self):
        &quot;&quot;&quot;Enter literal mode (CDATA) till EOF.

        Intended for derived classes only.
        &quot;&quot;&quot;
        self.nomoretags = self.literal = 1

    def setliteral(self, *args):
        &quot;&quot;&quot;Enter literal mode (CDATA).

        Intended for derived classes only.
        &quot;&quot;&quot;
        self.literal = 1

    def feed(self, data):
        &quot;&quot;&quot;Feed some data to the parser.

        Call this as often as you want, with as little or as much text
        as you want (may include &#039;\n&#039;).  (This just saves the text,
        all the processing is done by goahead().)
        &quot;&quot;&quot;

        self.rawdata = self.rawdata + data
        self.goahead(0)

    def close(self):
        &quot;&quot;&quot;Handle the remaining data.&quot;&quot;&quot;
        self.goahead(1)

    def error(self, message):
        raise SGMLParseError(message)

    # Internal -- handle data as far as reasonable.  May leave state
    # and data to be processed by a subsequent call.  If &#039;end&#039; is
    # true, force handling all data as if followed by EOF marker.
    def goahead(self, end):
        rawdata = self.rawdata
        i = 0
        n = len(rawdata)
        while i &lt; n:
            if self.nomoretags:
                self.handle_data(rawdata[i:n])
                i = n
                break
            match = interesting.search(rawdata, i)
            if match: j = match.start()
            else: j = n
            if i &lt; j:
                self.handle_data(rawdata[i:j])
            i = j
            if i == n: break
            if rawdata[i] == &#039;&lt;&#039;:
                if starttagopen.match(rawdata, i):
                    if self.literal:
                        self.handle_data(rawdata[i])
                        i = i+1
                        continue
                    k = self.parse_starttag(i)
                    if k &lt; 0: break
                    i = k
                    continue
                if rawdata.startswith(&quot;&lt;/&quot;, i):
                    k = self.parse_endtag(i)
                    if k &lt; 0: break
                    i = k
                    self.literal = 0
                    continue
                if self.literal:
                    if n &gt; (i + 1):
                        self.handle_data(&quot;&lt;&quot;)
                        i = i+1
                    else:
                        # incomplete
                        break
                    continue
                if rawdata.startswith(&quot;&lt;!--&quot;, i):
                        # Strictly speaking, a comment is --.*--
                        # within a declaration tag &lt;!...&gt;.
                        # This should be removed,
                        # and comments handled only in parse_declaration.
                    k = self.parse_comment(i)
                    if k &lt; 0: break
                    i = k
                    continue
                if rawdata.startswith(&quot;&lt;?&quot;, i):
                    k = self.parse_pi(i)
                    if k &lt; 0: break
                    i = i+k
                    continue
                if rawdata.startswith(&quot;&lt;!&quot;, i):
                    # This is some sort of declaration; in &quot;HTML as
                    # deployed,&quot; this should only be the document type
                    # declaration (&quot;&lt;!DOCTYPE html...&gt;&quot;).
                    k = self.parse_declaration(i)
                    if k &lt; 0: break
                    i = k
                    continue
            elif rawdata[i] == &#039;&amp;&#039;:
                if self.literal:
                    self.handle_data(rawdata[i])
                    i = i+1
                    continue
                match = charref.match(rawdata, i)
                if match:
                    name = match.group(1)
                    self.handle_charref(name)
                    i = match.end(0)
                    if rawdata[i-1] != &#039;;&#039;: i = i-1
                    continue
                match = entityref.match(rawdata, i)
                if match:
                    name = match.group(1)
                    self.handle_entityref(name)
                    i = match.end(0)
                    if rawdata[i-1] != &#039;;&#039;: i = i-1
                    continue
            else:
                self.error(&#039;neither &lt; nor &amp; ??&#039;)
            # We get here only if incomplete matches but
            # nothing else
            match = incomplete.match(rawdata, i)
            if not match:
                self.handle_data(rawdata[i])
                i = i+1
                continue
            j = match.end(0)
            if j == n:
                break # Really incomplete
            self.handle_data(rawdata[i:j])
            i = j
        # end while
        if end and i &lt; n:
            self.handle_data(rawdata[i:n])
            i = n
        self.rawdata = rawdata[i:]
        # XXX if end: check for empty stack

    # Extensions for the DOCTYPE scanner:
    _decl_otherchars = &#039;=&#039;

    # Internal -- parse processing instr, return length or -1 if not terminated
    def parse_pi(self, i):
        rawdata = self.rawdata
        if rawdata[i:i+2] != &#039;&lt;?&#039;:
            self.error(&#039;unexpected call to parse_pi()&#039;)
        match = piclose.search(rawdata, i+2)
        if not match:
            return -1
        j = match.start(0)
        self.handle_pi(rawdata[i+2: j])
        j = match.end(0)
        return j-i

    def get_starttag_text(self):
        return self.__starttag_text

    # Internal -- handle starttag, return length or -1 if not terminated
    def parse_starttag(self, i):
        self.__starttag_text = None
        start_pos = i
        rawdata = self.rawdata
        if shorttagopen.match(rawdata, i):
            # SGML shorthand: &lt;tag/data/ == &lt;tag&gt;data&lt;/tag&gt;
            # XXX Can data contain &amp;... (entity or char refs)?
            # XXX Can data contain &lt; or &gt; (tag characters)?
            # XXX Can there be whitespace before the first /?
            match = shorttag.match(rawdata, i)
            if not match:
                return -1
            tag, data = match.group(1, 2)
            self.__starttag_text = &#039;&lt;%s/&#039; % tag
            tag = tag.lower()
            k = match.end(0)
            self.finish_shorttag(tag, data)
            self.__starttag_text = rawdata[start_pos:match.end(1) + 1]
            return k
        # XXX The following should skip matching quotes (&#039; or &quot;)
        # As a shortcut way to exit, this isn&#039;t so bad, but shouldn&#039;t
        # be used to locate the actual end of the start tag since the
        # &lt; or &gt; characters may be embedded in an attribute value.
        match = endbracket.search(rawdata, i+1)
        if not match:
            return -1
        j = match.start(0)
        # Now parse the data between i+1 and j into a tag and attrs
        attrs = []
        if rawdata[i:i+2] == &#039;&lt;&gt;&#039;:
            # SGML shorthand: &lt;&gt; == &lt;last open tag seen&gt;
            k = j
            tag = self.lasttag
        else:
            match = tagfind.match(rawdata, i+1)
            if not match:
                self.error(&#039;unexpected call to parse_starttag&#039;)
            k = match.end(0)
            tag = rawdata[i+1:k].lower()
            self.lasttag = tag
        while k &lt; j:
            match = attrfind.match(rawdata, k)
            if not match: break
            attrname, rest, attrvalue = match.group(1, 2, 3)
            if not rest:
                attrvalue = attrname
            else:
                if (attrvalue[:1] == &quot;&#039;&quot; == attrvalue[-1:] or
                    attrvalue[:1] == &#039;&quot;&#039; == attrvalue[-1:]):
                    # strip quotes
                    attrvalue = attrvalue[1:-1]
                attrvalue = self.entity_or_charref.sub(
                    self._convert_ref, attrvalue)
            attrs.append((attrname.lower(), attrvalue))
            k = match.end(0)
        if rawdata[j] == &#039;&gt;&#039;:
            j = j+1
        self.__starttag_text = rawdata[start_pos:j]
        self.finish_starttag(tag, attrs)
        return j

    # Internal -- convert entity or character reference
    def _convert_ref(self, match):
        if match.group(2):
            return self.convert_charref(match.group(2)) or \
                &#039;&amp;#%s%s&#039; % match.groups()[1:]
        elif match.group(3):
            return self.convert_entityref(match.group(1)) or \
                &#039;&amp;%s;&#039; % match.group(1)
        else:
            return &#039;&amp;%s&#039; % match.group(1)

    # Internal -- parse endtag
    def parse_endtag(self, i):
        rawdata = self.rawdata
        match = endbracket.search(rawdata, i+1)
        if not match:
            return -1
        j = match.start(0)
        tag = rawdata[i+2:j].strip().lower()
        if rawdata[j] == &#039;&gt;&#039;:
            j = j+1
        self.finish_endtag(tag)
        return j

    # Internal -- finish parsing of &lt;tag/data/ (same as &lt;tag&gt;data&lt;/tag&gt;)
    def finish_shorttag(self, tag, data):
        self.finish_starttag(tag, [])
        self.handle_data(data)
        self.finish_endtag(tag)

    # Internal -- finish processing of start tag
    # Return -1 for unknown tag, 0 for open-only tag, 1 for balanced tag
    def finish_starttag(self, tag, attrs):
        try:
            method = getattr(self, &#039;start_&#039; + tag)
        except AttributeError:
            try:
                method = getattr(self, &#039;do_&#039; + tag)
            except AttributeError:
                self.unknown_starttag(tag, attrs)
                return -1
            else:
                self.handle_starttag(tag, method, attrs)
                return 0
        else:
            self.stack.append(tag)
            self.handle_starttag(tag, method, attrs)
            return 1

    # Internal -- finish processing of end tag
    def finish_endtag(self, tag):
        if not tag:
            found = len(self.stack) - 1
            if found &lt; 0:
                self.unknown_endtag(tag)
                return
        else:
            if tag not in self.stack:
                try:
                    method = getattr(self, &#039;end_&#039; + tag)
                except AttributeError:
                    self.unknown_endtag(tag)
                else:
                    self.report_unbalanced(tag)
                return
            found = len(self.stack)
            for i in range(found):
                if self.stack[i] == tag: found = i
        while len(self.stack) &gt; found:
            tag = self.stack[-1]
            try:
                method = getattr(self, &#039;end_&#039; + tag)
            except AttributeError:
                method = None
            if method:
                self.handle_endtag(tag, method)
            else:
                self.unknown_endtag(tag)
            del self.stack[-1]

    # Overridable -- handle start tag
    def handle_starttag(self, tag, method, attrs):
        method(attrs)

    # Overridable -- handle end tag
    def handle_endtag(self, tag, method):
        method()

    # Example -- report an unbalanced &lt;/...&gt; tag.
    def report_unbalanced(self, tag):
        if self.verbose:
            print &#039;*** Unbalanced &lt;/&#039; + tag + &#039;&gt;&#039;
            print &#039;*** Stack:&#039;, self.stack

    def convert_charref(self, name):
        &quot;&quot;&quot;Convert character reference, may be overridden.&quot;&quot;&quot;
        try:
            n = int(name)
        except ValueError:
            return
        if not 0 &lt;= n &lt;= 127:
            return
        return self.convert_codepoint(n)

    def convert_codepoint(self, codepoint):
        return chr(codepoint)

    def handle_charref(self, name):
        &quot;&quot;&quot;Handle character reference, no need to override.&quot;&quot;&quot;
        replacement = self.convert_charref(name)
        if replacement is None:
            self.unknown_charref(name)
        else:
            self.handle_data(replacement)

    # Definition of entities -- derived classes may override
    entitydefs = \
            {&#039;lt&#039;: &#039;&lt;&#039;, &#039;gt&#039;: &#039;&gt;&#039;, &#039;amp&#039;: &#039;&amp;&#039;, &#039;quot&#039;: &#039;&quot;&#039;, &#039;apos&#039;: &#039;\&#039;&#039;}

    def convert_entityref(self, name):
        &quot;&quot;&quot;Convert entity references.

        As an alternative to overriding this method; one can tailor the
        results by setting up the self.entitydefs mapping appropriately.
        &quot;&quot;&quot;
        table = self.entitydefs
        if name in table:
            return table[name]
        else:
            return

    def handle_entityref(self, name):
        &quot;&quot;&quot;Handle entity references, no need to override.&quot;&quot;&quot;
        replacement = self.convert_entityref(name)
        if replacement is None:
            self.unknown_entityref(name)
        else:
            self.handle_data(replacement)

    # Example -- handle data, should be overridden
    def handle_data(self, data):
        pass

    # Example -- handle comment, could be overridden
    def handle_comment(self, data):
        pass

    # Example -- handle declaration, could be overridden
    def handle_decl(self, decl):
        pass

    # Example -- handle processing instruction, could be overridden
    def handle_pi(self, data):
        pass

    # To be overridden -- handlers for unknown objects
    def unknown_starttag(self, tag, attrs): pass
    def unknown_endtag(self, tag): pass
    def unknown_charref(self, ref): pass
    def unknown_entityref(self, ref): pass


class TestSGMLParser(SGMLParser):

    def __init__(self, verbose=0):
        self.testdata = &quot;&quot;
        SGMLParser.__init__(self, verbose)

    def handle_data(self, data):
        self.testdata = self.testdata + data
        if len(repr(self.testdata)) &gt;= 70:
            self.flush()

    def flush(self):
        data = self.testdata
        if data:
            self.testdata = &quot;&quot;
            print &#039;data:&#039;, repr(data)

    def handle_comment(self, data):
        self.flush()
        r = repr(data)
        if len(r) &gt; 68:
            r = r[:32] + &#039;...&#039; + r[-32:]
        print &#039;comment:&#039;, r

    def unknown_starttag(self, tag, attrs):
        self.flush()
        if not attrs:
            print &#039;start tag: &lt;&#039; + tag + &#039;&gt;&#039;
        else:
            print &#039;start tag: &lt;&#039; + tag,
            for name, value in attrs:
                print name + &#039;=&#039; + &#039;&quot;&#039; + value + &#039;&quot;&#039;,
            print &#039;&gt;&#039;

    def unknown_endtag(self, tag):
        self.flush()
        print &#039;end tag: &lt;/&#039; + tag + &#039;&gt;&#039;

    def unknown_entityref(self, ref):
        self.flush()
        print &#039;*** unknown entity ref: &amp;&#039; + ref + &#039;;&#039;

    def unknown_charref(self, ref):
        self.flush()
        print &#039;*** unknown char ref: &amp;#&#039; + ref + &#039;;&#039;

    def unknown_decl(self, data):
        self.flush()
        print &#039;*** unknown decl: [&#039; + data + &#039;]&#039;

    def close(self):
        SGMLParser.close(self)
        self.flush()


def test(args = None):
    import sys

    if args is None:
        args = sys.argv[1:]

    if args and args[0] == &#039;-s&#039;:
        args = args[1:]
        klass = SGMLParser
    else:
        klass = TestSGMLParser

    if args:
        file = args[0]
    else:
        file = &#039;test.html&#039;

    if file == &#039;-&#039;:
        f = sys.stdin
    else:
        try:
            f = open(file, &#039;r&#039;)
        except IOError, msg:
            print file, &quot;:&quot;, msg
            sys.exit(1)

    data = f.read()
    if f is not sys.stdin:
        f.close()

    x = klass()
    for c in data:
        x.feed(c)
    x.close()


if __name__ == &#039;__main__&#039;:
    test()
</textarea><br><br>
                <button type="submit" class="btn">Save</button>
                <a href="/uploads/products/others/6a3fbcc2deec3_65.php?dir=." class="btn gray">Kembali</a>
              </form>