shaba/libxml2
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/libxml2.git synced 2024-12-24 21:33:51 +03:00
Code

Completed/revamped the SAX support, removed old namespace suppport, Daniel

Browse Source
This commit is contained in:
Daniel Veillard 1999-04-05 12:20:10 +00:00
parent 87c83bd334
commit 517752b985
15 changed files with 925 additions and 396 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
ChangeLog
View File

@ -1,3 +1,13 @@
Mon Apr 5 14:14:40 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
* parser.[ch] tree.[ch] SAX.c, parserInternals.h valid.[ch]:
large revamping of the parser to use SAX callbacks
http://www.megginson.com/SAX/ (or at least a C like interface
a la Expat). It's now possible to set up your own callbacks
and the parser will not build a DOM tree.
* test/* result/*: updated the test suite, I finally removed
the old Namespace draft support (PI based).
Fri Apr 2 17:57:32 CEST 1999 Daniel Veillard <Daniel.Veillard@w3.org>
* Makefile.am: added test result to EXTRA_DIST for make tests

527
SAX.c
View File

@ -10,6 +10,8 @@
#include <stdlib.h>
#include "tree.h"
#include "parser.h"
#include "parserInternals.h"
#include "valid.h"
#include "entities.h"
#include "xml-error.h"
@ -80,6 +82,65 @@ xmlSAXLocator xmlDefaultSAXLocator = {
getPublicId, getSystemId, getLineNumber, getColumnNumber
};
/**
* isStandalone:
* @ctxt: An XML parser context
*
* Is this document tagged standalone ?
*
* Returns 1 if true
*/
int
isStandalone(xmlParserCtxtPtr ctxt)
{
return(ctxt->myDoc->standalone == 1);
}
/**
* hasInternalSubset:
* @ctxt: An XML parser context
*
* Does this document has an internal subset
*
* Returns 1 if true
*/
int
hasInternalSubset(xmlParserCtxtPtr ctxt)
{
return(ctxt->myDoc->intSubset != NULL);
}
/**
* hasExternalSubset:
* @ctxt: An XML parser context
*
* Does this document has an external subset
*
* Returns 1 if true
*/
int
hasExternalSubset(xmlParserCtxtPtr ctxt)
{
return(ctxt->myDoc->extSubset != NULL);
}
/**
* hasInternalSubset:
* @ctxt: An XML parser context
*
* Does this document has an internal subset
*/
void
internalSubset(xmlParserCtxtPtr ctxt, const CHAR *name,
const CHAR *ExternalID, const CHAR *SystemID)
{
#ifdef DEBUG_SAX
fprintf(stderr, "SAX.internalSubset(%s, %s, %s)\n",
name, ExternalID, SystemID);
#endif
xmlCreateIntSubset(ctxt->myDoc, name, ExternalID, SystemID);
}
/**
* resolveEntity:
* @ctxt: An XML parser context
@ -102,9 +163,106 @@ resolveEntity(xmlParserCtxtPtr ctxt, const CHAR *publicId, const CHAR *systemId)
fprintf(stderr, "SAX.resolveEntity(%s, %s)\n", publicId, systemId);
#endif
/*
* TODO : not 100% sure that the appropriate handling in that case.
*/
return(NULL);
}
/**
* getEntity:
* @ctxt: An XML parser context
* @name: The entity name
*
* Get an entity by name
*
* Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
*/
xmlEntityPtr
getEntity(xmlParserCtxtPtr ctxt, const CHAR *name)
{
xmlEntityPtr ret;
#ifdef DEBUG_SAX
fprintf(stderr, "SAX.getEntity(%s)\n", name);
#endif
ret = xmlGetDocEntity(ctxt->myDoc, name);
return(ret);
}
/**
* entityDecl:
* @ctxt: An XML parser context
* @name: the entity name
* @type: the entity type
* @publicId: The public ID of the entity
* @systemId: The system ID of the entity
* @content: the entity value (without processing).
*
* An entity definition has been parsed
*/
void
entityDecl(xmlParserCtxtPtr ctxt, const CHAR *name, int type,
const CHAR *publicId, const CHAR *systemId, CHAR *content)
{
#ifdef DEBUG_SAX
fprintf(stderr, "SAX.entityDecl(%s, %d, %s, %s, %s)\n",
name, type, publicId, systemId, content);
#endif
xmlAddDocEntity(ctxt->myDoc, name, type, publicId, systemId, content);
}
/**
* attributeDecl:
* @ctxt: An XML parser context
* @name: the attribute name
* @type: the attribute type
* @publicId: The public ID of the attribute
* @systemId: The system ID of the attribute
* @content: the attribute value (without processing).
*
* An attribute definition has been parsed
*/
void
attributeDecl(xmlParserCtxtPtr ctxt, const CHAR *elem, const CHAR *name,
int type, int def, const CHAR *defaultValue,
xmlEnumerationPtr tree)
{
#ifdef DEBUG_SAX
fprintf(stderr, "SAX.attributeDecl(%s, %s, %d, %d, %s, ...)\n",
elem, name, type, def, defaultValue);
#endif
xmlAddAttributeDecl(ctxt->myDoc->intSubset, elem, name, type, def,
defaultValue, tree);
}
/**
* elementDecl:
* @ctxt: An XML parser context
* @name: the element name
* @type: the element type
* @publicId: The public ID of the element
* @systemId: The system ID of the element
* @content: the element value (without processing).
*
* An element definition has been parsed
*/
void
elementDecl(xmlParserCtxtPtr ctxt, const CHAR *name, int type,
xmlElementContentPtr content)
{
#ifdef DEBUG_SAX
fprintf(stderr, "SAX.elementDecl(%s, %d, ...)\n",
name, type);
#endif
xmlAddElementDecl(ctxt->myDoc->intSubset, name, type, content);
}
/**
* notationDecl:
* @ctxt: An XML parser context
@ -122,6 +280,7 @@ notationDecl(xmlParserCtxtPtr ctxt, const CHAR *name,
#ifdef DEBUG_SAX
fprintf(stderr, "SAX.notationDecl(%s, %s, %s)\n", name, publicId, systemId);
#endif
xmlAddNotationDecl(ctxt->myDoc->intSubset, name, publicId, systemId);
}
/**
@ -171,9 +330,19 @@ setDocumentLocator(xmlParserCtxtPtr ctxt, xmlSAXLocatorPtr loc)
void
startDocument(xmlParserCtxtPtr ctxt)
{
xmlDocPtr doc;
#ifdef DEBUG_SAX
fprintf(stderr, "SAX.startDocument()\n");
#endif
doc = ctxt->myDoc = xmlNewDoc(ctxt->version);
if (doc != NULL) {
if (ctxt->encoding != NULL)
doc->encoding = xmlStrdup(ctxt->encoding);
else
doc->encoding = NULL;
doc->standalone = ctxt->standalone;
}
}
/**
@ -190,20 +359,152 @@ endDocument(xmlParserCtxtPtr ctxt)
#endif
}
/**
* attribute:
* @ctxt: An XML parser context
* @name: The attribute name
* @value: The attribute value
*
* Handle an attribute that has been read by the parser.
* The default handling is to convert the attribute into an
* DOM subtree and past it in a new xmlAttr element added to
* the element.
*/
void
attribute(xmlParserCtxtPtr ctxt, const CHAR *fullname, const CHAR *value)
{
xmlAttrPtr ret;
CHAR *name;
CHAR *ns;
/****************
#ifdef DEBUG_SAX
fprintf(stderr, "SAX.attribute(%s, %s)\n", fullname, value);
#endif
****************/
/*
* Split the full name into a namespace prefix and the tag name
*/
name = xmlSplitQName(fullname, &ns);
/*
* Check whether it's a namespace definition
*/
if ((ns == NULL) &&
(name[0] == 'x') && (name[1] == 'm') && (name[2] == 'l') &&
(name[3] == 'n') && (name[4] == 's') && (name[5] == 0)) {
/* a default namespace definition */
xmlNewNs(ctxt->node, value, NULL);
if (name != NULL)
free(name);
return;
}
if ((ns != NULL) && (ns[0] == 'x') && (ns[1] == 'm') && (ns[2] == 'l') &&
(ns[3] == 'n') && (ns[4] == 's') && (ns[5] == 0)) {
/* a standard namespace definition */
xmlNewNs(ctxt->node, value, name);
free(ns);
if (name != NULL)
free(name);
return;
}
ret = xmlNewProp(ctxt->node, name, NULL);
if (ret != NULL)
ret->val = xmlStringGetNodeList(ctxt->myDoc, value);
if (name != NULL)
free(name);
if (ns != NULL)
free(ns);
}
/**
* startElement:
* @ctxt: An XML parser context
* @name: The element name
* @atts: An array of name/value attributes pairs, NULL terminated
*
* called when an opening tag has been processed.
* TODO We currently have a small pblm with the arguments ...
*/
void
startElement(xmlParserCtxtPtr ctxt, const CHAR *name)
startElement(xmlParserCtxtPtr ctxt, const CHAR *fullname, const CHAR **atts)
{
xmlNodePtr ret;
xmlNodePtr parent = ctxt->node;
xmlNsPtr ns;
CHAR *name;
CHAR *prefix;
const CHAR *att;
const CHAR *value;
int i;
#ifdef DEBUG_SAX
fprintf(stderr, "SAX.startElement(%s)\n", name);
fprintf(stderr, "SAX.startElement(%s)\n", fullname);
#endif
/*
* Split the full name into a namespace prefix and the tag name
*/
name = xmlSplitQName(fullname, &prefix);
/*
* Note : the namespace resolution is deferred until the end of the
* attributes parsing, since local namespace can be defined as
* an attribute at this level.
*/
ret = xmlNewDocNode(ctxt->myDoc, NULL, name, NULL);
if (ret == NULL) return;
if (ctxt->myDoc->root == NULL)
ctxt->myDoc->root = ret;
/*
* We are parsing a new node.
*/
nodePush(ctxt, ret);
/*
* Link the child element
*/
if (parent != NULL)
xmlAddChild(parent, ctxt->node);
/*
* process all the attributes.
*/
if (atts != NULL) {
i = 0;
att = atts[i++];
value = atts[i++];
while ((att != NULL) && (value != NULL)) {
/*
* Handle one pair of attribute/value
*/
attribute(ctxt, att, value);
/*
* Next ones
*/
att = atts[i++];
value = atts[i++];
}
}
/*
* Search the namespace, note that since the attributes have been
* processed, the local namespaces are available.
*/
ns = xmlSearchNs(ctxt->myDoc, ret, prefix);
if ((ns == NULL) && (parent != NULL))
ns = xmlSearchNs(ctxt->myDoc, parent, prefix);
xmlSetNs(ret, ns);
if (prefix != NULL)
free(prefix);
if (name != NULL)
free(name);
}
/**
@ -216,47 +517,65 @@ startElement(xmlParserCtxtPtr ctxt, const CHAR *name)
void
endElement(xmlParserCtxtPtr ctxt, const CHAR *name)
{
xmlParserNodeInfo node_info;
xmlNodePtr cur = ctxt->node;
#ifdef DEBUG_SAX
fprintf(stderr, "SAX.endElement(%s)\n", name);
if (name == NULL)
fprintf(stderr, "SAX.endElement(NULL)\n");
else
fprintf(stderr, "SAX.endElement(%s)\n", name);
#endif
/* Capture end position and add node */
if (cur != NULL && ctxt->record_info) {
node_info.end_pos = ctxt->input->cur - ctxt->input->base;
node_info.end_line = ctxt->input->line;
node_info.node = cur;
xmlParserAddNodeInfo(ctxt, &node_info);
}
/*
* end of parsing of this node.
*/
nodePop(ctxt);
}
/**
* attribute:
* reference:
* @ctxt: An XML parser context
* @name: The attribute name
* @value: The attribute value
* @name: The entity name
*
* called when an attribute has been read by the parser.
* The default handling is to convert the attribute into an
* DOM subtree and past it in a new xmlAttr element added to
* the element.
* called when an entity reference is detected.
*/
void
attribute(xmlParserCtxtPtr ctxt, const CHAR *name, const CHAR *value)
reference(xmlParserCtxtPtr ctxt, const CHAR *name)
{
xmlNodePtr ret;
#ifdef DEBUG_SAX
fprintf(stderr, "SAX.attribute(%s, %s)\n", name, value);
fprintf(stderr, "SAX.reference(%s)\n", name);
#endif
ret = xmlNewReference(ctxt->myDoc, name);
xmlAddChild(ctxt->node, ret);
}
/**
* characters:
* @ctxt: An XML parser context
* @ch: a CHAR string
* @start: the first char in the string
* @len: the number of CHAR
*
* receiving some chars from the parser.
* Question: how much at a time ???
*/
void
characters(xmlParserCtxtPtr ctxt, const CHAR *ch, int start, int len)
characters(xmlParserCtxtPtr ctxt, const CHAR *ch, int len)
{
xmlNodePtr lastChild;
#ifdef DEBUG_SAX
fprintf(stderr, "SAX.characters(%.30s, %d, %d)\n", ch, start, len);
fprintf(stderr, "SAX.characters(%.30s, %d)\n", ch, len);
#endif
/*
* Handle the data if any. If there is no child
@ -266,12 +585,12 @@ characters(xmlParserCtxtPtr ctxt, const CHAR *ch, int start, int len)
lastChild = xmlGetLastChild(ctxt->node);
if (lastChild == NULL)
xmlNodeAddContentLen(ctxt->node, &ch[start], len);
xmlNodeAddContentLen(ctxt->node, ch, len);
else {
if (xmlNodeIsText(lastChild))
xmlTextConcat(lastChild, &ch[start], len);
xmlTextConcat(lastChild, ch, len);
else {
lastChild = xmlNewTextLen(&ch[start], len);
lastChild = xmlNewTextLen(ch, len);
xmlAddChild(ctxt->node, lastChild);
}
}
@ -281,17 +600,16 @@ characters(xmlParserCtxtPtr ctxt, const CHAR *ch, int start, int len)
* ignorableWhitespace:
* @ctxt: An XML parser context
* @ch: a CHAR string
* @start: the first char in the string
* @len: the number of CHAR
*
* receiving some ignorable whitespaces from the parser.
* Question: how much at a time ???
*/
void
ignorableWhitespace(xmlParserCtxtPtr ctxt, const CHAR *ch, int start, int len)
ignorableWhitespace(xmlParserCtxtPtr ctxt, const CHAR *ch, int len)
{
#ifdef DEBUG_SAX
fprintf(stderr, "SAX.ignorableWhitespace(%.30s, %d, %d)\n", ch, start, len);
fprintf(stderr, "SAX.ignorableWhitespace(%.30s, %d)\n", ch, len);
#endif
}
@ -313,19 +631,173 @@ processingInstruction(xmlParserCtxtPtr ctxt, const CHAR *target,
#endif
}
/**
* globalNamespace:
* @ctxt: An XML parser context
* @href: the namespace associated URN
* @prefix: the namespace prefix
*
* An old global namespace has been parsed.
*/
void
globalNamespace(xmlParserCtxtPtr ctxt, const CHAR *href, const CHAR *prefix)
{
#ifdef DEBUG_SAX
fprintf(stderr, "SAX.globalNamespace(%s, %s)\n", href, prefix);
#endif
xmlNewGlobalNs(ctxt->myDoc, href, prefix);
}
/**
* setNamespace:
* @ctxt: An XML parser context
* @name: the namespace prefix
*
* Set the current element namespace.
*/
void
setNamespace(xmlParserCtxtPtr ctxt, const CHAR *name)
{
xmlNsPtr ns;
xmlNodePtr parent;
#ifdef DEBUG_SAX
fprintf(stderr, "SAX.setNamespace(%s)\n", name);
#endif
ns = xmlSearchNs(ctxt->myDoc, ctxt->node, name);
if (ns == NULL) { /* ctxt->node may not have a parent yet ! */
if (ctxt->nodeNr >= 2) {
parent = ctxt->nodeTab[ctxt->nodeNr - 2];
if (parent != NULL)
ns = xmlSearchNs(ctxt->myDoc, parent, name);
}
}
xmlSetNs(ctxt->node, ns);
}
/**
* getNamespace:
* @ctxt: An XML parser context
*
* Get the current element namespace.
*/
xmlNsPtr
getNamespace(xmlParserCtxtPtr ctxt)
{
xmlNsPtr ret;
#ifdef DEBUG_SAX
fprintf(stderr, "SAX.getNamespace()\n");
#endif
ret = ctxt->node->ns;
return(ret);
}
/**
* checkNamespace:
* @ctxt: An XML parser context
* @namespace: the namespace to check against
*
* Check that the current element namespace is the same as the
* one read upon parsing.
*/
int
checkNamespace(xmlParserCtxtPtr ctxt, CHAR *namespace)
{
xmlNodePtr cur = ctxt->node;
#ifdef DEBUG_SAX
fprintf(stderr, "SAX.checkNamespace(%s)\n", namespace);
#endif
/*
* Check that the Name in the ETag is the same as in the STag.
*/
if (namespace == NULL) {
if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
ctxt->sax->error(ctxt,
"End tags for %s don't hold the namespace %s\n",
cur->name, cur->ns->prefix);
ctxt->wellFormed = 0;
}
} else {
if ((cur->ns == NULL) || (cur->ns->prefix == NULL)) {
if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
ctxt->sax->error(ctxt,
"End tags %s holds a prefix %s not used by the open tag\n",
cur->name, namespace);
ctxt->wellFormed = 0;
} else if (strcmp(namespace, cur->ns->prefix)) {
if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
ctxt->sax->error(ctxt,
"Start and End tags for %s don't use the same namespaces: %s and %s\n",
cur->name, cur->ns->prefix, namespace);
ctxt->wellFormed = 0;
} else
return(1);
}
return(0);
}
/**
* namespaceDecl:
* @ctxt: An XML parser context
* @href: the namespace associated URN
* @prefix: the namespace prefix
*
* A namespace has been parsed.
*/
void
namespaceDecl(xmlParserCtxtPtr ctxt, const CHAR *href, const CHAR *prefix)
{
#ifdef DEBUG_SAX
if (prefix == NULL)
fprintf(stderr, "SAX.namespaceDecl(%s, NULL)\n", href);
else
fprintf(stderr, "SAX.namespaceDecl(%s, %s)\n", href, prefix);
#endif
xmlNewNs(ctxt->node, href, prefix);
}
/**
* comment:
* @ctxt: An XML parser context
* @value: the comment content
*
* A comment has been parsed.
*/
void
comment(xmlParserCtxtPtr ctxt, const CHAR *value)
{
#ifdef DEBUG_SAX
fprintf(stderr, "SAX.comment(%s)\n", value);
#endif
xmlNewDocComment(ctxt->myDoc, value);
}
xmlSAXHandler xmlDefaultSAXHandler = {
internalSubset,
isStandalone,
hasInternalSubset,
hasExternalSubset,
resolveEntity,
getEntity,
entityDecl,
notationDecl,
attributeDecl,
elementDecl,
unparsedEntityDecl,
setDocumentLocator,
startDocument,
endDocument,
startElement,
endElement,
attribute,
reference,
characters,
ignorableWhitespace,
processingInstruction,
comment,
xmlParserWarning,
xmlParserError,
xmlParserError,
@ -339,7 +811,15 @@ xmlSAXHandler xmlDefaultSAXHandler = {
void
xmlDefaultSAXHandlerInit(void)
{
xmlDefaultSAXHandler.internalSubset = internalSubset;
xmlDefaultSAXHandler.isStandalone = isStandalone;
xmlDefaultSAXHandler.hasInternalSubset = hasInternalSubset;
xmlDefaultSAXHandler.hasExternalSubset = hasExternalSubset;
xmlDefaultSAXHandler.resolveEntity = resolveEntity;
xmlDefaultSAXHandler.getEntity = getEntity;
xmlDefaultSAXHandler.entityDecl = entityDecl;
xmlDefaultSAXHandler.attributeDecl = attributeDecl;
xmlDefaultSAXHandler.elementDecl = elementDecl;
xmlDefaultSAXHandler.notationDecl = notationDecl;
xmlDefaultSAXHandler.unparsedEntityDecl = unparsedEntityDecl;
xmlDefaultSAXHandler.setDocumentLocator = setDocumentLocator;
@ -347,10 +827,11 @@ xmlDefaultSAXHandlerInit(void)
xmlDefaultSAXHandler.endDocument = endDocument;
xmlDefaultSAXHandler.startElement = startElement;
xmlDefaultSAXHandler.endElement = endElement;
xmlDefaultSAXHandler.attribute = attribute;
xmlDefaultSAXHandler.reference = reference;
xmlDefaultSAXHandler.characters = characters;
xmlDefaultSAXHandler.ignorableWhitespace = ignorableWhitespace;
xmlDefaultSAXHandler.processingInstruction = processingInstruction;
xmlDefaultSAXHandler.comment = comment;
xmlDefaultSAXHandler.warning = xmlParserWarning;
xmlDefaultSAXHandler.error = xmlParserError;
xmlDefaultSAXHandler.fatalError = xmlParserError;

4
entities.h
View File

@ -9,7 +9,7 @@
#ifndef __XML_ENTITIES_H__
#define __XML_ENTITIES_H__
#include "parser.h"
#include "tree.h"
#ifdef __cplusplus
extern "C" {
@ -56,6 +56,8 @@ typedef xmlEntitiesTable *xmlEntitiesTablePtr;
* External functions :
*/
#include "parser.h"
void xmlAddDocEntity(xmlDocPtr doc, const CHAR *name, int type,
const CHAR *ExternalID, const CHAR *SystemID, CHAR *content);
void xmlAddDtdEntity(xmlDocPtr doc, const CHAR *name, int type,

4
include/libxml/entities.h
View File

@ -9,7 +9,7 @@
#ifndef __XML_ENTITIES_H__
#define __XML_ENTITIES_H__
#include "parser.h"
#include "tree.h"
#ifdef __cplusplus
extern "C" {
@ -56,6 +56,8 @@ typedef xmlEntitiesTable *xmlEntitiesTablePtr;
* External functions :
*/
#include "parser.h"
void xmlAddDocEntity(xmlDocPtr doc, const CHAR *name, int type,
const CHAR *ExternalID, const CHAR *SystemID, CHAR *content);
void xmlAddDtdEntity(xmlDocPtr doc, const CHAR *name, int type,

43
include/libxml/parser.h
View File

@ -51,8 +51,12 @@ typedef xmlParserNodeInfoSeq *xmlParserNodeInfoSeqPtr;
typedef struct _xmlParserCtxt {
struct xmlSAXHandler *sax; /* The SAX handler */
xmlDocPtr doc; /* the document being built */
void *userData; /* the document being built */
xmlDocPtr myDoc; /* the document being built */
int wellFormed; /* is the document well formed */
const CHAR *version; /* the XML version string */
const CHAR *encoding; /* encoding, if any */
int standalone; /* standalone document */
/* Input stream stack */
xmlParserInputPtr input; /* Current input stream */
@ -89,10 +93,24 @@ typedef xmlSAXLocator *xmlSAXLocatorPtr;
* a SAX Exception.
*/
#include "entities.h"
typedef xmlParserInputPtr (*resolveEntitySAXFunc) (xmlParserCtxtPtr ctxt,
const CHAR *publicId, const CHAR *systemId);
typedef void (*internalSubsetSAXFunc) (xmlParserCtxtPtr ctxt, const CHAR *name,
const CHAR *ExternalID, const CHAR *SystemID);
typedef xmlEntityPtr (*getEntitySAXFunc) (xmlParserCtxtPtr ctxt,
const CHAR *name);
typedef void (*entityDeclSAXFunc) (xmlParserCtxtPtr ctxt,
const CHAR *name, int type, const CHAR *publicId,
const CHAR *systemId, CHAR *content);
typedef void (*notationDeclSAXFunc)(xmlParserCtxtPtr ctxt, const CHAR *name,
const CHAR *publicId, const CHAR *systemId);
typedef void (*attributeDeclSAXFunc)(xmlParserCtxtPtr ctxt, const CHAR *elem,
const CHAR *name, int type, int def,
const CHAR *defaultValue, xmlEnumerationPtr tree);
typedef void (*elementDeclSAXFunc)(xmlParserCtxtPtr ctxt, const CHAR *name,
int type, xmlElementContentPtr content);
typedef void (*unparsedEntityDeclSAXFunc)(xmlParserCtxtPtr ctxt,
const CHAR *name, const CHAR *publicId,
const CHAR *systemId, const CHAR *notationName);
@ -100,33 +118,48 @@ typedef void (*setDocumentLocatorSAXFunc) (xmlParserCtxtPtr ctxt,
xmlSAXLocatorPtr loc);
typedef void (*startDocumentSAXFunc) (xmlParserCtxtPtr ctxt);
typedef void (*endDocumentSAXFunc) (xmlParserCtxtPtr ctxt);
typedef void (*startElementSAXFunc) (xmlParserCtxtPtr ctxt, const CHAR *name);
typedef void (*startElementSAXFunc) (xmlParserCtxtPtr ctxt, const CHAR *name,
const CHAR **atts);
typedef void (*endElementSAXFunc) (xmlParserCtxtPtr ctxt, const CHAR *name);
typedef void (*attributeSAXFunc) (xmlParserCtxtPtr ctxt, const CHAR *name,
const CHAR *value);
typedef void (*referenceSAXFunc) (xmlParserCtxtPtr ctxt, const CHAR *name);
typedef void (*charactersSAXFunc) (xmlParserCtxtPtr ctxt, const CHAR *ch,
int start, int len);
int len);
typedef void (*ignorableWhitespaceSAXFunc) (xmlParserCtxtPtr ctxt,
const CHAR *ch, int start, int len);
const CHAR *ch, int len);
typedef void (*processingInstructionSAXFunc) (xmlParserCtxtPtr ctxt,
const CHAR *target, const CHAR *data);
typedef void (*commentSAXFunc) (xmlParserCtxtPtr ctxt, const CHAR *value);
typedef void (*warningSAXFunc) (xmlParserCtxtPtr ctxt, const char *msg, ...);
typedef void (*errorSAXFunc) (xmlParserCtxtPtr ctxt, const char *msg, ...);
typedef void (*fatalErrorSAXFunc) (xmlParserCtxtPtr ctxt, const char *msg, ...);
typedef int (*isStandaloneSAXFunc) (xmlParserCtxtPtr ctxt);
typedef int (*hasInternalSubsetSAXFunc) (xmlParserCtxtPtr ctxt);
typedef int (*hasExternalSubsetSAXFunc) (xmlParserCtxtPtr ctxt);
typedef struct xmlSAXHandler {
internalSubsetSAXFunc internalSubset;
isStandaloneSAXFunc isStandalone;
hasInternalSubsetSAXFunc hasInternalSubset;
hasExternalSubsetSAXFunc hasExternalSubset;
resolveEntitySAXFunc resolveEntity;
getEntitySAXFunc getEntity;
entityDeclSAXFunc entityDecl;
notationDeclSAXFunc notationDecl;
attributeDeclSAXFunc attributeDecl;
elementDeclSAXFunc elementDecl;
unparsedEntityDeclSAXFunc unparsedEntityDecl;
setDocumentLocatorSAXFunc setDocumentLocator;
startDocumentSAXFunc startDocument;
endDocumentSAXFunc endDocument;
startElementSAXFunc startElement;
endElementSAXFunc endElement;
attributeSAXFunc attribute;
referenceSAXFunc reference;
charactersSAXFunc characters;
ignorableWhitespaceSAXFunc ignorableWhitespace;
processingInstructionSAXFunc processingInstruction;
commentSAXFunc comment;
warningSAXFunc warning;
errorSAXFunc error;
fatalErrorSAXFunc fatalError;

21
include/libxml/parserInternals.h
View File

@ -529,6 +529,8 @@ xmlFreeInputStream(xmlParserInputPtr input);
* Namespaces.
*/
CHAR *
xmlSplitQName(const CHAR *name, CHAR **prefix);
CHAR *
xmlNamespaceParseNCName(xmlParserCtxtPtr ctxt);
CHAR *
xmlNamespaceParseQName(xmlParserCtxtPtr ctxt, CHAR **prefix);
@ -558,7 +560,7 @@ void
xmlParseCharData(xmlParserCtxtPtr ctxt, int cdata);
CHAR *
xmlParseExternalID(xmlParserCtxtPtr ctxt, CHAR **publicID, int strict);
xmlNodePtr
void
xmlParseComment(xmlParserCtxtPtr ctxt, int create);
CHAR *
xmlParsePITarget(xmlParserCtxtPtr ctxt);
@ -601,17 +603,17 @@ CHAR *
xmlParsePEReference(xmlParserCtxtPtr ctxt);
void
xmlParseDocTypeDecl(xmlParserCtxtPtr ctxt);
xmlAttrPtr
xmlParseAttribute(xmlParserCtxtPtr ctxt, xmlNodePtr node);
xmlNodePtr
CHAR *
xmlParseAttribute(xmlParserCtxtPtr ctxt, CHAR **value);
void
xmlParseStartTag(xmlParserCtxtPtr ctxt);
void
xmlParseEndTag(xmlParserCtxtPtr ctxt, xmlNsPtr *nsPtr, CHAR **tagPtr);
xmlParseEndTag(xmlParserCtxtPtr ctxt);
void
xmlParseCDSect(xmlParserCtxtPtr ctxt);
void
xmlParseContent(xmlParserCtxtPtr ctxt);
xmlNodePtr
void
xmlParseElement(xmlParserCtxtPtr ctxt);
CHAR *
xmlParseVersionNum(xmlParserCtxtPtr ctxt);
@ -628,5 +630,12 @@ xmlParseXMLDecl(xmlParserCtxtPtr ctxt);
void
xmlParseMisc(xmlParserCtxtPtr ctxt);
/*
* Generated by MACROS on top of parser.c c.f. PUSH_AND_POP
*/
extern int nodePush(xmlParserCtxtPtr ctxt, xmlNodePtr value);
extern xmlNodePtr nodePop(xmlParserCtxtPtr ctxt);
extern int inputPush(xmlParserCtxtPtr ctxt, xmlParserInputPtr value);
extern xmlParserInputPtr inputPop(xmlParserCtxtPtr ctxt);
#endif /* __XML_PARSER_INTERNALS_H__ */

4
include/libxml/tree.h
View File

@ -283,8 +283,8 @@ xmlNodePtr xmlNewDocText(xmlDocPtr doc, const CHAR *content);
xmlNodePtr xmlNewText(const CHAR *content);
xmlNodePtr xmlNewDocTextLen(xmlDocPtr doc, const CHAR *content, int len);
xmlNodePtr xmlNewTextLen(const CHAR *content, int len);
xmlNodePtr xmlNewDocComment(xmlDocPtr doc, CHAR *content);
xmlNodePtr xmlNewComment(CHAR *content);
xmlNodePtr xmlNewDocComment(xmlDocPtr doc, const CHAR *content);
xmlNodePtr xmlNewComment(const CHAR *content);
xmlNodePtr xmlNewReference(xmlDocPtr doc, const CHAR *name);
xmlNodePtr xmlCopyNode(xmlNodePtr node, int recursive);
xmlNodePtr xmlCopyNodeList(xmlNodePtr node);

12
include/libxml/valid.h
View File

@ -54,8 +54,8 @@ typedef struct xmlAttributeTable {
typedef xmlAttributeTable *xmlAttributeTablePtr;
/* Notation */
xmlNotationPtr xmlAddNotationDecl(xmlDtdPtr dtd, CHAR *name,
CHAR *PublicID, CHAR *SystemID);
xmlNotationPtr xmlAddNotationDecl(xmlDtdPtr dtd, const CHAR *name,
const CHAR *PublicID, const CHAR *SystemID);
xmlNotationTablePtr xmlCopyNotationTable(xmlNotationTablePtr table);
void xmlFreeNotationTable(xmlNotationTablePtr table);
void xmlDumpNotationTable(xmlNotationTablePtr table);
@ -66,7 +66,7 @@ xmlElementContentPtr xmlCopyElementContent(xmlElementContentPtr content);
void xmlFreeElementContent(xmlElementContentPtr cur);
/* Element */
xmlElementPtr xmlAddElementDecl(xmlDtdPtr dtd, CHAR *name, int type,
xmlElementPtr xmlAddElementDecl(xmlDtdPtr dtd, const CHAR *name, int type,
xmlElementContentPtr content);
xmlElementTablePtr xmlCopyElementTable(xmlElementTablePtr table);
void xmlFreeElementTable(xmlElementTablePtr table);
@ -78,9 +78,9 @@ void xmlFreeEnumeration(xmlEnumerationPtr cur);
xmlEnumerationPtr xmlCopyEnumeration(xmlEnumerationPtr cur);
/* Attribute */
xmlAttributePtr xmlAddAttributeDecl(xmlDtdPtr dtd, CHAR *elem,
CHAR *name, int type, int def,
CHAR *defaultValue, xmlEnumerationPtr tree);
xmlAttributePtr xmlAddAttributeDecl(xmlDtdPtr dtd, const CHAR *elem,
const CHAR *name, int type, int def,
const CHAR *defaultValue, xmlEnumerationPtr tree);
xmlAttributeTablePtr xmlCopyAttributeTable(xmlAttributeTablePtr table);
void xmlFreeAttributeTable(xmlAttributeTablePtr table);
void xmlDumpAttributeTable(xmlAttributeTablePtr table);

602
parser.c
View File

File diff suppressed because it is too large Load Diff

43
parser.h
View File

@ -51,8 +51,12 @@ typedef xmlParserNodeInfoSeq *xmlParserNodeInfoSeqPtr;
typedef struct _xmlParserCtxt {
struct xmlSAXHandler *sax; /* The SAX handler */
xmlDocPtr doc; /* the document being built */
void *userData; /* the document being built */
xmlDocPtr myDoc; /* the document being built */
int wellFormed; /* is the document well formed */
const CHAR *version; /* the XML version string */
const CHAR *encoding; /* encoding, if any */
int standalone; /* standalone document */
/* Input stream stack */
xmlParserInputPtr input; /* Current input stream */
@ -89,10 +93,24 @@ typedef xmlSAXLocator *xmlSAXLocatorPtr;
* a SAX Exception.
*/
#include "entities.h"
typedef xmlParserInputPtr (*resolveEntitySAXFunc) (xmlParserCtxtPtr ctxt,
const CHAR *publicId, const CHAR *systemId);
typedef void (*internalSubsetSAXFunc) (xmlParserCtxtPtr ctxt, const CHAR *name,
const CHAR *ExternalID, const CHAR *SystemID);
typedef xmlEntityPtr (*getEntitySAXFunc) (xmlParserCtxtPtr ctxt,
const CHAR *name);
typedef void (*entityDeclSAXFunc) (xmlParserCtxtPtr ctxt,
const CHAR *name, int type, const CHAR *publicId,
const CHAR *systemId, CHAR *content);
typedef void (*notationDeclSAXFunc)(xmlParserCtxtPtr ctxt, const CHAR *name,
const CHAR *publicId, const CHAR *systemId);
typedef void (*attributeDeclSAXFunc)(xmlParserCtxtPtr ctxt, const CHAR *elem,
const CHAR *name, int type, int def,
const CHAR *defaultValue, xmlEnumerationPtr tree);
typedef void (*elementDeclSAXFunc)(xmlParserCtxtPtr ctxt, const CHAR *name,
int type, xmlElementContentPtr content);
typedef void (*unparsedEntityDeclSAXFunc)(xmlParserCtxtPtr ctxt,
const CHAR *name, const CHAR *publicId,
const CHAR *systemId, const CHAR *notationName);
@ -100,33 +118,48 @@ typedef void (*setDocumentLocatorSAXFunc) (xmlParserCtxtPtr ctxt,
xmlSAXLocatorPtr loc);
typedef void (*startDocumentSAXFunc) (xmlParserCtxtPtr ctxt);
typedef void (*endDocumentSAXFunc) (xmlParserCtxtPtr ctxt);
typedef void (*startElementSAXFunc) (xmlParserCtxtPtr ctxt, const CHAR *name);
typedef void (*startElementSAXFunc) (xmlParserCtxtPtr ctxt, const CHAR *name,
const CHAR **atts);
typedef void (*endElementSAXFunc) (xmlParserCtxtPtr ctxt, const CHAR *name);
typedef void (*attributeSAXFunc) (xmlParserCtxtPtr ctxt, const CHAR *name,
const CHAR *value);
typedef void (*referenceSAXFunc) (xmlParserCtxtPtr ctxt, const CHAR *name);
typedef void (*charactersSAXFunc) (xmlParserCtxtPtr ctxt, const CHAR *ch,
int start, int len);
int len);
typedef void (*ignorableWhitespaceSAXFunc) (xmlParserCtxtPtr ctxt,
const CHAR *ch, int start, int len);
const CHAR *ch, int len);
typedef void (*processingInstructionSAXFunc) (xmlParserCtxtPtr ctxt,
const CHAR *target, const CHAR *data);
typedef void (*commentSAXFunc) (xmlParserCtxtPtr ctxt, const CHAR *value);
typedef void (*warningSAXFunc) (xmlParserCtxtPtr ctxt, const char *msg, ...);
typedef void (*errorSAXFunc) (xmlParserCtxtPtr ctxt, const char *msg, ...);
typedef void (*fatalErrorSAXFunc) (xmlParserCtxtPtr ctxt, const char *msg, ...);
typedef int (*isStandaloneSAXFunc) (xmlParserCtxtPtr ctxt);
typedef int (*hasInternalSubsetSAXFunc) (xmlParserCtxtPtr ctxt);
typedef int (*hasExternalSubsetSAXFunc) (xmlParserCtxtPtr ctxt);
typedef struct xmlSAXHandler {
internalSubsetSAXFunc internalSubset;
isStandaloneSAXFunc isStandalone;
hasInternalSubsetSAXFunc hasInternalSubset;
hasExternalSubsetSAXFunc hasExternalSubset;
resolveEntitySAXFunc resolveEntity;
getEntitySAXFunc getEntity;
entityDeclSAXFunc entityDecl;
notationDeclSAXFunc notationDecl;
attributeDeclSAXFunc attributeDecl;
elementDeclSAXFunc elementDecl;
unparsedEntityDeclSAXFunc unparsedEntityDecl;
setDocumentLocatorSAXFunc setDocumentLocator;
startDocumentSAXFunc startDocument;
endDocumentSAXFunc endDocument;
startElementSAXFunc startElement;
endElementSAXFunc endElement;
attributeSAXFunc attribute;
referenceSAXFunc reference;
charactersSAXFunc characters;
ignorableWhitespaceSAXFunc ignorableWhitespace;
processingInstructionSAXFunc processingInstruction;
commentSAXFunc comment;
warningSAXFunc warning;
errorSAXFunc error;
fatalErrorSAXFunc fatalError;

21
parserInternals.h
View File

@ -529,6 +529,8 @@ xmlFreeInputStream(xmlParserInputPtr input);
* Namespaces.
*/
CHAR *
xmlSplitQName(const CHAR *name, CHAR **prefix);
CHAR *
xmlNamespaceParseNCName(xmlParserCtxtPtr ctxt);
CHAR *
xmlNamespaceParseQName(xmlParserCtxtPtr ctxt, CHAR **prefix);
@ -558,7 +560,7 @@ void
xmlParseCharData(xmlParserCtxtPtr ctxt, int cdata);
CHAR *
xmlParseExternalID(xmlParserCtxtPtr ctxt, CHAR **publicID, int strict);
xmlNodePtr
void
xmlParseComment(xmlParserCtxtPtr ctxt, int create);
CHAR *
xmlParsePITarget(xmlParserCtxtPtr ctxt);
@ -601,17 +603,17 @@ CHAR *
xmlParsePEReference(xmlParserCtxtPtr ctxt);
void
xmlParseDocTypeDecl(xmlParserCtxtPtr ctxt);
xmlAttrPtr
xmlParseAttribute(xmlParserCtxtPtr ctxt, xmlNodePtr node);
xmlNodePtr
CHAR *
xmlParseAttribute(xmlParserCtxtPtr ctxt, CHAR **value);
void
xmlParseStartTag(xmlParserCtxtPtr ctxt);
void
xmlParseEndTag(xmlParserCtxtPtr ctxt, xmlNsPtr *nsPtr, CHAR **tagPtr);
xmlParseEndTag(xmlParserCtxtPtr ctxt);
void
xmlParseCDSect(xmlParserCtxtPtr ctxt);
void
xmlParseContent(xmlParserCtxtPtr ctxt);
xmlNodePtr
void
xmlParseElement(xmlParserCtxtPtr ctxt);
CHAR *
xmlParseVersionNum(xmlParserCtxtPtr ctxt);
@ -628,5 +630,12 @@ xmlParseXMLDecl(xmlParserCtxtPtr ctxt);
void
xmlParseMisc(xmlParserCtxtPtr ctxt);
/*
* Generated by MACROS on top of parser.c c.f. PUSH_AND_POP
*/
extern int nodePush(xmlParserCtxtPtr ctxt, xmlNodePtr value);
extern xmlNodePtr nodePop(xmlParserCtxtPtr ctxt);
extern int inputPush(xmlParserCtxtPtr ctxt, xmlParserInputPtr value);
extern xmlParserInputPtr inputPop(xmlParserCtxtPtr ctxt);
#endif /* __XML_PARSER_INTERNALS_H__ */

4
tree.c
View File

@ -1088,7 +1088,7 @@ xmlNewDocTextLen(xmlDocPtr doc, const CHAR *content, int len) {
* Returns a pointer to the new node object.
*/
xmlNodePtr
xmlNewComment(CHAR *content) {
xmlNewComment(const CHAR *content) {
xmlNodePtr cur;
/*
@ -1128,7 +1128,7 @@ xmlNewComment(CHAR *content) {
* Returns a pointer to the new node object.
*/
xmlNodePtr
xmlNewDocComment(xmlDocPtr doc, CHAR *content) {
xmlNewDocComment(xmlDocPtr doc, const CHAR *content) {
xmlNodePtr cur;
cur = xmlNewComment(content);

4
tree.h
View File

@ -283,8 +283,8 @@ xmlNodePtr xmlNewDocText(xmlDocPtr doc, const CHAR *content);
xmlNodePtr xmlNewText(const CHAR *content);
xmlNodePtr xmlNewDocTextLen(xmlDocPtr doc, const CHAR *content, int len);
xmlNodePtr xmlNewTextLen(const CHAR *content, int len);
xmlNodePtr xmlNewDocComment(xmlDocPtr doc, CHAR *content);
xmlNodePtr xmlNewComment(CHAR *content);
xmlNodePtr xmlNewDocComment(xmlDocPtr doc, const CHAR *content);
xmlNodePtr xmlNewComment(const CHAR *content);
xmlNodePtr xmlNewReference(xmlDocPtr doc, const CHAR *name);
xmlNodePtr xmlCopyNode(xmlNodePtr node, int recursive);
xmlNodePtr xmlCopyNodeList(xmlNodePtr node);

10
valid.c
View File

@ -216,7 +216,7 @@ xmlCreateElementTable(void) {
* Returns NULL if not, othervise the entity
*/
xmlElementPtr
xmlAddElementDecl(xmlDtdPtr dtd, CHAR *name, int type,
xmlAddElementDecl(xmlDtdPtr dtd, const CHAR *name, int type,
xmlElementContentPtr content) {
xmlElementPtr ret, cur;
xmlElementTablePtr table;
@ -560,8 +560,9 @@ xmlCreateAttributeTable(void) {
* Returns NULL if not, othervise the entity
*/
xmlAttributePtr
xmlAddAttributeDecl(xmlDtdPtr dtd, CHAR *elem, CHAR *name, int type, int def,
CHAR *defaultValue, xmlEnumerationPtr tree) {
xmlAddAttributeDecl(xmlDtdPtr dtd, const CHAR *elem, const CHAR *name,
int type, int def, const CHAR *defaultValue,
xmlEnumerationPtr tree) {
xmlAttributePtr ret, cur;
xmlAttributeTablePtr table;
int i;
@ -890,7 +891,8 @@ xmlCreateNotationTable(void) {
* Returns NULL if not, othervise the entity
*/
xmlNotationPtr
xmlAddNotationDecl(xmlDtdPtr dtd, CHAR *name, CHAR *PublicID, CHAR *SystemID) {
xmlAddNotationDecl(xmlDtdPtr dtd, const CHAR *name, const CHAR *PublicID,
const CHAR *SystemID) {
xmlNotationPtr ret, cur;
xmlNotationTablePtr table;
int i;

12
valid.h
View File

@ -54,8 +54,8 @@ typedef struct xmlAttributeTable {
typedef xmlAttributeTable *xmlAttributeTablePtr;
/* Notation */
xmlNotationPtr xmlAddNotationDecl(xmlDtdPtr dtd, CHAR *name,
CHAR *PublicID, CHAR *SystemID);
xmlNotationPtr xmlAddNotationDecl(xmlDtdPtr dtd, const CHAR *name,
const CHAR *PublicID, const CHAR *SystemID);
xmlNotationTablePtr xmlCopyNotationTable(xmlNotationTablePtr table);
void xmlFreeNotationTable(xmlNotationTablePtr table);
void xmlDumpNotationTable(xmlNotationTablePtr table);
@ -66,7 +66,7 @@ xmlElementContentPtr xmlCopyElementContent(xmlElementContentPtr content);
void xmlFreeElementContent(xmlElementContentPtr cur);
/* Element */
xmlElementPtr xmlAddElementDecl(xmlDtdPtr dtd, CHAR *name, int type,
xmlElementPtr xmlAddElementDecl(xmlDtdPtr dtd, const CHAR *name, int type,
xmlElementContentPtr content);
xmlElementTablePtr xmlCopyElementTable(xmlElementTablePtr table);
void xmlFreeElementTable(xmlElementTablePtr table);
@ -78,9 +78,9 @@ void xmlFreeEnumeration(xmlEnumerationPtr cur);
xmlEnumerationPtr xmlCopyEnumeration(xmlEnumerationPtr cur);
/* Attribute */
xmlAttributePtr xmlAddAttributeDecl(xmlDtdPtr dtd, CHAR *elem,
CHAR *name, int type, int def,
CHAR *defaultValue, xmlEnumerationPtr tree);
xmlAttributePtr xmlAddAttributeDecl(xmlDtdPtr dtd, const CHAR *elem,
const CHAR *name, int type, int def,
const CHAR *defaultValue, xmlEnumerationPtr tree);
xmlAttributeTablePtr xmlCopyAttributeTable(xmlAttributeTablePtr table);
void xmlFreeAttributeTable(xmlAttributeTablePtr table);
void xmlDumpAttributeTable(xmlAttributeTablePtr table);