ReactOS 0.4.15-dev-5666-gc548b97
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 xmlValidStatexmlValidStatePtr
 
typedef void(XMLCDECLxmlValidityErrorFunc) (void *ctx, const char *msg,...) LIBXML_ATTR_FORMAT(2
 
typedef void(XMLCDECL *) typedef void(XMLCDECLxmlValidityWarningFunc) (void *ctx, const char *msg,...) LIBXML_ATTR_FORMAT(2
 
typedef typedeftypedef void(XMLCDECL *) typedef void(XMLCDECL *) struct _xmlValidCtx xmlValidCtxt)
 
typedef xmlValidCtxtxmlValidCtxtPtr
 
typedef struct _xmlHashTable xmlNotationTable
 
typedef xmlNotationTablexmlNotationTablePtr
 
typedef struct _xmlHashTable xmlElementTable
 
typedef xmlElementTablexmlElementTablePtr
 
typedef struct _xmlHashTable xmlAttributeTable
 
typedef xmlAttributeTablexmlAttributeTablePtr
 
typedef struct _xmlHashTable xmlIDTable
 
typedef xmlIDTablexmlIDTablePtr
 
typedef struct _xmlHashTable xmlRefTable
 
typedef xmlRefTablexmlRefTablePtr
 

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)
 
XML_DEPRECATED XMLPUBFUN xmlRefPtr XMLCALL xmlAddRef (xmlValidCtxtPtr ctxt, xmlDocPtr doc, const xmlChar *value, xmlAttrPtr attr)
 
XML_DEPRECATED XMLPUBFUN void XMLCALL xmlFreeRefTable (xmlRefTablePtr table)
 
XML_DEPRECATED XMLPUBFUN int XMLCALL xmlIsRef (xmlDocPtr doc, xmlNodePtr elem, xmlAttrPtr attr)
 
XML_DEPRECATED XMLPUBFUN int XMLCALL xmlRemoveRef (xmlDocPtr doc, xmlAttrPtr attr)
 
XML_DEPRECATED 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

◆ xmlAttributeTable

Definition at line 133 of file valid.h.

◆ xmlAttributeTablePtr

Definition at line 134 of file valid.h.

◆ xmlElementTable

Definition at line 125 of file valid.h.

◆ xmlElementTablePtr

Definition at line 126 of file valid.h.

◆ xmlIDTable

Definition at line 141 of file valid.h.

◆ xmlIDTablePtr

Definition at line 142 of file valid.h.

◆ xmlNotationTable

Definition at line 117 of file valid.h.

◆ xmlNotationTablePtr

Definition at line 118 of file valid.h.

◆ xmlRefTable

Definition at line 149 of file valid.h.

◆ xmlRefTablePtr

Definition at line 150 of file valid.h.

◆ xmlValidCtxt

typedef typedeftypedef void(XMLCDECL *) typedef void(XMLCDECL *) struct _xmlValidCtx xmlValidCtxt)

Definition at line 80 of file valid.h.

◆ 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.

◆ xmlValidityWarningFunc

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

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.

◆ xmlValidState

typedef struct _xmlValidState xmlValidState

Definition at line 28 of file valid.h.

◆ 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 1967 of file valid.c.

