218   struct block *next;
294   struct open_internal_entity *next;
328                const char *s, const char *next);
333          const char *end, int tok, const char *next, const char **nextPtr,
945     openEntityList = openEntity->next;
946     openEntity->next = freeInternalEntities;
1163     entityList = entityList->next;
2133   const char *next = start; /* XmlContentTok doesn't always set the last arg */
2134   int tok = XmlContentTok(encoding, start, end, &next);
2137     /* If we are at the end of the buffer, this would cause the next stage,
2142     if (next == end && !ps_finalBuffer) {
2143       *endPtr = next;
2146     start = next;
2174   const char *next = start; /* XmlContentTok doesn't always set the last arg */
2176   tok = XmlContentTok(encoding, start, end, &next);
2177   eventEndPtr = next;
2183       result = processXmlDecl(parser, 1, start, next);
2188         *endPtr = next;
2193         start = next;
2255     const char *next = s; /* XmlContentTok doesn't always set the last arg */
2256     int tok = XmlContentTok(enc, s, end, &next);
2257     *eventEndPP = next;
2293       *eventPP = next;
2313                                               next - enc->minBytesPerChar);
2318             reportDefault(parser, enc, s, next);
2323                                 next - enc->minBytesPerChar);
2342             reportDefault(parser, enc, s, next);
2355               reportDefault(parser, enc, s, next);
2378           reportDefault(parser, enc, s, next);
2446           reportDefault(parser, enc, s, next);
2479           reportDefault(parser, enc, s, next);
2492         return epilogProcessor(parser, next, end, nextPtr);
2535           reportDefault(parser, enc, s, next);
2546           return epilogProcessor(parser, next, end, nextPtr);
2559           reportDefault(parser, enc, s, next);
2570         reportDefault(parser, enc, s, next);
2594           reportDefault(parser, enc, s, next);
2595         result = doCdataSection(parser, enc, &next, end, nextPtr, haveMore);
2598         else if (!next) {
2643               XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd);
2647               if (s == next)
2655                             (int)((XML_Char *)next - (XML_Char *)s));
2658           reportDefault(parser, enc, s, next);
2662       if (!reportProcessingInstruction(parser, enc, s, next))
2666       if (!reportComment(parser, enc, s, next))
2671         reportDefault(parser, enc, s, next);
2674     *eventPP = s = next;
2677       *nextPtr = next;
3216     const char *next;
3217     int tok = XmlCdataSectionTok(enc, s, end, &next);
3218     *eventEndPP = next;
3229         reportDefault(parser, enc, s, next);
3230       *startPtr = next;
3231       *nextPtr = next;
3242         reportDefault(parser, enc, s, next);
3251               XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd);
3252               *eventEndPP = next;
3255               if (s == next)
3263                             (int)((XML_Char *)next - (XML_Char *)s));
3266           reportDefault(parser, enc, s, next);
3270       *eventPP = next;
3286       *eventPP = next;
3290     *eventPP = s = next;
3293       *nextPtr = next;
3336   const char *next;
3352   tok = XmlIgnoreSectionTok(enc, s, end, &next);
3353   *eventEndPP = next;
3357       reportDefault(parser, enc, s, next);
3358     *startPtr = next;
3359     *nextPtr = next;
3365     *eventPP = next;
3381     *eventPP = next;
3420                const char *s, const char *next)
3434                            next,
3475     reportDefault(parser, encoding, s, next);
3593   const char *next = start;
3597     tok = XmlPrologTok(encoding, start, end, &next);
3598     eventEndPtr = next;
3620       result = processXmlDecl(parser, 0, start, next);
3625         *nextPtr = next;
3630         *nextPtr = next;
3634       return entityValueProcessor(parser, next, end, nextPtr);
3637        return XML_TOK_NONE on the next call, which would then cause the
3640        then, when this routine is entered the next time, XmlPrologTok will
3643     else if (tok == XML_TOK_BOM && next == end && !ps_finalBuffer) {
3644       *nextPtr = next;
3647     start = next;
3658   const char *next = s;
3661   tok = XmlPrologTok(encoding, s, end, &next);
3679   /* This would cause the next stage, i.e. doProlog to be passed XML_TOK_BOM.
3684     s = next;
3685     tok = XmlPrologTok(encoding, s, end, &next);
3689   return doProlog(parser, encoding, s, end, tok, next,
3700   const char *next = s;
3705     tok = XmlPrologTok(enc, start, end, &next);
3725     start = next;
3737   const char *next = s;
3738   int tok = XmlPrologTok(encoding, s, end, &next);
3739   return doProlog(parser, encoding, s, end, tok, next,
3749          const char *next,
3796     *eventEndPP = next;
3804         *eventPP = next;
3835         next = end;
3839     role = XmlTokenRole(&prologState, tok, s, next, enc);
3843         enum XML_Error result = processXmlDecl(parser, 0, s, next);
3852         doctypeName = poolStoreString(&tempPool, enc, s, next);
3873         enum XML_Error result = processXmlDecl(parser, 1, s, next);
3894         if (!XmlIsPublicId(enc, s, next, eventPP))
3898                                 next - enc->minBytesPerChar);
3909       if (!XmlIsPublicId(enc, s, next, eventPP))
3916                                         next - enc->minBytesPerChar);
4018       declElementType = getElementType(parser, enc, s, next);
4023       declAttributeId = getAttributeId(parser, enc, s, next);
4073         if (!poolAppend(&tempPool, enc, s, next))
4113                               next - enc->minBytesPerChar,
4148                                             next - enc->minBytesPerChar);
4178                                        next - enc->minBytesPerChar);
4215                                                next - enc->minBytesPerChar);
4240         declEntity->notation = poolStoreString(&dtd->pool, enc, s, next);
4269         if (XmlPredefinedEntityName(enc, s, next)) {
4274           const XML_Char *name = poolStoreString(&dtd->pool, enc, s, next);
4306         const XML_Char *name = poolStoreString(&dtd->pool, enc, s, next);
4341         declNotationName = poolStoreString(&tempPool, enc, s, next);
4349       if (!XmlIsPublicId(enc, s, next, eventPP))
4355                                         next - enc->minBytesPerChar);
4369                             next - enc->minBytesPerChar);
4410           reportDefault(parser, enc, s, next);
4412         result = doIgnoreSection(parser, enc, &next, end, nextPtr, haveMore);
4415         else if (!next) {
4488                                 next - enc->minBytesPerChar);
4561         declElementType = getElementType(parser, enc, s, next);
4619                            ? next
4620                            : next - enc->minBytesPerChar);
4672       if (!reportProcessingInstruction(parser, enc, s, next))
4677       if (!reportComment(parser, enc, s, next))
4711       reportDefault(parser, enc, s, next);
4715       *nextPtr = next;
4720       s = next;
4721       tok = XmlPrologTok(enc, s, end, &next);
4736     const char *next = NULL;
4737     int tok = XmlPrologTok(encoding, s, end, &next);
4738     eventEndPtr = next;
4743         reportDefault(parser, encoding, s, next);
4747       *nextPtr = next;
4754         reportDefault(parser, encoding, s, next);
4757       if (!reportProcessingInstruction(parser, encoding, s, next))
4761       if (!reportComment(parser, encoding, s, next))
4765       eventPtr = next;
4782     eventPtr = s = next;
4785       *nextPtr = next;
4799   const char *next;
4805     freeInternalEntities = openEntity->next;
4814   openEntity->next = openInternalEntities;
4826     int tok = XmlPrologTok(internalEncoding, textStart, textEnd, &next);
4828                       next, &next, XML_FALSE);
4833                        textEnd, &next, XML_FALSE);
4836     if (textEnd != next && ps_parsing == XML_SUSPENDED) {
4837       entity->processed = (int)(next - textStart);
4842       openInternalEntities = openEntity->next;
4844       openEntity->next = freeInternalEntities;
4859   const char *next;
4871     int tok = XmlPrologTok(internalEncoding, textStart, textEnd, &next);
4873                       next, &next, XML_FALSE);
4878                        textStart, textEnd, &next, XML_FALSE);
4882   else if (textEnd != next && ps_parsing == XML_SUSPENDED) {
4883     entity->processed = (int)(next - (char *)entity->textPtr);
4888     openInternalEntities = openEntity->next;
4890     openEntity->next = freeInternalEntities;
4898     tok = XmlPrologTok(encoding, s, end, &next);
4899     return doProlog(parser, encoding, s, end, tok, next, nextPtr,
4944     const char *next;
4945     int tok = XmlAttributeValueTok(enc, ptr, end, &next);
4951         eventPtr = next;
4984       if (!poolAppend(pool, enc, ptr, next))
4988       next = ptr + enc->minBytesPerChar;
5004                                               next - enc->minBytesPerChar);
5012                                next - enc->minBytesPerChar);
5045             reportDefault(parser, enc, ptr, next);
5082     ptr = next;
5109     const char *next;
5110     int tok = XmlEntityValueTok(enc, entityTextPtr, entityTextEnd, &next);
5119                                next - enc->minBytesPerChar);
5186       if (!poolAppend(pool, enc, entityTextPtr, next)) {
5192       next = entityTextPtr + enc->minBytesPerChar;
5235         eventPtr = next;
5244     entityTextPtr = next;
6115       BLOCK *tem = p->next;
6116       p->next = pool->freeBlocks;
6132     BLOCK *tem = p->next;
6138     BLOCK *tem = p->next;
6215       pool->freeBlocks = pool->freeBlocks->next;
6216       pool->blocks->next = NULL;
6223       BLOCK *tem = pool->freeBlocks->next;
6224       pool->freeBlocks->next = pool->blocks;
6261     tem->next = pool->blocks;
6278   int next;
6305   next = dtd->scaffCount++;
6306   me = &dtd->scaffold[next];
6310       dtd->scaffold[parent->lastchild].nextsib = next;
6313       parent->firstchild = next;
6314     parent->lastchild = next;
6318   return next;

Indexes created Tue Jul 24 14:28:13 CEST 2018