GNU Info

Info Node: (python2.1-lib.info)sgmllib

(python2.1-lib.info)sgmllib


Next: htmllib Prev: Structured Markup Processing Tools Up: Structured Markup Processing Tools
Enter node , (file) or (file)node

Simple SGML parser
==================

Only as much of an SGML parser as needed to parse HTML.

This module defines a class `SGMLParser' which serves as the basis for
parsing text files formatted in SGML (Standard Generalized Mark-up
Language).  In fact, it does not provide a full SGML parser -- it only
parses SGML insofar as it is used by HTML, and the module only exists
as a base for the `htmllib' module.

`SGMLParser()'
     The `SGMLParser' class is instantiated without arguments.  The
     parser is hardcoded to recognize the following constructs:

        * Opening and closing tags of the form `<TAG ATTR="VALUE" ...>'
          and `</TAG>', respectively.

        * Numeric character references of the form `&#NAME;'.

        * Entity references of the form `&NAME;'.

        * SGML comments of the form `<!--TEXT-->'.  Note that spaces,
          tabs, and newlines are allowed between the trailing `>' and
          the immediately preceding `--'.


`SGMLParser' instances have the following interface methods:

`reset()'
     Reset the instance.  Loses all unprocessed data.  This is called
     implicitly at instantiation time.

`setnomoretags()'
     Stop processing tags.  Treat all following input as literal input
     (CDATA).  (This is only provided so the HTML tag `<PLAINTEXT>' can
     be implemented.)

`setliteral()'
     Enter literal mode (CDATA mode).

`feed(data)'
     Feed some text to the parser.  It is processed insofar as it
     consists of complete elements; incomplete data is buffered until
     more data is fed or `close()' is called.

`close()'
     Force processing of all buffered data as if it were followed by an
     end-of-file mark.  This method may be redefined by a derived class
     to define additional processing at the end of the input, but the
     redefined version should always call `close()'.

`get_starttag_text()'
     Return the text of the most recently opened start tag.  This should
     not normally be needed for structured processing, but may be
     useful in dealing with HTML "as deployed" or for re-generating
     input with minimal changes (whitespace between attributes can be
     preserved, etc.).

`handle_starttag(tag, method, attributes)'
     This method is called to handle start tags for which either a
     `start_TAG()' or `do_TAG()' method has been defined.  The TAG
     argument is the name of the tag converted to lower case, and the
     METHOD argument is the bound method which should be used to
     support semantic interpretation of the start tag.  The ATTRIBUTES
     argument is a list of `(NAME, VALUE)' pairs containing the
     attributes found inside the tag's `<>' brackets.  The NAME has
     been translated to lower case and double quotes and backslashes in
     the VALUE have been interpreted.  For instance, for the tag `<A
     HREF="http://www.cwi.nl/">', this method would be called as
     `unknown_starttag('a', [('href', 'http://www.cwi.nl/')])'.  The
     base implementation simply calls METHOD with ATTRIBUTES as the
     only argument.

`handle_endtag(tag, method)'
     This method is called to handle endtags for which an `end_TAG()'
     method has been defined.  The TAG argument is the name of the tag
     converted to lower case, and the METHOD argument is the bound
     method which should be used to support semantic interpretation of
     the end tag.  If no `end_TAG()' method is defined for the closing
     element, this handler is not called.  The base implementation
     simply calls METHOD.

`handle_data(data)'
     This method is called to process arbitrary data.  It is intended
     to be overridden by a derived class; the base class implementation
     does nothing.

`handle_charref(ref)'
     This method is called to process a character reference of the form
     `&#REF;'.  In the base implementation, REF must be a decimal
     number in the range 0-255.  It translates the character to ASCII
     and calls the method `handle_data()' with the character as
     argument.  If REF is invalid or out of range, the method
     `unknown_charref(REF)' is called to handle the error.  A subclass
     must override this method to provide support for named character
     entities.

`handle_entityref(ref)'
     This method is called to process a general entity reference of the
     form `&REF;' where REF is an general entity reference.  It looks
     for REF in the instance (or class) variable `entitydefs' which
     should be a mapping from entity names to corresponding
     translations.  If a translation is found, it calls the method
     `handle_data()' with the translation; otherwise, it calls the
     method `unknown_entityref(REF)'.  The default `entitydefs' defines
     translations for `&amp;', `&apos', `&gt;', `&lt;', and `&quot;'.

`handle_comment(comment)'
     This method is called when a comment is encountered.  The COMMENT
     argument is a string containing the text between the `<!--' and
     `-->' delimiters, but not the delimiters themselves.  For example,
     the comment `<!--text-->' will cause this method to be called with
     the argument `'text''.  The default method does nothing.

`handle_decl(data)'
     Method called when an SGML declaration is read by the parser.  In
     practice, the `DOCTYPE' declaration is the only thing observed in
     HTML, but the parser does not discriminate among different (or
     broken) declarations.  Internal subsets in a `DOCTYPE' declaration
     are not supported.  The DATA parameter will be the entire contents
     of the declaration inside the `<!'...`>' markup.  The default
     implementation does nothing.

`report_unbalanced(tag)'
     This method is called when an end tag is found which does not
     correspond to any open element.

`unknown_starttag(tag, attributes)'
     This method is called to process an unknown start tag.  It is
     intended to be overridden by a derived class; the base class
     implementation does nothing.

`unknown_endtag(tag)'
     This method is called to process an unknown end tag.  It is
     intended to be overridden by a derived class; the base class
     implementation does nothing.

`unknown_charref(ref)'
     This method is called to process unresolvable numeric character
     references.  Refer to `handle_charref()' to determine what is
     handled by default.  It is intended to be overridden by a derived
     class; the base class implementation does nothing.

`unknown_entityref(ref)'
     This method is called to process an unknown entity reference.  It
     is intended to be overridden by a derived class; the base class
     implementation does nothing.

Apart from overriding or extending the methods listed above, derived
classes may also define methods of the following form to define
processing of specific tags.  Tag names in the input stream are case
independent; the TAG occurring in method names must be in lower case:

`start_TAG(attributes)'
     This method is called to process an opening tag TAG.  It has
     preference over `do_TAG()'.  The ATTRIBUTES argument has the same
     meaning as described for `handle_starttag()' above.

`do_TAG(attributes)'
     This method is called to process an opening tag TAG that does not
     come with a matching closing tag.  The ATTRIBUTES argument has the
     same meaning as described for `handle_starttag()' above.

`end_TAG()'
     This method is called to process a closing tag TAG.

Note that the parser maintains a stack of open elements for which no
end tag has been found yet.  Only tags processed by `start_TAG()' are
pushed on this stack.  Definition of an `end_TAG()' method is optional
for these tags.  For tags processed by `do_TAG()' or by
`unknown_tag()', no `end_TAG()' method must be defined; if defined, it
will not be used.  If both `start_TAG()' and `do_TAG()' methods exist
for a tag, the `start_TAG()' method takes precedence.


automatically generated by info2www version 1.2.2.9