ReactOS  0.4.15-dev-5463-g138eb58
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 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 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

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)
 
: 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 xmlRemoveMemoxmlRemoveMemoPtr
 
typedef struct xmlValidateMemo_t xmlValidateMemo
 
typedef xmlValidateMemoxmlValidateMemoPtr
 
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 xmlValidNormalizeString (xmlChar *str)
 
static int xmlIsStreaming (xmlValidCtxtPtr ctxt)
 
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)
 

Macro Definition Documentation

◆ DICT_FREE

#define DICT_FREE (   str)
Value:
if ((str) && ((!dict) || \
(xmlDictOwns(dict, (const xmlChar *)(str)) == 0))) \
xmlFree((char *)(str));
const WCHAR * str
unsigned char xmlChar
Definition: xmlstring.h:28
XMLPUBFUN int XMLCALL xmlDictOwns(xmlDictPtr dict, const xmlChar *str)
Definition: dict.c:1220

DICT_FREE: @str: a string

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

Definition at line 2591 of file valid.c.

◆ IN_LIBXML

#define IN_LIBXML

Definition at line 10 of file valid.c.

◆ TODO

#define TODO
Value:
"Unimplemented block at %s:%d\n", \
__FILE__, __LINE__);
XMLPUBVAR xmlGenericErrorFunc xmlGenericError
Definition: globals.h:337
XMLPUBVAR void * xmlGenericErrorContext
Definition: globals.h:353

Definition at line 31 of file valid.c.

Typedef Documentation

◆ xmlRemoveMemo

◆ xmlRemoveMemoPtr

Definition at line 2914 of file valid.c.

◆ xmlValidateMemo

◆ xmlValidateMemoPtr

Definition at line 2922 of file valid.c.

Function Documentation

◆ LIBXML_ATTR_FORMAT()

static void LIBXML_ATTR_FORMAT ( ,
 
)
static

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

Handle a validation error

Definition at line 92 of file valid.c.

95 {
96  xmlGenericErrorFunc channel = NULL;
97  xmlParserCtxtPtr pctxt = NULL;
98  void *data = NULL;
99 
100  if (ctxt != NULL) {
101  channel = ctxt->error;
102  data = ctxt->userData;
103  /* Look up flag to detect if it is part of a parsing
104  context */
105  if (ctxt->flags & XML_VCTXT_USE_PCTXT) {
106  long delta = (char *) ctxt - (char *) ctxt->userData;
107  if ((delta > 0) && (delta < 250))
108  pctxt = ctxt->userData;
109  }
110  }
111  if (extra)
112  __xmlRaiseError(NULL, channel, data,
113  pctxt, NULL, XML_FROM_VALID, error,
114  XML_ERR_ERROR, NULL, 0, extra, NULL, NULL, 0, 0,
115  msg, extra);
116  else
117  __xmlRaiseError(NULL, channel, data,
118  pctxt, NULL, XML_FROM_VALID, error,
119  XML_ERR_ERROR, NULL, 0, NULL, NULL, NULL, 0, 0,
120  "%s", msg);
121 }
#define error(str)
Definition: mkdosfs.c:1605
Definition: id3.c:95
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
#define NULL
Definition: types.h:112
#define msg(x)
Definition: auth_time.c:54
void(XMLCDECL * xmlGenericErrorFunc)(void *ctx, const char *msg,...) LIBXML_ATTR_FORMAT(2
Definition: xmlerror.h:847
void * userData
Definition: parser.h:186

◆ 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 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) {
1997  case XML_ATTRIBUTE_CDATA:
1998  break;
1999  case XML_ATTRIBUTE_ID:
2000  break;
2001  case XML_ATTRIBUTE_IDREF:
2002  break;
2003  case XML_ATTRIBUTE_IDREFS:
2004  break;
2005  case XML_ATTRIBUTE_ENTITY:
2006  break;
2008  break;
2009  case XML_ATTRIBUTE_NMTOKEN:
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 }
XMLPUBFUN int XMLCALL xmlHashAddEntry3(xmlHashTablePtr table, const xmlChar *name, const xmlChar *name2, const xmlChar *name3, void *userdata)
Definition: hash.c:531
struct _xmlDoc * doc
Definition: tree.h:415
struct _tree tree
void xmlFreeEnumeration(xmlEnumerationPtr cur)
Definition: valid.c:1817
GLenum GLsizei GLenum GLenum const GLvoid * table
Definition: glext.h:5644
static void xmlVErrMemory(xmlValidCtxtPtr ctxt, const char *extra)
Definition: valid.c:55
if(dx==0 &&dy==0)
Definition: linetemp.h:174
const xmlChar * name
Definition: tree.h:256
void * attributes
Definition: tree.h:420
static size_t elem
Definition: string.c:68
xmlAttributeTable * xmlAttributeTablePtr
Definition: valid.h:134
xmlNode * xmlNodePtr
Definition: tree.h:488
#define BAD_CAST
Definition: xmlstring.h:35
Definition: dict.c:111
XMLPUBFUN void *XMLCALL xmlHashLookup3(xmlHashTablePtr table, const xmlChar *name, const xmlChar *name2, const xmlChar *name3)
Definition: hash.c:769
xmlAttributePtr attributes
Definition: tree.h:359
struct _xmlNode * last
Definition: tree.h:411
XMLPUBFUN const xmlChar *XMLCALL xmlDictLookup(xmlDictPtr dict, const xmlChar *name, int len)
Definition: dict.c:867
Definition: tree.h:489
int ret
Definition: mxnamespace.c:44
static void xmlFreeAttribute(xmlAttributePtr attr)
Definition: valid.c:1914
xmlAttribute * xmlAttributePtr
Definition: tree.h:252
struct _xmlNode * children
Definition: tree.h:410
static xmlElementPtr xmlGetDtdElementDesc2(xmlDtdPtr dtd, const xmlChar *name, int create)
Definition: valid.c:3287
struct _xmlAttribute * nexth
Definition: tree.h:264
XMLPUBFUN xmlHashTablePtr XMLCALL xmlHashCreateDict(int size, xmlDictPtr dict)
Definition: hash.c:210
#define NULL
Definition: types.h:112
XMLPUBVAR xmlMallocFunc xmlMalloc
Definition: globals.h:248
Definition: name.c:38
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
XMLPUBFUN int XMLCALL xmlStrEqual(const xmlChar *str1, const xmlChar *str2)
Definition: xmlstring.c:160
int valid
Definition: valid.h:95
#define memset(x, y, z)
Definition: compat.h:39
XMLPUBFUN xmlChar *XMLCALL xmlStrdup(const xmlChar *cur)
Definition: xmlstring.c:67

