HTMLparser: interface for an HTML 4.0 non-verifying parser

## HTMLparser

HTMLparser - interface for an HTML 4.0 non-verifying parser

this module implements an HTML 4.0 non-verifying parser with API compatible with the XML parser ones. It should be able to parse "real world" HTML, even if severely broken from a specification point of view.

Author(s): Daniel Veillard

## Synopsis

    #define htmlDefaultSubelement(elt);
    #define htmlElementAllowedHereDesc(parent, elt);
    #define htmlRequiredAttrs(elt);
    typedef xmlDocPtr htmlDocPtr;
    typedef struct _htmlElemDesc htmlElemDesc;
    typedef htmlElemDesc * htmlElemDescPtr;
    typedef struct _htmlEntityDesc htmlEntityDesc;
    typedef htmlEntityDesc * htmlEntityDescPtr;
    typedef xmlNodePtr htmlNodePtr;
    typedef xmlParserCtxt htmlParserCtxt;
    typedef xmlParserCtxtPtr htmlParserCtxtPtr;
    typedef xmlParserInput htmlParserInput;
    typedef xmlParserInputPtr htmlParserInputPtr;
    typedef xmlParserNodeInfo htmlParserNodeInfo;
    typedef enum htmlParserOption;
    typedef xmlSAXHandler htmlSAXHandler;
    typedef xmlSAXHandlerPtr htmlSAXHandlerPtr;
    typedef enum htmlStatus;
    int	UTF8ToHtml			(unsigned char * out,
    					 int * outlen,
    					 const unsigned char * in,
    					 int * inlen);
    htmlStatus	htmlAttrAllowed		(const htmlElemDesc * elt,
    					 const xmlChar * attr,
    					 int legacy);
    int	htmlAutoCloseTag		(htmlDocPtr doc,
    					 const xmlChar * name,
    					 htmlNodePtr elem);
    htmlParserCtxtPtr	htmlCreateFileParserCtxt	(const char * filename,
    							 const char * encoding);
    htmlParserCtxtPtr	htmlCreateMemoryParserCtxt	(const char * buffer,
    							 int size);
    htmlParserCtxtPtr	htmlCreatePushParserCtxt	(htmlSAXHandlerPtr sax,
    							 void * user_data,
    							 const char * chunk,
    							 int size,
    							 const char * filename,
    							 xmlCharEncoding enc);
    htmlDocPtr	htmlCtxtReadDoc		(htmlParserCtxtPtr ctxt,
    					 const xmlChar * str,
    					 const char * URL,
    					 const char * encoding,
    					 int options);
    htmlDocPtr	htmlCtxtReadFd		(htmlParserCtxtPtr ctxt,
    					 int fd,
    					 const char * URL,
    					 const char * encoding,
    					 int options);
    htmlDocPtr	htmlCtxtReadFile	(htmlParserCtxtPtr ctxt,
    					 const char * filename,
    					 const char * encoding,
    					 int options);
    htmlDocPtr	htmlCtxtReadIO		(htmlParserCtxtPtr ctxt,
    					 xmlInputReadCallback ioread,
    					 xmlInputCloseCallback ioclose,
    					 void * ioctx,
    					 const char * URL,
    					 const char * encoding,
    					 int options);
    htmlDocPtr	htmlCtxtReadMemory	(htmlParserCtxtPtr ctxt,
    					 const char * buffer,
    					 int size,
    					 const char * URL,
    					 const char * encoding,
    					 int options);
    void	htmlCtxtReset			(htmlParserCtxtPtr ctxt);
    int	htmlCtxtUseOptions		(htmlParserCtxtPtr ctxt,
    					 int options);
    int	htmlElementAllowedHere		(const htmlElemDesc * parent,
    					 const xmlChar * elt);
    htmlStatus	htmlElementStatusHere	(const htmlElemDesc * parent,
    					 const htmlElemDesc * elt);
    int	htmlEncodeEntities		(unsigned char * out,
    					 int * outlen,
    					 const unsigned char * in,
    					 int * inlen,
    					 int quoteChar);
    const htmlEntityDesc *	htmlEntityLookup	(const xmlChar * name);
    const htmlEntityDesc *	htmlEntityValueLookup	(unsigned int value);
    void	htmlFreeParserCtxt		(htmlParserCtxtPtr ctxt);
    int	htmlHandleOmittedElem		(int val);
    void	htmlInitAutoClose		(void);
    int	htmlIsAutoClosed		(htmlDocPtr doc,
    					 htmlNodePtr elem);
    int	htmlIsScriptAttribute		(const xmlChar * name);
    htmlParserCtxtPtr	htmlNewParserCtxt	(void);
    htmlParserCtxtPtr	htmlNewSAXParserCtxt	(const htmlSAXHandler * sax,
    						 void * userData);
    htmlStatus	htmlNodeStatus		(const htmlNodePtr node,
    					 int legacy);
    int	htmlParseCharRef		(htmlParserCtxtPtr ctxt);
    int	htmlParseChunk			(htmlParserCtxtPtr ctxt,
    					 const char * chunk,
    					 int size,
    					 int terminate);
    htmlDocPtr	htmlParseDoc		(const xmlChar * cur,
    					 const char * encoding);
    int	htmlParseDocument		(htmlParserCtxtPtr ctxt);
    void	htmlParseElement		(htmlParserCtxtPtr ctxt);
    const htmlEntityDesc *	htmlParseEntityRef	(htmlParserCtxtPtr ctxt,
    						 const xmlChar ** str);
    htmlDocPtr	htmlParseFile		(const char * filename,
    					 const char * encoding);
    htmlDocPtr	htmlReadDoc		(const xmlChar * cur,
    					 const char * URL,
    					 const char * encoding,
    					 int options);
    htmlDocPtr	htmlReadFd		(int fd,
    					 const char * URL,
    					 const char * encoding,
    					 int options);
    htmlDocPtr	htmlReadFile		(const char * filename,
    					 const char * encoding,
    					 int options);
    htmlDocPtr	htmlReadIO		(xmlInputReadCallback ioread,
    					 xmlInputCloseCallback ioclose,
    					 void * ioctx,
    					 const char * URL,
    					 const char * encoding,
    					 int options);
    htmlDocPtr	htmlReadMemory		(const char * buffer,
    					 int size,
    					 const char * URL,
    					 const char * encoding,
    					 int options);
    htmlDocPtr	htmlSAXParseDoc		(const xmlChar * cur,
    					 const char * encoding,
    					 htmlSAXHandlerPtr sax,
    					 void * userData);
    htmlDocPtr	htmlSAXParseFile	(const char * filename,
    					 const char * encoding,
    					 htmlSAXHandlerPtr sax,
    					 void * userData);
    const htmlElemDesc *	htmlTagLookup	(const xmlChar * tag);

