From 9cb5ff4e6a18f557a2332111686f0ca69cd43917 Mon Sep 17 00:00:00 2001 From: Daniel Veillard Date: Mon, 29 Jan 2001 08:22:21 +0000 Subject: [PATCH] Fixed generated doc, Daniel --- doc/FAQ.html | 2 +- doc/html/gnome-xml-error.html | 390 ---- doc/html/gnome-xml-xml-error.html | 977 --------- ...xml-debugxml.html => libxml-debugxml.html} | 150 +- ...xml-encoding.html => libxml-encoding.html} | 178 +- ...xml-entities.html => libxml-entities.html} | 262 +-- ...htmlparser.html => libxml-htmlparser.html} | 266 +-- ...xml-htmltree.html => libxml-htmltree.html} | 158 +- ...e-xml-nanoftp.html => libxml-nanoftp.html} | 122 +- ...xml-nanohttp.html => libxml-nanohttp.html} | 66 +- ...ome-xml-parser.html => libxml-parser.html} | 882 ++++---- ...rnals.html => libxml-parserinternals.html} | 1082 +++++----- .../{gnome-xml-sax.html => libxml-sax.html} | 300 +-- .../{gnome-xml-tree.html => libxml-tree.html} | 1865 +++++++++-------- .../{gnome-xml-uri.html => libxml-uri.html} | 118 +- ...gnome-xml-valid.html => libxml-valid.html} | 963 +++++---- ...xml-xinclude.html => libxml-xinclude.html} | 30 +- ...gnome-xml-xmlio.html => libxml-xmlio.html} | 486 +++-- ...l-xmlmemory.html => libxml-xmlmemory.html} | 124 +- ...gnome-xml-xpath.html => libxml-xpath.html} | 437 ++-- ...ernals.html => libxml-xpathinternals.html} | 1287 ++++++++---- ...xml-xpointer.html => libxml-xpointer.html} | 118 +- doc/xml.html | 16 +- doc/xmldtd.html | 2 +- doc/xmlio.html | 8 +- doc/xmlmem.html | 18 +- 26 files changed, 4936 insertions(+), 5371 deletions(-) delete mode 100644 doc/html/gnome-xml-error.html delete mode 100644 doc/html/gnome-xml-xml-error.html rename doc/html/{gnome-xml-debugxml.html => libxml-debugxml.html} (89%) rename doc/html/{gnome-xml-encoding.html => libxml-encoding.html} (89%) rename doc/html/{gnome-xml-entities.html => libxml-entities.html} (84%) rename doc/html/{gnome-xml-htmlparser.html => libxml-htmlparser.html} (88%) rename doc/html/{gnome-xml-htmltree.html => libxml-htmltree.html} (86%) rename doc/html/{gnome-xml-nanoftp.html => libxml-nanoftp.html} (94%) rename doc/html/{gnome-xml-nanohttp.html => libxml-nanohttp.html} (93%) rename doc/html/{gnome-xml-parser.html => libxml-parser.html} (88%) rename doc/html/{gnome-xml-parserinternals.html => libxml-parserinternals.html} (86%) rename doc/html/{gnome-xml-sax.html => libxml-sax.html} (90%) rename doc/html/{gnome-xml-tree.html => libxml-tree.html} (85%) rename doc/html/{gnome-xml-uri.html => libxml-uri.html} (89%) rename doc/html/{gnome-xml-valid.html => libxml-valid.html} (84%) rename doc/html/{gnome-xml-xinclude.html => libxml-xinclude.html} (89%) rename doc/html/{gnome-xml-xmlio.html => libxml-xmlio.html} (85%) rename doc/html/{gnome-xml-xmlmemory.html => libxml-xmlmemory.html} (91%) rename doc/html/{gnome-xml-xpath.html => libxml-xpath.html} (79%) rename doc/html/{gnome-xml-xpathinternals.html => libxml-xpathinternals.html} (82%) rename doc/html/{gnome-xml-xpointer.html => libxml-xpointer.html} (84%) diff --git a/doc/FAQ.html b/doc/FAQ.html index 83008fe7..8146f54c 100644 --- a/doc/FAQ.html +++ b/doc/FAQ.html @@ -226,7 +226,7 @@ href="http://xmlsoft.org/messages/">http://xmlsoft.org/messages/

It is possible to validate documents which had not been validated at initial parsing time or documents who have been built from scratch using the API. Use the xmlValidateDtd() + href="http://xmlsoft.org/html/libxml-valid.html#XMLVALIDATEDTD">xmlValidateDtd() function. It is also possible to simply add a Dtd to an existing document:

xmlDocPtr doc; /* your existing document */
diff --git a/doc/html/gnome-xml-error.html b/doc/html/gnome-xml-error.html
deleted file mode 100644
index afb92b70..00000000
--- a/doc/html/gnome-xml-error.html
+++ /dev/null
@@ -1,390 +0,0 @@
-error
Gnome XML Library Reference Manual
PrevNext
error
Name
error — one line description goes here.
Synopsis

-
-void        xmlParserError                  (xmlParserCtxtPtr ctxt,
-                                             const char *msg,
-                                             ...);
-void        xmlParserWarning                (xmlParserCtxtPtr ctxt,
-                                             const char *msg,
-                                             ...);
Description
Details
xmlParserError()
void        xmlParserError                  (xmlParserCtxtPtr ctxt,
-                                             const char *msg,
-                                             ...);
Display and format an error messages, gives file, line, position and
-extra parameters.
ctxt :  an XML parser context
msg :  the message to display/transmit
... :  extra parameters for the message display
xmlParserWarning()
void        xmlParserWarning                (xmlParserCtxtPtr ctxt,
-                                             const char *msg,
-                                             ...);
Display and format a warning messages, gives file, line, position and
-extra parameters.
ctxt :  an XML parser context
msg :  the message to display/transmit
... :  extra parameters for the message display
PrevHomeNext
validUpparserInternals

\ No newline at end of file
diff --git a/doc/html/gnome-xml-xml-error.html b/doc/html/gnome-xml-xml-error.html
deleted file mode 100644
index 30272fd6..00000000
--- a/doc/html/gnome-xml-xml-error.html
+++ /dev/null
@@ -1,977 +0,0 @@
-xml-error
Gnome XML Library Reference Manual
<<< Previous PageHomeUpNext Page >>>
xml-error
Name
xml-error — 
Synopsis

-
-enum        xmlParserErrors;
-void        xmlParserError                  (void *ctx,
-                                             const char *msg,
-                                             ...);
-void        xmlParserWarning                (void *ctx,
-                                             const char *msg,
-                                             ...);
-void        xmlParserValidityError          (void *ctx,
-                                             const char *msg,
-                                             ...);
-void        xmlParserValidityWarning        (void *ctx,
-                                             const char *msg,
-                                             ...);
-void        xmlParserPrintFileInfo          (xmlParserInputPtr input);
-void        xmlParserPrintFileContext       (xmlParserInputPtr input);
Description
Details
enum xmlParserErrors
typedef enum {
-    XML_ERR_OK = 0,
-    XML_ERR_INTERNAL_ERROR,
-    XML_ERR_NO_MEMORY,
-    
-    XML_ERR_DOCUMENT_START, /* 3 */
-    XML_ERR_DOCUMENT_EMPTY,
-    XML_ERR_DOCUMENT_END,
-
-    XML_ERR_INVALID_HEX_CHARREF, /* 6 */
-    XML_ERR_INVALID_DEC_CHARREF,
-    XML_ERR_INVALID_CHARREF,
-    XML_ERR_INVALID_CHAR,
-
-    XML_ERR_CHARREF_AT_EOF, /* 10 */
-    XML_ERR_CHARREF_IN_PROLOG,
-    XML_ERR_CHARREF_IN_EPILOG,
-    XML_ERR_CHARREF_IN_DTD,
-    XML_ERR_ENTITYREF_AT_EOF,
-    XML_ERR_ENTITYREF_IN_PROLOG,
-    XML_ERR_ENTITYREF_IN_EPILOG,
-    XML_ERR_ENTITYREF_IN_DTD,
-    XML_ERR_PEREF_AT_EOF,
-    XML_ERR_PEREF_IN_PROLOG,
-    XML_ERR_PEREF_IN_EPILOG,
-    XML_ERR_PEREF_IN_INT_SUBSET,
-
-    XML_ERR_ENTITYREF_NO_NAME, /* 22 */
-    XML_ERR_ENTITYREF_SEMICOL_MISSING,
-
-    XML_ERR_PEREF_NO_NAME, /* 24 */
-    XML_ERR_PEREF_SEMICOL_MISSING,
-
-    XML_ERR_UNDECLARED_ENTITY, /* 26 */
-    XML_WAR_UNDECLARED_ENTITY,
-    XML_ERR_UNPARSED_ENTITY,
-    XML_ERR_ENTITY_IS_EXTERNAL,
-    XML_ERR_ENTITY_IS_PARAMETER,
-
-    XML_ERR_UNKNOWN_ENCODING, /* 31 */
-    XML_ERR_UNSUPPORTED_ENCODING,
-
-    XML_ERR_STRING_NOT_STARTED, /* 33 */
-    XML_ERR_STRING_NOT_CLOSED,
-    XML_ERR_NS_DECL_ERROR,
-
-    XML_ERR_ENTITY_NOT_STARTED, /* 36 */
-    XML_ERR_ENTITY_NOT_FINISHED,
-    
-    XML_ERR_LT_IN_ATTRIBUTE, /* 38 */
-    XML_ERR_ATTRIBUTE_NOT_STARTED,
-    XML_ERR_ATTRIBUTE_NOT_FINISHED,
-    XML_ERR_ATTRIBUTE_WITHOUT_VALUE,
-    XML_ERR_ATTRIBUTE_REDEFINED,
-
-    XML_ERR_LITERAL_NOT_STARTED, /* 43 */
-    XML_ERR_LITERAL_NOT_FINISHED,
-    
-    XML_ERR_COMMENT_NOT_FINISHED, /* 45 */
-
-    XML_ERR_PI_NOT_STARTED, /* 47 */
-    XML_ERR_PI_NOT_FINISHED,
-
-    XML_ERR_NOTATION_NOT_STARTED, /* 49 */
-    XML_ERR_NOTATION_NOT_FINISHED,
-
-    XML_ERR_ATTLIST_NOT_STARTED, /* 51 */
-    XML_ERR_ATTLIST_NOT_FINISHED,
-
-    XML_ERR_MIXED_NOT_STARTED, /* 53 */
-    XML_ERR_MIXED_NOT_FINISHED,
-
-    XML_ERR_ELEMCONTENT_NOT_STARTED, /* 55 */
-    XML_ERR_ELEMCONTENT_NOT_FINISHED,
-
-    XML_ERR_XMLDECL_NOT_STARTED, /* 57 */
-    XML_ERR_XMLDECL_NOT_FINISHED,
-
-    XML_ERR_CONDSEC_NOT_STARTED, /* 59 */
-    XML_ERR_CONDSEC_NOT_FINISHED,
-
-    XML_ERR_EXT_SUBSET_NOT_FINISHED, /* 61 */
-
-    XML_ERR_DOCTYPE_NOT_FINISHED, /* 62 */
-
-    XML_ERR_MISPLACED_CDATA_END, /* 63 */
-    XML_ERR_CDATA_NOT_FINISHED,
-
-    XML_ERR_RESERVED_XML_NAME, /* 65 */
-
-    XML_ERR_SPACE_REQUIRED, /* 66 */
-    XML_ERR_SEPARATOR_REQUIRED,
-    XML_ERR_NMTOKEN_REQUIRED,
-    XML_ERR_NAME_REQUIRED,
-    XML_ERR_PCDATA_REQUIRED,
-    XML_ERR_URI_REQUIRED,
-    XML_ERR_PUBID_REQUIRED,
-    XML_ERR_LT_REQUIRED,
-    XML_ERR_GT_REQUIRED,
-    XML_ERR_LTSLASH_REQUIRED,
-    XML_ERR_EQUAL_REQUIRED,
-
-    XML_ERR_TAG_NAME_MISMATCH, /* 77 */
-    XML_ERR_TAG_NOT_FINISED,
-
-    XML_ERR_STANDALONE_VALUE, /* 79 */
-
-    XML_ERR_ENCODING_NAME, /* 80 */
-
-    XML_ERR_HYPHEN_IN_COMMENT, /* 81 */
-
-    XML_ERR_INVALID_ENCODING, /* 82 */
-
-    XML_ERR_EXT_ENTITY_STANDALONE, /* 83 */
-
-    XML_ERR_CONDSEC_INVALID, /* 84 */
-
-    XML_ERR_VALUE_REQUIRED, /* 85 */
-
-    XML_ERR_NOT_WELL_BALANCED, /* 86 */
-    XML_ERR_EXTRA_CONTENT, /* 87 */
-    XML_ERR_ENTITY_CHAR_ERROR, /* 88 */
-    XML_ERR_ENTITY_PE_INTERNAL, /* 88 */
-    XML_ERR_ENTITY_LOOP, /* 89 */
-    XML_ERR_ENTITY_BOUNDARY, /* 90 */
-    XML_ERR_INVALID_URI, /* 91 */
-    XML_ERR_URI_FRAGMENT /* 92 */
-}xmlParserErrors;
xmlParserError ()
void        xmlParserError                  (void *ctx,
-                                             const char *msg,
-                                             ...);
Display and format an error messages, gives file, line, position and
-extra parameters.
ctx : 
msg : 
... : 
xmlParserWarning ()
void        xmlParserWarning                (void *ctx,
-                                             const char *msg,
-                                             ...);
Display and format a warning messages, gives file, line, position and
-extra parameters.
ctx : 
msg : 
... : 
xmlParserValidityError ()
void        xmlParserValidityError          (void *ctx,
-                                             const char *msg,
-                                             ...);
Display and format an validity error messages, gives file,
-line, position and extra parameters.
ctx : 
msg : 
... : 
xmlParserValidityWarning ()
void        xmlParserValidityWarning        (void *ctx,
-                                             const char *msg,
-                                             ...);
Display and format a validity warning messages, gives file, line,
-position and extra parameters.
ctx : 
msg : 
... : 
xmlParserPrintFileInfo ()
void        xmlParserPrintFileInfo          (xmlParserInputPtr input);
Displays the associated file and line informations for the current input
input : 
xmlParserPrintFileContext ()
void        xmlParserPrintFileContext       (xmlParserInputPtr input);
Displays current context within the input content for error tracking
input : 


<<< Previous PageHomeUpNext Page >>>
uriHTMLparser

\ No newline at end of file
diff --git a/doc/html/gnome-xml-debugxml.html b/doc/html/libxml-debugxml.html
similarity index 89%
rename from doc/html/gnome-xml-debugxml.html
rename to doc/html/libxml-debugxml.html
index e8bd8044..aafcc767 100644
--- a/doc/html/gnome-xml-debugxml.html
+++ b/doc/html/libxml-debugxml.html
@@ -13,10 +13,10 @@ TITLE="Libxml Library Reference"
 HREF="libxml-lib.html">
debugXML
Name
Synopsis

 
 void        xmlDebugDumpString              (FILE *output,
                                              const xmlChar *str);
 void        xmlDebugDumpAttr                (FILE *output,
                                              xmlAttrPtr attr,
                                              int depth);
 void        xmlDebugDumpAttrList            (FILE *output,
                                              xmlAttrPtr attr,
                                              int depth);
 void        xmlDebugDumpOneNode             (FILE *output,
                                              xmlNodePtr node,
                                              int depth);
 void        xmlDebugDumpNode                (FILE *output,
                                              xmlNodePtr node,
                                              int depth);
 void        xmlDebugDumpNodeList            (FILE *output,
                                              xmlNodePtr node,
                                              int depth);
 void        xmlDebugDumpDocumentHead        (FILE *output,
                                              xmlDocPtr doc);
 void        xmlDebugDumpDocument            (FILE *output,
                                              xmlDocPtr doc);
 void        xmlDebugDumpDTD                 (FILE *output,
                                              xmlDtdPtr doc);
 void        xmlDebugDumpEntities            (FILE *output,
                                              xmlDocPtr doc);
 void        xmlLsOneNode                    (FILE *output,
                                              xmlNodePtr node);
 char*       (*xmlShellReadlineFunc)         (char *prompt);
 struct      xmlShellCtxt;
 typedef     xmlShellCtxtPtr;
 int         (*xmlShellCmd)                  (xmlShellCtxtPtr ctxt,
                                              char *arg,
                                              xmlNodePtr node,
                                              xmlNodePtr node2);
 void        xmlShell                        (xmlDocPtr doc,
                                              char *filename,
                                              xmlShellReadlineFunc input,
                                              
Description
Details
FILE *output,
                                              const xmlChar *str);

FILE *output, xmlAttrPtr attr, int depth);

FILE *output, xmlAttrPtr attr, int depth);

FILE *output, xmlNodePtr node, int depth);

FILE *output, xmlNodePtr node, int depth);

FILE *output, xmlNodePtr node, int depth);

FILE *output, xmlDocPtr doc);

FILE *output, xmlDocPtr doc);

FILE *output, xmlDtdPtr doc);

FILE *output, xmlDocPtr doc);

FILE *output, xmlNodePtr node);

int         (*xmlShellCmd)                  (xmlShellCtxtPtr ctxt,
                                              char *arg,
                                              xmlNodePtr node,
                                              xmlNodePtr node2);

