valid.c File Reference

#include "libxml.h"
#include <string.h>
#include <stdlib.h>
#include <libxml/xmlmemory.h>
#include <libxml/hash.h>
#include <libxml/uri.h>
#include <libxml/valid.h>
#include <libxml/parser.h>
#include <libxml/parserInternals.h>
#include <libxml/xmlerror.h>
#include <libxml/list.h>
#include <libxml/globals.h>
#include "elfgcchack.h"

Include dependency graph for valid.c:

Go to the source code of this file.

Classes
struct	xmlRemoveMemo_t
struct	xmlValidateMemo_t

Macros
#define	IN_LIBXML
#define	TODO

Functions
static void	xmlVErrMemory (xmlValidCtxtPtr ctxt, const char *extra)
static void	LIBXML_ATTR_FORMAT (3, 0)
: the subelement name or NULL
xmlNewElementContent: @type: the type of element content decl Allocate an element content structure. Deprecated in favor of xmlNewDocElementContent Returns NULL if not, otherwise the new element content structure
xmlElementContentPtr	xmlNewDocElementContent (xmlDocPtr doc, const xmlChar *name, xmlElementContentType type)
xmlElementContentPtr	xmlNewElementContent (const xmlChar *name, xmlElementContentType type)
xmlElementContentPtr	xmlCopyDocElementContent (xmlDocPtr doc, xmlElementContentPtr cur)
xmlElementContentPtr	xmlCopyElementContent (xmlElementContentPtr cur)
void	xmlFreeDocElementContent (xmlDocPtr doc, xmlElementContentPtr cur)
void	xmlFreeElementContent (xmlElementContentPtr cur)
void	xmlSnprintfElementContent (char *buf, int size, xmlElementContentPtr content, int englob)
static void	xmlFreeElement (xmlElementPtr elem)
: the enumeration name or NULL
xmlCreateEnumeration: create and initialize an enumeration attribute node. Returns the xmlEnumerationPtr just created or NULL in case of error.
xmlEnumerationPtr	xmlCreateEnumeration (const xmlChar *name)
void	xmlFreeEnumeration (xmlEnumerationPtr cur)
static void	xmlFreeAttribute (xmlAttributePtr attr)
: the attribute name
xmlGetDtdQAttrDesc: @dtd: a pointer to the DtD to search @elem: the element name @prefix: the attribute namespace prefix Search the DTD for the description of this qualified attribute on this element. returns the xmlAttributePtr if found or NULL
xmlAttributePtr	xmlAddAttributeDecl (xmlValidCtxtPtr ctxt, xmlDtdPtr dtd, const xmlChar *elem, const xmlChar *name, const xmlChar *ns, xmlAttributeType type, xmlAttributeDefault def, const xmlChar *defaultValue, xmlEnumerationPtr tree)
static void	xmlFreeAttributeTableEntry (void *attr, const xmlChar *name ATTRIBUTE_UNUSED)
void	xmlFreeAttributeTable (xmlAttributeTablePtr table)
static void	xmlFreeNotation (xmlNotationPtr nota)
xmlAttributePtr	xmlGetDtdAttrDesc (xmlDtdPtr dtd, const xmlChar *elem, const xmlChar *name)
xmlAttributePtr	xmlGetDtdQAttrDesc (xmlDtdPtr dtd, const xmlChar *elem, const xmlChar *name, const xmlChar *prefix)
: the notation name
xmlGetDtdNotationDesc: @dtd: a pointer to the DtD to search Search the DTD for the description of this notation returns the xmlNotationPtr if found or NULL
xmlNotationPtr	xmlGetDtdNotationDesc (xmlDtdPtr dtd, const xmlChar *name)

