valid.h File Reference

#include <libxml/xmlversion.h>
#include <libxml/xmlerror.h>
#include <libxml/tree.h>
#include <libxml/list.h>
#include <libxml/xmlautomata.h>
#include <libxml/xmlregexp.h>

Include dependency graph for valid.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_xmlValidCtxt

Typedefs
typedef struct _xmlValidState	xmlValidState
typedef xmlValidState *	xmlValidStatePtr
typedef void(XMLCDECL *	xmlValidityErrorFunc) (void *ctx, const char *msg,...) LIBXML_ATTR_FORMAT(2
typedef void(XMLCDECL *) typede	void) (XMLCDECL *xmlValidityWarningFunc) (void *ctx
typedef void(XMLCDECL *) typedef const char	msg)
typedef void(XMLCDECL *) typedef const cha	LIBXML_ATTR_FORMAT) (2, 3)
typedef struct _xmlValidCtxt	xmlValidCtxt
typedef xmlValidCtxt *	xmlValidCtxtPtr
typedef struct _xmlHashTable	xmlNotationTable
typedef xmlNotationTable *	xmlNotationTablePtr
typedef struct _xmlHashTable	xmlElementTable
typedef xmlElementTable *	xmlElementTablePtr
typedef struct _xmlHashTable	xmlAttributeTable
typedef xmlAttributeTable *	xmlAttributeTablePtr
typedef struct _xmlHashTable	xmlIDTable
typedef xmlIDTable *	xmlIDTablePtr
typedef struct _xmlHashTable	xmlRefTable
typedef xmlRefTable *	xmlRefTablePtr

Functions
XMLPUBFUN xmlNotationPtr XMLCALL	xmlAddNotationDecl (xmlValidCtxtPtr ctxt, xmlDtdPtr dtd, const xmlChar *name, const xmlChar *PublicID, const xmlChar *SystemID)
XMLPUBFUN void XMLCALL	xmlFreeNotationTable (xmlNotationTablePtr table)
XMLPUBFUN xmlElementContentPtr XMLCALL	xmlNewElementContent (const xmlChar *name, xmlElementContentType type)
XMLPUBFUN xmlElementContentPtr XMLCALL	xmlCopyElementContent (xmlElementContentPtr content)
XMLPUBFUN void XMLCALL	xmlFreeElementContent (xmlElementContentPtr cur)
XMLPUBFUN xmlElementContentPtr XMLCALL	xmlNewDocElementContent (xmlDocPtr doc, const xmlChar *name, xmlElementContentType type)
XMLPUBFUN xmlElementContentPtr XMLCALL	xmlCopyDocElementContent (xmlDocPtr doc, xmlElementContentPtr content)
XMLPUBFUN void XMLCALL	xmlFreeDocElementContent (xmlDocPtr doc, xmlElementContentPtr cur)
XMLPUBFUN void XMLCALL	xmlSnprintfElementContent (char *buf, int size, xmlElementContentPtr content, int englob)
XMLPUBFUN xmlElementPtr XMLCALL	xmlAddElementDecl (xmlValidCtxtPtr ctxt, xmlDtdPtr dtd, const xmlChar *name, xmlElementTypeVal type, xmlElementContentPtr content)
XMLPUBFUN void XMLCALL	xmlFreeElementTable (xmlElementTablePtr table)
XMLPUBFUN xmlEnumerationPtr XMLCALL	xmlCreateEnumeration (const xmlChar *name)
XMLPUBFUN void XMLCALL	xmlFreeEnumeration (xmlEnumerationPtr cur)
XMLPUBFUN xmlAttributePtr XMLCALL	xmlAddAttributeDecl (xmlValidCtxtPtr ctxt, xmlDtdPtr dtd, const xmlChar *elem, const xmlChar *name, const xmlChar *ns, xmlAttributeType type, xmlAttributeDefault def, const xmlChar *defaultValue, xmlEnumerationPtr tree)
XMLPUBFUN void XMLCALL	xmlFreeAttributeTable (xmlAttributeTablePtr table)
XMLPUBFUN xmlIDPtr XMLCALL	xmlAddID (xmlValidCtxtPtr ctxt, xmlDocPtr doc, const xmlChar *value, xmlAttrPtr attr)
XMLPUBFUN void XMLCALL	xmlFreeIDTable (xmlIDTablePtr table)
XMLPUBFUN xmlAttrPtr XMLCALL	xmlGetID (xmlDocPtr doc, const xmlChar *ID)
XMLPUBFUN int XMLCALL	xmlIsID (xmlDocPtr doc, xmlNodePtr elem, xmlAttrPtr attr)
XMLPUBFUN int XMLCALL	xmlRemoveID (xmlDocPtr doc, xmlAttrPtr attr)
XMLPUBFUN xmlRefPtr XMLCALL	xmlAddRef (xmlValidCtxtPtr ctxt, xmlDocPtr doc, const xmlChar *value, xmlAttrPtr attr)
XMLPUBFUN void XMLCALL	xmlFreeRefTable (xmlRefTablePtr table)
XMLPUBFUN int XMLCALL	xmlIsRef (xmlDocPtr doc, xmlNodePtr elem, xmlAttrPtr attr)
XMLPUBFUN int XMLCALL	xmlRemoveRef (xmlDocPtr doc, xmlAttrPtr attr)
XMLPUBFUN xmlListPtr XMLCALL	xmlGetRefs (xmlDocPtr doc, const xmlChar *ID)
XMLPUBFUN int XMLCALL	xmlIsMixedElement (xmlDocPtr doc, const xmlChar *name)
XMLPUBFUN xmlAttributePtr XMLCALL	xmlGetDtdAttrDesc (xmlDtdPtr dtd, const xmlChar *elem, const xmlChar *name)
XMLPUBFUN xmlAttributePtr XMLCALL	xmlGetDtdQAttrDesc (xmlDtdPtr dtd, const xmlChar *elem, const xmlChar *name, const xmlChar *prefix)
XMLPUBFUN xmlNotationPtr XMLCALL	xmlGetDtdNotationDesc (xmlDtdPtr dtd, const xmlChar *name)
XMLPUBFUN xmlElementPtr XMLCALL	xmlGetDtdQElementDesc (xmlDtdPtr dtd, const xmlChar *name, const xmlChar *prefix)
XMLPUBFUN xmlElementPtr XMLCALL	xmlGetDtdElementDesc (xmlDtdPtr dtd, const xmlChar *name)

Typedef Documentation

LIBXML_ATTR_FORMAT

typedef void(XMLCDECL *) typedef const cha LIBXML_ATTR_FORMAT) (2, 3)

Definition at line 59 of file valid.h.

msg

typedef void(XMLCDECL *) typedef const char msg)

Definition at line 58 of file valid.h.

void

