Lines Matching defs:next
322 struct block *next;
398 struct open_internal_entity *next;
454 const char *s, const char *next);
458 const char *next, const char **nextPtr,
1214 openEntityList = openEntity->next;
1215 openEntity->next = parser->m_freeInternalEntities;
1471 entityList = entityList->next;
2644 const char *next = start; /* XmlContentTok doesn't always set the last arg */
2645 int tok = XmlContentTok(parser->m_encoding, start, end, &next);
2649 if (! accountingDiffTolerated(parser, tok, start, next, __LINE__,
2656 /* If we are at the end of the buffer, this would cause the next stage,
2661 if (next == end && ! parser->m_parsingStatus.finalBuffer) {
2662 *endPtr = next;
2665 start = next;
2690 const char *next = start; /* XmlContentTok doesn't always set the last arg */
2692 tok = XmlContentTok(parser->m_encoding, start, end, &next);
2697 parser->m_eventEndPtr = next;
2702 result = processXmlDecl(parser, 1, start, next);
2707 *endPtr = next;
2712 start = next;
2766 const char *next = s; /* XmlContentTok doesn't always set the last arg */
2767 int tok = XmlContentTok(enc, s, end, &next);
2772 : next;
2779 *eventEndPP = next;
2814 *eventPP = next;
2832 enc, s + enc->minBytesPerChar, next - enc->minBytesPerChar);
2845 reportDefault(parser, enc, s, next);
2849 next - enc->minBytesPerChar);
2867 reportDefault(parser, enc, s, next);
2881 reportDefault(parser, enc, s, next);
2900 reportDefault(parser, enc, s, next);
2968 reportDefault(parser, enc, s, next);
3004 reportDefault(parser, enc, s, next);
3013 return epilogProcessor(parser, next, end, nextPtr);
3058 reportDefault(parser, enc, s, next);
3074 return epilogProcessor(parser, next, end, nextPtr);
3087 reportDefault(parser, enc, s, next);
3096 reportDefault(parser, enc, s, next);
3120 reportDefault(parser, enc, s, next);
3122 = doCdataSection(parser, enc, &next, end, nextPtr, haveMore, account);
3125 else if (! next) {
3168 enc, &s, next, &dataPtr, (ICHAR *)parser->m_dataBufEnd);
3179 (int)((XML_Char *)next - (XML_Char *)s));
3181 reportDefault(parser, enc, s, next);
3184 if (! reportProcessingInstruction(parser, enc, s, next))
3188 if (! reportComment(parser, enc, s, next))
3200 reportDefault(parser, enc, s, next);
3204 *eventPP = s = next;
3207 *nextPtr = next;
4041 const char *next = s; /* in case of XML_TOK_NONE or XML_TOK_PARTIAL */
4042 int tok = XmlCdataSectionTok(enc, s, end, &next);
4044 if (! accountingDiffTolerated(parser, tok, s, next, __LINE__, account)) {
4051 *eventEndPP = next;
4063 reportDefault(parser, enc, s, next);
4064 *startPtr = next;
4065 *nextPtr = next;
4075 reportDefault(parser, enc, s, next);
4084 enc, &s, next, &dataPtr, (ICHAR *)parser->m_dataBufEnd);
4085 *eventEndPP = next;
4095 (int)((XML_Char *)next - (XML_Char *)s));
4097 reportDefault(parser, enc, s, next);
4100 *eventPP = next;
4123 *eventPP = next;
4128 *eventPP = s = next;
4131 *nextPtr = next;
4167 const char *next = *startPtr; /* in case of XML_TOK_NONE or XML_TOK_PARTIAL */
4194 tok = XmlIgnoreSectionTok(enc, s, end, &next);
4196 if (! accountingDiffTolerated(parser, tok, s, next, __LINE__,
4202 *eventEndPP = next;
4206 reportDefault(parser, enc, s, next);
4207 *startPtr = next;
4208 *nextPtr = next;
4214 *eventPP = next;
4237 *eventPP = next;
4278 const char *next) {
4288 if (! accountingDiffTolerated(parser, XML_TOK_XML_DECL, s, next, __LINE__,
4296 isGeneralTextEntity, parser->m_encoding, s, next, &parser->m_eventPtr,
4330 reportDefault(parser, parser->m_encoding, s, next);
4439 const char *next = start;
4443 tok = XmlPrologTok(parser->m_encoding, start, end, &next);
4448 parser->m_eventEndPtr = next;
4470 result = processXmlDecl(parser, 0, start, next);
4480 *nextPtr = next;
4483 return entityValueProcessor(parser, next, end, nextPtr);
4486 return XML_TOK_NONE on the next call, which would then cause the
4489 then, when this routine is entered the next time, XmlPrologTok will
4492 else if (tok == XML_TOK_BOM && next == end
4495 if (! accountingDiffTolerated(parser, tok, s, next, __LINE__,
4502 *nextPtr = next;
4510 *nextPtr = next;
4513 start = next;
4521 const char *next = s;
4524 tok = XmlPrologTok(parser->m_encoding, s, end, &next);
4542 /* This would cause the next stage, i.e. doProlog to be passed XML_TOK_BOM.
4548 if (! accountingDiffTolerated(parser, tok, s, next, __LINE__,
4554 s = next;
4555 tok = XmlPrologTok(parser->m_encoding, s, end, &next);
4559 return doProlog(parser, parser->m_encoding, s, end, tok, next, nextPtr,
4568 const char *next = s;
4573 tok = XmlPrologTok(enc, start, end, &next);
4596 start = next;
4605 const char *next = s;
4606 int tok = XmlPrologTok(parser->m_encoding, s, end, &next);
4607 return doProlog(parser, parser->m_encoding, s, end, tok, next, nextPtr,
4614 int tok, const char *next, const char **nextPtr, XML_Bool haveMore,
4665 *eventEndPP = next;
4673 *eventPP = next;
4705 next = end;
4709 role = XmlTokenRole(&parser->m_prologState, tok, s, next, enc);
4717 if (! accountingDiffTolerated(parser, tok, s, next, __LINE__, account)) {
4725 enum XML_Error result = processXmlDecl(parser, 0, s, next);
4734 = poolStoreString(&parser->m_tempPool, enc, s, next);
4755 enum XML_Error result = processXmlDecl(parser, 1, s, next);
4773 if (! XmlIsPublicId(enc, s, next, eventPP))
4777 next - enc->minBytesPerChar);
4788 if (! XmlIsPublicId(enc, s, next, eventPP))
4794 next - enc->minBytesPerChar);
4904 parser->m_declElementType = getElementType(parser, enc, s, next);
4909 parser->m_declAttributeId = getAttributeId(parser, enc, s, next);
4957 if (! poolAppend(&parser->m_tempPool, enc, s, next))
4998 s + enc->minBytesPerChar, next - enc->minBytesPerChar, &dtd->pool,
5034 next - enc->minBytesPerChar, XML_ACCOUNT_NONE);
5062 next - enc->minBytesPerChar);
5097 next - enc->minBytesPerChar);
5123 = poolStoreString(&dtd->pool, enc, s, next);
5145 if (XmlPredefinedEntityName(enc, s, next)) {
5150 const XML_Char *name = poolStoreString(&dtd->pool, enc, s, next);
5180 const XML_Char *name = poolStoreString(&dtd->pool, enc, s, next);
5215 = poolStoreString(&parser->m_tempPool, enc, s, next);
5223 if (! XmlIsPublicId(enc, s, next, eventPP))
5229 next - enc->minBytesPerChar);
5242 next - enc->minBytesPerChar);
5278 reportDefault(parser, enc, s, next);
5280 result = doIgnoreSection(parser, enc, &next, end, nextPtr, haveMore);
5283 else if (! next) {
5377 next - enc->minBytesPerChar);
5469 parser->m_declElementType = getElementType(parser, enc, s, next);
5528 = (quant == XML_CQUANT_NONE ? next : next - enc->minBytesPerChar);
5588 if (! reportProcessingInstruction(parser, enc, s, next))
5593 if (! reportComment(parser, enc, s, next))
5627 reportDefault(parser, enc, s, next);
5631 *nextPtr = next;
5636 s = next;
5637 tok = XmlPrologTok(enc, s, end, &next);
5649 const char *next = NULL;
5650 int tok = XmlPrologTok(parser->m_encoding, s, end, &next);
5652 if (! accountingDiffTolerated(parser, tok, s, next, __LINE__,
5658 parser->m_eventEndPtr = next;
5663 reportDefault(parser, parser->m_encoding, s, next);
5667 *nextPtr = next;
5674 reportDefault(parser, parser->m_encoding, s, next);
5677 if (! reportProcessingInstruction(parser, parser->m_encoding, s, next))
5681 if (! reportComment(parser, parser->m_encoding, s, next))
5685 parser->m_eventPtr = next;
5702 parser->m_eventPtr = s = next;
5705 *nextPtr = next;
5717 const char *next;
5723 parser->m_freeInternalEntities = openEntity->next;
5735 openEntity->next = parser->m_openInternalEntities;
5744 /* Set a safe default value in case 'next' does not get set */
5745 next = textStart;
5750 = XmlPrologTok(parser->m_internalEncoding, textStart, textEnd, &next);
5752 tok, next, &next, XML_FALSE, XML_FALSE,
5757 textStart, textEnd, &next, XML_FALSE,
5761 if (textEnd != next && parser->m_parsingStatus.parsing == XML_SUSPENDED) {
5762 entity->processed = (int)(next - textStart);
5769 parser->m_openInternalEntities = openEntity->next;
5771 openEntity->next = parser->m_freeInternalEntities;
5783 const char *next;
5792 /* Set a safe default value in case 'next' does not get set */
5793 next = textStart;
5798 = XmlPrologTok(parser->m_internalEncoding, textStart, textEnd, &next);
5800 tok, next, &next, XML_FALSE, XML_TRUE,
5805 parser->m_internalEncoding, textStart, textEnd, &next,
5811 if (textEnd != next && parser->m_parsingStatus.parsing == XML_SUSPENDED) {
5812 entity->processed = (int)(next - (const char *)entity->textPtr);
5820 parser->m_openInternalEntities = openEntity->next;
5822 openEntity->next = parser->m_freeInternalEntities;
5837 tok = XmlPrologTok(parser->m_encoding, s, end, &next);
5838 return doProlog(parser, parser->m_encoding, s, end, tok, next, nextPtr,
5892 const char *next
5894 int tok = XmlAttributeValueTok(enc, ptr, end, &next);
5896 if (! accountingDiffTolerated(parser, tok, ptr, next, __LINE__, account)) {
5906 parser->m_eventPtr = next;
5940 if (! poolAppend(pool, enc, ptr, next))
5944 next = ptr + enc->minBytesPerChar;
5958 enc, ptr + enc->minBytesPerChar, next - enc->minBytesPerChar);
5974 next - enc->minBytesPerChar);
6005 reportDefault(parser, enc, ptr, next);
6077 ptr = next;
6104 const char *next
6106 int tok = XmlEntityValueTok(enc, entityTextPtr, entityTextEnd, &next);
6109 if (! accountingDiffTolerated(parser, tok, entityTextPtr, next, __LINE__,
6125 next - enc->minBytesPerChar);
6192 if (! poolAppend(pool, enc, entityTextPtr, next)) {
6198 next = entityTextPtr + enc->minBytesPerChar;
6242 parser->m_eventPtr = next;
6259 entityTextPtr = next;
7188 BLOCK *tem = p->next;
7189 p->next = pool->freeBlocks;
7204 BLOCK *tem = p->next;
7210 BLOCK *tem = p->next;
7323 pool->freeBlocks = pool->freeBlocks->next;
7324 pool->blocks->next = NULL;
7331 BLOCK *tem = pool->freeBlocks->next;
7332 pool->freeBlocks->next = pool->blocks;
7411 tem->next = pool->blocks;
7426 int next;
7466 next = dtd->scaffCount++;
7467 me = &dtd->scaffold[next];
7472 dtd->scaffold[parent->lastchild].nextsib = next;
7475 parent->firstchild = next;
7476 parent->lastchild = next;
7480 return next;
7568 XML_Content *jobDest = ret; /* next free writing location in target array */