1971 {
1974 xmlElementPtr elemDef;
1975 xmlDictPtr dict = NULL;
1976
1977 if (dtd == NULL) {
1979 return(NULL);
1980 }
1981 if (name == NULL) {
1983 return(NULL);
1984 }
1985 if (elem == NULL) {
1987 return(NULL);
1988 }
1989 if (dtd->doc != NULL)
1990 dict = dtd->doc->dict;
1991
1992#ifdef LIBXML_VALID_ENABLED
1993 /*
1994 * Check the type and possibly the default value.
1995 */
1996 switch (type) {
1998 break;
1999 case XML_ATTRIBUTE_ID:
2000 break;
2002 break;
2004 break;
2006 break;
2008 break;
2010 break;
2012 break;
2014 break;
2016 break;
2017 default:
2018 xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
2019 "Internal: ATTRIBUTE struct corrupted invalid type\n",
2020 NULL);
2022 return(NULL);
2023 }
2024 if ((defaultValue != NULL) &&
2025 (!xmlValidateAttributeValueInternal(dtd->doc, type, defaultValue))) {
2026 xmlErrValidNode(ctxt, (xmlNodePtr) dtd, XML_DTD_ATTRIBUTE_DEFAULT,
2027 "Attribute %s of %s: invalid default value\n",
2028 elem, name, defaultValue);
2029 defaultValue = NULL;
2030 if (ctxt != NULL)
2031 ctxt->valid = 0;
2032 }
2033#endif /* LIBXML_VALID_ENABLED */
2034
2035 /*
2036 * Check first that an attribute defined in the external subset wasn't
2037 * already defined in the internal subset
2038 */
2039 if ((dtd->doc != NULL) && (dtd->doc->extSubset == dtd) &&
2040 (dtd->doc->intSubset != NULL) &&
2041 (dtd->doc->intSubset->attributes != NULL)) {
2042 ret = xmlHashLookup3(dtd->doc->intSubset->attributes, name, ns, elem);
2043 if (ret != NULL) {
2045 return(NULL);
2046 }
2047 }
2048
2049 /*
2050 * Create the Attribute table if needed.
2051 */
2053 if (table == NULL) {
2054 table = xmlHashCreateDict(0, dict);
2055 dtd->attributes = (void *) table;
2056 }
2057 if (table == NULL) {
2058 xmlVErrMemory(ctxt,
2059 "xmlAddAttributeDecl: Table creation failed!\n");
2061 return(NULL);
2062 }
2063
2064
2066 if (ret == NULL) {
2067 xmlVErrMemory(ctxt, "malloc failed");
2069 return(NULL);
2070 }
2071 memset(ret, 0, sizeof(xmlAttribute));
2072 ret->type = XML_ATTRIBUTE_DECL;
2073
2074 /*
2075 * fill the structure.
2076 */
2077 ret->atype = type;
2078 /*
2079 * doc must be set before possible error causes call
2080 * to xmlFreeAttribute (because it's used to check on
2081 * dict use)
2082 */
2083 ret->doc = dtd->doc;
2084 if (dict) {
2085 ret->name = xmlDictLookup(dict, name, -1);
2086 ret->prefix = xmlDictLookup(dict, ns, -1);
2087 ret->elem = xmlDictLookup(dict, elem, -1);
2088 } else {
2089 ret->name = xmlStrdup(name);
2090 ret->prefix = xmlStrdup(ns);
2091 ret->elem = xmlStrdup(elem);
2092 }
2093 ret->def = def;
2094 ret->tree = tree;
2095 if (defaultValue != NULL) {
2096 if (dict)
2097 ret->defaultValue = xmlDictLookup(dict, defaultValue, -1);
2098 else
2099 ret->defaultValue = xmlStrdup(defaultValue);
2100 }
2101
2102 /*
2103 * Validity Check:
2104 * Search the DTD for previous declarations of the ATTLIST
2105 */
2106 if (xmlHashAddEntry3(table, ret->name, ret->prefix, ret->elem, ret) < 0) {
2107#ifdef LIBXML_VALID_ENABLED
2108 /*
2109 * The attribute is already defined in this DTD.
2110 */
2111 xmlErrValidWarning(ctxt, (xmlNodePtr) dtd, XML_DTD_ATTRIBUTE_REDEFINED,
2112 "Attribute %s of element %s: already defined\n",
2113 name, elem, NULL);
2114#endif /* LIBXML_VALID_ENABLED */
2116 return(NULL);
2117 }
2118
2119 /*
2120 * Validity Check:
2121 * Multiple ID per element
2122 */
2123 elemDef = xmlGetDtdElementDesc2(dtd, elem, 1);
2124 if (elemDef != NULL) {
2125
2126#ifdef LIBXML_VALID_ENABLED
2127 if ((type == XML_ATTRIBUTE_ID) &&
2128 (xmlScanIDAttributeDecl(NULL, elemDef, 1) != 0)) {
2129 xmlErrValidNode(ctxt, (xmlNodePtr) dtd, XML_DTD_MULTIPLE_ID,
2130 "Element %s has too may ID attributes defined : %s\n",
2131 elem, name, NULL);
2132 if (ctxt != NULL)
2133 ctxt->valid = 0;
2134 }
2135#endif /* LIBXML_VALID_ENABLED */
2136
2137 /*
2138 * Insert namespace default def first they need to be
2139 * processed first.
2140 */
2141 if ((xmlStrEqual(ret->name, BAD_CAST "xmlns")) ||
2142 ((ret->prefix != NULL &&
2143 (xmlStrEqual(ret->prefix, BAD_CAST "xmlns"))))) {
2144 ret->nexth = elemDef->attributes;
2145 elemDef->attributes = ret;
2146 } else {
2147 xmlAttributePtr tmp = elemDef->attributes;
2148
2149 while ((tmp != NULL) &&
2150 ((xmlStrEqual(tmp->name, BAD_CAST "xmlns")) ||
2151 ((ret->prefix != NULL &&
2152 (xmlStrEqual(ret->prefix, BAD_CAST "xmlns")))))) {
2153 if (tmp->nexth == NULL)
2154 break;
2155 tmp = tmp->nexth;
2156 }
2157 if (tmp != NULL) {
2158 ret->nexth = tmp->nexth;
2159 tmp->nexth = ret;
2160 } else {
2161 ret->nexth = elemDef->attributes;
2162 elemDef->attributes = ret;
2163 }
2164 }
2165 }
2166
2167 /*
2168 * Link it to the DTD
2169 */
2170 ret->parent = dtd;
2171 if (dtd->last == NULL) {
2172 dtd->children = dtd->last = (xmlNodePtr) ret;
2173 } else {
2174 dtd->last->next = (xmlNodePtr) ret;
2175 ret->prev = dtd->last;
2176 dtd->last = (xmlNodePtr) ret;
2177 }
2178 return(ret);
2179}
struct _tree tree
#define NULL
Definition: types.h:112
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
if(dx< 0)
Definition: linetemp.h:194
static size_t elem
Definition: string.c:68
XMLPUBFUN const xmlChar *XMLCALL xmlDictLookup(xmlDictPtr dict, const xmlChar *name, int len)
Definition: dict.c:867
XMLPUBVAR xmlMallocFunc xmlMalloc
Definition: globals.h:248
XMLPUBFUN void *XMLCALL xmlHashLookup3(xmlHashTablePtr table, const xmlChar *name, const xmlChar *name2, const xmlChar *name3)
Definition: hash.c:769
XMLPUBFUN xmlHashTablePtr XMLCALL xmlHashCreateDict(int size, xmlDictPtr dict)
Definition: hash.c:210
XMLPUBFUN int XMLCALL xmlHashAddEntry3(xmlHashTablePtr table, const xmlChar *name, const xmlChar *name2, const xmlChar *name3, void *userdata)
Definition: hash.c:531
@ XML_ATTRIBUTE_NMTOKENS
Definition: tree.h:214
@ XML_ATTRIBUTE_IDREF
Definition: tree.h:209
@ XML_ATTRIBUTE_ENTITIES
Definition: tree.h:212
@ XML_ATTRIBUTE_IDREFS
Definition: tree.h:210
@ XML_ATTRIBUTE_ID
Definition: tree.h:208
@ XML_ATTRIBUTE_NOTATION
Definition: tree.h:216
@ XML_ATTRIBUTE_ENUMERATION
Definition: tree.h:215
@ XML_ATTRIBUTE_CDATA
Definition: tree.h:207
@ XML_ATTRIBUTE_NMTOKEN
Definition: tree.h:213
@ XML_ATTRIBUTE_ENTITY
Definition: tree.h:211
xmlNode * xmlNodePtr
Definition: tree.h:488
@ XML_ATTRIBUTE_DECL
Definition: tree.h:175
xmlAttribute * xmlAttributePtr
Definition: tree.h:252
#define memset(x, y, z)
Definition: compat.h:39
const xmlChar * name
Definition: tree.h:256
struct _xmlAttribute * nexth
Definition: tree.h:264
Definition: dict.c:111
struct _xmlDoc * doc
Definition: tree.h:415
struct _xmlNode * last
Definition: tree.h:411
struct _xmlNode * children
Definition: tree.h:410
void * attributes
Definition: tree.h:420
xmlAttributePtr attributes
Definition: tree.h:359
Definition: tree.h:489
Definition: name.c:39
Definition: mxnamespace.c:45
static void xmlVErrMemory(xmlValidCtxtPtr ctxt, const char *extra)
Definition: valid.c:55
static xmlElementPtr xmlGetDtdElementDesc2(xmlDtdPtr dtd, const xmlChar *name, int create)
Definition: valid.c:3287
void xmlFreeEnumeration(xmlEnumerationPtr cur)
Definition: valid.c:1817
static void xmlFreeAttribute(xmlAttributePtr attr)
Definition: valid.c:1914
xmlAttributeTable * xmlAttributeTablePtr
Definition: valid.h:134
int ret
@ XML_DTD_ATTRIBUTE_REDEFINED
Definition: xmlerror.h:220
@ XML_DTD_MULTIPLE_ID
Definition: xmlerror.h:239
@ XML_DTD_ATTRIBUTE_DEFAULT
Definition: xmlerror.h:219
@ XML_ERR_INTERNAL_ERROR
Definition: xmlerror.h:101
XMLPUBFUN xmlChar *XMLCALL xmlStrdup(const xmlChar *cur)
Definition: xmlstring.c:67
#define BAD_CAST
Definition: xmlstring.h:35
XMLPUBFUN int XMLCALL xmlStrEqual(const xmlChar *str1, const xmlChar *str2)
Definition: xmlstring.c:160

Referenced by xmlSAX2AttributeDecl().

◆ xmlAddElementDecl()

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

Definition at line 1418 of file valid.c.