Referenced by xmlSAX2AttributeDecl().

◆ xmlAddElementDecl()

xmlElementPtr 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;
1443  case XML_ELEMENT_TYPE_ANY:
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 {
1543  ret = (xmlElementPtr) xmlMalloc(sizeof(xmlElement));
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 }
static void xmlFreeElement(xmlElementPtr elem)
Definition: valid.c:1389
struct _xmlDoc * doc
Definition: tree.h:415
XMLPUBFUN int XMLCALL xmlHashAddEntry2(xmlHashTablePtr table, const xmlChar *name, const xmlChar *name2, void *userdata)
Definition: hash.c:406
GLenum GLsizei GLenum GLenum const GLvoid * table
Definition: glext.h:5644
static void xmlVErrMemory(xmlValidCtxtPtr ctxt, const char *extra)
Definition: valid.c:55
xmlElementTable * xmlElementTablePtr
Definition: valid.h:126
if(dx==0 &&dy==0)
Definition: linetemp.h:174
XMLPUBFUN void *XMLCALL xmlHashLookup2(xmlHashTablePtr table, const xmlChar *name, const xmlChar *name2)
Definition: hash.c:476
content
Definition: atl_ax.c:993
xmlNode * xmlNodePtr
Definition: tree.h:488
Definition: dict.c:111
xmlElement * xmlElementPtr
Definition: tree.h:345
void * elements
Definition: tree.h:419
XMLPUBFUN int XMLCALL xmlHashRemoveEntry2(xmlHashTablePtr table, const xmlChar *name, const xmlChar *name2, xmlHashDeallocator f)
Definition: hash.c:1071
XMLPUBVAR xmlFreeFunc xmlFree
Definition: globals.h:251
struct _xmlNode * last
Definition: tree.h:411
Definition: tree.h:489
int ret
Definition: mxnamespace.c:44
unsigned char xmlChar
Definition: xmlstring.h:28
struct _xmlNode * children
Definition: tree.h:410
XMLPUBFUN xmlHashTablePtr XMLCALL xmlHashCreateDict(int size, xmlDictPtr dict)
Definition: hash.c:210
#define NULL
Definition: types.h:112
XMLPUBVAR xmlMallocFunc xmlMalloc
Definition: globals.h:248
Definition: name.c:38
xmlElementContentPtr xmlCopyDocElementContent(xmlDocPtr doc, xmlElementContentPtr cur)
Definition: valid.c:995
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
unsigned int flags
Definition: valid.h:93
#define memset(x, y, z)
Definition: compat.h:39
XMLPUBFUN xmlChar *XMLCALL xmlStrdup(const xmlChar *cur)
Definition: xmlstring.c:67
xmlElementContent * xmlElementContentPtr
Definition: tree.h:305
XMLPUBFUN xmlChar *XMLCALL xmlSplitQName2(const xmlChar *name, xmlChar **prefix)

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 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 }
Definition: pdh_main.c:93
static void xmlFreeID(xmlIDPtr id)
Definition: valid.c:2644
GLenum GLsizei GLenum GLenum const GLvoid * table
Definition: glext.h:5644
XMLPUBFUN int XMLCALL xmlHashAddEntry(xmlHashTablePtr table, const xmlChar *name, void *userdata)
Definition: hash.c:389
static void xmlVErrMemory(xmlValidCtxtPtr ctxt, const char *extra)
Definition: valid.c:55
if(dx==0 &&dy==0)
Definition: linetemp.h:174
void * ids
Definition: tree.h:575
XMLPUBFUN long XMLCALL xmlGetLineNo(const xmlNode *node)
xmlID * xmlIDPtr
Definition: tree.h:456
XMLPUBFUN const xmlChar *XMLCALL xmlDictLookup(xmlDictPtr dict, const xmlChar *name, int len)
Definition: dict.c:867
Definition: cookie.c:201
int ret
__u8 attr
Definition: mkdosfs.c:359
static int xmlIsStreaming(xmlValidCtxtPtr ctxt)
Definition: valid.c:2626
xmlIDTable * xmlIDTablePtr
Definition: valid.h:142
XMLPUBFUN xmlHashTablePtr XMLCALL xmlHashCreateDict(int size, xmlDictPtr dict)
Definition: hash.c:210
#define NULL
Definition: types.h:112
XMLPUBVAR xmlMallocFunc xmlMalloc
Definition: globals.h:248
WCHAR * name
Definition: cookie.c:203
struct _xmlDict * dict
Definition: tree.h:580
XMLPUBFUN xmlChar *XMLCALL xmlStrdup(const xmlChar *cur)
Definition: xmlstring.c:67
Definition: tree.h:457

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 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 
2427  ret = (xmlNotationPtr) xmlMalloc(sizeof(xmlNotation));
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 }
struct _xmlDoc * doc
Definition: tree.h:415
void * notations
Definition: tree.h:418
GLenum GLsizei GLenum GLenum const GLvoid * table
Definition: glext.h:5644
XMLPUBFUN int XMLCALL xmlHashAddEntry(xmlHashTablePtr table, const xmlChar *name, void *userdata)
Definition: hash.c:389
static void xmlVErrMemory(xmlValidCtxtPtr ctxt, const char *extra)
Definition: valid.c:55
if(dx==0 &&dy==0)
Definition: linetemp.h:174
static void xmlFreeNotation(xmlNotationPtr nota)
Definition: valid.c:2369
Definition: dict.c:111
int ret
xmlNotationTable * xmlNotationTablePtr
Definition: valid.h:118
XMLPUBFUN xmlHashTablePtr XMLCALL xmlHashCreateDict(int size, xmlDictPtr dict)
Definition: hash.c:210
#define NULL
Definition: types.h:112
XMLPUBVAR xmlMallocFunc xmlMalloc
Definition: globals.h:248
Definition: name.c:38
xmlNotation * xmlNotationPtr
Definition: tree.h:193
#define memset(x, y, z)
Definition: compat.h:39
XMLPUBFUN xmlChar *XMLCALL xmlStrdup(const xmlChar *cur)
Definition: xmlstring.c:67

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

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);
3083 failed:
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 }
Definition: pdh_main.c:93
XMLPUBFUN xmlListPtr XMLCALL xmlListCreate(xmlListDeallocator deallocator, xmlListDataCompare compare)
Definition: list.c:188
xmlRef * xmlRefPtr
Definition: tree.h:473
XMLPUBFUN int XMLCALL xmlListAppend(xmlListPtr l, void *data)
Definition: list.c:305
GLenum GLsizei GLenum GLenum const GLvoid * table
Definition: glext.h:5644
XMLPUBFUN int XMLCALL xmlHashAddEntry(xmlHashTablePtr table, const xmlChar *name, void *userdata)
Definition: hash.c:389
static void xmlVErrMemory(xmlValidCtxtPtr ctxt, const char *extra)
Definition: valid.c:55
if(dx==0 &&dy==0)
Definition: linetemp.h:174
void * refs
Definition: tree.h:576
Definition: tree.h:474
XMLPUBFUN long XMLCALL xmlGetLineNo(const xmlNode *node)
XMLPUBVAR xmlFreeFunc xmlFree
Definition: globals.h:251
Definition: cookie.c:201
int ret
__u8 attr
Definition: mkdosfs.c:359
static int xmlDummyCompare(const void *data0 ATTRIBUTE_UNUSED, const void *data1 ATTRIBUTE_UNUSED)
Definition: valid.c:2983
static int xmlIsStreaming(xmlValidCtxtPtr ctxt)
Definition: valid.c:2626
Definition: list.c:38
XMLPUBFUN xmlHashTablePtr XMLCALL xmlHashCreateDict(int size, xmlDictPtr dict)
Definition: hash.c:210
#define NULL
Definition: types.h:112
XMLPUBVAR xmlMallocFunc xmlMalloc
Definition: globals.h:248
xmlRefTable * xmlRefTablePtr
Definition: valid.h:150
WCHAR * name
Definition: cookie.c:203
XMLPUBFUN void *XMLCALL xmlHashLookup(xmlHashTablePtr table, const xmlChar *name)
Definition: hash.c:461
XMLPUBFUN void XMLCALL xmlListDelete(xmlListPtr l)
Definition: list.c:333
static void xmlFreeRef(xmlLinkPtr lk)
Definition: valid.c:2931
struct _xmlDict * dict
Definition: tree.h:580
XMLPUBFUN xmlChar *XMLCALL xmlStrdup(const xmlChar *cur)
Definition: xmlstring.c:67

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 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 }
static void xmlVErrMemory(xmlValidCtxtPtr ctxt, const char *extra)
Definition: valid.c:55
Definition: dict.c:111
XMLPUBFUN const xmlChar *XMLCALL xmlDictLookup(xmlDictPtr dict, const xmlChar *name, int len)
Definition: dict.c:867
int ret
FxCollectionEntry * cur
#define NULL
Definition: types.h:112
XMLPUBVAR xmlMallocFunc xmlMalloc
Definition: globals.h:248
xmlElementContentPtr xmlCopyDocElementContent(xmlDocPtr doc, xmlElementContentPtr cur)
Definition: valid.c:995
#define memset(x, y, z)
Definition: compat.h:39
struct _xmlDict * dict
Definition: tree.h:580
XMLPUBFUN xmlChar *XMLCALL xmlStrdup(const xmlChar *cur)
Definition: xmlstring.c:67
xmlElementContent * xmlElementContentPtr
Definition: tree.h:305

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