typedef void(XMLCDECL *) typede void) (XMLCDECL *xmlValidityWarningFunc)(void *ctx

xmlValidityWarningFunc: @ctx: usually an xmlValidCtxtPtr to a validity error context, but comes from ctxt->userData (which normally contains such a pointer); ctxt->userData can be changed by the user. @msg: the string to format *printf like vararg ...: remaining arguments to the format

Callback called when a validity warning is found. This is a message oriented function similar to an *printf function.

Definition at line 57 of file valid.h.

xmlAttributeTable

typedef struct _xmlHashTable xmlAttributeTable

Definition at line 133 of file valid.h.

xmlAttributeTablePtr

typedef xmlAttributeTable* xmlAttributeTablePtr

Definition at line 134 of file valid.h.

xmlElementTable

typedef struct _xmlHashTable xmlElementTable

Definition at line 125 of file valid.h.

xmlElementTablePtr

typedef xmlElementTable* xmlElementTablePtr

Definition at line 126 of file valid.h.

xmlIDTable

typedef struct _xmlHashTable xmlIDTable

Definition at line 141 of file valid.h.

xmlIDTablePtr

typedef xmlIDTable* xmlIDTablePtr

Definition at line 142 of file valid.h.

xmlNotationTable

typedef struct _xmlHashTable xmlNotationTable

Definition at line 117 of file valid.h.

xmlNotationTablePtr

typedef xmlNotationTable* xmlNotationTablePtr

Definition at line 118 of file valid.h.

xmlRefTable

typedef struct _xmlHashTable xmlRefTable

Definition at line 149 of file valid.h.

xmlRefTablePtr

typedef xmlRefTable* xmlRefTablePtr

Definition at line 150 of file valid.h.

xmlValidCtxt

typedef struct _xmlValidCtxt xmlValidCtxt

Definition at line 80 of file valid.h.

xmlValidCtxtPtr

typedef xmlValidCtxt* xmlValidCtxtPtr

Definition at line 81 of file valid.h.

xmlValidityErrorFunc

typedef void(XMLCDECL * xmlValidityErrorFunc) (void *ctx, const char *msg,...) LIBXML_ATTR_FORMAT(2

xmlValidityErrorFunc: @ctx: usually an xmlValidCtxtPtr to a validity error context, but comes from ctxt->userData (which normally contains such a pointer); ctxt->userData can be changed by the user. @msg: the string to format *printf like vararg ...: remaining arguments to the format

Callback called when a validity error is found. This is a message oriented function similar to an *printf function.

Definition at line 42 of file valid.h.

xmlValidState

typedef struct _xmlValidState xmlValidState

Definition at line 28 of file valid.h.

xmlValidStatePtr

typedef xmlValidState* xmlValidStatePtr

Definition at line 29 of file valid.h.

Function Documentation

xmlAddAttributeDecl()

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

Definition at line 1938 of file valid.c.

                                                                 {
    xmlAttributePtr ret;
    xmlAttributeTablePtr table;
    xmlElementPtr elemDef;
    xmlDictPtr dict = NULL;

    if (dtd == NULL) {
    xmlFreeEnumeration(tree);
    return(NULL);
    }
    if (name == NULL) {
    xmlFreeEnumeration(tree);
    return(NULL);
    }
    if (elem == NULL) {
    xmlFreeEnumeration(tree);
    return(NULL);
    }
    if (dtd->doc != NULL)
    dict = dtd->doc->dict;

#ifdef LIBXML_VALID_ENABLED
    /*
     * Check the type and possibly the default value.
     */
    switch (type) {
        case XML_ATTRIBUTE_CDATA:
        break;
        case XML_ATTRIBUTE_ID:
        break;
        case XML_ATTRIBUTE_IDREF:
        break;
        case XML_ATTRIBUTE_IDREFS:
        break;
        case XML_ATTRIBUTE_ENTITY:
        break;
        case XML_ATTRIBUTE_ENTITIES:
        break;
        case XML_ATTRIBUTE_NMTOKEN:
        break;
        case XML_ATTRIBUTE_NMTOKENS:
        break;
        case XML_ATTRIBUTE_ENUMERATION:
        break;
        case XML_ATTRIBUTE_NOTATION:
        break;
    default:
        xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
            "Internal: ATTRIBUTE struct corrupted invalid type\n",
            NULL);
        xmlFreeEnumeration(tree);
        return(NULL);
    }
    if ((defaultValue != NULL) &&
        (!xmlValidateAttributeValueInternal(dtd->doc, type, defaultValue))) {
    xmlErrValidNode(ctxt, (xmlNodePtr) dtd, XML_DTD_ATTRIBUTE_DEFAULT,
                    "Attribute %s of %s: invalid default value\n",
                    elem, name, defaultValue);
    defaultValue = NULL;
    if (ctxt != NULL)
        ctxt->valid = 0;
    }
#endif /* LIBXML_VALID_ENABLED */

    /*
     * Check first that an attribute defined in the external subset wasn't
     * already defined in the internal subset
     */
    if ((dtd->doc != NULL) && (dtd->doc->extSubset == dtd) &&
    (dtd->doc->intSubset != NULL) &&
    (dtd->doc->intSubset->attributes != NULL)) {
        ret = xmlHashLookup3(dtd->doc->intSubset->attributes, name, ns, elem);
    if (ret != NULL) {
        xmlFreeEnumeration(tree);
        return(NULL);
    }
    }

    /*
     * Create the Attribute table if needed.
     */
    table = (xmlAttributeTablePtr) dtd->attributes;
    if (table == NULL) {
        table = xmlHashCreateDict(0, dict);
    dtd->attributes = (void *) table;
    }
    if (table == NULL) {
    xmlVErrMemory(ctxt,
            "xmlAddAttributeDecl: Table creation failed!\n");
    xmlFreeEnumeration(tree);
        return(NULL);
    }


    ret = (xmlAttributePtr) xmlMalloc(sizeof(xmlAttribute));
    if (ret == NULL) {
    xmlVErrMemory(ctxt, "malloc failed");
    xmlFreeEnumeration(tree);
    return(NULL);
    }
    memset(ret, 0, sizeof(xmlAttribute));
    ret->type = XML_ATTRIBUTE_DECL;

    /*
     * fill the structure.
     */
    ret->atype = type;
    /*
     * doc must be set before possible error causes call
     * to xmlFreeAttribute (because it's used to check on
     * dict use)
     */
    ret->doc = dtd->doc;
    if (dict) {
    ret->name = xmlDictLookup(dict, name, -1);
    ret->prefix = xmlDictLookup(dict, ns, -1);
    ret->elem = xmlDictLookup(dict, elem, -1);
    } else {
    ret->name = xmlStrdup(name);
    ret->prefix = xmlStrdup(ns);
    ret->elem = xmlStrdup(elem);
    }
    ret->def = def;
    ret->tree = tree;
    if (defaultValue != NULL) {
        if (dict)
        ret->defaultValue = xmlDictLookup(dict, defaultValue, -1);
    else
        ret->defaultValue = xmlStrdup(defaultValue);
    }

    /*
     * Validity Check:
     * Search the DTD for previous declarations of the ATTLIST
     */
    if (xmlHashAddEntry3(table, ret->name, ret->prefix, ret->elem, ret) < 0) {
#ifdef LIBXML_VALID_ENABLED
    /*
     * The attribute is already defined in this DTD.
     */
    xmlErrValidWarning(ctxt, (xmlNodePtr) dtd, XML_DTD_ATTRIBUTE_REDEFINED,
         "Attribute %s of element %s: already defined\n",
         name, elem, NULL);
#endif /* LIBXML_VALID_ENABLED */
    xmlFreeAttribute(ret);
    return(NULL);
    }

    /*
     * Validity Check:
     * Multiple ID per element
     */
    elemDef = xmlGetDtdElementDesc2(dtd, elem, 1);
    if (elemDef != NULL) {

#ifdef LIBXML_VALID_ENABLED
        if ((type == XML_ATTRIBUTE_ID) &&
        (xmlScanIDAttributeDecl(NULL, elemDef, 1) != 0)) {
        xmlErrValidNode(ctxt, (xmlNodePtr) dtd, XML_DTD_MULTIPLE_ID,
       "Element %s has too may ID attributes defined : %s\n",
           elem, name, NULL);
        if (ctxt != NULL)
        ctxt->valid = 0;
    }
#endif /* LIBXML_VALID_ENABLED */

    /*
     * Insert namespace default def first they need to be
     * processed first.
     */
    if ((xmlStrEqual(ret->name, BAD_CAST "xmlns")) ||
        ((ret->prefix != NULL &&
         (xmlStrEqual(ret->prefix, BAD_CAST "xmlns"))))) {
        ret->nexth = elemDef->attributes;
        elemDef->attributes = ret;
    } else {
        xmlAttributePtr tmp = elemDef->attributes;

        while ((tmp != NULL) &&
           ((xmlStrEqual(tmp->name, BAD_CAST "xmlns")) ||
            ((ret->prefix != NULL &&
             (xmlStrEqual(ret->prefix, BAD_CAST "xmlns")))))) {
        if (tmp->nexth == NULL)
            break;
        tmp = tmp->nexth;
        }
        if (tmp != NULL) {
        ret->nexth = tmp->nexth;
            tmp->nexth = ret;
        } else {
        ret->nexth = elemDef->attributes;
        elemDef->attributes = ret;
        }
    }
    }

    /*
     * Link it to the DTD
     */
    ret->parent = dtd;
    if (dtd->last == NULL) {
    dtd->children = dtd->last = (xmlNodePtr) ret;
    } else {
        dtd->last->next = (xmlNodePtr) ret;
    ret->prev = dtd->last;
    dtd->last = (xmlNodePtr) ret;
    }
    return(ret);
}

Referenced by xmlSAX2AttributeDecl().

xmlAddElementDecl()

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

Definition at line 1387 of file valid.c.

                                        {
    xmlElementPtr ret;
    xmlElementTablePtr table;
    xmlAttributePtr oldAttributes = NULL;
    xmlChar *ns, *uqname;

    if (dtd == NULL) {
    return(NULL);
    }
    if (name == NULL) {
    return(NULL);
    }

    switch (type) {
        case XML_ELEMENT_TYPE_EMPTY:
        if (content != NULL) {
        xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
                "xmlAddElementDecl: content != NULL for EMPTY\n",
            NULL);
        return(NULL);
        }
        break;
    case XML_ELEMENT_TYPE_ANY:
        if (content != NULL) {
        xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
                "xmlAddElementDecl: content != NULL for ANY\n",
            NULL);
        return(NULL);
        }
        break;
    case XML_ELEMENT_TYPE_MIXED:
        if (content == NULL) {
        xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
                "xmlAddElementDecl: content == NULL for MIXED\n",
            NULL);
        return(NULL);
        }
        break;
    case XML_ELEMENT_TYPE_ELEMENT:
        if (content == NULL) {
        xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
                "xmlAddElementDecl: content == NULL for ELEMENT\n",
            NULL);
        return(NULL);
        }
        break;
    default:
        xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
            "Internal: ELEMENT decl corrupted invalid type\n",
            NULL);
        return(NULL);
    }

    /*
     * check if name is a QName
     */
    uqname = xmlSplitQName2(name, &ns);
    if (uqname != NULL)
    name = uqname;

    /*
     * Create the Element table if needed.
     */
    table = (xmlElementTablePtr) dtd->elements;
    if (table == NULL) {
    xmlDictPtr dict = NULL;

    if (dtd->doc != NULL)
        dict = dtd->doc->dict;
        table = xmlHashCreateDict(0, dict);
    dtd->elements = (void *) table;
    }
    if (table == NULL) {
    xmlVErrMemory(ctxt,
            "xmlAddElementDecl: Table creation failed!\n");
    if (uqname != NULL)
        xmlFree(uqname);
    if (ns != NULL)
        xmlFree(ns);
        return(NULL);
    }

    /*
     * lookup old attributes inserted on an undefined element in the
     * internal subset.
     */
    if ((dtd->doc != NULL) && (dtd->doc->intSubset != NULL)) {
    ret = xmlHashLookup2(dtd->doc->intSubset->elements, name, ns);
    if ((ret != NULL) && (ret->etype == XML_ELEMENT_TYPE_UNDEFINED)) {
        oldAttributes = ret->attributes;
        ret->attributes = NULL;
        xmlHashRemoveEntry2(dtd->doc->intSubset->elements, name, ns, NULL);
        xmlFreeElement(ret);
    }
    }

    /*
     * The element may already be present if one of its attribute
     * was registered first
     */
    ret = xmlHashLookup2(table, name, ns);
    if (ret != NULL) {
    if (ret->etype != XML_ELEMENT_TYPE_UNDEFINED) {
#ifdef LIBXML_VALID_ENABLED
        /*
         * The element is already defined in this DTD.
         */
        xmlErrValidNode(ctxt, (xmlNodePtr) dtd, XML_DTD_ELEM_REDEFINED,
                        "Redefinition of element %s\n",
                name, NULL, NULL);
#endif /* LIBXML_VALID_ENABLED */
        if (uqname != NULL)
        xmlFree(uqname);
            if (ns != NULL)
            xmlFree(ns);
        return(NULL);
    }
    if (ns != NULL) {
        xmlFree(ns);
        ns = NULL;
    }
    } else {
    ret = (xmlElementPtr) xmlMalloc(sizeof(xmlElement));
    if (ret == NULL) {
        xmlVErrMemory(ctxt, "malloc failed");
        if (uqname != NULL)
        xmlFree(uqname);
            if (ns != NULL)
            xmlFree(ns);
        return(NULL);
    }
    memset(ret, 0, sizeof(xmlElement));
    ret->type = XML_ELEMENT_DECL;

    /*
     * fill the structure.
     */
    ret->name = xmlStrdup(name);
    if (ret->name == NULL) {
        xmlVErrMemory(ctxt, "malloc failed");
        if (uqname != NULL)
        xmlFree(uqname);
            if (ns != NULL)
            xmlFree(ns);
        xmlFree(ret);
        return(NULL);
    }
    ret->prefix = ns;

    /*
     * Validity Check:
     * Insertion must not fail
     */
    if (xmlHashAddEntry2(table, name, ns, ret)) {
#ifdef LIBXML_VALID_ENABLED
        /*
         * The element is already defined in this DTD.
         */
        xmlErrValidNode(ctxt, (xmlNodePtr) dtd, XML_DTD_ELEM_REDEFINED,
                        "Redefinition of element %s\n",
                name, NULL, NULL);
#endif /* LIBXML_VALID_ENABLED */
        xmlFreeElement(ret);
        if (uqname != NULL)
        xmlFree(uqname);
        return(NULL);
    }
    /*
     * For new element, may have attributes from earlier
     * definition in internal subset
     */
    ret->attributes = oldAttributes;
    }

    /*
     * Finish to fill the structure.
     */
    ret->etype = type;
    /*
     * Avoid a stupid copy when called by the parser
     * and flag it by setting a special parent value
     * so the parser doesn't unallocate it.
     */
    if ((ctxt != NULL) &&
        ((ctxt->finishDtd == XML_CTXT_FINISH_DTD_0) ||
         (ctxt->finishDtd == XML_CTXT_FINISH_DTD_1))) {
    ret->content = content;
    if (content != NULL)
        content->parent = (xmlElementContentPtr) 1;
    } else {
    ret->content = xmlCopyDocElementContent(dtd->doc, content);
    }

    /*
     * Link it to the DTD
     */
    ret->parent = dtd;
    ret->doc = dtd->doc;
    if (dtd->last == NULL) {
    dtd->children = dtd->last = (xmlNodePtr) ret;
    } else {
        dtd->last->next = (xmlNodePtr) ret;
    ret->prev = dtd->last;
    dtd->last = (xmlNodePtr) ret;
    }
    if (uqname != NULL)
    xmlFree(uqname);
    return(ret);
}

