Lines Matching defs:in
19 * production in the XML specification. A few productions defining the
20 * different ranges of character are actually implanted either in
22 * The DOM tree build is realized from the default SAX callbacks in
24 * The routines doing the validation checks are in valid.c and called either
101 * Arbitrary limits set in the parser. See XML_PARSE_HUGE *
110 * replacement over the size in byte of the input indicates that you have
202 * use the number of parsed entities in the replacement
374 errmsg = "PEReference in prolog";
377 errmsg = "PEReference in epilog";
392 errmsg = "PEReferences forbidden in internal subset";
401 errmsg = "Unescaped '<' not allowed in attributes values";
410 errmsg = "Sequence ']]>' not allowed in content";
443 errmsg = "NmToken expected in ATTLIST enumeration";
462 "PEReference: forbidden within markup decl in internal subset";
471 errmsg = "Content error in the external subset";
1098 * Normalize the space in non CDATA attribute values:
1136 * Normalize the space in non CDATA attribute values, a slightly more complex
1586 * Returns -1 in case of error, -2 if the namespace should be discarded
1587 * and the index in the stack otherwise.
1596 /* in scope */
1701 * Returns -1 in case of error, the index in the stack otherwise
1759 * Returns -1 in case of error, the index in the stack otherwise
1781 "Excessive depth in document: %d use XML_PARSE_HUGE option\n",
1827 * Returns -1 in case of error, the index in the stack otherwise
1897 * Returns -1 in case of error, the index in the stack otherwise
1993 * RAW same as CUR but in the input buffer, bypass any token
2004 * in UTF-8 mode. It also pop-up unfinished entities on the fly.
2132 * skip all blanks character found at that point in the input streams.
2133 * It pops up finished entities in the process if allowable at that point.
2149 * if we are in the document content, go really fast
2205 * Returns the current xmlChar in the parser context
2227 * Returns -1 in case of error or the index in the input stack
2262 * Returns the value parsed (as an int), 0 in case of error
2358 * @str: a pointer to an index in the string
2370 * Returns the value parsed (as an int), 0 in case of error, str will be
2508 * In a document without any DTD, a document with only an internal DTD
2514 * In a document with an external subset or external parameter entities
2518 * [ WFC: In DTD ]
2519 * Parameter-entity references may only appear in the DTD.
2522 * A PEReference may have been detected in the current input stream
2526 * - Included in literal in entity values
2566 * NOTE: in the case of entity values, we don't do the
2575 * [WFC: Well-Formedness Constraint: PEs in Internal Subset]
2576 * In the internal DTD subset, parameter-entity references
2579 * In that case this is handled in xmlParseMarkupDecl
2608 * In a document without any DTD, a document with only an
2622 * In a document with an external subset or external
2681 * the amount of data in the buffer.
3000 * Look if the element is mixed content in the DTD if available
3229 * characters for Name and NmToken in the Revision 5 of XML-1.0
3231 * changes in that revision. Also note that the macros used for the
3453 const xmlChar *in;
3466 in = ctxt->input->cur;
3467 if (((*in >= 0x61) && (*in <= 0x7A)) ||
3468 ((*in >= 0x41) && (*in <= 0x5A)) ||
3469 (*in == '_') || (*in == ':')) {
3470 in++;
3471 while (((*in >= 0x61) && (*in <= 0x7A)) ||
3472 ((*in >= 0x41) && (*in <= 0x5A)) ||
3473 ((*in >= 0x30) && (*in <= 0x39)) ||
3474 (*in == '_') || (*in == '-') ||
3475 (*in == ':') || (*in == '.'))
3476 in++;
3477 if ((*in > 0) && (*in < 0x80)) {
3478 count = in - ctxt->input->cur;
3485 ctxt->input->cur = in;
3575 const xmlChar *in, *e;
3586 in = ctxt->input->cur;
3588 if ((((*in >= 0x61) && (*in <= 0x7A)) ||
3589 ((*in >= 0x41) && (*in <= 0x5A)) ||
3590 (*in == '_')) && (in < e)) {
3591 in++;
3592 while ((((*in >= 0x61) && (*in <= 0x7A)) ||
3593 ((*in >= 0x41) && (*in <= 0x5A)) ||
3594 ((*in >= 0x30) && (*in <= 0x39)) ||
3595 (*in == '_') || (*in == '-') ||
3596 (*in == '.')) && (in < e))
3597 in++;
3598 if (in >= e)
3600 if ((*in > 0) && (*in < 0x80)) {
3601 count = in - ctxt->input->cur;
3608 ctxt->input->cur = in;
3635 register const xmlChar *in;
3642 in = ctxt->input->cur;
3643 while (*in != 0 && *in == *cmp) {
3644 ++in;
3648 if (*cmp == 0 && (*in == '>' || IS_BLANK_CH (*in))) {
3650 ctxt->input->cur = in;
3665 * @str: a pointer to the string pointer (IN/OUT)
3677 * is updated to the current location in the string.
3896 * The content of the entity definition is copied in a buffer.
3909 * NOTE: 4.4.5 Included in Literal
3910 * When a parameter entity reference appears in a literal entity
3911 * value, ... a single or double quote character in the replacement
3914 * In practice it means we stop the loop only when back at parsing
3953 * Raise problem w.r.t. '&' and '%' being used in non-entities
3954 * reference constructs. Note Charref will be handled in
3992 * When a general entity reference appears in the EntityValue in
4083 * The reparsing will be done in xmlStringGetNodeList()
4084 * called by the attribute() function in SAX.c
4225 "invalid character in attribute value\n");
4262 * will be handled later in xmlStringGetNodeList
4474 * used for the test in the inner loop of the char data testing
4521 * reference when it appears in the string "]]>" in content, when that
4529 const xmlChar *in;
4542 in = ctxt->input->cur;
4545 while (*in == 0x20) { in++; ctxt->input->col++; }
4546 if (*in == 0xA) {
4549 in++;
4550 } while (*in == 0xA);
4553 if (*in == '<') {
4554 nbchar = in - ctxt->input->cur;
4557 ctxt->input->cur = in;
4584 while (test_char_data[*in]) {
4585 in++;
4589 if (*in == 0xA) {
4592 in++;
4593 } while (*in == 0xA);
4596 if (*in == ']') {
4597 if ((in[1] == ']') && (in[2] == '>')) {
4599 ctxt->input->cur = in;
4602 in++;
4606 nbchar = in - ctxt->input->cur;
4613 ctxt->input->cur = in;
4635 /* something really bad happened in the SAX callback */
4639 ctxt->input->cur = in;
4640 if (*in == 0xD) {
4641 in++;
4642 if (*in == 0xA) {
4643 ctxt->input->cur = in;
4644 in++;
4648 in--;
4650 if (*in == '<') {
4653 if (*in == '&') {
4660 in = ctxt->input->cur;
4661 } while (((*in >= 0x20) && (*in <= 0x7F)) || (*in == 0x09));
4690 (IS_CHAR(cur))) /* test also done in xmlCurrentChar() */ {
4720 /* something really bad happened in the SAX callback */
4778 * Returns the function returns SystemLiteral and in the second
4848 * @len: number of bytes filles in the buffer
4854 * This is the slow routine in case the accelerator for ascii didn't work
4965 "Comment doesn't start and stop in the same entity\n");
4997 const xmlChar *in;
5018 in = ctxt->input->cur;
5020 if (*in == 0xA) {
5023 in++;
5024 } while (*in == 0xA);
5028 while (((*in > '-') && (*in <= 0x7F)) ||
5029 ((*in >= 0x20) && (*in < '-')) ||
5030 (*in == 0x09)) {
5031 in++;
5035 if (*in == 0xA) {
5038 in++;
5039 } while (*in == 0xA);
5042 nbchar = in - ctxt->input->cur;
5050 if ((*in == '-') && (in[1] == '-'))
5086 ctxt->input->cur = in;
5087 if (*in == 0xA) {
5088 in++;
5091 if (*in == 0xD) {
5092 in++;
5093 if (*in == 0xA) {
5094 ctxt->input->cur = in;
5095 in++;
5099 in--;
5107 in = ctxt->input->cur;
5108 if (*in == '-') {
5109 if (in[1] == '-') {
5110 if (in[2] == '>') {
5113 "comment doesn't start and stop in the same entity\n");
5137 in++;
5140 in++;
5144 } while (((*in >= 0x20) && (*in <= 0x7F)) || (*in == 0x09));
5207 * Occurs only if allowed by the user and if happening in the Misc
5209 * This will add the given catalog to the parsing context in order
5210 * to be used if there is a resolution need further down in the document
5299 "PI declaration doesn't start and stop in the same entity\n");
5383 "PI declaration doesn't start and stop in the same entity\n");
5475 "Notation declaration doesn't start and stop in the same entity\n");
5521 /* GROW; done in the caller */
5618 * For expat compatibility in SAX mode.
5689 * For expat compatibility in SAX mode.
5724 "Entity declaration doesn't start and stop in the same entity\n");
5771 * attribute must be specified for all elements of the type in the
5782 * [ WFC: No < in Attribute Values ]
5783 * handled in xmlParseAttValue()
5835 * in the declaration; all notation names in the declaration must be declared.
5856 "Name expected in NOTATION declaration\n");
5904 * Values of this type must match one of the Nmtoken tokens in
6012 * Validity constraints for attribute values syntax are checked in
6017 * appear more than once in an XML document as a value of this type;
6029 * of an ID attribute on some element in the XML document; i.e. IDREF
6035 * name of an unparsed entity declared in the DTD.
6171 "in xmlParseAttributeListDecl\n");
6200 "Attribute list declaration doesn't start and stop in the same entity\n",
6214 * The leading '(' and spaces have been skipped in xmlParseElementContentDecl
6222 * The same name must not appear more than once in a single
6240 "Element content declaration doesn't start and stop in the same entity\n",
6299 "Element content declaration doesn't start and stop in the same entity\n",
6322 * The leading '(' and spaces have been skipped in xmlParseElementContentDecl
6336 * opening or closing parentheses in a choice, seq, or Mixed
6337 * construct is contained in the replacement text for a parameter
6338 * entity, both must be contained in the same replacement text. For
6339 * interoperability, if a parameter-entity reference appears in a
6542 "Element content declaration doesn't start and stop in the same entity\n",
6619 * The leading '(' and spaces have been skipped in xmlParseElementContentDecl
6632 * opening or closing parentheses in a choice, seq, or Mixed
6633 * construct is contained in the replacement text for a parameter
6634 * entity, both must be contained in the same replacement text. For
6635 * interoperability, if a parameter-entity reference appears in a
6656 * the cases EMPTY and ANY are handled directly in xmlParseElementDecl
6706 * Returns the type of the element, or -1 in case of error
6714 /* GROW; done in the caller */
6755 * [ WFC: PEs in Internal Subset ] error handling.
6760 "PEReference: forbidden within markup decl in internal subset\n");
6784 "Element declaration doesn't start and stop in the same entity\n");
6838 "All markup of the conditional section is not in the same entity\n",
6901 "All markup of the conditional section is not in the same entity\n",
6917 * But disable SAX event generating DTD building in the meantime
6965 "All markup of the conditional section is not in the same entity\n",
6987 * contained in the replacement text for a parameter-entity reference,
6988 * both must be contained in the same replacement text.
6990 * [ WFC: PEs in Internal Subset ]
6991 * In the internal DTD subset, parameter-entity references can occur
6993 * (This does not apply to references that occur in external parameter
7042 * by PE References in the internal subset.
7109 "Missing encoding in text declaration\n");
7219 * parse and handle entity references in content, depending on the SAX
7220 * interface, this may end-up in a call to character() if this is a
7272 * Just encode the value in UTF-8
7381 * Prune it directly in the generated document
7441 * Probably running in SAX mode and the callbacks don't
7512 * and, if it's NULL, we copy in whatever was in the entity.
7521 * In the first occurrence list contains the replacement.
7555 * node cases in
7636 * characters() in SAX.c
7654 * In a document without any DTD, a document with only an internal DTD
7656 * with "standalone='yes'", the Name given in the entity reference
7657 * must match that in an entity declaration, except that well-formed
7661 * must precede any reference to it which appears in a default value in an
7662 * attribute-list declaration. Note that if entities are declared in the
7663 * external subset or in external parameter entities, a non-validating
7713 * entities which may have stored in the parser context.
7730 * In a document without any DTD, a document with only an
7733 * Name given in the entity reference must match that in an
7740 * precede any reference to it which appears in a default
7741 * value in an attribute-list declaration. Note that if
7742 * entities are declared in the external subset or in
7789 * [ WFC: No < in Attribute Values ]
7791 * indirectly in an attribute value (other than "<") must
7800 "'<' in entity '%s' is not allowed in attributes values\n", name);
7832 * @str: a pointer to an index in the string
7840 * In a document without any DTD, a document with only an internal DTD
7842 * with "standalone='yes'", the Name given in the entity reference
7843 * must match that in an entity declaration, except that well-formed
7847 * must precede any reference to it which appears in a default value in an
7848 * attribute-list declaration. Note that if entities are declared in the
7849 * external subset or in external parameter entities, a non-validating
7858 * is updated to the current location in the string.
7910 * entities which may have stored in the parser context.
7928 * In a document without any DTD, a document with only an
7931 * Name given in the entity reference must match that in an
7938 * precede any reference to it which appears in a default
7939 * value in an attribute-list declaration. Note that if
7940 * entities are declared in the external subset or in
7983 * [ WFC: No < in Attribute Values ]
7985 * indirectly in an attribute value (other than "<") must
7993 "'<' in entity '%s' is not allowed in attributes values\n",
8040 * In a document without any DTD, a document with only an internal DTD
8046 * In a document with an external subset or external parameter entities
8050 * [ WFC: In DTD ]
8051 * Parameter-entity references may only appear in the DTD.
8093 * In a document without any DTD, a document with only an
8108 * In a document with an external subset or external
8121 * Internal checking in case the entity quest barfed
8174 * ExternalID/SystemID given. This is to be used for Included in Literal
8177 * Returns 0 in case of success and -1 in case of failure
8268 * @str: a pointer to an index in the string
8279 * In a document without any DTD, a document with only an internal DTD
8285 * In a document with an external subset or external parameter entities
8289 * [ WFC: In DTD ]
8290 * Parameter-entity references may only appear in the DTD.
8343 * In a document without any DTD, a document with only an
8356 * In a document with an external subset or external
8369 * Internal checking in case the entity quest barfed
8394 * The Name in the document type declaration must match the element
8447 * they are handled separately in xmlParseInternalSubset()
8499 "xmlParseInternalSubset: error detected in Markup declaration\n");
8533 * [ WFC: No < in Attribute Values ]
8534 * The replacement text of any entity referred to directly or indirectly in
8550 * Returns the attribute name, and the value in *value.
8585 * since this was deprecated in XML second edition
8619 * EmptyElement. In both case we don't parse the tag closing chars.
8624 * No attribute name may appear more than once in the same start-tag or
8630 * No attribute name may appear more than once in the same start-tag or
8680 * No attribute name may appear more than once in the same
8811 * The Name in an element's end-tag must match the element type in the
8980 const xmlChar *in;
8987 in = ctxt->input->cur;
8990 while (*in != 0 && *in == *cmp) {
8991 ++in;
8994 if ((*cmp == 0) && (*in == ':')) {
8995 in++;
8997 while (*in != 0 && *in == *cmp) {
8998 ++in;
9001 if (*cmp == 0 && (*in == '>' || IS_BLANK_CH (*in))) {
9003 ctxt->input->cur = in;
9055 const xmlChar *in = NULL, *start, *end, *last;
9060 in = (xmlChar *) CUR_PTR;
9063 if (*in != '"' && *in != '\'') {
9070 * try to handle in this routine the most common case where no
9074 limit = *in++;
9077 start = in;
9078 if (in >= end) {
9084 in = in + delta;
9092 while ((in < end) && (*in != limit) &&
9093 ((*in == 0x20) || (*in == 0x9) ||
9094 (*in == 0xA) || (*in == 0xD))) {
9095 if (*in == 0xA) {
9100 in++;
9101 start = in;
9102 if (in >= end) {
9110 in = in + delta;
9113 if (((in - start) > XML_MAX_TEXT_LENGTH) &&
9121 while ((in < end) && (*in != limit) && (*in >= 0x20) &&
9122 (*in <= 0x7f) && (*in != '&') && (*in != '<')) {
9124 if ((*in++ == 0x20) && (*in == 0x20)) break;
9125 if (in >= end) {
9133 in = in + delta;
9136 if (((in - start) > XML_MAX_TEXT_LENGTH) &&
9144 last = in;
9149 while ((in < end) && (*in != limit) &&
9150 ((*in == 0x20) || (*in == 0x9) ||
9151 (*in == 0xA) || (*in == 0xD))) {
9152 if (*in == 0xA) {
9157 in++;
9158 if (in >= end) {
9166 in = in + delta;
9170 if (((in - start) > XML_MAX_TEXT_LENGTH) &&
9178 if (((in - start) > XML_MAX_TEXT_LENGTH) &&
9184 if (*in != limit) goto need_complex;
9186 while ((in < end) && (*in != limit) && (*in >= 0x20) &&
9187 (*in <= 0x7f) && (*in != '&') && (*in != '<')) {
9188 in++;
9190 if (in >= end) {
9198 in = in + delta;
9201 if (((in - start) > XML_MAX_TEXT_LENGTH) &&
9209 last = in;
9210 if (((in - start) > XML_MAX_TEXT_LENGTH) &&
9216 if (*in != limit) goto need_complex;
9218 in++;
9227 CUR_PTR = in;
9247 * parse an attribute in the new SAX2 framework.
9249 * Returns the attribute name, and the value in *value, .
9295 * have been used in the attribute value, i.e. the attribute
9296 * value have been extracted in an allocated string already.
9320 * since this was deprecated in XML second edition
9359 * EmptyElement. In both case we don't parse the tag closing chars.
9365 * No attribute name may appear more than once in the same start-tag or
9371 * No attribute name may appear more than once in the same start-tag or
9769 * No attribute name may appear more than once in the same
9771 * As extended by the Namespace in XML REC.
9781 "Namespaced Attribute %s in '%s' redefined\n",
9834 * We can't switch from one entity to another in the middle
9839 "Start tag doesn't start and stop in the same entity\n");
9913 * The Name in an element's end-tag must match the element type in the
10127 "detected an error in element content\n");
10143 * The Name in an element's end-tag must match the element type in the
10161 "Excessive depth in document: %d use XML_PARSE_HUGE option\n",
10202 * The Name in the document type declaration must match the element
10276 "Premature end of data in tag %s line %d\n",
10322 * In practice allow [0-9].[0-9]+ at that level
10610 * attributes apply appear in the document without specifications
10613 * to those entities appear in the document, or
10615 * attribute appears in the document with a value which will change
10831 * Returns 0, -1 in case of error. the parser context is augmented
10884 * Check for the XMLDecl in the Prolog.
11024 * Returns 0, -1 in case of error. the parser context is augmented
11070 * Check for the XMLDecl in the Prolog.
11137 * (first) is available in the input stream.
11149 xmlParserInputPtr in;
11152 in = ctxt->input;
11153 if (in == NULL) return(-1);
11154 base = in->cur - in->base;
11158 if (in->buf == NULL) {
11159 buf = in->base;
11160 len = in->length;
11162 buf = xmlBufContent(in->buf->buffer);
11163 len = xmlBufUse(in->buf->buffer);
11191 return(base - (in->cur - in->base));
11215 * Lookup the last < and > in the current chunk
11269 * @len: length of the block in bytes
11270 * @complete: 1 if complete CDATA block is passed in, 0 if partial block
11431 * remainng chars to avoid them stalling in the non-converted
11432 * buffer. But do not do this in document start where
11590 /* > can be found unescaped in attribute values */
11623 * The Name in the document type declaration must match
11754 * - tries to homogenize the differences in SAX
11781 "detected an error in element content\n");
11792 /* > can be found unescaped in attribute values */
12119 * Internal subset ends up with "']' S? '>'" in an unescaped
12120 * section and not in a ']]>' sequence which are conditional
12121 * sections (whoever argued to keep that crap in XML deserve
12122 * a place in hell !).
12342 * @size: the size in byte of the chunk
12347 * Returns -1 in case of error, 0 if the push is not needed and 1 if needed
12391 * @size: the size in byte of the chunk
12454 * if size is greater than len. Otherwise, memmove in xmlBufferAdd
12477 xmlParserInputBufferPtr in = ctxt->input->buf;
12478 if ((in->encoder != NULL) && (in->buffer != NULL) &&
12479 (in->raw != NULL)) {
12481 size_t base = xmlBufGetInputBase(in->buffer, ctxt->input);
12484 nbchars = xmlCharEncInput(in, terminate);
12491 xmlBufSetInputBaseCur(in->buffer, ctxt->input, base, current);
12502 * a good idea to try parsing if there is nothing in the chunk
12588 * @size: number of chars in the array
12591 * Create a parser context for using the XML parser in push mode.
12594 * don't need to be fed in again through xmlParseChunk.
12723 * in case there was a specific allocation deallocate before
12830 * Returns the resulting xmlDtdPtr or NULL in case of error.
12831 * @input will be freed by the function in any case.
12962 * Returns the resulting xmlDtdPtr or NULL in case of error.
13093 * Returns the resulting xmlDtdPtr or NULL in case of error.
13121 * Returns 0 if the entity is well formed, -1 in case of args problem and
13227 * useData callback field, otherwise the expected setup in a
13326 * Returns 0 if the entity is well formed, -1 in case of args problem and
13484 * Record in the parent context the number of entities replacement
13538 * Returns 0 if the entity is well formed, -1 in case of args problem and
13555 * @string: the input string in UTF8 or ISO-Latin (zero terminated)
13561 * the content production in the XML grammar:
13565 * Returns 0 if the chunk is well balanced, -1 in case of args problem and
13580 * @string: the input string in UTF8 or ISO-Latin (zero terminated)
13588 * the content production in the XML grammar:
13595 * In case recover is set to 1, the nodelist will not be empty even if
13690 * ID/IDREF registration will be done in xmlValidateElement below
13747 * Record in the parent context the number of entities replacement
13775 * @datalen: the input string length in bytes
13783 * the content production in the XML grammar:
13836 * node position in the tree
13844 * When parsing in context, it makes no sense to add implied
13886 /* parsing in context, i.e. as within existing content */
13927 * ID/IDREF registration will be done in xmlValidateElement below
14005 * @string: the input string in UTF8 or ISO-Latin (zero terminated)
14013 * the content production in the XML grammar:
14017 * Returns 0 if the chunk is well balanced, -1 in case of args problem and
14020 * In case recover is set to 1, the nodelist will not be empty even if
14384 * @recovery: work in recovery mode, i.e. tries to read no Well Formed
14393 * User data (void *) is stored within the parser context in the
14394 * context's _private member, so it is available nearly everywhere in libxml
14453 * @recovery: work in recovery mode, i.e. tries to read no Well Formed
14474 * parse an XML in-memory document and build a tree.
14475 * In the case the document is not Well Formed, a attempt to build a
14478 * Returns the resulting document tree or NULL in case of failure
14508 * In the case the document is not Well Formed, it attempts to build
14511 * Returns the resulting document tree or NULL in case of failure
14564 * Returns 0 in case of success or a error number otherwise
14615 * Create a parser context for an XML in-memory document.
14662 * @recovery: work in recovery mode, i.e. tries to read no Well Formed
14666 * parse an XML in-memory block and use the given SAX function block
14670 * User data (void *) is stored within the parser context in the
14671 * context's _private member, so it is available nearly everywhere in libxml
14718 * @recovery: work in recovery mode, i.e. tries to read not Well Formed
14721 * parse an XML in-memory block and use the given SAX function block
14738 * parse an XML in-memory block and build a tree.
14752 * parse an XML in-memory block and build a tree.
14753 * In the case the document is not Well Formed, an attempt to
14756 * Returns the resulting document tree or NULL in case of error
14767 * @buffer: an in-memory XML document input
14768 * @size: the length of the XML document in bytes
14771 * parse an XML in-memory buffer and call the given SAX handler routines.
14773 * Returns 0 in case of success or a error number otherwise
14818 * Creates a parser context for an XML in-memory document.
14837 * @recovery: work in recovery mode, i.e. tries to read no Well Formed
14840 * parse an XML in-memory document and build a tree.
14883 * parse an XML in-memory document and build a tree.
14952 * This is not reentrant. Call once before processing in case of
14953 * use in multithreaded programs.
15008 * guess if libxml2 is in use in the application, some libraries
15009 * or plugins may use it without notice. In case of doubt abstain
15049 * Free a string if it is not owned by the "dict" dictionary in the
15160 * @size: number of chars in the array
15166 * Returns 0 in case of success and 1 in case of error
15268 * Returns 0 in case of success, the set of unknown or unimplemented options
15269 * in case of error.
15409 * Returns 0 in case of success, the set of unknown or unimplemented options
15410 * in case of error.
15471 * parse an XML in-memory document and build a tree.
15520 * parse an XML in-memory document and build a tree.
15634 * parse an XML in-memory document and build a tree.
15704 * parse an XML in-memory document and build a tree.