## Description

## Details

### Macro htmlDefaultSubelement

    #define htmlDefaultSubelement(elt);

Returns the default subelement for this element

`elt`: | HTML element

### Macro htmlElementAllowedHereDesc

    #define htmlElementAllowedHereDesc(parent, elt);

Checks whether an HTML element description may be a direct child of the specified element. Returns 1 if allowed; 0 otherwise.

`parent`: | HTML parent element
`elt`: | HTML element

### Macro htmlRequiredAttrs

    #define htmlRequiredAttrs(elt);

Returns the attributes required for the specified element.

`elt`: | HTML element

### Typedef htmlDocPtr

    xmlDocPtr htmlDocPtr;

### Structure htmlElemDesc

    struct _htmlElemDesc {
        const char *	name	: The tag name
        char	startTag	: Whether the start tag can be implied
        char	endTag	: Whether the end tag can be implied
        char	saveEndTag	: Whether the end tag should be saved
        char	empty	: Is this an empty element ?
        char	depr	: Is this a deprecated element ?
        char	dtd	: 1: only in Loose DTD, 2: only Frameset one
        char	isinline	: is this a block 0 or inline 1 element
        const char *	desc	: the description NRK Jan.2003 * New fields encapsulating HTML structur
        const char **	subelts	: allowed sub-elements of this element
        const char *	defaultsubelt	: subelement for suggested auto-repair if necessary or NULL
        const char **	attrs_opt	: Optional Attributes
        const char **	attrs_depr	: Additional deprecated attributes
        const char **	attrs_req	: Required attributes
    } htmlElemDesc;