Referenced by xmlSAX2ElementDecl().

xmlAddID()

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

xmlAddID: @ctxt: the validation context @doc: pointer to the document @value: the value name @attr: the attribute holding the ID

Register a new id declaration

Returns NULL if not, otherwise the new xmlIDPtr

Definition at line 2602 of file valid.c.

                          {
    xmlIDPtr ret;
    xmlIDTablePtr table;

    if (doc == NULL) {
    return(NULL);
    }
    if (value == NULL) {
    return(NULL);
    }
    if (attr == NULL) {
    return(NULL);
    }

    /*
     * Create the ID table if needed.
     */
    table = (xmlIDTablePtr) doc->ids;
    if (table == NULL)  {
        doc->ids = table = xmlHashCreateDict(0, doc->dict);
    }
    if (table == NULL) {
    xmlVErrMemory(ctxt,
        "xmlAddID: Table creation failed!\n");
        return(NULL);
    }

    ret = (xmlIDPtr) xmlMalloc(sizeof(xmlID));
    if (ret == NULL) {
    xmlVErrMemory(ctxt, "malloc failed");
    return(NULL);
    }

    /*
     * fill the structure.
     */
    ret->value = xmlStrdup(value);
    ret->doc = doc;
    if ((ctxt != NULL) && (ctxt->vstateNr != 0)) {
    /*
     * Operating in streaming mode, attr is gonna disapear
     */
    if (doc->dict != NULL)
        ret->name = xmlDictLookup(doc->dict, attr->name, -1);
    else
        ret->name = xmlStrdup(attr->name);
    ret->attr = NULL;
    } else {
    ret->attr = attr;
    ret->name = NULL;
    }
    ret->lineno = xmlGetLineNo(attr->parent);

    if (xmlHashAddEntry(table, value, ret) < 0) {
#ifdef LIBXML_VALID_ENABLED
    /*
     * The id is already defined in this DTD.
     */
    if (ctxt != NULL) {
        xmlErrValidNode(ctxt, attr->parent, XML_DTD_ID_REDEFINED,
                "ID %s already defined\n", value, NULL, NULL);
    }
#endif /* LIBXML_VALID_ENABLED */
    xmlFreeID(ret);
    return(NULL);
    }
    if (attr != NULL)
    attr->atype = XML_ATTRIBUTE_ID;
    return(ret);
}