1421 {
1424 xmlAttributePtr oldAttributes = NULL;
1425 xmlChar *ns, *uqname;
1426
1427 if (dtd == NULL) {
1428 return(NULL);
1429 }
1430 if (name == NULL) {
1431 return(NULL);
1432 }
1433
1434 switch (type) {
1436 if (content != NULL) {
1437 xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
1438 "xmlAddElementDecl: content != NULL for EMPTY\n",
1439 NULL);
1440 return(NULL);
1441 }
1442 break;
1444 if (content != NULL) {
1445 xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
1446 "xmlAddElementDecl: content != NULL for ANY\n",
1447 NULL);
1448 return(NULL);
1449 }
1450 break;
1452 if (content == NULL) {
1453 xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
1454 "xmlAddElementDecl: content == NULL for MIXED\n",
1455 NULL);
1456 return(NULL);
1457 }
1458 break;
1460 if (content == NULL) {
1461 xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
1462 "xmlAddElementDecl: content == NULL for ELEMENT\n",
1463 NULL);
1464 return(NULL);
1465 }
1466 break;
1467 default:
1468 xmlErrValid(ctxt, XML_ERR_INTERNAL_ERROR,
1469 "Internal: ELEMENT decl corrupted invalid type\n",
1470 NULL);
1471 return(NULL);
1472 }
1473
1474 /*
1475 * check if name is a QName
1476 */
1477 uqname = xmlSplitQName2(name, &ns);
1478 if (uqname != NULL)
1479 name = uqname;
1480
1481 /*
1482 * Create the Element table if needed.
1483 */
1485 if (table == NULL) {
1486 xmlDictPtr dict = NULL;
1487
1488 if (dtd->doc != NULL)
1489 dict = dtd->doc->dict;
1490 table = xmlHashCreateDict(0, dict);
1491 dtd->elements = (void *) table;
1492 }
1493 if (table == NULL) {
1494 xmlVErrMemory(ctxt,
1495 "xmlAddElementDecl: Table creation failed!\n");
1496 if (uqname != NULL)
1497 xmlFree(uqname);
1498 if (ns != NULL)
1499 xmlFree(ns);
1500 return(NULL);
1501 }
1502
1503 /*
1504 * lookup old attributes inserted on an undefined element in the
1505 * internal subset.
1506 */
1507 if ((dtd->doc != NULL) && (dtd->doc->intSubset != NULL)) {
1508 ret = xmlHashLookup2(dtd->doc->intSubset->elements, name, ns);
1509 if ((ret != NULL) && (ret->etype == XML_ELEMENT_TYPE_UNDEFINED)) {
1510 oldAttributes = ret->attributes;
1511 ret->attributes = NULL;
1512 xmlHashRemoveEntry2(dtd->doc->intSubset->elements, name, ns, NULL);
1514 }
1515 }
1516
1517 /*
1518 * The element may already be present if one of its attribute
1519 * was registered first
1520 */
1522 if (ret != NULL) {
1523 if (ret->etype != XML_ELEMENT_TYPE_UNDEFINED) {
1524#ifdef LIBXML_VALID_ENABLED
1525 /*
1526 * The element is already defined in this DTD.
1527 */
1528 xmlErrValidNode(ctxt, (xmlNodePtr) dtd, XML_DTD_ELEM_REDEFINED,
1529 "Redefinition of element %s\n",
1530 name, NULL, NULL);
1531#endif /* LIBXML_VALID_ENABLED */
1532 if (uqname != NULL)
1533 xmlFree(uqname);
1534 if (ns != NULL)
1535 xmlFree(ns);
1536 return(NULL);
1537 }
1538 if (ns != NULL) {
1539 xmlFree(ns);
1540 ns = NULL;
1541 }
1542 } else {
1544 if (ret == NULL) {
1545 xmlVErrMemory(ctxt, "malloc failed");
1546 if (uqname != NULL)
1547 xmlFree(uqname);
1548 if (ns != NULL)
1549 xmlFree(ns);
1550 return(NULL);
1551 }
1552 memset(ret, 0, sizeof(xmlElement));
1553 ret->type = XML_ELEMENT_DECL;
1554
1555 /*
1556 * fill the structure.
1557 */
1558 ret->name = xmlStrdup(name);
1559 if (ret->name == NULL) {
1560 xmlVErrMemory(ctxt, "malloc failed");
1561 if (uqname != NULL)
1562 xmlFree(uqname);
1563 if (ns != NULL)
1564 xmlFree(ns);
1565 xmlFree(ret);
1566 return(NULL);
1567 }
1568 ret->prefix = ns;
1569
1570 /*
1571 * Validity Check:
1572 * Insertion must not fail
1573 */
1574 if (xmlHashAddEntry2(table, name, ns, ret)) {
1575#ifdef LIBXML_VALID_ENABLED
1576 /*
1577 * The element is already defined in this DTD.
1578 */
1579 xmlErrValidNode(ctxt, (xmlNodePtr) dtd, XML_DTD_ELEM_REDEFINED,
1580 "Redefinition of element %s\n",
1581 name, NULL, NULL);
1582#endif /* LIBXML_VALID_ENABLED */
1584 if (uqname != NULL)
1585 xmlFree(uqname);
1586 return(NULL);
1587 }
1588 /*
1589 * For new element, may have attributes from earlier
1590 * definition in internal subset
1591 */
1592 ret->attributes = oldAttributes;
1593 }
1594
1595 /*
1596 * Finish to fill the structure.
1597 */
1598 ret->etype = type;
1599 /*
1600 * Avoid a stupid copy when called by the parser
1601 * and flag it by setting a special parent value
1602 * so the parser doesn't unallocate it.
1603 */
1604 if ((ctxt != NULL) && (ctxt->flags & XML_VCTXT_USE_PCTXT)) {
1605 ret->content = content;
1606 if (content != NULL)
1607 content->parent = (xmlElementContentPtr) 1;
1608 } else {
1609 ret->content = xmlCopyDocElementContent(dtd->doc, content);
1610 }
1611
1612 /*
1613 * Link it to the DTD
1614 */
1615 ret->parent = dtd;
1616 ret->doc = dtd->doc;
1617 if (dtd->last == NULL) {
1618 dtd->children = dtd->last = (xmlNodePtr) ret;
1619 } else {
1620 dtd->last->next = (xmlNodePtr) ret;
1621 ret->prev = dtd->last;
1622 dtd->last = (xmlNodePtr) ret;
1623 }
1624 if (uqname != NULL)
1625 xmlFree(uqname);
1626 return(ret);
1627}
content
Definition: atl_ax.c:994
XMLPUBVAR xmlFreeFunc xmlFree
Definition: globals.h:251
XMLPUBFUN int XMLCALL xmlHashAddEntry2(xmlHashTablePtr table, const xmlChar *name, const xmlChar *name2, void *userdata)
Definition: hash.c:406
XMLPUBFUN int XMLCALL xmlHashRemoveEntry2(xmlHashTablePtr table, const xmlChar *name, const xmlChar *name2, xmlHashDeallocator f)
Definition: hash.c:1071
XMLPUBFUN void *XMLCALL xmlHashLookup2(xmlHashTablePtr table, const xmlChar *name, const xmlChar *name2)
Definition: hash.c:476
xmlElementContent * xmlElementContentPtr
Definition: tree.h:305
xmlElement * xmlElementPtr
Definition: tree.h:345
@ XML_ELEMENT_DECL
Definition: tree.h:174
@ XML_ELEMENT_TYPE_MIXED
Definition: tree.h:326
@ XML_ELEMENT_TYPE_EMPTY
Definition: tree.h:324
@ XML_ELEMENT_TYPE_UNDEFINED
Definition: tree.h:323
@ XML_ELEMENT_TYPE_ELEMENT
Definition: tree.h:327
@ XML_ELEMENT_TYPE_ANY
Definition: tree.h:325
XMLPUBFUN xmlChar *XMLCALL xmlSplitQName2(const xmlChar *name, xmlChar **prefix)
void * elements
Definition: tree.h:419
xmlElementContentPtr xmlCopyDocElementContent(xmlDocPtr doc, xmlElementContentPtr cur)
Definition: valid.c:995
static void xmlFreeElement(xmlElementPtr elem)
Definition: valid.c:1389
xmlElementTable * xmlElementTablePtr
Definition: valid.h:126
@ XML_DTD_ELEM_REDEFINED
Definition: xmlerror.h:228
unsigned char xmlChar
Definition: xmlstring.h:28

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 2672 of file valid.c.