1077  {
1078  return(xmlCopyDocElementContent(NULL, cur));
1079 }
FxCollectionEntry * cur
#define NULL
Definition: types.h:112
xmlElementContentPtr xmlCopyDocElementContent(xmlDocPtr doc, xmlElementContentPtr cur)
Definition: valid.c:995

◆ xmlCreateEnumeration()

xmlEnumerationPtr 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 }
static void xmlVErrMemory(xmlValidCtxtPtr ctxt, const char *extra)
Definition: valid.c:55
xmlEnumeration * xmlEnumerationPtr
Definition: tree.h:239
int ret
#define NULL
Definition: types.h:112
XMLPUBVAR xmlMallocFunc xmlMalloc
Definition: globals.h:248
Definition: name.c:38
#define memset(x, y, z)
Definition: compat.h:39
XMLPUBFUN xmlChar *XMLCALL xmlStrdup(const xmlChar *cur)
Definition: xmlstring.c:67

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

2985 {
2986  return (0);
2987 }

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

1914  {
1915  xmlDictPtr dict;
1916 
1917  if (attr == NULL) return;
1918  if (attr->doc != NULL)
1919  dict = attr->doc->dict;
1920  else
1921  dict = NULL;
1923  if (attr->tree != NULL)
1924  xmlFreeEnumeration(attr->tree);
1925  if (dict) {
1926  if ((attr->elem != NULL) && (!xmlDictOwns(dict, attr->elem)))
1927  xmlFree((xmlChar *) attr->elem);
1928  if ((attr->name != NULL) && (!xmlDictOwns(dict, attr->name)))
1929  xmlFree((xmlChar *) attr->name);
1930  if ((attr->prefix != NULL) && (!xmlDictOwns(dict, attr->prefix)))
1931  xmlFree((xmlChar *) attr->prefix);
1932  if ((attr->defaultValue != NULL) &&
1933  (!xmlDictOwns(dict, attr->defaultValue)))
1934  xmlFree((xmlChar *) attr->defaultValue);
1935  } else {
1936  if (attr->elem != NULL)
1937  xmlFree((xmlChar *) attr->elem);
1938  if (attr->name != NULL)
1939  xmlFree((xmlChar *) attr->name);
1940  if (attr->defaultValue != NULL)
1941  xmlFree((xmlChar *) attr->defaultValue);
1942  if (attr->prefix != NULL)
1943  xmlFree((xmlChar *) attr->prefix);
1944  }
1945  xmlFree(attr);
1946 }
void xmlFreeEnumeration(xmlEnumerationPtr cur)
Definition: valid.c:1817
Definition: dict.c:111
XMLPUBFUN void XMLCALL xmlUnlinkNode(xmlNodePtr cur)
XMLPUBVAR xmlFreeFunc xmlFree
Definition: globals.h:251
Definition: cookie.c:201
Definition: tree.h:489
unsigned char xmlChar
Definition: xmlstring.h:28
XMLPUBFUN int XMLCALL xmlDictOwns(xmlDictPtr dict, const xmlChar *str)
Definition: dict.c:1220
#define NULL
Definition: types.h:112
WCHAR * name
Definition: cookie.c:203

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