Referenced by xmlSAX2AttributeNs(), xsltAttribute(), and xsltAttrListTemplateProcess().

xmlAddNotationDecl()

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

Definition at line 2365 of file valid.c.

                                                                     {
    xmlNotationPtr ret;
    xmlNotationTablePtr table;

    if (dtd == NULL) {
    return(NULL);
    }
    if (name == NULL) {
    return(NULL);
    }
    if ((PublicID == NULL) && (SystemID == NULL)) {
    return(NULL);
    }

    /*
     * Create the Notation table if needed.
     */
    table = (xmlNotationTablePtr) dtd->notations;
    if (table == NULL) {
    xmlDictPtr dict = NULL;
    if (dtd->doc != NULL)
        dict = dtd->doc->dict;

        dtd->notations = table = xmlHashCreateDict(0, dict);
    }
    if (table == NULL) {
    xmlVErrMemory(ctxt,
        "xmlAddNotationDecl: Table creation failed!\n");
        return(NULL);
    }

    ret = (xmlNotationPtr) xmlMalloc(sizeof(xmlNotation));
    if (ret == NULL) {
    xmlVErrMemory(ctxt, "malloc failed");
    return(NULL);
    }
    memset(ret, 0, sizeof(xmlNotation));

    /*
     * fill the structure.
     */
    ret->name = xmlStrdup(name);
    if (SystemID != NULL)
        ret->SystemID = xmlStrdup(SystemID);
    if (PublicID != NULL)
        ret->PublicID = xmlStrdup(PublicID);

    /*
     * Validity Check:
     * Check the DTD for previous declarations of the ATTLIST
     */
    if (xmlHashAddEntry(table, name, ret)) {
#ifdef LIBXML_VALID_ENABLED
    xmlErrValid(NULL, XML_DTD_NOTATION_REDEFINED,
            "xmlAddNotationDecl: %s already defined\n",
            (const char *) name);
#endif /* LIBXML_VALID_ENABLED */
    xmlFreeNotation(ret);
    return(NULL);
    }
    return(ret);
}

Referenced by xmlSAX2NotationDecl().

xmlAddRef()

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

xmlAddRef: @ctxt: the validation context @doc: pointer to the document @value: the value name @attr: the attribute holding the Ref

Register a new ref declaration

Returns NULL if not, otherwise the new xmlRefPtr

Definition at line 2930 of file valid.c.

                     {
    xmlRefPtr ret;
    xmlRefTablePtr table;
    xmlListPtr ref_list;

    if (doc == NULL) {
        return(NULL);
    }
    if (value == NULL) {
        return(NULL);
    }
    if (attr == NULL) {
        return(NULL);
    }

    /*
     * Create the Ref table if needed.
     */
    table = (xmlRefTablePtr) doc->refs;
    if (table == NULL) {
        doc->refs = table = xmlHashCreateDict(0, doc->dict);
    }
    if (table == NULL) {
    xmlVErrMemory(ctxt,
            "xmlAddRef: Table creation failed!\n");
        return(NULL);
    }

    ret = (xmlRefPtr) xmlMalloc(sizeof(xmlRef));
    if (ret == NULL) {
    xmlVErrMemory(ctxt, "malloc failed");
        return(NULL);
    }

    /*
     * fill the structure.
     */
    ret->value = xmlStrdup(value);
    if ((ctxt != NULL) && (ctxt->vstateNr != 0)) {
    /*
     * Operating in streaming mode, attr is gonna disapear
     */
    ret->name = xmlStrdup(attr->name);
    ret->attr = NULL;
    } else {
    ret->name = NULL;
    ret->attr = attr;
    }
    ret->lineno = xmlGetLineNo(attr->parent);

    /* To add a reference :-
     * References are maintained as a list of references,
     * Lookup the entry, if no entry create new nodelist
     * Add the owning node to the NodeList
     * Return the ref
     */

    if (NULL == (ref_list = xmlHashLookup(table, value))) {
        if (NULL == (ref_list = xmlListCreate(xmlFreeRef, xmlDummyCompare))) {
        xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
            "xmlAddRef: Reference list creation failed!\n",
            NULL);
        goto failed;
        }
        if (xmlHashAddEntry(table, value, ref_list) < 0) {
            xmlListDelete(ref_list);
        xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
            "xmlAddRef: Reference list insertion failed!\n",
            NULL);
        goto failed;
        }
    }
    if (xmlListAppend(ref_list, ret) != 0) {
    xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
            "xmlAddRef: Reference list insertion failed!\n",
            NULL);
        goto failed;
    }
    return(ret);