2673 {
2674 xmlIDPtr ret;
2676
2677 if (doc == NULL) {
2678 return(NULL);
2679 }
2680 if ((value == NULL) || (value[0] == 0)) {
2681 return(NULL);
2682 }
2683 if (attr == NULL) {
2684 return(NULL);
2685 }
2686
2687 /*
2688 * Create the ID table if needed.
2689 */
2690 table = (xmlIDTablePtr) doc->ids;
2691 if (table == NULL) {
2692 doc->ids = table = xmlHashCreateDict(0, doc->dict);
2693 }
2694 if (table == NULL) {
2695 xmlVErrMemory(ctxt,
2696 "xmlAddID: Table creation failed!\n");
2697 return(NULL);
2698 }
2699
2700 ret = (xmlIDPtr) xmlMalloc(sizeof(xmlID));
2701 if (ret == NULL) {
2702 xmlVErrMemory(ctxt, "malloc failed");
2703 return(NULL);
2704 }
2705
2706 /*
2707 * fill the structure.
2708 */
2709 ret->value = xmlStrdup(value);
2710 ret->doc = doc;
2711 if (xmlIsStreaming(ctxt)) {
2712 /*
2713 * Operating in streaming mode, attr is gonna disappear
2714 */
2715 if (doc->dict != NULL)
2716 ret->name = xmlDictLookup(doc->dict, attr->name, -1);
2717 else
2718 ret->name = xmlStrdup(attr->name);
2719 ret->attr = NULL;
2720 } else {
2721 ret->attr = attr;
2722 ret->name = NULL;
2723 }
2724 ret->lineno = xmlGetLineNo(attr->parent);
2725
2726 if (xmlHashAddEntry(table, value, ret) < 0) {
2727#ifdef LIBXML_VALID_ENABLED
2728 /*
2729 * The id is already defined in this DTD.
2730 */
2731 if (ctxt != NULL) {
2732 xmlErrValidNode(ctxt, attr->parent, XML_DTD_ID_REDEFINED,
2733 "ID %s already defined\n", value, NULL, NULL);
2734 }
2735#endif /* LIBXML_VALID_ENABLED */
2736 xmlFreeID(ret);
2737 return(NULL);
2738 }
2739 if (attr != NULL)
2740 attr->atype = XML_ATTRIBUTE_ID;
2741 return(ret);
2742}
XMLPUBFUN int XMLCALL xmlHashAddEntry(xmlHashTablePtr table, const xmlChar *name, void *userdata)
Definition: hash.c:389
xmlID * xmlIDPtr
Definition: tree.h:456
XMLPUBFUN long XMLCALL xmlGetLineNo(const xmlNode *node)
void * ids
Definition: tree.h:575
struct _xmlDict * dict
Definition: tree.h:580
Definition: tree.h:457
Definition: cookie.c:202
WCHAR * name
Definition: cookie.c:203
Definition: pdh_main.c:94
static int xmlIsStreaming(xmlValidCtxtPtr ctxt)
Definition: valid.c:2626
static void xmlFreeID(xmlIDPtr id)
Definition: valid.c:2644
xmlIDTable * xmlIDTablePtr
Definition: valid.h:142
@ XML_DTD_ID_REDEFINED
Definition: xmlerror.h:232

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 2394 of file valid.c.

2396 {
2399
2400 if (dtd == NULL) {
2401 return(NULL);
2402 }
2403 if (name == NULL) {
2404 return(NULL);
2405 }
2406 if ((PublicID == NULL) && (SystemID == NULL)) {
2407 return(NULL);
2408 }
2409
2410 /*
2411 * Create the Notation table if needed.
2412 */
2414 if (table == NULL) {
2415 xmlDictPtr dict = NULL;
2416 if (dtd->doc != NULL)
2417 dict = dtd->doc->dict;
2418
2419 dtd->notations = table = xmlHashCreateDict(0, dict);
2420 }
2421 if (table == NULL) {
2422 xmlVErrMemory(ctxt,
2423 "xmlAddNotationDecl: Table creation failed!\n");
2424 return(NULL);
2425 }
2426
2428 if (ret == NULL) {
2429 xmlVErrMemory(ctxt, "malloc failed");
2430 return(NULL);
2431 }
2432 memset(ret, 0, sizeof(xmlNotation));
2433
2434 /*
2435 * fill the structure.
2436 */
2437 ret->name = xmlStrdup(name);
2438 if (SystemID != NULL)
2439 ret->SystemID = xmlStrdup(SystemID);
2440 if (PublicID != NULL)
2441 ret->PublicID = xmlStrdup(PublicID);
2442
2443 /*
2444 * Validity Check:
2445 * Check the DTD for previous declarations of the ATTLIST
2446 */
2447 if (xmlHashAddEntry(table, name, ret)) {
2448#ifdef LIBXML_VALID_ENABLED
2449 xmlErrValid(NULL, XML_DTD_NOTATION_REDEFINED,
2450 "xmlAddNotationDecl: %s already defined\n",
2451 (const char *) name);
2452#endif /* LIBXML_VALID_ENABLED */
2454 return(NULL);
2455 }
2456 return(ret);
2457}
xmlNotation * xmlNotationPtr
Definition: tree.h:193
void * notations
Definition: tree.h:418
static void xmlFreeNotation(xmlNotationPtr nota)
Definition: valid.c:2369
xmlNotationTable * xmlNotationTablePtr
Definition: valid.h:118
@ XML_DTD_NOTATION_REDEFINED
Definition: xmlerror.h:245

Referenced by xmlSAX2NotationDecl().

◆ xmlAddRef()

XML_DEPRECATED 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

DEPRECATED, do not use. This function will be removed from the public API.

Register a new ref declaration

Returns NULL if not, otherwise the new xmlRefPtr

Definition at line 3003 of file valid.c.