◆ xmlFreeAttributeTableEntry()

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

Definition at line 2182 of file valid.c.

2182  {
2184 }
Definition: cookie.c:201
static void xmlFreeAttribute(xmlAttributePtr attr)
Definition: valid.c:1914

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 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 }
Definition: dict.c:111
r parent
Definition: btrfs.c:3010
XMLPUBVAR xmlFreeFunc xmlFree
Definition: globals.h:251
GLint GLint GLsizei GLsizei GLsizei depth
Definition: gl.h:1546
unsigned char xmlChar
Definition: xmlstring.h:28
FxCollectionEntry * cur
XMLPUBFUN int XMLCALL xmlDictOwns(xmlDictPtr dict, const xmlChar *str)
Definition: dict.c:1220
#define NULL
Definition: types.h:112
struct _xmlDict * dict
Definition: tree.h:580

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

1389  {
1390  if (elem == NULL) return;
1392  xmlFreeDocElementContent(elem->doc, elem->content);
1393  if (elem->name != NULL)
1394  xmlFree((xmlChar *) elem->name);
1395  if (elem->prefix != NULL)
1396  xmlFree((xmlChar *) elem->prefix);
1397 #ifdef LIBXML_REGEXP_ENABLED
1398  if (elem->contModel != NULL)
1399  xmlRegFreeRegexp(elem->contModel);
1400 #endif
1401  xmlFree(elem);
1402 }
void xmlFreeDocElementContent(xmlDocPtr doc, xmlElementContentPtr cur)
Definition: valid.c:1089
static size_t elem
Definition: string.c:68
XMLPUBFUN void XMLCALL xmlUnlinkNode(xmlNodePtr cur)
XMLPUBVAR xmlFreeFunc xmlFree
Definition: globals.h:251
Definition: tree.h:489
unsigned char xmlChar
Definition: xmlstring.h:28
#define NULL
Definition: types.h:112

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

1155  {
1157 }
void xmlFreeDocElementContent(xmlDocPtr doc, xmlElementContentPtr cur)
Definition: valid.c:1089
FxCollectionEntry * cur
#define NULL
Definition: types.h:112

◆ xmlFreeElementTable()

void 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 }
XMLPUBFUN void XMLCALL xmlHashFree(xmlHashTablePtr table, xmlHashDeallocator f)
Definition: hash.c:322
static void xmlFreeElementTableEntry(void *elem, const xmlChar *name ATTRIBUTE_UNUSED)
Definition: valid.c:1630

◆ xmlFreeElementTableEntry()

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

Definition at line 1630 of file valid.c.

1630  {
1632 }
static void xmlFreeElement(xmlElementPtr elem)
Definition: valid.c:1389
static size_t elem
Definition: string.c:68

Referenced by xmlFreeElementTable().

◆ xmlFreeEnumeration()

void 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 }
void xmlFreeEnumeration(xmlEnumerationPtr cur)
Definition: valid.c:1817
XMLPUBVAR xmlFreeFunc xmlFree
Definition: globals.h:251
unsigned char xmlChar
Definition: xmlstring.h:28
FxCollectionEntry * cur
#define NULL
Definition: types.h:112

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

2644  {
2645  xmlDictPtr dict = NULL;
2646 
2647  if (id == NULL) return;
2648 
2649  if (id->doc != NULL)
2650  dict = id->doc->dict;
2651 
2652  if (id->value != NULL)
2653  DICT_FREE(id->value)
2654  if (id->name != NULL)
2655  DICT_FREE(id->name)
2656  xmlFree(id);
2657 }
if(dx==0 &&dy==0)
Definition: linetemp.h:174
struct _xmlDictEntry * dict
Definition: dict.c:114
Definition: dict.c:111
XMLPUBVAR xmlFreeFunc xmlFree
Definition: globals.h:251
#define DICT_FREE(str)
Definition: valid.c:2591
#define NULL
Definition: types.h:112
Definition: name.c:38
GLenum GLuint id
Definition: glext.h:5579

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

2756  {
2758 }
XMLPUBFUN void XMLCALL xmlHashFree(xmlHashTablePtr table, xmlHashDeallocator f)
Definition: hash.c:322
static void xmlFreeIDTableEntry(void *id, const xmlChar *name ATTRIBUTE_UNUSED)
Definition: valid.c:2745