: the entity name
xmlAddNotationDecl: @dtd: pointer to the DTD @ctxt: the validation context @PublicID: the public identifier or NULL @SystemID: the system identifier or NULL Register a new notation declaration Returns NULL if not, otherwise the entity
#define	DICT_FREE(str)
typedef struct xmlRemoveMemo_t	xmlRemoveMemo
typedef xmlRemoveMemo *	xmlRemoveMemoPtr
typedef struct xmlValidateMemo_t	xmlValidateMemo
typedef xmlValidateMemo *	xmlValidateMemoPtr
xmlElementPtr	xmlAddElementDecl (xmlValidCtxtPtr ctxt, xmlDtdPtr dtd, const xmlChar *name, xmlElementTypeVal type, xmlElementContentPtr content)
static void	xmlFreeElementTableEntry (void *elem, const xmlChar *name ATTRIBUTE_UNUSED)
void	xmlFreeElementTable (xmlElementTablePtr table)
xmlNotationPtr	xmlAddNotationDecl (xmlValidCtxtPtr ctxt, xmlDtdPtr dtd, const xmlChar *name, const xmlChar *PublicID, const xmlChar *SystemID)
static void	xmlFreeNotationTableEntry (void *nota, const xmlChar *name ATTRIBUTE_UNUSED)
void	xmlFreeNotationTable (xmlNotationTablePtr table)
static void	xmlFreeID (xmlIDPtr id)
xmlIDPtr	xmlAddID (xmlValidCtxtPtr ctxt, xmlDocPtr doc, const xmlChar *value, xmlAttrPtr attr)
static void	xmlFreeIDTableEntry (void *id, const xmlChar *name ATTRIBUTE_UNUSED)
void	xmlFreeIDTable (xmlIDTablePtr table)
int	xmlIsID (xmlDocPtr doc, xmlNodePtr elem, xmlAttrPtr attr)
int	xmlRemoveID (xmlDocPtr doc, xmlAttrPtr attr)
xmlAttrPtr	xmlGetID (xmlDocPtr doc, const xmlChar *ID)
static void	xmlFreeRef (xmlLinkPtr lk)
static void	xmlFreeRefTableEntry (void *payload, const xmlChar *name ATTRIBUTE_UNUSED)
static int	xmlWalkRemoveRef (const void *data, void *user)
static int	xmlDummyCompare (const void *data0 ATTRIBUTE_UNUSED, const void *data1 ATTRIBUTE_UNUSED)
xmlRefPtr	xmlAddRef (xmlValidCtxtPtr ctxt, xmlDocPtr doc, const xmlChar *value, xmlAttrPtr attr)
void	xmlFreeRefTable (xmlRefTablePtr table)
int	xmlIsRef (xmlDocPtr doc, xmlNodePtr elem, xmlAttrPtr attr)
int	xmlRemoveRef (xmlDocPtr doc, xmlAttrPtr attr)
xmlListPtr	xmlGetRefs (xmlDocPtr doc, const xmlChar *ID)

: the element name
xmlIsMixedElement: @doc: the document Search in the DtDs whether an element accept Mixed content (or ANY) basically if it is supposed to accept text childs returns 0 if no, 1 if yes, and -1 if no element description is available
#define	bottom_valid
static xmlElementPtr	xmlGetDtdElementDesc2 (xmlDtdPtr dtd, const xmlChar *name, int create)
xmlElementPtr	xmlGetDtdElementDesc (xmlDtdPtr dtd, const xmlChar *name)
xmlElementPtr	xmlGetDtdQElementDesc (xmlDtdPtr dtd, const xmlChar *name, const xmlChar *prefix)
int	xmlIsMixedElement (xmlDocPtr doc, const xmlChar *name)

Macro Definition Documentation

bottom_valid

#define bottom_valid

Definition at line 7095 of file valid.c.

DICT_FREE

#define DICT_FREE

(

str

)

Value:

if ((str) && ((!dict) ||                \
        (xmlDictOwns(dict, (const xmlChar *)(str)) == 0)))  \
        xmlFree((char *)(str));

DICT_FREE: @str: a string

Free a string if it is not owned by the "dict" dictionary in the current scope

Definition at line 2562 of file valid.c.

IN_LIBXML

#define IN_LIBXML

Definition at line 10 of file valid.c.

TODO

#define TODO

Value:

xmlGenericError(xmlGenericErrorContext,             \
        "Unimplemented block at %s:%d\n",               \
            __FILE__, __LINE__);

Definition at line 34 of file valid.c.

Typedef Documentation

xmlRemoveMemo

typedef struct xmlRemoveMemo_t xmlRemoveMemo

xmlRemoveMemoPtr

typedef xmlRemoveMemo* xmlRemoveMemoPtr

Definition at line 2843 of file valid.c.

xmlValidateMemo

typedef struct xmlValidateMemo_t xmlValidateMemo

xmlValidateMemoPtr

typedef xmlValidateMemo* xmlValidateMemoPtr

Definition at line 2851 of file valid.c.

Function Documentation

LIBXML_ATTR_FORMAT()

static void LIBXML_ATTR_FORMAT ( 3  , 0    )

static

xmlErrValid: @ctxt: an XML validation parser context @error: the error number @extra: extra informations

Handle a validation error