3004 {
3005 xmlRefPtr ret;
3007 xmlListPtr ref_list;
3008
3009 if (doc == NULL) {
3010 return(NULL);
3011 }
3012 if (value == NULL) {
3013 return(NULL);
3014 }
3015 if (attr == NULL) {
3016 return(NULL);
3017 }
3018
3019 /*
3020 * Create the Ref table if needed.
3021 */
3022 table = (xmlRefTablePtr) doc->refs;
3023 if (table == NULL) {
3024 doc->refs = table = xmlHashCreateDict(0, doc->dict);
3025 }
3026 if (table == NULL) {
3027 xmlVErrMemory(ctxt,
3028 "xmlAddRef: Table creation failed!\n");
3029 return(NULL);
3030 }
3031
3032 ret = (xmlRefPtr) xmlMalloc(sizeof(xmlRef));
3033 if (ret == NULL) {
3034 xmlVErrMemory(ctxt, "malloc failed");
3035 return(NULL);
3036 }
3037
3038 /*
3039 * fill the structure.
3040 */
3041 ret->value = xmlStrdup(value);
3042 if (xmlIsStreaming(ctxt)) {
3043 /*
3044 * Operating in streaming mode, attr is gonna disappear
3045 */
3046 ret->name = xmlStrdup(attr->name);
3047 ret->attr = NULL;
3048 } else {
3049 ret->name = NULL;
3050 ret->attr = attr;
3051 }
3052 ret->lineno = xmlGetLineNo(attr->parent);
3053
3054 /* To add a reference :-
3055 * References are maintained as a list of references,
3056 * Lookup the entry, if no entry create new nodelist
3057 * Add the owning node to the NodeList
3058 * Return the ref
3059 */
3060
3061 if (NULL == (ref_list = xmlHashLookup(table, value))) {
3062 if (NULL == (ref_list = xmlListCreate(xmlFreeRef, xmlDummyCompare))) {
3063 xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
3064 "xmlAddRef: Reference list creation failed!\n",
3065 NULL);
3066 goto failed;
3067 }
3068 if (xmlHashAddEntry(table, value, ref_list) < 0) {
3069 xmlListDelete(ref_list);
3070 xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
3071 "xmlAddRef: Reference list insertion failed!\n",
3072 NULL);
3073 goto failed;
3074 }
3075 }
3076 if (xmlListAppend(ref_list, ret) != 0) {
3077 xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
3078 "xmlAddRef: Reference list insertion failed!\n",
3079 NULL);
3080 goto failed;
3081 }
3082 return(ret);
3083failed:
3084 if (ret != NULL) {
3085 if (ret->value != NULL)
3086 xmlFree((char *)ret->value);
3087 if (ret->name != NULL)
3088 xmlFree((char *)ret->name);
3089 xmlFree(ret);
3090 }
3091 return(NULL);
3092}
XMLPUBFUN void *XMLCALL xmlHashLookup(xmlHashTablePtr table, const xmlChar *name)
Definition: hash.c:461
XMLPUBFUN int XMLCALL xmlListAppend(xmlListPtr l, void *data)
Definition: list.c:305
XMLPUBFUN void XMLCALL xmlListDelete(xmlListPtr l)
Definition: list.c:333
XMLPUBFUN xmlListPtr XMLCALL xmlListCreate(xmlListDeallocator deallocator, xmlListDataCompare compare)
Definition: list.c:188
xmlRef * xmlRefPtr
Definition: tree.h:473
void * refs
Definition: tree.h:576
Definition: list.c:39
Definition: tree.h:474
static int xmlDummyCompare(const void *data0 ATTRIBUTE_UNUSED, const void *data1 ATTRIBUTE_UNUSED)
Definition: valid.c:2983
static void xmlFreeRef(xmlLinkPtr lk)
Definition: valid.c:2931
xmlRefTable * xmlRefTablePtr
Definition: valid.h:150

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 995 of file valid.c.

995 {
996 xmlElementContentPtr ret = NULL, prev = NULL, tmp;
997 xmlDictPtr dict = NULL;
998
999 if (cur == NULL) return(NULL);
1000
1001 if (doc != NULL)
1002 dict = doc->dict;
1003
1005 if (ret == NULL) {
1006 xmlVErrMemory(NULL, "malloc failed");
1007 return(NULL);
1008 }
1009 memset(ret, 0, sizeof(xmlElementContent));
1010 ret->type = cur->type;
1011 ret->ocur = cur->ocur;
1012 if (cur->name != NULL) {
1013 if (dict)
1014 ret->name = xmlDictLookup(dict, cur->name, -1);
1015 else
1016 ret->name = xmlStrdup(cur->name);
1017 }
1018
1019 if (cur->prefix != NULL) {
1020 if (dict)
1021 ret->prefix = xmlDictLookup(dict, cur->prefix, -1);
1022 else
1023 ret->prefix = xmlStrdup(cur->prefix);
1024 }
1025 if (cur->c1 != NULL)
1026 ret->c1 = xmlCopyDocElementContent(doc, cur->c1);
1027 if (ret->c1 != NULL)
1028 ret->c1->parent = ret;
1029 if (cur->c2 != NULL) {
1030 prev = ret;
1031 cur = cur->c2;
1032 while (cur != NULL) {
1034 if (tmp == NULL) {
1035 xmlVErrMemory(NULL, "malloc failed");
1036 return(ret);
1037 }
1038 memset(tmp, 0, sizeof(xmlElementContent));
1039 tmp->type = cur->type;
1040 tmp->ocur = cur->ocur;
1041 prev->c2 = tmp;
1042 tmp->parent = prev;
1043 if (cur->name != NULL) {
1044 if (dict)
1045 tmp->name = xmlDictLookup(dict, cur->name, -1);
1046 else
1047 tmp->name = xmlStrdup(cur->name);
1048 }
1049
1050 if (cur->prefix != NULL) {
1051 if (dict)
1052 tmp->prefix = xmlDictLookup(dict, cur->prefix, -1);
1053 else
1054 tmp->prefix = xmlStrdup(cur->prefix);
1055 }
1056 if (cur->c1 != NULL)
1057 tmp->c1 = xmlCopyDocElementContent(doc,cur->c1);
1058 if (tmp->c1 != NULL)
1059 tmp->c1->parent = ret;
1060 prev = tmp;
1061 cur = cur->c2;
1062 }
1063 }
1064 return(ret);
1065}
FxCollectionEntry * cur

Referenced by xmlAddElementDecl(), xmlCopyDocElementContent(), and xmlCopyElementContent().

◆ xmlCopyElementContent()

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 1077 of file valid.c.

1077 {
1079}

◆ xmlCreateEnumeration()

XMLPUBFUN xmlEnumerationPtr XMLCALL xmlCreateEnumeration ( const xmlChar name)

Definition at line 1795 of file valid.c.

1795 {
1797
1799 if (ret == NULL) {
1800 xmlVErrMemory(NULL, "malloc failed");
1801 return(NULL);
1802 }
1803 memset(ret, 0, sizeof(xmlEnumeration));
1804
1805 if (name != NULL)
1806 ret->name = xmlStrdup(name);
1807 return(ret);
1808}
xmlEnumeration * xmlEnumerationPtr
Definition: tree.h:239

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 2193 of file valid.c.

2193 {
2195}
XMLPUBFUN void XMLCALL xmlHashFree(xmlHashTablePtr table, xmlHashDeallocator f)
Definition: hash.c:322
static void xmlFreeAttributeTableEntry(void *attr, const xmlChar *name ATTRIBUTE_UNUSED)
Definition: valid.c:2182

◆ 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 1089 of file valid.c.