failed:
    if (ret != NULL) {
        if (ret->value != NULL)
        xmlFree((char *)ret->value);
        if (ret->name != NULL)
        xmlFree((char *)ret->name);
        xmlFree(ret);
    }
    return(NULL);
}

Referenced by xmlSAX2AttributeNs().

xmlCopyDocElementContent()

XMLPUBFUN xmlElementContentPtr XMLCALL xmlCopyDocElementContent	(	xmlDocPtr	doc,
		xmlElementContentPtr	cur
	)

xmlCopyDocElementContent: @doc: the document owning the element declaration @cur: An element content pointer.

Build a copy of an element content description.

Returns the new xmlElementContentPtr or NULL in case of error.

Definition at line 1008 of file valid.c.

                                                                  {
    xmlElementContentPtr ret = NULL, prev = NULL, tmp;
    xmlDictPtr dict = NULL;

    if (cur == NULL) return(NULL);

    if (doc != NULL)
        dict = doc->dict;

    ret = (xmlElementContentPtr) xmlMalloc(sizeof(xmlElementContent));
    if (ret == NULL) {
    xmlVErrMemory(NULL, "malloc failed");
    return(NULL);
    }
    memset(ret, 0, sizeof(xmlElementContent));
    ret->type = cur->type;
    ret->ocur = cur->ocur;
    if (cur->name != NULL) {
    if (dict)
        ret->name = xmlDictLookup(dict, cur->name, -1);
    else
        ret->name = xmlStrdup(cur->name);
    }

    if (cur->prefix != NULL) {
    if (dict)
        ret->prefix = xmlDictLookup(dict, cur->prefix, -1);
    else
        ret->prefix = xmlStrdup(cur->prefix);
    }
    if (cur->c1 != NULL)
        ret->c1 = xmlCopyDocElementContent(doc, cur->c1);
    if (ret->c1 != NULL)
    ret->c1->parent = ret;
    if (cur->c2 != NULL) {
        prev = ret;
    cur = cur->c2;
    while (cur != NULL) {
        tmp = (xmlElementContentPtr) xmlMalloc(sizeof(xmlElementContent));
        if (tmp == NULL) {
        xmlVErrMemory(NULL, "malloc failed");
        return(ret);
        }
        memset(tmp, 0, sizeof(xmlElementContent));
        tmp->type = cur->type;
        tmp->ocur = cur->ocur;
        prev->c2 = tmp;
        if (cur->name != NULL) {
        if (dict)
            tmp->name = xmlDictLookup(dict, cur->name, -1);
        else
            tmp->name = xmlStrdup(cur->name);
        }

        if (cur->prefix != NULL) {
        if (dict)
            tmp->prefix = xmlDictLookup(dict, cur->prefix, -1);
        else
            tmp->prefix = xmlStrdup(cur->prefix);
        }
        if (cur->c1 != NULL)
            tmp->c1 = xmlCopyDocElementContent(doc,cur->c1);
        if (tmp->c1 != NULL)
        tmp->c1->parent = ret;
        prev = tmp;
        cur = cur->c2;
    }
    }
    return(ret);
}

Referenced by xmlAddElementDecl(), and xmlCopyElementContent().

xmlCopyElementContent()

XMLPUBFUN xmlElementContentPtr XMLCALL xmlCopyElementContent

(

xmlElementContentPtr

cur

)

xmlCopyElementContent: @cur: An element content pointer.

Build a copy of an element content description. Deprecated, use xmlCopyDocElementContent instead

Returns the new xmlElementContentPtr or NULL in case of error.

Definition at line 1089 of file valid.c.

                                                {
    return(xmlCopyDocElementContent(NULL, cur));
}

xmlCreateEnumeration()

XMLPUBFUN xmlEnumerationPtr XMLCALL xmlCreateEnumeration

(

const xmlChar *

name

)

Definition at line 1766 of file valid.c.

                                          {
    xmlEnumerationPtr ret;

    ret = (xmlEnumerationPtr) xmlMalloc(sizeof(xmlEnumeration));
    if (ret == NULL) {
    xmlVErrMemory(NULL, "malloc failed");
        return(NULL);
    }
    memset(ret, 0, sizeof(xmlEnumeration));

    if (name != NULL)
        ret->name = xmlStrdup(name);
    return(ret);
}

Referenced by xmlParseEnumerationType(), and xmlParseNotationType().

xmlFreeAttributeTable()

XMLPUBFUN void XMLCALL xmlFreeAttributeTable

(

xmlAttributeTablePtr

table

)

xmlFreeAttributeTable: @table: An attribute table

Deallocate the memory used by an entities hash table.

Definition at line 2164 of file valid.c.

                                                  {
    xmlHashFree(table, xmlFreeAttributeTableEntry);
}

xmlFreeDocElementContent()

XMLPUBFUN void XMLCALL xmlFreeDocElementContent	(	xmlDocPtr	doc,
		xmlElementContentPtr	cur
	)

xmlFreeDocElementContent: @doc: the document owning the element declaration @cur: the element content tree to free

Free an element content structure. The whole subtree is removed.

Definition at line 1101 of file valid.c.

                                                                  {
    xmlElementContentPtr next;
    xmlDictPtr dict = NULL;

    if (doc != NULL)
        dict = doc->dict;

    while (cur != NULL) {
        next = cur->c2;
    switch (cur->type) {
        case XML_ELEMENT_CONTENT_PCDATA:
        case XML_ELEMENT_CONTENT_ELEMENT:
        case XML_ELEMENT_CONTENT_SEQ:
        case XML_ELEMENT_CONTENT_OR:
        break;
        default:
        xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
            "Internal: ELEMENT content corrupted invalid type\n",
            NULL);
        return;
    }
    if (cur->c1 != NULL) xmlFreeDocElementContent(doc, cur->c1);
    if (dict) {
        if ((cur->name != NULL) && (!xmlDictOwns(dict, cur->name)))
            xmlFree((xmlChar *) cur->name);
        if ((cur->prefix != NULL) && (!xmlDictOwns(dict, cur->prefix)))
            xmlFree((xmlChar *) cur->prefix);
    } else {
        if (cur->name != NULL) xmlFree((xmlChar *) cur->name);
        if (cur->prefix != NULL) xmlFree((xmlChar *) cur->prefix);
    }
    xmlFree(cur);
    cur = next;
    }
}

Referenced by xmlFreeElement(), xmlFreeElementContent(), xmlParseElementChildrenContentDeclPriv(), xmlParseElementDecl(), and xmlParseElementMixedContentDecl().

xmlFreeElementContent()

XMLPUBFUN void XMLCALL xmlFreeElementContent

(

xmlElementContentPtr

cur

)

xmlFreeElementContent: @cur: the element content tree to free

Free an element content structure. The whole subtree is removed. Deprecated, use xmlFreeDocElementContent instead

Definition at line 1145 of file valid.c.

                                                {
    xmlFreeDocElementContent(NULL, cur);
}

xmlFreeElementTable()

XMLPUBFUN void XMLCALL xmlFreeElementTable

(

xmlElementTablePtr

table

)

xmlFreeElementTable: @table: An element table

Deallocate the memory used by an element hash table.

Definition at line 1612 of file valid.c.

                                              {
    xmlHashFree(table, xmlFreeElementTableEntry);
}