Referenced by xsltReleaseRVT().

◆ xmlFreeIDTableEntry()

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

Definition at line 2745 of file valid.c.

2745  {
2746  xmlFreeID((xmlIDPtr) id);
2747 }
static void xmlFreeID(xmlIDPtr id)
Definition: valid.c:2644
Definition: tree.h:457

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

2369  {
2370  if (nota == NULL) return;
2371  if (nota->name != NULL)
2372  xmlFree((xmlChar *) nota->name);
2373  if (nota->PublicID != NULL)
2374  xmlFree((xmlChar *) nota->PublicID);
2375  if (nota->SystemID != NULL)
2376  xmlFree((xmlChar *) nota->SystemID);
2377  xmlFree(nota);
2378 }
const xmlChar * PublicID
Definition: tree.h:196
const xmlChar * SystemID
Definition: tree.h:197
XMLPUBVAR xmlFreeFunc xmlFree
Definition: globals.h:251
unsigned char xmlChar
Definition: xmlstring.h:28
#define NULL
Definition: types.h:112
const xmlChar * name
Definition: tree.h:195

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

2471  {
2473 }
XMLPUBFUN void XMLCALL xmlHashFree(xmlHashTablePtr table, xmlHashDeallocator f)
Definition: hash.c:322
static void xmlFreeNotationTableEntry(void *nota, const xmlChar *name ATTRIBUTE_UNUSED)
Definition: valid.c:2460

◆ xmlFreeNotationTableEntry()

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

Definition at line 2460 of file valid.c.

2460  {
2462 }
static void xmlFreeNotation(xmlNotationPtr nota)
Definition: valid.c:2369

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

2931  {
2933  if (ref == NULL) return;
2934  if (ref->value != NULL)
2935  xmlFree((xmlChar *)ref->value);
2936  if (ref->name != NULL)
2937  xmlFree((xmlChar *)ref->name);
2938  xmlFree(ref);
2939 }
xmlRef * xmlRefPtr
Definition: tree.h:473
Definition: send.c:48
Definition: tree.h:474
char name[1]
Definition: send.c:52
XMLPUBVAR xmlFreeFunc xmlFree
Definition: globals.h:251
unsigned char xmlChar
Definition: xmlstring.h:28
#define NULL
Definition: types.h:112
XMLPUBFUN void *XMLCALL xmlLinkGetData(xmlLinkPtr lk)
Definition: list.c:604

Referenced by xmlAddRef().

◆ xmlFreeRefTable()

void 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 }
XMLPUBFUN void XMLCALL xmlHashFree(xmlHashTablePtr table, xmlHashDeallocator f)
Definition: hash.c:322
static void xmlFreeRefTableEntry(void *payload, const xmlChar *name ATTRIBUTE_UNUSED)
Definition: valid.c:2948

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

2948  {
2949  xmlListPtr list_ref = (xmlListPtr) payload;
2950  if (list_ref == NULL) return;
2951  xmlListDelete(list_ref);
2952 }
xmlList * xmlListPtr
Definition: list.h:24
Definition: list.c:38
#define NULL
Definition: types.h:112
XMLPUBFUN void XMLCALL xmlListDelete(xmlListPtr l)
Definition: list.c:333

Referenced by xmlFreeRefTable(), and xmlRemoveRef().

◆ xmlGetDtdAttrDesc()

xmlAttributePtr 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 }
GLenum GLsizei GLenum GLenum const GLvoid * table
Definition: glext.h:5644
if(dx==0 &&dy==0)
Definition: linetemp.h:174
void * attributes
Definition: tree.h:420
static size_t elem
Definition: string.c:68
xmlAttributeTable * xmlAttributeTablePtr
Definition: valid.h:134
XMLPUBFUN void *XMLCALL xmlHashLookup3(xmlHashTablePtr table, const xmlChar *name, const xmlChar *name2, const xmlChar *name3)
Definition: hash.c:769
XMLPUBVAR xmlFreeFunc xmlFree
Definition: globals.h:251
unsigned char xmlChar
Definition: xmlstring.h:28
FxCollectionEntry * cur
#define NULL
Definition: types.h:112
Definition: name.c:38
XMLPUBFUN xmlChar *XMLCALL xmlSplitQName2(const xmlChar *name, xmlChar **prefix)

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

◆ xmlGetDtdElementDesc()

xmlElementPtr 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 }
GLenum GLsizei GLenum GLenum const GLvoid * table
Definition: glext.h:5644
xmlElementTable * xmlElementTablePtr
Definition: valid.h:126
XMLPUBFUN void *XMLCALL xmlHashLookup2(xmlHashTablePtr table, const xmlChar *name, const xmlChar *name2)
Definition: hash.c:476
void * elements
Definition: tree.h:419
XMLPUBVAR xmlFreeFunc xmlFree
Definition: globals.h:251
unsigned char xmlChar
Definition: xmlstring.h:28
FxCollectionEntry * cur
#define NULL
Definition: types.h:112
Definition: name.c:38
XMLPUBFUN xmlChar *XMLCALL xmlSplitQName2(const xmlChar *name, xmlChar **prefix)

Referenced by xmlIsMixedElement().

◆ xmlGetDtdElementDesc2()

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

Definition at line 3287 of file valid.c.