1089 {
1090 xmlDictPtr dict = NULL;
1091 size_t depth = 0;
1092
1093 if (cur == NULL)
1094 return;
1095 if (doc != NULL)
1096 dict = doc->dict;
1097
1098 while (1) {
1100
1101 while ((cur->c1 != NULL) || (cur->c2 != NULL)) {
1102 cur = (cur->c1 != NULL) ? cur->c1 : cur->c2;
1103 depth += 1;
1104 }
1105
1106 switch (cur->type) {
1111 break;
1112 default:
1113 xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
1114 "Internal: ELEMENT content corrupted invalid type\n",
1115 NULL);
1116 return;
1117 }
1118 if (dict) {
1119 if ((cur->name != NULL) && (!xmlDictOwns(dict, cur->name)))
1120 xmlFree((xmlChar *) cur->name);
1121 if ((cur->prefix != NULL) && (!xmlDictOwns(dict, cur->prefix)))
1122 xmlFree((xmlChar *) cur->prefix);
1123 } else {
1124 if (cur->name != NULL) xmlFree((xmlChar *) cur->name);
1125 if (cur->prefix != NULL) xmlFree((xmlChar *) cur->prefix);
1126 }
1127 parent = cur->parent;
1128 if ((depth == 0) || (parent == NULL)) {
1129 xmlFree(cur);
1130 break;
1131 }
1132 if (cur == parent->c1)
1133 parent->c1 = NULL;
1134 else
1135 parent->c2 = NULL;
1136 xmlFree(cur);
1137
1138 if (parent->c2 != NULL) {
1139 cur = parent->c2;
1140 } else {
1141 depth -= 1;
1142 cur = parent;
1143 }
1144 }
1145}
r parent
Definition: btrfs.c:3010
GLint GLint GLsizei GLsizei GLsizei depth
Definition: gl.h:1546
XMLPUBFUN int XMLCALL xmlDictOwns(xmlDictPtr dict, const xmlChar *str)
Definition: dict.c:1220
@ XML_ELEMENT_CONTENT_PCDATA
Definition: tree.h:279
@ XML_ELEMENT_CONTENT_ELEMENT
Definition: tree.h:280
@ XML_ELEMENT_CONTENT_OR
Definition: tree.h:282
@ XML_ELEMENT_CONTENT_SEQ
Definition: tree.h:281

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 1155 of file valid.c.

1155 {
1157}
void xmlFreeDocElementContent(xmlDocPtr doc, xmlElementContentPtr cur)
Definition: valid.c:1089

◆ xmlFreeElementTable()

XMLPUBFUN void XMLCALL xmlFreeElementTable ( xmlElementTablePtr  table)

xmlFreeElementTable: @table: An element table

Deallocate the memory used by an element hash table.

Definition at line 1641 of file valid.c.

1641 {
1643}
static void xmlFreeElementTableEntry(void *elem, const xmlChar *name ATTRIBUTE_UNUSED)
Definition: valid.c:1630

◆ xmlFreeEnumeration()

XMLPUBFUN void XMLCALL xmlFreeEnumeration ( xmlEnumerationPtr  cur)

xmlFreeEnumeration: @cur: the tree to free.

free an enumeration attribute node (recursive).

Definition at line 1817 of file valid.c.

1817 {
1818 if (cur == NULL) return;
1819
1820 if (cur->next != NULL) xmlFreeEnumeration(cur->next);
1821
1822 if (cur->name != NULL) xmlFree((xmlChar *) cur->name);
1823 xmlFree(cur);
1824}

Referenced by attributeDeclDebug(), xmlAddAttributeDecl(), xmlFreeAttribute(), xmlFreeEnumeration(), 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 2756 of file valid.c.

2756 {
2758}
static void xmlFreeIDTableEntry(void *id, const xmlChar *name ATTRIBUTE_UNUSED)
Definition: valid.c:2745

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 2471 of file valid.c.

2471 {
2473}
static void xmlFreeNotationTableEntry(void *nota, const xmlChar *name ATTRIBUTE_UNUSED)
Definition: valid.c:2460

◆ xmlFreeRefTable()

XML_DEPRECATED XMLPUBFUN void XMLCALL xmlFreeRefTable ( xmlRefTablePtr  table)

xmlFreeRefTable: @table: An ref table

DEPRECATED, do not use. This function will be removed from the public API.

Deallocate the memory used by an Ref hash table.

Definition at line 3103 of file valid.c.

3103 {
3105}
static void xmlFreeRefTableEntry(void *payload, const xmlChar *name ATTRIBUTE_UNUSED)
Definition: valid.c:2948

◆ xmlGetDtdAttrDesc()

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

Definition at line 3379 of file valid.c.

3379 {
3382 xmlChar *uqname = NULL, *prefix = NULL;
3383
3384 if (dtd == NULL) return(NULL);
3385 if (dtd->attributes == NULL) return(NULL);
3386
3388 if (table == NULL)
3389 return(NULL);
3390
3391 uqname = xmlSplitQName2(name, &prefix);
3392
3393 if (uqname != NULL) {
3394 cur = xmlHashLookup3(table, uqname, prefix, elem);
3395 if (prefix != NULL) xmlFree(prefix);
3396 if (uqname != NULL) xmlFree(uqname);
3397 } else
3399 return(cur);
3400}

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

◆ xmlGetDtdElementDesc()

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

Definition at line 3257 of file valid.c.

3257 {
3260 xmlChar *uqname = NULL, *prefix = NULL;
3261
3262 if ((dtd == NULL) || (name == NULL)) return(NULL);
3263 if (dtd->elements == NULL)
3264 return(NULL);
3266
3267 uqname = xmlSplitQName2(name, &prefix);
3268 if (uqname != NULL)
3269 name = uqname;
3270 cur = xmlHashLookup2(table, name, prefix);
3271 if (prefix != NULL) xmlFree(prefix);
3272 if (uqname != NULL) xmlFree(uqname);
3273 return(cur);
3274}

Referenced by xmlIsMixedElement().

◆ xmlGetDtdNotationDesc()

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

Definition at line 3438 of file valid.c.

3438 {
3440
3441 if (dtd == NULL) return(NULL);
3442 if (dtd->notations == NULL) return(NULL);
3444
3445 return(xmlHashLookup(table, name));
3446}

◆ xmlGetDtdQAttrDesc()

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

Definition at line 3416 of file valid.c.

3417 {
3419
3420 if (dtd == NULL) return(NULL);
3421 if (dtd->attributes == NULL) return(NULL);
3423
3424 return(xmlHashLookup3(table, name, prefix, elem));
3425}

◆ xmlGetDtdQElementDesc()

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

Definition at line 3355 of file valid.c.

3356 {
3358
3359 if (dtd == NULL) return(NULL);
3360 if (dtd->elements == NULL) return(NULL);
3362
3363 return(xmlHashLookup2(table, name, prefix));
3364}

◆ 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 2874 of file valid.c.

2874 {
2876 xmlIDPtr id;
2877
2878 if (doc == NULL) {
2879 return(NULL);
2880 }
2881
2882 if (ID == NULL) {
2883 return(NULL);
2884 }
2885
2886 table = (xmlIDTablePtr) doc->ids;
2887 if (table == NULL)
2888 return(NULL);
2889
2890 id = xmlHashLookup(table, ID);
2891 if (id == NULL)
2892 return(NULL);
2893 if (id->attr == NULL) {
2894 /*
2895 * We are operating on a stream, return a well known reference
2896 * since the attribute node doesn't exist anymore
2897 */
2898 return((xmlAttrPtr) doc);
2899 }
2900 return(id->attr);
2901}
GLuint id
Definition: glext.h:5910
#define ID
Definition: ruserpass.c:36
Definition: tree.h:434

Referenced by xsltLoadStylesheetPI(), and xsltTestStepMatch().

◆ xmlGetRefs()

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

DEPRECATED, do not use. This function will be removed from the public API.

Find the set of references for the supplied ID.

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

Definition at line 3222 of file valid.c.

3222 {
3224
3225 if (doc == NULL) {
3226 return(NULL);
3227 }
3228
3229 if (ID == NULL) {
3230 return(NULL);
3231 }
3232
3233 table = (xmlRefTablePtr) doc->refs;
3234 if (table == NULL)
3235 return(NULL);
3236
3237 return (xmlHashLookup(table, ID));
3238}

◆ 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 2774 of file valid.c.