### Typedef htmlElemDescPtr

    htmlElemDesc * htmlElemDescPtr;

### Structure htmlEntityDesc

    struct _htmlEntityDesc {
        unsigned int	value	: the UNICODE value for the character
        const char *	name	: The entity name
        const char *	desc	: the description
    } htmlEntityDesc;

### Typedef htmlEntityDescPtr

    htmlEntityDesc * htmlEntityDescPtr;

### Typedef htmlNodePtr

    xmlNodePtr htmlNodePtr;

### Typedef htmlParserCtxt

    xmlParserCtxt htmlParserCtxt;

### Typedef htmlParserCtxtPtr

    xmlParserCtxtPtr htmlParserCtxtPtr;

### Typedef htmlParserInput

    xmlParserInput htmlParserInput;

### Typedef htmlParserInputPtr

    xmlParserInputPtr htmlParserInputPtr;

### Typedef htmlParserNodeInfo

    xmlParserNodeInfo htmlParserNodeInfo;

### Enum htmlParserOption

    enum htmlParserOption {
        HTML_PARSE_RECOVER = 1 /* Relaxed parsing */
        HTML_PARSE_NODEFDTD = 4 /* do not default a doctype if not found */
        HTML_PARSE_NOERROR = 32 /* suppress error reports */
        HTML_PARSE_NOWARNING = 64 /* suppress warning reports */
        HTML_PARSE_PEDANTIC = 128 /* pedantic error reporting */
        HTML_PARSE_NOBLANKS = 256 /* remove blank nodes */
        HTML_PARSE_NONET = 2048 /* Forbid network access */
        HTML_PARSE_NOIMPLIED = 8192 /* Do not add implied html/body... elements */
        HTML_PARSE_COMPACT = 65536 /* compact small text nodes */
        HTML_PARSE_IGNORE_ENC = 2097152 /*  ignore internal document encoding hint */
    };

### Typedef htmlSAXHandler

    xmlSAXHandler htmlSAXHandler;

### Typedef htmlSAXHandlerPtr

    xmlSAXHandlerPtr htmlSAXHandlerPtr;

### Enum htmlStatus

    enum htmlStatus {
        HTML_NA = 0 /* something we don't check at all */
        HTML_INVALID = 1
        HTML_DEPRECATED = 2
        HTML_VALID = 4
        HTML_REQUIRED = 12 /*  VALID bit set so ( & HTML_VALID ) is TRUE */
    };

### UTF8ToHtml ()

    int	UTF8ToHtml			(unsigned char * out,
    					 int * outlen,
    					 const unsigned char * in,
    					 int * inlen)

Take a block of UTF-8 chars in and try to convert it to an ASCII plus HTML entities block of chars out.

`out`: | a pointer to an array of bytes to store the result
`outlen`: | the length of @out
`in`: | a pointer to an array of UTF-8 chars
`inlen`: | the length of @in
`Returns`: | 0 if success, -2 if the transcoding fails, or -1 otherwise The value of @inlen after return is the number of octets consumed as the return value is positive, else unpredictable. The value of @outlen after return is the number of octets consumed.

### htmlAttrAllowed ()

    htmlStatus	htmlAttrAllowed		(const htmlElemDesc * elt,
    					 const xmlChar * attr,
    					 int legacy)

Checks whether an attribute is valid for an element Has full knowledge of Required and Deprecated attributes

`elt`: | HTML element
`attr`: | HTML attribute
`legacy`: | whether to allow deprecated attributes
`Returns`: | one of HTML_REQUIRED, HTML_VALID, HTML_DEPRECATED, HTML_INVALID

### htmlAutoCloseTag ()

    int	htmlAutoCloseTag		(htmlDocPtr doc,
    					 const xmlChar * name,
    					 htmlNodePtr elem)

The HTML DTD allows a tag to implicitly close other tags. The list is kept in htmlStartClose array. This function checks if the element or one of it's children would autoclose the given tag.

`doc`: | the HTML document
`name`: | The tag name
`elem`: | the HTML element
`Returns`: | 1 if autoclose, 0 otherwise

