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
196 * use the number of parsed entities in the replacement
369 errmsg = "PEReference in prolog";
372 errmsg = "PEReference in epilog";
387 errmsg = "PEReferences forbidden in internal subset";
396 errmsg = "Unescaped '<' not allowed in attributes values";
405 errmsg = "Sequence ']]>' not allowed in content";
438 errmsg = "NmToken expected in ATTLIST enumeration";
457 "PEReference: forbidden within markup decl in internal subset";
466 errmsg = "Content error in the external subset";
1091 * Normalize the space in non CDATA attribute values:
1129 * Normalize the space in non CDATA attribute values, a slightly more complex
1579 * Returns -1 in case of error, -2 if the namespace should be discarded
1580 * and the index in the stack otherwise.
1589 /* in scope */
1694 * Returns -1 in case of error, the index in the stack otherwise
1752 * Returns -1 in case of error, the index in the stack otherwise
1774 "Excessive depth in document: %d use XML_PARSE_HUGE option\n",
1820 * Returns -1 in case of error, the index in the stack otherwise
1890 * Returns -1 in case of error, the index in the stack otherwise
1986 * RAW same as CUR but in the input buffer, bypass any token
1997 * in UTF-8 mode. It also pop-up unfinished entities on the fly.
2124 * skip all blanks character found at that point in the input streams.
2125 * It pops up finished entities in the process if allowable at that point.
2141 * if we are in the document content, go really fast
2197 * Returns the current xmlChar in the parser context
2219 * Returns -1 in case of error or the index in the input stack
2254 * Returns the value parsed (as an int), 0 in case of error
2350 * @str: a pointer to an index in the string
2362 * Returns the value parsed (as an int), 0 in case of error, str will be
2500 * In a document without any DTD, a document with only an internal DTD
2506 * In a document with an external subset or external parameter entities
2510 * [ WFC: In DTD ]
2511 * Parameter-entity references may only appear in the DTD.
2514 * A PEReference may have been detected in the current input stream
2518 * - Included in literal in entity values
2558 * NOTE: in the case of entity values, we don't do the
2567 * [WFC: Well-Formedness Constraint: PEs in Internal Subset]
2568 * In the internal DTD subset, parameter-entity references
2571 * In that case this is handled in xmlParseMarkupDecl
2600 * In a document without any DTD, a document with only an
2614 * In a document with an external subset or external
2673 * the amount of data in the buffer.
2978 * Look if the element is mixed content in the DTD if available
3207 * characters for Name and NmToken in the Revision 5 of XML-1.0
3209 * changes in that revision. Also note that the macros used for the
3424 const xmlChar *in;
3437 in = ctxt->input->cur;
3438 if (((*in >= 0x61) && (*in <= 0x7A)) ||
3439 ((*in >= 0x41) && (*in <= 0x5A)) ||
3440 (*in == '_') || (*in == ':')) {
3441 in++;
3442 while (((*in >= 0x61) && (*in <= 0x7A)) ||
3443 ((*in >= 0x41) && (*in <= 0x5A)) ||
3444 ((*in >= 0x30) && (*in <= 0x39)) ||
3445 (*in == '_') || (*in == '-') ||
3446 (*in == ':') || (*in == '.'))
3447 in++;
3448 if ((*in > 0) && (*in < 0x80)) {
3449 count = in - ctxt->input->cur;
3456 ctxt->input->cur = in;
3548 const xmlChar *in, *e;
3559 in = ctxt->input->cur;
3561 if ((((*in >= 0x61) && (*in <= 0x7A)) ||
3562 ((*in >= 0x41) && (*in <= 0x5A)) ||
3563 (*in == '_')) && (in < e)) {
3564 in++;
3565 while ((((*in >= 0x61) && (*in <= 0x7A)) ||
3566 ((*in >= 0x41) && (*in <= 0x5A)) ||
3567 ((*in >= 0x30) && (*in <= 0x39)) ||
3568 (*in == '_') || (*in == '-') ||
3569 (*in == '.')) && (in < e))
3570 in++;
3571 if (in >= e)
3573 if ((*in > 0) && (*in < 0x80)) {
3574 count = in - ctxt->input->cur;
3581 ctxt->input->cur = in;
3608 register const xmlChar *in;
3615 in = ctxt->input->cur;
3616 while (*in != 0 && *in == *cmp) {
3617 ++in;
3621 if (*cmp == 0 && (*in == '>' || IS_BLANK_CH (*in))) {
3623 ctxt->input->cur = in;
3638 * @str: a pointer to the string pointer (IN/OUT)
3650 * is updated to the current location in the string.
3869 * The content of the entity definition is copied in a buffer.
3882 * NOTE: 4.4.5 Included in Literal
3883 * When a parameter entity reference appears in a literal entity
3884 * value, ... a single or double quote character in the replacement
3887 * In practice it means we stop the loop only when back at parsing
3926 * Raise problem w.r.t. '&' and '%' being used in non-entities
3927 * reference constructs. Note Charref will be handled in
3965 * When a general entity reference appears in the EntityValue in
4054 * The reparsing will be done in xmlStringGetNodeList()
4055 * called by the attribute() function in SAX.c
4192 "invalid character in attribute value\n");
4229 * will be handled later in xmlStringGetNodeList
4441 * used for the test in the inner loop of the char data testing
4488 * reference when it appears in the string "]]>" in content, when that
4496 const xmlChar *in;
4509 in = ctxt->input->cur;
4512 while (*in == 0x20) { in++; ctxt->input->col++; }
4513 if (*in == 0xA) {
4516 in++;
4517 } while (*in == 0xA);
4520 if (*in == '<') {
4521 nbchar = in - ctxt->input->cur;
4524 ctxt->input->cur = in;
4551 while (test_char_data[*in]) {
4552 in++;
4556 if (*in == 0xA) {
4559 in++;
4560 } while (*in == 0xA);
4563 if (*in == ']') {
4564 if ((in[1] == ']') && (in[2] == '>')) {
4566 ctxt->input->cur = in;
4569 in++;
4573 nbchar = in - ctxt->input->cur;
4580 ctxt->input->cur = in;
4602 /* something really bad happened in the SAX callback */
4606 ctxt->input->cur = in;
4607 if (*in == 0xD) {
4608 in++;
4609 if (*in == 0xA) {
4610 ctxt->input->cur = in;
4611 in++;
4615 in--;
4617 if (*in == '<') {
4620 if (*in == '&') {
4627 in = ctxt->input->cur;
4628 } while (((*in >= 0x20) && (*in <= 0x7F)) || (*in == 0x09));
4657 (IS_CHAR(cur))) /* test also done in xmlCurrentChar() */ {
4687 /* something really bad happened in the SAX callback */
4745 * Returns the function returns SystemLiteral and in the second
4815 * @len: number of bytes filles in the buffer
4821 * This is the slow routine in case the accelerator for ascii didn't work
4932 "Comment doesn't start and stop in the same entity\n");
4964 const xmlChar *in;
4985 in = ctxt->input->cur;
4987 if (*in == 0xA) {
4990 in++;
4991 } while (*in == 0xA);
4995 while (((*in > '-') && (*in <= 0x7F)) ||
4996 ((*in >= 0x20) && (*in < '-')) ||
4997 (*in == 0x09)) {
4998 in++;
5002 if (*in == 0xA) {
5005 in++;
5006 } while (*in == 0xA);
5009 nbchar = in - ctxt->input->cur;
5017 if ((*in == '-') && (in[1] == '-'))
5053 ctxt->input->cur = in;
5054 if (*in == 0xA) {
5055 in++;
5058 if (*in == 0xD) {
5059 in++;
5060 if (*in == 0xA) {
5061 ctxt->input->cur = in;
5062 in++;
5066 in--;
5074 in = ctxt->input->cur;
5075 if (*in == '-') {
5076 if (in[1] == '-') {
5077 if (in[2] == '>') {
5080 "comment doesn't start and stop in the same entity\n");
5104 in++;
5107 in++;
5111 } while (((*in >= 0x20) && (*in <= 0x7F)) || (*in == 0x09));
5174 * Occurs only if allowed by the user and if happening in the Misc
5176 * This will add the given catalog to the parsing context in order
5177 * to be used if there is a resolution need further down in the document
5266 "PI declaration doesn't start and stop in the same entity\n");
5350 "PI declaration doesn't start and stop in the same entity\n");
5442 "Notation declaration doesn't start and stop in the same entity\n");
5488 /* GROW; done in the caller */
5585 * For expat compatibility in SAX mode.
5656 * For expat compatibility in SAX mode.
5691 "Entity declaration doesn't start and stop in the same entity\n");
5738 * attribute must be specified for all elements of the type in the
5749 * [ WFC: No < in Attribute Values ]
5750 * handled in xmlParseAttValue()
5802 * in the declaration; all notation names in the declaration must be declared.
5823 "Name expected in NOTATION declaration\n");
5871 * Values of this type must match one of the Nmtoken tokens in
5979 * Validity constraints for attribute values syntax are checked in
5984 * appear more than once in an XML document as a value of this type;
5996 * of an ID attribute on some element in the XML document; i.e. IDREF
6002 * name of an unparsed entity declared in the DTD.
6138 "in xmlParseAttributeListDecl\n");
6167 "Attribute list declaration doesn't start and stop in the same entity\n",
6181 * The leading '(' and spaces have been skipped in xmlParseElementContentDecl
6189 * The same name must not appear more than once in a single
6207 "Element content declaration doesn't start and stop in the same entity\n",
6266 "Element content declaration doesn't start and stop in the same entity\n",
6289 * The leading '(' and spaces have been skipped in xmlParseElementContentDecl
6303 * opening or closing parentheses in a choice, seq, or Mixed
6304 * construct is contained in the replacement text for a parameter
6305 * entity, both must be contained in the same replacement text. For
6306 * interoperability, if a parameter-entity reference appears in a
6509 "Element content declaration doesn't start and stop in the same entity\n",
6586 * The leading '(' and spaces have been skipped in xmlParseElementContentDecl
6599 * opening or closing parentheses in a choice, seq, or Mixed
6600 * construct is contained in the replacement text for a parameter
6601 * entity, both must be contained in the same replacement text. For
6602 * interoperability, if a parameter-entity reference appears in a
6623 * the cases EMPTY and ANY are handled directly in xmlParseElementDecl
6673 * Returns the type of the element, or -1 in case of error
6681 /* GROW; done in the caller */
6721 * [ WFC: PEs in Internal Subset ] error handling.
6726 "PEReference: forbidden within markup decl in internal subset\n");
6750 "Element declaration doesn't start and stop in the same entity\n");
6804 "All markup of the conditional section is not in the same entity\n",
6866 "All markup of the conditional section is not in the same entity\n",
6882 * But disable SAX event generating DTD building in the meantime
6930 "All markup of the conditional section is not in the same entity\n",
6952 * contained in the replacement text for a parameter-entity reference,
6953 * both must be contained in the same replacement text.
6955 * [ WFC: PEs in Internal Subset ]
6956 * In the internal DTD subset, parameter-entity references can occur
6958 * (This does not apply to references that occur in external parameter
7007 * by PE References in the internal subset.
7074 "Missing encoding in text declaration\n");
7184 * parse and handle entity references in content, depending on the SAX
7185 * interface, this may end-up in a call to character() if this is a
7237 * Just encode the value in UTF-8
7346 * Prune it directly in the generated document
7406 * Probably running in SAX mode and the callbacks don't
7477 * and, if it's NULL, we copy in whatever was in the entity.
7486 * In the first occurrence list contains the replacement.
7520 * node cases in the reader tests
7601 * characters() in SAX.c
7619 * In a document without any DTD, a document with only an internal DTD
7621 * with "standalone='yes'", the Name given in the entity reference
7622 * must match that in an entity declaration, except that well-formed
7626 * must precede any reference to it which appears in a default value in an
7627 * attribute-list declaration. Note that if entities are declared in the
7628 * external subset or in external parameter entities, a non-validating
7678 * entities which may have stored in the parser context.
7695 * In a document without any DTD, a document with only an
7698 * Name given in the entity reference must match that in an
7705 * precede any reference to it which appears in a default
7706 * value in an attribute-list declaration. Note that if
7707 * entities are declared in the external subset or in
7754 * [ WFC: No < in Attribute Values ]
7756 * indirectly in an attribute value (other than "<") must
7765 "'<' in entity '%s' is not allowed in attributes values\n", name);
7797 * @str: a pointer to an index in the string
7805 * In a document without any DTD, a document with only an internal DTD
7807 * with "standalone='yes'", the Name given in the entity reference
7808 * must match that in an entity declaration, except that well-formed
7812 * must precede any reference to it which appears in a default value in an
7813 * attribute-list declaration. Note that if entities are declared in the
7814 * external subset or in external parameter entities, a non-validating
7823 * is updated to the current location in the string.
7875 * entities which may have stored in the parser context.
7893 * In a document without any DTD, a document with only an
7896 * Name given in the entity reference must match that in an
7903 * precede any reference to it which appears in a default
7904 * value in an attribute-list declaration. Note that if
7905 * entities are declared in the external subset or in
7948 * [ WFC: No < in Attribute Values ]
7950 * indirectly in an attribute value (other than "<") must
7958 "'<' in entity '%s' is not allowed in attributes values\n",
8005 * In a document without any DTD, a document with only an internal DTD
8011 * In a document with an external subset or external parameter entities
8015 * [ WFC: In DTD ]
8016 * Parameter-entity references may only appear in the DTD.
8058 * In a document without any DTD, a document with only an
8073 * In a document with an external subset or external
8086 * Internal checking in case the entity quest barfed
8131 * ExternalID/SystemID given. This is to be used for Included in Literal
8134 * Returns 0 in case of success and -1 in case of failure
8225 * @str: a pointer to an index in the string
8236 * In a document without any DTD, a document with only an internal DTD
8242 * In a document with an external subset or external parameter entities
8246 * [ WFC: In DTD ]
8247 * Parameter-entity references may only appear in the DTD.
8300 * In a document without any DTD, a document with only an
8313 * In a document with an external subset or external
8326 * Internal checking in case the entity quest barfed
8351 * The Name in the document type declaration must match the element
8404 * they are handled separately in xmlParseInternalSubset()
8456 "xmlParseInternalSubset: error detected in Markup declaration\n");
8489 * [ WFC: No < in Attribute Values ]
8490 * The replacement text of any entity referred to directly or indirectly in
8506 * Returns the attribute name, and the value in *value.
8541 * since this was deprecated in XML second edition
8575 * EmptyElement. In both case we don't parse the tag closing chars.
8580 * No attribute name may appear more than once in the same start-tag or
8586 * No attribute name may appear more than once in the same start-tag or
8636 * No attribute name may appear more than once in the same
8767 * The Name in an element's end-tag must match the element type in the
8936 const xmlChar *in;
8943 in = ctxt->input->cur;
8946 while (*in != 0 && *in == *cmp) {
8947 ++in;
8950 if ((*cmp == 0) && (*in == ':')) {
8951 in++;
8953 while (*in != 0 && *in == *cmp) {
8954 ++in;
8957 if (*cmp == 0 && (*in == '>' || IS_BLANK_CH (*in))) {
8959 ctxt->input->cur = in;
9011 const xmlChar *in = NULL, *start, *end, *last;
9016 in = (xmlChar *) CUR_PTR;
9019 if (*in != '"' && *in != '\'') {
9026 * try to handle in this routine the most common case where no
9030 limit = *in++;
9033 start = in;
9034 if (in >= end) {
9040 in = in + delta;
9048 while ((in < end) && (*in != limit) &&
9049 ((*in == 0x20) || (*in == 0x9) ||
9050 (*in == 0xA) || (*in == 0xD))) {
9051 if (*in == 0xA) {
9056 in++;
9057 start = in;
9058 if (in >= end) {
9066 in = in + delta;
9069 if (((in - start) > XML_MAX_TEXT_LENGTH) &&
9077 while ((in < end) && (*in != limit) && (*in >= 0x20) &&
9078 (*in <= 0x7f) && (*in != '&') && (*in != '<')) {
9080 if ((*in++ == 0x20) && (*in == 0x20)) break;
9081 if (in >= end) {
9089 in = in + delta;
9092 if (((in - start) > XML_MAX_TEXT_LENGTH) &&
9100 last = in;
9105 while ((in < end) && (*in != limit) &&
9106 ((*in == 0x20) || (*in == 0x9) ||
9107 (*in == 0xA) || (*in == 0xD))) {
9108 if (*in == 0xA) {
9113 in++;
9114 if (in >= end) {
9122 in = in + delta;
9126 if (((in - start) > XML_MAX_TEXT_LENGTH) &&
9134 if (((in - start) > XML_MAX_TEXT_LENGTH) &&
9140 if (*in != limit) goto need_complex;
9142 while ((in < end) && (*in != limit) && (*in >= 0x20) &&
9143 (*in <= 0x7f) && (*in != '&') && (*in != '<')) {
9144 in++;
9146 if (in >= end) {
9154 in = in + delta;
9157 if (((in - start) > XML_MAX_TEXT_LENGTH) &&
9165 last = in;
9166 if (((in - start) > XML_MAX_TEXT_LENGTH) &&
9172 if (*in != limit) goto need_complex;
9174 in++;
9183 CUR_PTR = in;
9203 * parse an attribute in the new SAX2 framework.
9205 * Returns the attribute name, and the value in *value, .
9251 * have been used in the attribute value, i.e. the attribute
9252 * value have been extracted in an allocated string already.
9276 * since this was deprecated in XML second edition
9315 * EmptyElement. In both case we don't parse the tag closing chars.
9321 * No attribute name may appear more than once in the same start-tag or
9327 * No attribute name may appear more than once in the same start-tag or
9717 * No attribute name may appear more than once in the same
9719 * As extended by the Namespace in XML REC.
9729 "Namespaced Attribute %s in '%s' redefined\n",
9782 * We can't switch from one entity to another in the middle
9787 "Start tag doesn't start and stop in the same entity\n");
9857 * The Name in an element's end-tag must match the element type in the
10071 "detected an error in element content\n");
10087 * The Name in an element's end-tag must match the element type in the
10105 "Excessive depth in document: %d use XML_PARSE_HUGE option\n",
10146 * The Name in the document type declaration must match the element
10220 "Premature end of data in tag %s line %d\n",
10266 * In practice allow [0-9].[0-9]+ at that level
10554 * attributes apply appear in the document without specifications
10557 * to those entities appear in the document, or
10559 * attribute appears in the document with a value which will change
10775 * Returns 0, -1 in case of error. the parser context is augmented
10828 * Check for the XMLDecl in the Prolog.
10968 * Returns 0, -1 in case of error. the parser context is augmented
11014 * Check for the XMLDecl in the Prolog.
11081 * (first) is available in the input stream.
11093 xmlParserInputPtr in;
11096 in = ctxt->input;
11097 if (in == NULL) return(-1);
11098 base = in->cur - in->base;
11102 if (in->buf == NULL) {
11103 buf = in->base;
11104 len = in->length;
11106 buf = xmlBufContent(in->buf->buffer);
11107 len = xmlBufUse(in->buf->buffer);
11135 return(base - (in->cur - in->base));
11159 * Lookup the last < and > in the current chunk
11213 * @len: length of the block in bytes
11374 * remainng chars to avoid them stalling in the non-converted
11375 * buffer. But do not do this in document start where
11533 /* > can be found unescaped in attribute values */
11566 * The Name in the document type declaration must match
11697 * - tries to homogenize the differences in SAX
11724 "detected an error in element content\n");
11735 /* > can be found unescaped in attribute values */
12062 * Internal subset ends up with "']' S? '>'" in an unescaped
12063 * section and not in a ']]>' sequence which are conditional
12064 * sections (whoever argued to keep that crap in XML deserve
12065 * a place in hell !).
12285 * @size: the size in byte of the chunk
12290 * Returns -1 in case of error, 0 if the push is not needed and 1 if needed
12334 * @size: the size in byte of the chunk
12397 * if size is greater than len. Otherwise, memmove in xmlBufferAdd
12420 xmlParserInputBufferPtr in = ctxt->input->buf;
12421 if ((in->encoder != NULL) && (in->buffer != NULL) &&
12422 (in->raw != NULL)) {
12424 size_t base = xmlBufGetInputBase(in->buffer, ctxt->input);
12427 nbchars = xmlCharEncInput(in, terminate);
12434 xmlBufSetInputBaseCur(in->buffer, ctxt->input, base, current);
12445 * a good idea to try parsing if there is nothing in the chunk
12531 * @size: number of chars in the array
12534 * Create a parser context for using the XML parser in push mode.
12537 * don't need to be fed in again through xmlParseChunk.
12666 * in case there was a specific allocation deallocate before
12773 * Returns the resulting xmlDtdPtr or NULL in case of error.
12774 * @input will be freed by the function in any case.
12905 * Returns the resulting xmlDtdPtr or NULL in case of error.
13036 * Returns the resulting xmlDtdPtr or NULL in case of error.
13064 * Returns 0 if the entity is well formed, -1 in case of args problem and
13170 * useData callback field, otherwise the expected setup in a
13269 * Returns 0 if the entity is well formed, -1 in case of args problem and
13427 * Record in the parent context the number of entities replacement
13481 * Returns 0 if the entity is well formed, -1 in case of args problem and
13498 * @string: the input string in UTF8 or ISO-Latin (zero terminated)
13504 * the content production in the XML grammar:
13508 * Returns 0 if the chunk is well balanced, -1 in case of args problem and
13523 * @string: the input string in UTF8 or ISO-Latin (zero terminated)
13531 * the content production in the XML grammar:
13538 * In case recover is set to 1, the nodelist will not be empty even if
13633 * ID/IDREF registration will be done in xmlValidateElement below
13690 * Record in the parent context the number of entities replacement
13718 * @datalen: the input string length in bytes
13726 * the content production in the XML grammar:
13779 * node position in the tree
13787 * When parsing in context, it makes no sense to add implied
13829 /* parsing in context, i.e. as within existing content */
13870 * ID/IDREF registration will be done in xmlValidateElement below
13948 * @string: the input string in UTF8 or ISO-Latin (zero terminated)
13956 * the content production in the XML grammar:
13960 * Returns 0 if the chunk is well balanced, -1 in case of args problem and
13963 * In case recover is set to 1, the nodelist will not be empty even if
14327 * @recovery: work in recovery mode, i.e. tries to read no Well Formed
14336 * User data (void *) is stored within the parser context in the
14337 * context's _private member, so it is available nearly everywhere in libxml
14396 * @recovery: work in recovery mode, i.e. tries to read no Well Formed
14417 * parse an XML in-memory document and build a tree.
14418 * In the case the document is not Well Formed, a attempt to build a
14421 * Returns the resulting document tree or NULL in case of failure
14451 * In the case the document is not Well Formed, it attempts to build
14454 * Returns the resulting document tree or NULL in case of failure
14507 * Returns 0 in case of success or a error number otherwise
14558 * Create a parser context for an XML in-memory document.
14605 * @recovery: work in recovery mode, i.e. tries to read no Well Formed
14609 * parse an XML in-memory block and use the given SAX function block
14613 * User data (void *) is stored within the parser context in the
14614 * context's _private member, so it is available nearly everywhere in libxml
14661 * @recovery: work in recovery mode, i.e. tries to read not Well Formed
14664 * parse an XML in
14681 * parse an XML in-memory block and build a tree.
14695 * parse an XML in-memory block and build a tree.
14696 * In the case the document is not Well Formed, an attempt to
14699 * Returns the resulting document tree or NULL in case of error
14710 * @buffer: an in-memory XML document input
14711 * @size: the length of the XML document in bytes
14714 * parse an XML in-memory buffer and call the given SAX handler routines.
14716 * Returns 0 in case of success or a error number otherwise
14761 * Creates a parser context for an XML in-memory document.
14780 * @recovery: work in recovery mode, i.e. tries to read no Well Formed
14783 * parse an XML in-memory document and build a tree.
14826 * parse an XML in-memory document and build a tree.
14895 * This is not reentrant. Call once before processing in case of
14896 * use in multithreaded programs.
14951 * guess if libxml2 is in use in the application, some libraries
14952 * or plugins may use it without notice. In case of doubt abstain
14992 * Free a string if it is not owned by the "dict" dictionnary in the
15103 * @size: number of chars in the array
15109 * Returns 0 in case of success and 1 in case of error
15211 * Returns 0 in case of success, the set of unknown or unimplemented options
15212 * in case of error.
15352 * Returns 0 in case of success, the set of unknown or unimplemented options
15353 * in case of error.
15414 * parse an XML in-memory document and build a tree.
15463 * parse an XML in-memory document and build a tree.
15577 * parse an XML in-memory document and build a tree.
15647 * parse an XML in-memory document and build a tree.