Definition at line 96 of file valid.c.

{
    xmlGenericErrorFunc channel = NULL;
    xmlParserCtxtPtr pctxt = NULL;
    void *data = NULL;

    if (ctxt != NULL) {
        channel = ctxt->error;
        data = ctxt->userData;
    /* Use the special values to detect if it is part of a parsing
       context */
    if ((ctxt->finishDtd == XML_CTXT_FINISH_DTD_0) ||
        (ctxt->finishDtd == XML_CTXT_FINISH_DTD_1)) {
        long delta = (char *) ctxt - (char *) ctxt->userData;
        if ((delta > 0) && (delta < 250))
        pctxt = ctxt->userData;
    }
    }
    if (extra)
        __xmlRaiseError(NULL, channel, data,
                        pctxt, NULL, XML_FROM_VALID, error,
                        XML_ERR_ERROR, NULL, 0, extra, NULL, NULL, 0, 0,
                        msg, extra);
    else
        __xmlRaiseError(NULL, channel, data,
                        pctxt, NULL, XML_FROM_VALID, error,
                        XML_ERR_ERROR, NULL, 0, NULL, NULL, NULL, 0, 0,
                        "%s", msg);
}

xmlAddAttributeDecl()

xmlAttributePtr 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()

xmlElementPtr 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()

xmlIDPtr 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()

xmlNotationPtr 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()

xmlRefPtr 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()

xmlElementContentPtr 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()

xmlElementContentPtr 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()

xmlEnumerationPtr 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().

xmlDummyCompare()

static int xmlDummyCompare ( const void *data0  ATTRIBUTE_UNUSED, const void *data1  ATTRIBUTE_UNUSED  )

static

xmlDummyCompare @data0: Value supplied by the user @data1: Value supplied by the user

Do nothing, return 0. Used to create unordered lists.

Definition at line 2912 of file valid.c.

{
    return (0);
}

Referenced by xmlAddRef().

xmlFreeAttribute()

static void xmlFreeAttribute ( xmlAttributePtr  attr )

static

xmlFreeAttribute: @elem: An attribute

Deallocate the memory used by an attribute definition

Definition at line 1885 of file valid.c.

                                       {
    xmlDictPtr dict;

    if (attr == NULL) return;
    if (attr->doc != NULL)
    dict = attr->doc->dict;
    else
    dict = NULL;
    xmlUnlinkNode((xmlNodePtr) attr);
    if (attr->tree != NULL)
        xmlFreeEnumeration(attr->tree);
    if (dict) {
        if ((attr->elem != NULL) && (!xmlDictOwns(dict, attr->elem)))
        xmlFree((xmlChar *) attr->elem);
        if ((attr->name != NULL) && (!xmlDictOwns(dict, attr->name)))
        xmlFree((xmlChar *) attr->name);
        if ((attr->prefix != NULL) && (!xmlDictOwns(dict, attr->prefix)))
        xmlFree((xmlChar *) attr->prefix);
        if ((attr->defaultValue != NULL) &&
        (!xmlDictOwns(dict, attr->defaultValue)))
        xmlFree((xmlChar *) attr->defaultValue);
    } else {
    if (attr->elem != NULL)
        xmlFree((xmlChar *) attr->elem);
    if (attr->name != NULL)
        xmlFree((xmlChar *) attr->name);
    if (attr->defaultValue != NULL)
        xmlFree((xmlChar *) attr->defaultValue);
    if (attr->prefix != NULL)
        xmlFree((xmlChar *) attr->prefix);
    }
    xmlFree(attr);
}

Referenced by xmlAddAttributeDecl(), and xmlFreeAttributeTableEntry().

xmlFreeAttributeTable()

void 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);
}

xmlFreeAttributeTableEntry()

static void xmlFreeAttributeTableEntry ( void *  attr, const xmlChar *name  ATTRIBUTE_UNUSED  )

static

Definition at line 2153 of file valid.c.

                                                                             {
    xmlFreeAttribute((xmlAttributePtr) attr);
}

Referenced by xmlFreeAttributeTable().

xmlFreeDocElementContent()

void 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().

xmlFreeElement()

static void xmlFreeElement ( xmlElementPtr  elem )

static

xmlFreeElement: @elem: An element

Deallocate the memory used by an element definition

