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
99 * Arbitrary limits set in the parser. See XML_PARSE_HUGE *
108 * replacement over the size in byte of the input indicates that you have
171 * use the number of parsed entities in the replacement
341 errmsg = "PEReference in prolog";
344 errmsg = "PEReference in epilog";
359 errmsg = "PEReferences forbidden in internal subset";
368 errmsg = "Unescaped '<' not allowed in attributes values";
377 errmsg = "Sequence ']]>' not allowed in content";
410 errmsg = "NmToken expected in ATTLIST enumeration";
429 "PEReference: forbidden within markup decl in internal subset";
438 errmsg = "Content error in the external subset";
1063 * Normalize the space in non CDATA attribute values:
1101 * Normalize the space in non CDATA attribute values, a slightly more complex
1551 * Returns -1 in case of error, -2 if the namespace should be discarded
1552 * and the index in the stack otherwise.
1561 /* in scope */
1666 * Returns -1 in case of error, the index in the stack otherwise
1724 * Returns -1 in case of error, the index in the stack otherwise
1746 "Excessive depth in document: %d use XML_PARSE_HUGE option\n",
1792 * Returns -1 in case of error, the index in the stack otherwise
1862 * Returns -1 in case of error, the index in the stack otherwise
1958 * RAW same as CUR but in the input buffer, bypass any token
1969 * in UTF-8 mode. It also pop-up unfinished entities on the fly.
2086 * skip all blanks character found at that point in the input streams.
2087 * It pops up finished entities in the process if allowable at that point.
2103 * if we are in the document content, go really fast
2155 * Returns the current xmlChar in the parser context
2177 * Returns -1 in case of error or the index in the input stack
2212 * Returns the value parsed (as an int), 0 in case of error
2308 * @str: a pointer to an index in the string
2320 * Returns the value parsed (as an int), 0 in case of error, str will be
2458 * In a document without any DTD, a document with only an internal DTD
2464 * In a document with an external subset or external parameter entities
2468 * [ WFC: In DTD ]
2469 * Parameter-entity references may only appear in the DTD.
2472 * A PEReference may have been detected in the current input stream
2476 * - Included in literal in entity values
2516 * NOTE: in the case of entity values, we don't do the
2525 * [WFC: Well-Formedness Constraint: PEs in Internal Subset]
2526 * In the internal DTD subset, parameter-entity references
2529 * In that case this is handled in xmlParseMarkupDecl
2558 * In a document without any DTD, a document with only an
2572 * In a document with an external subset or external
2613 * the amount of data in the buffer.
2912 * Look if the element is mixed content in the DTD if available
3141 * characters for Name and NmToken in the Revision 5 of XML-1.0
3143 * changes in that revision. Also note that the macros used for the
3358 const xmlChar *in;
3371 in = ctxt->input->cur;
3372 if (((*in >= 0x61) && (*in <= 0x7A)) ||
3373 ((*in >= 0x41) && (*in <= 0x5A)) ||
3374 (*in == '_') || (*in == ':')) {
3375 in++;
3376 while (((*in >= 0x61) && (*in <= 0x7A)) ||
3377 ((*in >= 0x41) && (*in <= 0x5A)) ||
3378 ((*in >= 0x30) && (*in <= 0x39)) ||
3379 (*in == '_') || (*in == '-') ||
3380 (*in == ':') || (*in == '.'))
3381 in++;
3382 if ((*in > 0) && (*in < 0x80)) {
3383 count = in - ctxt->input->cur;
3390 ctxt->input->cur = in;
3471 const xmlChar *in;
3482 in = ctxt->input->cur;
3483 if (((*in >= 0x61) && (*in <= 0x7A)) ||
3484 ((*in >= 0x41) && (*in <= 0x5A)) ||
3485 (*in == '_')) {
3486 in++;
3487 while (((*in >= 0x61) && (*in <= 0x7A)) ||
3488 ((*in >= 0x41) && (*in <= 0x5A)) ||
3489 ((*in >= 0x30) && (*in <= 0x39)) ||
3490 (*in == '_') || (*in == '-') ||
3491 (*in == '.'))
3492 in++;
3493 if ((*in > 0) && (*in < 0x80)) {
3494 count = in - ctxt->input->cur;
3501 ctxt->input->cur = in;
3527 register const xmlChar *in;
3534 in = ctxt->input->cur;
3535 while (*in != 0 && *in == *cmp) {
3536 ++in;
3540 if (*cmp == 0 && (*in == '>' || IS_BLANK_CH (*in))) {
3542 ctxt->input->cur = in;
3557 * @str: a pointer to the string pointer (IN/OUT)
3569 * is updated to the current location in the string.
3788 * The content of the entity definition is copied in a buffer.
3801 * NOTE: 4.4.5 Included in Literal
3802 * When a parameter entity reference appears in a literal entity
3803 * value, ... a single or double quote character in the replacement
3806 * In practice it means we stop the loop only when back at parsing
3845 * Raise problem w.r.t. '&' and '%' being used in non-entities
3846 * reference constructs. Note Charref will be handled in
3884 * When a general entity reference appears in the EntityValue in
3973 * The reparsing will be done in xmlStringGetNodeList()
3974 * called by the attribute() function in SAX.c
4111 "invalid character in attribute value\n");
4148 * will be handled later in xmlStringGetNodeList
4360 * used for the test in the inner loop of the char data testing
4407 * reference when it appears in the string "]]>" in content, when that
4415 const xmlChar *in;
4428 in = ctxt->input->cur;
4431 while (*in == 0x20) { in++; ctxt->input->col++; }
4432 if (*in == 0xA) {
4435 in++;
4436 } while (*in == 0xA);
4439 if (*in == '<') {
4440 nbchar = in - ctxt->input->cur;
4443 ctxt->input->cur = in;
4470 while (test_char_data[*in]) {
4471 in++;
4475 if (*in == 0xA) {
4478 in++;
4479 } while (*in == 0xA);
4482 if (*in == ']') {
4483 if ((in[1] == ']') && (in[2] == '>')) {
4485 ctxt->input->cur = in;
4488 in++;
4492 nbchar = in - ctxt->input->cur;
4499 ctxt->input->cur = in;
4521 /* something really bad happened in the SAX callback */
4525 ctxt->input->cur = in;
4526 if (*in == 0xD) {
4527 in++;
4528 if (*in == 0xA) {
4529 ctxt->input->cur = in;
4530 in++;
4534 in--;
4536 if (*in == '<') {
4539 if (*in == '&') {
4546 in = ctxt->input->cur;
4547 } while (((*in >= 0x20) && (*in <= 0x7F)) || (*in == 0x09));
4576 (IS_CHAR(cur))) /* test also done in xmlCurrentChar() */ {
4606 /* something really bad happened in the SAX callback */
4664 * Returns the function returns SystemLiteral and in the second
4734 * @len: number of bytes filles in the buffer
4740 * This is the slow routine in case the accelerator for ascii didn't work
4851 "Comment doesn't start and stop in the same entity\n");
4883 const xmlChar *in;
4904 in = ctxt->input->cur;
4906 if (*in == 0xA) {
4909 in++;
4910 } while (*in == 0xA);
4914 while (((*in > '-') && (*in <= 0x7F)) ||
4915 ((*in >= 0x20) && (*in < '-')) ||
4916 (*in == 0x09)) {
4917 in++;
4921 if (*in == 0xA) {
4924 in++;
4925 } while (*in == 0xA);
4928 nbchar = in - ctxt->input->cur;
4936 if ((*in == '-') && (in[1] == '-'))
4972 ctxt->input->cur = in;
4973 if (*in == 0xA) {
4974 in++;
4977 if (*in == 0xD) {
4978 in++;
4979 if (*in == 0xA) {
4980 ctxt->input->cur = in;
4981 in++;
4985 in--;
4993 in = ctxt->input->cur;
4994 if (*in == '-') {
4995 if (in[1] == '-') {
4996 if (in[2] == '>') {
4999 "comment doesn't start and stop in the same entity\n");
5023 in++;
5026 in++;
5030 } while (((*in >= 0x20) && (*in <= 0x7F)) || (*in == 0x09));
5093 * Occurs only if allowed by the user and if happening in the Misc
5095 * This will add the given catalog to the parsing context in order
5096 * to be used if there is a resolution need further down in the document
5185 "PI declaration doesn't start and stop in the same entity\n");
5269 "PI declaration doesn't start and stop in the same entity\n");
5361 "Notation declaration doesn't start and stop in the same entity\n");
5407 /* GROW; done in the caller */
5504 * For expat compatibility in SAX mode.
5575 * For expat compatibility in SAX mode.
5609 "Entity declaration doesn't start and stop in the same entity\n");
5656 * attribute must be specified for all elements of the type in the
5667 * [ WFC: No < in Attribute Values ]
5668 * handled in xmlParseAttValue()
5720 * in the declaration; all notation names in the declaration must be declared.
5741 "Name expected in NOTATION declaration\n");
5789 * Values of this type must match one of the Nmtoken tokens in
5897 * Validity constraints for attribute values syntax are checked in
5902 * appear more than once in an XML document as a value of this type;
5914 * of an ID attribute on some element in the XML document; i.e. IDREF
5920 * name of an unparsed entity declared in the DTD.
6056 "in xmlParseAttributeListDecl\n");
6085 "Attribute list declaration doesn't start and stop in the same entity\n",
6099 * The leading '(' and spaces have been skipped in xmlParseElementContentDecl
6107 * The same name must not appear more than once in a single
6125 "Element content declaration doesn't start and stop in the same entity\n",
6184 "Element content declaration doesn't start and stop in the same entity\n",
6207 * The leading '(' and spaces have been skipped in xmlParseElementContentDecl
6221 * opening or closing parentheses in a choice, seq, or Mixed
6222 * construct is contained in the replacement text for a parameter
6223 * entity, both must be contained in the same replacement text. For
6224 * interoperability, if a parameter-entity reference appears in a
6427 "Element content declaration doesn't start and stop in the same entity\n",
6504 * The leading '(' and spaces have been skipped in xmlParseElementContentDecl
6517 * opening or closing parentheses in a choice, seq, or Mixed
6518 * construct is contained in the replacement text for a parameter
6519 * entity, both must be contained in the same replacement text. For
6520 * interoperability, if a parameter-entity reference appears in a
6541 * the cases EMPTY and ANY are handled directly in xmlParseElementDecl
6591 * Returns the type of the element, or -1 in case of error
6599 /* GROW; done in the caller */
6639 * [ WFC: PEs in Internal Subset ] error handling.
6644 "PEReference: forbidden within markup decl in internal subset\n");
6668 "Element declaration doesn't start and stop in the same entity\n");
6720 "All markup of the conditional section is not in the same entity\n",
6780 "All markup of the conditional section is not in the same entity\n",
6796 * But disable SAX event generating DTD building in the meantime
6842 "All markup of the conditional section is not in the same entity\n",
6862 * contained in the replacement text for a parameter-entity reference,
6863 * both must be contained in the same replacement text.
6865 * [ WFC: PEs in Internal Subset ]
6866 * In the internal DTD subset, parameter-entity references can occur
6868 * (This does not apply to references that occur in external parameter
6909 * by PE References in the internal subset.
6976 "Missing encoding in text declaration\n");
7086 * parse and handle entity references in content, depending on the SAX
7087 * interface, this may end-up in a call to character() if this is a
7139 * Just encode the value in UTF-8
7247 * Prune it directly in the generated document
7306 * Probably running in SAX mode and the callbacks don't
7377 * and, if it's NULL, we copy in whatever was in the entity.
7386 * In the first occurrence list contains the replacement.
7420 * node cases in the reader tests
7501 * characters() in SAX.c
7519 * In a document without any DTD, a document with only an internal DTD
7521 * with "standalone='yes'", the Name given in the entity reference
7522 * must match that in an entity declaration, except that well-formed
7526 * must precede any reference to it which appears in a default value in an
7527 * attribute-list declaration. Note that if entities are declared in the
7528 * external subset or in external parameter entities, a non-validating
7578 * entities which may have stored in
7595 * In a document without any DTD, a document with only an
7598 * Name given in the entity reference must match that in an
7605 * precede any reference to it which appears in a default
7606 * value in an attribute-list declaration. Note that if
7607 * entities are declared in the external subset or in
7653 * [ WFC: No < in Attribute Values ]
7655 * indirectly in an attribute value (other than "<") must
7664 "'<' in entity '%s' is not allowed in attributes values\n", name);
7696 * @str: a pointer to an index in the string
7704 * In a document without any DTD, a document with only an internal DTD
7706 * with "standalone='yes'", the Name given in the entity reference
7707 * must match that in an entity declaration, except that well-formed
7711 * must precede any reference to it which appears in a default value in an
7712 * attribute-list declaration. Note that if entities are declared in the
7713 * external subset or in external parameter entities, a non-validating
7722 * is updated to the current location in the string.
7774 * entities which may have stored in the parser context.
7792 * In a document without any DTD, a document with only an
7795 * Name given in the entity reference must match that in an
7802 * precede any reference to it which appears in a default
7803 * value in an attribute-list declaration. Note that if
7804 * entities are declared in the external subset or in
7846 * [ WFC: No < in Attribute Values ]
7848 * indirectly in an attribute value (other than "<") must
7856 "'<' in entity '%s' is not allowed in attributes values\n",
7903 * In a document without any DTD, a document with only an internal DTD
7909 * In a document with an external subset or external parameter entities
7913 * [ WFC: In DTD ]
7914 * Parameter-entity references may only appear in the DTD.
7956 * In a document without any DTD, a document with only an
7971 * In a document with an external subset or external
7983 * Internal checking in case the entity quest barfed
8028 * ExternalID/SystemID given. This is to be used for Included in Literal
8031 * Returns 0 in case of success and -1 in case of failure
8122 * @str: a pointer to an index in the string
8133 * In a document without any DTD, a document with only an internal DTD
8139 * In a document with an external subset or external parameter entities
8143 * [ WFC: In DTD ]
8144 * Parameter-entity references may only appear in the DTD.
8197 * In a document without any DTD, a document with only an
8210 * In a document with an external subset or external
8222 * Internal checking in case the entity quest barfed
8247 * The Name in the document type declaration must match the element
8300 * they are handled separately in xmlParseInternalSubset()
8352 "xmlParseInternalSubset: error detected in Markup declaration\n");
8385 * [ WFC: No < in Attribute Values ]
8386 * The replacement text of any entity referred to directly or indirectly in
8402 * Returns the attribute name, and the value in *value.
8437 * since this was deprecated in XML second edition
8471 * EmptyElement. In both case we don't parse the tag closing chars.
8476 * No attribute name may appear more than once in the same start-tag or
8482 * No attribute name may appear more than once in the same start-tag or
8532 * No attribute name may appear more than once in the same
8663 * The Name in an element's end-tag must match the element type in the
8832 const xmlChar *in;
8839 in = ctxt->input->cur;
8842 while (*in != 0 && *in == *cmp) {
8843 ++in;
8846 if ((*cmp == 0) && (*in == ':')) {
8847 in++;
8849 while (*in != 0 && *in == *cmp) {
8850 ++in;
8853 if (*cmp == 0 && (*in == '>' || IS_BLANK_CH (*in))) {
8855 ctxt->input->cur = in;
8907 const xmlChar *in = NULL, *start, *end, *last;
8911 in = (xmlChar *) CUR_PTR;
8912 if (*in != '"' && *in != '\'') {
8919 * try to handle in this routine the most common case where no
8923 limit = *in++;
8925 start = in;
8926 if (in >= end) {
8932 in = in + delta;
8940 while ((in < end) && (*in != limit) &&
8941 ((*in == 0x20) || (*in == 0x9) ||
8942 (*in == 0xA) || (*in == 0xD))) {
8943 in++;
8944 start = in;
8945 if (in >= end) {
8953 in = in + delta;
8956 if (((in - start) > XML_MAX_TEXT_LENGTH) &&
8964 while ((in < end) && (*in != limit) && (*in >= 0x20) &&
8965 (*in <= 0x7f) && (*in != '&') && (*in != '<')) {
8966 if ((*in++ == 0x20) && (*in == 0x20)) break;
8967 if (in >= end) {
8975 in = in + delta;
8978 if (((in - start) > XML_MAX_TEXT_LENGTH) &&
8986 last = in;
8991 while ((in < end) && (*in != limit) &&
8992 ((*in == 0x20) || (*in == 0x9) ||
8993 (*in == 0xA) || (*in == 0xD))) {
8994 in++;
8995 if (in >= end) {
9003 in = in + delta;
9007 if (((in - start) > XML_MAX_TEXT_LENGTH) &&
9015 if (((in - start) > XML_MAX_TEXT_LENGTH) &&
9021 if (*in != limit) goto need_complex;
9023 while ((in < end) && (*in != limit) && (*in >= 0x20) &&
9024 (*in <= 0x7f) && (*in != '&') && (*in != '<')) {
9025 in++;
9026 if (in >= end) {
9034 in = in + delta;
9037 if (((in - start) > XML_MAX_TEXT_LENGTH) &&
9045 last = in;
9046 if (((in - start) > XML_MAX_TEXT_LENGTH) &&
9052 if (*in != limit) goto need_complex;
9054 in++;
9062 CUR_PTR = in;
9080 * parse an attribute in the new SAX2 framework.
9082 * Returns the attribute name, and the value in *value, .
9128 * have been used in the attribute value, i.e. the attribute
9129 * value have been extracted in an allocated string already.
9153 * since this was deprecated in XML second edition
9192 * EmptyElement. In both case we don't parse the tag closing chars.
9198 * No attribute name may appear more than once in the same start-tag or
9204 * No attribute name may appear more than once in the same start-tag or
9569 * No attribute name may appear more than once in the same
9571 * As extended by the Namespace in XML REC.
9581 "Namespaced Attribute %s in '%s' redefined\n",
9696 * The Name in an element's end-tag must match the element type in the
9910 "detected an error in element content\n");
9926 * The Name in an element's end-tag must match the element type in the
9944 "Excessive depth in document: %d use XML_PARSE_HUGE option\n",
9985 * The Name in the document type declaration must match the element
10059 "Premature end of data in tag %s line %d\n",
10105 * In practice allow [0-9].[0-9]+ at that level
10383 * attributes apply appear in the document without specifications
10386 * to those entities appear in the document, or
10388 * attribute appears in the document with a value which will change
10603 * Returns 0, -1 in case of error. the parser context is augmented
10655 * Check for the XMLDecl in the Prolog.
10790 * Returns 0, -1 in case of error. the parser context is augmented
10836 * Check for the XMLDecl in the Prolog.
10903 * (first) is available in the input stream.
10915 xmlParserInputPtr in;
10918 in = ctxt->input;
10919 if (in == NULL) return(-1);
10920 base = in->cur - in->base;
10924 if (in->buf == NULL) {
10925 buf = in->base;
10926 len = in->length;
10928 buf = xmlBufContent(in->buf->buffer);
10929 len = xmlBufUse(in->buf->buffer);
10957 return(base - (in->cur - in->base));
10981 * Lookup the last < and > in the current chunk
11035 * @len: length of the block in bytes
11196 * remainng chars to avoid them stalling in the non-converted
11197 * buffer. But do not do this in document start where
11355 /* > can be found unescaped in attribute values */
11388 * The Name in the document type declaration must match
11519 * - tries to homogenize the differences in SAX
11546 "detected an error in element content\n");
11557 /* > can be found unescaped in attribute values */
11884 * Internal subset ends up with "']' S? '>'" in an unescaped
11885 * section and not in a ']]>' sequence which are conditional
11886 * sections (whoever argued to keep that crap in XML deserve
11887 * a place in hell !).
12107 * @size: the size in byte of the chunk
12112 * Returns -1 in case of error, 0 if the push is not needed and 1 if needed
12156 * @size: the size in byte of the chunk
12219 * if size is greater than len. Otherwise, memmove in xmlBufferAdd
12242 xmlParserInputBufferPtr in = ctxt->input->buf;
12243 if ((in->encoder != NULL) && (in->buffer != NULL) &&
12244 (in->raw != NULL)) {
12246 size_t base = xmlBufGetInputBase(in->buffer, ctxt->input);
12249 nbchars = xmlCharEncInput(in, terminate);
12256 xmlBufSetInputBaseCur(in->buffer, ctxt->input, base, current);
12267 * a good idea to try parsing if there is nothing in the chunk
12353 * @size: number of chars in the array
12356 * Create a parser context for using the XML parser in push mode.
12359 * don't need to be fed in again through xmlParseChunk.
12573 * Returns the resulting xmlDtdPtr or NULL in case of error.
12574 * @input will be freed by the function in any case.
12702 * Returns the resulting xmlDtdPtr or NULL in case of error.
12830 * Returns the resulting xmlDtdPtr or NULL in case of error.
12858 * Returns 0 if the entity is well formed, -1 in
12964 * useData callback field, otherwise the expected setup in a
13063 * Returns 0 if the entity is well formed, -1 in case of args problem and
13221 * Record in the parent context the number of entities replacement
13273 * Returns 0 if the entity is well formed, -1 in case of args problem and
13290 * @string: the input string in UTF8 or ISO-Latin (zero terminated)
13296 * the content production in the XML grammar:
13300 * Returns 0 if the chunk is well balanced, -1 in case of args problem and
13315 * @string: the input string in UTF8 or ISO-Latin (zero terminated)
13323 * the content production in the XML grammar:
13330 * In case recover is set to 1, the nodelist will not be empty even if
13425 * ID/IDREF registration will be done in xmlValidateElement below
13482 * Record in the parent context the number of entities replacement
13510 * @datalen: the input string length in bytes
13518 * the content production in the XML grammar:
13571 * node position in the tree
13579 * When parsing in context, it makes no sense to add implied
13661 * ID/IDREF registration will be done in xmlValidateElement below
13739 * @string: the input string in UTF8 or ISO-Latin (zero terminated)
13747 * the content production in the XML grammar:
13751 * Returns 0 if the chunk is well balanced, -1 in case of args problem and
13754 * In case recover is set to 1, the nodelist will not be empty even if
14118 * @recovery: work in recovery mode, i.e. tries to read no Well Formed
14127 * User data (void *) is stored within the parser context in the
14128 * context's _private member, so it is available nearly everywhere in libxml
14187 * @recovery: work in recovery mode, i.e. tries to read no Well Formed
14208 * parse an XML in-memory document and build a tree.
14209 * In the case the document is not Well Formed, a attempt to build a
14212 * Returns the resulting document tree or NULL in case of failure
14242 * In the case the document is not Well Formed, it attempts to build
14245 * Returns the resulting document tree or NULL in case of failure
14298 * Returns 0 in case of success or a error number otherwise
14349 * Create a parser context for an XML in-memory document.
14396 * @recovery: work in recovery mode, i.e. tries to read no Well Formed
14400 * parse an XML in-memory block and use the given SAX function block
14404 * User data (void *) is stored within the parser context in the
14405 * context's _private member, so it is available nearly everywhere in libxml
14452 * @recovery: work in recovery mode, i.e. tries to read not Well Formed
14455 * parse an XML in-memory block and use the given SAX function block
14472 * parse an XML in-memory block and build a tree.
14486 * parse an XML in-memory block and build a tree.
14487 * In the case the document is not Well Formed, an attempt to
14490 * Returns the resulting document tree or NULL in case of error
14501 * @buffer: an in-memory XML document input
14502 * @size: the length of the XML document in bytes
14505 * parse an XML in-memory buffer and call the given SAX handler routines.
14507 * Returns 0 in case of success or a error number otherwise
14552 * Creates a parser context for an XML in-memory document.
14571 * @recovery: work in recovery mode, i.e. tries to read no Well Formed
14574 * parse an XML in-memory document and build a tree.
14617 * parse an XML in-memory document and build a tree.
14686 * This is not reentrant. Call once before processing in case of
14687 * use in multithreaded programs.
14742 * guess if libxml2 is in use in the application, some libraries
14743 * or plugins may use it without notice. In case of doubt abstain
14783 * Free a string if it is not owned by the "dict" dictionnary in the
14894 * @size: number of chars in the array
14900 * Returns 0 in case of success and 1 in case of error
15002 * Returns 0 in case of success, the set of unknown or unimplemented options
15003 * in case of error.
15143 * Returns 0 in case of success, the set of unknown or unimplemented options
15144 * in case of error.
15205 * parse an XML in-memory document and build a tree.
15252 * parse an XML in-memory document and build a tree.
15363 * parse an XML in-memory document and build a tree.
15431 * parse an XML in-memory document and build a tree.
