| blob | 2cb32f32c841f98e7ce425a308a3d18d4cafa959 |
1 /*
2 * valid.c : part of the code use to do the DTD handling and the validity
3 * checking
4 *
5 * See Copyright for the status of this software.
6 *
7 * daniel@veillard.com
8 */
10 #define IN_LIBXML
13 #include <string.h>
15 #ifdef HAVE_STDLIB_H
16 #include <stdlib.h>
17 #endif
19 #include <libxml/xmlmemory.h>
20 #include <libxml/hash.h>
21 #include <libxml/uri.h>
22 #include <libxml/valid.h>
23 #include <libxml/parser.h>
24 #include <libxml/parserInternals.h>
25 #include <libxml/xmlerror.h>
26 #include <libxml/list.h>
27 #include <libxml/globals.h>
31 /* #define DEBUG_VALID_ALGO */
32 /* #define DEBUG_REGEXP_ALGO */
34 #define TODO \
35 xmlGenericError(xmlGenericErrorContext, \
37 __FILE__, __LINE__);
39 #ifdef LIBXML_VALID_ENABLED
40 static int
43 #endif
44 /************************************************************************
45 * *
46 * Error handling routines *
47 * *
48 ************************************************************************/
50 /**
51 * xmlVErrMemory:
52 * @ctxt: an XML validation parser context
53 * @extra: extra informations
54 *
55 * Handle an out of memory error
56 */
57 static void
59 {
67 /* Use the special values to detect if it is part of a parsing
68 context */
74 }
75 }
81 else
86 }
88 /**
89 * xmlErrValid:
90 * @ctxt: an XML validation parser context
91 * @error: the error number
92 * @extra: extra informations
93 *
94 * Handle a validation error
95 */
96 static void
99 {
107 /* Use the special values to detect if it is part of a parsing
108 context */
114 }
115 }
121 else
126 }
128 #if defined(LIBXML_VALID_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
129 /**
130 * xmlErrValidNode:
131 * @ctxt: an XML validation parser context
132 * @node: the node raising the error
133 * @error: the error number
134 * @str1: extra informations
135 * @str2: extra informations
136 * @str3: extra informations
137 *
138 * Handle a validation error, provide contextual informations
139 */
140 static void
145 {
154 /* Use the special values to detect if it is part of a parsing
155 context */
161 }
162 }
168 }
171 #ifdef LIBXML_VALID_ENABLED
172 /**
173 * xmlErrValidNodeNr:
174 * @ctxt: an XML validation parser context
175 * @node: the node raising the error
176 * @error: the error number
177 * @str1: extra informations
178 * @int2: extra informations
179 * @str3: extra informations
180 *
181 * Handle a validation error, provide contextual informations
182 */
183 static void
188 {
197 /* Use the special values to detect if it is part of a parsing
198 context */
204 }
205 }
211 }
213 /**
214 * xmlErrValidWarning:
215 * @ctxt: an XML validation parser context
216 * @node: the node raising the error
217 * @error: the error number
218 * @str1: extra information
219 * @str2: extra information
220 * @str3: extra information
221 *
222 * Handle a validation error, provide contextual information
223 */
224 static void
229 {
238 /* Use the special values to detect if it is part of a parsing
239 context */
245 }
246 }
252 }
256 #ifdef LIBXML_REGEXP_ENABLED
257 /*
258 * If regexp are enabled we can do continuous validation without the
259 * need of a tree to validate the content model. this is done in each
260 * callbacks.
261 * Each xmlValidState represent the validation state associated to the
262 * set of nodes currently open from the document root to the current element.
263 */
273 static int
282 }
283 }
293 }
296 }
309 XML_ERR_INTERNAL_ERROR,
312 }
313 }
315 }
317 static int
319 xmlElementPtr elemDecl;
328 }
332 else
335 }
338 /*
339 * If regexp are not enabled, it uses a home made algorithm less
340 * complex and easier to
341 * debug/maintain than a generic NFA -> DFA state based algo. The
342 * only restriction is on the deepness of the tree limited by the
343 * size of the occurs bitfield
344 *
345 * this is the content of a saved state for rollbacks
346 */
348 #define ROLLBACK_OR 0
349 #define ROLLBACK_PARENT 1
359 #define MAX_RECURSE 25000
360 #define MAX_DEPTH ((sizeof(_xmlValidState.occurs)) * 8)
361 #define CONT ctxt->vstate->cont
362 #define NODE ctxt->vstate->node
363 #define DEPTH ctxt->vstate->depth
364 #define OCCURS ctxt->vstate->occurs
365 #define STATE ctxt->vstate->state
367 #define OCCURRENCE (ctxt->vstate->occurs & (1 << DEPTH))
368 #define PARENT_OCCURRENCE (ctxt->vstate->occurs & ((1 << DEPTH) - 1))
370 #define SET_OCCURRENCE ctxt->vstate->occurs |= (1 << DEPTH)
371 #define RESET_OCCURRENCE ctxt->vstate->occurs &= ((1 << DEPTH) - 1)
373 static int
381 }
389 }
390 }
399 }
403 }
404 /*
405 * Don't push on the stack a state already here
406 */
419 }
421 static int
432 }
436 static int
438 {
448 }
449 }
457 }
460 }
464 }
465 static xmlNodePtr
467 {
468 xmlNodePtr ret;
475 else
480 }
482 #ifdef DEBUG_VALID_ALGO
483 static void
488 }
529 #ifdef LIBXML_DOCB_ENABLED
533 #endif
555 }
556 }
558 static void
565 }
566 }
568 static void
578 }
580 static void
585 else
600 }
604 }
606 static void
617 }
619 /*****
620 #define DEBUG_VALID_STATE(n,c) xmlValidDebug(n,c);
621 *****/
623 #define DEBUG_VALID_STATE(n,c) xmlValidStateDebug(ctxt);
624 #define DEBUG_VALID_MSG(m) \
627 #else
628 #define DEBUG_VALID_STATE(n,c)
629 #define DEBUG_VALID_MSG(m)
630 #endif
632 /* TODO: use hash table for accesses to elem and attribute definitions */
635 #define CHECK_DTD \
636 if (doc == NULL) return(0); \
637 else if ((doc->intSubset == NULL) && \
638 (doc->extSubset == NULL)) return(0)
640 #ifdef LIBXML_REGEXP_ENABLED
642 /************************************************************************
643 * *
644 * Content model validation based on the regexps *
645 * *
646 ************************************************************************/
648 /**
649 * xmlValidBuildAContentModel:
650 * @content: the content model
651 * @ctxt: the schema parser context
652 * @name: the element name whose content is being built
653 *
654 * Generate the automata sequence needed for that type
655 *
656 * Returns 1 if successful or 0 in case of error.
657 */
658 static int
660 xmlValidCtxtPtr ctxt,
667 }
684 }
708 }
712 }
715 xmlElementContentOccur ocur;
717 /*
718 * Simply iterate over the content
719 */
725 }
747 }
749 }
752 xmlElementContentOccur ocur;
759 }
763 /*
764 * iterate over the subtypes and remerge the end with an
765 * epsilon transition
766 */
791 }
793 }
799 }
801 }
802 /**
803 * xmlValidBuildContentModel:
804 * @ctxt: a validation context
805 * @elem: an element declaration node
806 *
807 * (Re)Build the automata associated to the content model of this
808 * element
809 *
810 * Returns 1 in case of success, 0 in case of error
811 */
812 int
821 /* TODO: should we rebuild in this case ? */
826 }
828 }
833 XML_ERR_INTERNAL_ERROR,
837 }
847 XML_DTD_CONTENT_NOT_DETERMINIST,
850 #ifdef DEBUG_REGEXP_ALGO
852 #endif
858 }
863 }
867 /****************************************************************
868 * *
869 * Util functions for data allocation/deallocation *
870 * *
871 ****************************************************************/
873 /**
874 * xmlNewValidCtxt:
875 *
876 * Allocate a validation context structure.
877 *
878 * Returns NULL if not, otherwise the new validation context structure
879 */
881 xmlValidCtxtPtr ret;
886 }
891 }
893 /**
894 * xmlFreeValidCtxt:
895 * @cur: the validation context to free
896 *
897 * Free a validation context structure.
898 */
899 void
906 }
910 /**
911 * xmlNewDocElementContent:
912 * @doc: the document
913 * @name: the subelement name or NULL
914 * @type: the type of element content decl
915 *
916 * Allocate an element content structure for the document.
917 *
918 * Returns NULL if not, otherwise the new element content structure
919 */
920 xmlElementContentPtr
922 xmlElementContentType type) {
923 xmlElementContentPtr ret;
934 NULL);
935 }
943 NULL);
944 }
949 NULL);
951 }
956 }
968 else
977 }
978 }
979 }
981 }
983 /**
984 * xmlNewElementContent:
985 * @name: the subelement name or NULL
986 * @type: the type of element content decl
987 *
988 * Allocate an element content structure.
989 * Deprecated in favor of xmlNewDocElementContent
990 *
991 * Returns NULL if not, otherwise the new element content structure
992 */
993 xmlElementContentPtr
996 }
998 /**
999 * xmlCopyDocElementContent:
1000 * @doc: the document owning the element declaration
1001 * @cur: An element content pointer.
1002 *
1003 * Build a copy of an element content description.
1004 *
1005 * Returns the new xmlElementContentPtr or NULL in case of error.
1006 */
1007 xmlElementContentPtr
1021 }
1028 else
1030 }
1035 else
1037 }
1050 }
1058 else
1060 }
1065 else
1067 }
1074 }
1075 }
1077 }
1079 /**
1080 * xmlCopyElementContent:
1081 * @cur: An element content pointer.
1082 *
1083 * Build a copy of an element content description.
1084 * Deprecated, use xmlCopyDocElementContent instead
1085 *
1086 * Returns the new xmlElementContentPtr or NULL in case of error.
1087 */
1088 xmlElementContentPtr
1091 }
1093 /**
1094 * xmlFreeDocElementContent:
1095 * @doc: the document owning the element declaration
1096 * @cur: the element content tree to free
1097 *
1098 * Free an element content structure. The whole subtree is removed.
1099 */
1100 void
1102 xmlElementContentPtr next;
1119 NULL);
1121 }
1131 }
1134 }
1135 }
1137 /**
1138 * xmlFreeElementContent:
1139 * @cur: the element content tree to free
1140 *
1141 * Free an element content structure. The whole subtree is removed.
1142 * Deprecated, use xmlFreeDocElementContent instead
1143 */
1144 void
1147 }
1149 #ifdef LIBXML_OUTPUT_ENABLED
1150 /**
1151 * xmlDumpElementContent:
1152 * @buf: An XML buffer
1153 * @content: An element table
1154 * @glob: 1 if one must print the englobing parenthesis, 0 otherwise
1155 *
1156 * This will dump the content of the element table as an XML DTD definition
1157 */
1158 static void
1171 }
1178 else
1185 else
1192 else
1199 else
1205 NULL);
1206 }
1221 }
1222 }
1224 /**
1225 * xmlSprintfElementContent:
1226 * @buf: an output buffer
1227 * @content: An element table
1228 * @englob: 1 if one must print the englobing parenthesis, 0 otherwise
1229 *
1230 * Deprecated, unsafe, use xmlSnprintfElementContent
1231 */
1232 void
1234 xmlElementContentPtr content ATTRIBUTE_UNUSED,
1236 }
1239 /**
1240 * xmlSnprintfElementContent:
1241 * @buf: an output buffer
1242 * @size: the buffer size
1243 * @content: An element table
1244 * @englob: 1 if one must print the englobing parenthesis, 0 otherwise
1245 *
1246 * This will dump the content of the element content definition
1247 * Intended just for the debug routine
1248 */
1249 void
1259 }
1270 }
1273 }
1277 }
1285 else
1292 }
1298 else
1305 else
1312 }
1318 else
1321 }
1336 }
1337 }
1339 /****************************************************************
1340 * *
1341 * Registration of DTD declarations *
1342 * *
1343 ****************************************************************/
1345 /**
1346 * xmlFreeElement:
1347 * @elem: An element
1348 *
1349 * Deallocate the memory used by an element definition
1350 */
1351 static void
1360 #ifdef LIBXML_REGEXP_ENABLED
1363 #endif
1365 }
1368 /**
1369 * xmlAddElementDecl:
1370 * @ctxt: the validation context
1371 * @dtd: pointer to the DTD
1372 * @name: the entity name
1373 * @type: the element type
1374 * @content: the element content tree or NULL
1375 *
1376 * Register a new element declaration
1377 *
1378 * Returns NULL if not, otherwise the entity
1379 */
1380 xmlElementPtr
1383 xmlElementTypeVal type,
1384 xmlElementContentPtr content) {
1385 xmlElementPtr ret;
1386 xmlElementTablePtr table;
1392 }
1395 }
1402 NULL);
1404 }
1410 NULL);
1412 }
1418 NULL);
1420 }
1426 NULL);
1428 }
1433 NULL);
1435 }
1437 /*
1438 * check if name is a QName
1439 */
1444 /*
1445 * Create the Element table if needed.
1446 */
1455 }
1464 }
1466 /*
1467 * lookup old attributes inserted on an undefined element in the
1468 * internal subset.
1469 */
1477 }
1478 }
1480 /*
1481 * The element may already be present if one of its attribute
1482 * was registered first
1483 */
1487 #ifdef LIBXML_VALID_ENABLED
1488 /*
1489 * The element is already defined in this DTD.
1490 */
1500 }
1504 }
1514 }
1518 /*
1519 * fill the structure.
1520 */
1530 }
1533 /*
1534 * Validity Check:
1535 * Insertion must not fail
1536 */
1538 #ifdef LIBXML_VALID_ENABLED
1539 /*
1540 * The element is already defined in this DTD.
1541 */
1550 }
1551 /*
1552 * For new element, may have attributes from earlier
1553 * definition in internal subset
1554 */
1556 }
1558 /*
1559 * Finish to fill the structure.
1560 */
1562 /*
1563 * Avoid a stupid copy when called by the parser
1564 * and flag it by setting a special parent value
1565 * so the parser doesn't unallocate it.
1566 */
1575 }
1577 /*
1578 * Link it to the DTD
1579 */
1588 }
1592 }
1594 /**
1595 * xmlFreeElementTable:
1596 * @table: An element table
1597 *
1598 * Deallocate the memory used by an element hash table.
1599 */
1600 void
1603 }
1605 #ifdef LIBXML_TREE_ENABLED
1606 /**
1607 * xmlCopyElement:
1608 * @elem: An element
1609 *
1610 * Build a copy of an element.
1611 *
1612 * Returns the new xmlElementPtr or NULL in case of error.
1613 */
1614 static xmlElementPtr
1616 xmlElementPtr cur;
1622 }
1628 else
1632 else
1635 /* TODO : rebuild the attribute list on the copy */
1638 }
1640 /**
1641 * xmlCopyElementTable:
1642 * @table: An element table
1643 *
1644 * Build a copy of an element table.
1645 *
1646 * Returns the new xmlElementTablePtr or NULL in case of error.
1647 */
1648 xmlElementTablePtr
1652 }
1655 #ifdef LIBXML_OUTPUT_ENABLED
1656 /**
1657 * xmlDumpElementDecl:
1658 * @buf: the XML buffer output
1659 * @elem: An element table
1660 *
1661 * This will dump the content of the element declaration as an XML
1662 * DTD definition
1663 */
1664 void
1674 }
1683 }
1692 }
1703 }
1712 NULL);
1713 }
1714 }
1716 /**
1717 * xmlDumpElementDeclScan:
1718 * @elem: An element table
1719 * @buf: the XML buffer output
1720 *
1721 * This routine is used by the hash scan function. It just reverses
1722 * the arguments.
1723 */
1724 static void
1727 }
1729 /**
1730 * xmlDumpElementTable:
1731 * @buf: the XML buffer output
1732 * @table: An element table
1733 *
1734 * This will dump the content of the element table as an XML DTD definition
1735 */
1736 void
1741 }
1744 /**
1745 * xmlCreateEnumeration:
1746 * @name: the enumeration name or NULL
1747 *
1748 * create and initialize an enumeration attribute node.
1749 *
1750 * Returns the xmlEnumerationPtr just created or NULL in case
1751 * of error.
1752 */
1753 xmlEnumerationPtr
1755 xmlEnumerationPtr ret;
1761 }
1767 }
1769 /**
1770 * xmlFreeEnumeration:
1771 * @cur: the tree to free.
1772 *
1773 * free an enumeration attribute node (recursive).
1774 */
1775 void
1783 }
1785 #ifdef LIBXML_TREE_ENABLED
1786 /**
1787 * xmlCopyEnumeration:
1788 * @cur: the tree to copy.
1789 *
1790 * Copy an enumeration attribute node (recursive).
1791 *
1792 * Returns the xmlEnumerationPtr just created or NULL in case
1793 * of error.
1794 */
1795 xmlEnumerationPtr
1797 xmlEnumerationPtr ret;
1806 }
1809 #ifdef LIBXML_OUTPUT_ENABLED
1810 /**
1811 * xmlDumpEnumeration:
1812 * @buf: the XML buffer output
1813 * @enum: An enumeration
1814 *
1815 * This will dump the content of the enumeration
1816 */
1817 static void
1828 }
1829 }
1832 #ifdef LIBXML_VALID_ENABLED
1833 /**
1834 * xmlScanIDAttributeDecl:
1835 * @ctxt: the validation context
1836 * @elem: the element name
1837 * @err: whether to raise errors here
1838 *
1839 * Verify that the element don't have too many ID attributes
1840 * declared.
1841 *
1842 * Returns the number of ID attributes found.
1843 */
1844 static int
1846 xmlAttributePtr cur;
1853 ret ++;
1858 }
1860 }
1862 }
1865 /**
1866 * xmlFreeAttribute:
1867 * @elem: An attribute
1868 *
1869 * Deallocate the memory used by an attribute definition
1870 */
1871 static void
1873 xmlDictPtr dict;
1878 else
1902 }
1904 }
1907 /**
1908 * xmlAddAttributeDecl:
1909 * @ctxt: the validation context
1910 * @dtd: pointer to the DTD
1911 * @elem: the element name
1912 * @name: the attribute name
1913 * @ns: the attribute namespace prefix
1914 * @type: the attribute type
1915 * @def: the attribute default type
1916 * @defaultValue: the attribute default value
1917 * @tree: if it's an enumeration, the associated list
1918 *
1919 * Register a new attribute declaration
1920 * Note that @tree becomes the ownership of the DTD
1921 *
1922 * Returns NULL if not new, otherwise the attribute decl
1923 */
1924 xmlAttributePtr
1930 xmlAttributePtr ret;
1931 xmlAttributeTablePtr table;
1932 xmlElementPtr elemDef;
1938 }
1942 }
1946 }
1950 #ifdef LIBXML_VALID_ENABLED
1951 /*
1952 * Check the type and possibly the default value.
1953 */
1978 NULL);
1981 }
1990 }
1993 /*
1994 * Check first that an attribute defined in the external subset wasn't
1995 * already defined in the internal subset
1996 */
2004 }
2005 }
2007 /*
2008 * Create the Attribute table if needed.
2009 */
2014 }
2020 }
2028 }
2032 /*
2033 * fill the structure.
2034 */
2036 /*
2037 * doc must be set before possible error causes call
2038 * to xmlFreeAttribute (because it's used to check on
2039 * dict use)
2040 */
2050 }
2056 else
2058 }
2060 /*
2061 * Validity Check:
2062 * Search the DTD for previous declarations of the ATTLIST
2063 */
2065 #ifdef LIBXML_VALID_ENABLED
2066 /*
2067 * The attribute is already defined in this DTD.
2068 */
2075 }
2077 /*
2078 * Validity Check:
2079 * Multiple ID per element
2080 */
2084 #ifdef LIBXML_VALID_ENABLED
2092 }
2095 /*
2096 * Insert namespace default def first they need to be
2097 * processed first.
2098 */
2114 }
2121 }
2122 }
2123 }
2125 /*
2126 * Link it to the DTD
2127 */
2135 }
2137 }
2139 /**
2140 * xmlFreeAttributeTable:
2141 * @table: An attribute table
2142 *
2143 * Deallocate the memory used by an entities hash table.
2144 */
2145 void
2148 }
2150 #ifdef LIBXML_TREE_ENABLED
2151 /**
2152 * xmlCopyAttribute:
2153 * @attr: An attribute
2154 *
2155 * Build a copy of an attribute.
2156 *
2157 * Returns the new xmlAttributePtr or NULL in case of error.
2158 */
2159 static xmlAttributePtr
2161 xmlAttributePtr cur;
2167 }
2182 }
2184 /**
2185 * xmlCopyAttributeTable:
2186 * @table: An attribute table
2187 *
2188 * Build a copy of an attribute table.
2189 *
2190 * Returns the new xmlAttributeTablePtr or NULL in case of error.
2191 */
2192 xmlAttributeTablePtr
2196 }
2199 #ifdef LIBXML_OUTPUT_ENABLED
2200 /**
2201 * xmlDumpAttributeDecl:
2202 * @buf: the XML buffer output
2203 * @attr: An attribute declaration
2204 *
2205 * This will dump the content of the attribute declaration as an XML
2206 * DTD definition
2207 */
2208 void
2218 }
2256 NULL);
2257 }
2273 NULL);
2274 }
2278 }
2280 }
2282 /**
2283 * xmlDumpAttributeDeclScan:
2284 * @attr: An attribute declaration
2285 * @buf: the XML buffer output
2286 *
2287 * This is used with the hash scan function - just reverses arguments
2288 */
2289 static void
2292 }
2294 /**
2295 * xmlDumpAttributeTable:
2296 * @buf: the XML buffer output
2297 * @table: An attribute table
2298 *
2299 * This will dump the content of the attribute table as an XML DTD definition
2300 */
2301 void
2306 }
2309 /************************************************************************
2310 * *
2311 * NOTATIONs *
2312 * *
2313 ************************************************************************/
2314 /**
2315 * xmlFreeNotation:
2316 * @not: A notation
2317 *
2318 * Deallocate the memory used by an notation definition
2319 */
2320 static void
2330 }
2333 /**
2334 * xmlAddNotationDecl:
2335 * @dtd: pointer to the DTD
2336 * @ctxt: the validation context
2337 * @name: the entity name
2338 * @PublicID: the public identifier or NULL
2339 * @SystemID: the system identifier or NULL
2340 *
2341 * Register a new notation declaration
2342 *
2343 * Returns NULL if not, otherwise the entity
2344 */
2345 xmlNotationPtr
2349 xmlNotationPtr ret;
2350 xmlNotationTablePtr table;
2354 }
2357 }
2360 }
2362 /*
2363 * Create the Notation table if needed.
2364 */
2372 }
2377 }
2383 }
2386 /*
2387 * fill the structure.
2388 */
2395 /*
2396 * Validity Check:
2397 * Check the DTD for previous declarations of the ATTLIST
2398 */
2400 #ifdef LIBXML_VALID_ENABLED
2407 }
2409 }
2411 /**
2412 * xmlFreeNotationTable:
2413 * @table: An notation table
2414 *
2415 * Deallocate the memory used by an entities hash table.
2416 */
2417 void
2420 }
2422 #ifdef LIBXML_TREE_ENABLED
2423 /**
2424 * xmlCopyNotation:
2425 * @nota: A notation
2426 *
2427 * Build a copy of a notation.
2428 *
2429 * Returns the new xmlNotationPtr or NULL in case of error.
2430 */
2431 static xmlNotationPtr
2433 xmlNotationPtr cur;
2439 }
2442 else
2446 else
2450 else
2453 }
2455 /**
2456 * xmlCopyNotationTable:
2457 * @table: A notation table
2458 *
2459 * Build a copy of a notation table.
2460 *
2461 * Returns the new xmlNotationTablePtr or NULL in case of error.
2462 */
2463 xmlNotationTablePtr
2467 }
2470 #ifdef LIBXML_OUTPUT_ENABLED
2471 /**
2472 * xmlDumpNotationDecl:
2473 * @buf: the XML buffer output
2474 * @nota: A notation declaration
2475 *
2476 * This will dump the content the notation declaration as an XML DTD definition
2477 */
2478 void
2490 }
2494 }
2496 }
2498 /**
2499 * xmlDumpNotationDeclScan:
2500 * @nota: A notation declaration
2501 * @buf: the XML buffer output
2502 *
2503 * This is called with the hash scan function, and just reverses args
2504 */
2505 static void
2508 }
2510 /**
2511 * xmlDumpNotationTable:
2512 * @buf: the XML buffer output
2513 * @table: A notation table
2514 *
2515 * This will dump the content of the notation table as an XML DTD definition
2516 */
2517 void
2522 }
2525 /************************************************************************
2526 * *
2527 * IDs *
2528 * *
2529 ************************************************************************/
2530 /**
2531 * DICT_FREE:
2532 * @str: a string
2533 *
2534 * Free a string if it is not owned by the "dict" dictionnary in the
2535 * current scope
2536 */
2537 #define DICT_FREE(str) \
2538 if ((str) && ((!dict) || \
2539 (xmlDictOwns(dict, (const xmlChar *)(str)) == 0))) \
2540 xmlFree((char *)(str));
2542 /**
2543 * xmlFreeID:
2544 * @not: A id
2545 *
2546 * Deallocate the memory used by an id definition
2547 */
2548 static void
2562 }
2565 /**
2566 * xmlAddID:
2567 * @ctxt: the validation context
2568 * @doc: pointer to the document
2569 * @value: the value name
2570 * @attr: the attribute holding the ID
2571 *
2572 * Register a new id declaration
2573 *
2574 * Returns NULL if not, otherwise the new xmlIDPtr
2575 */
2576 xmlIDPtr
2578 xmlAttrPtr attr) {
2579 xmlIDPtr ret;
2580 xmlIDTablePtr table;
2584 }
2587 }
2590 }
2592 /*
2593 * Create the ID table if needed.
2594 */
2598 }
2603 }
2609 }
2611 /*
2612 * fill the structure.
2613 */
2617 /*
2618 * Operating in streaming mode, attr is gonna disapear
2619 */
2622 else
2628 }
2632 #ifdef LIBXML_VALID_ENABLED
2633 /*
2634 * The id is already defined in this DTD.
2635 */
2640 }
2644 }
2648 }
2650 /**
2651 * xmlFreeIDTable:
2652 * @table: An id table
2653 *
2654 * Deallocate the memory used by an ID hash table.
2655 */
2656 void
2659 }
2661 /**
2662 * xmlIsID:
2663 * @doc: the document
2664 * @elem: the element carrying the attribute
2665 * @attr: the attribute
2666 *
2667 * Determine whether an attribute is of type ID. In case we have DTD(s)
2668 * then this is done if DTD loading has been requested. In the case
2669 * of HTML documents parsed with the HTML parser, then ID detection is
2670 * done systematically.
2671 *
2672 * Returns 0 or 1 depending on the lookup result
2673 */
2674 int
2709 fullattrname);
2712 fullattrname);
2713 }
2722 }
2724 }
2726 /**
2727 * xmlRemoveID:
2728 * @doc: the document
2729 * @attr: the attribute
2730 *
2731 * Remove the given attribute from the ID table maintained internally.
2732 *
2733 * Returns -1 if the lookup failed and 0 otherwise
2734 */
2735 int
2737 xmlIDTablePtr table;
2738 xmlIDPtr id;
2756 }
2761 }
2763 /**
2764 * xmlGetID:
2765 * @doc: pointer to the document
2766 * @ID: the ID value
2767 *
2768 * Search the attribute declaring the given ID
2769 *
2770 * Returns NULL if not found, otherwise the xmlAttrPtr defining the ID
2771 */
2772 xmlAttrPtr
2774 xmlIDTablePtr table;
2775 xmlIDPtr id;
2779 }
2783 }
2793 /*
2794 * We are operating on a stream, return a well known reference
2795 * since the attribute node doesn't exist anymore
2796 */
2798 }
2800 }
2802 /************************************************************************
2803 * *
2804 * Refs *
2805 * *
2806 ************************************************************************/
2808 {
2809 xmlListPtr l;
2810 xmlAttrPtr ap;
2816 {
2817 xmlValidCtxtPtr ctxt;
2823 /**
2824 * xmlFreeRef:
2825 * @lk: A list link
2826 *
2827 * Deallocate the memory used by a ref definition
2828 */
2829 static void
2838 }
2840 /**
2841 * xmlFreeRefList:
2842 * @list_ref: A list of references.
2843 *
2844 * Deallocate the memory used by a list of references
2845 */
2846 static void
2850 }
2852 /**
2853 * xmlWalkRemoveRef:
2854 * @data: Contents of current link
2855 * @user: Value supplied by the user
2856 *
2857 * Returns 0 to abort the walk or 1 to continue
2858 */
2859 static int
2861 {
2869 }
2871 }
2873 /**
2874 * xmlDummyCompare
2875 * @data0: Value supplied by the user
2876 * @data1: Value supplied by the user
2877 *
2878 * Do nothing, return 0. Used to create unordered lists.
2879 */
2880 static int
2883 {
2885 }
2887 /**
2888 * xmlAddRef:
2889 * @ctxt: the validation context
2890 * @doc: pointer to the document
2891 * @value: the value name
2892 * @attr: the attribute holding the Ref
2893 *
2894 * Register a new ref declaration
2895 *
2896 * Returns NULL if not, otherwise the new xmlRefPtr
2897 */
2898 xmlRefPtr
2900 xmlAttrPtr attr) {
2901 xmlRefPtr ret;
2902 xmlRefTablePtr table;
2903 xmlListPtr ref_list;
2907 }
2910 }
2913 }
2915 /*
2916 * Create the Ref table if needed.
2917 */
2921 }
2926 }
2932 }
2934 /*
2935 * fill the structure.
2936 */
2939 /*
2940 * Operating in streaming mode, attr is gonna disapear
2941 */
2947 }
2950 /* To add a reference :-
2951 * References are maintained as a list of references,
2952 * Lookup the entry, if no entry create new nodelist
2953 * Add the owning node to the NodeList
2954 * Return the ref
2955 */
2961 NULL);
2963 }
2968 NULL);
2970 }
2971 }
2975 NULL);
2977 }
2979 failed:
2986 }
2988 }
2990 /**
2991 * xmlFreeRefTable:
2992 * @table: An ref table
2993 *
2994 * Deallocate the memory used by an Ref hash table.
2995 */
2996 void
2999 }
3001 /**
3002 * xmlIsRef:
3003 * @doc: the document
3004 * @elem: the element carrying the attribute
3005 * @attr: the attribute
3006 *
3007 * Determine whether an attribute is of type Ref. In case we have DTD(s)
3008 * then this is simple, otherwise we use an heuristic: name Ref (upper
3009 * or lowercase).
3010 *
3011 * Returns 0 or 1 depending on the lookup result
3012 */
3013 int
3020 }
3025 /* TODO @@@ */
3028 xmlAttributePtr attrDecl;
3040 }
3042 }
3044 /**
3045 * xmlRemoveRef:
3046 * @doc: the document
3047 * @attr: the attribute
3048 *
3049 * Remove the given attribute from the Ref table maintained internally.
3050 *
3051 * Returns -1 if the lookup failed and 0 otherwise
3052 */
3053 int
3055 xmlListPtr ref_list;
3056 xmlRefTablePtr table;
3058 xmlRemoveMemo target;
3076 }
3077 /* At this point, ref_list refers to a list of references which
3078 * have the same key as the supplied attr. Our list of references
3079 * is ordered by reference address and we don't have that information
3080 * here to use when removing. We'll have to walk the list and
3081 * check for a matching attribute, when we find one stop the walk
3082 * and remove the entry.
3083 * The list is ordered by reference, so that means we don't have the
3084 * key. Passing the list and the reference to the walker means we
3085 * will have enough data to be able to remove the entry.
3086 */
3090 /* Remove the supplied attr from our list */
3093 /*If the list is empty then remove the list entry in the hash */
3096 xmlFreeRefList);
3099 }
3101 /**
3102 * xmlGetRefs:
3103 * @doc: pointer to the document
3104 * @ID: the ID value
3105 *
3106 * Find the set of references for the supplied ID.
3107 *
3108 * Returns NULL if not found, otherwise node set for the ID.
3109 */
3110 xmlListPtr
3112 xmlRefTablePtr table;
3116 }
3120 }
3127 }
3129 /************************************************************************
3130 * *
3131 * Routines for validity checking *
3132 * *
3133 ************************************************************************/
3135 /**
3136 * xmlGetDtdElementDesc:
3137 * @dtd: a pointer to the DtD to search
3138 * @name: the element name
3139 *
3140 * Search the DTD for the description of this element
3141 *
3142 * returns the xmlElementPtr if found or NULL
3143 */
3145 xmlElementPtr
3147 xmlElementTablePtr table;
3148 xmlElementPtr cur;
3163 }
3164 /**
3165 * xmlGetDtdElementDesc2:
3166 * @dtd: a pointer to the DtD to search
3167 * @name: the element name
3168 * @create: create an empty description if not found
3169 *
3170 * Search the DTD for the description of this element
3171 *
3172 * returns the xmlElementPtr if found or NULL
3173 */
3175 static xmlElementPtr
3177 xmlElementTablePtr table;
3178 xmlElementPtr cur;
3190 /*
3191 * Create the Element table if needed.
3192 */
3197 }
3201 }
3202 }
3214 }
3218 /*
3219 * fill the structure.
3220 */
3226 }
3230 }
3232 /**
3233 * xmlGetDtdQElementDesc:
3234 * @dtd: a pointer to the DtD to search
3235 * @name: the element name
3236 * @prefix: the element namespace prefix
3237 *
3238 * Search the DTD for the description of this element
3239 *
3240 * returns the xmlElementPtr if found or NULL
3241 */
3243 xmlElementPtr
3246 xmlElementTablePtr table;
3253 }
3255 /**
3256 * xmlGetDtdAttrDesc:
3257 * @dtd: a pointer to the DtD to search
3258 * @elem: the element name
3259 * @name: the attribute name
3260 *
3261 * Search the DTD for the description of this attribute on
3262 * this element.
3263 *
3264 * returns the xmlAttributePtr if found or NULL
3265 */
3267 xmlAttributePtr
3269 xmlAttributeTablePtr table;
3270 xmlAttributePtr cur;
3289 }
3291 /**
3292 * xmlGetDtdQAttrDesc:
3293 * @dtd: a pointer to the DtD to search
3294 * @elem: the element name
3295 * @name: the attribute name
3296 * @prefix: the attribute namespace prefix
3297 *
3298 * Search the DTD for the description of this qualified attribute on
3299 * this element.
3300 *
3301 * returns the xmlAttributePtr if found or NULL
3302 */
3304 xmlAttributePtr
3307 xmlAttributeTablePtr table;
3314 }
3316 /**
3317 * xmlGetDtdNotationDesc:
3318 * @dtd: a pointer to the DtD to search
3319 * @name: the notation name
3320 *
3321 * Search the DTD for the description of this notation
3322 *
3323 * returns the xmlNotationPtr if found or NULL
3324 */
3326 xmlNotationPtr
3328 xmlNotationTablePtr table;
3335 }
3337 #if defined(LIBXML_VALID_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
3338 /**
3339 * xmlValidateNotationUse:
3340 * @ctxt: the validation context
3341 * @doc: the document
3342 * @notationName: the notation name to check
3343 *
3344 * Validate that the given name match a notation declaration.
3345 * - [ VC: Notation Declared ]
3346 *
3347 * returns 1 if valid or 0 otherwise
3348 */
3350 int
3353 xmlNotationPtr notaDecl;
3366 }
3368 }
3371 /**
3372 * xmlIsMixedElement:
3373 * @doc: the document
3374 * @name: the element name
3375 *
3376 * Search in the DtDs whether an element accept Mixed content (or ANY)
3377 * basically if it is supposed to accept text childs
3378 *
3379 * returns 0 if no, 1 if yes, and -1 if no element description is available
3380 */
3382 int
3384 xmlElementPtr elemDecl;
3398 /*
3399 * return 1 for EMPTY since we want VC error to pop up
3400 * on <empty> </empty> for example
3401 */
3405 }
3407 }
3409 #ifdef LIBXML_VALID_ENABLED
3411 static int
3414 /*
3415 * Use the new checks of production [4] [4a] amd [5] of the
3416 * Update 5 of XML-1.0
3417 */
3437 }
3439 }
3441 static int
3444 /*
3445 * Use the new checks of production [4] [4a] amd [5] of the
3446 * Update 5 of XML-1.0
3447 */
3475 }
3477 }
3479 /**
3480 * xmlValidateNameValue:
3481 * @doc: pointer to the document or NULL
3482 * @value: an Name value
3483 *
3484 * Validate that the given value match Name production
3485 *
3486 * returns 1 if valid or 0 otherwise
3487 */
3489 static int
3506 }
3511 }
3513 /**
3514 * xmlValidateNameValue:
3515 * @value: an Name value
3516 *
3517 * Validate that the given value match Name production
3518 *
3519 * returns 1 if valid or 0 otherwise
3520 */
3522 int
3525 }
3527 /**
3528 * xmlValidateNamesValueInternal:
3529 * @doc: pointer to the document or NULL
3530 * @value: an Names value
3531 *
3532 * Validate that the given value match Names production
3533 *
3534 * returns 1 if valid or 0 otherwise
3535 */
3537 static int
3555 }
3557 /* Should not test IS_BLANK(val) here -- see erratum E20*/
3562 }
3573 }
3574 }
3579 }
3581 /**
3582 * xmlValidateNamesValue:
3583 * @value: an Names value
3584 *
3585 * Validate that the given value match Names production
3586 *
3587 * returns 1 if valid or 0 otherwise
3588 */
3590 int
3593 }
3595 /**
3596 * xmlValidateNmtokenValueInternal:
3597 * @doc: pointer to the document or NULL
3598 * @value: an Nmtoken value
3599 *
3600 * Validate that the given value match Nmtoken production
3601 *
3602 * [ VC: Name Token ]
3603 *
3604 * returns 1 if valid or 0 otherwise
3605 */
3607 static int
3625 }
3630 }
3632 /**
3633 * xmlValidateNmtokenValue:
3634 * @value: an Nmtoken value
3635 *
3636 * Validate that the given value match Nmtoken production
3637 *
3638 * [ VC: Name Token ]
3639 *
3640 * returns 1 if valid or 0 otherwise
3641 */
3643 int
3646 }
3648 /**
3649 * xmlValidateNmtokensValueInternal:
3650 * @doc: pointer to the document or NULL
3651 * @value: an Nmtokens value
3652 *
3653 * Validate that the given value match Nmtokens production
3654 *
3655 * [ VC: Name Token ]
3656 *
3657 * returns 1 if valid or 0 otherwise
3658 */
3660 static int
3673 }
3681 }
3683 /* Should not test IS_BLANK(val) here -- see erratum E20*/
3688 }
3700 }
3701 }
3706 }
3708 /**
3709 * xmlValidateNmtokensValue:
3710 * @value: an Nmtokens value
3711 *
3712 * Validate that the given value match Nmtokens production
3713 *
3714 * [ VC: Name Token ]
3715 *
3716 * returns 1 if valid or 0 otherwise
3717 */
3719 int
3722 }
3724 /**
3725 * xmlValidateNotationDecl:
3726 * @ctxt: the validation context
3727 * @doc: a document instance
3728 * @nota: a notation definition
3729 *
3730 * Try to validate a single notation definition
3731 * basically it does the following checks as described by the
3732 * XML-1.0 recommendation:
3733 * - it seems that no validity constraint exists on notation declarations
3734 * But this function get called anyway ...
3735 *
3736 * returns 1 if valid or 0 otherwise
3737 */
3739 int
3741 xmlNotationPtr nota ATTRIBUTE_UNUSED) {
3745 }
3747 /**
3748 * xmlValidateAttributeValueInternal:
3749 * @doc: the document
3750 * @type: an attribute type
3751 * @value: an attribute value
3752 *
3753 * Validate that the given attribute value match the proper production
3754 *
3755 * returns 1 if valid or 0 otherwise
3756 */
3758 static int
3777 }
3779 }
3781 /**
3782 * xmlValidateAttributeValue:
3783 * @type: an attribute type
3784 * @value: an attribute value
3785 *
3786 * Validate that the given attribute value match the proper production
3787 *
3788 * [ VC: ID ]
3789 * Values of type ID must match the Name production....
3790 *
3791 * [ VC: IDREF ]
3792 * Values of type IDREF must match the Name production, and values
3793 * of type IDREFS must match Names ...
3794 *
3795 * [ VC: Entity Name ]
3796 * Values of type ENTITY must match the Name production, values
3797 * of type ENTITIES must match Names ...
3798 *
3799 * [ VC: Name Token ]
3800 * Values of type NMTOKEN must match the Nmtoken production; values
3801 * of type NMTOKENS must match Nmtokens.
3802 *
3803 * returns 1 if valid or 0 otherwise
3804 */
3805 int
3808 }
3810 /**
3811 * xmlValidateAttributeValue2:
3812 * @ctxt: the validation context
3813 * @doc: the document
3814 * @name: the attribute name (used for error reporting only)
3815 * @type: the attribute type
3816 * @value: the attribute value
3817 *
3818 * Validate that the given attribute value match a given type.
3819 * This typically cannot be done before having finished parsing
3820 * the subsets.
3821 *
3822 * [ VC: IDREF ]
3823 * Values of type IDREF must match one of the declared IDs
3824 * Values of type IDREFS must match a sequence of the declared IDs
3825 * each Name must match the value of an ID attribute on some element
3826 * in the XML document; i.e. IDREF values must match the value of
3827 * some ID attribute
3828 *
3829 * [ VC: Entity Name ]
3830 * Values of type ENTITY must match one declared entity
3831 * Values of type ENTITIES must match a sequence of declared entities
3832 *
3833 * [ VC: Notation Attributes ]
3834 * all notation names in the declaration must be declared.
3835 *
3836 * returns 1 if valid or 0 otherwise
3837 */
3839 static int
3853 xmlEntityPtr ent;
3856 /* yeah it's a bit messy... */
3860 }
3863 XML_DTD_UNKNOWN_ENTITY,
3869 XML_DTD_ENTITY_TYPE,
3873 }
3875 }
3878 xmlEntityPtr ent;
3892 XML_DTD_UNKNOWN_ENTITY,
3898 XML_DTD_ENTITY_TYPE,
3902 }
3907 }
3910 }
3912 xmlNotationPtr nota;
3920 XML_DTD_UNKNOWN_NOTATION,
3924 }
3926 }
3927 }
3929 }
3931 /**
3932 * xmlValidCtxtNormalizeAttributeValue:
3933 * @ctxt: the validation context
3934 * @doc: the document
3935 * @elem: the parent
3936 * @name: the attribute name
3937 * @value: the attribute value
3938 * @ctxt: the validation context or NULL
3939 *
3940 * Does the validation related extra step of the normalization of attribute
3941 * values:
3942 *
3943 * If the declared value is not CDATA, then the XML processor must further
3944 * process the normalized attribute value by discarding any leading and
3945 * trailing space (#x20) characters, and by replacing sequences of space
3946 * (#x20) characters by single space (#x20) character.
3947 *
3948 * Also check VC: Standalone Document Declaration in P32, and update
3949 * ctxt->valid accordingly
3950 *
3951 * returns a new normalized string if normalization is needed, NULL otherwise
3952 * the caller must free the returned value.
3953 */
3955 xmlChar *
3980 }
3983 }
3990 }
4010 }
4011 }
4018 }
4020 }
4022 /**
4023 * xmlValidNormalizeAttributeValue:
4024 * @doc: the document
4025 * @elem: the parent
4026 * @name: the attribute name
4027 * @value: the attribute value
4028 *
4029 * Does the validation related extra step of the normalization of attribute
4030 * values:
4031 *
4032 * If the declared value is not CDATA, then the XML processor must further
4033 * process the normalized attribute value by discarding any leading and
4034 * trailing space (#x20) characters, and by replacing sequences of space
4035 * (#x20) characters by single space (#x20) character.
4036 *
4037 * Returns a new normalized string if normalization is needed, NULL otherwise
4038 * the caller must free the returned value.
4039 */
4041 xmlChar *
4062 }
4085 }
4086 }
4089 }
4091 static void
4095 }
4097 /**
4098 * xmlValidateAttributeDecl:
4099 * @ctxt: the validation context
4100 * @doc: a document instance
4101 * @attr: an attribute definition
4102 *
4103 * Try to validate a single attribute definition
4104 * basically it does the following checks as described by the
4105 * XML-1.0 recommendation:
4106 * - [ VC: Attribute Default Legal ]
4107 * - [ VC: Enumeration ]
4108 * - [ VC: ID Attribute Default ]
4109 *
4110 * The ID/IDREF uniqueness and matching are done separately
4111 *
4112 * returns 1 if valid or 0 otherwise
4113 */
4115 int
4117 xmlAttributePtr attr) {
4120 CHECK_DTD;
4123 /* Attribute Default Legal */
4124 /* Enumeration */
4132 }
4134 }
4136 /* ID Attribute Default */
4144 }
4146 /* One ID per Element Type */
4150 /* the trick is that we parse DtD as their own internal subset */
4156 xmlAttributeTablePtr table;
4158 /*
4159 * The attribute may be declared in the internal subset and the
4160 * element in the external subset.
4161 */
4167 }
4168 }
4179 }
4188 }
4189 }
4190 }
4192 /* Validity Constraint: Enumeration */
4198 }
4204 }
4205 }
4208 }
4210 /**
4211 * xmlValidateElementDecl:
4212 * @ctxt: the validation context
4213 * @doc: a document instance
4214 * @elem: an element definition
4215 *
4216 * Try to validate a single element definition
4217 * basically it does the following checks as described by the
4218 * XML-1.0 recommendation:
4219 * - [ VC: One ID per Element Type ]
4220 * - [ VC: No Duplicate Types ]
4221 * - [ VC: Unique Element Type Declaration ]
4222 *
4223 * returns 1 if valid or 0 otherwise
4224 */
4226 int
4228 xmlElementPtr elem) {
4230 xmlElementPtr tst;
4232 CHECK_DTD;
4236 #if 0
4237 #ifdef LIBXML_REGEXP_ENABLED
4238 /* Build the regexp associated to the content model */
4240 #endif
4241 #endif
4243 /* No Duplicate Types */
4267 }
4269 }
4271 }
4284 }
4286 }
4288 }
4289 }
4291 }
4292 }
4294 /* VC: Unique Element Type Declaration */
4304 }
4314 }
4315 /* One ID per Element Type
4316 * already done when registering the attribute
4317 if (xmlScanIDAttributeDecl(ctxt, elem) > 1) {
4318 ret = 0;
4319 } */
4321 }
4323 /**
4324 * xmlValidateOneAttribute:
4325 * @ctxt: the validation context
4326 * @doc: a document instance
4327 * @elem: an element instance
4328 * @attr: an attribute instance
4329 * @value: the attribute value (without entities processing)
4330 *
4331 * Try to validate a single attribute for an element
4332 * basically it does the following checks as described by the
4333 * XML-1.0 recommendation:
4334 * - [ VC: Attribute Value Type ]
4335 * - [ VC: Fixed Attribute Default ]
4336 * - [ VC: Entity Name ]
4337 * - [ VC: Name Token ]
4338 * - [ VC: ID ]
4339 * - [ VC: IDREF ]
4340 * - [ VC: Entity Name ]
4341 * - [ VC: Notation Attributes ]
4342 *
4343 * The ID/IDREF uniqueness and matching are done separately
4344 *
4345 * returns 1 if valid or 0 otherwise
4346 */
4348 int
4351 {
4356 CHECK_DTD;
4378 }
4381 }
4395 }
4396 }
4399 /* Validity Constraint: Attribute Value Type */
4405 }
4414 }
4416 /* Validity constraint: Fixed Attribute Default */
4423 }
4424 }
4426 /* Validity Constraint: ID uniqueness */
4430 }
4436 }
4438 /* Validity Constraint: Notation Attributes */
4441 xmlNotationPtr nota;
4443 /* First check that the given NOTATION was declared */
4453 }
4455 /* Second, verify that it's among the list */
4459 }
4465 }
4466 }
4468 /* Validity Constraint: Enumeration */
4474 }
4480 }
4481 }
4483 /* Fixed Attribute Default */
4490 }
4492 /* Extra check for the attribute value */
4497 }
4499 /**
4500 * xmlValidateOneNamespace:
4501 * @ctxt: the validation context
4502 * @doc: a document instance
4503 * @elem: an element instance
4504 * @prefix: the namespace prefix
4505 * @ns: an namespace declaration instance
4506 * @value: the attribute value (without entities processing)
4507 *
4508 * Try to validate a single namespace declaration for an element
4509 * basically it does the following checks as described by the
4510 * XML-1.0 recommendation:
4511 * - [ VC: Attribute Value Type ]
4512 * - [ VC: Fixed Attribute Default ]
4513 * - [ VC: Entity Name ]
4514 * - [ VC: Name Token ]
4515 * - [ VC: ID ]
4516 * - [ VC: IDREF ]
4517 * - [ VC: Entity Name ]
4518 * - [ VC: Notation Attributes ]
4519 *
4520 * The ID/IDREF uniqueness and matching are done separately
4521 *
4522 * returns 1 if valid or 0 otherwise
4523 */
4525 int
4528 /* xmlElementPtr elemDecl; */
4533 CHECK_DTD;
4545 }
4558 }
4561 }
4575 }
4576 }
4579 /* Validity Constraint: Attribute Value Type */
4589 }
4591 }
4603 }
4605 }
4607 /* Validity constraint: Fixed Attribute Default */
4618 }
4620 }
4621 }
4623 /* Validity Constraint: ID uniqueness */
4627 }
4633 }
4635 /* Validity Constraint: Notation Attributes */
4638 xmlNotationPtr nota;
4640 /* First check that the given NOTATION was declared */
4654 }
4656 }
4658 /* Second, verify that it's among the list */
4662 }
4672 }
4674 }
4675 }
4677 /* Validity Constraint: Enumeration */
4683 }
4693 }
4695 }
4696 }
4698 /* Fixed Attribute Default */
4709 }
4711 }
4713 /* Extra check for the attribute value */
4720 }
4723 }
4725 #ifndef LIBXML_REGEXP_ENABLED
4726 /**
4727 * xmlValidateSkipIgnorable:
4728 * @ctxt: the validation context
4729 * @child: the child list
4730 *
4731 * Skip ignorable elements w.r.t. the validation process
4732 *
4733 * returns the first element to consider for validation of the content model
4734 */
4736 static xmlNodePtr
4740 /* These things are ignored (skipped) during validation. */
4750 else
4753 /* keep current node */
4756 }
4757 }
4759 }
4761 /**
4762 * xmlValidateElementType:
4763 * @ctxt: the validation context
4764 *
4765 * Try to validate the content model of an element internal function
4766 *
4767 * returns 1 if valid or 0 ,-1 in case of error, -2 if an entity
4768 * reference is found and -3 if the validation succeeded but
4769 * the content model is not determinist.
4770 */
4772 static int
4784 }
4789 /*
4790 * We arrive here when more states need to be examined
4791 */
4792 cont:
4794 /*
4795 * We just recovered from a rollback generated by a possible
4796 * epsilon transition, go directly to the analysis phase
4797 */
4803 }
4806 /*
4807 * we may have to save a backup state here. This is the equivalent
4808 * of handling epsilon transition in NFAs.
4809 */
4819 }
4822 /*
4823 * Check first if the content matches
4824 */
4831 }
4834 /*
4835 * go to next element in the content model
4836 * skipping ignorable elems
4837 */
4854 }
4861 }
4871 }
4872 }
4875 /*
4876 * go to next element in the content model
4877 * skipping ignorable elems
4878 */
4893 }
4896 /*
4897 * Small optimization.
4898 */
4902 DEPTH++;
4905 }
4912 }
4914 DEPTH++;
4917 }
4918 }
4920 /*
4921 * save the second branch 'or' branch
4922 */
4927 DEPTH++;
4931 /*
4932 * Small optimization.
4933 */
4939 DEPTH++;
4942 }
4949 }
4951 DEPTH++;
4954 }
4955 }
4956 DEPTH++;
4959 }
4961 /*
4962 * At this point handle going up in the tree
4963 */
4967 }
4968 analyze:
4970 /*
4971 * First do the analysis depending on the occurrence model at
4972 * this level.
4973 */
4976 xmlNodePtr cur;
4984 }
4995 }
4999 }
5004 #ifdef DEBUG_VALID_ALGO
5009 }
5010 #endif
5017 }
5033 }
5038 }
5040 SET_OCCURRENCE;
5047 }
5052 }
5054 /* SET_OCCURRENCE; */
5056 }
5057 }
5060 /*
5061 * Then act accordingly at the parent level
5062 */
5063 RESET_OCCURRENCE;
5078 DEPTH--;
5082 DEPTH--;
5083 }
5089 DEPTH--;
5097 DEPTH--;
5098 }
5099 }
5100 }
5102 xmlNodePtr cur;
5109 }
5113 }
5115 xmlNodePtr cur;
5122 }
5126 }
5128 }
5129 #endif
5131 /**
5132 * xmlSnprintfElements:
5133 * @buf: an output buffer
5134 * @size: the size of the buffer
5135 * @content: An element
5136 * @glob: 1 if one must print the englobing parenthesis, 0 otherwise
5137 *
5138 * This will dump the list of elements to the buffer
5139 * Intended just for the debug routine
5140 */
5141 static void
5143 xmlNodePtr cur;
5155 }
5163 }
5166 }
5171 }
5187 #ifdef LIBXML_DOCB_ENABLED
5189 #endif
5209 }
5211 }
5213 }
5215 /**
5216 * xmlValidateElementContent:
5217 * @ctxt: the validation context
5218 * @child: the child list
5219 * @elemDecl: pointer to the element declaration
5220 * @warn: emit the error message
5221 * @parent: the parent element (for error reporting)
5222 *
5223 * Try to validate the content model of an element
5224 *
5225 * returns 1 if valid or 0 if not and -1 in case of error
5226 */
5228 static int
5232 #ifndef LIBXML_REGEXP_ENABLED
5234 #endif
5235 xmlNodePtr cur;
5236 xmlElementContentPtr cont;
5244 #ifdef LIBXML_REGEXP_ENABLED
5245 /* Build the regexp associated to the content model */
5251 xmlRegExecCtxtPtr exec;
5255 }
5265 /*
5266 * Push the current node to be able to roll back
5267 * and process within the entity
5268 */
5274 }
5282 /* TODO */
5295 }
5301 }
5305 }
5306 /*
5307 * Switch to next element
5308 */
5315 }
5316 }
5318 fail:
5320 }
5321 }
5323 /*
5324 * Allocate the stack
5325 */
5332 }
5333 /*
5334 * The first entry in the stack is reserved to the current state
5335 */
5352 /*
5353 * An entities reference appeared at this level.
5354 * Buid a minimal representation of this node content
5355 * sufficient to run the validation process on it
5356 */
5362 /*
5363 * Push the current node to be able to roll back
5364 * and process within the entity
5365 */
5371 }
5376 /* no break on purpose */
5378 /* no break on purpose */
5380 /*
5381 * Allocate a new node and minimally fills in
5382 * what's required
5383 */
5390 }
5401 }
5403 /*
5404 * E59 spaces in CDATA does not match the
5405 * nonterminal S
5406 */
5408 }
5412 }
5413 /*
5414 * Switch to next element
5415 */
5422 }
5423 }
5425 /*
5426 * Relaunch the validation
5427 */
5436 }
5446 #ifndef LIBXML_REGEXP_ENABLED
5449 else
5461 }
5471 }
5472 }
5474 }
5478 #ifndef LIBXML_REGEXP_ENABLED
5479 done:
5480 /*
5481 * Deallocate the copy if done, and free up the validation stack
5482 */
5487 }
5492 }
5493 #endif
5499 }
5502 }
5504 /**
5505 * xmlValidateCdataElement:
5506 * @ctxt: the validation context
5507 * @doc: a document instance
5508 * @elem: an element instance
5509 *
5510 * Check that an element follows #CDATA
5511 *
5512 * returns 1 if valid or 0 otherwise
5513 */
5514 static int
5516 xmlNodePtr elem) {
5529 /*
5530 * Push the current node to be able to roll back
5531 * and process within the entity
5532 */
5538 }
5548 }
5549 /*
5550 * Switch to next element
5551 */
5558 }
5559 }
5560 done:
5566 }
5568 }
5570 /**
5571 * xmlValidateCheckMixed:
5572 * @ctxt: the validation context
5573 * @cont: the mixed content model
5574 * @qname: the qualified name as appearing in the serialization
5575 *
5576 * Check if the given node is part of the content model.
5577 *
5578 * Returns 1 if yes, 0 if no, -1 in case of error
5579 */
5580 static int
5603 NULL);
5605 }
5607 }
5627 NULL);
5629 }
5631 }
5632 }
5634 }
5636 /**
5637 * xmlValidGetElemDecl:
5638 * @ctxt: the validation context
5639 * @doc: a document instance
5640 * @elem: an element instance
5641 * @extsubset: pointer, (out) indicate if the declaration was found
5642 * in the external subset.
5643 *
5644 * Finds a declaration associated to an element in the document.
5645 *
5646 * returns the pointer to the declaration or NULL if not found.
5647 */
5648 static xmlElementPtr
5660 /*
5661 * Fetch the declaration for the qualified name
5662 */
5674 }
5675 }
5677 /*
5678 * Fetch the declaration for the non qualified name
5679 * This is "non-strict" validation should be done on the
5680 * full QName but in that case being flexible makes sense.
5681 */
5688 }
5689 }
5692 XML_DTD_UNKNOWN_ELEM,
5695 }
5697 }
5699 #ifdef LIBXML_REGEXP_ENABLED
5700 /**
5701 * xmlValidatePushElement:
5702 * @ctxt: the validation context
5703 * @doc: a document instance
5704 * @elem: an element instance
5705 * @qname: the qualified name as appearing in the serialization
5706 *
5707 * Push a new element start on the validation stack.
5708 *
5709 * returns 1 if no validation problem was found or 0 otherwise
5710 */
5711 int
5715 xmlElementPtr eDecl;
5720 /* printf("PushElem %s\n", qname); */
5723 xmlElementPtr elemDecl;
5725 /*
5726 * Check the new element agaisnt the content model of the new elem.
5727 */
5737 XML_DTD_NOT_EMPTY,
5743 /* I don't think anything is required then */
5746 /* simple case of declared as #PCDATA */
5749 XML_ELEMENT_CONTENT_PCDATA)) {
5751 XML_DTD_NOT_PCDATA,
5757 qname);
5760 XML_DTD_INVALID_CHILD,
5763 }
5764 }
5767 /*
5768 * TODO:
5769 * VC: Standalone Document Declaration
5770 * - element types with element content, if white space
5771 * occurs directly within any instance of those types.
5772 */
5777 XML_DTD_CONTENT_MODEL,
5783 }
5784 }
5786 }
5787 }
5788 }
5792 }
5794 /**
5795 * xmlValidatePushCData:
5796 * @ctxt: the validation context
5797 * @data: some character data read
5798 * @len: the lenght of the data
5799 *
5800 * check the CData parsed for validation in the current stack
5801 *
5802 * returns 1 if no validation problem was found or 0 otherwise
5803 */
5804 int
5808 /* printf("CDATA %s %d\n", data, len); */
5815 xmlElementPtr elemDecl;
5817 /*
5818 * Check the new element agaisnt the content model of the new elem.
5819 */
5829 XML_DTD_NOT_EMPTY,
5845 XML_DTD_CONTENT_MODEL,
5850 }
5851 }
5852 /*
5853 * TODO:
5854 * VC: Standalone Document Declaration
5855 * element types with element content, if white space
5856 * occurs directly within any instance of those types.
5857 */
5858 }
5860 }
5861 }
5862 }
5863 done:
5865 }
5867 /**
5868 * xmlValidatePopElement:
5869 * @ctxt: the validation context
5870 * @doc: a document instance
5871 * @elem: an element instance
5872 * @qname: the qualified name as appearing in the serialization
5873 *
5874 * Pop the element end from the validation stack.
5875 *
5876 * returns 1 if no validation problem was found or 0 otherwise
5877 */
5878 int
5880 xmlNodePtr elem ATTRIBUTE_UNUSED,
5886 /* printf("PopElem %s\n", qname); */
5889 xmlElementPtr elemDecl;
5891 /*
5892 * Check the new element agaisnt the content model of the new elem.
5893 */
5902 XML_DTD_CONTENT_MODEL,
5906 /*
5907 * previous validation errors should not generate
5908 * a new one here
5909 */
5911 }
5912 }
5913 }
5914 }
5916 }
5918 }
5921 /**
5922 * xmlValidateOneElement:
5923 * @ctxt: the validation context
5924 * @doc: a document instance
5925 * @elem: an element instance
5926 *
5927 * Try to validate a single element and it's attributes,
5928 * basically it does the following checks as described by the
5929 * XML-1.0 recommendation:
5930 * - [ VC: Element Valid ]
5931 * - [ VC: Required Attribute ]
5932 * Then call xmlValidateOneAttribute() for each attribute present.
5933 *
5934 * The ID/IDREF checkings are done separately
5935 *
5936 * returns 1 if valid or 0 otherwise
5937 */
5939 int
5941 xmlNodePtr elem) {
5943 xmlElementContentPtr cont;
5944 xmlAttributePtr attr;
5945 xmlNodePtr child;
5950 CHECK_DTD;
5964 }
5970 }
5976 }
6010 }
6012 /*
6013 * Fetch the declaration
6014 */
6019 /*
6020 * If vstateNr is not zero that means continuous validation is
6021 * activated, do not try to check the content model at that level.
6022 */
6024 /* Check that the element content matches the definition */
6037 }
6040 /* I don't think anything is required then */
6044 /* simple case of declared as #PCDATA */
6052 }
6054 }
6056 /* Hum, this start to get messy */
6083 NULL);
6085 }
6087 }
6092 }
6106 NULL);
6108 }
6110 }
6116 }
6117 }
6118 child_ok:
6120 }
6124 /*
6125 * VC: Standalone Document Declaration
6126 * - element types with element content, if white space
6127 * occurs directly within any instance of those types.
6128 */
6135 content++;
6138 XML_DTD_STANDALONE_WHITE_SPACE,
6143 }
6144 }
6146 }
6147 }
6154 }
6157 /* [ VC: Required Attribute ] */
6165 xmlNsPtr ns;
6172 }
6174 xmlNsPtr ns;
6181 }
6183 xmlAttrPtr attrib;
6193 /*
6194 * qualified names handling is problematic, having a
6195 * different prefix should be possible but DTDs don't
6196 * allow to define the URI instead of the prefix :-(
6197 */
6208 /*
6209 * We should allow applications to define namespaces
6210 * for their application even if the DTD doesn't
6211 * carry one, otherwise, basically we would always
6212 * break.
6213 */
6215 }
6216 }
6218 }
6219 }
6231 }
6240 }
6242 /*
6243 * Special tests checking #FIXED namespace declarations
6244 * have the right value since this is not done as an
6245 * attribute checking
6246 */
6249 xmlNsPtr ns;
6256 XML_DTD_ELEM_DEFAULT_NAMESPACE,
6260 }
6262 }
6264 }
6266 xmlNsPtr ns;
6276 }
6278 }
6280 }
6281 }
6282 }
6283 found:
6285 }
6287 }
6289 /**
6290 * xmlValidateRoot:
6291 * @ctxt: the validation context
6292 * @doc: a document instance
6293 *
6294 * Try to validate a the root element
6295 * basically it does the following check as described by the
6296 * XML-1.0 recommendation:
6297 * - [ VC: Root Element Type ]
6298 * it doesn't try to recurse or apply other check to the element
6299 *
6300 * returns 1 if valid or 0 otherwise
6301 */
6303 int
6305 xmlNodePtr root;
6315 }
6317 /*
6318 * When doing post validation against a separate DTD, those may
6319 * no internal subset has been generated
6320 */
6323 /*
6324 * Check first the document root against the NQName
6325 */
6335 }
6341 }
6349 }
6350 }
6351 name_ok:
6353 }
6356 /**
6357 * xmlValidateElement:
6358 * @ctxt: the validation context
6359 * @doc: a document instance
6360 * @elem: an element instance
6361 *
6362 * Try to validate the subtree under an element
6363 *
6364 * returns 1 if valid or 0 otherwise
6365 */
6367 int
6369 xmlNodePtr child;
6370 xmlAttrPtr attr;
6371 xmlNsPtr ns;
6377 /*
6378 * XInclude elements were added after parsing in the infoset,
6379 * they don't really mean anything validation wise.
6380 */
6385 CHECK_DTD;
6387 /*
6388 * Entities references have to be handled separately
6389 */
6392 }
6403 }
6409 else
6413 }
6414 }
6419 }
6422 }
6424 /**
6425 * xmlValidateRef:
6426 * @ref: A reference to be validated
6427 * @ctxt: Validation context
6428 * @name: Name of ID we are searching for
6429 *
6430 */
6431 static void
6434 xmlAttrPtr id;
6435 xmlAttrPtr attr;
6449 }
6462 }
6467 }
6476 }
6485 }
6498 }
6503 }
6505 }
6506 }
6508 /**
6509 * xmlWalkValidateList:
6510 * @data: Contents of current link
6511 * @user: Value supplied by the user
6512 *
6513 * Returns 0 to abort the walk or 1 to continue
6514 */
6515 static int
6517 {
6521 }
6523 /**
6524 * xmlValidateCheckRefCallback:
6525 * @ref_list: List of references
6526 * @ctxt: Validation context
6527 * @name: Name of ID we are searching for
6528 *
6529 */
6530 static void
6533 xmlValidateMemo memo;
6542 }
6544 /**
6545 * xmlValidateDocumentFinal:
6546 * @ctxt: the validation context
6547 * @doc: a document instance
6548 *
6549 * Does the final step for the document validation once all the
6550 * incremental validation steps have been completed
6551 *
6552 * basically it does the following checks described by the XML Rec
6553 *
6554 * Check all the IDREF/IDREFS attributes definition for validity
6555 *
6556 * returns 1 if valid or 0 otherwise
6557 */
6559 int
6561 xmlRefTablePtr table;
6569 }
6571 /*
6572 * Check all the NOTATION/NOTATIONS attributes
6573 */
6574 /*
6575 * Check all the ENTITY/ENTITIES attributes definition for validity
6576 */
6577 /*
6578 * Check all the IDREF/IDREFS attributes definition for validity
6579 */
6585 }
6587 /**
6588 * xmlValidateDtd:
6589 * @ctxt: the validation context
6590 * @doc: a document instance
6591 * @dtd: a dtd instance
6592 *
6593 * Try to validate the document against the dtd instance
6594 *
6595 * Basically it does check all the definitions in the DtD.
6596 * Note the the internal subset (if present) is de-coupled
6597 * (i.e. not used), which could give problems if ID or IDREF
6598 * is present.
6599 *
6600 * returns 1 if valid or 0 otherwise
6601 */
6603 int
6607 xmlNodePtr root;
6620 }
6624 }
6628 }
6635 }
6637 static void
6651 }
6652 }
6653 }
6654 }
6656 static void
6660 xmlDocPtr doc;
6683 }
6692 }
6693 }
6694 }
6702 }
6716 }
6722 }
6723 }
6724 }
6726 /**
6727 * xmlValidateDtdFinal:
6728 * @ctxt: the validation context
6729 * @doc: a document instance
6730 *
6731 * Does the final step for the dtds validation once all the
6732 * subsets have been parsed
6733 *
6734 * basically it does the following checks described by the XML Rec
6735 * - check that ENTITY and ENTITIES type attributes default or
6736 * possible values matches one of the defined entities.
6737 * - check that NOTATION type attributes default or
6738 * possible values matches one of the defined notations.
6739 *
6740 * returns 1 if valid or 0 if invalid and -1 if not well-formed
6741 */
6743 int
6745 xmlDtdPtr dtd;
6746 xmlAttributeTablePtr table;
6747 xmlEntitiesTablePtr entities;
6758 }
6762 ctxt);
6763 }
6768 }
6772 ctxt);
6773 }
6775 }
6777 /**
6778 * xmlValidateDocument:
6779 * @ctxt: the validation context
6780 * @doc: a document instance
6781 *
6782 * Try to validate the document instance
6783 *
6784 * basically it does the all the checks described by the XML Rec
6785 * i.e. validates the internal and external subset (if present)
6786 * and validate the document tree.
6787 *
6788 * returns 1 if valid or 0 otherwise
6789 */
6791 int
6794 xmlNodePtr root;
6802 }
6814 }
6830 }
6832 }
6833 }
6838 }
6842 }
6850 }
6852 /************************************************************************
6853 * *
6854 * Routines for dynamic validation editing *
6855 * *
6856 ************************************************************************/
6858 /**
6859 * xmlValidGetPotentialChildren:
6860 * @ctree: an element content tree
6861 * @names: an array to store the list of child names
6862 * @len: a pointer to the number of element in the list
6863 * @max: the size of the array
6864 *
6865 * Build/extend a list of potential children allowed by the content tree
6866 *
6867 * returns the number of element in the list, or -1 in case of error.
6868 */
6870 int
6899 }
6902 }
6904 /*
6905 * Dummy function to suppress messages while we try out valid elements
6906 */
6910 }
6912 /**
6913 * xmlValidGetValidElements:
6914 * @prev: an element to insert after
6915 * @next: an element to insert next
6916 * @names: an array to store the list of child names
6917 * @max: the size of the array
6918 *
6919 * This function returns the list of authorized children to insert
6920 * within an existing tree while respecting the validity constraints
6921 * forced by the Dtd. The insertion point is defined using @prev and
6922 * @next in the following ways:
6923 * to insert before 'node': xmlValidGetValidElements(node->prev, node, ...
6924 * to insert next 'node': xmlValidGetValidElements(node, node->next, ...
6925 * to replace 'node': xmlValidGetValidElements(node->prev, node->next, ...
6926 * to prepend a child to 'node': xmlValidGetValidElements(NULL, node->childs,
6927 * to append a child to 'node': xmlValidGetValidElements(node->last, NULL, ...
6928 *
6929 * pointers to the element names are inserted at the beginning of the array
6930 * and do not need to be freed.
6931 *
6932 * returns the number of element in the list, or -1 in case of error. If
6933 * the function returns the value @max the caller is invited to grow the
6934 * receiving array and retry.
6935 */
6937 int
6940 xmlValidCtxt vctxt;
6970 /*
6971 * Retrieves the parent element declaration
6972 */
6980 /*
6981 * Do a backup of the current tree structure
6982 */
6988 /*
6989 * Creates a dummy node and insert it into the tree
6990 */
7003 /*
7004 * Insert each potential child node and check if the parent is
7005 * still valid
7006 */
7019 }
7020 }
7022 /*
7023 * Restore the tree structure
7024 */
7030 /*
7031 * Free up the dummy node
7032 */
7037 }
7040 #define bottom_valid