3287  {
3290  xmlChar *uqname = NULL, *prefix = NULL;
3291 
3292  if (dtd == NULL) return(NULL);
3293  if (dtd->elements == NULL) {
3294  xmlDictPtr dict = NULL;
3295 
3296  if (dtd->doc != NULL)
3297  dict = dtd->doc->dict;
3298 
3299  if (!create)
3300  return(NULL);
3301  /*
3302  * Create the Element table if needed.
3303  */
3305  if (table == NULL) {
3306  table = xmlHashCreateDict(0, dict);
3307  dtd->elements = (void *) table;
3308  }
3309  if (table == NULL) {
3310  xmlVErrMemory(NULL, "element table allocation failed");
3311  return(NULL);
3312  }
3313  }
3315 
3316  uqname = xmlSplitQName2(name, &prefix);
3317  if (uqname != NULL)
3318  name = uqname;
3319  cur = xmlHashLookup2(table, name, prefix);
3320  if ((cur == NULL) && (create)) {
3321  cur = (xmlElementPtr) xmlMalloc(sizeof(xmlElement));
3322  if (cur == NULL) {
3323  xmlVErrMemory(NULL, "malloc failed");
3324  return(NULL);
3325  }
3326  memset(cur, 0, sizeof(xmlElement));
3327  cur->type = XML_ELEMENT_DECL;
3328 
3329  /*
3330  * fill the structure.
3331  */
3332  cur->name = xmlStrdup(name);
3333  cur->prefix = xmlStrdup(prefix);
3335 
3336  xmlHashAddEntry2(table, name, prefix, cur);
3337  }
3338  if (prefix != NULL) xmlFree(prefix);
3339  if (uqname != NULL) xmlFree(uqname);
3340  return(cur);
3341 }
struct _xmlDoc * doc
Definition: tree.h:415
XMLPUBFUN int XMLCALL xmlHashAddEntry2(xmlHashTablePtr table, const xmlChar *name, const xmlChar *name2, void *userdata)
Definition: hash.c:406
GLenum GLsizei GLenum GLenum const GLvoid * table
Definition: glext.h:5644
static void xmlVErrMemory(xmlValidCtxtPtr ctxt, const char *extra)
Definition: valid.c:55
xmlElementTable * xmlElementTablePtr
Definition: valid.h:126
if(dx==0 &&dy==0)
Definition: linetemp.h:174
XMLPUBFUN void *XMLCALL xmlHashLookup2(xmlHashTablePtr table, const xmlChar *name, const xmlChar *name2)
Definition: hash.c:476
Definition: dict.c:111
xmlElement * xmlElementPtr
Definition: tree.h:345
void * elements
Definition: tree.h:419
XMLPUBVAR xmlFreeFunc xmlFree
Definition: globals.h:251
unsigned char xmlChar
Definition: xmlstring.h:28
FxCollectionEntry * cur
XMLPUBFUN xmlHashTablePtr XMLCALL xmlHashCreateDict(int size, xmlDictPtr dict)
Definition: hash.c:210
#define NULL
Definition: types.h:112
XMLPUBVAR xmlMallocFunc xmlMalloc
Definition: globals.h:248
Definition: name.c:38
#define memset(x, y, z)
Definition: compat.h:39
static const struct access_res create[16]
Definition: package.c:7644
XMLPUBFUN xmlChar *XMLCALL xmlStrdup(const xmlChar *cur)
Definition: xmlstring.c:67
XMLPUBFUN xmlChar *XMLCALL xmlSplitQName2(const xmlChar *name, xmlChar **prefix)

Referenced by xmlAddAttributeDecl().

◆ xmlGetDtdNotationDesc()

xmlNotationPtr 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 }
void * notations
Definition: tree.h:418
GLenum GLsizei GLenum GLenum const GLvoid * table
Definition: glext.h:5644
xmlNotationTable * xmlNotationTablePtr
Definition: valid.h:118
#define NULL
Definition: types.h:112
Definition: name.c:38
XMLPUBFUN void *XMLCALL xmlHashLookup(xmlHashTablePtr table, const xmlChar *name)
Definition: hash.c:461

◆ xmlGetDtdQAttrDesc()

xmlAttributePtr 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 }
GLenum GLsizei GLenum GLenum const GLvoid * table
Definition: glext.h:5644
void * attributes
Definition: tree.h:420
static size_t elem
Definition: string.c:68
xmlAttributeTable * xmlAttributeTablePtr
Definition: valid.h:134
XMLPUBFUN void *XMLCALL xmlHashLookup3(xmlHashTablePtr table, const xmlChar *name, const xmlChar *name2, const xmlChar *name3)
Definition: hash.c:769
#define NULL
Definition: types.h:112
Definition: name.c:38

◆ xmlGetDtdQElementDesc()

xmlElementPtr 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 }
GLenum GLsizei GLenum GLenum const GLvoid * table
Definition: glext.h:5644
xmlElementTable * xmlElementTablePtr
Definition: valid.h:126
XMLPUBFUN void *XMLCALL xmlHashLookup2(xmlHashTablePtr table, const xmlChar *name, const xmlChar *name2)
Definition: hash.c:476
void * elements
Definition: tree.h:419
#define NULL
Definition: types.h:112
Definition: name.c:38

◆ 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 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 }
GLenum GLsizei GLenum GLenum const GLvoid * table
Definition: glext.h:5644
if(dx==0 &&dy==0)
Definition: linetemp.h:174
void * ids
Definition: tree.h:575
#define ID
Definition: ruserpass.c:36
xmlIDTable * xmlIDTablePtr
Definition: valid.h:142
#define NULL
Definition: types.h:112
Definition: tree.h:434
GLenum GLuint id
Definition: glext.h:5579
XMLPUBFUN void *XMLCALL xmlHashLookup(xmlHashTablePtr table, const xmlChar *name)
Definition: hash.c:461
Definition: tree.h:457

Referenced by xsltLoadStylesheetPI(), and xsltTestStepMatch().

◆ xmlGetRefs()

xmlListPtr xmlGetRefs ( xmlDocPtr  doc,
const xmlChar ID 
)

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 }
GLenum GLsizei GLenum GLenum const GLvoid * table
Definition: glext.h:5644
if(dx==0 &&dy==0)
Definition: linetemp.h:174
void * refs
Definition: tree.h:576
#define ID
Definition: ruserpass.c:36
#define NULL
Definition: types.h:112
xmlRefTable * xmlRefTablePtr
Definition: valid.h:150
XMLPUBFUN void *XMLCALL xmlHashLookup(xmlHashTablePtr table, const xmlChar *name)
Definition: hash.c:461