xmlFreeEnumeration()

XMLPUBFUN void XMLCALL xmlFreeEnumeration

(

xmlEnumerationPtr

cur

)

xmlFreeEnumeration: @cur: the tree to free.

free an enumeration attribute node (recursive).

Definition at line 1788 of file valid.c.

                                          {
    if (cur == NULL) return;

    if (cur->next != NULL) xmlFreeEnumeration(cur->next);

    if (cur->name != NULL) xmlFree((xmlChar *) cur->name);
    xmlFree(cur);
}

Referenced by attributeDeclDebug(), xmlAddAttributeDecl(), xmlFreeAttribute(), xmlParseAttributeListDecl(), xmlParseEnumerationType(), xmlParseNotationType(), and xmlSAX2AttributeDecl().

xmlFreeIDTable()

XMLPUBFUN void XMLCALL xmlFreeIDTable

(

xmlIDTablePtr

table

)

xmlFreeIDTable: @table: An id table

Deallocate the memory used by an ID hash table.

Definition at line 2686 of file valid.c.

                                    {
    xmlHashFree(table, xmlFreeIDTableEntry);
}

Referenced by xsltReleaseRVT().

xmlFreeNotationTable()

XMLPUBFUN void XMLCALL xmlFreeNotationTable

(

xmlNotationTablePtr

table

)

xmlFreeNotationTable: @table: An notation table

Deallocate the memory used by an entities hash table.

Definition at line 2442 of file valid.c.

                                                {
    xmlHashFree(table, xmlFreeNotationTableEntry);
}

xmlFreeRefTable()

XMLPUBFUN void XMLCALL xmlFreeRefTable

(

xmlRefTablePtr

table

)

xmlFreeRefTable: @table: An ref table

Deallocate the memory used by an Ref hash table.

Definition at line 3028 of file valid.c.

                                      {
    xmlHashFree(table, xmlFreeRefTableEntry);
}

Referenced by xsltReleaseRVT().

xmlGetDtdAttrDesc()

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

Definition at line 3298 of file valid.c.

                                                                           {
    xmlAttributeTablePtr table;
    xmlAttributePtr cur;
    xmlChar *uqname = NULL, *prefix = NULL;

    if (dtd == NULL) return(NULL);
    if (dtd->attributes == NULL) return(NULL);

    table = (xmlAttributeTablePtr) dtd->attributes;
    if (table == NULL)
    return(NULL);

    uqname = xmlSplitQName2(name, &prefix);

    if (uqname != NULL) {
    cur = xmlHashLookup3(table, uqname, prefix, elem);
    if (prefix != NULL) xmlFree(prefix);
    if (uqname != NULL) xmlFree(uqname);
    } else
    cur = xmlHashLookup3(table, name, NULL, elem);
    return(cur);
}

Referenced by xmlIsID(), xmlIsRef(), xsltGetCNsProp(), and xsltGetNsProp().

xmlGetDtdElementDesc()

XMLPUBFUN xmlElementPtr XMLCALL xmlGetDtdElementDesc	(	xmlDtdPtr	dtd,
		const xmlChar *	name
	)

Definition at line 3176 of file valid.c.

                                                         {
    xmlElementTablePtr table;
    xmlElementPtr cur;
    xmlChar *uqname = NULL, *prefix = NULL;

    if ((dtd == NULL) || (name == NULL)) return(NULL);
    if (dtd->elements == NULL)
    return(NULL);
    table = (xmlElementTablePtr) dtd->elements;

    uqname = xmlSplitQName2(name, &prefix);
    if (uqname != NULL)
        name = uqname;
    cur = xmlHashLookup2(table, name, prefix);
    if (prefix != NULL) xmlFree(prefix);
    if (uqname != NULL) xmlFree(uqname);
    return(cur);
}

Referenced by xmlIsMixedElement().

xmlGetDtdNotationDesc()

XMLPUBFUN xmlNotationPtr XMLCALL xmlGetDtdNotationDesc	(	xmlDtdPtr	dtd,
		const xmlChar *	name
	)

Definition at line 3357 of file valid.c.

                                                          {
    xmlNotationTablePtr table;

    if (dtd == NULL) return(NULL);
    if (dtd->notations == NULL) return(NULL);
    table = (xmlNotationTablePtr) dtd->notations;

    return(xmlHashLookup(table, name));
}

xmlGetDtdQAttrDesc()

XMLPUBFUN xmlAttributePtr XMLCALL xmlGetDtdQAttrDesc	(	xmlDtdPtr	dtd,
		const xmlChar *	elem,
		const xmlChar *	name,
		const xmlChar *	prefix
	)

Definition at line 3335 of file valid.c.

                                     {
    xmlAttributeTablePtr table;

    if (dtd == NULL) return(NULL);
    if (dtd->attributes == NULL) return(NULL);
    table = (xmlAttributeTablePtr) dtd->attributes;

    return(xmlHashLookup3(table, name, prefix, elem));
}

xmlGetDtdQElementDesc()

XMLPUBFUN xmlElementPtr XMLCALL xmlGetDtdQElementDesc	(	xmlDtdPtr	dtd,
		const xmlChar *	name,
		const xmlChar *	prefix
	)

Definition at line 3274 of file valid.c.

                                         {
    xmlElementTablePtr table;

    if (dtd == NULL) return(NULL);
    if (dtd->elements == NULL) return(NULL);
    table = (xmlElementTablePtr) dtd->elements;

    return(xmlHashLookup2(table, name, prefix));
}

xmlGetID()

XMLPUBFUN xmlAttrPtr XMLCALL xmlGetID	(	xmlDocPtr	doc,
		const xmlChar *	ID
	)

xmlGetID: @doc: pointer to the document @ID: the ID value

Search the attribute declaring the given ID

Returns NULL if not found, otherwise the xmlAttrPtr defining the ID

Definition at line 2803 of file valid.c.

                                           {
    xmlIDTablePtr table;
    xmlIDPtr id;

    if (doc == NULL) {
    return(NULL);
    }

    if (ID == NULL) {
    return(NULL);
    }

    table = (xmlIDTablePtr) doc->ids;
    if (table == NULL)
        return(NULL);

    id = xmlHashLookup(table, ID);
    if (id == NULL)
    return(NULL);
    if (id->attr == NULL) {
    /*
     * We are operating on a stream, return a well known reference
     * since the attribute node doesn't exist anymore
     */
    return((xmlAttrPtr) doc);
    }
    return(id->attr);
}

Referenced by xsltLoadStylesheetPI(), and xsltTestCompMatch().

xmlGetRefs()

XMLPUBFUN xmlListPtr XMLCALL xmlGetRefs	(	xmlDocPtr	doc,
		const xmlChar *	ID
	)

xmlGetRefs: @doc: pointer to the document @ID: the ID value

Find the set of references for the supplied ID.

Returns NULL if not found, otherwise node set for the ID.

Definition at line 3141 of file valid.c.

                                             {
    xmlRefTablePtr table;

    if (doc == NULL) {
        return(NULL);
    }

    if (ID == NULL) {
        return(NULL);
    }

    table = (xmlRefTablePtr) doc->refs;
    if (table == NULL)
        return(NULL);

    return (xmlHashLookup(table, ID));
}

xmlIsID()

XMLPUBFUN int XMLCALL xmlIsID	(	xmlDocPtr	doc,
		xmlNodePtr	elem,
		xmlAttrPtr	attr
	)