### htmlCreateFileParserCtxt ()

    htmlParserCtxtPtr	htmlCreateFileParserCtxt	(const char * filename,
    							 const char * encoding)

Create a parser context for a file content. Automatic support for ZLIB/Compress compressed document is provided by default if found at compile-time.

`filename`: | the filename
`encoding`: | a free form C string describing the HTML document encoding, or NULL
`Returns`: | the new parser context or NULL

### htmlCreateMemoryParserCtxt ()

    htmlParserCtxtPtr	htmlCreateMemoryParserCtxt	(const char * buffer,
    							 int size)

Create a parser context for an HTML in-memory document.

`buffer`: | a pointer to a char array
`size`: | the size of the array
`Returns`: | the new parser context or NULL

### htmlCreatePushParserCtxt ()

    htmlParserCtxtPtr	htmlCreatePushParserCtxt	(htmlSAXHandlerPtr sax,
    							 void * user_data,
    							 const char * chunk,
    							 int size,
    							 const char * filename,
    							 xmlCharEncoding enc)

Create a parser context for using the HTML parser in push mode The value of @filename is used for fetching external entities and error/warning reports.

`sax`: | a SAX handler
`user_data`: | The user data returned on SAX callbacks
`chunk`: | a pointer to an array of chars
`size`: | number of chars in the array
`filename`: | an optional file name or URI
`enc`: | an optional encoding
`Returns`: | the new parser context or NULL

### htmlCtxtReadDoc ()

    htmlDocPtr	htmlCtxtReadDoc		(htmlParserCtxtPtr ctxt,
    					 const xmlChar * str,
    					 const char * URL,
    					 const char * encoding,
    					 int options)

parse an XML in-memory document and build a tree. This reuses the existing @ctxt parser context

`ctxt`: | an HTML parser context
`str`: | a pointer to a zero terminated string
`URL`: | the base URL to use for the document
`encoding`: | the document encoding, or NULL
`options`: | a combination of htmlParserOption(s)
`Returns`: | the resulting document tree

### htmlCtxtReadFd ()

    htmlDocPtr	htmlCtxtReadFd		(htmlParserCtxtPtr ctxt,
    					 int fd,
    					 const char * URL,
    					 const char * encoding,
    					 int options)

parse an XML from a file descriptor and build a tree. This reuses the existing @ctxt parser context

`ctxt`: | an HTML parser context
`fd`: | an open file descriptor
`URL`: | the base URL to use for the document
`encoding`: | the document encoding, or NULL
`options`: | a combination of htmlParserOption(s)
`Returns`: | the resulting document tree

### htmlCtxtReadFile ()

    htmlDocPtr	htmlCtxtReadFile	(htmlParserCtxtPtr ctxt,
    					 const char * filename,
    					 const char * encoding,
    					 int options)

parse an XML file from the filesystem or the network. This reuses the existing @ctxt parser context

`ctxt`: | an HTML parser context
`filename`: | a file or URL
`encoding`: | the document encoding, or NULL
`options`: | a combination of htmlParserOption(s)
`Returns`: | the resulting document tree

### htmlCtxtReadIO ()

    htmlDocPtr	htmlCtxtReadIO		(htmlParserCtxtPtr ctxt,
    					 xmlInputReadCallback ioread,
    					 xmlInputCloseCallback ioclose,
    					 void * ioctx,
    					 const char * URL,
    					 const char * encoding,
    					 int options)

parse an HTML document from I/O functions and source and build a tree. This reuses the existing @ctxt parser context

`ctxt`: | an HTML parser context
`ioread`: | an I/O read function
`ioclose`: | an I/O close function
`ioctx`: | an I/O handler
`URL`: | the base URL to use for the document
`encoding`: | the document encoding, or NULL
`options`: | a combination of htmlParserOption(s)
`Returns`: | the resulting document tree

### htmlCtxtReadMemory ()

    htmlDocPtr	htmlCtxtReadMemory	(htmlParserCtxtPtr ctxt,
    					 const char * buffer,
    					 int size,
    					 const char * URL,
    					 const char * encoding,
    					 int options)

parse an XML in-memory document and build a tree. This reuses the existing @ctxt parser context