◆ 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 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 }
xmlElementType type
Definition: tree.h:553
XMLPUBFUN xmlChar *XMLCALL xmlBuildQName(const xmlChar *ncname, const xmlChar *prefix, xmlChar *memory, int len)
struct _xmlDtd * intSubset
Definition: tree.h:570
Definition: fatfs.h:133
static size_t elem
Definition: string.c:68
xmlAttributeType atype
Definition: tree.h:265
#define BAD_CAST
Definition: xmlstring.h:35
xmlAttributePtr xmlGetDtdAttrDesc(xmlDtdPtr dtd, const xmlChar *elem, const xmlChar *name)
Definition: valid.c:3379
XMLPUBVAR xmlFreeFunc xmlFree
Definition: globals.h:251
Definition: cookie.c:201
unsigned char xmlChar
Definition: xmlstring.h:28
#define NULL
Definition: types.h:112
struct _xmlDtd * extSubset
Definition: tree.h:571
Definition: name.c:38
WCHAR * name
Definition: cookie.c:203
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
XMLPUBFUN int XMLCALL xmlStrEqual(const xmlChar *str1, const xmlChar *str2)
Definition: xmlstring.c:160

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 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  */
3513  case XML_ELEMENT_TYPE_ANY:
3515  return(1);
3516  }
3517  return(1);
3518 }
struct _xmlDtd * intSubset
Definition: tree.h:570
xmlElementTypeVal etype
Definition: tree.h:357
xmlElementPtr xmlGetDtdElementDesc(xmlDtdPtr dtd, const xmlChar *name)
Definition: valid.c:3257
#define NULL
Definition: types.h:112
struct _xmlDtd * extSubset
Definition: tree.h:571
Definition: name.c:38

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

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 }
xmlElementType type
Definition: tree.h:553
struct _xmlDtd * intSubset
Definition: tree.h:570
static size_t elem
Definition: string.c:68
xmlAttributeType atype
Definition: tree.h:265
xmlAttributePtr xmlGetDtdAttrDesc(xmlDtdPtr dtd, const xmlChar *elem, const xmlChar *name)
Definition: valid.c:3379
Definition: cookie.c:201
#define NULL
Definition: types.h:112
struct _xmlDtd * extSubset
Definition: tree.h:571
WCHAR * name
Definition: cookie.c:203

Referenced by xmlSAX2AttributeNs().

◆ xmlIsStreaming()

static int xmlIsStreaming ( xmlValidCtxtPtr  ctxt)
static

Definition at line 2626 of file valid.c.

2626  {
2627  xmlParserCtxtPtr pctxt;
2628 
2629  if (ctxt == NULL)
2630  return(0);
2631  if ((ctxt->flags & XML_VCTXT_USE_PCTXT) == 0)
2632  return(0);
2633  pctxt = ctxt->userData;
2634  return(pctxt->parseMode == XML_PARSE_READER);
2635 }
xmlParserMode parseMode
Definition: parser.h:302
#define NULL
Definition: types.h:112
void * userData
Definition: valid.h:83
unsigned int flags
Definition: valid.h:93

Referenced by xmlAddID(), and xmlAddRef().

◆ xmlNewDocElementContent()

xmlElementContentPtr 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 }
XMLPUBFUN const xmlChar *XMLCALL xmlSplitQName3(const xmlChar *name, int *len)
XMLPUBFUN xmlChar *XMLCALL xmlStrndup(const xmlChar *cur, int len)
Definition: xmlstring.c:42
static void xmlVErrMemory(xmlValidCtxtPtr ctxt, const char *extra)
Definition: valid.c:55
Definition: dict.c:111
r l[0]
Definition: byte_order.h:167
XMLPUBFUN const xmlChar *XMLCALL xmlDictLookup(xmlDictPtr dict, const xmlChar *name, int len)
Definition: dict.c:867
int ret
unsigned char xmlChar
Definition: xmlstring.h:28
#define NULL
Definition: types.h:112
XMLPUBVAR xmlMallocFunc xmlMalloc
Definition: globals.h:248
Definition: name.c:38
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
#define memset(x, y, z)
Definition: compat.h:39
struct _xmlDict * dict
Definition: tree.h:580
XMLPUBFUN xmlChar *XMLCALL xmlStrdup(const xmlChar *cur)
Definition: xmlstring.c:67
xmlElementContent * xmlElementContentPtr
Definition: tree.h:305

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

◆ xmlNewElementContent()

xmlElementContentPtr 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
#define NULL
Definition: types.h:112
Definition: name.c:38
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545

◆ 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 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
GLenum GLsizei GLenum GLenum const GLvoid * table
Definition: glext.h:5644
if(dx==0 &&dy==0)
Definition: linetemp.h:174
void * ids
Definition: tree.h:575
static void xmlValidNormalizeString(xmlChar *str)
Definition: valid.c:2603
static void xmlFreeIDTableEntry(void *id, const xmlChar *name ATTRIBUTE_UNUSED)
Definition: valid.c:2745
XMLPUBVAR xmlFreeFunc xmlFree
Definition: globals.h:251
Definition: cookie.c:201
XMLPUBFUN xmlChar *XMLCALL xmlNodeListGetString(xmlDocPtr doc, const xmlNode *list, int inLine)
unsigned char xmlChar
Definition: xmlstring.h:28
#define ID
Definition: ruserpass.c:36
xmlIDTable * xmlIDTablePtr
Definition: valid.h:142
#define NULL
Definition: types.h:112
GLenum GLuint id
Definition: glext.h:5579
XMLPUBFUN void *XMLCALL xmlHashLookup(xmlHashTablePtr table, const xmlChar *name)
Definition: hash.c:461
Definition: tree.h:457