xmlIsID: @doc: the document @elem: the element carrying the attribute @attr: the attribute

Determine whether an attribute is of type ID. In case we have DTD(s) then this is done if DTD loading has been requested. In the case of HTML documents parsed with the HTML parser, then ID detection is done systematically.

Returns 0 or 1 depending on the lookup result

Definition at line 2704 of file valid.c.

                                                         {
    if ((attr == NULL) || (attr->name == NULL)) return(0);
    if ((attr->ns != NULL) && (attr->ns->prefix != NULL) &&
        (!strcmp((char *) attr->name, "id")) &&
        (!strcmp((char *) attr->ns->prefix, "xml")))
    return(1);
    if (doc == NULL) return(0);
    if ((doc->intSubset == NULL) && (doc->extSubset == NULL) &&
        (doc->type != XML_HTML_DOCUMENT_NODE)) {
    return(0);
    } else if (doc->type == XML_HTML_DOCUMENT_NODE) {
        if ((xmlStrEqual(BAD_CAST "id", attr->name)) ||
        ((xmlStrEqual(BAD_CAST "name", attr->name)) &&
        ((elem == NULL) || (xmlStrEqual(elem->name, BAD_CAST "a")))))
        return(1);
    return(0);
    } else if (elem == NULL) {
    return(0);
    } else {
    xmlAttributePtr attrDecl = NULL;

    xmlChar felem[50], fattr[50];
    xmlChar *fullelemname, *fullattrname;

    fullelemname = (elem->ns != NULL && elem->ns->prefix != NULL) ?
        xmlBuildQName(elem->name, elem->ns->prefix, felem, 50) :
        (xmlChar *)elem->name;

    fullattrname = (attr->ns != NULL && attr->ns->prefix != NULL) ?
        xmlBuildQName(attr->name, attr->ns->prefix, fattr, 50) :
        (xmlChar *)attr->name;

    if (fullelemname != NULL && fullattrname != NULL) {
        attrDecl = xmlGetDtdAttrDesc(doc->intSubset, fullelemname,
                                 fullattrname);
        if ((attrDecl == NULL) && (doc->extSubset != NULL))
        attrDecl = xmlGetDtdAttrDesc(doc->extSubset, fullelemname,
                         fullattrname);
    }

    if ((fullattrname != fattr) && (fullattrname != attr->name))
        xmlFree(fullattrname);
    if ((fullelemname != felem) && (fullelemname != elem->name))
        xmlFree(fullelemname);

        if ((attrDecl != NULL) && (attrDecl->atype == XML_ATTRIBUTE_ID))
        return(1);
    }
    return(0);
}

Referenced by xmlSAX2AttributeNs(), xsltAttribute(), and xsltAttrListTemplateProcess().

xmlIsMixedElement()

XMLPUBFUN int XMLCALL xmlIsMixedElement	(	xmlDocPtr	doc,
		const xmlChar *	name
	)

The public function calls related to validity checking.

Definition at line 3413 of file valid.c.

                                                      {
    xmlElementPtr elemDecl;

    if ((doc == NULL) || (doc->intSubset == NULL)) return(-1);

    elemDecl = xmlGetDtdElementDesc(doc->intSubset, name);
    if ((elemDecl == NULL) && (doc->extSubset != NULL))
    elemDecl = xmlGetDtdElementDesc(doc->extSubset, name);
    if (elemDecl == NULL) return(-1);
    switch (elemDecl->etype) {
    case XML_ELEMENT_TYPE_UNDEFINED:
        return(-1);
    case XML_ELEMENT_TYPE_ELEMENT:
        return(0);
        case XML_ELEMENT_TYPE_EMPTY:
        /*
         * return 1 for EMPTY since we want VC error to pop up
         * on <empty>     </empty> for example
         */
    case XML_ELEMENT_TYPE_ANY:
    case XML_ELEMENT_TYPE_MIXED:
        return(1);
    }
    return(1);
}

Referenced by areBlanks().

xmlIsRef()

XMLPUBFUN int XMLCALL xmlIsRef	(	xmlDocPtr	doc,
		xmlNodePtr	elem,
		xmlAttrPtr	attr
	)

xmlIsRef: @doc: the document @elem: the element carrying the attribute @attr: the attribute

Determine whether an attribute is of type Ref. In case we have DTD(s) then this is simple, otherwise we use an heuristic: name Ref (upper or lowercase).

Returns 0 or 1 depending on the lookup result

Definition at line 3045 of file valid.c.

                                                          {
    if (attr == NULL)
        return(0);
    if (doc == NULL) {
        doc = attr->doc;
    if (doc == NULL) return(0);
    }

    if ((doc->intSubset == NULL) && (doc->extSubset == NULL)) {
        return(0);
    } else if (doc->type == XML_HTML_DOCUMENT_NODE) {
        /* TODO @@@ */
        return(0);
    } else {
        xmlAttributePtr attrDecl;

        if (elem == NULL) return(0);
        attrDecl = xmlGetDtdAttrDesc(doc->intSubset, elem->name, attr->name);
        if ((attrDecl == NULL) && (doc->extSubset != NULL))
            attrDecl = xmlGetDtdAttrDesc(doc->extSubset,
                                 elem->name, attr->name);

    if ((attrDecl != NULL) &&
        (attrDecl->atype == XML_ATTRIBUTE_IDREF ||
         attrDecl->atype == XML_ATTRIBUTE_IDREFS))
    return(1);
    }
    return(0);
}

Referenced by xmlSAX2AttributeNs().

xmlNewDocElementContent()

XMLPUBFUN xmlElementContentPtr XMLCALL xmlNewDocElementContent	(	xmlDocPtr	doc,
		const xmlChar *	name,
		xmlElementContentType	type
	)

Definition at line 921 of file valid.c.

                                                    {
    xmlElementContentPtr ret;
    xmlDictPtr dict = NULL;

    if (doc != NULL)
        dict = doc->dict;

    switch(type) {
    case XML_ELEMENT_CONTENT_ELEMENT:
        if (name == NULL) {
            xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
            "xmlNewElementContent : name == NULL !\n",
            NULL);
        }
        break;
        case XML_ELEMENT_CONTENT_PCDATA:
    case XML_ELEMENT_CONTENT_SEQ:
    case XML_ELEMENT_CONTENT_OR:
        if (name != NULL) {
            xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
            "xmlNewElementContent : name != NULL !\n",
            NULL);
        }
        break;
    default:
        xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
            "Internal: ELEMENT content corrupted invalid type\n",
            NULL);
        return(NULL);
    }
    ret = (xmlElementContentPtr) xmlMalloc(sizeof(xmlElementContent));
    if (ret == NULL) {
    xmlVErrMemory(NULL, "malloc failed");
    return(NULL);
    }
    memset(ret, 0, sizeof(xmlElementContent));
    ret->type = type;
    ret->ocur = XML_ELEMENT_CONTENT_ONCE;
    if (name != NULL) {
        int l;
    const xmlChar *tmp;

    tmp = xmlSplitQName3(name, &l);
    if (tmp == NULL) {
        if (dict == NULL)
        ret->name = xmlStrdup(name);
        else
            ret->name = xmlDictLookup(dict, name, -1);
    } else {
        if (dict == NULL) {
        ret->prefix = xmlStrndup(name, l);
        ret->name = xmlStrdup(tmp);
        } else {
            ret->prefix = xmlDictLookup(dict, name, l);
        ret->name = xmlDictLookup(dict, tmp, -1);
        }
    }
    }
    return(ret);
}