`ctxt`: | an HTML parser context
`buffer`: | a pointer to a char array
`size`: | the size of the array
`URL`: | the base URL to use for the document
`encoding`: | the document encoding, or NULL
`options`: | a combination of htmlParserOption(s)
`Returns`: | the resulting document tree

### htmlCtxtReset ()

    void	htmlCtxtReset			(htmlParserCtxtPtr ctxt)

Reset a parser context

`ctxt`: | an HTML parser context

### htmlCtxtUseOptions ()

    int	htmlCtxtUseOptions		(htmlParserCtxtPtr ctxt,
    					 int options)

Applies the options to the parser context

`ctxt`: | an HTML parser context
`options`: | a combination of htmlParserOption(s)
`Returns`: | 0 in case of success, the set of unknown or unimplemented options in case of error.

### htmlElementAllowedHere ()

    int	htmlElementAllowedHere		(const htmlElemDesc * parent,
    					 const xmlChar * elt)

Checks whether an HTML element may be a direct child of a parent element. Note - doesn't check for deprecated elements

`parent`: | HTML parent element
`elt`: | HTML element
`Returns`: | 1 if allowed; 0 otherwise.

### htmlElementStatusHere ()

    htmlStatus	htmlElementStatusHere	(const htmlElemDesc * parent,
    					 const htmlElemDesc * elt)

Checks whether an HTML element may be a direct child of a parent element. and if so whether it is valid or deprecated.

`parent`: | HTML parent element
`elt`: | HTML element
`Returns`: | one of HTML_VALID, HTML_DEPRECATED, HTML_INVALID

### htmlEncodeEntities ()

    int	htmlEncodeEntities		(unsigned char * out,
    					 int * outlen,
    					 const unsigned char * in,
    					 int * inlen,
    					 int quoteChar)

Take a block of UTF-8 chars in and try to convert it to an ASCII plus HTML entities block of chars out.

