| blob | e74801fa456f7840a8bbee995cb92b622fc17236 |
1 /*
2 * parserInternals.c : Internal routines (and obsolete ones) needed for the
3 * XML and HTML parsers.
4 *
5 * See Copyright for the status of this software.
6 *
7 * daniel@veillard.com
8 */
10 #define IN_LIBXML
13 #if defined(WIN32) && !defined (__CYGWIN__)
15 #else
17 #endif
19 #include <string.h>
20 #ifdef HAVE_CTYPE_H
21 #include <ctype.h>
22 #endif
23 #ifdef HAVE_STDLIB_H
24 #include <stdlib.h>
25 #endif
26 #ifdef HAVE_SYS_STAT_H
27 #include <sys/stat.h>
28 #endif
29 #ifdef HAVE_FCNTL_H
30 #include <fcntl.h>
31 #endif
32 #ifdef HAVE_UNISTD_H
33 #include <unistd.h>
34 #endif
35 #ifdef HAVE_ZLIB_H
36 #include <zlib.h>
37 #endif
39 #include <libxml/xmlmemory.h>
40 #include <libxml/tree.h>
41 #include <libxml/parser.h>
42 #include <libxml/parserInternals.h>
43 #include <libxml/valid.h>
44 #include <libxml/entities.h>
45 #include <libxml/xmlerror.h>
46 #include <libxml/encoding.h>
47 #include <libxml/valid.h>
48 #include <libxml/xmlIO.h>
49 #include <libxml/uri.h>
50 #include <libxml/SAX.h>
51 #ifdef LIBXML_CATALOG_ENABLED
52 #include <libxml/catalog.h>
53 #endif
54 #include <libxml/globals.h>
58 /*
59 * Various global defaults for parsing
60 */
62 /**
63 * xmlCheckVersion:
64 * @version: the include version number
65 *
66 * check the compiled lib version against the include one.
67 * This can warn or immediately kill the application
68 */
69 void
82 }
87 }
88 }
134 };
136 /**
137 * xmlGetFeaturesList:
138 * @len: the length of the features name array (input/output)
139 * @result: an array of string to be filled with the features name.
140 *
141 * Copy at most *@len feature names into the @result array
142 *
143 * Returns -1 in case or error, or the total number of features,
144 * len is updated with the number of strings copied,
145 * strings must not be deallocated
146 */
147 int
161 }
163 /**
164 * xmlGetFeature:
165 * @ctxt: an XML/HTML parser context
166 * @name: the feature name
167 * @result: location to store the result
168 *
169 * Read the current value of one feature of this parser instance
170 *
171 * Returns -1 in case or error, 0 otherwise
172 */
173 int
260 }
262 }
264 /**
265 * xmlSetFeature:
266 * @ctxt: an XML/HTML parser context
267 * @name: the feature name
268 * @value: pointer to the location of the new value
269 *
270 * Change the current value of one feature of this parser instance
271 *
272 * Returns -1 in case or error, 0 otherwise
273 */
274 int
287 }
369 }
371 }
373 /************************************************************************
374 * *
375 * Some functions to avoid too large macros *
376 * *
377 ************************************************************************/
379 /**
380 * xmlIsChar:
381 * @c: an unicode character (int)
382 *
383 * Check whether the character is allowed by the production
384 * [2] Char ::= #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD]
385 * | [#x10000-#x10FFFF]
386 * any Unicode character, excluding the surrogate blocks, FFFE, and FFFF.
387 * Also available as a macro IS_CHAR()
388 *
389 * Returns 0 if not, non-zero otherwise
390 */
391 int
398 }
400 /**
401 * xmlIsBlank:
402 * @c: an unicode character (int)
403 *
404 * Check whether the character is allowed by the production
405 * [3] S ::= (#x20 | #x9 | #xD | #xA)+
406 * Also available as a macro IS_BLANK()
407 *
408 * Returns 0 if not, non-zero otherwise
409 */
410 int
413 }
415 /**
416 * xmlIsBaseChar:
417 * @c: an unicode character (int)
418 *
419 * Check whether the character is allowed by the production
420 * [85] BaseChar ::= ... long list see REC ...
421 *
422 * VI is your friend !
423 * :1,$ s/\[#x\([0-9A-Z]*\)-#x\([0-9A-Z]*\)\]/ (((c) >= 0x\1) \&\& ((c) <= 0x\2)) ||/
424 * and
425 * :1,$ s/#x\([0-9A-Z]*\)/ ((c) == 0x\1) ||/
426 *
427 * Returns 0 if not, non-zero otherwise
428 */
446 };
448 int
652 }
654 /**
655 * xmlIsDigit:
656 * @c: an unicode character (int)
657 *
658 * Check whether the character is allowed by the production
659 * [88] Digit ::= ... long list see REC ...
660 *
661 * Returns 0 if not, non-zero otherwise
662 */
663 int
682 }
684 /**
685 * xmlIsCombining:
686 * @c: an unicode character (int)
687 *
688 * Check whether the character is allowed by the production
689 * [87] CombiningChar ::= ... long list see REC ...
690 *
691 * Returns 0 if not, non-zero otherwise
692 */
693 int
795 }
797 /**
798 * xmlIsExtender:
799 * @c: an unicode character (int)
800 *
801 * Check whether the character is allowed by the production
802 * [89] Extender ::= #x00B7 | #x02D0 | #x02D1 | #x0387 | #x0640 |
803 * #x0E46 | #x0EC6 | #x3005 | [#x3031-#x3035] |
804 * [#x309D-#x309E] | [#x30FC-#x30FE]
805 *
806 * Returns 0 if not, non-zero otherwise
807 */
808 int
819 }
820 }
822 /**
823 * xmlIsIdeographic:
824 * @c: an unicode character (int)
825 *
826 * Check whether the character is allowed by the production
827 * [86] Ideographic ::= [#x4E00-#x9FA5] | #x3007 | [#x3021-#x3029]
828 *
829 * Returns 0 if not, non-zero otherwise
830 */
831 int
838 }
840 /**
841 * xmlIsLetter:
842 * @c: an unicode character (int)
843 *
844 * Check whether the character is allowed by the production
845 * [84] Letter ::= BaseChar | Ideographic
846 *
847 * Returns 0 if not, non-zero otherwise
848 */
849 int
852 }
854 /**
855 * xmlIsPubidChar:
856 * @c: an unicode character (int)
857 *
858 * Check whether the character is allowed by the production
859 * [13] PubidChar ::= #x20 | #xD | #xA | [a-zA-Z0-9] | [-'()+,./:=?;!*#@$_%]
860 *
861 * Returns 0 if not, non-zero otherwise
862 */
863 int
875 }
877 /************************************************************************
878 * *
879 * Input handling functions for progressive parsing *
880 * *
881 ************************************************************************/
883 /* #define DEBUG_INPUT */
884 /* #define DEBUG_STACK */
885 /* #define DEBUG_PUSH */
888 /* we need to keep enough input to show errors in context */
889 #define LINE_LEN 80
891 #ifdef DEBUG_INPUT
892 #define CHECK_BUFFER(in) check_buffer(in)
898 }
902 }
906 }
910 }
912 #else
913 #define CHECK_BUFFER(in)
914 #endif
917 /**
918 * xmlParserInputRead:
919 * @in: an XML parser input
920 * @len: an indicative size for the lookahead
921 *
922 * This function refresh the input for the parser. It doesn't try to
923 * preserve pointers to the input buffer, and discard already read data
924 *
925 * Returns the number of xmlChars read, or -1 in case of error, 0 indicate the
926 * end of this entity
927 */
928 int
934 #ifdef DEBUG_INPUT
936 #endif
950 }
953 /*
954 * the buffer has been reallocated
955 */
959 }
965 }
967 /**
968 * xmlParserInputGrow:
969 * @in: an XML parser input
970 * @len: an indicative size for the lookahead
971 *
972 * This function increase the input for the parser. It tries to
973 * preserve pointers to the input buffer, and keep already read data
974 *
975 * Returns the number of xmlChars read, or -1 in case of error, 0 indicate the
976 * end of this entity
977 */
978 int
983 #ifdef DEBUG_INPUT
985 #endif
999 }
1002 else
1005 /*
1006 * NOTE : in->base may be a "dangling" i.e. freed pointer in this
1007 * block, but we use it really as an integer to do some
1008 * pointer arithmetic. Insure will raise it as a bug but in
1009 * that specific case, that's not !
1010 */
1012 /*
1013 * the buffer has been reallocated
1014 */
1018 }
1024 }
1026 /**
1027 * xmlParserInputShrink:
1028 * @in: an XML parser input
1029 *
1030 * This function removes used input for the parser.
1031 */
1032 void
1038 #ifdef DEBUG_INPUT
1040 #endif
1049 /*
1050 * Do not shrink on large buffers whose only a tiny fraction
1051 * was consumed
1052 */
1060 }
1062 }
1068 }
1071 /*
1072 * the buffer has been reallocated
1073 */
1077 }
1081 }
1083 /************************************************************************
1084 * *
1085 * UTF8 character input and related functions *
1086 * *
1087 ************************************************************************/
1089 /**
1090 * xmlNextChar:
1091 * @ctxt: the XML parser context
1092 *
1093 * Skip to the next char input char.
1094 */
1096 void
1101 /*
1102 * 2.11 End-of-Line Handling
1103 * the literal two-character sequence "#xD#xA" or a standalone
1104 * literal #xD, an XML processor must pass to the application
1105 * the single character #xA.
1106 */
1111 /*
1112 * If we are at the end of the current entity and
1113 * the context allows it, we pop consumed entities
1114 * automatically.
1115 * the auto closing should be blocked in other cases
1116 */
1123 /*
1124 * We are supposed to handle UTF8, check it's valid
1125 * From rfc2044: encoding of the Unicode values on UTF-8:
1126 *
1127 * UCS-4 range (hex.) UTF-8 octet sequence (binary)
1128 * 0000 0000-0000 007F 0xxxxxxx
1129 * 0000 0080-0000 07FF 110xxxxx 10xxxxxx
1130 * 0000 0800-0000 FFFF 1110xxxx 10xxxxxx 10xxxxxx
1131 *
1132 * Check for the 0x110000 limit too
1133 */
1156 /* 4-byte code */
1163 /* 3-byte code */
1168 }
1179 }
1181 /* 2-byte code */
1184 /* 1-byte code */
1187 /*
1188 * Assume it's a fixed length encoding (1) with
1189 * a compatible encoding for the ASCII set, since
1190 * XML constructs only use < 128 chars
1191 */
1193 }
1197 }
1203 }
1210 encoding_error:
1211 /*
1212 * If we detect an UTF8 error that probably mean that the
1213 * input encoding didn't get properly advertised in the
1214 * declaration header. Report the error and switch the encoding
1215 * to ISO-Latin-1 (if you don't like this policy, just declare the
1216 * encoding !)
1217 */
1224 }
1231 }
1233 /**
1234 * xmlCurrentChar:
1235 * @ctxt: the XML parser context
1236 * @len: pointer to the length of the char read
1237 *
1238 * The current char value, if using UTF-8 this may actually span multiple
1239 * bytes in the input buffer. Implement the end of line normalization:
1240 * 2.11 End-of-Line Handling
1241 * Wherever an external parsed entity or the literal entity value
1242 * of an internal parsed entity contains either the literal two-character
1243 * sequence "#xD#xA" or a standalone literal #xD, an XML processor
1244 * must pass to the application the single character #xA.
1245 * This behavior can conveniently be produced by normalizing all
1246 * line breaks to #xA on input, before parsing.)
1247 *
1248 * Returns the current char value and its length
1249 */
1251 int
1259 }
1261 /*
1262 * We are supposed to handle UTF8, check it's valid
1263 * From rfc2044: encoding of the Unicode values on UTF-8:
1264 *
1265 * UCS-4 range (hex.) UTF-8 octet sequence (binary)
1266 * 0000 0000-0000 007F 0xxxxxxx
1267 * 0000 0080-0000 07FF 110xxxxx 10xxxxxx
1268 * 0000 0800-0000 FFFF 1110xxxx 10xxxxxx 10xxxxxx
1269 *
1270 * Check for the 0x110000 limit too
1271 */
1294 /* 4-byte code */
1301 /* 3-byte code */
1306 }
1308 /* 2-byte code */
1312 }
1321 }
1324 /* 1-byte code */
1330 }
1332 }
1334 }
1335 }
1336 /*
1337 * Assume it's a fixed length encoding (1) with
1338 * a compatible encoding for the ASCII set, since
1339 * XML constructs only use < 128 chars
1340 */
1346 }
1348 }
1350 encoding_error:
1351 /*
1352 * An encoding problem may arise from a truncated input buffer
1353 * splitting a character in the middle. In that case do not raise
1354 * an error but return 0 to endicate an end of stream problem
1355 */
1359 }
1361 /*
1362 * If we detect an UTF8 error that probably mean that the
1363 * input encoding didn't get properly advertised in the
1364 * declaration header. Report the error and switch the encoding
1365 * to ISO-Latin-1 (if you don't like this policy, just declare the
1366 * encoding !)
1367 */
1374 }
1381 }
1383 /**
1384 * xmlStringCurrentChar:
1385 * @ctxt: the XML parser context
1386 * @cur: pointer to the beginning of the char
1387 * @len: pointer to the length of the char read
1388 *
1389 * The current char value, if using UTF-8 this may actually span multiple
1390 * bytes in the input buffer.
1391 *
1392 * Returns the current char value and its length
1393 */
1395 int
1397 {
1399 /*
1400 * We are supposed to handle UTF8, check it's valid
1401 * From rfc2044: encoding of the Unicode values on UTF-8:
1402 *
1403 * UCS-4 range (hex.) UTF-8 octet sequence (binary)
1404 * 0000 0000-0000 007F 0xxxxxxx
1405 * 0000 0080-0000 07FF 110xxxxx 10xxxxxx
1406 * 0000 0800-0000 FFFF 1110xxxx 10xxxxxx 10xxxxxx
1407 *
1408 * Check for the 0x110000 limit too
1409 */
1424 /* 4-byte code */
1431 /* 3-byte code */
1436 }
1438 /* 2-byte code */
1442 }
1448 val);
1453 }
1454 }
1457 /* 1-byte code */
1460 }
1461 }
1462 /*
1463 * Assume it's a fixed length encoding (1) with
1464 * a compatible encoding for the ASCII set, since
1465 * XML constructs only use < 128 chars
1466 */
1469 encoding_error:
1471 /*
1472 * If we detect an UTF8 error that probably mean that the
1473 * input encoding didn't get properly advertised in the
1474 * declaration header. Report the error and switch the encoding
1475 * to ISO-Latin-1 (if you don't like this policy, just declare the
1476 * encoding !)
1477 */
1486 }
1489 }
1493 }
1495 /**
1496 * xmlCopyCharMultiByte:
1497 * @out: pointer to an array of xmlChar
1498 * @val: the char value
1499 *
1500 * append the char value in the array
1501 *
1502 * Returns the number of xmlChar written
1503 */
1504 int
1506 /*
1507 * We are supposed to handle UTF8, check it's valid
1508 * From rfc2044: encoding of the Unicode values on UTF-8:
1509 *
1510 * UCS-4 range (hex.) UTF-8 octet sequence (binary)
1511 * 0000 0000-0000 007F 0xxxxxxx
1512 * 0000 0080-0000 07FF 110xxxxx 10xxxxxx
1513 * 0000 0800-0000 FFFF 1110xxxx 10xxxxxx 10xxxxxx
1514 */
1524 val);
1526 }
1530 }
1533 }
1535 /**
1536 * xmlCopyChar:
1537 * @len: Ignored, compatibility
1538 * @out: pointer to an array of xmlChar
1539 * @val: the char value
1540 *
1541 * append the char value in the array
1542 *
1543 * Returns the number of xmlChar written
1544 */
1546 int
1548 /* the len parameter is ignored */
1551 }
1554 }
1556 /************************************************************************
1557 * *
1558 * Commodity functions to switch encodings *
1559 * *
1560 ************************************************************************/
1562 /**
1563 * xmlSwitchEncoding:
1564 * @ctxt: the parser context
1565 * @enc: the encoding value (number)
1566 *
1567 * change the input functions when discovering the character encoding
1568 * of a given entity.
1569 *
1570 * Returns 0 in case of success, -1 otherwise
1571 */
1572 int
1574 {
1575 xmlCharEncodingHandlerPtr handler;
1586 /* let's assume it's UTF-8 without the XML decl */
1590 /* default encoding, no conversion should be needed */
1593 /*
1594 * Errata on XML-1.0 June 20 2001
1595 * Specific handling of the Byte Order Mark for
1596 * UTF-8
1597 */
1603 }
1607 }
1610 /*
1611 * Default handlers.
1612 */
1623 /* let's assume it's UTF-8 without the XML decl */
1628 /* default encoding, no conversion should be needed */
1680 /*
1681 * We used to keep the internal content in the
1682 * document encoding however this turns being unmaintainable
1683 * So xmlGetCharEncodingHandler() will return non-null
1684 * values for this now.
1685 */
1690 }
1711 }
1712 }
1717 }
1719 /**
1720 * xmlSwitchToEncoding:
1721 * @ctxt: the parser context
1722 * @handler: the encoding handler
1723 *
1724 * change the input functions when discovering the character encoding
1725 * of a given entity.
1726 *
1727 * Returns 0 in case of success, -1 otherwise
1728 */
1729 int
1731 {
1738 /*
1739 * Check in case the auto encoding detetection triggered
1740 * in already.
1741 */
1745 /*
1746 * "UTF-16" can be used for both LE and BE
1747 */
1753 }
1755 /*
1756 * Note: this is a bit dangerous, but that's what it
1757 * takes to use nearly compatible signature for different
1758 * encodings.
1759 */
1763 }
1766 /*
1767 * Is there already some content down the pipe to convert ?
1768 */
1773 /*
1774 * Specific handling of the Byte Order Mark for
1775 * UTF-16
1776 */
1782 }
1788 }
1789 /*
1790 * Errata on XML-1.0 June 20 2001
1791 * Specific handling of the Byte Order Mark for
1792 * UTF-8
1793 */
1800 }
1802 /*
1803 * Shrink the current input buffer.
1804 * Move it as the raw buffer and create a new input buffer
1805 */
1812 /*
1813 * convert as much as possible of the buffer
1814 */
1819 /*
1820 * convert just enough to get
1821 * '<?xml version="1.0" encoding="xxx"?>'
1822 * parsed with the autodetected encoding
1823 * into the parser reading buffer.
1824 */
1828 }
1833 }
1839 }
1843 /*
1844 * When parsing a static memory array one must know the
1845 * size to be able to convert the buffer.
1846 */
1854 /*
1855 * Shrink the current input buffer.
1856 * Move it as the raw buffer and create a new input buffer
1857 */
1865 /*
1866 * convert as much as possible of the raw input
1867 * to the parser reading buffer.
1868 */
1876 }
1878 /*
1879 * Conversion succeeded, get rid of the old buffer
1880 */
1888 }
1889 }
1895 }
1896 /*
1897 * The parsing is now done in UTF8 natively
1898 */
1904 }
1906 /************************************************************************
1907 * *
1908 * Commodity functions to handle entities processing *
1909 * *
1910 ************************************************************************/
1912 /**
1913 * xmlFreeInputStream:
1914 * @input: an xmlParserInputPtr
1915 *
1916 * Free up an input stream.
1917 */
1918 void
1931 }
1933 /**
1934 * xmlNewInputStream:
1935 * @ctxt: an XML parser context
1936 *
1937 * Create a new input stream structure
1938 * Returns the new input stream or NULL
1939 */
1940 xmlParserInputPtr
1942 xmlParserInputPtr input;
1952 }
1954 }
1960 }
1962 /**
1963 * xmlNewIOInputStream:
1964 * @ctxt: an XML parser context
1965 * @input: an I/O Input
1966 * @enc: the charset encoding if known
1967 *
1968 * Create a new input stream structure encapsulating the @input into
1969 * a stream suitable for the parser.
1970 *
1971 * Returns the new input stream or NULL
1972 */
1973 xmlParserInputPtr
1975 xmlCharEncoding enc) {
1976 xmlParserInputPtr inputStream;
1983 }
1991 }
1994 }
1996 /**
1997 * xmlNewEntityInputStream:
1998 * @ctxt: an XML parser context
1999 * @entity: an Entity pointer
2000 *
2001 * Create a new input stream based on an xmlEntityPtr
2002 *
2003 * Returns the new input stream or NULL
2004 */
2005 xmlParserInputPtr
2007 xmlParserInputPtr input;
2016 }
2049 }
2051 }
2055 }
2062 }
2064 /**
2065 * xmlNewStringInputStream:
2066 * @ctxt: an XML parser context
2067 * @buffer: an memory buffer
2068 *
2069 * Create a new input stream based on a memory buffer.
2070 * Returns the new input stream
2071 */
2072 xmlParserInputPtr
2074 xmlParserInputPtr input;
2082 }
2089 }
2095 }
2097 /**
2098 * xmlNewInputFromFile:
2099 * @ctxt: an XML parser context
2100 * @filename: the filename to use as entity
2101 *
2102 * Create a new input stream based on a file.
2103 *
2104 * Returns the new input stream or NULL in case of error
2105 */
2106 xmlParserInputPtr
2108 xmlParserInputBufferPtr buf;
2109 xmlParserInputPtr inputStream;
2129 }
2141 }
2143 /************************************************************************
2144 * *
2145 * Commodity functions to handle parser contexts *
2146 * *
2147 ************************************************************************/
2149 /**
2150 * xmlInitParserCtxt:
2151 * @ctxt: an XML parser context
2152 *
2153 * Initialize a parser context
2154 */
2156 void
2158 {
2163 }
2171 }
2172 else
2175 /* Allocate the Input stack */
2185 }
2201 /* Allocate the Node stack */
2213 }
2218 /* Allocate the Name stack */
2233 }
2238 /* Allocate the space stack */
2256 }
2279 else
2282 }
2293 }
2295 /**
2296 * xmlFreeParserCtxt:
2297 * @ctxt: an XML parser context
2298 *
2299 * Free all the memory used by a parser context. However the parsed
2300 * document in ctxt->myDoc is not freed.
2301 */
2303 void
2305 {
2306 xmlParserInputPtr input;
2313 }
2316 }
2330 #ifdef LIBXML_CATALOG_ENABLED
2333 #endif
2335 }
2337 /**
2338 * xmlNewParserCtxt:
2339 *
2340 * Allocate and initialize a new parser context.
2341 *
2342 * Returns the xmlParserCtxtPtr or NULL
2343 */
2345 xmlParserCtxtPtr
2347 {
2348 xmlParserCtxtPtr ctxt;
2356 }
2360 }
2362 /************************************************************************
2363 * *
2364 * Handling of node informations *
2365 * *
2366 ************************************************************************/
2368 /**
2369 * xmlClearParserCtxt:
2370 * @ctxt: an XML parser context
2371 *
2372 * Clear (release owned resources) and reinitialize a parser context
2373 */
2375 void
2377 {
2382 }
2384 /**
2385 * xmlParserFindNodeInfo:
2386 * @ctxt: an XML parser context
2387 * @node: an XML node within the tree
2388 *
2389 * Find the parser node info struct for a given node
2390 *
2391 * Returns an xmlParserNodeInfo block pointer or NULL
2392 */
2395 {
2398 /* Find position where node should be at */
2402 else
2404 }
2407 /**
2408 * xmlInitNodeInfoSeq:
2409 * @seq: a node info sequence pointer
2410 *
2411 * -- Initialize (set to initial state) node info sequence
2412 */
2413 void
2415 {
2419 }
2421 /**
2422 * xmlClearNodeInfoSeq:
2423 * @seq: a node info sequence pointer
2424 *
2425 * -- Clear (release memory and reinitialize) node
2426 * info sequence
2427 */
2428 void
2430 {
2434 }
2437 /**
2438 * xmlParserFindNodeInfoIndex:
2439 * @seq: a node info sequence pointer
2440 * @node: an XML node pointer
2441 *
2442 *
2443 * xmlParserFindNodeInfoIndex : Find the index that the info record for
2444 * the given node is or should be at in a sorted sequence
2445 *
2446 * Returns a long indicating the position of the record
2447 */
2450 {
2454 /* Do a binary search for the key */
2464 else
2466 }
2468 /* Return position */
2471 else
2473 }
2476 /**
2477 * xmlParserAddNodeInfo:
2478 * @ctxt: an XML parser context
2479 * @info: a node info sequence pointer
2480 *
2481 * Insert node info record into the sorted sequence
2482 */
2483 void
2486 {
2489 /* Find pos and check to see if node is already in the sequence */
2495 }
2497 /* Otherwise, we need to add new node to buffer */
2510 else
2511 tmp_buffer =
2513 byte_size);
2520 }
2523 }
2525 /* If position is not at end, move elements out of the way */
2531 }
2533 /* Copy element and increase length */
2536 }
2537 }
2539 /************************************************************************
2540 * *
2541 * Defaults settings *
2542 * *
2543 ************************************************************************/
2544 /**
2545 * xmlPedanticParserDefault:
2546 * @val: int 0 or 1
2547 *
2548 * Set and return the previous value for enabling pedantic warnings.
2549 *
2550 * Returns the last value for 0 for no substitution, 1 for substitution.
2551 */
2553 int
2559 }
2561 /**
2562 * xmlLineNumbersDefault:
2563 * @val: int 0 or 1
2564 *
2565 * Set and return the previous value for enabling line numbers in elements
2566 * contents. This may break on old application and is turned off by default.
2567 *
2568 * Returns the last value for 0 for no substitution, 1 for substitution.
2569 */
2571 int
2577 }
2579 /**
2580 * xmlSubstituteEntitiesDefault:
2581 * @val: int 0 or 1
2582 *
2583 * Set and return the previous value for default entity support.
2584 * Initially the parser always keep entity references instead of substituting
2585 * entity values in the output. This function has to be used to change the
2586 * default parser behavior
2587 * SAX::substituteEntities() has to be used for changing that on a file by
2588 * file basis.
2589 *
2590 * Returns the last value for 0 for no substitution, 1 for substitution.
2591 */
2593 int
2599 }
2601 /**
2602 * xmlKeepBlanksDefault:
2603 * @val: int 0 or 1
2604 *
2605 * Set and return the previous value for default blanks text nodes support.
2606 * The 1.x version of the parser used an heuristic to try to detect
2607 * ignorable white spaces. As a result the SAX callback was generating
2608 * ignorableWhitespace() callbacks instead of characters() one, and when
2609 * using the DOM output text nodes containing those blanks were not generated.
2610 * The 2.x and later version will switch to the XML standard way and
2611 * ignorableWhitespace() are only generated when running the parser in
2612 * validating mode and when the current element doesn't allow CDATA or
2613 * mixed content.
2614 * This function is provided as a way to force the standard behavior
2615 * on 1.X libs and to switch back to the old mode for compatibility when
2616 * running 1.X client code on 2.X . Upgrade of 1.X code should be done
2617 * by using xmlIsBlankNode() commodity function to detect the "empty"
2618 * nodes generated.
2619 * This value also affect autogeneration of indentation when saving code
2620 * if blanks sections are kept, indentation is not generated.
2621 *
2622 * Returns the last value for 0 for no substitution, 1 for substitution.
2623 */
2625 int
2632 }
2634 /************************************************************************
2635 * *
2636 * Deprecated functions kept for compatibility *
2637 * *
2638 ************************************************************************/
2640 /**
2641 * xmlCheckLanguageID:
2642 * @lang: pointer to the string value
2643 *
2644 * Checks that the value conforms to the LanguageID production:
2645 *
2646 * NOTE: this is somewhat deprecated, those productions were removed from
2647 * the XML Second edition.
2648 *
2649 * [33] LanguageID ::= Langcode ('-' Subcode)*
2650 * [34] Langcode ::= ISO639Code | IanaCode | UserCode
2651 * [35] ISO639Code ::= ([a-z] | [A-Z]) ([a-z] | [A-Z])
2652 * [36] IanaCode ::= ('i' | 'I') '-' ([a-z] | [A-Z])+
2653 * [37] UserCode ::= ('x' | 'X') '-' ([a-z] | [A-Z])+
2654 * [38] Subcode ::= ([a-z] | [A-Z])+
2655 *
2656 * Returns 1 if correct 0 otherwise
2657 **/
2658 int
2666 /*
2667 * IANA code
2668 */
2672 cur++;
2675 /*
2676 * User code
2677 */
2681 cur++;
2684 /*
2685 * ISO639
2686 */
2687 cur++;
2690 cur++;
2691 else
2698 cur++;
2701 cur++;
2702 else
2706 cur++;
2707 }
2709 }
2711 /**
2712 * xmlDecodeEntities:
2713 * @ctxt: the parser context
2714 * @what: combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF
2715 * @len: the len to decode (in bytes !), -1 for no size limit
2716 * @end: an end marker xmlChar, 0 if none
2717 * @end2: an end marker xmlChar, 0 if none
2718 * @end3: an end marker xmlChar, 0 if none
2719 *
2720 * This function is deprecated, we now always process entities content
2721 * through xmlStringDecodeEntities
2722 *
2723 * TODO: remove it in next major release.
2724 *
2725 * [67] Reference ::= EntityRef | CharRef
2726 *
2727 * [69] PEReference ::= '%' Name ';'
2728 *
2729 * Returns A newly allocated string with the substitution done. The caller
2730 * must deallocate it !
2731 */
2732 xmlChar *
2733 xmlDecodeEntities(xmlParserCtxtPtr ctxt ATTRIBUTE_UNUSED, int len ATTRIBUTE_UNUSED, int what ATTRIBUTE_UNUSED,
2735 #if 0
2741 xmlEntityPtr ent;
2744 #endif
2751 }
2753 #if 0
2762 }
2764 /*
2765 * allocate a translation buffer.
2766 */
2773 }
2775 /*
2776 * OK loop until we reach one of the ending char or a size limit.
2777 */
2778 GROW;
2782 GROW;
2801 }
2802 }
2809 }
2812 }
2814 }
2816 /*
2817 * a PEReference induce to switch the entity flow,
2818 * we break here to flush the current set of chars
2819 * parsed if any. We will be called back later.
2820 */
2828 /*
2829 * Pop-up of finished entities.
2830 */
2840 }
2841 }
2843 }
2846 #endif
2848 }
2850 /**
2851 * xmlNamespaceParseNCName:
2852 * @ctxt: an XML parser context
2853 *
2854 * parse an XML namespace name.
2855 *
2856 * TODO: this seems not in use anymore, the namespace handling is done on
2857 * top of the SAX interfaces, i.e. not on raw input.
2858 *
2859 * [NS 3] NCName ::= (Letter | '_') (NCNameChar)*
2860 *
2861 * [NS 4] NCNameChar ::= Letter | Digit | '.' | '-' | '_' |
2862 * CombiningChar | Extender
2863 *
2864 * Returns the namespace name or NULL
2865 */
2867 xmlChar *
2869 #if 0
2873 #endif
2880 }
2882 #if 0
2883 /* load first the value of the char !!! */
2884 GROW;
2907 }
2909 }
2910 }
2912 #endif
2914 }
2916 /**
2917 * xmlNamespaceParseQName:
2918 * @ctxt: an XML parser context
2919 * @prefix: a xmlChar **
2920 *
2921 * TODO: this seems not in use anymore, the namespace handling is done on
2922 * top of the SAX interfaces, i.e. not on raw input.
2923 *
2924 * parse an XML qualified name
2925 *
2926 * [NS 5] QName ::= (Prefix ':')? LocalPart
2927 *
2928 * [NS 6] Prefix ::= NCName
2929 *
2930 * [NS 7] LocalPart ::= NCName
2931 *
2932 * Returns the local part, and prefix is updated
2933 * to get the Prefix if any.
2934 */
2936 xmlChar *
2937 xmlNamespaceParseQName(xmlParserCtxtPtr ctxt ATTRIBUTE_UNUSED, xmlChar **prefix ATTRIBUTE_UNUSED) {
2944 }
2946 #if 0
2953 NEXT;
2955 }
2958 #endif
2960 }
2962 /**
2963 * xmlNamespaceParseNSDef:
2964 * @ctxt: an XML parser context
2965 *
2966 * parse a namespace prefix declaration
2967 *
2968 * TODO: this seems not in use anymore, the namespace handling is done on
2969 * top of the SAX interfaces, i.e. not on raw input.
2970 *
2971 * [NS 1] NSDef ::= PrefixDef Eq SystemLiteral
2972 *
2973 * [NS 2] PrefixDef ::= 'xmlns' (':' NCName)?
2974 *
2975 * Returns the namespace name
2976 */
2978 xmlChar *
2985 }
2987 #if 0
2995 NEXT;
2997 }
2998 }
3000 #endif
3001 }
3003 /**
3004 * xmlParseQuotedString:
3005 * @ctxt: an XML parser context
3006 *
3007 * Parse and return a string between quotes or doublequotes
3008 *
3009 * TODO: Deprecated, to be removed at next drop of binary compatibility
3010 *
3011 * Returns the string parser or NULL.
3012 */
3013 xmlChar *
3020 }
3023 #if 0
3034 }
3038 NEXT;
3048 }
3049 }
3053 }
3062 NEXT;
3063 }
3065 NEXT;
3075 }
3076 }
3078 NEXT;
3080 }
3089 NEXT;
3090 }
3091 }
3093 #endif
3094 }
3096 /**
3097 * xmlParseNamespace:
3098 * @ctxt: an XML parser context
3099 *
3100 * xmlParseNamespace: parse specific PI '<?namespace ...' constructs.
3101 *
3102 * This is what the older xml-name Working Draft specified, a bunch of
3103 * other stuff may still rely on it, so support is still here as
3104 * if it was declared on the root of the Tree:-(
3105 *
3106 * TODO: remove from library
3107 *
3108 * To be removed at next drop of binary compatibility
3109 */
3111 void
3118 }
3120 #if 0
3125 /*
3126 * We just skipped "namespace" or "xml:namespace"
3127 */
3128 SKIP_BLANKS;
3133 /*
3134 * We can have "ns" or "prefix" attributes
3135 * Old encoding as 'href' or 'AS' attributes is still supported
3136 */
3140 SKIP_BLANKS;
3143 NEXT;
3144 SKIP_BLANKS;
3147 SKIP_BLANKS;
3152 SKIP_BLANKS;
3155 NEXT;
3156 SKIP_BLANKS;
3159 SKIP_BLANKS;
3165 SKIP_BLANKS;
3168 NEXT;
3169 SKIP_BLANKS;
3172 SKIP_BLANKS;
3176 SKIP_BLANKS;
3179 NEXT;
3180 SKIP_BLANKS;
3183 SKIP_BLANKS;
3186 NEXT;
3188 /*
3189 * Found garbage when parsing the namespace
3190 */
3195 }
3199 NEXT;
3200 }
3201 }
3204 NEXT;
3206 /*
3207 * Register the DTD.
3208 if (href != NULL)
3209 if ((ctxt->sax != NULL) && (ctxt->sax->globalNamespace != NULL))
3210 ctxt->sax->globalNamespace(ctxt->userData, href, prefix);
3211 */
3215 #endif
3216 }
3218 /**
3219 * xmlScanName:
3220 * @ctxt: an XML parser context
3221 *
3222 * Trickery: parse an XML name but without consuming the input flow
3223 * Needed for rollback cases. Used only when parsing entities references.
3224 *
3225 * TODO: seems deprecated now, only used in the default part of
3226 * xmlParserHandleReference
3227 *
3228 * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' |
3229 * CombiningChar | Extender
3230 *
3231 * [5] Name ::= (Letter | '_' | ':') (NameChar)*
3232 *
3233 * [6] Names ::= Name (S Name)*
3234 *
3235 * Returns the Name parsed or NULL
3236 */
3238 xmlChar *
3245 }
3248 #if 0
3252 GROW;
3256 }
3264 GROW;
3266 len++;
3276 len++;
3278 }
3279 }
3281 #endif
3282 }
3284 /**
3285 * xmlParserHandleReference:
3286 * @ctxt: the parser context
3287 *
3288 * TODO: Remove, now deprecated ... the test is done directly in the
3289 * content parsing
3290 * routines.
3291 *
3292 * [67] Reference ::= EntityRef | CharRef
3293 *
3294 * [68] EntityRef ::= '&' Name ';'
3295 *
3296 * [ WFC: Entity Declared ]
3297 * the Name given in the entity reference must match that in an entity
3298 * declaration, except that well-formed documents need not declare any
3299 * of the following entities: amp, lt, gt, apos, quot.
3300 *
3301 * [ WFC: Parsed Entity ]
3302 * An entity reference must not contain the name of an unparsed entity
3303 *
3304 * [66] CharRef ::= '&#' [0-9]+ ';' |
3305 * '&#x' [0-9a-fA-F]+ ';'
3306 *
3307 * A PEReference may have been detected in the current input stream
3308 * the handling is done accordingly to
3309 * http://www.w3.org/TR/REC-xml#entproc
3310 */
3311 void
3318 }
3321 }
3323 /**
3324 * xmlHandleEntity:
3325 * @ctxt: an XML parser context
3326 * @entity: an XML entity pointer.
3327 *
3328 * Default handling of defined entities, when should we define a new input
3329 * stream ? When do we just handle that as a set of chars ?
3330 *
3331 * OBSOLETE: to be removed at some point.
3332 */
3334 void
3335 xmlHandleEntity(xmlParserCtxtPtr ctxt ATTRIBUTE_UNUSED, xmlEntityPtr entity ATTRIBUTE_UNUSED) {
3341 }
3343 #if 0
3345 xmlParserInputPtr input;
3355 }
3359 /*
3360 * Redefine its content as an input stream.
3361 */
3366 handle_as_char:
3367 /*
3368 * Just handle the content as a set of chars.
3369 */
3373 #endif
3374 }
3376 /**
3377 * xmlNewGlobalNs:
3378 * @doc: the document carrying the namespace
3379 * @href: the URI associated
3380 * @prefix: the prefix for the namespace
3381 *
3382 * Creation of a Namespace, the old way using PI and without scoping
3383 * DEPRECATED !!!
3384 * It now create a namespace on the root element of the document if found.
3385 * Returns NULL this functionality had been removed
3386 */
3387 xmlNsPtr
3395 }
3397 #if 0
3398 xmlNodePtr root;
3400 xmlNsPtr cur;
3406 /*
3407 * if there is no root element yet, create an old Namespace type
3408 * and it will be moved to the root at save time.
3409 */
3415 }
3424 /*
3425 * Add it at the end to preserve parsing order ...
3426 */
3435 }
3436 }
3439 #endif
3440 }
3442 /**
3443 * xmlUpgradeOldNs:
3444 * @doc: a document pointer
3445 *
3446 * Upgrade old style Namespaces (PI) and move them to the root of the document.
3447 * DEPRECATED
3448 */
3449 void
3456 }
3457 #if 0
3458 xmlNsPtr cur;
3462 #ifdef DEBUG_TREE
3465 #endif
3467 }
3473 }
3478 #endif
3479 }