◆ xmlRemoveRef()

int 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 GLsizei GLenum GLenum const GLvoid * table
Definition: glext.h:5644
XMLPUBFUN int XMLCALL xmlListEmpty(xmlListPtr l)
Definition: list.c:446
if(dx==0 &&dy==0)
Definition: linetemp.h:174
void * refs
Definition: tree.h:576
XMLPUBFUN void XMLCALL xmlListWalk(xmlListPtr l, xmlListWalker walker, void *user)
Definition: list.c:676
XMLPUBVAR xmlFreeFunc xmlFree
Definition: globals.h:251
Definition: cookie.c:201
XMLPUBFUN xmlChar *XMLCALL xmlNodeListGetString(xmlDocPtr doc, const xmlNode *list, int inLine)
__u8 attr
Definition: mkdosfs.c:359
unsigned char xmlChar
Definition: xmlstring.h:28
#define ID
Definition: ruserpass.c:36
XMLPUBFUN int XMLCALL xmlHashUpdateEntry(xmlHashTablePtr table, const xmlChar *name, void *userdata, xmlHashDeallocator f)
Definition: hash.c:425
Definition: list.c:38
#define NULL
Definition: types.h:112
xmlRefTable * xmlRefTablePtr
Definition: valid.h:150
GLenum target
Definition: glext.h:7315
XMLPUBFUN void *XMLCALL xmlHashLookup(xmlHashTablePtr table, const xmlChar *name)
Definition: hash.c:461
static void xmlFreeRefTableEntry(void *payload, const xmlChar *name ATTRIBUTE_UNUSED)
Definition: valid.c:2948
static int xmlWalkRemoveRef(const void *data, void *user)
Definition: valid.c:2962

◆ 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 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 }
void xmlSnprintfElementContent(char *buf, int size, xmlElementContentPtr content, int englob)
Definition: valid.c:1285
char * strcat(char *DstString, const char *SrcString)
Definition: utclib.c:568
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
XMLPUBFUN int XMLCALL xmlStrlen(const xmlChar *str)
Definition: xmlstring.c:426
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
content
Definition: atl_ax.c:993
GLsizeiptr size
Definition: glext.h:5919
GLenum GLsizei len
Definition: glext.h:6722
#define NULL
Definition: types.h:112

◆ xmlValidNormalizeString()

static void xmlValidNormalizeString ( xmlChar str)
static

xmlValidNormalizeString: @str: a string

Normalize a string in-place.

Definition at line 2603 of file valid.c.

2603  {
2604  xmlChar *dst;
2605  const xmlChar *src;
2606 
2607  if (str == NULL)
2608  return;
2609  src = str;
2610  dst = str;
2611 
2612  while (*src == 0x20) src++;
2613  while (*src != 0) {
2614  if (*src == 0x20) {
2615  while (*src == 0x20) src++;
2616  if (*src != 0)
2617  *dst++ = 0x20;
2618  } else {
2619  *dst++ = *src++;
2620  }
2621  }
2622  *dst = 0;
2623 }
const WCHAR * str
unsigned char xmlChar
Definition: xmlstring.h:28
GLenum src
Definition: glext.h:6340
GLenum GLenum dst
Definition: glext.h:6340
#define NULL
Definition: types.h:112

Referenced by xmlRemoveID().

◆ xmlVErrMemory()

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

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

Handle an out of memory error

Definition at line 55 of file valid.c.

56 {
57  xmlGenericErrorFunc channel = NULL;
58  xmlParserCtxtPtr pctxt = NULL;
59  void *data = NULL;
60 
61  if (ctxt != NULL) {
62  channel = ctxt->error;
63  data = ctxt->userData;
64  /* Look up flag to detect if it is part of a parsing
65  context */
66  if (ctxt->flags & XML_VCTXT_USE_PCTXT) {
67  long delta = (char *) ctxt - (char *) ctxt->userData;
68  if ((delta > 0) && (delta < 250))
69  pctxt = ctxt->userData;
70  }
71  }
72  if (extra)
73  __xmlRaiseError(NULL, channel, data,
75  XML_ERR_FATAL, NULL, 0, extra, NULL, NULL, 0, 0,
76  "Memory allocation failed : %s\n", extra);
77  else
78  __xmlRaiseError(NULL, channel, data,
80  XML_ERR_FATAL, NULL, 0, NULL, NULL, NULL, 0, 0,
81  "Memory allocation failed\n");
82 }
xmlValidityErrorFunc error
Definition: valid.h:84
Definition: id3.c:95
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
#define NULL
Definition: types.h:112
void(XMLCDECL * xmlGenericErrorFunc)(void *ctx, const char *msg,...) LIBXML_ATTR_FORMAT(2
Definition: xmlerror.h:847
void * userData
Definition: valid.h:83
unsigned int flags
Definition: valid.h:93

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

2963 {
2964  xmlAttrPtr attr0 = ((xmlRefPtr)data)->attr;
2965  xmlAttrPtr attr1 = ((xmlRemoveMemoPtr)user)->ap;
2966  xmlListPtr ref_list = ((xmlRemoveMemoPtr)user)->l;
2967 
2968  if (attr0 == attr1) { /* Matched: remove and terminate walk */
2969  xmlListRemoveFirst(ref_list, (void *)data);
2970  return 0;
2971  }
2972  return 1;
2973 }
XMLPUBFUN int XMLCALL xmlListRemoveFirst(xmlListPtr l, void *data)
Definition: list.c:353
xmlRef * xmlRefPtr
Definition: tree.h:473
xmlRemoveMemo * xmlRemoveMemoPtr
Definition: valid.c:2914
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
Definition: list.c:38
Definition: tree.h:434
void user(int argc, const char *argv[])
Definition: cmds.c:1350

Referenced by xmlRemoveRef().