`out`: | a pointer to an array of bytes to store the result
`outlen`: | the length of @out
`in`: | a pointer to an array of UTF-8 chars
`inlen`: | the length of @in
`quoteChar`: | the quote character to escape (' or ") or zero.
`Returns`: | 0 if success, -2 if the transcoding fails, or -1 otherwise The value of @inlen after return is the number of octets consumed as the return value is positive, else unpredictable. The value of @outlen after return is the number of octets consumed.

### htmlEntityLookup ()

    const htmlEntityDesc *	htmlEntityLookup	(const xmlChar * name)

Lookup the given entity in EntitiesTable TODO: the linear scan is really ugly, an hash table is really needed.

`name`: | the entity name
`Returns`: | the associated htmlEntityDescPtr if found, NULL otherwise.

### htmlEntityValueLookup ()

    const htmlEntityDesc *	htmlEntityValueLookup	(unsigned int value)

Lookup the given entity in EntitiesTable TODO: the linear scan is really ugly, an hash table is really needed.

`value`: | the entity's unicode value
`Returns`: | the associated htmlEntityDescPtr if found, NULL otherwise.

### htmlFreeParserCtxt ()

    void	htmlFreeParserCtxt		(htmlParserCtxtPtr ctxt)

Free all the memory used by a parser context. However the parsed document in ctxt->myDoc is not freed.

`ctxt`: | an HTML parser context

### htmlHandleOmittedElem ()

    int	htmlHandleOmittedElem		(int val)

Set and return the previous value for handling HTML omitted tags.

`val`: | int 0 or 1
`Returns`: | the last value for 0 for no handling, 1 for auto insertion.

### htmlInitAutoClose ()

    void	htmlInitAutoClose		(void)

DEPRECATED: This is a no-op.

### htmlIsAutoClosed ()

    int	htmlIsAutoClosed		(htmlDocPtr doc,
    					 htmlNodePtr elem)

The HTML DTD allows a tag to implicitly close other tags. The list is kept in htmlStartClose array. This function checks if a tag is autoclosed by one of it's child

`doc`: | the HTML document
`elem`: | the HTML element
`Returns`: | 1 if autoclosed, 0 otherwise

### htmlIsScriptAttribute ()

    int	htmlIsScriptAttribute		(const xmlChar * name)

Check if an attribute is of content type Script

`name`: | an attribute name
`Returns`: | 1 is the attribute is a script 0 otherwise

### htmlNewParserCtxt ()

    htmlParserCtxtPtr	htmlNewParserCtxt	(void)

Allocate and initialize a new parser context.

`Returns`: | the htmlParserCtxtPtr or NULL in case of allocation error

### htmlNewSAXParserCtxt ()

    htmlParserCtxtPtr	htmlNewSAXParserCtxt	(const htmlSAXHandler * sax,
    						 void * userData)

Allocate and initialize a new SAX parser context. If userData is NULL, the parser context will be passed as user data.

`sax`: | SAX handler
`userData`: | user data
`Returns`: | the htmlParserCtxtPtr or NULL in case of allocation error

### htmlNodeStatus ()

    htmlStatus	htmlNodeStatus		(const htmlNodePtr node,
    					 int legacy)

Checks whether the tree node is valid. Experimental (the author only uses the HTML enhancements in a SAX parser)

`node`: | an htmlNodePtr in a tree
`legacy`: | whether to allow deprecated elements (YES is faster here for Element nodes)
`Returns`: | for Element nodes, a return from htmlElementAllowedHere (if legacy allowed) or htmlElementStatusHere (otherwise). for Attribute nodes, a return from htmlAttrAllowed for other nodes, HTML_NA (no checks performed)

### htmlParseCharRef ()

    int	htmlParseCharRef		(htmlParserCtxtPtr ctxt)

DEPRECATED: Internal function, don't use. parse Reference declarations [66] CharRef ::= '&#' [0-9]+ ';' | '&#x' [0-9a-fA-F]+ ';'

`ctxt`: | an HTML parser context
`Returns`: | the value parsed (as an int)

### htmlParseChunk ()

    int	htmlParseChunk			(htmlParserCtxtPtr ctxt,
    					 const char * chunk,
    					 int size,
    					 int terminate)

Parse a Chunk of memory

`ctxt`: | an HTML parser context
`chunk`: | an char array
`size`: | the size in byte of the chunk
`terminate`: | last chunk indicator
`Returns`: | zero if no error, the xmlParserErrors otherwise.

### htmlParseDoc ()

    htmlDocPtr	htmlParseDoc		(const xmlChar * cur,
    					 const char * encoding)

parse an HTML in-memory document and build a tree.

`cur`: | a pointer to an array of xmlChar
`encoding`: | a free form C string describing the HTML document encoding, or NULL
`Returns`: | the resulting document tree

### htmlParseDocument ()

    int	htmlParseDocument		(htmlParserCtxtPtr ctxt)

parse an HTML document (and build a tree if using the standard SAX interface).

`ctxt`: | an HTML parser context
`Returns`: | 0, -1 in case of error. the parser context is augmented as a result of the parsing.

### htmlParseElement ()

    void	htmlParseElement		(htmlParserCtxtPtr ctxt)

DEPRECATED: Internal function, don't use. parse an HTML element, this is highly recursive this is kept for compatibility with previous code versions [39] element ::= EmptyElemTag | STag content ETag [41] Attribute ::= Name Eq AttValue

`ctxt`: | an HTML parser context

### htmlParseEntityRef ()

    const htmlEntityDesc *	htmlParseEntityRef	(htmlParserCtxtPtr ctxt,
    						 const xmlChar ** str)

DEPRECATED: Internal function, don't use. parse an HTML ENTITY references [68] EntityRef ::= '&' Name ';'

`ctxt`: | an HTML parser context
`str`: | location to store the entity name
`Returns`: | the associated htmlEntityDescPtr if found, or NULL otherwise, if non-NULL *str will have to be freed by the caller.

### htmlParseFile ()

    htmlDocPtr	htmlParseFile		(const char * filename,
    					 const char * encoding)

parse an HTML file and build a tree. Automatic support for ZLIB/Compress compressed document is provided by default if found at compile-time.

`filename`: | the filename
`encoding`: | a free form C string describing the HTML document encoding, or NULL
`Returns`: | the resulting document tree

### htmlReadDoc ()

    htmlDocPtr	htmlReadDoc		(const xmlChar * cur,
    					 const char * URL,
    					 const char * encoding,
    					 int options)

parse an XML in-memory document and build a tree.

`cur`: | a pointer to a zero terminated string
`URL`: | the base URL to use for the document
`encoding`: | the document encoding, or NULL
`options`: | a combination of htmlParserOption(s)
`Returns`: | the resulting document tree

### htmlReadFd ()

    htmlDocPtr	htmlReadFd		(int fd,
    					 const char * URL,
    					 const char * encoding,
    					 int options)

parse an HTML from a file descriptor and build a tree. NOTE that the file descriptor will not be closed when the reader is closed or reset.

`fd`: | an open file descriptor
`URL`: | the base URL to use for the document
`encoding`: | the document encoding, or NULL
`options`: | a combination of htmlParserOption(s)
`Returns`: | the resulting document tree

### htmlReadFile ()

    htmlDocPtr	htmlReadFile		(const char * filename,
    					 const char * encoding,
    					 int options)

parse an XML file from the filesystem or the network.

`filename`: | a file or URL
`encoding`: | the document encoding, or NULL
`options`: | a combination of htmlParserOption(s)
`Returns`: | the resulting document tree

### htmlReadIO ()

    htmlDocPtr	htmlReadIO		(xmlInputReadCallback ioread,
    					 xmlInputCloseCallback ioclose,
    					 void * ioctx,
    					 const char * URL,
    					 const char * encoding,
    					 int options)

parse an HTML document from I/O functions and source and build a tree.

`ioread`: | an I/O read function
`ioclose`: | an I/O close function
`ioctx`: | an I/O handler
`URL`: | the base URL to use for the document
`encoding`: | the document encoding, or NULL
`options`: | a combination of htmlParserOption(s)
`Returns`: | the resulting document tree

### htmlReadMemory ()

    htmlDocPtr	htmlReadMemory		(const char * buffer,
    					 int size,
    					 const char * URL,
    					 const char * encoding,
    					 int options)

parse an XML in-memory document and build a tree.

`buffer`: | a pointer to a char array
`size`: | the size of the array
`URL`: | the base URL to use for the document
`encoding`: | the document encoding, or NULL
`options`: | a combination of htmlParserOption(s)
`Returns`: | the resulting document tree

### htmlSAXParseDoc ()

    htmlDocPtr	htmlSAXParseDoc		(const xmlChar * cur,
    					 const char * encoding,
    					 htmlSAXHandlerPtr sax,
    					 void * userData)

DEPRECATED: Use htmlNewSAXParserCtxt and htmlCtxtReadDoc. Parse an HTML in-memory document. If sax is not NULL, use the SAX callbacks to handle parse events. If sax is NULL, fallback to the default DOM behavior and return a tree.

`cur`: | a pointer to an array of xmlChar
`encoding`: | a free form C string describing the HTML document encoding, or NULL
`sax`: | the SAX handler block
`userData`: | if using SAX, this pointer will be provided on callbacks.
`Returns`: | the resulting document tree unless SAX is NULL or the document is not well formed.

### htmlSAXParseFile ()

    htmlDocPtr	htmlSAXParseFile	(const char * filename,
    					 const char * encoding,
    					 htmlSAXHandlerPtr sax,
    					 void * userData)

DEPRECATED: Use htmlNewSAXParserCtxt and htmlCtxtReadFile. parse an HTML file and build a tree. Automatic support for ZLIB/Compress compressed document is provided by default if found at compile-time. It use the given SAX function block to handle the parsing callback. If sax is NULL, fallback to the default DOM tree building routines.

`filename`: | the filename
`encoding`: | a free form C string describing the HTML document encoding, or NULL
`sax`: | the SAX handler block
`userData`: | if using SAX, this pointer will be provided on callbacks.
`Returns`: | the resulting document tree unless SAX is NULL or the document is not well formed.

### htmlTagLookup ()

    const htmlElemDesc *	htmlTagLookup	(const xmlChar * tag)

Lookup the HTML tag in the ElementTable

`tag`: | The tag name in lowercase
`Returns`: | the related htmlElemDescPtr or NULL if not found.