Definition at line 1358 of file valid.c.

                                   {
    if (elem == NULL) return;
    xmlUnlinkNode((xmlNodePtr) elem);
    xmlFreeDocElementContent(elem->doc, elem->content);
    if (elem->name != NULL)
    xmlFree((xmlChar *) elem->name);
    if (elem->prefix != NULL)
    xmlFree((xmlChar *) elem->prefix);
#ifdef LIBXML_REGEXP_ENABLED
    if (elem->contModel != NULL)
    xmlRegFreeRegexp(elem->contModel);
#endif
    xmlFree(elem);
}

Referenced by xmlAddElementDecl(), and xmlFreeElementTableEntry().

xmlFreeElementContent()

void 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()

void 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);
}

xmlFreeElementTableEntry()

static void xmlFreeElementTableEntry ( void *  elem, const xmlChar *name  ATTRIBUTE_UNUSED  )

static

Definition at line 1601 of file valid.c.

                                                                           {
    xmlFreeElement((xmlElementPtr) elem);
}

Referenced by xmlFreeElementTable().

xmlFreeEnumeration()

void 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().

xmlFreeID()

static void xmlFreeID ( xmlIDPtr  id )

static

xmlFreeID: @not: A id

Deallocate the memory used by an id definition

Definition at line 2574 of file valid.c.

                       {
    xmlDictPtr dict = NULL;

    if (id == NULL) return;

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

    if (id->value != NULL)
    DICT_FREE(id->value)
    if (id->name != NULL)
    DICT_FREE(id->name)
    xmlFree(id);
}

Referenced by xmlAddID(), and xmlFreeIDTableEntry().

xmlFreeIDTable()

void 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().

xmlFreeIDTableEntry()

static void xmlFreeIDTableEntry ( void *  id, const xmlChar *name  ATTRIBUTE_UNUSED  )

static

Definition at line 2675 of file valid.c.

                                                                    {
    xmlFreeID((xmlIDPtr) id);
}

Referenced by xmlFreeIDTable(), and xmlRemoveID().

xmlFreeNotation()

static void xmlFreeNotation ( xmlNotationPtr  nota )

static

xmlFreeNotation: @not: A notation

Deallocate the memory used by an notation definition

Definition at line 2340 of file valid.c.

                                     {
    if (nota == NULL) return;
    if (nota->name != NULL)
    xmlFree((xmlChar *) nota->name);
    if (nota->PublicID != NULL)
    xmlFree((xmlChar *) nota->PublicID);
    if (nota->SystemID != NULL)
    xmlFree((xmlChar *) nota->SystemID);
    xmlFree(nota);
}

Referenced by xmlAddNotationDecl(), and xmlFreeNotationTableEntry().

xmlFreeNotationTable()

void 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);
}

xmlFreeNotationTableEntry()

static void xmlFreeNotationTableEntry ( void *  nota, const xmlChar *name  ATTRIBUTE_UNUSED  )

static

Definition at line 2431 of file valid.c.

                                                                            {
    xmlFreeNotation((xmlNotationPtr) nota);
}

Referenced by xmlFreeNotationTable().

xmlFreeRef()

static void xmlFreeRef ( xmlLinkPtr  lk )

static

xmlFreeRef: @lk: A list link

Deallocate the memory used by a ref definition

Definition at line 2860 of file valid.c.

                          {
    xmlRefPtr ref = (xmlRefPtr)xmlLinkGetData(lk);
    if (ref == NULL) return;
    if (ref->value != NULL)
        xmlFree((xmlChar *)ref->value);
    if (ref->name != NULL)
        xmlFree((xmlChar *)ref->name);
    xmlFree(ref);
}

Referenced by xmlAddRef().

xmlFreeRefTable()

void 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().

xmlFreeRefTableEntry()

static void xmlFreeRefTableEntry ( void *  payload, const xmlChar *name  ATTRIBUTE_UNUSED  )

static

xmlFreeRefTableEntry: @list_ref: A list of references.

Deallocate the memory used by a list of references

Definition at line 2877 of file valid.c.

                                                                          {
    xmlListPtr list_ref = (xmlListPtr) payload;
    if (list_ref == NULL) return;
    xmlListDelete(list_ref);
}

Referenced by xmlFreeRefTable(), and xmlRemoveRef().

xmlGetDtdAttrDesc()

xmlAttributePtr 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()

xmlElementPtr 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().

xmlGetDtdElementDesc2()

static xmlElementPtr xmlGetDtdElementDesc2 ( xmlDtdPtr  dtd, const xmlChar *  name, int  create  )

static