2774 {
2775 if ((attr == NULL) || (attr->name == NULL)) return(0);
2776 if ((attr->ns != NULL) && (attr->ns->prefix != NULL) &&
2777 (!strcmp((char *) attr->name, "id")) &&
2778 (!strcmp((char *) attr->ns->prefix, "xml")))
2779 return(1);
2780 if (doc == NULL) return(0);
2781 if ((doc->intSubset == NULL) && (doc->extSubset == NULL) &&
2782 (doc->type != XML_HTML_DOCUMENT_NODE)) {
2783 return(0);
2784 } else if (doc->type == XML_HTML_DOCUMENT_NODE) {
2785 if ((xmlStrEqual(BAD_CAST "id", attr->name)) ||
2786 ((xmlStrEqual(BAD_CAST "name", attr->name)) &&
2787 ((elem == NULL) || (xmlStrEqual(elem->name, BAD_CAST "a")))))
2788 return(1);
2789 return(0);
2790 } else if (elem == NULL) {
2791 return(0);
2792 } else {
2793 xmlAttributePtr attrDecl = NULL;
2794
2795 xmlChar felem[50], fattr[50];
2796 xmlChar *fullelemname, *fullattrname;
2797
2798 fullelemname = (elem->ns != NULL && elem->ns->prefix != NULL) ?
2799 xmlBuildQName(elem->name, elem->ns->prefix, felem, 50) :
2800 (xmlChar *)elem->name;
2801
2802 fullattrname = (attr->ns != NULL && attr->ns->prefix != NULL) ?
2803 xmlBuildQName(attr->name, attr->ns->prefix, fattr, 50) :
2804 (xmlChar *)attr->name;
2805
2806 if (fullelemname != NULL && fullattrname != NULL) {
2807 attrDecl = xmlGetDtdAttrDesc(doc->intSubset, fullelemname,
2808 fullattrname);
2809 if ((attrDecl == NULL) && (doc->extSubset != NULL))
2810 attrDecl = xmlGetDtdAttrDesc(doc->extSubset, fullelemname,
2811 fullattrname);
2812 }
2813
2814 if ((fullattrname != fattr) && (fullattrname != attr->name))
2815 xmlFree(fullattrname);
2816 if ((fullelemname != felem) && (fullelemname != elem->name))
2817 xmlFree(fullelemname);
2818
2819 if ((attrDecl != NULL) && (attrDecl->atype == XML_ATTRIBUTE_ID))
2820 return(1);
2821 }
2822 return(0);
2823}
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
XMLPUBFUN xmlChar *XMLCALL xmlBuildQName(const xmlChar *ncname, const xmlChar *prefix, xmlChar *memory, int len)
@ XML_HTML_DOCUMENT_NODE
Definition: tree.h:172
xmlAttributeType atype
Definition: tree.h:265
struct _xmlDtd * intSubset
Definition: tree.h:570
xmlElementType type
Definition: tree.h:553
struct _xmlDtd * extSubset
Definition: tree.h:571
Definition: fatfs.h:133
xmlAttributePtr xmlGetDtdAttrDesc(xmlDtdPtr dtd, const xmlChar *elem, const xmlChar *name)
Definition: valid.c:3379

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 3494 of file valid.c.

3494 {
3495 xmlElementPtr elemDecl;
3496
3497 if ((doc == NULL) || (doc->intSubset == NULL)) return(-1);
3498
3499 elemDecl = xmlGetDtdElementDesc(doc->intSubset, name);
3500 if ((elemDecl == NULL) && (doc->extSubset != NULL))
3501 elemDecl = xmlGetDtdElementDesc(doc->extSubset, name);
3502 if (elemDecl == NULL) return(-1);
3503 switch (elemDecl->etype) {
3505 return(-1);
3507 return(0);
3509 /*
3510 * return 1 for EMPTY since we want VC error to pop up
3511 * on <empty> </empty> for example
3512 */
3515 return(1);
3516 }
3517 return(1);
3518}
xmlElementTypeVal etype
Definition: tree.h:357
xmlElementPtr xmlGetDtdElementDesc(xmlDtdPtr dtd, const xmlChar *name)
Definition: valid.c:3257

Referenced by areBlanks().

◆ xmlIsRef()

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

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

DEPRECATED, do not use. This function will be removed from the public API.

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 3122 of file valid.c.

3122 {
3123 if (attr == NULL)
3124 return(0);
3125 if (doc == NULL) {
3126 doc = attr->doc;
3127 if (doc == NULL) return(0);
3128 }
3129
3130 if ((doc->intSubset == NULL) && (doc->extSubset == NULL)) {
3131 return(0);
3132 } else if (doc->type == XML_HTML_DOCUMENT_NODE) {
3133 /* TODO @@@ */
3134 return(0);
3135 } else {
3136 xmlAttributePtr attrDecl;
3137
3138 if (elem == NULL) return(0);
3139 attrDecl = xmlGetDtdAttrDesc(doc->intSubset, elem->name, attr->name);
3140 if ((attrDecl == NULL) && (doc->extSubset != NULL))
3141 attrDecl = xmlGetDtdAttrDesc(doc->extSubset,
3142 elem->name, attr->name);
3143
3144 if ((attrDecl != NULL) &&
3145 (attrDecl->atype == XML_ATTRIBUTE_IDREF ||
3146 attrDecl->atype == XML_ATTRIBUTE_IDREFS))
3147 return(1);
3148 }
3149 return(0);
3150}

Referenced by xmlSAX2AttributeNs().

◆ xmlNewDocElementContent()

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

Definition at line 908 of file valid.c.

909 {
911 xmlDictPtr dict = NULL;
912
913 if (doc != NULL)
914 dict = doc->dict;
915
916 switch(type) {
918 if (name == NULL) {
919 xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
920 "xmlNewElementContent : name == NULL !\n",
921 NULL);
922 }
923 break;
927 if (name != NULL) {
928 xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
929 "xmlNewElementContent : name != NULL !\n",
930 NULL);
931 }
932 break;
933 default:
934 xmlErrValid(NULL, XML_ERR_INTERNAL_ERROR,
935 "Internal: ELEMENT content corrupted invalid type\n",
936 NULL);
937 return(NULL);
938 }
940 if (ret == NULL) {
941 xmlVErrMemory(NULL, "malloc failed");
942 return(NULL);
943 }
944 memset(ret, 0, sizeof(xmlElementContent));
945 ret->type = type;
947 if (name != NULL) {
948 int l;
949 const xmlChar *tmp;
950
951 tmp = xmlSplitQName3(name, &l);
952 if (tmp == NULL) {
953 if (dict == NULL)
954 ret->name = xmlStrdup(name);
955 else
956 ret->name = xmlDictLookup(dict, name, -1);
957 } else {
958 if (dict == NULL) {
959 ret->prefix = xmlStrndup(name, l);
960 ret->name = xmlStrdup(tmp);
961 } else {
962 ret->prefix = xmlDictLookup(dict, name, l);
963 ret->name = xmlDictLookup(dict, tmp, -1);
964 }
965 }
966 }
967 return(ret);
968}
r l[0]
Definition: byte_order.h:167
@ XML_ELEMENT_CONTENT_ONCE
Definition: tree.h:291
XMLPUBFUN const xmlChar *XMLCALL xmlSplitQName3(const xmlChar *name, int *len)
XMLPUBFUN xmlChar *XMLCALL xmlStrndup(const xmlChar *cur, int len)
Definition: xmlstring.c:42

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

◆ xmlNewElementContent()

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