Referenced by xmlNewElementContent(), xmlParseElementChildrenContentDeclPriv(), and xmlParseElementMixedContentDecl().

xmlNewElementContent()

XMLPUBFUN xmlElementContentPtr XMLCALL xmlNewElementContent	(	const xmlChar *	name,
		xmlElementContentType	type
	)

Definition at line 994 of file valid.c.

                                                                      {
    return(xmlNewDocElementContent(NULL, name, type));
}

xmlRemoveID()

XMLPUBFUN int XMLCALL xmlRemoveID	(	xmlDocPtr	doc,
		xmlAttrPtr	attr
	)

xmlRemoveID: @doc: the document @attr: the attribute

Remove the given attribute from the ID table maintained internally.

Returns -1 if the lookup failed and 0 otherwise

Definition at line 2765 of file valid.c.

                                            {
    xmlIDTablePtr table;
    xmlIDPtr id;
    xmlChar *ID;

    if (doc == NULL) return(-1);
    if (attr == NULL) return(-1);

    table = (xmlIDTablePtr) doc->ids;
    if (table == NULL)
        return(-1);

    ID = xmlNodeListGetString(doc, attr->children, 1);
    if (ID == NULL)
        return(-1);

    id = xmlHashLookup(table, ID);
    if (id == NULL || id->attr != attr) {
        xmlFree(ID);
        return(-1);
    }

    xmlHashRemoveEntry(table, ID, xmlFreeIDTableEntry);
    xmlFree(ID);
    attr->atype = 0;
    return(0);
}

xmlRemoveRef()

XMLPUBFUN int XMLCALL xmlRemoveRef	(	xmlDocPtr	doc,
		xmlAttrPtr	attr
	)

xmlRemoveRef: @doc: the document @attr: the attribute

Remove the given attribute from the Ref table maintained internally.

Returns -1 if the lookup failed and 0 otherwise

Definition at line 3085 of file valid.c.

                                             {
    xmlListPtr ref_list;
    xmlRefTablePtr table;
    xmlChar *ID;
    xmlRemoveMemo target;

    if (doc == NULL) return(-1);
    if (attr == NULL) return(-1);

    table = (xmlRefTablePtr) doc->refs;
    if (table == NULL)
        return(-1);

    ID = xmlNodeListGetString(doc, attr->children, 1);
    if (ID == NULL)
        return(-1);

    ref_list = xmlHashLookup(table, ID);
    if(ref_list == NULL) {
        xmlFree(ID);
        return (-1);
    }

    /* At this point, ref_list refers to a list of references which
     * have the same key as the supplied attr. Our list of references
     * is ordered by reference address and we don't have that information
     * here to use when removing. We'll have to walk the list and
     * check for a matching attribute, when we find one stop the walk
     * and remove the entry.
     * The list is ordered by reference, so that means we don't have the
     * key. Passing the list and the reference to the walker means we
     * will have enough data to be able to remove the entry.
     */
    target.l = ref_list;
    target.ap = attr;

    /* Remove the supplied attr from our list */
    xmlListWalk(ref_list, xmlWalkRemoveRef, &target);

    /*If the list is empty then remove the list entry in the hash */
    if (xmlListEmpty(ref_list))
        xmlHashUpdateEntry(table, ID, NULL, xmlFreeRefTableEntry);
    xmlFree(ID);
    return(0);
}

xmlSnprintfElementContent()

XMLPUBFUN void XMLCALL xmlSnprintfElementContent	(	char *	buf,
		int	size,
		xmlElementContentPtr	content,
		int	englob
	)

xmlSnprintfElementContent: @buf: an output buffer @size: the buffer size @content: An element table @englob: 1 if one must print the englobing parenthesis, 0 otherwise

This will dump the content of the element content definition Intended just for the debug routine

Definition at line 1254 of file valid.c.

                                                                                         {
    int len;

    if (content == NULL) return;
    len = strlen(buf);
    if (size - len < 50) {
    if ((size - len > 4) && (buf[len - 1] != '.'))
        strcat(buf, " ...");
    return;
    }
    if (englob) strcat(buf, "(");
    switch (content->type) {
        case XML_ELEMENT_CONTENT_PCDATA:
            strcat(buf, "#PCDATA");
        break;
    case XML_ELEMENT_CONTENT_ELEMENT: {
            int qnameLen = xmlStrlen(content->name);

        if (content->prefix != NULL)
                qnameLen += xmlStrlen(content->prefix) + 1;
        if (size - len < qnameLen + 10) {
        strcat(buf, " ...");
        return;
        }
        if (content->prefix != NULL) {
        strcat(buf, (char *) content->prefix);
        strcat(buf, ":");
        }
        if (content->name != NULL)
        strcat(buf, (char *) content->name);
        break;
        }
    case XML_ELEMENT_CONTENT_SEQ:
        if ((content->c1->type == XML_ELEMENT_CONTENT_OR) ||
            (content->c1->type == XML_ELEMENT_CONTENT_SEQ))
        xmlSnprintfElementContent(buf, size, content->c1, 1);
        else
        xmlSnprintfElementContent(buf, size, content->c1, 0);
        len = strlen(buf);
        if (size - len < 50) {
        if ((size - len > 4) && (buf[len - 1] != '.'))
            strcat(buf, " ...");
        return;
        }
            strcat(buf, " , ");
        if (((content->c2->type == XML_ELEMENT_CONTENT_OR) ||
         (content->c2->ocur != XML_ELEMENT_CONTENT_ONCE)) &&
        (content->c2->type != XML_ELEMENT_CONTENT_ELEMENT))
        xmlSnprintfElementContent(buf, size, content->c2, 1);
        else
        xmlSnprintfElementContent(buf, size, content->c2, 0);
        break;
    case XML_ELEMENT_CONTENT_OR:
        if ((content->c1->type == XML_ELEMENT_CONTENT_OR) ||
            (content->c1->type == XML_ELEMENT_CONTENT_SEQ))
        xmlSnprintfElementContent(buf, size, content->c1, 1);
        else
        xmlSnprintfElementContent(buf, size, content->c1, 0);
        len = strlen(buf);
        if (size - len < 50) {
        if ((size - len > 4) && (buf[len - 1] != '.'))
            strcat(buf, " ...");
        return;
        }
            strcat(buf, " | ");
        if (((content->c2->type == XML_ELEMENT_CONTENT_SEQ) ||
         (content->c2->ocur != XML_ELEMENT_CONTENT_ONCE)) &&
        (content->c2->type != XML_ELEMENT_CONTENT_ELEMENT))
        xmlSnprintfElementContent(buf, size, content->c2, 1);
        else
        xmlSnprintfElementContent(buf, size, content->c2, 0);
        break;
    }
    if (size - strlen(buf) <= 2) return;
    if (englob)
        strcat(buf, ")");
    switch (content->ocur) {
        case XML_ELEMENT_CONTENT_ONCE:
        break;
        case XML_ELEMENT_CONTENT_OPT:
        strcat(buf, "?");
        break;
        case XML_ELEMENT_CONTENT_MULT:
        strcat(buf, "*");
        break;
        case XML_ELEMENT_CONTENT_PLUS:
        strcat(buf, "+");
        break;
    }
}