void        xmlShell                        (xmlDocPtr doc,
                                              char *filename,
                                              xmlShellReadlineFunc input,

encoding

Name

Synopsis

enum xmlCharEncoding; int (*xmlCharEncodingInputFunc) (unsigned char *out, int *outlen, unsigned char *in, int *inlen); int (*xmlCharEncodingOutputFunc) (unsigned char *out, int *outlen, unsigned char *in, int *inlen); struct xmlCharEncodingHandler; typedef xmlCharEncodingHandlerPtr; void xmlInitCharEncodingHandlers (void); void xmlCleanupCharEncodingHandlers (void); void xmlRegisterCharEncodingHandler (xmlCharEncodingHandlerPtr handler); xmlCharEncodingHandlerPtr xmlGetCharEncodingHandler (xmlCharEncoding enc); xmlCharEncodingHandlerPtr xmlFindCharEncodingHandler (const char *name); int xmlAddEncodingAlias (const char *name, const char *alias); int xmlDelEncodingAlias (const char *alias); const char* xmlGetEncodingAlias (const char *alias); void xmlCleanupEncodingAliases (void); xmlCharEncoding xmlParseCharEncoding (const char *name); const char* xmlGetCharEncodingName (xmlCharEncoding enc); xmlCharEncoding xmlDetectCharEncoding (unsigned char *in, int len); int xmlCheckUTF8 (unsigned char *utf); int xmlCharEncOutFunc (xmlCharEncodingHandler *handler, xmlBufferPtr out, xmlBufferPtr in); int xmlCharEncInFunc (xmlCharEncodingHandler *handler, xmlBufferPtr out, xmlBufferPtr in); int xmlCharEncFirstLine (xmlCharEncodingHandler *handler, xmlBufferPtr out, xmlBufferPtr in); int xmlCharEncCloseFunc (xmlCharEncodingHandler *handler);

Description

Details

void        xmlRegisterCharEncodingHandler  (xmlCharEncodingHandlerPtr handler);

xmlCharEncodingHandlerPtr xmlGetCharEncodingHandler
                                             (xmlCharEncoding enc);

xmlCharEncodingHandlerPtr xmlFindCharEncodingHandler
                                             (const char *name);

xmlCharEncoding xmlParseCharEncoding        (const char *name);

const char* xmlGetCharEncodingName          (xmlCharEncoding enc);

xmlCharEncoding xmlDetectCharEncoding       (unsigned char *in,
                                              int len);

int         xmlCharEncOutFunc               (xmlCharEncodingHandler *handler,
                                              xmlBufferPtr out,
                                              xmlBufferPtr in);

int         xmlCharEncInFunc                (xmlCharEncodingHandler *handler,
                                              xmlBufferPtr out,
                                              xmlBufferPtr in);

int         xmlCharEncFirstLine             (xmlCharEncodingHandler *handler,
                                              xmlBufferPtr out,
                                              xmlBufferPtr in);

int         xmlCharEncCloseFunc             (xmlCharEncodingHandler *handler);

entities

Name

Synopsis

enum xmlEntityType; struct xmlEntity; typedef xmlEntityPtr; typedef xmlEntitiesTablePtr; void xmlInitializePredefinedEntities (void); xmlEntityPtr xmlAddDocEntity (xmlDocPtr doc, const xmlChar *name, int type, const xmlChar *ExternalID, const xmlChar *SystemID, const xmlChar *content); xmlEntityPtr xmlAddDtdEntity (xmlDocPtr doc, const xmlChar *name, int type, const xmlChar *ExternalID, const xmlChar *SystemID, const xmlChar *content); xmlEntityPtr xmlGetPredefinedEntity (const xmlChar *name); xmlEntityPtr xmlGetDocEntity (xmlDocPtr doc, const xmlChar *name); xmlEntityPtr xmlGetDtdEntity (xmlDocPtr doc, const xmlChar *name); xmlEntityPtr xmlGetParameterEntity (xmlDocPtr doc, const xmlChar *name); const xmlChar* xmlEncodeEntities (xmlDocPtr doc, const xmlChar *input); xmlChar* xmlEncodeEntitiesReentrant (xmlDocPtr doc, const xmlChar *input); xmlChar* xmlEncodeSpecialChars (xmlDocPtr doc, const xmlChar *input); xmlEntitiesTablePtr xmlCreateEntitiesTable (void); xmlEntitiesTablePtr xmlCopyEntitiesTable (xmlEntitiesTablePtr table); void xmlFreeEntitiesTable (xmlEntitiesTablePtr table); void xmlDumpEntitiesTable (xmlBufferPtr buf, xmlEntitiesTablePtr table); void xmlDumpEntityDecl (xmlBufferPtr buf, xmlEntityPtr ent); void xmlCleanupPredefinedEntities (void);

Description

Details

xmlEntityPtr xmlAddDocEntity                (xmlDocPtr doc,
                                              const xmlChar *name,
                                              int type,
                                              const xmlChar *ExternalID,
                                              const xmlChar *SystemID,
                                              const xmlChar *content);

xmlEntityPtr xmlAddDtdEntity                (xmlDocPtr doc,
                                              const xmlChar *name,
                                              int type,
                                              const xmlChar *ExternalID,
                                              const xmlChar *SystemID,
                                              const xmlChar *content);

xmlEntityPtr xmlGetPredefinedEntity         (const xmlChar *name);

xmlEntityPtr xmlGetDocEntity                (xmlDocPtr doc,
                                              const xmlChar *name);

xmlEntityPtr xmlGetDtdEntity                (xmlDocPtr doc,
                                              const xmlChar *name);

xmlEntityPtr xmlGetParameterEntity          (xmlDocPtr doc,
                                              const xmlChar *name);

const xmlChar* xmlEncodeEntities            (xmlDocPtr doc,
                                              const xmlChar *input);

xmlChar*    xmlEncodeEntitiesReentrant      (xmlDocPtr doc,
                                              const xmlChar *input);

xmlChar*    xmlEncodeSpecialChars           (xmlDocPtr doc,
                                              const xmlChar *input);

xmlEntitiesTablePtr xmlCreateEntitiesTable  (void);

xmlEntitiesTablePtr xmlCopyEntitiesTable    (xmlEntitiesTablePtr table);

void        xmlFreeEntitiesTable            (xmlEntitiesTablePtr table);

void        xmlDumpEntitiesTable            (xmlBufferPtr buf,
                                              xmlEntitiesTablePtr table);

void        xmlDumpEntityDecl               (xmlBufferPtr buf,
                                              xmlEntityPtr ent);

HTMLparser

Name

Synopsis

typedef htmlParserCtxt; typedef htmlParserCtxtPtr; typedef htmlParserNodeInfo; typedef htmlSAXHandler; typedef htmlSAXHandlerPtr; typedef htmlParserInput; typedef htmlParserInputPtr; typedef htmlDocPtr; typedef htmlNodePtr; struct htmlElemDesc; typedef htmlElemDescPtr; struct htmlEntityDesc; typedef htmlEntityDescPtr; htmlElemDescPtr htmlTagLookup (const xmlChar *tag); htmlEntityDescPtr htmlEntityLookup (const xmlChar *name); htmlEntityDescPtr htmlEntityValueLookup (int value); int htmlIsAutoClosed (htmlDocPtr doc, htmlNodePtr elem); int htmlAutoCloseTag (htmlDocPtr doc, const xmlChar *name, htmlNodePtr elem); htmlEntityDescPtr htmlParseEntityRef (htmlParserCtxtPtr ctxt, xmlChar **str); int htmlParseCharRef (htmlParserCtxtPtr ctxt); void htmlParseElement (htmlParserCtxtPtr ctxt); htmlDocPtr htmlSAXParseDoc (xmlChar *cur, const char *encoding, htmlSAXHandlerPtr sax, void *userData); htmlDocPtr htmlParseDoc (xmlChar *cur, const char *encoding); htmlDocPtr htmlSAXParseFile (const char *filename, const char *encoding, htmlSAXHandlerPtr sax, void *userData); htmlDocPtr htmlParseFile (const char *filename, const char *encoding); int UTF8ToHtml (unsigned char *out, int *outlen, unsigned char *in, int *inlen); int htmlEncodeEntities (unsigned char *out, int *outlen, @@ -341,31 +341,31 @@ HREF="gnome-xml-htmlparser.html#HTMLENCODEENTITIES" int *inlen, int quoteChar); int htmlIsScriptAttribute (const xmlChar *name); int htmlHandleOmittedElem (int val); void htmlFreeParserCtxt (htmlParserCtxtPtr ctxt); htmlParserCtxtPtr htmlCreatePushParserCtxt (htmlSAXHandlerPtr sax, void *user_data, @@ -373,14 +373,14 @@ HREF="gnome-xml-htmlparser.html#HTMLSAXHANDLERPTR" int size, const char *filename, xmlCharEncoding enc); int htmlParseChunk (htmlParserCtxtPtr ctxt, const char *chunk, @@ -393,7 +393,7 @@ HREF="gnome-xml-htmlparser.html#HTMLPARSERCTXTPTR" >

Description

Details

htmlElemDescPtr htmlTagLookup               (const xmlChar *tag);

htmlEntityDescPtr htmlEntityLookup          (const xmlChar *name);

htmlEntityDescPtr htmlEntityValueLookup     (int value);

int         htmlIsAutoClosed                (htmlDocPtr doc,
                                              htmlNodePtr elem);

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

htmlEntityDescPtr htmlParseEntityRef        (htmlParserCtxtPtr ctxt,
                                              xmlChar **str);

int         htmlParseCharRef                (htmlParserCtxtPtr ctxt);

void        htmlParseElement                (htmlParserCtxtPtr ctxt);

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

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

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

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

int         htmlIsScriptAttribute           (const xmlChar *name);

void        htmlFreeParserCtxt              (htmlParserCtxtPtr ctxt);

htmlParserCtxtPtr htmlCreatePushParserCtxt  (htmlSAXHandlerPtr sax,
                                              void *user_data,
@@ -2527,7 +2527,7 @@ HREF="gnome-xml-htmlparser.html#HTMLSAXHANDLERPTR"
                                              int size,
                                              const char *filename,
                                              xmlCharEncoding enc);

int         htmlParseChunk                  (htmlParserCtxtPtr ctxt,
                                              const char *chunk,
@@ -2831,7 +2831,7 @@ WIDTH="25%"
 BGCOLOR="#C00000"
 ALIGN="left"
 >

HTMLtree

Name

Synopsis

#define HTML_TEXT_NODE #define HTML_ENTITY_REF_NODE #define HTML_COMMENT_NODE #define HTML_PRESERVE_NODE htmlDocPtr htmlNewDoc (const xmlChar *URI, const xmlChar *ExternalID); htmlDocPtr htmlNewDocNoDtD (const xmlChar *URI, const xmlChar *ExternalID); const xmlChar* htmlGetMetaEncoding (htmlDocPtr doc); int htmlSetMetaEncoding (htmlDocPtr doc, const xmlChar *encoding); void htmlDocDumpMemory (xmlDocPtr cur, xmlChar **mem, int *size); int htmlDocDump (FILE *f, xmlDocPtr cur); int htmlSaveFile (const char *filename, xmlDocPtr cur); void htmlNodeDump (xmlBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur); void htmlNodeDumpFile (FILE *out, xmlDocPtr doc, xmlNodePtr cur); int htmlSaveFileEnc (const char *filename, xmlDocPtr cur, const char *encoding);

Description

Details

htmlDocPtr  htmlNewDoc                      (const xmlChar *URI,
                                              const xmlChar *ExternalID);

htmlDocPtr  htmlNewDocNoDtD                 (const xmlChar *URI,
                                              const xmlChar *ExternalID);

const xmlChar* htmlGetMetaEncoding          (htmlDocPtr doc);

int         htmlSetMetaEncoding             (htmlDocPtr doc,
                                              const xmlChar *encoding);

void        htmlDocDumpMemory               (xmlDocPtr cur,
                                              xmlChar **mem,
                                              int *size);

FILE *f, xmlDocPtr cur);

int htmlSaveFile (const char *filename, xmlDocPtr cur);

void        htmlNodeDump                    (xmlBufferPtr buf,
                                              xmlDocPtr doc,
                                              xmlNodePtr cur);

FILE *out, xmlDocPtr doc, xmlNodePtr cur);

int htmlSaveFileEnc (const char *filename, xmlDocPtr cur, const char *encoding);

nanoftp

Name

Synopsis

void (*ftpListCallback) (void *userData, const char *filename, @@ -163,54 +163,54 @@ HREF="LONG" int hour, int minute); void (*ftpDataCallback) (void *userData, const char *data, int len); void xmlNanoFTPInit (void); void xmlNanoFTPCleanup (void); void* xmlNanoFTPNewCtxt (const char *URL); void xmlNanoFTPFreeCtxt (void *ctx); void* xmlNanoFTPConnectTo (const char *server, int port); void* xmlNanoFTPOpen (const char *URL); int xmlNanoFTPConnect (void *ctx); int xmlNanoFTPClose (void *ctx); int xmlNanoFTPQuit (void *ctx); void xmlNanoFTPScanProxy (const char *URL); void xmlNanoFTPProxy (const char *host, int port, @@ -218,58 +218,58 @@ HREF="gnome-xml-nanoftp.html#XMLNANOFTPPROXY" const char *passwd, int type); int xmlNanoFTPUpdateURL (void *ctx, const char *URL); int xmlNanoFTPGetResponse (void *ctx); int xmlNanoFTPCheckResponse (void *ctx); int xmlNanoFTPCwd (void *ctx, char *directory); int xmlNanoFTPGetConnection (void *ctx); int xmlNanoFTPCloseConnection (void *ctx); int xmlNanoFTPList (void *ctx, ftpListCallback callback, void *userData, char *filename); int xmlNanoFTPGetSocket (void *ctx, const char *filename); int xmlNanoFTPGet (void *ctx, ftpDataCallback callback, void *userData, const char *filename); int xmlNanoFTPRead (void *ctx, void *dest, @@ -281,7 +281,7 @@ HREF="gnome-xml-nanoftp.html#XMLNANOFTPREAD" >

Description

Details

int xmlNanoFTPList (void *ctx, ftpListCallback callback, void *userData, @@ -2016,7 +2016,7 @@ VALIGN="TOP" >

int xmlNanoFTPGet (void *ctx, ftpDataCallback callback, void *userData, @@ -2242,7 +2242,7 @@ VALIGN="TOP" >

nanohttp

Name

Synopsis

void xmlNanoHTTPInit (void); void xmlNanoHTTPCleanup (void); void xmlNanoHTTPScanProxy (const char *URL); int xmlNanoHTTPFetch (const char *URL, const char *filename, char **contentType); void* xmlNanoHTTPMethod (const char *URL, const char *method, @@ -171,31 +171,31 @@ HREF="gnome-xml-nanohttp.html#XMLNANOHTTPMETHOD" char **contentType, const char *headers); void* xmlNanoHTTPOpen (const char *URL, char **contentType); int xmlNanoHTTPReturnCode (void *ctx); const char* xmlNanoHTTPAuthHeader (void *ctx); int xmlNanoHTTPRead (void *ctx, void *dest, int len); int xmlNanoHTTPSave (void *ctxt, const char *filename); void xmlNanoHTTPClose (void *ctx);

Description

Details

parser

#define XML_DEFAULT_VERSION void (*xmlParserInputDeallocate) (xmlChar*); struct xmlParserInput; typedef xmlParserInputPtr; struct xmlParserNodeInfo; typedef xmlParserNodeInfoPtr; struct xmlParserNodeInfoSeq; typedef xmlParserNodeInfoSeqPtr; enum xmlParserInputState; struct xmlParserCtxt; typedef xmlParserCtxtPtr; struct xmlSAXLocator; typedef xmlSAXLocatorPtr; xmlParserInputPtr (*resolveEntitySAXFunc) (void *ctx, const xmlChar *publicId, const xmlChar *systemId); void (*internalSubsetSAXFunc) (void *ctx, const xmlChar *name, const xmlChar *ExternalID, const xmlChar *SystemID); void (*externalSubsetSAXFunc) (void *ctx, const xmlChar *name, const xmlChar *ExternalID, const xmlChar *SystemID); xmlEntityPtr (*getEntitySAXFunc) (void *ctx, const xmlChar *name); xmlEntityPtr (*getParameterEntitySAXFunc) (void *ctx, const xmlChar *name); void (*entityDeclSAXFunc) (void *ctx, const xmlChar *name, int type, const xmlChar *publicId, const xmlChar *systemId, xmlChar *content); void (*notationDeclSAXFunc) (void *ctx, const xmlChar *name, const xmlChar *publicId, const xmlChar *systemId); void (*attributeDeclSAXFunc) (void *ctx, const xmlChar *elem, const xmlChar *name, int type, int def, const xmlChar *defaultValue, xmlEnumerationPtr tree); void (*elementDeclSAXFunc) (void *ctx, const xmlChar *name, int type, xmlElementContentPtr content); void (*unparsedEntityDeclSAXFunc) (void *ctx, const xmlChar *name, const xmlChar *publicId, const xmlChar *systemId, const xmlChar *notationName); void (*setDocumentLocatorSAXFunc) (void *ctx, xmlSAXLocatorPtr loc); void (*startDocumentSAXFunc) (void *ctx); void (*endDocumentSAXFunc) (void *ctx); void (*startElementSAXFunc) (void *ctx, const xmlChar *name, const xmlChar **atts); void (*endElementSAXFunc) (void *ctx, const xmlChar *name); void (*attributeSAXFunc) (void *ctx, const xmlChar *name, const xmlChar *value); void (*referenceSAXFunc) (void *ctx, const xmlChar *name); void (*charactersSAXFunc) (void *ctx, const xmlChar *ch, int len); void (*ignorableWhitespaceSAXFunc) (void *ctx, const xmlChar *ch, int len); void (*processingInstructionSAXFunc) (void *ctx, const xmlChar *target, const xmlChar *data); void (*commentSAXFunc) (void *ctx, const xmlChar *value); void (*cdataBlockSAXFunc) (void *ctx, const xmlChar *value, int len); void (*warningSAXFunc) (void *ctx, const char *msg, ...); void (*errorSAXFunc) (void *ctx, const char *msg, ...); void (*fatalErrorSAXFunc) (void *ctx, const char *msg, ...); int (*isStandaloneSAXFunc) (void *ctx); int (*hasInternalSubsetSAXFunc) (void *ctx); int (*hasExternalSubsetSAXFunc) (void *ctx); struct xmlSAXHandler; typedef xmlSAXHandlerPtr; xmlParserInputPtr (*xmlExternalEntityLoader) (const char *URL, const char *ID, xmlParserCtxtPtr context); #define xmlSubstituteEntitiesDefaultValue void xmlInitParser (void); void xmlCleanupParser (void); int xmlParserInputRead (xmlParserInputPtr in, int len); int xmlParserInputGrow (xmlParserInputPtr in, int len); xmlChar* xmlStrdup (const xmlChar *cur); xmlChar* xmlStrndup (const xmlChar *cur, int len); xmlChar* xmlStrsub (const xmlChar *str, int start, int len); const xmlChar* xmlStrchr (const xmlChar *str, xmlChar val); const xmlChar* xmlStrstr (const xmlChar *str, xmlChar *val); const xmlChar* xmlStrcasestr (const xmlChar *str, xmlChar *val); int xmlStrcmp (const xmlChar *str1, const xmlChar *str2); int xmlStrncmp (const xmlChar *str1, const xmlChar *str2, int len); int xmlStrcasecmp (const xmlChar *str1, const xmlChar *str2); int xmlStrncasecmp (const xmlChar *str1, const xmlChar *str2, int len); int xmlStrEqual (const xmlChar *str1, const xmlChar *str2); int xmlStrlen (const xmlChar *str); xmlChar* xmlStrcat (xmlChar *cur, const xmlChar *add); xmlChar* xmlStrncat (xmlChar *cur, const xmlChar *add, int len); xmlDocPtr xmlParseDoc (xmlChar *cur); xmlDocPtr xmlParseMemory (char *buffer, int size); xmlDocPtr xmlParseFile (const char *filename); int xmlSubstituteEntitiesDefault (int val); int xmlKeepBlanksDefault (int val); void xmlStopParser (xmlParserCtxtPtr ctxt); int xmlPedanticParserDefault (int val); xmlDocPtr xmlRecoverDoc (xmlChar *cur); xmlDocPtr xmlRecoverMemory (char *buffer, int size); xmlDocPtr xmlRecoverFile (const char *filename); int xmlParseDocument (xmlParserCtxtPtr ctxt); int xmlParseExtParsedEnt (xmlParserCtxtPtr ctxt); xmlDocPtr xmlSAXParseDoc (xmlSAXHandlerPtr sax, xmlChar *cur, int recovery); int xmlSAXUserParseFile (xmlSAXHandlerPtr sax, void *user_data, const char *filename); int xmlSAXUserParseMemory (xmlSAXHandlerPtr sax, void *user_data, char *buffer, int size); xmlDocPtr xmlSAXParseMemory (xmlSAXHandlerPtr sax, char *buffer, int size, int recovery); xmlDocPtr xmlSAXParseFile (xmlSAXHandlerPtr sax, const char *filename, int recovery); xmlDocPtr xmlSAXParseEntity (xmlSAXHandlerPtr sax, const char *filename); xmlDocPtr xmlParseEntity (const char *filename); xmlDtdPtr xmlParseDTD (const xmlChar *ExternalID, const xmlChar *SystemID); xmlDtdPtr xmlSAXParseDTD (xmlSAXHandlerPtr sax, const xmlChar *ExternalID, const xmlChar *SystemID); xmlDtdPtr xmlIOParseDTD (xmlSAXHandlerPtr sax, xmlParserInputBufferPtr input, xmlCharEncoding enc); int xmlParseBalancedChunkMemory (xmlDocPtr doc, xmlSAXHandlerPtr sax, void *user_data, int depth, const xmlChar *string, xmlNodePtr *list); int xmlParseExternalEntity (xmlDocPtr doc, xmlSAXHandlerPtr sax, void *user_data, int depth, const xmlChar *URL, const xmlChar *ID, xmlNodePtr *list); int xmlParseCtxtExternalEntity (xmlParserCtxtPtr ctx, const xmlChar *URL, const xmlChar *ID, xmlNodePtr *list); void xmlDefaultSAXHandlerInit (void); void htmlDefaultSAXHandlerInit (void); void xmlInitParserCtxt (xmlParserCtxtPtr ctxt); void xmlClearParserCtxt (xmlParserCtxtPtr ctxt); void xmlFreeParserCtxt (xmlParserCtxtPtr ctxt); void xmlSetupParserForBuffer (xmlParserCtxtPtr ctxt, const xmlChar *buffer, const char *filename); xmlParserCtxtPtr xmlCreateDocParserCtxt (xmlChar *cur); int xmlGetFeaturesList (int *len, const char **result); int xmlGetFeature (xmlParserCtxtPtr ctxt, const char *name, void *result); int xmlSetFeature (xmlParserCtxtPtr ctxt, const char *name, void *value); xmlParserCtxtPtr xmlCreatePushParserCtxt (xmlSAXHandlerPtr sax, void *user_data, @@ -1074,136 +1074,136 @@ HREF="gnome-xml-parser.html#XMLSAXHANDLERPTR" int size, const char *filename); int xmlParseChunk (xmlParserCtxtPtr ctxt, const char *chunk, int size, int terminate); xmlParserCtxtPtr xmlCreateIOParserCtxt (xmlSAXHandlerPtr sax, void *user_data, xmlInputReadCallback ioread, xmlInputCloseCallback ioclose, void *ioctx, xmlCharEncoding enc); xmlParserInputPtr xmlNewIOInputStream (xmlParserCtxtPtr ctxt, xmlParserInputBufferPtr input, xmlCharEncoding enc); const xmlParserNodeInfo* xmlParserFindNodeInfo (const xmlParserCtxt *ctxt, const xmlNode *node); void xmlInitNodeInfoSeq (xmlParserNodeInfoSeqPtr seq); void xmlClearNodeInfoSeq (xmlParserNodeInfoSeqPtr seq); unsigned long xmlParserFindNodeInfoIndex (const xmlParserNodeInfoSeq *seq, const xmlNode *node); void xmlParserAddNodeInfo (xmlParserCtxtPtr ctxt, const xmlParserNodeInfo *info); void xmlSetExternalEntityLoader (xmlExternalEntityLoader f); xmlExternalEntityLoader xmlGetExternalEntityLoader (void); xmlParserInputPtr xmlLoadExternalEntity (const char *URL, const char *ID, xmlParserCtxtPtr context);
void        (*xmlParserInputDeallocate)     (xmlChar*);
xmlParserInputPtr (*resolveEntitySAXFunc)   (void *ctx,
                                              const xmlChar *publicId,
                                              const xmlChar *systemId);
void (*internalSubsetSAXFunc) (void *ctx, const xmlChar *name, const xmlChar *ExternalID, const xmlChar *SystemID);void (*externalSubsetSAXFunc) (void *ctx, const xmlChar *name, const xmlChar *ExternalID, const xmlChar *SystemID);
xmlEntityPtr (*getEntitySAXFunc)            (void *ctx,
                                              const xmlChar *name);
xmlEntityPtr (*getParameterEntitySAXFunc)   (void *ctx,
                                              const xmlChar *name);
void (*entityDeclSAXFunc) (void *ctx, const xmlChar *name, int type, const xmlChar *publicId, const xmlChar *systemId, xmlChar *content);void (*notationDeclSAXFunc) (void *ctx, const xmlChar *name, const xmlChar *publicId, const xmlChar *systemId);void (*attributeDeclSAXFunc) (void *ctx, const xmlChar *elem, const xmlChar *name, int type, int def, const xmlChar *defaultValue, xmlEnumerationPtr tree);void (*elementDeclSAXFunc) (void *ctx, const xmlChar *name, int type, xmlElementContentPtr content);void (*unparsedEntityDeclSAXFunc) (void *ctx, const xmlChar *name, const xmlChar *publicId, const xmlChar *systemId, const xmlChar *notationName);void (*setDocumentLocatorSAXFunc) (void *ctx, xmlSAXLocatorPtr loc);void (*startElementSAXFunc) (void *ctx, const xmlChar *name, const xmlChar **atts);void (*endElementSAXFunc) (void *ctx, const xmlChar *name);void (*attributeSAXFunc) (void *ctx, const xmlChar *name, const xmlChar *value);void (*referenceSAXFunc) (void *ctx, const xmlChar *name);void (*charactersSAXFunc) (void *ctx, const xmlChar *ch, int len);void (*ignorableWhitespaceSAXFunc) (void *ctx, const xmlChar *ch, int len);void (*processingInstructionSAXFunc) (void *ctx, const xmlChar *target, const xmlChar *data);void (*commentSAXFunc) (void *ctx, const xmlChar *value);void (*cdataBlockSAXFunc) (void *ctx, const xmlChar *value, int len);
xmlParserInputPtr (*xmlExternalEntityLoader)
                                             (const char *URL,
                                              const char *ID,
                                              xmlParserCtxtPtr context);
int         xmlParserInputRead              (xmlParserInputPtr in,
                                              int len);
int         xmlParserInputGrow              (xmlParserInputPtr in,
                                              int len);
xmlChar*    xmlStrdup                       (const xmlChar *cur);
xmlChar*    xmlStrndup                      (const xmlChar *cur,
                                              int len);
xmlChar*    xmlStrsub                       (const xmlChar *str,
                                              int start,
@@ -5320,14 +5320,14 @@ CELLPADDING="6"
 >
const xmlChar* xmlStrchr                    (const xmlChar *str,
                                              xmlChar val);
const xmlChar* xmlStrstr                    (const xmlChar *str,
                                              xmlChar *val);
const xmlChar* xmlStrcasestr                (const xmlChar *str,
                                              xmlChar *val);
int         xmlStrcmp                       (const xmlChar *str1,
                                              const xmlChar *str2);
int         xmlStrncmp                      (const xmlChar *str1,
                                              const xmlChar *str2,
                                              int len);
int         xmlStrcasecmp                   (const xmlChar *str1,
                                              const xmlChar *str2);
int         xmlStrncasecmp                  (const xmlChar *str1,
                                              const xmlChar *str2,
                                              int len);
int         xmlStrEqual                     (const xmlChar *str1,
                                              const xmlChar *str2);
Check if both string are equal of have same content
 Should be a bit more readable and faster than xmlStrEqual()
int         xmlStrlen                       (const xmlChar *str);
xmlChar*    xmlStrcat                       (xmlChar *cur,
                                              const xmlChar *add);
xmlChar*    xmlStrncat                      (xmlChar *cur,
                                              const xmlChar *add,
                                              int len);
xmlDocPtr   xmlParseDoc                     (xmlChar *cur);
xmlDocPtr   xmlParseMemory                  (char *buffer,
                                              int size);
xmlDocPtr   xmlParseFile                    (const char *filename);
ignorableWhitespace() callbacks instead of characters() one, and when
 using the DOM output text nodes containing those blanks were not generated.
 The 2.x and later version will switch to the XML standard way and
 ignorableWhitespace() are only generated when running the parser in
 validating mode and when the current element doesn't allow CDATA or
@@ -6833,7 +6833,7 @@ This function is provided as a way to force the standard behaviour
 on 1.X libs and to switch back to the old mode for compatibility when
 running 1.X client code on 2.X . Upgrade of 1.X code should be done
 by using xmlIsBlankNode() commodity function to detect the "empty"
 nodes generated.
@@ -6909,7 +6909,7 @@ CELLPADDING="6"
 >
void        xmlStopParser                   (xmlParserCtxtPtr ctxt);
xmlDocPtr   xmlRecoverDoc                   (xmlChar *cur);
xmlDocPtr   xmlRecoverMemory                (char *buffer,
                                              int size);
xmlDocPtr   xmlRecoverFile                  (const char *filename);
int         xmlParseDocument                (xmlParserCtxtPtr ctxt);
int         xmlParseExtParsedEnt            (xmlParserCtxtPtr ctxt);
xmlDocPtr   xmlSAXParseDoc                  (xmlSAXHandlerPtr sax,
                                              xmlChar *cur,
                                              int recovery);
int         xmlSAXUserParseFile             (xmlSAXHandlerPtr sax,
                                              void *user_data,
@@ -7711,7 +7711,7 @@ CELLPADDING="6"
 >
int         xmlSAXUserParseMemory           (xmlSAXHandlerPtr sax,
                                              void *user_data,
@@ -7844,10 +7844,10 @@ CELLPADDING="6"
 >
xmlDocPtr   xmlSAXParseMemory               (xmlSAXHandlerPtr sax,
                                              char *buffer,
@@ -7982,10 +7982,10 @@ CELLPADDING="6"
 >
xmlDocPtr   xmlSAXParseFile                 (xmlSAXHandlerPtr sax,
                                              const char *filename,
@@ -8103,10 +8103,10 @@ CELLPADDING="6"
 >
xmlDocPtr   xmlSAXParseEntity               (xmlSAXHandlerPtr sax,
                                              const char *filename);
xmlDocPtr   xmlParseEntity                  (const char *filename);
xmlDtdPtr   xmlParseDTD                     (const xmlChar *ExternalID,
                                              const xmlChar *SystemID);
xmlDtdPtr   xmlSAXParseDTD                  (xmlSAXHandlerPtr sax,
                                              const xmlChar *ExternalID,
                                              const xmlChar *SystemID);
xmlDtdPtr   xmlIOParseDTD                   (xmlSAXHandlerPtr sax,
                                              xmlParserInputBufferPtr input,
                                              xmlCharEncoding enc);
int         xmlParseBalancedChunkMemory     (xmlDocPtr doc,
                                              xmlSAXHandlerPtr sax,
                                              void *user_data,
                                              int depth,
                                              const xmlChar *string,
                                              xmlNodePtr *list);
int         xmlParseExternalEntity          (xmlDocPtr doc,
                                              xmlSAXHandlerPtr sax,
                                              void *user_data,
                                              int depth,
                                              const xmlChar *URL,
                                              const xmlChar *ID,
                                              xmlNodePtr *list);
int         xmlParseCtxtExternalEntity      (xmlParserCtxtPtr ctx,
                                              const xmlChar *URL,
                                              const xmlChar *ID,
                                              xmlNodePtr *list);
void        xmlInitParserCtxt               (xmlParserCtxtPtr ctxt);
void        xmlClearParserCtxt              (xmlParserCtxtPtr ctxt);
void        xmlFreeParserCtxt               (xmlParserCtxtPtr ctxt);
void        xmlSetupParserForBuffer         (xmlParserCtxtPtr ctxt,
                                              const xmlChar *buffer,
                                              const char *filename);
xmlParserCtxtPtr xmlCreateDocParserCtxt     (xmlChar *cur);
int         xmlGetFeature                   (xmlParserCtxtPtr ctxt,
                                              const char *name,
@@ -9802,7 +9802,7 @@ CELLPADDING="6"
 >
int         xmlSetFeature                   (xmlParserCtxtPtr ctxt,
                                              const char *name,
@@ -9914,10 +9914,10 @@ CELLPADDING="6"
 >
xmlParserCtxtPtr xmlCreatePushParserCtxt    (xmlSAXHandlerPtr sax,
                                              void *user_data,
@@ -10080,7 +10080,7 @@ CELLPADDING="6"
 >
int         xmlParseChunk                   (xmlParserCtxtPtr ctxt,
                                              const char *chunk,
@@ -10212,24 +10212,24 @@ CELLPADDING="6"
 >
xmlParserCtxtPtr xmlCreateIOParserCtxt      (xmlSAXHandlerPtr sax,
                                              void *user_data,
                                              xmlInputReadCallback ioread,
                                              xmlInputCloseCallback ioclose,
                                              void *ioctx,
                                              xmlCharEncoding enc);
xmlParserInputPtr xmlNewIOInputStream       (xmlParserCtxtPtr ctxt,
                                              xmlParserInputBufferPtr input,
                                              xmlCharEncoding enc);
const xmlParserNodeInfo* xmlParserFindNodeInfo
                                             (const xmlParserCtxt *ctxt,
                                              const xmlNode *node);
void        xmlInitNodeInfoSeq              (xmlParserNodeInfoSeqPtr seq);
void        xmlClearNodeInfoSeq             (xmlParserNodeInfoSeqPtr seq);
long xmlParserFindNodeInfoIndex    (const xmlParserNodeInfoSeq *seq,
                                              const xmlNode *node);
void        xmlParserAddNodeInfo            (xmlParserCtxtPtr ctxt,
                                              const xmlParserNodeInfo *info);
void        xmlSetExternalEntityLoader      (xmlExternalEntityLoader f);
xmlExternalEntityLoader xmlGetExternalEntityLoader
                                             (void);
xmlParserInputPtr xmlLoadExternalEntity     (const char *URL,
                                              const char *ID,
                                              xmlParserCtxtPtr context);

parserInternals

Name

Synopsis

#define XML_MAX_NAMELEN #define INPUT_CHUNK #define IS_CHAR (c) #define IS_BLANK (c) #define IS_BASECHAR (c) #define IS_DIGIT (c) #define IS_COMBINING (c) #define IS_EXTENDER (c) #define IS_IDEOGRAPHIC (c) #define IS_LETTER (c) #define IS_PUBIDCHAR (c) #define SKIP_EOL (p) #define MOVETO_ENDTAG (p) #define MOVETO_STARTTAG (p) int xmlIsBaseChar (int c); int xmlIsBlank (int c); int xmlIsPubidChar (int c); int xmlIsLetter (int c); int xmlIsDigit (int c); int xmlIsIdeographic (int c); int xmlIsCombining (int c); int xmlIsExtender (int c); int xmlIsChar (int c); xmlParserCtxtPtr xmlCreateDocParserCtxt (xmlChar *cur); xmlParserCtxtPtr xmlCreateFileParserCtxt (const char *filename); xmlParserCtxtPtr xmlCreateMemoryParserCtxt (char *buffer, int size); xmlParserCtxtPtr xmlNewParserCtxt (void); xmlParserCtxtPtr xmlCreateEntityParserCtxt (const xmlChar *URL, const xmlChar *ID, const xmlChar *base); int xmlSwitchEncoding (xmlParserCtxtPtr ctxt, xmlCharEncoding enc); int xmlSwitchToEncoding (xmlParserCtxtPtr ctxt, xmlCharEncodingHandlerPtr handler); void xmlFreeParserCtxt (xmlParserCtxtPtr ctxt); void xmlHandleEntity (xmlParserCtxtPtr ctxt, xmlEntityPtr entity); xmlParserInputPtr xmlNewEntityInputStream (xmlParserCtxtPtr ctxt, xmlEntityPtr entity); void xmlPushInput (xmlParserCtxtPtr ctxt, xmlParserInputPtr input); xmlChar xmlPopInput (xmlParserCtxtPtr ctxt); void xmlFreeInputStream (xmlParserInputPtr input); xmlParserInputPtr xmlNewInputFromFile (xmlParserCtxtPtr ctxt, const char *filename); xmlParserInputPtr xmlNewInputStream (xmlParserCtxtPtr ctxt); xmlChar* xmlSplitQName (xmlParserCtxtPtr ctxt, const xmlChar *name, xmlChar **prefix); xmlChar* xmlNamespaceParseNCName (xmlParserCtxtPtr ctxt); xmlChar* xmlNamespaceParseQName (xmlParserCtxtPtr ctxt, xmlChar **prefix); xmlChar* xmlNamespaceParseNSDef (xmlParserCtxtPtr ctxt); xmlChar* xmlParseQuotedString (xmlParserCtxtPtr ctxt); void xmlParseNamespace (xmlParserCtxtPtr ctxt); xmlChar* xmlScanName (xmlParserCtxtPtr ctxt); xmlChar* xmlParseName (xmlParserCtxtPtr ctxt); xmlChar* xmlParseNmtoken (xmlParserCtxtPtr ctxt); xmlChar* xmlParseEntityValue (xmlParserCtxtPtr ctxt, xmlChar **orig); xmlChar* xmlParseAttValue (xmlParserCtxtPtr ctxt); xmlChar* xmlParseSystemLiteral (xmlParserCtxtPtr ctxt); xmlChar* xmlParsePubidLiteral (xmlParserCtxtPtr ctxt); void xmlParseCharData (xmlParserCtxtPtr ctxt, int cdata); xmlChar* xmlParseExternalID (xmlParserCtxtPtr ctxt, xmlChar **publicID, int strict); void xmlParseComment (xmlParserCtxtPtr ctxt); xmlChar* xmlParsePITarget (xmlParserCtxtPtr ctxt); void xmlParsePI (xmlParserCtxtPtr ctxt); void xmlParseNotationDecl (xmlParserCtxtPtr ctxt); void xmlParseEntityDecl (xmlParserCtxtPtr ctxt); int xmlParseDefaultDecl (xmlParserCtxtPtr ctxt, xmlChar **value); xmlEnumerationPtr xmlParseNotationType (xmlParserCtxtPtr ctxt); xmlEnumerationPtr xmlParseEnumerationType (xmlParserCtxtPtr ctxt); int xmlParseEnumeratedType (xmlParserCtxtPtr ctxt, xmlEnumerationPtr *tree); int xmlParseAttributeType (xmlParserCtxtPtr ctxt, xmlEnumerationPtr *tree); void xmlParseAttributeListDecl (xmlParserCtxtPtr ctxt); xmlElementContentPtr xmlParseElementMixedContentDecl (xmlParserCtxtPtr ctxt); xmlElementContentPtr xmlParseElementChildrenContentD (xmlParserCtxtPtr ctxt); xmlElementContentPtr xmlParseElementChildrenContentDecl (xmlParserCtxtPtr ctxt); int xmlParseElementContentDecl (xmlParserCtxtPtr ctxt, xmlChar *name, xmlElementContentPtr *result); int xmlParseElementDecl (xmlParserCtxtPtr ctxt); void xmlParseMarkupDecl (xmlParserCtxtPtr ctxt); int xmlParseCharRef (xmlParserCtxtPtr ctxt); xmlEntityPtr xmlParseEntityRef (xmlParserCtxtPtr ctxt); void xmlParseReference (xmlParserCtxtPtr ctxt); void xmlParsePEReference (xmlParserCtxtPtr ctxt); void xmlParseDocTypeDecl (xmlParserCtxtPtr ctxt); xmlChar* xmlParseAttribute (xmlParserCtxtPtr ctxt, xmlChar **value); xmlChar* xmlParseStartTag (xmlParserCtxtPtr ctxt); void xmlParseEndTag (xmlParserCtxtPtr ctxt); void xmlParseCDSect (xmlParserCtxtPtr ctxt); void xmlParseContent (xmlParserCtxtPtr ctxt); void xmlParseElement (xmlParserCtxtPtr ctxt); xmlChar* xmlParseVersionNum (xmlParserCtxtPtr ctxt); xmlChar* xmlParseVersionInfo (xmlParserCtxtPtr ctxt); xmlChar* xmlParseEncName (xmlParserCtxtPtr ctxt); xmlChar* xmlParseEncodingDecl (xmlParserCtxtPtr ctxt); int xmlParseSDDecl (xmlParserCtxtPtr ctxt); void xmlParseXMLDecl (xmlParserCtxtPtr ctxt); void xmlParseTextDecl (xmlParserCtxtPtr ctxt); void xmlParseMisc (xmlParserCtxtPtr ctxt); void xmlParseExternalSubset (xmlParserCtxtPtr ctxt, const xmlChar *ExternalID, const xmlChar *SystemID); #define XML_SUBSTITUTE_NONE #define XML_SUBSTITUTE_REF #define XML_SUBSTITUTE_PEREF #define XML_SUBSTITUTE_BOTH xmlChar* xmlDecodeEntities (xmlParserCtxtPtr ctxt, int len, int what, xmlChar end, xmlChar end2, xmlChar end3); xmlChar* xmlStringDecodeEntities (xmlParserCtxtPtr ctxt, const xmlChar *str, int what, xmlChar end, xmlChar end2, xmlChar end3); int nodePush (xmlParserCtxtPtr ctxt, xmlNodePtr value); xmlNodePtr nodePop (xmlParserCtxtPtr ctxt); int inputPush (xmlParserCtxtPtr ctxt, xmlParserInputPtr value); xmlParserInputPtr inputPop (xmlParserCtxtPtr ctxt); int xmlSkipBlankChars (xmlParserCtxtPtr ctxt); int xmlStringCurrentChar (xmlParserCtxtPtr ctxt, const xmlChar *cur, int *len); void xmlParserHandlePEReference (xmlParserCtxtPtr ctxt); void xmlParserHandleReference (xmlParserCtxtPtr ctxt); xmlChar* namePop (xmlParserCtxtPtr ctxt); int xmlCheckLanguageID (const xmlChar *lang); int xmlCurrentChar (xmlParserCtxtPtr ctxt, int *len); int xmlCopyChar (int len, xmlChar *out, int val); void xmlNextChar (xmlParserCtxtPtr ctxt); void xmlParserInputShrink (xmlParserInputPtr in); void htmlInitAutoClose (void);

Description

Details

xA)+ Also available as a macro IS_BLANK()

] any Unicode character, excluding the surrogate blocks, FFFE, and FFFF. Also available as a macro IS_CHAR()

xmlParserCtxtPtr xmlCreateDocParserCtxt     (xmlChar *cur);

xmlParserCtxtPtr xmlCreateFileParserCtxt    (const char *filename);

xmlParserCtxtPtr xmlCreateMemoryParserCtxt  (char *buffer,
                                              int size);

xmlParserCtxtPtr xmlNewParserCtxt           (void);

xmlParserCtxtPtr xmlCreateEntityParserCtxt  (const xmlChar *URL,
                                              const xmlChar *ID,
                                              const xmlChar *base);

int         xmlSwitchEncoding               (xmlParserCtxtPtr ctxt,
                                              xmlCharEncoding enc);

int         xmlSwitchToEncoding             (xmlParserCtxtPtr ctxt,
                                              xmlCharEncodingHandlerPtr handler);

void        xmlFreeParserCtxt               (xmlParserCtxtPtr ctxt);

void        xmlHandleEntity                 (xmlParserCtxtPtr ctxt,
                                              xmlEntityPtr entity);

xmlParserInputPtr xmlNewEntityInputStream   (xmlParserCtxtPtr ctxt,
                                              xmlEntityPtr entity);

void        xmlPushInput                    (xmlParserCtxtPtr ctxt,
                                              xmlParserInputPtr input);

xmlChar     xmlPopInput                     (xmlParserCtxtPtr ctxt);

void        xmlFreeInputStream              (xmlParserInputPtr input);

xmlParserInputPtr xmlNewInputFromFile       (xmlParserCtxtPtr ctxt,
                                              const char *filename);

xmlParserInputPtr xmlNewInputStream         (xmlParserCtxtPtr ctxt);

xmlChar*    xmlSplitQName                   (xmlParserCtxtPtr ctxt,
                                              const xmlChar *name,
                                              xmlChar **prefix);

xmlChar*    xmlNamespaceParseNCName         (xmlParserCtxtPtr ctxt);

xmlChar*    xmlNamespaceParseQName          (xmlParserCtxtPtr ctxt,
                                              xmlChar **prefix);

xmlChar*    xmlNamespaceParseNSDef          (xmlParserCtxtPtr ctxt);

xmlChar*    xmlParseQuotedString            (xmlParserCtxtPtr ctxt);

void        xmlParseNamespace               (xmlParserCtxtPtr ctxt);

xmlChar*    xmlScanName                     (xmlParserCtxtPtr ctxt);

xmlChar*    xmlParseName                    (xmlParserCtxtPtr ctxt);

xmlChar*    xmlParseNmtoken                 (xmlParserCtxtPtr ctxt);

xmlChar*    xmlParseEntityValue             (xmlParserCtxtPtr ctxt,
                                              xmlChar **orig);

xmlChar*    xmlParseAttValue                (xmlParserCtxtPtr ctxt);

xmlChar*    xmlParseSystemLiteral           (xmlParserCtxtPtr ctxt);

xmlChar*    xmlParsePubidLiteral            (xmlParserCtxtPtr ctxt);

void        xmlParseCharData                (xmlParserCtxtPtr ctxt,
                                              int cdata);

xmlChar*    xmlParseExternalID              (xmlParserCtxtPtr ctxt,
                                              xmlChar **publicID,
                                              int strict);

void        xmlParseComment                 (xmlParserCtxtPtr ctxt);

xmlChar*    xmlParsePITarget                (xmlParserCtxtPtr ctxt);

void        xmlParsePI                      (xmlParserCtxtPtr ctxt);

void        xmlParseNotationDecl            (xmlParserCtxtPtr ctxt);

See the NOTE on xmlParseExternalID().

void        xmlParseEntityDecl              (xmlParserCtxtPtr ctxt);

int         xmlParseDefaultDecl             (xmlParserCtxtPtr ctxt,
                                              xmlChar **value);
[ VC: Attribute Default Legal ] The declared default value must meet the lexical constraints of the declared attribute type c.f. xmlValidateAttributeDecl()

[ WFC: No < in Attribute Values ] handled in xmlParseAttValue()

xmlEnumerationPtr xmlParseNotationType      (xmlParserCtxtPtr ctxt);

xmlEnumerationPtr xmlParseEnumerationType   (xmlParserCtxtPtr ctxt);

int         xmlParseEnumeratedType          (xmlParserCtxtPtr ctxt,
                                              xmlEnumerationPtr *tree);

int         xmlParseAttributeType           (xmlParserCtxtPtr ctxt,
                                              xmlEnumerationPtr *tree);

Validity constraints for attribute values syntax are checked in xmlValidateAttributeValue()

void        xmlParseAttributeListDecl       (xmlParserCtxtPtr ctxt);

xmlElementContentPtr xmlParseElementMixedContentDecl
                                             (xmlParserCtxtPtr ctxt);

xmlElementContentPtr xmlParseElementChildrenContentD
                                             (xmlParserCtxtPtr ctxt);

xmlElementContentPtr xmlParseElementChildrenContentDecl
                                             (xmlParserCtxtPtr ctxt);

int         xmlParseElementContentDecl      (xmlParserCtxtPtr ctxt,
                                              xmlChar *name,
                                              xmlElementContentPtr *result);

int         xmlParseElementDecl             (xmlParserCtxtPtr ctxt);

void        xmlParseMarkupDecl              (xmlParserCtxtPtr ctxt);

int         xmlParseCharRef                 (xmlParserCtxtPtr ctxt);

xmlEntityPtr xmlParseEntityRef              (xmlParserCtxtPtr ctxt);

void        xmlParseReference               (xmlParserCtxtPtr ctxt);
character() if this is a CharRef, a predefined entity, if there is no reference() callback. or if the parser was asked to switch to that mode.

void        xmlParsePEReference             (xmlParserCtxtPtr ctxt);

void        xmlParseDocTypeDecl             (xmlParserCtxtPtr ctxt);

xmlChar*    xmlParseAttribute               (xmlParserCtxtPtr ctxt,
                                              xmlChar **value);

xmlChar*    xmlParseStartTag                (xmlParserCtxtPtr ctxt);

void        xmlParseEndTag                  (xmlParserCtxtPtr ctxt);

void        xmlParseCDSect                  (xmlParserCtxtPtr ctxt);

void        xmlParseContent                 (xmlParserCtxtPtr ctxt);

void        xmlParseElement                 (xmlParserCtxtPtr ctxt);

xmlChar*    xmlParseVersionNum              (xmlParserCtxtPtr ctxt);

xmlChar*    xmlParseVersionInfo             (xmlParserCtxtPtr ctxt);

xmlChar*    xmlParseEncName                 (xmlParserCtxtPtr ctxt);

xmlChar*    xmlParseEncodingDecl            (xmlParserCtxtPtr ctxt);

int         xmlParseSDDecl                  (xmlParserCtxtPtr ctxt);

void        xmlParseXMLDecl                 (xmlParserCtxtPtr ctxt);

void        xmlParseTextDecl                (xmlParserCtxtPtr ctxt);

void        xmlParseMisc                    (xmlParserCtxtPtr ctxt);

void        xmlParseExternalSubset          (xmlParserCtxtPtr ctxt,
                                              const xmlChar *ExternalID,
                                              const xmlChar *SystemID);

xmlChar*    xmlDecodeEntities               (xmlParserCtxtPtr ctxt,
                                              int len,
                                              int what,
                                              xmlChar end,
                                              xmlChar end2,
                                              xmlChar end3);

xmlChar*    xmlStringDecodeEntities         (xmlParserCtxtPtr ctxt,
                                              const xmlChar *str,
                                              int what,
                                              xmlChar end,
                                              xmlChar end2,
                                              xmlChar end3);

int         nodePush                        (xmlParserCtxtPtr ctxt,
                                              xmlNodePtr value);

xmlNodePtr  nodePop                         (xmlParserCtxtPtr ctxt);

int         inputPush                       (xmlParserCtxtPtr ctxt,
                                              xmlParserInputPtr value);

xmlParserInputPtr inputPop                  (xmlParserCtxtPtr ctxt);

int         xmlSkipBlankChars               (xmlParserCtxtPtr ctxt);

int         xmlStringCurrentChar            (xmlParserCtxtPtr ctxt,
                                              const xmlChar *cur,
                                              int *len);

void        xmlParserHandlePEReference      (xmlParserCtxtPtr ctxt);

void        xmlParserHandleReference        (xmlParserCtxtPtr ctxt);

xmlChar*    namePop                         (xmlParserCtxtPtr ctxt);

int         xmlCheckLanguageID              (const xmlChar *lang);

int         xmlCurrentChar                  (xmlParserCtxtPtr ctxt,
                                              int *len);

int xmlCopyChar (int len, xmlChar *out, int val);

void        xmlNextChar                     (xmlParserCtxtPtr ctxt);

void        xmlParserInputShrink            (xmlParserInputPtr in);

Initialize the htmlStartCloseIndex for fast lookup of closing tags names. This is not reentrant. Call xmlInitParser() once before processing in case of use in multithreaded programs.

SAX

const xmlChar* getPublicId (void *ctx); const xmlChar* getSystemId (void *ctx); void setDocumentLocator (void *ctx, xmlSAXLocatorPtr loc); int getLineNumber (void *ctx); int getColumnNumber (void *ctx); int isStandalone (void *ctx); int hasInternalSubset (void *ctx); int hasExternalSubset (void *ctx); void internalSubset (void *ctx, const xmlChar *name, const xmlChar *ExternalID, const xmlChar *SystemID); void externalSubset (void *ctx, const xmlChar *name, const xmlChar *ExternalID, const xmlChar *SystemID); xmlEntityPtr getEntity (void *ctx, const xmlChar *name); xmlEntityPtr getParameterEntity (void *ctx, const xmlChar *name); xmlParserInputPtr resolveEntity (void *ctx, const xmlChar *publicId, const xmlChar *systemId); void entityDecl (void *ctx, const xmlChar *name, int type, const xmlChar *publicId, const xmlChar *systemId, xmlChar *content); void attributeDecl (void *ctx, const xmlChar *elem, const xmlChar *name, int type, int def, const xmlChar *defaultValue, xmlEnumerationPtr tree); void elementDecl (void *ctx, const xmlChar *name, int type, xmlElementContentPtr content); void notationDecl (void *ctx, const xmlChar *name, const xmlChar *publicId, const xmlChar *systemId); void unparsedEntityDecl (void *ctx, const xmlChar *name, const xmlChar *publicId, const xmlChar *systemId, const xmlChar *notationName); void startDocument (void *ctx); void endDocument (void *ctx); void attribute (void *ctx, const xmlChar *fullname, const xmlChar *value); void startElement (void *ctx, const xmlChar *fullname, const xmlChar **atts); void endElement (void *ctx, const xmlChar *name); void reference (void *ctx, const xmlChar *name); void characters (void *ctx, const xmlChar *ch, int len); void ignorableWhitespace (void *ctx, const xmlChar *ch, int len); void processingInstruction (void *ctx, const xmlChar *target, const xmlChar *data); void globalNamespace (void *ctx, const xmlChar *href, const xmlChar *prefix); void setNamespace (void *ctx, const xmlChar *name); xmlNsPtr getNamespace (void *ctx); int checkNamespace (void *ctx, xmlChar *nameSpace); void namespaceDecl (void *ctx, const xmlChar *href, const xmlChar *prefix); void comment (void *ctx, const xmlChar *value); void cdataBlock (void *ctx, const xmlChar *value, int len); void xmlDefaultSAXHandlerInit (void); void htmlDefaultSAXHandlerInit (void); void sgmlDefaultSAXHandlerInit (void);
const xmlChar* getPublicId                  (void *ctx);
const xmlChar* getSystemId                  (void *ctx);
void setDocumentLocator (void *ctx, xmlSAXLocatorPtr loc);void internalSubset (void *ctx, const xmlChar *name, const xmlChar *ExternalID, const xmlChar *SystemID);void externalSubset (void *ctx, const xmlChar *name, const xmlChar *ExternalID, const xmlChar *SystemID);
xmlEntityPtr getEntity                      (void *ctx,
                                              const xmlChar *name);
xmlEntityPtr getParameterEntity             (void *ctx,
                                              const xmlChar *name);
xmlParserInputPtr resolveEntity             (void *ctx,
                                              const xmlChar *publicId,
                                              const xmlChar *systemId);
The entity loader, to control the loading of external entities, the application can either: - override this resolveEntity() callback in the SAX block - or better use the xmlSetExternalEntityLoader() function to set up it's own entity resolution routine

void entityDecl (void *ctx, const xmlChar *name, int type, const xmlChar *publicId, const xmlChar *systemId, xmlChar *content);void attributeDecl (void *ctx, const xmlChar *elem, const xmlChar *name, int type, int def, const xmlChar *defaultValue, xmlEnumerationPtr tree);void elementDecl (void *ctx, const xmlChar *name, int type, xmlElementContentPtr content);void notationDecl (void *ctx, const xmlChar *name, const xmlChar *publicId, const xmlChar *systemId);void unparsedEntityDecl (void *ctx, const xmlChar *name, const xmlChar *publicId, const xmlChar *systemId, const xmlChar *notationName);void attribute (void *ctx, const xmlChar *fullname, const xmlChar *value);void startElement (void *ctx, const xmlChar *fullname, const xmlChar **atts);void endElement (void *ctx, const xmlChar *name);void reference (void *ctx, const xmlChar *name);void characters (void *ctx, const xmlChar *ch, int len);void ignorableWhitespace (void *ctx, const xmlChar *ch, int len);void processingInstruction (void *ctx, const xmlChar *target, const xmlChar *data);void globalNamespace (void *ctx, const xmlChar *href, const xmlChar *prefix);void setNamespace (void *ctx, const xmlChar *name);
xmlNsPtr    getNamespace                    (void *ctx);
int checkNamespace (void *ctx, xmlChar *nameSpace);void namespaceDecl (void *ctx, const xmlChar *href, const xmlChar *prefix);void comment (void *ctx, const xmlChar *value);void cdataBlock (void *ctx, const xmlChar *value, int len);

tree

enum xmlElementType; typedef xmlChar; #define CHAR #define BAD_CAST struct xmlNotation; typedef xmlNotationPtr; enum xmlAttributeType; enum xmlAttributeDefault; struct xmlEnumeration; typedef xmlEnumerationPtr; struct xmlAttribute; typedef xmlAttributePtr; enum xmlElementContentType; enum xmlElementContentOccur; struct xmlElementContent; typedef xmlElementContentPtr; enum xmlElementTypeVal; struct xmlElement; typedef xmlElementPtr; #define XML_LOCAL_NAMESPACE typedef xmlNsType; struct xmlNs; typedef xmlNsPtr; struct xmlDtd; typedef xmlDtdPtr; struct xmlAttr; typedef xmlAttrPtr; struct xmlID; typedef xmlIDPtr; struct xmlRef; typedef xmlRefPtr; enum xmlBufferAllocationScheme; struct xmlBuffer; typedef xmlBufferPtr; struct xmlNode; typedef xmlNodePtr; struct xmlDoc; typedef xmlDocPtr; #define xmlChildrenNode #define xmlRootNode xmlBufferPtr xmlBufferCreate (void); xmlBufferPtr xmlBufferCreateSize (size_t size); void xmlBufferFree (xmlBufferPtr buf); int xmlBufferDump (FILE *file, xmlBufferPtr buf); void xmlBufferAdd (xmlBufferPtr buf, const xmlChar *str, int len); void xmlBufferAddHead (xmlBufferPtr buf, const xmlChar *str, int len); void xmlBufferCat (xmlBufferPtr buf, const xmlChar *str); void xmlBufferCCat (xmlBufferPtr buf, const char *str); int xmlBufferShrink (xmlBufferPtr buf, unsigned int len); int xmlBufferGrow (xmlBufferPtr buf, unsigned int len); void xmlBufferEmpty (xmlBufferPtr buf); const xmlChar* xmlBufferContent (const xmlBufferPtr buf); int xmlBufferUse (const xmlBufferPtr buf); void xmlBufferSetAllocationScheme (xmlBufferPtr buf, xmlBufferAllocationScheme scheme); int xmlBufferLength (const xmlBufferPtr buf); xmlDtdPtr xmlCreateIntSubset (xmlDocPtr doc, const xmlChar *name, const xmlChar *ExternalID, const xmlChar *SystemID); xmlDtdPtr xmlNewDtd (xmlDocPtr doc, const xmlChar *name, const xmlChar *ExternalID, const xmlChar *SystemID); xmlDtdPtr xmlGetIntSubset (xmlDocPtr doc); void xmlFreeDtd (xmlDtdPtr cur); xmlNsPtr xmlNewGlobalNs (xmlDocPtr doc, const xmlChar *href, const xmlChar *prefix); xmlNsPtr xmlNewNs (xmlNodePtr node, const xmlChar *href, const xmlChar *prefix); void xmlFreeNs (xmlNsPtr cur); xmlDocPtr xmlNewDoc (const xmlChar *version); void xmlFreeDoc (xmlDocPtr cur); xmlAttrPtr xmlNewDocProp (xmlDocPtr doc, const xmlChar *name, const xmlChar *value); xmlAttrPtr xmlNewProp (xmlNodePtr node, const xmlChar *name, const xmlChar *value); xmlAttrPtr xmlNewNsProp (xmlNodePtr node, xmlNsPtr ns, const xmlChar *name, const xmlChar *value); void xmlFreePropList (xmlAttrPtr cur); void xmlFreeProp (xmlAttrPtr cur); xmlAttrPtr xmlCopyProp (xmlNodePtr target, xmlAttrPtr cur); xmlAttrPtr xmlCopyPropList (xmlNodePtr target, xmlAttrPtr cur); xmlDtdPtr xmlCopyDtd (xmlDtdPtr dtd); xmlDocPtr xmlCopyDoc (xmlDocPtr doc, int recursive); xmlNodePtr xmlNewDocNode (xmlDocPtr doc, xmlNsPtr ns, const xmlChar *name, const xmlChar *content); xmlNodePtr xmlNewDocRawNode (xmlDocPtr doc, xmlNsPtr ns, const xmlChar *name, const xmlChar *content); xmlNodePtr xmlNewNode (xmlNsPtr ns, const xmlChar *name); xmlNodePtr xmlNewChild (xmlNodePtr parent, xmlNsPtr ns, const xmlChar *name, const xmlChar *content); xmlNodePtr xmlNewTextChild (xmlNodePtr parent, xmlNsPtr ns, const xmlChar *name, const xmlChar *content); xmlNodePtr xmlNewDocText (xmlDocPtr doc, const xmlChar *content); xmlNodePtr xmlNewText (const xmlChar *content); xmlNodePtr xmlNewPI (const xmlChar *name, const xmlChar *content); xmlNodePtr xmlNewDocTextLen (xmlDocPtr doc, const xmlChar *content, int len); xmlNodePtr xmlNewTextLen (const xmlChar *content, int len); xmlNodePtr xmlNewDocComment (xmlDocPtr doc, const xmlChar *content); xmlNodePtr xmlNewComment (const xmlChar *content); xmlNodePtr xmlNewCDataBlock (xmlDocPtr doc, const xmlChar *content, int len); xmlNodePtr xmlNewCharRef (xmlDocPtr doc, const xmlChar *name); xmlNodePtr xmlNewReference (xmlDocPtr doc, const xmlChar *name); xmlNodePtr xmlCopyNode (xmlNodePtr node, int recursive); xmlNodePtr xmlCopyNodeList (xmlNodePtr node); xmlNodePtr xmlNewDocFragment (xmlDocPtr doc); xmlNodePtr xmlDocGetRootElement (xmlDocPtr doc); xmlNodePtr xmlGetLastChild (xmlNodePtr parent); int xmlNodeIsText (xmlNodePtr node); int xmlIsBlankNode (xmlNodePtr node); xmlNodePtr xmlDocSetRootElement (xmlDocPtr doc, xmlNodePtr root); void xmlNodeSetName (xmlNodePtr cur, const xmlChar *name); xmlNodePtr xmlAddChild (xmlNodePtr parent, xmlNodePtr cur); xmlNodePtr xmlAddChildList (xmlNodePtr parent, xmlNodePtr cur); xmlNodePtr xmlReplaceNode (xmlNodePtr old, xmlNodePtr cur); xmlNodePtr xmlAddSibling (xmlNodePtr cur, xmlNodePtr elem); xmlNodePtr xmlAddPrevSibling (xmlNodePtr cur, xmlNodePtr elem); xmlNodePtr xmlAddNextSibling (xmlNodePtr cur, xmlNodePtr elem); void xmlUnlinkNode (xmlNodePtr cur); xmlNodePtr xmlTextMerge (xmlNodePtr first, xmlNodePtr second); void xmlTextConcat (xmlNodePtr node, const xmlChar *content, int len); void xmlFreeNodeList (xmlNodePtr cur); void xmlFreeNode (xmlNodePtr cur); void xmlSetTreeDoc (xmlNodePtr tree, xmlDocPtr doc); void xmlSetListDoc (xmlNodePtr list, xmlDocPtr doc); xmlNsPtr xmlSearchNs (xmlDocPtr doc, xmlNodePtr node, const xmlChar *nameSpace); xmlNsPtr xmlSearchNsByHref (xmlDocPtr doc, xmlNodePtr node, const xmlChar *href); xmlNsPtr* xmlGetNsList (xmlDocPtr doc, xmlNodePtr node); void xmlSetNs (xmlNodePtr node, xmlNsPtr ns); xmlNsPtr xmlCopyNamespace (xmlNsPtr cur); xmlNsPtr xmlCopyNamespaceList (xmlNsPtr cur); xmlAttrPtr xmlSetProp (xmlNodePtr node, const xmlChar *name, const xmlChar *value); xmlChar* xmlGetProp (xmlNodePtr node, const xmlChar *name); xmlAttrPtr xmlHasProp (xmlNodePtr node, const xmlChar *name); xmlChar* xmlGetNsPropxmlAttrPtr xmlSetNsProp (xmlNodePtr node, + xmlNsPtr ns, const xmlChar *name, const xmlChar *value); +xmlChar* xmlGetNsProp (xmlNodePtr node, + const xmlChar *name, + const xmlChar *nameSpace); xmlNodePtr xmlStringGetNodeList (xmlDocPtr doc, const xmlChar *value); xmlNodePtr xmlStringLenGetNodeList (xmlDocPtr doc, const xmlChar *value, int len); xmlChar* xmlNodeListGetString (xmlDocPtr doc, xmlNodePtr list, int inLine); xmlChar* xmlNodeListGetRawString (xmlDocPtr doc, xmlNodePtr list, int inLine); void xmlNodeSetContent (xmlNodePtr cur, const xmlChar *content); void xmlNodeSetContentLen (xmlNodePtr cur, const xmlChar *content, int len); void xmlNodeAddContent (xmlNodePtr cur, const xmlChar *content); void xmlNodeAddContentLen (xmlNodePtr cur, const xmlChar *content, int len); xmlChar* xmlNodeGetContent (xmlNodePtr cur); xmlChar* xmlNodeGetLang (xmlNodePtr cur); void xmlNodeSetLang (xmlNodePtr cur, const xmlChar *lang); int xmlNodeGetSpacePreserve (xmlNodePtr cur); void xmlNodeSetSpacePreserve (xmlNodePtr cur, intval); xmlChar* xmlNodeGetBase (xmlDocPtr doc, xmlNodePtr cur); void xmlNodeSetBase (xmlNodePtr cur, xmlChar *uri); int xmlRemoveProp (xmlAttrPtr attr); int xmlRemoveNode (xmlNodePtr node); void xmlBufferWriteXmlCHAR (xmlBufferPtr buf, const xmlChar *string); void xmlBufferWriteCHAR (xmlBufferPtr buf, const xmlChar *string); void xmlBufferWriteChar (xmlBufferPtr buf, const char *string); void xmlBufferWriteQuotedString (xmlBufferPtr buf, const xmlChar *string); int xmlReconciliateNs (xmlDocPtr doc, xmlNodePtr tree); void xmlDocDumpFormatMemory (xmlDocPtr cur, xmlChar **mem, int *size, int format); void xmlDocDumpMemory (xmlDocPtr cur, xmlChar **mem, int *size); void xmlDocDumpMemoryEnc (xmlDocPtr out_doc, xmlChar **doc_txt_ptr, int *doc_txt_len, const char *txt_encoding); void xmlDocDumpFormatMemoryEnc (xmlDocPtr out_doc, xmlChar **doc_txt_ptr, int *doc_txt_len, const char *txt_encoding, int format); int xmlDocDump (FILE *f, xmlDocPtr cur); void xmlElemDump (FILE *f, xmlDocPtr doc, xmlNodePtr cur); int xmlSaveFile (const char *filename, xmlDocPtr cur); void xmlNodeDump (xmlBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur, int level, int format); int xmlSaveFileEnc (const char *filename, xmlDocPtr cur, const char *encoding); int xmlGetDocCompressMode (xmlDocPtr doc); void xmlSetDocCompressMode (xmlDocPtr doc, int mode); int xmlGetCompressMode (void); void xmlSetCompressMode (int mode);

Description

Details

xmlBufferPtr xmlBufferCreate                (void);

xmlBufferPtr xmlBufferCreateSize            (
void        xmlBufferFree                   (xmlBufferPtr buf);
FILE *file,
                                              xmlBufferPtr buf);

void        xmlBufferAdd                    (xmlBufferPtr buf,
                                              const xmlChar *str,
                                              int len);

void        xmlBufferAddHead                (xmlBufferPtr buf,
                                              const xmlChar *str,
                                              int len);

void        xmlBufferCat                    (xmlBufferPtr buf,
                                              const xmlChar *str);

void        xmlBufferCCat                   (xmlBufferPtr buf,
                                              const char *str);

int         xmlBufferShrink                 (xmlBufferPtr buf,
                                              unsigned int len);

int         xmlBufferGrow                   (xmlBufferPtr buf,
                                              unsigned int len);

void        xmlBufferEmpty                  (xmlBufferPtr buf);

const xmlChar* xmlBufferContent             (const xmlBufferPtr buf);

int         xmlBufferUse                    (const xmlBufferPtr buf);

void        xmlBufferSetAllocationScheme    (xmlBufferPtr buf,
                                              xmlBufferAllocationScheme scheme);

int         xmlBufferLength                 (const xmlBufferPtr buf);

xmlDtdPtr   xmlCreateIntSubset              (xmlDocPtr doc,
                                              const xmlChar *name,
                                              const xmlChar *ExternalID,
                                              const xmlChar *SystemID);

xmlDtdPtr   xmlNewDtd                       (xmlDocPtr doc,
                                              const xmlChar *name,
                                              const xmlChar *ExternalID,
                                              const xmlChar *SystemID);

Creation of a new DTD for the external subset. To create an internal subset, use xmlCreateIntSubset().

xmlDtdPtr   xmlGetIntSubset                 (xmlDocPtr doc);

void        xmlFreeDtd                      (xmlDtdPtr cur);

xmlNsPtr    xmlNewGlobalNs                  (xmlDocPtr doc,
                                              const xmlChar *href,
                                              const xmlChar *prefix);

xmlNsPtr    xmlNewNs                        (xmlNodePtr node,
                                              const xmlChar *href,
                                              const xmlChar *prefix);

void        xmlFreeNs                       (xmlNsPtr cur);

xmlDocPtr   xmlNewDoc                       (const xmlChar *version);

void        xmlFreeDoc                      (xmlDocPtr cur);

xmlAttrPtr  xmlNewDocProp                   (xmlDocPtr doc,
                                              const xmlChar *name,
                                              const xmlChar *value);

xmlAttrPtr  xmlNewProp                      (xmlNodePtr node,
                                              const xmlChar *name,
                                              const xmlChar *value);

xmlAttrPtr  xmlNewNsProp                    (xmlNodePtr node,
                                              xmlNsPtr ns,
                                              const xmlChar *name,
                                              const xmlChar *value);

void        xmlFreePropList                 (xmlAttrPtr cur);

void        xmlFreeProp                     (xmlAttrPtr cur);

xmlAttrPtr  xmlCopyProp                     (xmlNodePtr target,
                                              xmlAttrPtr cur);

xmlAttrPtr  xmlCopyPropList                 (xmlNodePtr target,
                                              xmlAttrPtr cur);

xmlDtdPtr   xmlCopyDtd                      (xmlDtdPtr dtd);

xmlDocPtr   xmlCopyDoc                      (xmlDocPtr doc,
                                              int recursive);

xmlNodePtr  xmlNewDocNode                   (xmlDocPtr doc,
                                              xmlNsPtr ns,
                                              const xmlChar *name,
                                              const xmlChar *content);
is supposed to be a piece of XML CDATA, so it allow entities references, but XML special chars need to be escaped first by using xmlEncodeEntitiesReentrant(). Use xmlNewDocRawNode() if you don't need entities support.

xmlNodePtr  xmlNewDocRawNode                (xmlDocPtr doc,
                                              xmlNsPtr ns,
                                              const xmlChar *name,
                                              const xmlChar *content);

xmlNodePtr  xmlNewNode                      (xmlNsPtr ns,
                                              const xmlChar *name);

xmlNodePtr  xmlNewChild                     (xmlNodePtr parent,
                                              xmlNsPtr ns,
                                              const xmlChar *name,
                                              const xmlChar *content);
is supposed to be a piece of XML CDATA, so it allow entities references, but XML special chars need to be escaped first by using xmlEncodeEntitiesReentrant(). Use xmlNewTextChild() if entities support is not needed.

xmlNodePtr  xmlNewTextChild                 (xmlNodePtr parent,
                                              xmlNsPtr ns,
                                              const xmlChar *name,
                                              const xmlChar *content);

xmlNodePtr  xmlNewDocText                   (xmlDocPtr doc,
                                              const xmlChar *content);

xmlNodePtr  xmlNewText                      (const xmlChar *content);

xmlNodePtr  xmlNewPI                        (const xmlChar *name,
                                              const xmlChar *content);

xmlNodePtr  xmlNewDocTextLen                (xmlDocPtr doc,
                                              const xmlChar *content,
                                              int len);

xmlNodePtr  xmlNewTextLen                   (const xmlChar *content,
                                              int len);

xmlNodePtr  xmlNewDocComment                (xmlDocPtr doc,
                                              const xmlChar *content);

xmlNodePtr  xmlNewComment                   (const xmlChar *content);

xmlNodePtr  xmlNewCDataBlock                (xmlDocPtr doc,
                                              const xmlChar *content,
                                              int len);

xmlNodePtr  xmlNewCharRef                   (xmlDocPtr doc,
                                              const xmlChar *name);

xmlNodePtr  xmlNewReference                 (xmlDocPtr doc,
                                              const xmlChar *name);

xmlNodePtr  xmlCopyNode                     (xmlNodePtr node,
                                              int recursive);

xmlNodePtr  xmlCopyNodeList                 (xmlNodePtr node);

xmlNodePtr  xmlNewDocFragment               (xmlDocPtr doc);

xmlNodePtr  xmlDocGetRootElement            (xmlDocPtr doc);

xmlNodePtr  xmlGetLastChild                 (xmlNodePtr parent);

int         xmlNodeIsText                   (xmlNodePtr node);

int         xmlIsBlankNode                  (xmlNodePtr node);

xmlNodePtr  xmlDocSetRootElement            (xmlDocPtr doc,
                                              xmlNodePtr root);

void        xmlNodeSetName                  (xmlNodePtr cur,
                                              const xmlChar *name);

xmlNodePtr  xmlAddChild                     (xmlNodePtr parent,
                                              xmlNodePtr cur);

xmlNodePtr  xmlAddChildList                 (xmlNodePtr parent,
                                              xmlNodePtr cur);

xmlNodePtr  xmlReplaceNode                  (xmlNodePtr old,
                                              xmlNodePtr cur);

xmlNodePtr  xmlAddSibling                   (xmlNodePtr cur,
                                              xmlNodePtr elem);

xmlNodePtr  xmlAddPrevSibling               (xmlNodePtr cur,
                                              xmlNodePtr elem);

xmlNodePtr  xmlAddNextSibling               (xmlNodePtr cur,
                                              xmlNodePtr elem);

void        xmlUnlinkNode                   (xmlNodePtr cur);

xmlNodePtr  xmlTextMerge                    (xmlNodePtr first,
                                              xmlNodePtr second);

void        xmlTextConcat                   (xmlNodePtr node,
                                              const xmlChar *content,
                                              int len);

void        xmlFreeNodeList                 (xmlNodePtr cur);

void        xmlFreeNode                     (xmlNodePtr cur);

Free a node, this is a recursive behaviour, all the children are freed too. This doesn't unlink the child from the list, use xmlUnlinkNode() first.

void        xmlSetTreeDoc                   (xmlNodePtr tree,
                                              xmlDocPtr doc);

void        xmlSetListDoc                   (xmlNodePtr list,
                                              xmlDocPtr doc);

xmlNsPtr    xmlSearchNs                     (xmlDocPtr doc,
                                              xmlNodePtr node,
                                              const xmlChar *nameSpace);

xmlNsPtr    xmlSearchNsByHref               (xmlDocPtr doc,
                                              xmlNodePtr node,
                                              const xmlChar *href);

xmlNsPtr*   xmlGetNsList                    (xmlDocPtr doc,
                                              xmlNodePtr node);

void        xmlSetNs                        (xmlNodePtr node,
                                              xmlNsPtr ns);

xmlNsPtr    xmlCopyNamespace                (xmlNsPtr cur);

xmlNsPtr    xmlCopyNamespaceList            (xmlNsPtr cur);

xmlAttrPtr  xmlSetProp                      (xmlNodePtr node,
                                              const xmlChar *name,
                                              const xmlChar *value);

xmlChar*    xmlGetProp                      (xmlNodePtr node,
                                              const xmlChar *name);

xmlAttrPtr  xmlHasProp                      (xmlNodePtr node,
                                              const xmlChar *name);

xmlSetNsProp ()

xmlAttrPtr  xmlSetNsProp                    (xmlNodePtr node,
+                                             xmlNsPtr ns,
+                                             const xmlChar *name,
+                                             const xmlChar *value);

Set (or reset) an attribute carried by a node. +The ns structure must be in scope, this is not checked.

node : the node
ns : the namespace definition
name : the attribute name
value : the attribute value
Returns :the attribute pointer.

xmlChar*    xmlGetNsProp                    (xmlNodePtr node,
                                              const xmlChar *name,
                                              const xmlChar *nameSpace);

xmlNodePtr  xmlStringGetNodeList            (xmlDocPtr doc,
                                              const xmlChar *value);

xmlNodePtr  xmlStringLenGetNodeList         (xmlDocPtr doc,
                                              const xmlChar *value,
                                              int len);

xmlChar*    xmlNodeListGetString            (xmlDocPtr doc,
                                              xmlNodePtr list,
                                              int inLine);

xmlChar*    xmlNodeListGetRawString         (xmlDocPtr doc,
                                              xmlNodePtr list,
                                              int inLine);

Returns the string equivalent to the text contained in the Node list made of TEXTs and ENTITY_REFs, contrary to xmlNodeListGetString() this function doesn't do any character encoding handling.

void        xmlNodeSetContent               (xmlNodePtr cur,
                                              const xmlChar *content);

void        xmlNodeSetContentLen            (xmlNodePtr cur,
                                              const xmlChar *content,
                                              int len);

void        xmlNodeAddContent               (xmlNodePtr cur,
                                              const xmlChar *content);

void        xmlNodeAddContentLen            (xmlNodePtr cur,
                                              const xmlChar *content,
                                              int len);

xmlChar*    xmlNodeGetContent               (xmlNodePtr cur);

xmlChar*    xmlNodeGetLang                  (xmlNodePtr cur);

void        xmlNodeSetLang                  (xmlNodePtr cur,
                                              const xmlChar *lang);

int         xmlNodeGetSpacePreserve         (xmlNodePtr cur);

void        xmlNodeSetSpacePreserve         (xmlNodePtr cur,
                                              
xmlChar*    xmlNodeGetBase                  (xmlDocPtr doc,
                                              xmlNodePtr cur);
void        xmlNodeSetBase                  (xmlNodePtr cur,
                                              xmlChar *uri);
int         xmlRemoveProp                   (xmlAttrPtr attr);
int         xmlRemoveNode                   (xmlNodePtr node);
void        xmlBufferWriteXmlCHAR           (xmlBufferPtr buf,
                                              const xmlChar *string);
void        xmlBufferWriteCHAR              (xmlBufferPtr buf,
                                              const xmlChar *string);
void        xmlBufferWriteChar              (xmlBufferPtr buf,
                                              const char *string);
void        xmlBufferWriteQuotedString      (xmlBufferPtr buf,
                                              const xmlChar *string);
int         xmlReconciliateNs               (xmlDocPtr doc,
                                              xmlNodePtr tree);
void        xmlDocDumpFormatMemory          (xmlDocPtr cur,
                                              xmlChar **mem,
                                              int *size,
@@ -13080,7 +13247,7 @@ VALIGN="TOP"
 >
void        xmlDocDumpMemory                (xmlDocPtr cur,
                                              xmlChar **mem,
                                              int *size);
void        xmlDocDumpMemoryEnc             (xmlDocPtr out_doc,
                                              xmlChar **doc_txt_ptr,
                                              int *doc_txt_len,
@@ -13305,7 +13472,7 @@ VALIGN="TOP"
 >
void        xmlDocDumpFormatMemoryEnc       (xmlDocPtr out_doc,
                                              xmlChar **doc_txt_ptr,
                                              int *doc_txt_len,
@@ -13441,7 +13608,7 @@ VALIGN="TOP"
 >
FILE *f,
                                              xmlDocPtr cur);
FILE *f,
                                              xmlDocPtr doc,
                                              xmlNodePtr cur);
int         xmlSaveFile                     (const char *filename,
                                              xmlDocPtr cur);
void        xmlNodeDump                     (xmlBufferPtr buf,
                                              xmlDocPtr doc,
                                              xmlNodePtr cur,
                                              int level,
@@ -13889,7 +14056,7 @@ VALIGN="TOP"
 >
int         xmlSaveFileEnc                  (const char *filename,
                                              xmlDocPtr cur,
                                              const char *encoding);
int         xmlGetDocCompressMode           (xmlDocPtr doc);
void        xmlSetDocCompressMode           (xmlDocPtr doc,
                                              int mode);
uri
Name
Synopsis

 
 struct      xmlURI;
 typedef     xmlURIPtr;
 xmlURIPtr   xmlCreateURI                    (void);
 xmlChar*    xmlBuildURI                     (const xmlChar *URI,
                                              const xmlChar *base);
 xmlURIPtr   xmlParseURI                     (const char *URI);
 int         xmlParseURIReference            (xmlURIPtr uri,
                                              const char *str);
 xmlChar*    xmlSaveUri                      (xmlURIPtr uri);
 void        xmlPrintURI                     (FILE *stream,
                                              xmlURIPtr uri);
 char*       xmlURIUnescapeString            (const char *str,
                                              int len,
                                              char *target);
 int         xmlNormalizeURIPath             (char *path);
 xmlChar*    xmlURIEscape                    (const xmlChar *str);
 void        xmlFreeURI                      (xmlURIPtr uri);

Description

Details

xmlURIPtr   xmlCreateURI                    (void);

xmlChar*    xmlBuildURI                     (const xmlChar *URI,
                                              const xmlChar *base);

xmlURIPtr   xmlParseURI                     (const char *URI);

int         xmlParseURIReference            (xmlURIPtr uri,
                                              const char *str);

xmlChar*    xmlSaveUri                      (xmlURIPtr uri);

FILE *stream, xmlURIPtr uri);

xmlChar*    xmlURIEscape                    (const xmlChar *str);

void        xmlFreeURI                      (xmlURIPtr uri);

valid

Name

Synopsis

void (*xmlValidityErrorFunc) (void *ctx, const char *msg, ...); void (*xmlValidityWarningFunc) (void *ctx, const char *msg, ...); struct xmlValidCtxt; typedef xmlValidCtxtPtr; typedef xmlNotationTablePtr; typedef xmlElementTablePtr; typedef xmlAttributeTablePtr; typedef xmlIDTablePtr; typedef xmlRefTablePtr; xmlChar* xmlSplitQName2 (const xmlChar *name, + xmlChar **prefix); +xmlNotationPtr xmlAddNotationDecl (xmlValidCtxtPtr ctxt, xmlDtdPtr dtd, const xmlChar *name, const xmlChar *PublicID, const xmlChar *SystemID); xmlNotationTablePtr xmlCopyNotationTable (xmlNotationTablePtr table); void xmlFreeNotationTable (xmlNotationTablePtr table); void xmlDumpNotationDecl (xmlBufferPtr buf, xmlNotationPtr nota); void xmlDumpNotationTable (xmlBufferPtr buf, xmlNotationTablePtr table); xmlElementContentPtr xmlNewElementContent (xmlChar *name, xmlElementContentType type); xmlElementContentPtr xmlCopyElementContent (xmlElementContentPtr content); void xmlFreeElementContent (xmlElementContentPtr cur); void xmlSprintfElementContent (char *buf, xmlElementContentPtr content, int glob); xmlElementPtr xmlAddElementDecl (xmlValidCtxtPtr ctxt, xmlDtdPtr dtd, const xmlChar *name, xmlElementTypeVal type, xmlElementContentPtr content); xmlElementTablePtr xmlCopyElementTable (xmlElementTablePtr table); void xmlFreeElementTable (xmlElementTablePtr table); void xmlDumpElementTable (xmlBufferPtr buf, xmlElementTablePtr table); void xmlDumpElementDecl (xmlBufferPtr buf, xmlElementPtr elem); xmlEnumerationPtr xmlCreateEnumeration (xmlChar *name); void xmlFreeEnumeration (xmlEnumerationPtr cur); xmlEnumerationPtr xmlCopyEnumeration (xmlEnumerationPtr cur); xmlAttributePtr xmlAddAttributeDecl (xmlValidCtxtPtr ctxt, xmlDtdPtr dtd, const xmlChar *elem, const xmlChar *name, const xmlChar *ns, xmlAttributeType type, xmlAttributeDefault def, const xmlChar *defaultValue, xmlEnumerationPtr tree); xmlAttributeTablePtr xmlCopyAttributeTable (xmlAttributeTablePtr table); void xmlFreeAttributeTable (xmlAttributeTablePtr table); void xmlDumpAttributeTable (xmlBufferPtr buf, xmlAttributeTablePtr table); void xmlDumpAttributeDecl (xmlBufferPtr buf, xmlAttributePtr attr); xmlIDPtr xmlAddID (xmlValidCtxtPtr ctxt, xmlDocPtr doc, const xmlChar *value, xmlAttrPtr attr); xmlIDTablePtr xmlCopyIDTable (xmlIDTablePtr table); void xmlFreeIDTable (xmlIDTablePtr table); xmlAttrPtr xmlGetID (xmlDocPtr doc, const xmlChar *ID); int xmlIsID (xmlDocPtr doc, xmlNodePtr elem, xmlAttrPtr attr); int xmlRemoveID (xmlDocPtr doc, xmlAttrPtr attr); xmlRefPtr xmlAddRef (xmlValidCtxtPtr ctxt, xmlDocPtr doc, const xmlChar *value, xmlAttrPtr attr); xmlRefTablePtr xmlCopyRefTable (xmlRefTablePtr table); void xmlFreeRefTable (xmlRefTablePtr table); int xmlIsRef (xmlDocPtr doc, xmlNodePtr elem, xmlAttrPtr attr); int xmlRemoveRef (xmlDocPtr doc, xmlAttrPtr attr); int xmlValidateRoot (xmlValidCtxtPtr ctxt, xmlDocPtr doc); int xmlValidateElementDecl (xmlValidCtxtPtr ctxt, xmlDocPtr doc, xmlElementPtr elem); xmlChar* xmlValidNormalizeAttributeValue (xmlDocPtr doc, xmlNodePtr elem, const xmlChar *name, const xmlChar *value); int xmlValidateAttributeDecl (xmlValidCtxtPtr ctxt, xmlDocPtr doc, xmlAttributePtr attr); int xmlValidateAttributeValue (xmlAttributeType type, const xmlChar *value); int xmlValidateNotationDecl (xmlValidCtxtPtr ctxt, xmlDocPtr doc, xmlNotationPtr nota); int xmlValidateDtd (xmlValidCtxtPtr ctxt, xmlDocPtr doc, xmlDtdPtr dtd); int xmlValidateDtdFinal (xmlValidCtxtPtr ctxt, xmlDocPtr doc); int xmlValidateDocument (xmlValidCtxtPtr ctxt, xmlDocPtr doc); int xmlValidateElement (xmlValidCtxtPtr ctxt, xmlDocPtr doc, xmlNodePtr elem); int xmlValidateOneElement (xmlValidCtxtPtr ctxt, xmlDocPtr doc, xmlNodePtr elem); int xmlValidateOneAttribute (xmlValidCtxtPtr ctxt, xmlDocPtr doc, xmlNodePtr elem, xmlAttrPtr attr, const xmlChar *value); int xmlValidateDocumentFinal (xmlValidCtxtPtr ctxt, xmlDocPtr doc); int xmlValidateNotationUse (xmlValidCtxtPtr ctxt, xmlDocPtr doc, const xmlChar *notationName); int xmlIsMixedElement (xmlDocPtr doc, const xmlChar *name); xmlAttributePtr xmlGetDtdAttrDesc (xmlDtdPtr dtd, const xmlChar *elem, const xmlChar *name); xmlNotationPtr xmlGetDtdNotationDesc (xmlDtdPtr dtd, const xmlChar *name); xmlElementPtr xmlGetDtdElementDesc (xmlDtdPtr dtd, const xmlChar *name); int xmlValidGetValidElements (xmlNode *prev, xmlNode *next, const xmlChar **list, int max); int xmlValidGetPotentialChildren (xmlElementContent *ctree, const xmlChar **list, int *len, @@ -904,7 +918,7 @@ HREF="gnome-xml-tree.html#XMLCHAR" >

Description

Details

xmlSplitQName2 ()

xmlChar*    xmlSplitQName2                  (const xmlChar *name,
+                                             xmlChar **prefix);

parse an XML qualified name string

[NS 5] QName ::= (Prefix ':')? LocalPart

[NS 6] Prefix ::= NCName

[NS 7] LocalPart ::= NCName

name : an XML parser context
prefix : a xmlChar **
Returns :NULL if not a QName, otherwise the local part, and prefix +is updated to get the Prefix if any.

xmlNotationPtr xmlAddNotationDecl           (xmlValidCtxtPtr ctxt,
                                              xmlDtdPtr dtd,
                                              const xmlChar *name,
                                              const xmlChar *PublicID,
                                              const xmlChar *SystemID);

xmlNotationTablePtr xmlCopyNotationTable    (xmlNotationTablePtr table);

void        xmlFreeNotationTable            (xmlNotationTablePtr table);

void        xmlDumpNotationDecl             (xmlBufferPtr buf,
                                              xmlNotationPtr nota);

void        xmlDumpNotationTable            (xmlBufferPtr buf,
                                              xmlNotationTablePtr table);

xmlElementContentPtr xmlNewElementContent   (xmlChar *name,
                                              xmlElementContentType type);

xmlElementContentPtr xmlCopyElementContent  (xmlElementContentPtr content);

void        xmlFreeElementContent           (xmlElementContentPtr cur);

void xmlSprintfElementContent (char *buf, xmlElementContentPtr content, int glob);

xmlElementPtr xmlAddElementDecl             (xmlValidCtxtPtr ctxt,
                                              xmlDtdPtr dtd,
                                              const xmlChar *name,
                                              xmlElementTypeVal type,
                                              xmlElementContentPtr content);

xmlElementTablePtr xmlCopyElementTable      (xmlElementTablePtr table);

void        xmlFreeElementTable             (xmlElementTablePtr table);

void        xmlDumpElementTable             (xmlBufferPtr buf,
                                              xmlElementTablePtr table);

void        xmlDumpElementDecl              (xmlBufferPtr buf,
                                              xmlElementPtr elem);

xmlEnumerationPtr xmlCreateEnumeration      (xmlChar *name);

void        xmlFreeEnumeration              (xmlEnumerationPtr cur);

xmlEnumerationPtr xmlCopyEnumeration        (xmlEnumerationPtr cur);

xmlAttributePtr xmlAddAttributeDecl         (xmlValidCtxtPtr ctxt,
                                              xmlDtdPtr dtd,
                                              const xmlChar *elem,
                                              const xmlChar *name,
                                              const xmlChar *ns,
                                              xmlAttributeType type,
                                              xmlAttributeDefault def,
                                              const xmlChar *defaultValue,
                                              xmlEnumerationPtr tree);

xmlAttributeTablePtr xmlCopyAttributeTable  (xmlAttributeTablePtr table);

void        xmlFreeAttributeTable           (xmlAttributeTablePtr table);

void        xmlDumpAttributeTable           (xmlBufferPtr buf,
                                              xmlAttributeTablePtr table);

void        xmlDumpAttributeDecl            (xmlBufferPtr buf,
                                              xmlAttributePtr attr);

xmlIDPtr    xmlAddID                        (xmlValidCtxtPtr ctxt,
                                              xmlDocPtr doc,
                                              const xmlChar *value,
                                              xmlAttrPtr attr);

xmlIDTablePtr xmlCopyIDTable                (xmlIDTablePtr table);

void        xmlFreeIDTable                  (xmlIDTablePtr table);

xmlAttrPtr  xmlGetID                        (xmlDocPtr doc,
                                              const xmlChar *ID);

int         xmlIsID                         (xmlDocPtr doc,
                                              xmlNodePtr elem,
                                              xmlAttrPtr attr);

int         xmlRemoveID                     (xmlDocPtr doc,
                                              xmlAttrPtr attr);

xmlRefPtr   xmlAddRef                       (xmlValidCtxtPtr ctxt,
                                              xmlDocPtr doc,
                                              const xmlChar *value,
                                              xmlAttrPtr attr);

xmlRefTablePtr xmlCopyRefTable              (xmlRefTablePtr table);

void        xmlFreeRefTable                 (xmlRefTablePtr table);

int         xmlIsRef                        (xmlDocPtr doc,
                                              xmlNodePtr elem,
                                              xmlAttrPtr attr);

int         xmlRemoveRef                    (xmlDocPtr doc,
                                              xmlAttrPtr attr);

int         xmlValidateRoot                 (xmlValidCtxtPtr ctxt,
                                              xmlDocPtr doc);

int         xmlValidateElementDecl          (xmlValidCtxtPtr ctxt,
                                              xmlDocPtr doc,
                                              xmlElementPtr elem);

xmlChar*    xmlValidNormalizeAttributeValue (xmlDocPtr doc,
                                              xmlNodePtr elem,
                                              const xmlChar *name,
                                              const xmlChar *value);

int         xmlValidateAttributeDecl        (xmlValidCtxtPtr ctxt,
                                              xmlDocPtr doc,
                                              xmlAttributePtr attr);

int         xmlValidateAttributeValue       (xmlAttributeType type,
                                              const xmlChar *value);

int         xmlValidateNotationDecl         (xmlValidCtxtPtr ctxt,
                                              xmlDocPtr doc,
                                              xmlNotationPtr nota);

int         xmlValidateDtd                  (xmlValidCtxtPtr ctxt,
                                              xmlDocPtr doc,
                                              xmlDtdPtr dtd);

int         xmlValidateDtdFinal             (xmlValidCtxtPtr ctxt,
                                              xmlDocPtr doc);

int         xmlValidateDocument             (xmlValidCtxtPtr ctxt,
                                              xmlDocPtr doc);

int         xmlValidateElement              (xmlValidCtxtPtr ctxt,
                                              xmlDocPtr doc,
                                              xmlNodePtr elem);

int         xmlValidateOneElement           (xmlValidCtxtPtr ctxt,
                                              xmlDocPtr doc,
                                              xmlNodePtr elem);
xmlValidateOneAttribute() for each attribute present.

int         xmlValidateOneAttribute         (xmlValidCtxtPtr ctxt,
                                              xmlDocPtr doc,
                                              xmlNodePtr elem,
                                              xmlAttrPtr attr,
                                              const xmlChar *value);

int         xmlValidateDocumentFinal        (xmlValidCtxtPtr ctxt,
                                              xmlDocPtr doc);

int         xmlValidateNotationUse          (xmlValidCtxtPtr ctxt,
                                              xmlDocPtr doc,
                                              const xmlChar *notationName);

int         xmlIsMixedElement               (xmlDocPtr doc,
                                              const xmlChar *name);

xmlAttributePtr xmlGetDtdAttrDesc           (xmlDtdPtr dtd,
                                              const xmlChar *elem,
                                              const xmlChar *name);

xmlNotationPtr xmlGetDtdNotationDesc        (xmlDtdPtr dtd,
                                              const xmlChar *name);

xmlElementPtr xmlGetDtdElementDesc          (xmlDtdPtr dtd,
                                              const xmlChar *name);

int         xmlValidGetValidElements        (xmlNode *prev,
                                              xmlNode *next,
                                              const xmlChar **list,
                                              int max);

int         xmlValidGetPotentialChildren    (xmlElementContent *ctree,
                                              const xmlChar **list,
                                              int *len,
@@ -6990,7 +7113,7 @@ WIDTH="25%"
 BGCOLOR="#C00000"
 ALIGN="left"
 >

xinclude

Name

Synopsis

int xmlXIncludeProcess (xmlDocPtr doc);

Description

Details

int         xmlXIncludeProcess              (xmlDocPtr doc);

xmlIO

Name

Synopsis

int (*xmlInputMatchCallback) (char const *filename); void* (*xmlInputOpenCallback) (char const *filename); int (*xmlInputReadCallback) (void *context, char *buffer, int len); void (*xmlInputCloseCallback) (void *context); struct xmlParserInputBuffer; typedef xmlParserInputBufferPtr; int (*xmlOutputMatchCallback) (char const *filename); void* (*xmlOutputOpenCallback) (char const *filename); int (*xmlOutputWriteCallback) (void *context, const char *buffer, int len); void (*xmlOutputCloseCallback) (void *context); struct xmlOutputBuffer; typedef xmlOutputBufferPtr; void xmlRegisterDefaultInputCallbacks (void); xmlParserInputBufferPtr xmlAllocParserInputBuffer (xmlCharEncoding enc); xmlParserInputBufferPtr xmlParserInputBufferCreateFname (const char *URI, xmlCharEncoding enc); xmlParserInputBufferPtr xmlParserInputBufferCreateFilename (const char *URI, xmlCharEncoding enc); xmlParserInputBufferPtr xmlParserInputBufferCreateFile (FILE *file, xmlCharEncoding enc); xmlParserInputBufferPtr xmlParserInputBufferCreateFd (int fd, xmlCharEncoding enc); xmlParserInputBufferPtr xmlParserInputBufferCreateMem (const char *mem, int size, xmlCharEncoding enc); xmlParserInputBufferPtr xmlParserInputBufferCreateIO (xmlInputReadCallback ioread, xmlInputCloseCallback ioclose, void *ioctx, xmlCharEncoding enc); int xmlParserInputBufferRead (xmlParserInputBufferPtr in, int len); int xmlParserInputBufferGrow (xmlParserInputBufferPtr in, int len); int xmlParserInputBufferPush (xmlParserInputBufferPtr in, int len, const char *buf); void xmlFreeParserInputBuffer (xmlParserInputBufferPtr in); char* xmlParserGetDirectory (const char *filename); int xmlRegisterInputCallbacks (xmlInputMatchCallback match, xmlInputOpenCallback open, xmlInputReadCallback read, xmlInputCloseCallback close); void xmlRegisterDefaultOutputCallbacks (void); xmlOutputBufferPtr xmlAllocOutputBuffer (xmlCharEncodingHandlerPtr encoder); xmlOutputBufferPtr xmlOutputBufferCreateFilename (const char *URI, xmlCharEncodingHandlerPtr encoder, int compression); xmlOutputBufferPtr xmlOutputBufferCreateFile (FILE *file, xmlCharEncodingHandlerPtr encoder); xmlOutputBufferPtr xmlOutputBufferCreateFd (int fd, xmlCharEncodingHandlerPtr encoder); xmlOutputBufferPtr xmlOutputBufferCreateIO (xmlOutputWriteCallback iowrite, xmlOutputCloseCallback ioclose, void *ioctx, xmlCharEncodingHandlerPtr encoder); int xmlOutputBufferWrite (xmlOutputBufferPtr out, int len, const char *buf); int xmlOutputBufferWriteString (xmlOutputBufferPtr out, const char *str); int xmlOutputBufferFlush (xmlOutputBufferPtr out); int xmlOutputBufferClose (xmlOutputBufferPtr out); int xmlRegisterOutputCallbacks (xmlOutputMatchCallback match, xmlOutputOpenCallback open, xmlOutputWriteCallback write, xmlOutputCloseCallback close); int xmlSaveFileTo (xmlOutputBuffer *buf, xmlDocPtr cur, const char *encoding); void xmlNodeDumpOutput (xmlOutputBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur, int level, int format, + const char *encoding); +void htmlDocContentDumpOutput (xmlOutputBufferPtr buf, + xmlDocPtr cur, const char *encoding);

Description

Details

xmlParserInputBufferPtr xmlAllocParserInputBuffer
                                             (xmlCharEncoding enc);

xmlParserInputBufferPtr xmlParserInputBufferCreateFname
                                             (const char *URI,
                                              xmlCharEncoding enc);

xmlParserInputBufferPtr xmlParserInputBufferCreateFilename
                                             (const char *URI,
                                              xmlCharEncoding enc);

xmlParserInputBufferPtr xmlParserInputBufferCreateFile
                                             (FILE *file,
                                              xmlCharEncoding enc);

xmlParserInputBufferPtr xmlParserInputBufferCreateFd
                                             (int fd,
                                              xmlCharEncoding enc);

xmlParserInputBufferPtr xmlParserInputBufferCreateMem
                                             (const char *mem,
                                              int size,
                                              xmlCharEncoding enc);

xmlParserInputBufferPtr xmlParserInputBufferCreateIO
                                             (xmlInputReadCallback ioread,
                                              xmlInputCloseCallback ioclose,
                                              void *ioctx,
                                              xmlCharEncoding enc);

int         xmlParserInputBufferRead        (xmlParserInputBufferPtr in,
                                              int len);

int         xmlParserInputBufferGrow        (xmlParserInputBufferPtr in,
                                              int len);

int         xmlParserInputBufferPush        (xmlParserInputBufferPtr in,
                                              int len,
@@ -2345,7 +2357,7 @@ in case of error.
void        xmlFreeParserInputBuffer        (xmlParserInputBufferPtr in);
int         xmlRegisterInputCallbacks       (xmlInputMatchCallback match,
                                              xmlInputOpenCallback open,
                                              xmlInputReadCallback read,
                                              xmlInputCloseCallback close);
xmlOutputBufferPtr xmlAllocOutputBuffer     (xmlCharEncodingHandlerPtr encoder);
xmlOutputBufferPtr xmlOutputBufferCreateFilename
                                             (const char *URI,
                                              xmlCharEncodingHandlerPtr encoder,
                                              int compression);
xmlOutputBufferPtr xmlOutputBufferCreateFile
                                             (FILE *file,
                                              xmlCharEncodingHandlerPtr encoder);
xmlOutputBufferPtr xmlOutputBufferCreateFd  (int fd,
                                              xmlCharEncodingHandlerPtr encoder);
xmlOutputBufferPtr xmlOutputBufferCreateIO  (xmlOutputWriteCallback iowrite,
                                              xmlOutputCloseCallback ioclose,
                                              void *ioctx,
                                              xmlCharEncodingHandlerPtr encoder);
int         xmlOutputBufferWrite            (xmlOutputBufferPtr out,
                                              int len,
@@ -3319,7 +3331,7 @@ in case of error.
int         xmlOutputBufferWriteString      (xmlOutputBufferPtr out,
                                              const char *str);
int         xmlOutputBufferFlush            (xmlOutputBufferPtr out);
int         xmlOutputBufferClose            (xmlOutputBufferPtr out);
int         xmlRegisterOutputCallbacks      (xmlOutputMatchCallback match,
                                              xmlOutputOpenCallback open,
                                              xmlOutputWriteCallback write,
                                              xmlOutputCloseCallback close);
int         xmlSaveFileTo                   (xmlOutputBuffer *buf,
                                              xmlDocPtr cur,
                                              const char *encoding);
void        xmlNodeDumpOutput               (xmlOutputBufferPtr buf,
                                              xmlDocPtr doc,
                                              xmlNodePtr cur,
                                              int level,
@@ -3990,6 +4002,106 @@ VALIGN="TOP"
 >
htmlDocContentDumpOutput ()
void        htmlDocContentDumpOutput        (xmlOutputBufferPtr buf,
+                                             xmlDocPtr cur,
+                                             const char *encoding);
buf : 
cur : 
encoding :
xmlmemory
Name
Synopsis

 
 #define     DEBUG_MEMORY
 #define     MEM_LIST
 void        (*xmlFreeFunc)                  (void*);
 void*       (*xmlMallocFunc)                (...);
 void*       (*xmlReallocFunc)               (void*,
                                              ...);
 char*       (*xmlStrdupFunc)                (const char*);
 int         xmlMemSetup                     (xmlFreeFunc freeFunc,
                                              xmlMallocFunc mallocFunc,
                                              xmlReallocFunc reallocFunc,
                                              xmlStrdupFunc strdupFunc);
 int         xmlMemGet                       (xmlFreeFunc *freeFunc,
                                              xmlMallocFunc *mallocFunc,
                                              xmlReallocFunc *reallocFunc,
                                              xmlStrdupFunc *strdupFunc);
 int         xmlInitMemory                   (void);
 int         xmlMemUsed                      (void);
 void        xmlMemDisplay                   (FILE *fp);
 void        xmlMemShow                      ( *fp,
                                              int nr);
 void        xmlMemoryDump                   (void);
 #define     xmlMalloc                       (x)
 #define     xmlRealloc                      (p, x)
 #define     xmlMemStrdup                    (x)
 void*       xmlMallocLoc                    (int size,
                                              const char *file,
                                              int line);
 void*       xmlReallocLoc                   (void *ptr,
                                              int size,
                                              const char *file,
                                              int line);
 char*       xmlMemStrdupLoc                 (const char *str,
                                              const char *file,
@@ -260,7 +260,7 @@ HREF="gnome-xml-xmlmemory.html#XMLMEMSTRDUPLOC"
 >
Description
Details
int         xmlMemSetup                     (xmlFreeFunc freeFunc,
                                              xmlMallocFunc mallocFunc,
                                              xmlReallocFunc reallocFunc,
                                              xmlStrdupFunc strdupFunc);
int         xmlMemGet                       (xmlFreeFunc *freeFunc,
                                              xmlMallocFunc *mallocFunc,
                                              xmlReallocFunc *reallocFunc,
                                              xmlStrdupFunc *strdupFunc);
xpath
Name
Synopsis

 
 struct      xmlXPathContext;
 typedef     xmlXPathContextPtr;
 struct      xmlXPathParserContext;
 typedef     xmlXPathParserContextPtr;
 enum        xmlXPathError;
 struct      xmlNodeSet;
 typedef     xmlNodeSetPtr;
 enum        xmlXPathObjectType;
 struct      xmlXPathObject;
-typedef     typedef     xmlXPathObjectPtr;
+>               ();
 int         (*xmlXPathConvertFunc)          (xmlXPathObjectPtr obj,
                                              int type);
 struct      xmlXPathType;
 typedef     xmlXPathTypePtr;
 struct      xmlXPathVariable;
 typedef     xmlXPathVariablePtr;
 void        (*xmlXPathEvalFunc)             (xmlXPathParserContextPtr ctxt,
                                              int nargs);
 struct      xmlXPathFunct;
 typedef     xmlXPathFuncPtr;
 xmlXPathObjectPtr (*xmlXPathAxisFunc)       (xmlXPathParserContextPtr ctxt,
                                              xmlXPathObjectPtr cur);
 struct      xmlXPathAxis;
 typedef     xmlXPathAxisPtr;
 void        (*xmlXPathFunction)             (xmlXPathParserContextPtr ctxt,
                                              int nargs);
 void        xmlXPathInit                    (void);
 xmlXPathContextPtr xmlXPathNewContext       (xmlDocPtr doc);
 void        xmlXPathFreeContext             (xmlXPathContextPtr ctxt);
 xmlXPathObjectPtr xmlXPathEval              (const xmlChar *str,
                                              xmlXPathContextPtr ctxt);
 xmlXPathObjectPtr xmlXPathEvalXPtrExpr      (const xmlChar *str,
                                              xmlXPathContextPtr ctxt);
 void        xmlXPathFreeObject              (xmlXPathObjectPtr obj);
 xmlXPathObjectPtr xmlXPathEvalExpression    (const xmlChar *str,
                                              xmlXPathContextPtr ctxt);
 xmlNodeSetPtr xmlXPathNodeSetCreate         (xmlNodePtr val);
 void        xmlXPathFreeNodeSetList         (xmlXPathObjectPtr obj);
 void        xmlXPathFreeNodeSet             (xmlNodeSetPtr obj);
 xmlXPathObjectPtr xmlXPathObjectCopy        (xmlXPathObjectPtr val);
 val);
+int         xmlXPathCmpNodes                (xmlNodePtr node1,
+                                             xmlNodePtr node2);

Description

Details

xmlXPathObjectPtr

xmlXPathObjectPtr ()

typedef xmlXPathObject *xmlXPathObjectPtr;
typedef xmlXPathObjectPtr ();

Returns : 

int         (*xmlXPathConvertFunc)          (xmlXPathObjectPtr obj,
                                              int type);

void        (*xmlXPathEvalFunc)             (xmlXPathParserContextPtr ctxt,
                                              int nargs);

xmlXPathObjectPtr (*xmlXPathAxisFunc)       (xmlXPathParserContextPtr ctxt,
                                              xmlXPathObjectPtr cur);

void        (*xmlXPathFunction)             (xmlXPathParserContextPtr ctxt,
                                              int nargs);

xmlXPathContextPtr xmlXPathNewContext       (xmlDocPtr doc);
  the XML document the xmlXPathContext just allocated.

void        xmlXPathFreeContext             (xmlXPathContextPtr ctxt);
the context to free

xmlXPathObjectPtr xmlXPathEval              (const xmlChar *str,
                                              xmlXPathContextPtr ctxt);

xmlXPathObjectPtr xmlXPathEvalXPtrExpr      (const xmlChar *str,
                                              xmlXPathContextPtr ctxt);

void        xmlXPathFreeObject              (xmlXPathObjectPtr obj);
the object to free

xmlXPathObjectPtr xmlXPathEvalExpression    (const xmlChar *str,
                                              xmlXPathContextPtr ctxt);

xmlNodeSetPtr xmlXPathNodeSetCreate         (xmlNodePtr val);
  an initial xmlNodePtr, or NULL the newly created object.

void        xmlXPathFreeNodeSetList         (xmlXPathObjectPtr obj);
but don't deallocate the objects in the list contrary to xmlXPathFreeObject().

an existing NodeSetList object

void        xmlXPathFreeNodeSet             (xmlNodeSetPtr obj);
the xmlNodeSetPtr to free

xmlXPathObjectPtr xmlXPathObjectCopy        (xmlXPathObjectPtr val);

xmlXPathCmpNodes ()

int         xmlXPathCmpNodes                (xmlNodePtr node1,
+                                             xmlNodePtr node2);

Compare two nodes w.r.t document order

node1 : the first node
node2 : the second node
Returns :-2 in case of error 1 if first point < second point, 0 if +that's the same point, -1 otherwise

xpathInternals

Name

Synopsis

#define CHECK_ERROR #define CHECK_ERROR0 #define XP_ERROR (X) #define XP_ERROR0 (X) #define CHECK_TYPE (typeval) #define CHECK_ARITY (x) #define CAST_TO_STRING #define CAST_TO_NUMBER #define CAST_TO_BOOLEAN +typedef xmlXPathObjectPtr (); void xmlXPathRegisterVariableLookup (xmlXPathContextPtr ctxt, + xmlXPathVariableLookupFunc f, + void *varCtxt); +void xmlXPatherror (xmlXPathParserContextPtr ctxt, const char *file, int line, int no); void xmlXPathDebugDumpObject (FILE *output, xmlXPathObjectPtr cur, int depth); int xmlXPathRegisterNs (xmlXPathContextPtr ctxt, const xmlChar *prefix, const xmlChar *ns_uri); const xmlChar* xmlXPathNsLookup (xmlXPathContextPtr ctxt, const xmlChar *ns_uri); void xmlXPathRegisteredNsCleanup (xmlXPathContextPtr ctxt); int xmlXPathRegisterFunc (xmlXPathContextPtr ctxt, const xmlChar *name, xmlXPathFunction f); int xmlXPathRegisterFuncNS (xmlXPathContextPtr ctxt, const xmlChar *name, const xmlChar *ns_uri, xmlXPathFunction f); int xmlXPathRegisterVariable (xmlXPathContextPtr ctxt, const xmlChar *name, xmlXPathObjectPtr value); int xmlXPathRegisterVariableNS (xmlXPathContextPtr ctxt, const xmlChar *name, const xmlChar *ns_uri, xmlXPathObjectPtr value); xmlXPathFunction xmlXPathFunctionLookup (xmlXPathContextPtr ctxt, const xmlChar *name); xmlXPathFunction xmlXPathFunctionLookupNS (xmlXPathContextPtr ctxt, const xmlChar *name, const xmlChar *ns_uri); void xmlXPathRegisteredFuncsCleanup (xmlXPathContextPtr ctxt); xmlXPathObjectPtr xmlXPathVariableLookup (xmlXPathContextPtr ctxt, const xmlChar *name); xmlXPathObjectPtr xmlXPathVariableLookupNS (xmlXPathContextPtr ctxt, const xmlChar *name, const xmlChar *ns_uri); void xmlXPathRegisteredVariablesCleanup (xmlXPathContextPtr ctxt); xmlXPathParserContextPtr xmlXPathNewParserContext (const xmlChar *str, xmlXPathContextPtr ctxt); void xmlXPathFreeParserContext (xmlXPathParserContextPtr ctxt); xmlXPathObjectPtr valuePop (xmlXPathParserContextPtr ctxt); int valuePush (xmlXPathParserContextPtr ctxt, xmlXPathObjectPtr value); xmlXPathObjectPtr xmlXPathNewString (const xmlChar *val); xmlXPathObjectPtr xmlXPathNewCString (const char *val); xmlXPathObjectPtr xmlXPathNewFloat (double val); xmlXPathObjectPtr xmlXPathNewBoolean (int val); xmlXPathObjectPtr xmlXPathNewNodeSet (xmlNodePtr val); +xmlXPathObjectPtr xmlXPathNewValueTree (xmlNodePtr val); void xmlXPathNodeSetAdd (xmlNodeSetPtr cur, xmlNodePtr val); void xmlXPathIdFunction (xmlXPathParserContextPtr ctxt, int nargs); void xmlXPathRoot (xmlXPathParserContextPtr ctxt); void xmlXPathEvalExpr (xmlXPathParserContextPtr ctxt); xmlChar* xmlXPathParseName (xmlXPathParserContextPtr ctxt); xmlChar* xmlXPathParseNCName (xmlXPathParserContextPtr ctxt); double xmlXPathStringEvalNumber (const xmlChar *str); int xmlXPathEvaluatePredicateResult (xmlXPathParserContextPtr ctxt, xmlXPathObjectPtr res); void xmlXPathInit (void); void xmlXPathStringFunction (xmlXPathParserContextPtr ctxt, int nargs); void xmlXPathRegisterAllFunctions (xmlXPathContextPtr ctxt); xmlNodeSetPtr xmlXPathNodeSetCreate (xmlNodePtr val); xmlNodeSetPtr xmlXPathNodeSetMerge (xmlNodeSetPtr val1, xmlNodeSetPtr val2); void xmlXPathNodeSetDel (xmlNodeSetPtr cur, xmlNodePtr val); void xmlXPathNodeSetRemove (xmlNodeSetPtr cur, int val); void xmlXPathFreeNodeSet (xmlNodeSetPtr obj); xmlXPathObjectPtr xmlXPathNewNodeSetList (xmlNodeSetPtr val); xmlXPathObjectPtr xmlXPathWrapNodeSet (xmlNodeSetPtr val); void xmlXPathFreeNodeSetList (xmlXPathObjectPtr obj); void xmlXPathFreeObject (xmlXPathObjectPtr obj); xmlXPathContextPtr xmlXPathNewContext (xmlDocPtr doc); void xmlXPathFreeContext (xmlXPathContextPtr ctxt); int xmlXPathEqualValues (xmlXPathParserContextPtr ctxt); int xmlXPathCompareValues (xmlXPathParserContextPtr ctxt, int inf, int strict); void xmlXPathValueFlipSign (xmlXPathParserContextPtr ctxt); void xmlXPathAddValues (xmlXPathParserContextPtr ctxt); void xmlXPathSubValues (xmlXPathParserContextPtr ctxt); void xmlXPathMultValues (xmlXPathParserContextPtr ctxt); void xmlXPathDivValues (xmlXPathParserContextPtr ctxt); void xmlXPathModValues (xmlXPathParserContextPtr ctxt); void xmlXPathLastFunction (xmlXPathParserContextPtr ctxt, int nargs); void xmlXPathPositionFunction (xmlXPathParserContextPtr ctxt, int nargs); void xmlXPathCountFunction (xmlXPathParserContextPtr ctxt, int nargs); void xmlXPathLocalNameFunction (xmlXPathParserContextPtr ctxt, int nargs); void xmlXPathNamespaceURIFunction (xmlXPathParserContextPtr ctxt, int nargs); void xmlXPathStringLengthFunction (xmlXPathParserContextPtr ctxt, int nargs); void xmlXPathConcatFunction (xmlXPathParserContextPtr ctxt, int nargs); void xmlXPathContainsFunction (xmlXPathParserContextPtr ctxt, int nargs); void xmlXPathStartsWithFunction (xmlXPathParserContextPtr ctxt, int nargs); void xmlXPathSubstringFunction (xmlXPathParserContextPtr ctxt, int nargs); void xmlXPathSubstringBeforeFunction (xmlXPathParserContextPtr ctxt, int nargs); void xmlXPathSubstringAfterFunction (xmlXPathParserContextPtr ctxt, int nargs); void xmlXPathNormalizeFunction (xmlXPathParserContextPtr ctxt, int nargs); void xmlXPathTranslateFunction (xmlXPathParserContextPtr ctxt, int nargs); void xmlXPathNotFunction (xmlXPathParserContextPtr ctxt, int nargs); void xmlXPathTrueFunction (xmlXPathParserContextPtr ctxt, int nargs); void xmlXPathFalseFunction (xmlXPathParserContextPtr ctxt, int nargs); void xmlXPathLangFunction (xmlXPathParserContextPtr ctxt, int nargs); void xmlXPathNumberFunction (xmlXPathParserContextPtr ctxt, int nargs); void xmlXPathSumFunction (xmlXPathParserContextPtr ctxt, int nargs); void xmlXPathFloorFunction (xmlXPathParserContextPtr ctxt, int nargs); void xmlXPathCeilingFunction (xmlXPathParserContextPtr ctxt, int nargs); void xmlXPathRoundFunction (xmlXPathParserContextPtr ctxt, + int nargs); +void xmlXPathBooleanFunction (xmlXPathParserContextPtr ctxt, int nargs);

Description

Details

xmlXPathObjectPtr ()

typedef     xmlXPathObjectPtr               ();

Returns :

xmlXPathRegisterVariableLookup ()

void        xmlXPathRegisterVariableLookup  (xmlXPathContextPtr ctxt,
+                                             xmlXPathVariableLookupFunc f,
+                                             void *varCtxt);

register an external mechanism to do variable lookup

ctxt : the XPath context
f : the lookup function
varCtxt : 

void        xmlXPatherror                   (xmlXPathParserContextPtr ctxt,
                                              const char *file,
@@ -1409,7 +1607,7 @@ VALIGN="TOP"
 >
FILE *output,
                                              xmlXPathObjectPtr cur,
                                              int depth);

int         xmlXPathRegisterNs              (xmlXPathContextPtr ctxt,
                                              const xmlChar *prefix,
                                              const xmlChar *ns_uri);

const xmlChar* xmlXPathNsLookup             (xmlXPathContextPtr ctxt,
                                              const xmlChar *ns_uri);

void        xmlXPathRegisteredNsCleanup     (xmlXPathContextPtr ctxt);

int         xmlXPathRegisterFunc            (xmlXPathContextPtr ctxt,
                                              const xmlChar *name,
                                              xmlXPathFunction f);

int         xmlXPathRegisterFuncNS          (xmlXPathContextPtr ctxt,
                                              const xmlChar *name,
                                              const xmlChar *ns_uri,
                                              xmlXPathFunction f);

int         xmlXPathRegisterVariable        (xmlXPathContextPtr ctxt,
                                              const xmlChar *name,
                                              xmlXPathObjectPtr value);

int         xmlXPathRegisterVariableNS      (xmlXPathContextPtr ctxt,
                                              const xmlChar *name,
                                              const xmlChar *ns_uri,
                                              xmlXPathObjectPtr value);

xmlXPathFunction xmlXPathFunctionLookup     (xmlXPathContextPtr ctxt,
                                              const xmlChar *name);

xmlXPathFunction xmlXPathFunctionLookupNS   (xmlXPathContextPtr ctxt,
                                              const xmlChar *name,
                                              const xmlChar *ns_uri);

void        xmlXPathRegisteredFuncsCleanup  (xmlXPathContextPtr ctxt);

xmlXPathObjectPtr xmlXPathVariableLookup    (xmlXPathContextPtr ctxt,
                                              const xmlChar *name);

xmlXPathObjectPtr xmlXPathVariableLookupNS  (xmlXPathContextPtr ctxt,
                                              const xmlChar *name,
                                              const xmlChar *ns_uri);

void xmlXPathRegisteredVariablesCleanup (xmlXPathContextPtr ctxt);

xmlXPathParserContextPtr xmlXPathNewParserContext
                                             (const xmlChar *str,
                                              xmlXPathContextPtr ctxt);

void        xmlXPathFreeParserContext       (xmlXPathParserContextPtr ctxt);

xmlXPathObjectPtr valuePop                  (xmlXPathParserContextPtr ctxt);

int         valuePush                       (xmlXPathParserContextPtr ctxt,
                                              xmlXPathObjectPtr value);

xmlXPathObjectPtr xmlXPathNewString         (const xmlChar *val);

xmlXPathObjectPtr xmlXPathNewCString        (const char *val);

xmlXPathObjectPtr xmlXPathNewFloat          (
xmlXPathObjectPtr xmlXPathNewBoolean        (int val);
xmlXPathObjectPtr xmlXPathNewNodeSet        (xmlNodePtr val);
xmlXPathNewValueTree ()
xmlXPathObjectPtr xmlXPathNewValueTree      (xmlNodePtr val);
Create a new xmlXPathObjectPtr of type Value Tree (XSLT) and initialize
+it with the tree root val
val :  the NodePtr value
Returns :the newly created object.

int         xmlXPathEvaluatePredicateResult (xmlXPathParserContextPtr ctxt,
                                              xmlXPathObjectPtr res);

void        xmlXPathStringFunction          (xmlXPathParserContextPtr ctxt,
                                              int nargs);
the number of arguments

void        xmlXPathRegisterAllFunctions    (xmlXPathContextPtr ctxt);

Registers all default XPath functions in this context

the XPath context

xmlNodeSetPtr xmlXPathNodeSetCreate         (xmlNodePtr val);
an initial xmlNodePtr, or NULL the newly created object. 

xmlNodeSetPtr xmlXPathNodeSetMerge          (xmlNodeSetPtr val1,
                                              xmlNodeSetPtr val2);

void        xmlXPathNodeSetDel              (xmlNodeSetPtr cur,
                                              xmlNodePtr val);

void        xmlXPathNodeSetRemove           (xmlNodeSetPtr cur,
                                              int val);

void        xmlXPathFreeNodeSet             (xmlNodeSetPtr obj);
the xmlNodeSetPtr to free 

xmlXPathObjectPtr xmlXPathNewNodeSetList    (xmlNodeSetPtr val);

xmlXPathObjectPtr xmlXPathWrapNodeSet       (xmlNodeSetPtr val);

void        xmlXPathFreeNodeSetList         (xmlXPathObjectPtr obj);
but don't deallocate the objects in the list contrary to xmlXPathFreeObject().

an existing NodeSetList object 

void        xmlXPathFreeObject              (xmlXPathObjectPtr obj);
the object to free 

xmlXPathContextPtr xmlXPathNewContext       (xmlDocPtr doc);
the XML document the xmlXPathContext just allocated. 

void        xmlXPathFreeContext             (xmlXPathContextPtr ctxt);
the context to free 

int         xmlXPathEqualValues             (xmlXPathParserContextPtr ctxt);

int         xmlXPathCompareValues           (xmlXPathParserContextPtr ctxt,
                                              int inf,
@@ -5670,7 +5957,7 @@ CLASS="PARAMETER"
 WIDTH="80%"
 ALIGN="LEFT"
 VALIGN="TOP"
->  less than (1) or greater than (2)  less than (1) or greater than (0)
1 if the comparaison succeeded, 0 if it failed
void        xmlXPathValueFlipSign           (xmlXPathParserContextPtr ctxt);
void        xmlXPathAddValues               (xmlXPathParserContextPtr ctxt);
void        xmlXPathSubValues               (xmlXPathParserContextPtr ctxt);
void        xmlXPathMultValues              (xmlXPathParserContextPtr ctxt);
void        xmlXPathDivValues               (xmlXPathParserContextPtr ctxt);
void        xmlXPathModValues               (xmlXPathParserContextPtr ctxt);
void        xmlXPathLastFunction            (xmlXPathParserContextPtr ctxt,
                                              int nargs);

  the number of arguments
void        xmlXPathPositionFunction        (xmlXPathParserContextPtr ctxt,
                                              int nargs);

  the number of arguments
void        xmlXPathCountFunction           (xmlXPathParserContextPtr ctxt,
                                              int nargs);

  the number of arguments
void        xmlXPathLocalNameFunction       (xmlXPathParserContextPtr ctxt,
                                              int nargs);

  the number of arguments
void        xmlXPathNamespaceURIFunction    (xmlXPathParserContextPtr ctxt,
                                              int nargs);

  the number of arguments
void        xmlXPathStringLengthFunction    (xmlXPathParserContextPtr ctxt,
                                              int nargs);

  the number of arguments
void        xmlXPathConcatFunction          (xmlXPathParserContextPtr ctxt,
                                              int nargs);

  the number of arguments
void        xmlXPathContainsFunction        (xmlXPathParserContextPtr ctxt,
                                              int nargs);

  the number of arguments
void        xmlXPathStartsWithFunction      (xmlXPathParserContextPtr ctxt,
                                              int nargs);

  the number of arguments
void        xmlXPathSubstringFunction       (xmlXPathParserContextPtr ctxt,
                                              int nargs);

  the number of arguments
void        xmlXPathSubstringBeforeFunction (xmlXPathParserContextPtr ctxt,
                                              int nargs);

  the number of arguments
void        xmlXPathSubstringAfterFunction  (xmlXPathParserContextPtr ctxt,
                                              int nargs);

  the number of arguments
void        xmlXPathNormalizeFunction       (xmlXPathParserContextPtr ctxt,
                                              int nargs);

  the number of arguments
void        xmlXPathTranslateFunction       (xmlXPathParserContextPtr ctxt,
                                              int nargs);

  the number of arguments
void        xmlXPathNotFunction             (xmlXPathParserContextPtr ctxt,
                                              int nargs);

  the number of arguments
void        xmlXPathTrueFunction            (xmlXPathParserContextPtr ctxt,
                                              int nargs);

  the number of arguments
void        xmlXPathFalseFunction           (xmlXPathParserContextPtr ctxt,
                                              int nargs);

  the number of arguments
void        xmlXPathLangFunction            (xmlXPathParserContextPtr ctxt,
                                              int nargs);

  the number of arguments
void        xmlXPathNumberFunction          (xmlXPathParserContextPtr ctxt,
                                              int nargs);

  the number of arguments
void        xmlXPathSumFunction             (xmlXPathParserContextPtr ctxt,
                                              int nargs);

  the number of arguments
void        xmlXPathFloorFunction           (xmlXPathParserContextPtr ctxt,
                                              int nargs);

  the number of arguments
void        xmlXPathCeilingFunction         (xmlXPathParserContextPtr ctxt,
                                              int nargs);

  the number of arguments
void        xmlXPathRoundFunction           (xmlXPathParserContextPtr ctxt,
                                              int nargs);

  the number of arguments
xmlXPathBooleanFunction ()
void        xmlXPathBooleanFunction         (xmlXPathParserContextPtr ctxt,
+                                             int nargs);
Implement the boolean() XPath function
+boolean boolean(object)
+he boolean function converts its argument to a boolean as follows:
+- a number is true if and only if it is neither positive or
+negative zero nor NaN
+- a node-set is true if and only if it is non-empty
+- a string is true if and only if its length is non-zero
ctxt :  the XPath Parser context
nargs :  the number of arguments
xpointer
Name
Synopsis

 
 struct      xmlLocationSet;
 typedef     xmlLocationSetPtr;
 void        xmlXPtrFreeLocationSet          (xmlLocationSetPtr obj);
 xmlLocationSetPtr xmlXPtrLocationSetMerge   (xmlLocationSetPtr val1,
                                              xmlLocationSetPtr val2);
 xmlXPathContextPtr xmlXPtrNewContext        (xmlDocPtr doc,
                                              xmlNodePtr here,
                                              xmlNodePtr origin);
 xmlXPathObjectPtr xmlXPtrEval               (const xmlChar *str,
                                              xmlXPathContextPtr ctx);
 void        xmlXPtrRangeToFunction          (xmlXPathParserContextPtr ctxt,
                                              int nargs);
 xmlNodePtr  xmlXPtrBuildNodeList            (xmlXPathObjectPtr obj);
 void        xmlXPtrEvalRangePredicate       (xmlXPathParserContextPtr ctxt);

Description

Details

void        xmlXPtrFreeLocationSet          (xmlLocationSetPtr obj);

xmlLocationSetPtr xmlXPtrLocationSetMerge   (xmlLocationSetPtr val1,
                                              xmlLocationSetPtr val2);

xmlXPathContextPtr xmlXPtrNewContext        (xmlDocPtr doc,
                                              xmlNodePtr here,
                                              xmlNodePtr origin);

xmlXPathObjectPtr xmlXPtrEval               (const xmlChar *str,
                                              xmlXPathContextPtr ctx);

void        xmlXPtrRangeToFunction          (xmlXPathParserContextPtr ctxt,
                                              int nargs);

xmlNodePtr  xmlXPtrBuildNodeList            (xmlXPathObjectPtr obj);

void        xmlXPtrEvalRangePredicate       (xmlXPathParserContextPtr ctxt);

1.7.0: sep 23 1999

  • Added the ability to fetch remote DTD or parsed entities, see the nanohttp module.
    • + href="html/libxml-nanohttp.html">nanohttp module.
  • Added an errno to report errors by another mean than a simple printf like callback
  • Finished ID/IDREF support and checking when validation
  • Serious memory leaks fixed (there is now a memory wrapper module)
    • + href="html/libxml-xmlmemory.html">memory wrapper module)
  • Improvement of XPath implementation
  • Added an HTML parser front-end
    • @@ -778,8 +778,8 @@ required, but as a separate set of documents. The interfaces of the XML library are by principle low level, there is nearly zero abstraction. Those interested in a higher level API should look at DOM.

    -

    The parser interfaces for XML are -separated from the HTML parser +

    The parser interfaces for XML are +separated from the HTML parser interfaces. Let's have a look at how the XML parser can be called:

    Invoking the parser : the pull method

    @@ -879,7 +879,7 @@ that produces the XML document used in the previous examples:

    Traversing the tree

    -

    Basically by including "tree.h" your +

    Basically by including "tree.h" your code has access to the internal structure of all the elements of the tree. The names should be somewhat simple like parent, children, next, prev, @@ -901,7 +901,7 @@ to an element which is not the document Root Element, a function

    Modifying the tree

    Functions are provided for reading and writing the document content. Here -is an excerpt from the tree API:

    +is an excerpt from the tree API:

    xmlAttrPtr xmlSetProp(xmlNodePtr node, const xmlChar *name, const xmlChar *value);
    @@ -1021,7 +1021,7 @@ content to be able to save the document back without losing this usually precious information (if the user went through the pain of explicitly defining entities, he may have a a rather negative attitude if you blindly susbtitute them as saving time). The xmlSubstituteEntitiesDefault() +href="html/libxml-parser.html#XMLSUBSTITUTEENTITIESDEFAULT">xmlSubstituteEntitiesDefault() function allows you to check and change the behaviour, which is to not substitute entities by default.

    @@ -1410,6 +1410,6 @@ Gnome CVS base under gnome-xml/example

    Daniel Veillard

    -

    $Id: xml.html,v 1.64 2001/01/22 15:32:01 veillard Exp $

    +

    $Id: xml.html,v 1.65 2001/01/23 11:39:52 veillard Exp $

    diff --git a/doc/xmldtd.html b/doc/xmldtd.html index a8c2ce73..c0920adf 100644 --- a/doc/xmldtd.html +++ b/doc/xmldtd.html @@ -185,7 +185,7 @@ for example the following validates a copy of the first revision of the XML a given DTD.

    Libxml exports an API to handle DTDs and validation, check the associated +href="http://xmlsoft.org/html/libxml-valid.html">associated description.

    Other resources

    diff --git a/doc/xmlio.html b/doc/xmlio.html index 71a6c5f8..52cf60b4 100644 --- a/doc/xmlio.html +++ b/doc/xmlio.html @@ -18,7 +18,7 @@ href="http://xmlsoft.org/xmlio.html">http://xmlsoft.org/xmlio.html

    Mailing-list archive: http://xmlsoft.org/messages/

    -

    Version: $Revision: 1.2 $

    +

    Version: $Revision: 1.3 $

    Table of Content:

      @@ -33,7 +33,7 @@ href="http://xmlsoft.org/messages/">http://xmlsoft.org/messages/

      General overview

      The module xmlIO.h +href="http://xmlsoft.org/html/libxml-xmlio.html">xmlIO.h provides the interfaces to the libxml I/O system. This consists of 4 main parts:

        @@ -85,7 +85,7 @@ default libxml I/O routines.

        All the buffer manipulation handling is done using the xmlBuffer type define in tree.h which is +href="http://xmlsoft.org/html/libxml-tree.html">tree.h which is a resizable memory buffer. The buffer allocation strategy can be selected to be either best-fit or use an exponential doubling one (CPU vs. memory use tradeoff). The values are XML_BUFFER_ALLOC_EXACT and @@ -196,6 +196,6 @@ res = xmlSaveFileTo(output, doc, NULL);

        Daniel Veillard

        -

        $Id: xmlio.html,v 1.2 2000/08/31 14:19:54 veillard Exp $

        +

        $Id: xmlio.html,v 1.3 2000/08/31 14:57:50 veillard Exp $

        diff --git a/doc/xmlmem.html b/doc/xmlmem.html index 2508a964..0ec47fbc 100644 --- a/doc/xmlmem.html +++ b/doc/xmlmem.html @@ -32,7 +32,7 @@ href="http://xmlsoft.org/messages/">http://xmlsoft.org/messages/

        General overview

        The module xmlmemory.h +href="http://xmlsoft.org/html/libxml-xmlmemory.html">xmlmemory.h provides the interfaces to the libxml memory system:

        • libxml does not use the libc memory allocator directly but xmlFree(), @@ -48,10 +48,10 @@ provides the interfaces to the libxml memory system:

          debugging, analysis or to implement a specific behaviour on memory management (like on embedded systems). Two function calls are available to do so:

            -
          • xmlMemGet +
          • xmlMemGet () which return the current set of functions in use by the parser
          • xmlMemSetup() + href="http://xmlsoft.org/html/libxml-xmlmemory.html">xmlMemSetup() which allow to set up a new set of memory allocation functions
          @@ -67,11 +67,11 @@ for example). This also mean that once parsing is finished there is a tiny amount of memory (a few hundred bytes) which can be recollected if you don't reuse the parser immediately:

            -
          • xmlCleanupParser +
          • xmlCleanupParser () is a centralized routine to free the parsing states. Note that it won't deallocate any produced tree if any (use the xmlFreeDoc() and related routines for this).
            • -
          • xmlInitParser +
          • xmlInitParser () is the dual routine allowing to preallocate the parsing state which can be useful for example to avoid initialization reentrancy problems when using libxml in multithreaded applications
            • @@ -90,13 +90,13 @@ other debugging routines allow to dump the memory allocated infos to a file or call a specific routine when a given block number is allocated:

            • xmlMallocLoc() + href="http://xmlsoft.org/html/libxml-xmlmemory.html">xmlMallocLoc() xmlReallocLoc() + href="http://xmlsoft.org/html/libxml-xmlmemory.html">xmlReallocLoc() and xmlMemStrdupLoc() + href="http://xmlsoft.org/html/libxml-xmlmemory.html">xmlMemStrdupLoc() are the memory debugging replacement allocation routines
              • -
            • xmlMemoryDump +
            • xmlMemoryDump () dumps all the informations about the allocated memory block lefts in the .memdump file