Definition at line 981 of file valid.c.

981 {
983}
xmlElementContentPtr xmlNewDocElementContent(xmlDocPtr doc, const xmlChar *name, xmlElementContentType type)
Definition: valid.c:908

◆ 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 2835 of file valid.c.

2835 {
2837 xmlIDPtr id;
2838 xmlChar *ID;
2839
2840 if (doc == NULL) return(-1);
2841 if (attr == NULL) return(-1);
2842
2843 table = (xmlIDTablePtr) doc->ids;
2844 if (table == NULL)
2845 return(-1);
2846
2847 ID = xmlNodeListGetString(doc, attr->children, 1);
2848 if (ID == NULL)
2849 return(-1);
2851
2852 id = xmlHashLookup(table, ID);
2853 if (id == NULL || id->attr != attr) {
2854 xmlFree(ID);
2855 return(-1);
2856 }
2857
2859 xmlFree(ID);
2860 attr->atype = 0;
2861 return(0);
2862}
XMLPUBFUN int XMLCALL xmlHashRemoveEntry(xmlHashTablePtr table, const xmlChar *name, xmlHashDeallocator f)
Definition: hash.c:1052
XMLPUBFUN xmlChar *XMLCALL xmlNodeListGetString(xmlDocPtr doc, const xmlNode *list, int inLine)
static void xmlValidNormalizeString(xmlChar *str)
Definition: valid.c:2603

◆ xmlRemoveRef()

XML_DEPRECATED XMLPUBFUN int XMLCALL xmlRemoveRef ( xmlDocPtr  doc,
xmlAttrPtr  attr 
)

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

DEPRECATED, do not use. This function will be removed from the public API.

Remove the given attribute from the Ref table maintained internally.

Returns -1 if the lookup failed and 0 otherwise

Definition at line 3164 of file valid.c.

3164 {
3165 xmlListPtr ref_list;
3167 xmlChar *ID;
3169
3170 if (doc == NULL) return(-1);
3171 if (attr == NULL) return(-1);
3172
3173 table = (xmlRefTablePtr) doc->refs;
3174 if (table == NULL)
3175 return(-1);
3176
3177 ID = xmlNodeListGetString(doc, attr->children, 1);
3178 if (ID == NULL)
3179 return(-1);
3180
3181 ref_list = xmlHashLookup(table, ID);
3182 if(ref_list == NULL) {
3183 xmlFree(ID);
3184 return (-1);
3185 }
3186
3187 /* At this point, ref_list refers to a list of references which
3188 * have the same key as the supplied attr. Our list of references
3189 * is ordered by reference address and we don't have that information
3190 * here to use when removing. We'll have to walk the list and
3191 * check for a matching attribute, when we find one stop the walk
3192 * and remove the entry.
3193 * The list is ordered by reference, so that means we don't have the
3194 * key. Passing the list and the reference to the walker means we
3195 * will have enough data to be able to remove the entry.
3196 */
3197 target.l = ref_list;
3198 target.ap = attr;
3199
3200 /* Remove the supplied attr from our list */
3201 xmlListWalk(ref_list, xmlWalkRemoveRef, &target);
3202
3203 /*If the list is empty then remove the list entry in the hash */
3204 if (xmlListEmpty(ref_list))
3206 xmlFree(ID);
3207 return(0);
3208}
GLenum target
Definition: glext.h:7315
XMLPUBFUN int XMLCALL xmlHashUpdateEntry(xmlHashTablePtr table, const xmlChar *name, void *userdata, xmlHashDeallocator f)
Definition: hash.c:425
XMLPUBFUN void XMLCALL xmlListWalk(xmlListPtr l, xmlListWalker walker, void *user)
Definition: list.c:676
XMLPUBFUN int XMLCALL xmlListEmpty(xmlListPtr l)
Definition: list.c:446
static int xmlWalkRemoveRef(const void *data, void *user)
Definition: valid.c:2962

◆ 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 1285 of file valid.c.

1285 {
1286 int len;
1287
1288 if (content == NULL) return;
1289 len = strlen(buf);
1290 if (size - len < 50) {
1291 if ((size - len > 4) && (buf[len - 1] != '.'))
1292 strcat(buf, " ...");
1293 return;
1294 }
1295 if (englob) strcat(buf, "(");
1296 switch (content->type) {
1298 strcat(buf, "#PCDATA");
1299 break;
1301 int qnameLen = xmlStrlen(content->name);
1302
1303 if (content->prefix != NULL)
1304 qnameLen += xmlStrlen(content->prefix) + 1;
1305 if (size - len < qnameLen + 10) {
1306 strcat(buf, " ...");
1307 return;
1308 }
1309 if (content->prefix != NULL) {
1310 strcat(buf, (char *) content->prefix);
1311 strcat(buf, ":");
1312 }
1313 if (content->name != NULL)
1314 strcat(buf, (char *) content->name);
1315 break;
1316 }
1318 if ((content->c1->type == XML_ELEMENT_CONTENT_OR) ||
1319 (content->c1->type == XML_ELEMENT_CONTENT_SEQ))
1321 else
1323 len = strlen(buf);
1324 if (size - len < 50) {
1325 if ((size - len > 4) && (buf[len - 1] != '.'))
1326 strcat(buf, " ...");
1327 return;
1328 }
1329 strcat(buf, " , ");
1330 if (((content->c2->type == XML_ELEMENT_CONTENT_OR) ||
1331 (content->c2->ocur != XML_ELEMENT_CONTENT_ONCE)) &&
1332 (content->c2->type != XML_ELEMENT_CONTENT_ELEMENT))
1334 else
1336 break;
1338 if ((content->c1->type == XML_ELEMENT_CONTENT_OR) ||
1339 (content->c1->type == XML_ELEMENT_CONTENT_SEQ))
1341 else
1343 len = strlen(buf);
1344 if (size - len < 50) {
1345 if ((size - len > 4) && (buf[len - 1] != '.'))
1346 strcat(buf, " ...");
1347 return;
1348 }
1349 strcat(buf, " | ");
1350 if (((content->c2->type == XML_ELEMENT_CONTENT_SEQ) ||
1351 (content->c2->ocur != XML_ELEMENT_CONTENT_ONCE)) &&
1352 (content->c2->type != XML_ELEMENT_CONTENT_ELEMENT))
1354 else
1356 break;
1357 }
1358 if (size - strlen(buf) <= 2) return;
1359 if (englob)
1360 strcat(buf, ")");
1361 switch (content->ocur) {
1363 break;
1365 strcat(buf, "?");
1366 break;
1368 strcat(buf, "*");
1369 break;
1371 strcat(buf, "+");
1372 break;
1373 }
1374}
char * strcat(char *DstString, const char *SrcString)
Definition: utclib.c:568
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
GLsizeiptr size
Definition: glext.h:5919
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
GLenum GLsizei len
Definition: glext.h:6722
@ XML_ELEMENT_CONTENT_OPT
Definition: tree.h:292
@ XML_ELEMENT_CONTENT_PLUS
Definition: tree.h:294
@ XML_ELEMENT_CONTENT_MULT
Definition: tree.h:293
void xmlSnprintfElementContent(char *buf, int size, xmlElementContentPtr content, int englob)
Definition: valid.c:1285
XMLPUBFUN int XMLCALL xmlStrlen(const xmlChar *str)
Definition: xmlstring.c:426

Referenced by xmlSnprintfElementContent().