Definition at line 3206 of file valid.c.

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

    if (dtd == NULL) return(NULL);
    if (dtd->elements == NULL) {
    xmlDictPtr dict = NULL;

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

    if (!create)
        return(NULL);
    /*
     * Create the Element table if needed.
     */
    table = (xmlElementTablePtr) dtd->elements;
    if (table == NULL) {
        table = xmlHashCreateDict(0, dict);
        dtd->elements = (void *) table;
    }
    if (table == NULL) {
        xmlVErrMemory(NULL, "element table allocation failed");
        return(NULL);
    }
    }
    table = (xmlElementTablePtr) dtd->elements;

    uqname = xmlSplitQName2(name, &prefix);
    if (uqname != NULL)
        name = uqname;
    cur = xmlHashLookup2(table, name, prefix);
    if ((cur == NULL) && (create)) {
    cur = (xmlElementPtr) xmlMalloc(sizeof(xmlElement));
    if (cur == NULL) {
        xmlVErrMemory(NULL, "malloc failed");
        return(NULL);
    }
    memset(cur, 0, sizeof(xmlElement));
    cur->type = XML_ELEMENT_DECL;

    /*
     * fill the structure.
     */
    cur->name = xmlStrdup(name);
    cur->prefix = xmlStrdup(prefix);
    cur->etype = XML_ELEMENT_TYPE_UNDEFINED;

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

Referenced by xmlAddAttributeDecl().

xmlGetDtdNotationDesc()

xmlNotationPtr 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()

xmlAttributePtr 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()

xmlElementPtr 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()

xmlAttrPtr 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()

xmlListPtr 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()

int 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()

int 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()

int 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()

xmlElementContentPtr 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()

xmlElementContentPtr xmlNewElementContent	(	const xmlChar *	name,
		xmlElementContentType	type
	)

Definition at line 994 of file valid.c.

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

xmlRemoveID()

int 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()

int 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()

void 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;
    }
}

xmlVErrMemory()

static void xmlVErrMemory ( xmlValidCtxtPtr  ctxt, const char *  extra  )

static

xmlVErrMemory: @ctxt: an XML validation parser context @extra: extra informations

Handle an out of memory error

Definition at line 58 of file valid.c.

{
    xmlGenericErrorFunc channel = NULL;
    xmlParserCtxtPtr pctxt = NULL;
    void *data = NULL;

    if (ctxt != NULL) {
        channel = ctxt->error;
        data = ctxt->userData;
    /* Use the special values to detect if it is part of a parsing
       context */
    if ((ctxt->finishDtd == XML_CTXT_FINISH_DTD_0) ||
        (ctxt->finishDtd == XML_CTXT_FINISH_DTD_1)) {
        long delta = (char *) ctxt - (char *) ctxt->userData;
        if ((delta > 0) && (delta < 250))
        pctxt = ctxt->userData;
    }
    }
    if (extra)
        __xmlRaiseError(NULL, channel, data,
                        pctxt, NULL, XML_FROM_VALID, XML_ERR_NO_MEMORY,
                        XML_ERR_FATAL, NULL, 0, extra, NULL, NULL, 0, 0,
                        "Memory allocation failed : %s\n", extra);
    else
        __xmlRaiseError(NULL, channel, data,
                        pctxt, NULL, XML_FROM_VALID, XML_ERR_NO_MEMORY,
                        XML_ERR_FATAL, NULL, 0, NULL, NULL, NULL, 0, 0,
                        "Memory allocation failed\n");
}

Referenced by xmlAddAttributeDecl(), xmlAddElementDecl(), xmlAddID(), xmlAddNotationDecl(), xmlAddRef(), xmlCopyDocElementContent(), xmlCreateEnumeration(), xmlGetDtdElementDesc2(), and xmlNewDocElementContent().

xmlWalkRemoveRef()

static int xmlWalkRemoveRef ( const void *  data, void *  user  )

static

xmlWalkRemoveRef: @data: Contents of current link @user: Value supplied by the user

Returns 0 to abort the walk or 1 to continue

Definition at line 2891 of file valid.c.

{
    xmlAttrPtr attr0 = ((xmlRefPtr)data)->attr;
    xmlAttrPtr attr1 = ((xmlRemoveMemoPtr)user)->ap;
    xmlListPtr ref_list = ((xmlRemoveMemoPtr)user)->l;

    if (attr0 == attr1) { /* Matched: remove and terminate walk */
        xmlListRemoveFirst(ref_list, (void *)data);
        return 0;
    }
    return 1;
}

Referenced by xmlRemoveRef().