| blob | 06a7f382044a2ac7e325d1bf4fe3e07c2b3b7a38 |
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>
14 #include <stdlib.h>
16 #include <libxml/xmlmemory.h>
17 #include <libxml/hash.h>
18 #include <libxml/uri.h>
19 #include <libxml/valid.h>
20 #include <libxml/parser.h>
21 #include <libxml/parserInternals.h>
22 #include <libxml/xmlerror.h>
23 #include <libxml/list.h>
24 #include <libxml/globals.h>
29 static xmlElementPtr
32 /* #define DEBUG_VALID_ALGO */
33 /* #define DEBUG_REGEXP_ALGO */
35 #define TODO \
36 xmlGenericError(xmlGenericErrorContext, \
38 __FILE__, __LINE__);
40 #ifdef LIBXML_VALID_ENABLED
41 static int
44 #endif
45 /************************************************************************
46 * *
47 * Error handling routines *
48 * *
49 ************************************************************************/
51 /**
52 * xmlVErrMemory:
53 * @ctxt: an XML validation parser context
54 * @extra: extra information
55 *
56 * Handle an out of memory error
57 */
58 static void
60 {
68 /* Look up flag to detect if it is part of a parsing
69 context */
72 }
73 }
79 else
84 }
86 /**
87 * xmlErrValid:
88 * @ctxt: an XML validation parser context
89 * @error: the error number
90 * @extra: extra information
91 *
92 * Handle a validation error
93 */
97 {
105 /* Look up flag to detect if it is part of a parsing
106 context */
109 }
110 }
116 else
121 }
123 #if defined(LIBXML_VALID_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
124 /**
125 * xmlErrValidNode:
126 * @ctxt: an XML validation parser context
127 * @node: the node raising the error
128 * @error: the error number
129 * @str1: extra information
130 * @str2: extra information
131 * @str3: extra information
132 *
133 * Handle a validation error, provide contextual information
134 */
140 {
149 /* Look up flag to detect if it is part of a parsing
150 context */
153 }
154 }
160 }
163 #ifdef LIBXML_VALID_ENABLED
164 /**
165 * xmlErrValidNodeNr:
166 * @ctxt: an XML validation parser context
167 * @node: the node raising the error
168 * @error: the error number
169 * @str1: extra information
170 * @int2: extra information
171 * @str3: extra information
172 *
173 * Handle a validation error, provide contextual information
174 */
180 {
189 /* Look up flag to detect if it is part of a parsing
190 context */
193 }
194 }
200 }
202 /**
203 * xmlErrValidWarning:
204 * @ctxt: an XML validation parser context
205 * @node: the node raising the error
206 * @error: the error number
207 * @str1: extra information
208 * @str2: extra information
209 * @str3: extra information
210 *
211 * Handle a validation error, provide contextual information
212 */
218 {
227 /* Look up flag to detect if it is part of a parsing
228 context */
231 }
232 }
238 }
242 #ifdef LIBXML_REGEXP_ENABLED
243 /*
244 * If regexp are enabled we can do continuous validation without the
245 * need of a tree to validate the content model. this is done in each
246 * callbacks.
247 * Each xmlValidState represent the validation state associated to the
248 * set of nodes currently open from the document root to the current element.
249 */
259 static int
268 }
269 }
279 }
282 }
295 XML_ERR_INTERNAL_ERROR,
298 }
299 }
301 }
303 static int
305 xmlElementPtr elemDecl;
314 }
318 else
321 }
324 /*
325 * If regexp are not enabled, it uses a home made algorithm less
326 * complex and easier to
327 * debug/maintain than a generic NFA -> DFA state based algo. The
328 * only restriction is on the deepness of the tree limited by the
329 * size of the occurs bitfield
330 *
331 * this is the content of a saved state for rollbacks
332 */
334 #define ROLLBACK_OR 0
335 #define ROLLBACK_PARENT 1
345 #define MAX_RECURSE 25000
346 #define MAX_DEPTH ((sizeof(_xmlValidState.occurs)) * 8)
347 #define CONT ctxt->vstate->cont
348 #define NODE ctxt->vstate->node
349 #define DEPTH ctxt->vstate->depth
350 #define OCCURS ctxt->vstate->occurs
351 #define STATE ctxt->vstate->state
353 #define OCCURRENCE (ctxt->vstate->occurs & (1 << DEPTH))
354 #define PARENT_OCCURRENCE (ctxt->vstate->occurs & ((1 << DEPTH) - 1))
356 #define SET_OCCURRENCE ctxt->vstate->occurs |= (1 << DEPTH)
357 #define RESET_OCCURRENCE ctxt->vstate->occurs &= ((1 << DEPTH) - 1)
359 static int
367 }
375 }
376 }
385 }
389 }
390 /*
391 * Don't push on the stack a state already here
392 */
405 }
407 static int
418 }
422 static int
424 {
434 }
435 }
443 }
446 }
450 }
451 static xmlNodePtr
453 {
454 xmlNodePtr ret;
461 else
466 }
468 #ifdef DEBUG_VALID_ALGO
469 static void
474 }
536 }
537 }
539 static void
546 }
547 }
549 static void
559 }
561 static void
566 else
581 }
585 }
587 static void
598 }
600 /*****
601 #define DEBUG_VALID_STATE(n,c) xmlValidDebug(n,c);
602 *****/
604 #define DEBUG_VALID_STATE(n,c) xmlValidStateDebug(ctxt);
605 #define DEBUG_VALID_MSG(m) \
608 #else
609 #define DEBUG_VALID_STATE(n,c)
610 #define DEBUG_VALID_MSG(m)
611 #endif
613 /* TODO: use hash table for accesses to elem and attribute definitions */
616 #define CHECK_DTD \
617 if (doc == NULL) return(0); \
618 else if ((doc->intSubset == NULL) && \
619 (doc->extSubset == NULL)) return(0)
621 #ifdef LIBXML_REGEXP_ENABLED
623 /************************************************************************
624 * *
625 * Content model validation based on the regexps *
626 * *
627 ************************************************************************/
629 /**
630 * xmlValidBuildAContentModel:
631 * @content: the content model
632 * @ctxt: the schema parser context
633 * @name: the element name whose content is being built
634 *
635 * Generate the automata sequence needed for that type
636 *
637 * Returns 1 if successful or 0 in case of error.
638 */
639 static int
641 xmlValidCtxtPtr ctxt,
648 }
665 }
689 }
693 }
696 xmlElementContentOccur ocur;
698 /*
699 * Simply iterate over the content
700 */
706 }
728 }
730 }
733 xmlElementContentOccur ocur;
740 }
744 /*
745 * iterate over the subtypes and remerge the end with an
746 * epsilon transition
747 */
772 }
774 }
780 }
782 }
783 /**
784 * xmlValidBuildContentModel:
785 * @ctxt: a validation context
786 * @elem: an element declaration node
787 *
788 * (Re)Build the automata associated to the content model of this
789 * element
790 *
791 * Returns 1 in case of success, 0 in case of error
792 */
793 int
802 /* TODO: should we rebuild in this case ? */
807 }
809 }
814 XML_ERR_INTERNAL_ERROR,
818 }
828 XML_DTD_CONTENT_NOT_DETERMINIST,
831 #ifdef DEBUG_REGEXP_ALGO
833 #endif
839 }
844 }
848 /****************************************************************
849 * *
850 * Util functions for data allocation/deallocation *
851 * *
852 ****************************************************************/
854 /**
855 * xmlNewValidCtxt:
856 *
857 * Allocate a validation context structure.
858 *
859 * Returns NULL if not, otherwise the new validation context structure
860 */
862 xmlValidCtxtPtr ret;
867 }
872 }
874 /**
875 * xmlFreeValidCtxt:
876 * @cur: the validation context to free
877 *
878 * Free a validation context structure.
879 */
880 void
889 }
893 /**
894 * xmlNewDocElementContent:
895 * @doc: the document
896 * @name: the subelement name or NULL
897 * @type: the type of element content decl
898 *
899 * Allocate an element content structure for the document.
900 *
901 * Returns NULL if not, otherwise the new element content structure
902 */
903 xmlElementContentPtr
905 xmlElementContentType type) {
906 xmlElementContentPtr ret;
917 NULL);
918 }
926 NULL);
927 }
932 NULL);
934 }
939 }
951 else
960 }
961 }
962 }
964 }
966 /**
967 * xmlNewElementContent:
968 * @name: the subelement name or NULL
969 * @type: the type of element content decl
970 *
971 * Allocate an element content structure.
972 * Deprecated in favor of xmlNewDocElementContent
973 *
974 * Returns NULL if not, otherwise the new element content structure
975 */
976 xmlElementContentPtr
979 }
981 /**
982 * xmlCopyDocElementContent:
983 * @doc: the document owning the element declaration
984 * @cur: An element content pointer.
985 *
986 * Build a copy of an element content description.
987 *
988 * Returns the new xmlElementContentPtr or NULL in case of error.
989 */
990 xmlElementContentPtr
1004 }
1011 else
1013 }
1018 else
1020 }
1033 }
1042 else
1044 }
1049 else
1051 }
1058 }
1059 }
1061 }
1063 /**
1064 * xmlCopyElementContent:
1065 * @cur: An element content pointer.
1066 *
1067 * Build a copy of an element content description.
1068 * Deprecated, use xmlCopyDocElementContent instead
1069 *
1070 * Returns the new xmlElementContentPtr or NULL in case of error.
1071 */
1072 xmlElementContentPtr
1075 }
1077 /**
1078 * xmlFreeDocElementContent:
1079 * @doc: the document owning the element declaration
1080 * @cur: the element content tree to free
1081 *
1082 * Free an element content structure. The whole subtree is removed.
1083 */
1084 void
1095 xmlElementContentPtr parent;
1100 }
1111 NULL);
1113 }
1122 }
1127 }
1130 else
1139 }
1140 }
1141 }
1143 /**
1144 * xmlFreeElementContent:
1145 * @cur: the element content tree to free
1146 *
1147 * Free an element content structure. The whole subtree is removed.
1148 * Deprecated, use xmlFreeDocElementContent instead
1149 */
1150 void
1153 }
1155 #ifdef LIBXML_OUTPUT_ENABLED
1156 /**
1157 * xmlDumpElementOccur:
1158 * @buf: An XML buffer
1159 * @cur: An element table
1160 *
1161 * Dump the occurrence operator of an element.
1162 */
1163 static void
1177 }
1178 }
1180 /**
1181 * xmlDumpElementContent:
1182 * @buf: An XML buffer
1183 * @content: An element table
1184 *
1185 * This will dump the content of the element table as an XML DTD definition
1186 */
1187 static void
1189 xmlElementContentPtr cur;
1207 }
1222 NULL);
1223 }
1245 }
1248 }
1253 }
1255 /**
1256 * xmlSprintfElementContent:
1257 * @buf: an output buffer
1258 * @content: An element table
1259 * @englob: 1 if one must print the englobing parenthesis, 0 otherwise
1260 *
1261 * Deprecated, unsafe, use xmlSnprintfElementContent
1262 */
1263 void
1265 xmlElementContentPtr content ATTRIBUTE_UNUSED,
1267 }
1270 /**
1271 * xmlSnprintfElementContent:
1272 * @buf: an output buffer
1273 * @size: the buffer size
1274 * @content: An element table
1275 * @englob: 1 if one must print the englobing parenthesis, 0 otherwise
1276 *
1277 * This will dump the content of the element content definition
1278 * Intended just for the debug routine
1279 */
1280 void
1290 }
1304 }
1308 }
1312 }
1317 else
1324 }
1330 else
1337 else
1344 }
1350 else
1353 }
1369 }
1370 }
1372 /****************************************************************
1373 * *
1374 * Registration of DTD declarations *
1375 * *
1376 ****************************************************************/
1378 /**
1379 * xmlFreeElement:
1380 * @elem: An element
1381 *
1382 * Deallocate the memory used by an element definition
1383 */
1384 static void
1393 #ifdef LIBXML_REGEXP_ENABLED
1396 #endif
1398 }
1401 /**
1402 * xmlAddElementDecl:
1403 * @ctxt: the validation context
1404 * @dtd: pointer to the DTD
1405 * @name: the entity name
1406 * @type: the element type
1407 * @content: the element content tree or NULL
1408 *
1409 * Register a new element declaration
1410 *
1411 * Returns NULL if not, otherwise the entity
1412 */
1413 xmlElementPtr
1416 xmlElementTypeVal type,
1417 xmlElementContentPtr content) {
1418 xmlElementPtr ret;
1419 xmlElementTablePtr table;
1425 }
1428 }
1435 NULL);
1437 }
1443 NULL);
1445 }
1451 NULL);
1453 }
1459 NULL);
1461 }
1466 NULL);
1468 }
1470 /*
1471 * check if name is a QName
1472 */
1477 /*
1478 * Create the Element table if needed.
1479 */
1488 }
1497 }
1499 /*
1500 * lookup old attributes inserted on an undefined element in the
1501 * internal subset.
1502 */
1510 }
1511 }
1513 /*
1514 * The element may already be present if one of its attribute
1515 * was registered first
1516 */
1520 #ifdef LIBXML_VALID_ENABLED
1521 /*
1522 * The element is already defined in this DTD.
1523 */
1533 }
1537 }
1547 }
1551 /*
1552 * fill the structure.
1553 */
1563 }
1566 /*
1567 * Validity Check:
1568 * Insertion must not fail
1569 */
1571 #ifdef LIBXML_VALID_ENABLED
1572 /*
1573 * The element is already defined in this DTD.
1574 */
1583 }
1584 /*
1585 * For new element, may have attributes from earlier
1586 * definition in internal subset
1587 */
1589 }
1591 /*
1592 * Finish to fill the structure.
1593 */
1595 /*
1596 * Avoid a stupid copy when called by the parser
1597 * and flag it by setting a special parent value
1598 * so the parser doesn't unallocate it.
1599 */
1606 }
1608 /*
1609 * Link it to the DTD
1610 */
1619 }
1623 }
1625 static void
1628 }
1630 /**
1631 * xmlFreeElementTable:
1632 * @table: An element table
1633 *
1634 * Deallocate the memory used by an element hash table.
1635 */
1636 void
1639 }
1641 #ifdef LIBXML_TREE_ENABLED
1642 /**
1643 * xmlCopyElement:
1644 * @elem: An element
1645 *
1646 * Build a copy of an element.
1647 *
1648 * Returns the new xmlElementPtr or NULL in case of error.
1649 */
1653 xmlElementPtr cur;
1659 }
1665 else
1669 else
1672 /* TODO : rebuild the attribute list on the copy */
1675 }
1677 /**
1678 * xmlCopyElementTable:
1679 * @table: An element table
1680 *
1681 * Build a copy of an element table.
1682 *
1683 * Returns the new xmlElementTablePtr or NULL in case of error.
1684 */
1685 xmlElementTablePtr
1688 }
1691 #ifdef LIBXML_OUTPUT_ENABLED
1692 /**
1693 * xmlDumpElementDecl:
1694 * @buf: the XML buffer output
1695 * @elem: An element table
1696 *
1697 * This will dump the content of the element declaration as an XML
1698 * DTD definition
1699 */
1700 void
1710 }
1719 }
1728 }
1739 }
1748 NULL);
1749 }
1750 }
1752 /**
1753 * xmlDumpElementDeclScan:
1754 * @elem: An element table
1755 * @buf: the XML buffer output
1756 *
1757 * This routine is used by the hash scan function. It just reverses
1758 * the arguments.
1759 */
1760 static void
1764 }
1766 /**
1767 * xmlDumpElementTable:
1768 * @buf: the XML buffer output
1769 * @table: An element table
1770 *
1771 * This will dump the content of the element table as an XML DTD definition
1772 */
1773 void
1778 }
1781 /**
1782 * xmlCreateEnumeration:
1783 * @name: the enumeration name or NULL
1784 *
1785 * create and initialize an enumeration attribute node.
1786 *
1787 * Returns the xmlEnumerationPtr just created or NULL in case
1788 * of error.
1789 */
1790 xmlEnumerationPtr
1792 xmlEnumerationPtr ret;
1798 }
1804 }
1806 /**
1807 * xmlFreeEnumeration:
1808 * @cur: the tree to free.
1809 *
1810 * free an enumeration attribute node (recursive).
1811 */
1812 void
1820 }
1822 #ifdef LIBXML_TREE_ENABLED
1823 /**
1824 * xmlCopyEnumeration:
1825 * @cur: the tree to copy.
1826 *
1827 * Copy an enumeration attribute node (recursive).
1828 *
1829 * Returns the xmlEnumerationPtr just created or NULL in case
1830 * of error.
1831 */
1832 xmlEnumerationPtr
1834 xmlEnumerationPtr ret;
1844 }
1847 #ifdef LIBXML_OUTPUT_ENABLED
1848 /**
1849 * xmlDumpEnumeration:
1850 * @buf: the XML buffer output
1851 * @enum: An enumeration
1852 *
1853 * This will dump the content of the enumeration
1854 */
1855 static void
1866 }
1867 }
1870 #ifdef LIBXML_VALID_ENABLED
1871 /**
1872 * xmlScanIDAttributeDecl:
1873 * @ctxt: the validation context
1874 * @elem: the element name
1875 * @err: whether to raise errors here
1876 *
1877 * Verify that the element don't have too many ID attributes
1878 * declared.
1879 *
1880 * Returns the number of ID attributes found.
1881 */
1882 static int
1884 xmlAttributePtr cur;
1891 ret ++;
1896 }
1898 }
1900 }
1903 /**
1904 * xmlFreeAttribute:
1905 * @elem: An attribute
1906 *
1907 * Deallocate the memory used by an attribute definition
1908 */
1909 static void
1911 xmlDictPtr dict;
1916 else
1940 }
1942 }
1945 /**
1946 * xmlAddAttributeDecl:
1947 * @ctxt: the validation context
1948 * @dtd: pointer to the DTD
1949 * @elem: the element name
1950 * @name: the attribute name
1951 * @ns: the attribute namespace prefix
1952 * @type: the attribute type
1953 * @def: the attribute default type
1954 * @defaultValue: the attribute default value
1955 * @tree: if it's an enumeration, the associated list
1956 *
1957 * Register a new attribute declaration
1958 * Note that @tree becomes the ownership of the DTD
1959 *
1960 * Returns NULL if not new, otherwise the attribute decl
1961 */
1962 xmlAttributePtr
1968 xmlAttributePtr ret;
1969 xmlAttributeTablePtr table;
1970 xmlElementPtr elemDef;
1976 }
1980 }
1984 }
1988 #ifdef LIBXML_VALID_ENABLED
1989 /*
1990 * Check the type and possibly the default value.
1991 */
2016 NULL);
2019 }
2028 }
2031 /*
2032 * Check first that an attribute defined in the external subset wasn't
2033 * already defined in the internal subset
2034 */
2042 }
2043 }
2045 /*
2046 * Create the Attribute table if needed.
2047 */
2052 }
2058 }
2066 }
2070 /*
2071 * fill the structure.
2072 */
2074 /*
2075 * doc must be set before possible error causes call
2076 * to xmlFreeAttribute (because it's used to check on
2077 * dict use)
2078 */
2088 }
2094 else
2096 }
2098 /*
2099 * Validity Check:
2100 * Search the DTD for previous declarations of the ATTLIST
2101 */
2103 #ifdef LIBXML_VALID_ENABLED
2104 /*
2105 * The attribute is already defined in this DTD.
2106 */
2113 }
2115 /*
2116 * Validity Check:
2117 * Multiple ID per element
2118 */
2122 #ifdef LIBXML_VALID_ENABLED
2130 }
2133 /*
2134 * Insert namespace default def first they need to be
2135 * processed first.
2136 */
2152 }
2159 }
2160 }
2161 }
2163 /*
2164 * Link it to the DTD
2165 */
2173 }
2175 }
2177 static void
2180 }
2182 /**
2183 * xmlFreeAttributeTable:
2184 * @table: An attribute table
2185 *
2186 * Deallocate the memory used by an entities hash table.
2187 */
2188 void
2191 }
2193 #ifdef LIBXML_TREE_ENABLED
2194 /**
2195 * xmlCopyAttribute:
2196 * @attr: An attribute
2197 *
2198 * Build a copy of an attribute.
2199 *
2200 * Returns the new xmlAttributePtr or NULL in case of error.
2201 */
2205 xmlAttributePtr cur;
2211 }
2226 }
2228 /**
2229 * xmlCopyAttributeTable:
2230 * @table: An attribute table
2231 *
2232 * Build a copy of an attribute table.
2233 *
2234 * Returns the new xmlAttributeTablePtr or NULL in case of error.
2235 */
2236 xmlAttributeTablePtr
2239 }
2242 #ifdef LIBXML_OUTPUT_ENABLED
2243 /**
2244 * xmlDumpAttributeDecl:
2245 * @buf: the XML buffer output
2246 * @attr: An attribute declaration
2247 *
2248 * This will dump the content of the attribute declaration as an XML
2249 * DTD definition
2250 */
2251 void
2261 }
2299 NULL);
2300 }
2316 NULL);
2317 }
2321 }
2323 }
2325 /**
2326 * xmlDumpAttributeDeclScan:
2327 * @attr: An attribute declaration
2328 * @buf: the XML buffer output
2329 *
2330 * This is used with the hash scan function - just reverses arguments
2331 */
2332 static void
2336 }
2338 /**
2339 * xmlDumpAttributeTable:
2340 * @buf: the XML buffer output
2341 * @table: An attribute table
2342 *
2343 * This will dump the content of the attribute table as an XML DTD definition
2344 */
2345 void
2350 }
2353 /************************************************************************
2354 * *
2355 * NOTATIONs *
2356 * *
2357 ************************************************************************/
2358 /**
2359 * xmlFreeNotation:
2360 * @not: A notation
2361 *
2362 * Deallocate the memory used by an notation definition
2363 */
2364 static void
2374 }
2377 /**
2378 * xmlAddNotationDecl:
2379 * @dtd: pointer to the DTD
2380 * @ctxt: the validation context
2381 * @name: the entity name
2382 * @PublicID: the public identifier or NULL
2383 * @SystemID: the system identifier or NULL
2384 *
2385 * Register a new notation declaration
2386 *
2387 * Returns NULL if not, otherwise the entity
2388 */
2389 xmlNotationPtr
2393 xmlNotationPtr ret;
2394 xmlNotationTablePtr table;
2398 }
2401 }
2404 }
2406 /*
2407 * Create the Notation table if needed.
2408 */
2416 }
2421 }
2427 }
2430 /*
2431 * fill the structure.
2432 */
2439 /*
2440 * Validity Check:
2441 * Check the DTD for previous declarations of the ATTLIST
2442 */
2444 #ifdef LIBXML_VALID_ENABLED
2451 }
2453 }
2455 static void
2458 }
2460 /**
2461 * xmlFreeNotationTable:
2462 * @table: An notation table
2463 *
2464 * Deallocate the memory used by an entities hash table.
2465 */
2466 void
2469 }
2471 #ifdef LIBXML_TREE_ENABLED
2472 /**
2473 * xmlCopyNotation:
2474 * @nota: A notation
2475 *
2476 * Build a copy of a notation.
2477 *
2478 * Returns the new xmlNotationPtr or NULL in case of error.
2479 */
2483 xmlNotationPtr cur;
2489 }
2492 else
2496 else
2500 else
2503 }
2505 /**
2506 * xmlCopyNotationTable:
2507 * @table: A notation table
2508 *
2509 * Build a copy of a notation table.
2510 *
2511 * Returns the new xmlNotationTablePtr or NULL in case of error.
2512 */
2513 xmlNotationTablePtr
2516 }
2519 #ifdef LIBXML_OUTPUT_ENABLED
2520 /**
2521 * xmlDumpNotationDecl:
2522 * @buf: the XML buffer output
2523 * @nota: A notation declaration
2524 *
2525 * This will dump the content the notation declaration as an XML DTD definition
2526 */
2527 void
2539 }
2543 }
2545 }
2547 /**
2548 * xmlDumpNotationDeclScan:
2549 * @nota: A notation declaration
2550 * @buf: the XML buffer output
2551 *
2552 * This is called with the hash scan function, and just reverses args
2553 */
2554 static void
2558 }
2560 /**
2561 * xmlDumpNotationTable:
2562 * @buf: the XML buffer output
2563 * @table: A notation table
2564 *
2565 * This will dump the content of the notation table as an XML DTD definition
2566 */
2567 void
2572 }
2575 /************************************************************************
2576 * *
2577 * IDs *
2578 * *
2579 ************************************************************************/
2580 /**
2581 * DICT_FREE:
2582 * @str: a string
2583 *
2584 * Free a string if it is not owned by the "dict" dictionary in the
2585 * current scope
2586 */
2587 #define DICT_FREE(str) \
2588 if ((str) && ((!dict) || \
2589 (xmlDictOwns(dict, (const xmlChar *)(str)) == 0))) \
2590 xmlFree((char *)(str));
2592 /**
2593 * xmlValidNormalizeString:
2594 * @str: a string
2595 *
2596 * Normalize a string in-place.
2597 */
2598 static void
2616 }
2617 }
2619 }
2621 static int
2623 xmlParserCtxtPtr pctxt;
2631 }
2633 /**
2634 * xmlFreeID:
2635 * @not: A id
2636 *
2637 * Deallocate the memory used by an id definition
2638 */
2639 static void
2653 }
2656 /**
2657 * xmlAddID:
2658 * @ctxt: the validation context
2659 * @doc: pointer to the document
2660 * @value: the value name
2661 * @attr: the attribute holding the ID
2662 *
2663 * Register a new id declaration
2664 *
2665 * Returns NULL if not, otherwise the new xmlIDPtr
2666 */
2667 xmlIDPtr
2669 xmlAttrPtr attr) {
2670 xmlIDPtr ret;
2671 xmlIDTablePtr table;
2675 }
2678 }
2681 }
2683 /*
2684 * Create the ID table if needed.
2685 */
2689 }
2694 }
2700 }
2702 /*
2703 * fill the structure.
2704 */
2708 /*
2709 * Operating in streaming mode, attr is gonna disappear
2710 */
2713 else
2719 }
2723 #ifdef LIBXML_VALID_ENABLED
2724 /*
2725 * The id is already defined in this DTD.
2726 */
2730 }
2734 }
2738 }
2740 static void
2743 }
2745 /**
2746 * xmlFreeIDTable:
2747 * @table: An id table
2748 *
2749 * Deallocate the memory used by an ID hash table.
2750 */
2751 void
2754 }
2756 /**
2757 * xmlIsID:
2758 * @doc: the document
2759 * @elem: the element carrying the attribute
2760 * @attr: the attribute
2761 *
2762 * Determine whether an attribute is of type ID. In case we have DTD(s)
2763 * then this is done if DTD loading has been requested. In the case
2764 * of HTML documents parsed with the HTML parser, then ID detection is
2765 * done systematically.
2766 *
2767 * Returns 0 or 1 depending on the lookup result
2768 */
2769 int
2804 fullattrname);
2807 fullattrname);
2808 }
2817 }
2819 }
2821 /**
2822 * xmlRemoveID:
2823 * @doc: the document
2824 * @attr: the attribute
2825 *
2826 * Remove the given attribute from the ID table maintained internally.
2827 *
2828 * Returns -1 if the lookup failed and 0 otherwise
2829 */
2830 int
2832 xmlIDTablePtr table;
2833 xmlIDPtr id;
2852 }
2858 }
2860 /**
2861 * xmlGetID:
2862 * @doc: pointer to the document
2863 * @ID: the ID value
2864 *
2865 * Search the attribute declaring the given ID
2866 *
2867 * Returns NULL if not found, otherwise the xmlAttrPtr defining the ID
2868 */
2869 xmlAttrPtr
2871 xmlIDTablePtr table;
2872 xmlIDPtr id;
2876 }
2880 }
2890 /*
2891 * We are operating on a stream, return a well known reference
2892 * since the attribute node doesn't exist anymore
2893 */
2895 }
2897 }
2899 /************************************************************************
2900 * *
2901 * Refs *
2902 * *
2903 ************************************************************************/
2905 {
2906 xmlListPtr l;
2907 xmlAttrPtr ap;
2913 {
2914 xmlValidCtxtPtr ctxt;
2920 /**
2921 * xmlFreeRef:
2922 * @lk: A list link
2923 *
2924 * Deallocate the memory used by a ref definition
2925 */
2926 static void
2935 }
2937 /**
2938 * xmlFreeRefTableEntry:
2939 * @list_ref: A list of references.
2940 *
2941 * Deallocate the memory used by a list of references
2942 */
2943 static void
2948 }
2950 /**
2951 * xmlWalkRemoveRef:
2952 * @data: Contents of current link
2953 * @user: Value supplied by the user
2954 *
2955 * Returns 0 to abort the walk or 1 to continue
2956 */
2957 static int
2959 {
2967 }
2969 }
2971 /**
2972 * xmlDummyCompare
2973 * @data0: Value supplied by the user
2974 * @data1: Value supplied by the user
2975 *
2976 * Do nothing, return 0. Used to create unordered lists.
2977 */
2978 static int
2981 {
2983 }
2985 /**
2986 * xmlAddRef:
2987 * @ctxt: the validation context
2988 * @doc: pointer to the document
2989 * @value: the value name
2990 * @attr: the attribute holding the Ref
2991 *
2992 * DEPRECATED, do not use. This function will be removed from the public API.
2993 *
2994 * Register a new ref declaration
2995 *
2996 * Returns NULL if not, otherwise the new xmlRefPtr
2997 */
2998 xmlRefPtr
3000 xmlAttrPtr attr) {
3001 xmlRefPtr ret;
3002 xmlRefTablePtr table;
3003 xmlListPtr ref_list;
3007 }
3010 }
3013 }
3015 /*
3016 * Create the Ref table if needed.
3017 */
3021 }
3026 }
3032 }
3034 /*
3035 * fill the structure.
3036 */
3039 /*
3040 * Operating in streaming mode, attr is gonna disappear
3041 */
3047 }
3050 /* To add a reference :-
3051 * References are maintained as a list of references,
3052 * Lookup the entry, if no entry create new nodelist
3053 * Add the owning node to the NodeList
3054 * Return the ref
3055 */
3061 NULL);
3063 }
3068 NULL);
3070 }
3071 }
3075 NULL);
3077 }
3079 failed:
3086 }
3088 }
3090 /**
3091 * xmlFreeRefTable:
3092 * @table: An ref table
3093 *
3094 * DEPRECATED, do not use. This function will be removed from the public API.
3095 *
3096 * Deallocate the memory used by an Ref hash table.
3097 */
3098 void
3101 }
3103 /**
3104 * xmlIsRef:
3105 * @doc: the document
3106 * @elem: the element carrying the attribute
3107 * @attr: the attribute
3108 *
3109 * DEPRECATED, do not use. This function will be removed from the public API.
3110 *
3111 * Determine whether an attribute is of type Ref. In case we have DTD(s)
3112 * then this is simple, otherwise we use an heuristic: name Ref (upper
3113 * or lowercase).
3114 *
3115 * Returns 0 or 1 depending on the lookup result
3116 */
3117 int
3124 }
3129 /* TODO @@@ */
3132 xmlAttributePtr attrDecl;
3144 }
3146 }
3148 /**
3149 * xmlRemoveRef:
3150 * @doc: the document
3151 * @attr: the attribute
3152 *
3153 * DEPRECATED, do not use. This function will be removed from the public API.
3154 *
3155 * Remove the given attribute from the Ref table maintained internally.
3156 *
3157 * Returns -1 if the lookup failed and 0 otherwise
3158 */
3159 int
3161 xmlListPtr ref_list;
3162 xmlRefTablePtr table;
3164 xmlRemoveMemo target;
3181 }
3183 /* At this point, ref_list refers to a list of references which
3184 * have the same key as the supplied attr. Our list of references
3185 * is ordered by reference address and we don't have that information
3186 * here to use when removing. We'll have to walk the list and
3187 * check for a matching attribute, when we find one stop the walk
3188 * and remove the entry.
3189 * The list is ordered by reference, so that means we don't have the
3190 * key. Passing the list and the reference to the walker means we
3191 * will have enough data to be able to remove the entry.
3192 */
3196 /* Remove the supplied attr from our list */
3199 /*If the list is empty then remove the list entry in the hash */
3204 }
3206 /**
3207 * xmlGetRefs:
3208 * @doc: pointer to the document
3209 * @ID: the ID value
3210 *
3211 * DEPRECATED, do not use. This function will be removed from the public API.
3212 *
3213 * Find the set of references for the supplied ID.
3214 *
3215 * Returns NULL if not found, otherwise node set for the ID.
3216 */
3217 xmlListPtr
3219 xmlRefTablePtr table;
3223 }
3227 }
3234 }
3236 /************************************************************************
3237 * *
3238 * Routines for validity checking *
3239 * *
3240 ************************************************************************/
3242 /**
3243 * xmlGetDtdElementDesc:
3244 * @dtd: a pointer to the DtD to search
3245 * @name: the element name
3246 *
3247 * Search the DTD for the description of this element
3248 *
3249 * returns the xmlElementPtr if found or NULL
3250 */
3252 xmlElementPtr
3254 xmlElementTablePtr table;
3255 xmlElementPtr cur;
3270 }
3271 /**
3272 * xmlGetDtdElementDesc2:
3273 * @dtd: a pointer to the DtD to search
3274 * @name: the element name
3275 * @create: create an empty description if not found
3276 *
3277 * Search the DTD for the description of this element
3278 *
3279 * returns the xmlElementPtr if found or NULL
3280 */
3282 static xmlElementPtr
3285 xmlElementTablePtr table;
3286 xmlElementPtr cur;
3298 /*
3299 * Create the Element table if needed.
3300 */
3305 }
3309 }
3310 }
3322 }
3326 /*
3327 * fill the structure.
3328 */
3337 }
3338 }
3339 error:
3343 }
3345 /**
3346 * xmlGetDtdQElementDesc:
3347 * @dtd: a pointer to the DtD to search
3348 * @name: the element name
3349 * @prefix: the element namespace prefix
3350 *
3351 * Search the DTD for the description of this element
3352 *
3353 * returns the xmlElementPtr if found or NULL
3354 */
3356 xmlElementPtr
3359 xmlElementTablePtr table;
3366 }
3368 /**
3369 * xmlGetDtdAttrDesc:
3370 * @dtd: a pointer to the DtD to search
3371 * @elem: the element name
3372 * @name: the attribute name
3373 *
3374 * Search the DTD for the description of this attribute on
3375 * this element.
3376 *
3377 * returns the xmlAttributePtr if found or NULL
3378 */
3380 xmlAttributePtr
3382 xmlAttributeTablePtr table;
3383 xmlAttributePtr cur;
3402 }
3404 /**
3405 * xmlGetDtdQAttrDesc:
3406 * @dtd: a pointer to the DtD to search
3407 * @elem: the element name
3408 * @name: the attribute name
3409 * @prefix: the attribute namespace prefix
3410 *
3411 * Search the DTD for the description of this qualified attribute on
3412 * this element.
3413 *
3414 * returns the xmlAttributePtr if found or NULL
3415 */
3417 xmlAttributePtr
3420 xmlAttributeTablePtr table;
3427 }
3429 /**
3430 * xmlGetDtdNotationDesc:
3431 * @dtd: a pointer to the DtD to search
3432 * @name: the notation name
3433 *
3434 * Search the DTD for the description of this notation
3435 *
3436 * returns the xmlNotationPtr if found or NULL
3437 */
3439 xmlNotationPtr
3441 xmlNotationTablePtr table;
3448 }
3450 #if defined(LIBXML_VALID_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
3451 /**
3452 * xmlValidateNotationUse:
3453 * @ctxt: the validation context
3454 * @doc: the document
3455 * @notationName: the notation name to check
3456 *
3457 * Validate that the given name match a notation declaration.
3458 * - [ VC: Notation Declared ]
3459 *
3460 * returns 1 if valid or 0 otherwise
3461 */
3463 int
3466 xmlNotationPtr notaDecl;
3479 }
3481 }
3484 /**
3485 * xmlIsMixedElement:
3486 * @doc: the document
3487 * @name: the element name
3488 *
3489 * Search in the DtDs whether an element accept Mixed content (or ANY)
3490 * basically if it is supposed to accept text childs
3491 *
3492 * returns 0 if no, 1 if yes, and -1 if no element description is available
3493 */
3495 int
3497 xmlElementPtr elemDecl;
3511 /*
3512 * return 1 for EMPTY since we want VC error to pop up
3513 * on <empty> </empty> for example
3514 */
3518 }
3520 }
3522 #ifdef LIBXML_VALID_ENABLED
3524 static int
3527 /*
3528 * Use the new checks of production [4] [4a] amd [5] of the
3529 * Update 5 of XML-1.0
3530 */
3550 }
3552 }
3554 static int
3557 /*
3558 * Use the new checks of production [4] [4a] amd [5] of the
3559 * Update 5 of XML-1.0
3560 */
3588 }
3590 }
3592 /**
3593 * xmlValidateNameValue:
3594 * @doc: pointer to the document or NULL
3595 * @value: an Name value
3596 *
3597 * Validate that the given value match Name production
3598 *
3599 * returns 1 if valid or 0 otherwise
3600 */
3602 static int
3619 }
3624 }
3626 /**
3627 * xmlValidateNameValue:
3628 * @value: an Name value
3629 *
3630 * Validate that the given value match Name production
3631 *
3632 * returns 1 if valid or 0 otherwise
3633 */
3635 int
3638 }
3640 /**
3641 * xmlValidateNamesValueInternal:
3642 * @doc: pointer to the document or NULL
3643 * @value: an Names value
3644 *
3645 * Validate that the given value match Names production
3646 *
3647 * returns 1 if valid or 0 otherwise
3648 */
3650 static int
3668 }
3670 /* Should not test IS_BLANK(val) here -- see erratum E20*/
3675 }
3686 }
3687 }
3692 }
3694 /**
3695 * xmlValidateNamesValue:
3696 * @value: an Names value
3697 *
3698 * Validate that the given value match Names production
3699 *
3700 * returns 1 if valid or 0 otherwise
3701 */
3703 int
3706 }
3708 /**
3709 * xmlValidateNmtokenValueInternal:
3710 * @doc: pointer to the document or NULL
3711 * @value: an Nmtoken value
3712 *
3713 * Validate that the given value match Nmtoken production
3714 *
3715 * [ VC: Name Token ]
3716 *
3717 * returns 1 if valid or 0 otherwise
3718 */
3720 static int
3738 }
3743 }
3745 /**
3746 * xmlValidateNmtokenValue:
3747 * @value: an Nmtoken value
3748 *
3749 * Validate that the given value match Nmtoken production
3750 *
3751 * [ VC: Name Token ]
3752 *
3753 * returns 1 if valid or 0 otherwise
3754 */
3756 int
3759 }
3761 /**
3762 * xmlValidateNmtokensValueInternal:
3763 * @doc: pointer to the document or NULL
3764 * @value: an Nmtokens value
3765 *
3766 * Validate that the given value match Nmtokens production
3767 *
3768 * [ VC: Name Token ]
3769 *
3770 * returns 1 if valid or 0 otherwise
3771 */
3773 static int
3786 }
3794 }
3796 /* Should not test IS_BLANK(val) here -- see erratum E20*/
3801 }
3813 }
3814 }
3819 }
3821 /**
3822 * xmlValidateNmtokensValue:
3823 * @value: an Nmtokens value
3824 *
3825 * Validate that the given value match Nmtokens production
3826 *
3827 * [ VC: Name Token ]
3828 *
3829 * returns 1 if valid or 0 otherwise
3830 */
3832 int
3835 }
3837 /**
3838 * xmlValidateNotationDecl:
3839 * @ctxt: the validation context
3840 * @doc: a document instance
3841 * @nota: a notation definition
3842 *
3843 * Try to validate a single notation definition
3844 * basically it does the following checks as described by the
3845 * XML-1.0 recommendation:
3846 * - it seems that no validity constraint exists on notation declarations
3847 * But this function get called anyway ...
3848 *
3849 * returns 1 if valid or 0 otherwise
3850 */
3852 int
3854 xmlNotationPtr nota ATTRIBUTE_UNUSED) {
3858 }
3860 /**
3861 * xmlValidateAttributeValueInternal:
3862 * @doc: the document
3863 * @type: an attribute type
3864 * @value: an attribute value
3865 *
3866 * Validate that the given attribute value match the proper production
3867 *
3868 * returns 1 if valid or 0 otherwise
3869 */
3871 static int
3890 }
3892 }
3894 /**
3895 * xmlValidateAttributeValue:
3896 * @type: an attribute type
3897 * @value: an attribute value
3898 *
3899 * Validate that the given attribute value match the proper production
3900 *
3901 * [ VC: ID ]
3902 * Values of type ID must match the Name production....
3903 *
3904 * [ VC: IDREF ]
3905 * Values of type IDREF must match the Name production, and values
3906 * of type IDREFS must match Names ...
3907 *
3908 * [ VC: Entity Name ]
3909 * Values of type ENTITY must match the Name production, values
3910 * of type ENTITIES must match Names ...
3911 *
3912 * [ VC: Name Token ]
3913 * Values of type NMTOKEN must match the Nmtoken production; values
3914 * of type NMTOKENS must match Nmtokens.
3915 *
3916 * returns 1 if valid or 0 otherwise
3917 */
3918 int
3921 }
3923 /**
3924 * xmlValidateAttributeValue2:
3925 * @ctxt: the validation context
3926 * @doc: the document
3927 * @name: the attribute name (used for error reporting only)
3928 * @type: the attribute type
3929 * @value: the attribute value
3930 *
3931 * Validate that the given attribute value match a given type.
3932 * This typically cannot be done before having finished parsing
3933 * the subsets.
3934 *
3935 * [ VC: IDREF ]
3936 * Values of type IDREF must match one of the declared IDs
3937 * Values of type IDREFS must match a sequence of the declared IDs
3938 * each Name must match the value of an ID attribute on some element
3939 * in the XML document; i.e. IDREF values must match the value of
3940 * some ID attribute
3941 *
3942 * [ VC: Entity Name ]
3943 * Values of type ENTITY must match one declared entity
3944 * Values of type ENTITIES must match a sequence of declared entities
3945 *
3946 * [ VC: Notation Attributes ]
3947 * all notation names in the declaration must be declared.
3948 *
3949 * returns 1 if valid or 0 otherwise
3950 */
3952 static int
3966 xmlEntityPtr ent;
3969 /* yeah it's a bit messy... */
3973 }
3976 XML_DTD_UNKNOWN_ENTITY,
3982 XML_DTD_ENTITY_TYPE,
3986 }
3988 }
3991 xmlEntityPtr ent;
4005 XML_DTD_UNKNOWN_ENTITY,
4011 XML_DTD_ENTITY_TYPE,
4015 }
4020 }
4023 }
4025 xmlNotationPtr nota;
4033 XML_DTD_UNKNOWN_NOTATION,
4037 }
4039 }
4040 }
4042 }
4044 /**
4045 * xmlValidCtxtNormalizeAttributeValue:
4046 * @ctxt: the validation context
4047 * @doc: the document
4048 * @elem: the parent
4049 * @name: the attribute name
4050 * @value: the attribute value
4051 * @ctxt: the validation context or NULL
4052 *
4053 * Does the validation related extra step of the normalization of attribute
4054 * values:
4055 *
4056 * If the declared value is not CDATA, then the XML processor must further
4057 * process the normalized attribute value by discarding any leading and
4058 * trailing space (#x20) characters, and by replacing sequences of space
4059 * (#x20) characters by single space (#x20) character.
4060 *
4061 * Also check VC: Standalone Document Declaration in P32, and update
4062 * ctxt->valid accordingly
4063 *
4064 * returns a new normalized string if normalization is needed, NULL otherwise
4065 * the caller must free the returned value.
4066 */
4068 xmlChar *
4092 }
4095 }
4102 }
4118 }
4120 }
4122 /**
4123 * xmlValidNormalizeAttributeValue:
4124 * @doc: the document
4125 * @elem: the parent
4126 * @name: the attribute name
4127 * @value: the attribute value
4128 *
4129 * Does the validation related extra step of the normalization of attribute
4130 * values:
4131 *
4132 * If the declared value is not CDATA, then the XML processor must further
4133 * process the normalized attribute value by discarding any leading and
4134 * trailing space (#x20) characters, and by replacing sequences of space
4135 * (#x20) characters by single space (#x20) character.
4136 *
4137 * Returns a new normalized string if normalization is needed, NULL otherwise
4138 * the caller must free the returned value.
4139 */
4141 xmlChar *
4161 }
4176 }
4178 static void
4184 }
4186 /**
4187 * xmlValidateAttributeDecl:
4188 * @ctxt: the validation context
4189 * @doc: a document instance
4190 * @attr: an attribute definition
4191 *
4192 * Try to validate a single attribute definition
4193 * basically it does the following checks as described by the
4194 * XML-1.0 recommendation:
4195 * - [ VC: Attribute Default Legal ]
4196 * - [ VC: Enumeration ]
4197 * - [ VC: ID Attribute Default ]
4198 *
4199 * The ID/IDREF uniqueness and matching are done separately
4200 *
4201 * returns 1 if valid or 0 otherwise
4202 */
4204 int
4206 xmlAttributePtr attr) {
4209 CHECK_DTD;
4212 /* Attribute Default Legal */
4213 /* Enumeration */
4221 }
4223 }
4225 /* ID Attribute Default */
4233 }
4235 /* One ID per Element Type */
4239 /* the trick is that we parse DtD as their own internal subset */
4245 xmlAttributeTablePtr table;
4247 /*
4248 * The attribute may be declared in the internal subset and the
4249 * element in the external subset.
4250 */
4256 }
4257 }
4268 }
4277 }
4278 }
4279 }
4281 /* Validity Constraint: Enumeration */
4287 }
4293 }
4294 }
4297 }
4299 /**
4300 * xmlValidateElementDecl:
4301 * @ctxt: the validation context
4302 * @doc: a document instance
4303 * @elem: an element definition
4304 *
4305 * Try to validate a single element definition
4306 * basically it does the following checks as described by the
4307 * XML-1.0 recommendation:
4308 * - [ VC: One ID per Element Type ]
4309 * - [ VC: No Duplicate Types ]
4310 * - [ VC: Unique Element Type Declaration ]
4311 *
4312 * returns 1 if valid or 0 otherwise
4313 */
4315 int
4317 xmlElementPtr elem) {
4319 xmlElementPtr tst;
4321 CHECK_DTD;
4325 #if 0
4326 #ifdef LIBXML_REGEXP_ENABLED
4327 /* Build the regexp associated to the content model */
4329 #endif
4330 #endif
4332 /* No Duplicate Types */
4356 }
4358 }
4360 }
4373 }
4375 }
4377 }
4378 }
4380 }
4381 }
4383 /* VC: Unique Element Type Declaration */
4393 }
4403 }
4404 /* One ID per Element Type
4405 * already done when registering the attribute
4406 if (xmlScanIDAttributeDecl(ctxt, elem) > 1) {
4407 ret = 0;
4408 } */
4410 }
4412 /**
4413 * xmlValidateOneAttribute:
4414 * @ctxt: the validation context
4415 * @doc: a document instance
4416 * @elem: an element instance
4417 * @attr: an attribute instance
4418 * @value: the attribute value (without entities processing)
4419 *
4420 * Try to validate a single attribute for an element
4421 * basically it does the following checks as described by the
4422 * XML-1.0 recommendation:
4423 * - [ VC: Attribute Value Type ]
4424 * - [ VC: Fixed Attribute Default ]
4425 * - [ VC: Entity Name ]
4426 * - [ VC: Name Token ]
4427 * - [ VC: ID ]
4428 * - [ VC: IDREF ]
4429 * - [ VC: Entity Name ]
4430 * - [ VC: Notation Attributes ]
4431 *
4432 * The ID/IDREF uniqueness and matching are done separately
4433 *
4434 * returns 1 if valid or 0 otherwise
4435 */
4437 int
4440 {
4445 CHECK_DTD;
4467 }
4470 }
4484 }
4485 }
4488 /* Validity Constraint: Attribute Value Type */
4494 }
4503 }
4505 /* Validity constraint: Fixed Attribute Default */
4512 }
4513 }
4515 /* Validity Constraint: ID uniqueness */
4519 }
4525 }
4527 /* Validity Constraint: Notation Attributes */
4530 xmlNotationPtr nota;
4532 /* First check that the given NOTATION was declared */
4542 }
4544 /* Second, verify that it's among the list */
4548 }
4554 }
4555 }
4557 /* Validity Constraint: Enumeration */
4563 }
4569 }
4570 }
4572 /* Fixed Attribute Default */
4579 }
4581 /* Extra check for the attribute value */
4586 }
4588 /**
4589 * xmlValidateOneNamespace:
4590 * @ctxt: the validation context
4591 * @doc: a document instance
4592 * @elem: an element instance
4593 * @prefix: the namespace prefix
4594 * @ns: an namespace declaration instance
4595 * @value: the attribute value (without entities processing)
4596 *
4597 * Try to validate a single namespace declaration for an element
4598 * basically it does the following checks as described by the
4599 * XML-1.0 recommendation:
4600 * - [ VC: Attribute Value Type ]
4601 * - [ VC: Fixed Attribute Default ]
4602 * - [ VC: Entity Name ]
4603 * - [ VC: Name Token ]
4604 * - [ VC: ID ]
4605 * - [ VC: IDREF ]
4606 * - [ VC: Entity Name ]
4607 * - [ VC: Notation Attributes ]
4608 *
4609 * The ID/IDREF uniqueness and matching are done separately
4610 *
4611 * returns 1 if valid or 0 otherwise
4612 */
4614 int
4617 /* xmlElementPtr elemDecl; */
4622 CHECK_DTD;
4634 }
4647 }
4650 }
4664 }
4665 }
4668 /* Validity Constraint: Attribute Value Type */
4678 }
4680 }
4692 }
4694 }
4696 /* Validity constraint: Fixed Attribute Default */
4707 }
4709 }
4710 }
4712 /*
4713 * Casting ns to xmlAttrPtr is wrong. We'd need separate functions
4714 * xmlAddID and xmlAddRef for namespace declarations, but it makes
4715 * no practical sense to use ID types anyway.
4716 */
4717 #if 0
4718 /* Validity Constraint: ID uniqueness */
4722 }
4728 }
4729 #endif
4731 /* Validity Constraint: Notation Attributes */
4734 xmlNotationPtr nota;
4736 /* First check that the given NOTATION was declared */
4750 }
4752 }
4754 /* Second, verify that it's among the list */
4758 }
4768 }
4770 }
4771 }
4773 /* Validity Constraint: Enumeration */
4779 }
4789 }
4791 }
4792 }
4794 /* Fixed Attribute Default */
4805 }
4807 }
4809 /* Extra check for the attribute value */
4816 }
4819 }
4821 #ifndef LIBXML_REGEXP_ENABLED
4822 /**
4823 * xmlValidateSkipIgnorable:
4824 * @ctxt: the validation context
4825 * @child: the child list
4826 *
4827 * Skip ignorable elements w.r.t. the validation process
4828 *
4829 * returns the first element to consider for validation of the content model
4830 */
4832 static xmlNodePtr
4836 /* These things are ignored (skipped) during validation. */
4846 else
4849 /* keep current node */
4852 }
4853 }
4855 }
4857 /**
4858 * xmlValidateElementType:
4859 * @ctxt: the validation context
4860 *
4861 * Try to validate the content model of an element internal function
4862 *
4863 * returns 1 if valid or 0 ,-1 in case of error, -2 if an entity
4864 * reference is found and -3 if the validation succeeded but
4865 * the content model is not determinist.
4866 */
4868 static int
4880 }
4885 /*
4886 * We arrive here when more states need to be examined
4887 */
4888 cont:
4890 /*
4891 * We just recovered from a rollback generated by a possible
4892 * epsilon transition, go directly to the analysis phase
4893 */
4899 }
4902 /*
4903 * we may have to save a backup state here. This is the equivalent
4904 * of handling epsilon transition in NFAs.
4905 */
4916 }
4919 /*
4920 * Check first if the content matches
4921 */
4928 }
4931 /*
4932 * go to next element in the content model
4933 * skipping ignorable elems
4934 */
4951 }
4958 }
4968 }
4969 }
4972 /*
4973 * go to next element in the content model
4974 * skipping ignorable elems
4975 */
4990 }
4993 /*
4994 * Small optimization.
4995 */
4999 DEPTH++;
5002 }
5009 }
5011 DEPTH++;
5014 }
5015 }
5017 /*
5018 * save the second branch 'or' branch
5019 */
5024 DEPTH++;
5028 /*
5029 * Small optimization.
5030 */
5036 DEPTH++;
5039 }
5046 }
5048 DEPTH++;
5051 }
5052 }
5053 DEPTH++;
5056 }
5058 /*
5059 * At this point handle going up in the tree
5060 */
5064 }
5065 analyze:
5067 /*
5068 * First do the analysis depending on the occurrence model at
5069 * this level.
5070 */
5073 xmlNodePtr cur;
5081 }
5092 }
5096 }
5101 #ifdef DEBUG_VALID_ALGO
5106 }
5107 #endif
5114 }
5130 }
5135 }
5137 SET_OCCURRENCE;
5144 }
5149 }
5151 /* SET_OCCURRENCE; */
5153 }
5154 }
5157 /*
5158 * Then act accordingly at the parent level
5159 */
5160 RESET_OCCURRENCE;
5176 DEPTH--;
5180 DEPTH--;
5181 }
5187 DEPTH--;
5195 DEPTH--;
5196 }
5197 }
5198 }
5200 xmlNodePtr cur;
5207 }
5211 }
5213 xmlNodePtr cur;
5220 }
5224 }
5226 }
5227 #endif
5229 /**
5230 * xmlSnprintfElements:
5231 * @buf: an output buffer
5232 * @size: the size of the buffer
5233 * @content: An element
5234 * @glob: 1 if one must print the englobing parenthesis, 0 otherwise
5235 *
5236 * This will dump the list of elements to the buffer
5237 * Intended just for the debug routine
5238 */
5239 static void
5241 xmlNodePtr cur;
5253 }
5261 }
5264 }
5269 }
5277 /* Falls through. */
5305 }
5307 }
5309 }
5311 /**
5312 * xmlValidateElementContent:
5313 * @ctxt: the validation context
5314 * @child: the child list
5315 * @elemDecl: pointer to the element declaration
5316 * @warn: emit the error message
5317 * @parent: the parent element (for error reporting)
5318 *
5319 * Try to validate the content model of an element
5320 *
5321 * returns 1 if valid or 0 if not and -1 in case of error
5322 */
5324 static int
5328 #ifndef LIBXML_REGEXP_ENABLED
5330 #endif
5331 xmlNodePtr cur;
5332 xmlElementContentPtr cont;
5340 #ifdef LIBXML_REGEXP_ENABLED
5341 /* Build the regexp associated to the content model */
5347 xmlRegExecCtxtPtr exec;
5351 }
5361 /*
5362 * Push the current node to be able to roll back
5363 * and process within the entity
5364 */
5370 }
5378 /* TODO */
5391 }
5397 }
5401 }
5402 /*
5403 * Switch to next element
5404 */
5411 }
5412 }
5414 fail:
5416 }
5417 }
5419 /*
5420 * Allocate the stack
5421 */
5428 }
5429 /*
5430 * The first entry in the stack is reserved to the current state
5431 */
5448 XML_DTD_CONTENT_NOT_DETERMINIST,
5452 /*
5453 * An entities reference appeared at this level.
5454 * Build a minimal representation of this node content
5455 * sufficient to run the validation process on it
5456 */
5462 /*
5463 * Push the current node to be able to roll back
5464 * and process within the entity
5465 */
5471 }
5476 /* no break on purpose */
5478 /* no break on purpose */
5480 /*
5481 * Allocate a new node and minimally fills in
5482 * what's required
5483 */
5490 }
5501 }
5503 /*
5504 * E59 spaces in CDATA does not match the
5505 * nonterminal S
5506 */
5508 }
5512 }
5513 /*
5514 * Switch to next element
5515 */
5522 }
5523 }
5525 /*
5526 * Relaunch the validation
5527 */
5536 }
5546 #ifndef LIBXML_REGEXP_ENABLED
5549 else
5561 }
5571 }
5572 }
5574 }
5578 #ifndef LIBXML_REGEXP_ENABLED
5579 done:
5580 /*
5581 * Deallocate the copy if done, and free up the validation stack
5582 */
5587 }
5592 }
5593 #endif
5599 }
5602 }
5604 /**
5605 * xmlValidateCdataElement:
5606 * @ctxt: the validation context
5607 * @doc: a document instance
5608 * @elem: an element instance
5609 *
5610 * Check that an element follows #CDATA
5611 *
5612 * returns 1 if valid or 0 otherwise
5613 */
5614 static int
5616 xmlNodePtr elem) {
5630 /*
5631 * Push the current node to be able to roll back
5632 * and process within the entity
5633 */
5639 }
5649 }
5650 /*
5651 * Switch to next element
5652 */
5659 }
5660 }
5661 done:
5667 }
5669 }
5671 #ifdef LIBXML_REGEXP_ENABLED
5672 /**
5673 * xmlValidateCheckMixed:
5674 * @ctxt: the validation context
5675 * @cont: the mixed content model
5676 * @qname: the qualified name as appearing in the serialization
5677 *
5678 * Check if the given node is part of the content model.
5679 *
5680 * Returns 1 if yes, 0 if no, -1 in case of error
5681 */
5682 static int
5705 NULL);
5707 }
5709 }
5729 NULL);
5731 }
5733 }
5734 }
5736 }
5739 /**
5740 * xmlValidGetElemDecl:
5741 * @ctxt: the validation context
5742 * @doc: a document instance
5743 * @elem: an element instance
5744 * @extsubset: pointer, (out) indicate if the declaration was found
5745 * in the external subset.
5746 *
5747 * Finds a declaration associated to an element in the document.
5748 *
5749 * returns the pointer to the declaration or NULL if not found.
5750 */
5751 static xmlElementPtr
5763 /*
5764 * Fetch the declaration for the qualified name
5765 */
5777 }
5778 }
5780 /*
5781 * Fetch the declaration for the non qualified name
5782 * This is "non-strict" validation should be done on the
5783 * full QName but in that case being flexible makes sense.
5784 */
5791 }
5792 }
5795 XML_DTD_UNKNOWN_ELEM,
5798 }
5800 }
5802 #ifdef LIBXML_REGEXP_ENABLED
5803 /**
5804 * xmlValidatePushElement:
5805 * @ctxt: the validation context
5806 * @doc: a document instance
5807 * @elem: an element instance
5808 * @qname: the qualified name as appearing in the serialization
5809 *
5810 * Push a new element start on the validation stack.
5811 *
5812 * returns 1 if no validation problem was found or 0 otherwise
5813 */
5814 int
5818 xmlElementPtr eDecl;
5823 /* printf("PushElem %s\n", qname); */
5826 xmlElementPtr elemDecl;
5828 /*
5829 * Check the new element against the content model of the new elem.
5830 */
5840 XML_DTD_NOT_EMPTY,
5846 /* I don't think anything is required then */
5849 /* simple case of declared as #PCDATA */
5852 XML_ELEMENT_CONTENT_PCDATA)) {
5854 XML_DTD_NOT_PCDATA,
5860 qname);
5863 XML_DTD_INVALID_CHILD,
5866 }
5867 }
5870 /*
5871 * TODO:
5872 * VC: Standalone Document Declaration
5873 * - element types with element content, if white space
5874 * occurs directly within any instance of those types.
5875 */
5880 XML_DTD_CONTENT_MODEL,
5886 }
5887 }
5889 }
5890 }
5891 }
5895 }
5897 /**
5898 * xmlValidatePushCData:
5899 * @ctxt: the validation context
5900 * @data: some character data read
5901 * @len: the length of the data
5902 *
5903 * check the CData parsed for validation in the current stack
5904 *
5905 * returns 1 if no validation problem was found or 0 otherwise
5906 */
5907 int
5911 /* printf("CDATA %s %d\n", data, len); */
5918 xmlElementPtr elemDecl;
5920 /*
5921 * Check the new element against the content model of the new elem.
5922 */
5932 XML_DTD_NOT_EMPTY,
5947 XML_DTD_CONTENT_MODEL,
5952 }
5953 }
5954 /*
5955 * TODO:
5956 * VC: Standalone Document Declaration
5957 * element types with element content, if white space
5958 * occurs directly within any instance of those types.
5959 */
5961 }
5962 }
5963 }
5964 }
5965 done:
5967 }
5969 /**
5970 * xmlValidatePopElement:
5971 * @ctxt: the validation context
5972 * @doc: a document instance
5973 * @elem: an element instance
5974 * @qname: the qualified name as appearing in the serialization
5975 *
5976 * Pop the element end from the validation stack.
5977 *
5978 * returns 1 if no validation problem was found or 0 otherwise
5979 */
5980 int
5982 xmlNodePtr elem ATTRIBUTE_UNUSED,
5988 /* printf("PopElem %s\n", qname); */
5991 xmlElementPtr elemDecl;
5993 /*
5994 * Check the new element against the content model of the new elem.
5995 */
6004 XML_DTD_CONTENT_MODEL,
6009 /*
6010 * previous validation errors should not generate
6011 * a new one here
6012 */
6014 }
6015 }
6016 }
6017 }
6019 }
6021 }
6024 /**
6025 * xmlValidateOneElement:
6026 * @ctxt: the validation context
6027 * @doc: a document instance
6028 * @elem: an element instance
6029 *
6030 * Try to validate a single element and it's attributes,
6031 * basically it does the following checks as described by the
6032 * XML-1.0 recommendation:
6033 * - [ VC: Element Valid ]
6034 * - [ VC: Required Attribute ]
6035 * Then call xmlValidateOneAttribute() for each attribute present.
6036 *
6037 * The ID/IDREF checkings are done separately
6038 *
6039 * returns 1 if valid or 0 otherwise
6040 */
6042 int
6044 xmlNodePtr elem) {
6046 xmlElementContentPtr cont;
6047 xmlAttributePtr attr;
6048 xmlNodePtr child;
6053 CHECK_DTD;
6067 }
6073 }
6079 }
6113 }
6115 /*
6116 * Fetch the declaration
6117 */
6122 /*
6123 * If vstateNr is not zero that means continuous validation is
6124 * activated, do not try to check the content model at that level.
6125 */
6127 /* Check that the element content matches the definition */
6140 }
6143 /* I don't think anything is required then */
6147 /* simple case of declared as #PCDATA */
6155 }
6157 }
6159 /* Hum, this start to get messy */
6186 NULL);
6188 }
6190 }
6195 }
6209 NULL);
6211 }
6213 }
6219 }
6220 }
6221 child_ok:
6223 }
6227 /*
6228 * VC: Standalone Document Declaration
6229 * - element types with element content, if white space
6230 * occurs directly within any instance of those types.
6231 */
6238 content++;
6241 XML_DTD_STANDALONE_WHITE_SPACE,
6246 }
6247 }
6249 }
6250 }
6257 }
6260 /* [ VC: Required Attribute ] */
6268 xmlNsPtr ns;
6275 }
6277 xmlNsPtr ns;
6284 }
6286 xmlAttrPtr attrib;
6296 /*
6297 * qualified names handling is problematic, having a
6298 * different prefix should be possible but DTDs don't
6299 * allow to define the URI instead of the prefix :-(
6300 */
6311 /*
6312 * We should allow applications to define namespaces
6313 * for their application even if the DTD doesn't
6314 * carry one, otherwise, basically we would always
6315 * break.
6316 */
6318 }
6319 }
6321 }
6322 }
6334 }
6343 }
6345 /*
6346 * Special tests checking #FIXED namespace declarations
6347 * have the right value since this is not done as an
6348 * attribute checking
6349 */
6352 xmlNsPtr ns;
6359 XML_DTD_ELEM_DEFAULT_NAMESPACE,
6363 }
6365 }
6367 }
6369 xmlNsPtr ns;
6379 }
6381 }
6383 }
6384 }
6385 }
6386 found:
6388 }
6390 }
6392 /**
6393 * xmlValidateRoot:
6394 * @ctxt: the validation context
6395 * @doc: a document instance
6396 *
6397 * Try to validate a the root element
6398 * basically it does the following check as described by the
6399 * XML-1.0 recommendation:
6400 * - [ VC: Root Element Type ]
6401 * it doesn't try to recurse or apply other check to the element
6402 *
6403 * returns 1 if valid or 0 otherwise
6404 */
6406 int
6408 xmlNodePtr root;
6418 }
6420 /*
6421 * When doing post validation against a separate DTD, those may
6422 * no internal subset has been generated
6423 */
6426 /*
6427 * Check first the document root against the NQName
6428 */
6438 }
6444 }
6452 }
6453 }
6454 name_ok:
6456 }
6459 /**
6460 * xmlValidateElement:
6461 * @ctxt: the validation context
6462 * @doc: a document instance
6463 * @elem: an element instance
6464 *
6465 * Try to validate the subtree under an element
6466 *
6467 * returns 1 if valid or 0 otherwise
6468 */
6470 int
6472 xmlNodePtr elem;
6473 xmlAttrPtr attr;
6474 xmlNsPtr ns;
6480 CHECK_DTD;
6494 }
6501 else
6506 }
6511 }
6512 }
6520 }
6522 }
6524 done:
6526 }
6528 /**
6529 * xmlValidateRef:
6530 * @ref: A reference to be validated
6531 * @ctxt: Validation context
6532 * @name: Name of ID we are searching for
6533 *
6534 */
6535 static void
6538 xmlAttrPtr id;
6539 xmlAttrPtr attr;
6553 }
6566 }
6571 }
6580 }
6589 }
6602 }
6607 }
6609 }
6610 }
6612 /**
6613 * xmlWalkValidateList:
6614 * @data: Contents of current link
6615 * @user: Value supplied by the user
6616 *
6617 * Returns 0 to abort the walk or 1 to continue
6618 */
6619 static int
6621 {
6625 }
6627 /**
6628 * xmlValidateCheckRefCallback:
6629 * @ref_list: List of references
6630 * @ctxt: Validation context
6631 * @name: Name of ID we are searching for
6632 *
6633 */
6634 static void
6638 xmlValidateMemo memo;
6647 }
6649 /**
6650 * xmlValidateDocumentFinal:
6651 * @ctxt: the validation context
6652 * @doc: a document instance
6653 *
6654 * Does the final step for the document validation once all the
6655 * incremental validation steps have been completed
6656 *
6657 * basically it does the following checks described by the XML Rec
6658 *
6659 * Check all the IDREF/IDREFS attributes definition for validity
6660 *
6661 * returns 1 if valid or 0 otherwise
6662 */
6664 int
6666 xmlRefTablePtr table;
6675 }
6677 /* trick to get correct line id report */
6681 /*
6682 * Check all the NOTATION/NOTATIONS attributes
6683 */
6684 /*
6685 * Check all the ENTITY/ENTITIES attributes definition for validity
6686 */
6687 /*
6688 * Check all the IDREF/IDREFS attributes definition for validity
6689 */
6697 }
6699 /**
6700 * xmlValidateDtd:
6701 * @ctxt: the validation context
6702 * @doc: a document instance
6703 * @dtd: a dtd instance
6704 *
6705 * Try to validate the document against the dtd instance
6706 *
6707 * Basically it does check all the definitions in the DtD.
6708 * Note the the internal subset (if present) is de-coupled
6709 * (i.e. not used), which could give problems if ID or IDREF
6710 * is present.
6711 *
6712 * returns 1 if valid or 0 otherwise
6713 */
6715 int
6719 xmlNodePtr root;
6732 }
6736 }
6740 }
6747 }
6749 static void
6765 }
6766 }
6767 }
6768 }
6770 static void
6776 xmlDocPtr doc;
6799 }
6808 }
6809 }
6810 }
6818 }
6832 }
6838 }
6839 }
6840 }
6842 /**
6843 * xmlValidateDtdFinal:
6844 * @ctxt: the validation context
6845 * @doc: a document instance
6846 *
6847 * Does the final step for the dtds validation once all the
6848 * subsets have been parsed
6849 *
6850 * basically it does the following checks described by the XML Rec
6851 * - check that ENTITY and ENTITIES type attributes default or
6852 * possible values matches one of the defined entities.
6853 * - check that NOTATION type attributes default or
6854 * possible values matches one of the defined notations.
6855 *
6856 * returns 1 if valid or 0 if invalid and -1 if not well-formed
6857 */
6859 int
6861 xmlDtdPtr dtd;
6862 xmlAttributeTablePtr table;
6863 xmlEntitiesTablePtr entities;
6874 }
6878 }
6883 }
6887 }
6889 }
6891 /**
6892 * xmlValidateDocument:
6893 * @ctxt: the validation context
6894 * @doc: a document instance
6895 *
6896 * Try to validate the document instance
6897 *
6898 * basically it does the all the checks described by the XML Rec
6899 * i.e. validates the internal and external subset (if present)
6900 * and validate the document tree.
6901 *
6902 * returns 1 if valid or 0 otherwise
6903 */
6905 int
6908 xmlNodePtr root;
6916 }
6928 }
6944 }
6946 }
6947 }
6952 }
6956 }
6964 }
6966 /************************************************************************
6967 * *
6968 * Routines for dynamic validation editing *
6969 * *
6970 ************************************************************************/
6972 /**
6973 * xmlValidGetPotentialChildren:
6974 * @ctree: an element content tree
6975 * @names: an array to store the list of child names
6976 * @len: a pointer to the number of element in the list
6977 * @max: the size of the array
6978 *
6979 * Build/extend a list of potential children allowed by the content tree
6980 *
6981 * returns the number of element in the list, or -1 in case of error.
6982 */
6984 int
7013 }
7016 }
7018 /*
7019 * Dummy function to suppress messages while we try out valid elements
7020 */
7024 }
7026 /**
7027 * xmlValidGetValidElements:
7028 * @prev: an element to insert after
7029 * @next: an element to insert next
7030 * @names: an array to store the list of child names
7031 * @max: the size of the array
7032 *
7033 * This function returns the list of authorized children to insert
7034 * within an existing tree while respecting the validity constraints
7035 * forced by the Dtd. The insertion point is defined using @prev and
7036 * @next in the following ways:
7037 * to insert before 'node': xmlValidGetValidElements(node->prev, node, ...
7038 * to insert next 'node': xmlValidGetValidElements(node, node->next, ...
7039 * to replace 'node': xmlValidGetValidElements(node->prev, node->next, ...
7040 * to prepend a child to 'node': xmlValidGetValidElements(NULL, node->childs,
7041 * to append a child to 'node': xmlValidGetValidElements(node->last, NULL, ...
7042 *
7043 * pointers to the element names are inserted at the beginning of the array
7044 * and do not need to be freed.
7045 *
7046 * returns the number of element in the list, or -1 in case of error. If
7047 * the function returns the value @max the caller is invited to grow the
7048 * receiving array and retry.
7049 */
7051 int
7054 xmlValidCtxt vctxt;
7084 /*
7085 * Retrieves the parent element declaration
7086 */
7094 /*
7095 * Do a backup of the current tree structure
7096 */
7102 /*
7103 * Creates a dummy node and insert it into the tree
7104 */
7120 /*
7121 * Insert each potential child node and check if the parent is
7122 * still valid
7123 */
7136 }
7137 }
7139 /*
7140 * Restore the tree structure
7141 */
7147 /*
7148 * Free up the dummy node
7149 */
7154 }