Attachment #434502 for bug #583268




          for (;;) {
            int bufSize;
            int convLen;
            const enum XML_Convert_Result convert_res = XmlConvert(enc,
                       &fromPtr, rawNameEnd,
                       (ICHAR **)&toPtr, (ICHAR *)tag->bufEnd - 1);
            convLen = (int)(toPtr - (XML_Char *)tag->buf);
            if ((convert_res == XML_CONVERT_COMPLETED) || (convert_res == XML_CONVERT_INPUT_INCOMPLETE)) {
              tag->name.strLen = convLen;
              break;
            }

          if (MUST_CONVERT(enc, s)) {
            for (;;) {
              ICHAR *dataPtr = (ICHAR *)dataBuf;
              const enum XML_Convert_Result convert_res = XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd);
              *eventEndPP = s;
              charDataHandler(handlerArg, dataBuf,
                              (int)(dataPtr - (ICHAR *)dataBuf));
              if ((convert_res == XML_CONVERT_COMPLETED) || (convert_res == XML_CONVERT_INPUT_INCOMPLETE))
                break;
              *eventPP = s;
            }

          if (MUST_CONVERT(enc, s)) {
            for (;;) {
              ICHAR *dataPtr = (ICHAR *)dataBuf;
              const enum XML_Convert_Result convert_res = XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd);
              *eventEndPP = next;
              charDataHandler(handlerArg, dataBuf,
                              (int)(dataPtr - (ICHAR *)dataBuf));
              if ((convert_res == XML_CONVERT_COMPLETED) || (convert_res == XML_CONVERT_INPUT_INCOMPLETE))
                break;
              *eventPP = s;
            }

              const char *s, const char *end)
{
  if (MUST_CONVERT(enc, s)) {
    enum XML_Convert_Result convert_res;
    const char **eventPP;
    const char **eventEndPP;
    if (enc == encoding) {

    }
    do {
      ICHAR *dataPtr = (ICHAR *)dataBuf;
      convert_res = XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)dataBufEnd);
      *eventEndPP = s;
      defaultHandler(handlerArg, dataBuf, (int)(dataPtr - (ICHAR *)dataBuf));
      *eventPP = s;
    } while ((convert_res != XML_CONVERT_COMPLETED) && (convert_res != XML_CONVERT_INPUT_INCOMPLETE));
  }
  else
    defaultHandler(handlerArg, (XML_Char *)s, (int)((XML_Char *)end - (XML_Char *)s));

  if (!pool->ptr && !poolGrow(pool))
    return NULL;
  for (;;) {
    const enum XML_Convert_Result convert_res = XmlConvert(enc, &ptr, end, (ICHAR **)&(pool->ptr), (ICHAR *)pool->end);
    if ((convert_res == XML_CONVERT_COMPLETED) || (convert_res == XML_CONVERT_INPUT_INCOMPLETE))
      break;
    if (!poolGrow(pool))
      return NULL;

    }
  }
  if (pool->blocks && pool->start == pool->blocks->s) {
    BLOCK *temp;
    int blockSize = (int)((unsigned)(pool->end - pool->start)*2U);

    if (blockSize < 0)
      return XML_FALSE;

    temp = (BLOCK *)
      pool->mem->realloc_fcn(pool->blocks,
                             (offsetof(BLOCK, s)
                              + blockSize * sizeof(XML_Char)));

  else {
    BLOCK *tem;
    int blockSize = (int)(pool->end - pool->start);

    if (blockSize < 0)
      return XML_FALSE;

    if (blockSize < INIT_BLOCK_SIZE)
      blockSize = INIT_BLOCK_SIZE;
    else




  UTF8_cval4 = 0xf0
};

static enum XML_Convert_Result PTRCALL
utf8_toUtf8(const ENCODING *enc,
            const char **fromP, const char *fromLim,
            char **toP, const char *toLim)
{
  enum XML_Convert_Result res = XML_CONVERT_COMPLETED;
  char *to;
  const char *from;
  if (fromLim - *fromP > toLim - *toP) {
    /* Avoid copying partial characters. */
    res = XML_CONVERT_OUTPUT_EXHAUSTED;
    for (fromLim = *fromP + (toLim - *toP); fromLim > *fromP; fromLim--)
      if (((unsigned char)fromLim[-1] & 0xc0) != 0x80)
        break;
  }
  for (to = *toP, from = *fromP; (from < fromLim) && (to < toLim); from++, to++)
    *to = *from;
  *fromP = from;
  *toP = to;

  if ((to == toLim) && (from < fromLim))
    return XML_CONVERT_OUTPUT_EXHAUSTED;
  else
    return res;
}

static enum XML_Convert_Result PTRCALL
utf8_toUtf16(const ENCODING *enc,
             const char **fromP, const char *fromLim,
             unsigned short **toP, const unsigned short *toLim)
{
  enum XML_Convert_Result res = XML_CONVERT_COMPLETED;
  unsigned short *to = *toP;
  const char *from = *fromP;
  while (from < fromLim && to < toLim) {
    switch (((struct normal_encoding *)enc)->type[(unsigned char)*from]) {
    case BT_LEAD2:
      if (fromLim - from < 2) {
        res = XML_CONVERT_INPUT_INCOMPLETE;
        break;
      }
      *to++ = (unsigned short)(((from[0] & 0x1f) << 6) | (from[1] & 0x3f));
      from += 2;
      break;
    case BT_LEAD3:
      if (fromLim - from < 3) {
        res = XML_CONVERT_INPUT_INCOMPLETE;
        break;
      }
      *to++ = (unsigned short)(((from[0] & 0xf) << 12)
                               | ((from[1] & 0x3f) << 6) | (from[2] & 0x3f));
      from += 3;

    case BT_LEAD4:
      {
        unsigned long n;
        if (toLim - to < 2) {
          res = XML_CONVERT_OUTPUT_EXHAUSTED;
          goto after;
        }
        if (fromLim - from < 4) {
          res = XML_CONVERT_INPUT_INCOMPLETE;
          goto after;
        }
        n = ((from[0] & 0x7) << 18) | ((from[1] & 0x3f) << 12)
            | ((from[2] & 0x3f) << 6) | (from[3] & 0x3f);
        n -= 0x10000;

after:
  *fromP = from;
  *toP = to;
  return res;
}

#ifdef XML_NS

  STANDARD_VTABLE(sb_) NORMAL_VTABLE(utf8_)
};

static enum XML_Convert_Result PTRCALL
latin1_toUtf8(const ENCODING *enc,
              const char **fromP, const char *fromLim,
              char **toP, const char *toLim)

  for (;;) {
    unsigned char c;
    if (*fromP == fromLim)
      return XML_CONVERT_COMPLETED;
    c = (unsigned char)**fromP;
    if (c & 0x80) {
      if (toLim - *toP < 2)
        return XML_CONVERT_OUTPUT_EXHAUSTED;
      *(*toP)++ = (char)((c >> 6) | UTF8_cval2);
      *(*toP)++ = (char)((c & 0x3f) | 0x80);
      (*fromP)++;
    }
    else {
      if (*toP == toLim)
        return XML_CONVERT_OUTPUT_EXHAUSTED;
      *(*toP)++ = *(*fromP)++;
    }
  }
}

static enum XML_Convert_Result PTRCALL
latin1_toUtf16(const ENCODING *enc,
               const char **fromP, const char *fromLim,
               unsigned short **toP, const unsigned short *toLim)
{
  while (*fromP < fromLim && *toP < toLim)
    *(*toP)++ = (unsigned char)*(*fromP)++;

  if ((*toP == toLim) && (*fromP < fromLim))
    return XML_CONVERT_OUTPUT_EXHAUSTED;
  else
    return XML_CONVERT_COMPLETED;
}

#ifdef XML_NS

  STANDARD_VTABLE(sb_)
};

static enum XML_Convert_Result PTRCALL
ascii_toUtf8(const ENCODING *enc,
             const char **fromP, const char *fromLim,
             char **toP, const char *toLim)
{
  while (*fromP < fromLim && *toP < toLim)
    *(*toP)++ = *(*fromP)++;

  if ((*toP == toLim) && (*fromP < fromLim))
    return XML_CONVERT_OUTPUT_EXHAUSTED;
  else
    return XML_CONVERT_COMPLETED;
}

#ifdef XML_NS

}

#define DEFINE_UTF16_TO_UTF8(E) \
static enum XML_Convert_Result  PTRCALL \
E ## toUtf8(const ENCODING *enc, \
            const char **fromP, const char *fromLim, \
            char **toP, const char *toLim) \
{ \
  const char *from = *fromP; \
  fromLim = from + (((fromLim - from) >> 1) << 1);  /* shrink to even */ \
  for (; from < fromLim; from += 2) { \
    int plane; \
    unsigned char lo2; \
    unsigned char lo = GET_LO(from); \

      if (lo < 0x80) { \
        if (*toP == toLim) { \
          *fromP = from; \
          return XML_CONVERT_OUTPUT_EXHAUSTED; \
        } \
        *(*toP)++ = lo; \
        break; \

    case 0x4: case 0x5: case 0x6: case 0x7: \
      if (toLim -  *toP < 2) { \
        *fromP = from; \
        return XML_CONVERT_OUTPUT_EXHAUSTED; \
      } \
      *(*toP)++ = ((lo >> 6) | (hi << 2) |  UTF8_cval2); \
      *(*toP)++ = ((lo & 0x3f) | 0x80); \

    default: \
      if (toLim -  *toP < 3)  { \
        *fromP = from; \
        return XML_CONVERT_OUTPUT_EXHAUSTED; \
      } \
      /* 16 bits divided 4, 6, 6 amongst 3 bytes */ \
      *(*toP)++ = ((hi >> 4) | UTF8_cval3); \

    case 0xD8: case 0xD9: case 0xDA: case 0xDB: \
      if (toLim -  *toP < 4) { \
        *fromP = from; \
        return XML_CONVERT_OUTPUT_EXHAUSTED; \
      } \
      if (fromLim - from < 4) { \
        *fromP = from; \
        return XML_CONVERT_INPUT_INCOMPLETE; \
      } \
      plane = (((hi & 0x3) << 2) | ((lo >> 6) & 0x3)) + 1; \
      *(*toP)++ = ((plane >> 2) | UTF8_cval4); \

    } \
  } \
  *fromP = from; \
  if (from < fromLim) \
    return XML_CONVERT_INPUT_INCOMPLETE; \
  else \
    return XML_CONVERT_COMPLETED; \
}

#define DEFINE_UTF16_TO_UTF16(E) \
static enum XML_Convert_Result  PTRCALL \
E ## toUtf16(const ENCODING *enc, \
             const char **fromP, const char *fromLim, \
             unsigned short **toP, const unsigned short *toLim) \
{ \
  enum XML_Convert_Result res = XML_CONVERT_COMPLETED; \
  fromLim = *fromP + (((fromLim - *fromP) >> 1) << 1);  /* shrink to even */ \
  /* Avoid copying first half only of surrogate */ \
  if (fromLim - *fromP > ((toLim - *toP) << 1) \
      && (GET_HI(fromLim - 2) & 0xF8) == 0xD8) { \
    fromLim -= 2; \
    res = XML_CONVERT_INPUT_INCOMPLETE; \
  } \
  for (; *fromP < fromLim && *toP < toLim; *fromP += 2) \
    *(*toP)++ = (GET_HI(*fromP) << 8) | GET_LO(*fromP); \
  if ((*toP == toLim) && (*fromP < fromLim)) \
    return XML_CONVERT_OUTPUT_EXHAUSTED; \
  else \
    return res; \
}

#define SET2(ptr, ch) \

  return (c & ~0xFFFF) || checkCharRefNumber(c) < 0;
}

static enum XML_Convert_Result PTRCALL
unknown_toUtf8(const ENCODING *enc,
               const char **fromP, const char *fromLim,
               char **toP, const char *toLim)

    const char *utf8;
    int n;
    if (*fromP == fromLim)
      return XML_CONVERT_COMPLETED;
    utf8 = uenc->utf8[(unsigned char)**fromP];
    n = *utf8++;
    if (n == 0) {
      int c = uenc->convert(uenc->userData, *fromP);
      n = XmlUtf8Encode(c, buf);
      if (n > toLim - *toP)
        return XML_CONVERT_OUTPUT_EXHAUSTED;
      utf8 = buf;
      *fromP += (AS_NORMAL_ENCODING(enc)->type[(unsigned char)**fromP]
                 - (BT_LEAD2 - 2));
    }
    else {
      if (n > toLim - *toP)
        return XML_CONVERT_OUTPUT_EXHAUSTED;
      (*fromP)++;
    }
    do {

  }
}

static enum XML_Convert_Result PTRCALL
unknown_toUtf16(const ENCODING *enc,
                const char **fromP, const char *fromLim,
                unsigned short **toP, const unsigned short *toLim)
{
  const struct unknown_encoding *uenc = AS_UNKNOWN_ENCODING(enc);
  while (*fromP < fromLim && *toP < toLim) {
    unsigned short c = uenc->utf16[(unsigned char)**fromP];
    if (c == 0) {
      c = (unsigned short)

      (*fromP)++;
    *(*toP)++ = c;
  }

  if ((*toP == toLim) && (*fromP < fromLim))
    return XML_CONVERT_OUTPUT_EXHAUSTED;
  else
    return XML_CONVERT_COMPLETED;
}

ENCODING *

{
  const ENCODING **encPtr;

  if (ptr >= end)
    return XML_TOK_NONE;
  encPtr = enc->encPtr;
  if (ptr + 1 == end) {




                               const char *,
                               const char **);

enum XML_Convert_Result {
  XML_CONVERT_COMPLETED = 0,
  XML_CONVERT_INPUT_INCOMPLETE = 1,
  XML_CONVERT_OUTPUT_EXHAUSTED = 2  /* and therefore potentially input remaining as well */
};

struct encoding {
  SCANNER scanners[XML_N_STATES];
  SCANNER literalScanners[XML_N_LITERAL_TYPES];

                            const char *ptr,
                            const char *end,
                            const char **badPtr);
  enum XML_Convert_Result (PTRCALL *utf8Convert)(const ENCODING *enc,
                              const char **fromP,
                              const char *fromLim,
                              char **toP,
                              const char *toLim);
  enum XML_Convert_Result (PTRCALL *utf16Convert)(const ENCODING *enc,
                               const char **fromP,
                               const char *fromLim,
                               unsigned short **toP,




PREFIX(scanComment)(const ENCODING *enc, const char *ptr,
                    const char *end, const char **nextTokPtr)
{
  if (ptr < end) {
    if (!CHAR_MATCHES(enc, ptr, ASCII_MINUS)) {
      *nextTokPtr = ptr;
      return XML_TOK_INVALID;
    }
    ptr += MINBPC(enc);
    while (ptr < end) {
      switch (BYTE_TYPE(enc, ptr)) {
      INVALID_CASES(ptr, nextTokPtr)
      case BT_MINUS:

    *nextTokPtr = ptr;
    return XML_TOK_INVALID;
  }
  while (ptr < end) {
    switch (BYTE_TYPE(enc, ptr)) {
    case BT_PERCNT:
      if (ptr + MINBPC(enc) == end)

    *nextTokPtr = ptr;
    return XML_TOK_INVALID;
  }
  while (ptr < end) {
    switch (BYTE_TYPE(enc, ptr)) {
    CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
    case BT_S: case BT_CR: case BT_LF:

        return XML_TOK_INVALID;
      }
      ptr += MINBPC(enc);
      while (ptr < end) {
        switch (BYTE_TYPE(enc, ptr)) {
        INVALID_CASES(ptr, nextTokPtr)
        case BT_QUEST:

PREFIX(cdataSectionTok)(const ENCODING *enc, const char *ptr,
                        const char *end, const char **nextTokPtr)
{
  if (ptr >= end)
    return XML_TOK_NONE;
  if (MINBPC(enc) > 1) {
    size_t n = end - ptr;

    ptr += MINBPC(enc);
    break;
  }
  while (ptr < end) {
    switch (BYTE_TYPE(enc, ptr)) {
#define LEAD_CASE(n) \
    case BT_LEAD ## n: \

    *nextTokPtr = ptr;
    return XML_TOK_INVALID;
  }
  while (ptr < end) {
    switch (BYTE_TYPE(enc, ptr)) {
    CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
    case BT_S: case BT_CR: case BT_LF:
      for (ptr += MINBPC(enc); ptr < end; ptr += MINBPC(enc)) {
        switch (BYTE_TYPE(enc, ptr)) {
        case BT_S: case BT_CR: case BT_LF:
          break;

PREFIX(scanHexCharRef)(const ENCODING *enc, const char *ptr,
                       const char *end, const char **nextTokPtr)
{
  if (ptr < end) {
    switch (BYTE_TYPE(enc, ptr)) {
    case BT_DIGIT:
    case BT_HEX:

      *nextTokPtr = ptr;
      return XML_TOK_INVALID;
    }
    for (ptr += MINBPC(enc); ptr < end; ptr += MINBPC(enc)) {
      switch (BYTE_TYPE(enc, ptr)) {
      case BT_DIGIT:
      case BT_HEX:

PREFIX(scanCharRef)(const ENCODING *enc, const char *ptr,
                    const char *end, const char **nextTokPtr)
{
  if (ptr < end) {
    if (CHAR_MATCHES(enc, ptr, ASCII_x))
      return PREFIX(scanHexCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
    switch (BYTE_TYPE(enc, ptr)) {

      *nextTokPtr = ptr;
      return XML_TOK_INVALID;
    }
    for (ptr += MINBPC(enc); ptr < end; ptr += MINBPC(enc)) {
      switch (BYTE_TYPE(enc, ptr)) {
      case BT_DIGIT:
        break;

    *nextTokPtr = ptr;
    return XML_TOK_INVALID;
  }
  while (ptr < end) {
    switch (BYTE_TYPE(enc, ptr)) {
    CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
    case BT_SEMI:

#ifdef XML_NS
  int hadColon = 0;
#endif
  while (ptr < end) {
    switch (BYTE_TYPE(enc, ptr)) {
    CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
#ifdef XML_NS

  hadColon = 0;
#endif
  /* we have a start-tag */
  while (ptr < end) {
    switch (BYTE_TYPE(enc, ptr)) {
    CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
#ifdef XML_NS

    case BT_S: case BT_CR: case BT_LF:
      {
        ptr += MINBPC(enc);
        while (ptr < end) {
          switch (BYTE_TYPE(enc, ptr)) {
          CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
          case BT_GT:

PREFIX(contentTok)(const ENCODING *enc, const char *ptr, const char *end,
                   const char **nextTokPtr)
{
  if (ptr >= end)
    return XML_TOK_NONE;
  if (MINBPC(enc) > 1) {
    size_t n = end - ptr;

    ptr += MINBPC(enc);
    break;
  }
  while (ptr < end) {
    switch (BYTE_TYPE(enc, ptr)) {
#define LEAD_CASE(n) \
    case BT_LEAD ## n: \

    *nextTokPtr = ptr;
    return XML_TOK_INVALID;
  }
  while (ptr < end) {
    switch (BYTE_TYPE(enc, ptr)) {
    CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
    case BT_SEMI:

    *nextTokPtr = ptr;
    return XML_TOK_INVALID;
  }
  while (ptr < end) {
    switch (BYTE_TYPE(enc, ptr)) {
    CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
    case BT_CR: case BT_LF: case BT_S:

                const char *ptr, const char *end,
                const char **nextTokPtr)
{
  while (ptr < end) {
    int t = BYTE_TYPE(enc, ptr);
    switch (t) {
    INVALID_CASES(ptr, nextTokPtr)

                  const char **nextTokPtr)
{
  int tok;
  if (ptr >= end)
    return XML_TOK_NONE;
  if (MINBPC(enc) > 1) {
    size_t n = end - ptr;

    *nextTokPtr = ptr;
    return XML_TOK_INVALID;
  }
  while (ptr < end) {
    switch (BYTE_TYPE(enc, ptr)) {
    CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
    case BT_GT: case BT_RPAR: case BT_COMMA:

                          const char *end, const char **nextTokPtr)
{
  const char *start;
  if (ptr >= end)
    return XML_TOK_NONE;
  start = ptr;
  while (ptr < end) {
    switch (BYTE_TYPE(enc, ptr)) {
#define LEAD_CASE(n) \
    case BT_LEAD ## n: ptr += n; break;

                       const char *end, const char **nextTokPtr)
{
  const char *start;
  if (ptr >= end)
    return XML_TOK_NONE;
  start = ptr;
  while (ptr < end) {
    switch (BYTE_TYPE(enc, ptr)) {
#define LEAD_CASE(n) \
    case BT_LEAD ## n: ptr += n; break;

      end = ptr + n;
    }
  }
  while (ptr < end) {
    switch (BYTE_TYPE(enc, ptr)) {
    INVALID_CASES(ptr, nextTokPtr)
    case BT_LT:

{
  ptr += MINBPC(enc);
  end -= MINBPC(enc);
  for (; ptr < end; ptr += MINBPC(enc)) {
    switch (BYTE_TYPE(enc, ptr)) {
    case BT_DIGIT:
    case BT_HEX:

    case BT_CR:
      pos->lineNumber++;
      ptr += MINBPC(enc);
      if (ptr < end && BYTE_TYPE(enc, ptr) == BT_LF)
        ptr += MINBPC(enc);
      pos->columnNumber = (XML_Size)-1;
      break;
- 

Return to bug 583268

Lines 2426-2436 doContent(XML_Parser parser, Link Here

(-)a/expat/lib/xmlparse.c (-12 / +22 lines)
2426	for (;;) {	2426	for (;;) {
2427	int bufSize;	2427	int bufSize;
2428	int convLen;	2428	int convLen;
2429	XmlConvert(enc,	2429	const enum XML_Convert_Result convert_res = XmlConvert(enc,
2430	&fromPtr, rawNameEnd,	2430	&fromPtr, rawNameEnd,
2431	(ICHAR *)&toPtr, (ICHAR )tag->bufEnd - 1);	2431	(ICHAR *)&toPtr, (ICHAR )tag->bufEnd - 1);
2432	convLen = (int)(toPtr - (XML_Char *)tag->buf);	2432	convLen = (int)(toPtr - (XML_Char *)tag->buf);
2433	if (fromPtr == rawNameEnd) {	2433	if ((convert_res == XML_CONVERT_COMPLETED) \|\| (convert_res == XML_CONVERT_INPUT_INCOMPLETE)) {
2434	tag->name.strLen = convLen;	2434	tag->name.strLen = convLen;
2435	break;	2435	break;
2436	}	2436	}
Lines 2651-2661 doContent(XML_Parser parser, Link Here
2651	if (MUST_CONVERT(enc, s)) {	2651	if (MUST_CONVERT(enc, s)) {
2652	for (;;) {	2652	for (;;) {
2653	ICHAR dataPtr = (ICHAR )dataBuf;	2653	ICHAR dataPtr = (ICHAR )dataBuf;
2654	XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd);	2654	const enum XML_Convert_Result convert_res = XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd);
2655	*eventEndPP = s;	2655	*eventEndPP = s;
2656	charDataHandler(handlerArg, dataBuf,	2656	charDataHandler(handlerArg, dataBuf,
2657	(int)(dataPtr - (ICHAR *)dataBuf));	2657	(int)(dataPtr - (ICHAR *)dataBuf));
2658	if (s == next)	2658	if ((convert_res == XML_CONVERT_COMPLETED) \|\| (convert_res == XML_CONVERT_INPUT_INCOMPLETE))
2659	break;	2659	break;
2660	*eventPP = s;	2660	*eventPP = s;
2661	}	2661	}
Lines 3261-3271 doCdataSection(XML_Parser parser, Link Here
3261	if (MUST_CONVERT(enc, s)) {	3261	if (MUST_CONVERT(enc, s)) {
3262	for (;;) {	3262	for (;;) {
3263	ICHAR dataPtr = (ICHAR )dataBuf;	3263	ICHAR dataPtr = (ICHAR )dataBuf;
3264	XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd);	3264	const enum XML_Convert_Result convert_res = XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd);
3265	*eventEndPP = next;	3265	*eventEndPP = next;
3266	charDataHandler(handlerArg, dataBuf,	3266	charDataHandler(handlerArg, dataBuf,
3267	(int)(dataPtr - (ICHAR *)dataBuf));	3267	(int)(dataPtr - (ICHAR *)dataBuf));
3268	if (s == next)	3268	if ((convert_res == XML_CONVERT_COMPLETED) \|\| (convert_res == XML_CONVERT_INPUT_INCOMPLETE))
3269	break;	3269	break;
3270	*eventPP = s;	3270	*eventPP = s;
3271	}	3271	}
Lines 5342-5347 reportDefault(XML_Parser parser, const ENCODING *enc, Link Here
5342	const char s, const char end)	5342	const char s, const char end)
5343	{	5343	{
5344	if (MUST_CONVERT(enc, s)) {	5344	if (MUST_CONVERT(enc, s)) {
		5345	enum XML_Convert_Result convert_res;
5345	const char **eventPP;	5346	const char **eventPP;
5346	const char **eventEndPP;	5347	const char **eventEndPP;
5347	if (enc == encoding) {	5348	if (enc == encoding) {
Lines 5354-5364 reportDefault(XML_Parser parser, const ENCODING *enc, Link Here
5354	}	5355	}
5355	do {	5356	do {
5356	ICHAR dataPtr = (ICHAR )dataBuf;	5357	ICHAR dataPtr = (ICHAR )dataBuf;
5357	XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)dataBufEnd);	5358	convert_res = XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)dataBufEnd);
5358	*eventEndPP = s;	5359	*eventEndPP = s;
5359	defaultHandler(handlerArg, dataBuf, (int)(dataPtr - (ICHAR *)dataBuf));	5360	defaultHandler(handlerArg, dataBuf, (int)(dataPtr - (ICHAR *)dataBuf));
5360	*eventPP = s;	5361	*eventPP = s;
5361	} while (s != end);	5362	} while ((convert_res != XML_CONVERT_COMPLETED) && (convert_res != XML_CONVERT_INPUT_INCOMPLETE));
5362	}	5363	}
5363	else	5364	else
5364	defaultHandler(handlerArg, (XML_Char )s, (int)((XML_Char )end - (XML_Char *)s));	5365	defaultHandler(handlerArg, (XML_Char )s, (int)((XML_Char )end - (XML_Char *)s));
Lines 6163-6170 poolAppend(STRING_POOL pool, const ENCODING enc, Link Here
6163	if (!pool->ptr && !poolGrow(pool))	6164	if (!pool->ptr && !poolGrow(pool))
6164	return NULL;	6165	return NULL;
6165	for (;;) {	6166	for (;;) {
6166	XmlConvert(enc, &ptr, end, (ICHAR *)&(pool->ptr), (ICHAR )pool->end);	6167	const enum XML_Convert_Result convert_res = XmlConvert(enc, &ptr, end, (ICHAR *)&(pool->ptr), (ICHAR )pool->end);
6167	if (ptr == end)	6168	if ((convert_res == XML_CONVERT_COMPLETED) \|\| (convert_res == XML_CONVERT_INPUT_INCOMPLETE))
6168	break;	6169	break;
6169	if (!poolGrow(pool))	6170	if (!poolGrow(pool))
6170	return NULL;	6171	return NULL;
Lines 6248-6255 poolGrow(STRING_POOL *pool) Link Here
6248	}	6249	}
6249	}	6250	}
6250	if (pool->blocks && pool->start == pool->blocks->s) {	6251	if (pool->blocks && pool->start == pool->blocks->s) {
6251	int blockSize = (int)(pool->end - pool->start)*2;	6252	BLOCK *temp;
6252	BLOCK temp = (BLOCK )	6253	int blockSize = (int)((unsigned)(pool->end - pool->start)*2U);
		6254
		6255	if (blockSize < 0)
		6256	return XML_FALSE;
		6257
		6258	temp = (BLOCK *)
6253	pool->mem->realloc_fcn(pool->blocks,	6259	pool->mem->realloc_fcn(pool->blocks,
6254	(offsetof(BLOCK, s)	6260	(offsetof(BLOCK, s)
6255	+ blockSize * sizeof(XML_Char)));	6261	+ blockSize * sizeof(XML_Char)));
Lines 6264-6269 poolGrow(STRING_POOL *pool) Link Here
6264	else {	6270	else {
6265	BLOCK *tem;	6271	BLOCK *tem;
6266	int blockSize = (int)(pool->end - pool->start);	6272	int blockSize = (int)(pool->end - pool->start);
		6273
		6274	if (blockSize < 0)
		6275	return XML_FALSE;
		6276
6267	if (blockSize < INIT_BLOCK_SIZE)	6277	if (blockSize < INIT_BLOCK_SIZE)
6268	blockSize = INIT_BLOCK_SIZE;	6278	blockSize = INIT_BLOCK_SIZE;
6269	else	6279	else

Lines 130-135 typedef int (PTRCALL SCANNER)(const ENCODING , Link Here

(-)a/expat/lib/xmltok.h (-2 / +8 lines)
130	const char *,	130	const char *,
131	const char **);	131	const char **);
132		132
		133	enum XML_Convert_Result {
		134	XML_CONVERT_COMPLETED = 0,
		135	XML_CONVERT_INPUT_INCOMPLETE = 1,
		136	XML_CONVERT_OUTPUT_EXHAUSTED = 2 /* and therefore potentially input remaining as well */
		137	};
		138
133	struct encoding {	139	struct encoding {
134	SCANNER scanners[XML_N_STATES];	140	SCANNER scanners[XML_N_STATES];
135	SCANNER literalScanners[XML_N_LITERAL_TYPES];	141	SCANNER literalScanners[XML_N_LITERAL_TYPES];
Lines 158-169 struct encoding { Link Here
158	const char *ptr,	164	const char *ptr,
159	const char *end,	165	const char *end,
160	const char **badPtr);	166	const char **badPtr);
161	void (PTRCALL utf8Convert)(const ENCODING enc,	167	enum XML_Convert_Result (PTRCALL utf8Convert)(const ENCODING enc,
162	const char **fromP,	168	const char **fromP,
163	const char *fromLim,	169	const char *fromLim,
164	char **toP,	170	char **toP,
165	const char *toLim);	171	const char *toLim);
166	void (PTRCALL utf16Convert)(const ENCODING enc,	172	enum XML_Convert_Result (PTRCALL utf16Convert)(const ENCODING enc,
167	const char **fromP,	173	const char **fromP,
168	const char *fromLim,	174	const char *fromLim,
169	unsigned short **toP,	175	unsigned short **toP,

Lines 318-356 enum { /* UTF8_cvalN is value of masked first byte of N byte sequence */ Link Here

(-)a/expat/lib/xmltok.c (-30 / +85 lines)
318	UTF8_cval4 = 0xf0	318	UTF8_cval4 = 0xf0
319	};	319	};
320		320
321	static void PTRCALL	321	static enum XML_Convert_Result PTRCALL
322	utf8_toUtf8(const ENCODING *enc,	322	utf8_toUtf8(const ENCODING *enc,
323	const char *fromP, const char fromLim,	323	const char *fromP, const char fromLim,
324	char *toP, const char toLim)	324	char *toP, const char toLim)
325	{	325	{
		326	enum XML_Convert_Result res = XML_CONVERT_COMPLETED;
326	char *to;	327	char *to;
327	const char *from;	328	const char *from;
328	if (fromLim - fromP > toLim - toP) {	329	if (fromLim - fromP > toLim - toP) {
329	/* Avoid copying partial characters. */	330	/* Avoid copying partial characters. */
		331	res = XML_CONVERT_OUTPUT_EXHAUSTED;
330	for (fromLim = fromP + (toLim - toP); fromLim > *fromP; fromLim--)	332	for (fromLim = fromP + (toLim - toP); fromLim > *fromP; fromLim--)
331	if (((unsigned char)fromLim[-1] & 0xc0) != 0x80)	333	if (((unsigned char)fromLim[-1] & 0xc0) != 0x80)
332	break;	334	break;
333	}	335	}
334	for (to = toP, from = fromP; from != fromLim; from++, to++)	336	for (to = toP, from = fromP; (from < fromLim) && (to < toLim); from++, to++)
335	to = from;	337	to = from;
336	*fromP = from;	338	*fromP = from;
337	*toP = to;	339	*toP = to;
		340
		341	if ((to == toLim) && (from < fromLim))
		342	return XML_CONVERT_OUTPUT_EXHAUSTED;
		343	else
		344	return res;
338	}	345	}
339		346
340	static void PTRCALL	347	static enum XML_Convert_Result PTRCALL
341	utf8_toUtf16(const ENCODING *enc,	348	utf8_toUtf16(const ENCODING *enc,
342	const char *fromP, const char fromLim,	349	const char *fromP, const char fromLim,
343	unsigned short *toP, const unsigned short toLim)	350	unsigned short *toP, const unsigned short toLim)
344	{	351	{
		352	enum XML_Convert_Result res = XML_CONVERT_COMPLETED;
345	unsigned short to = toP;	353	unsigned short to = toP;
346	const char from = fromP;	354	const char from = fromP;
347	while (from != fromLim && to != toLim) {	355	while (from < fromLim && to < toLim) {
348	switch (((struct normal_encoding )enc)->type[(unsigned char)from]) {	356	switch (((struct normal_encoding )enc)->type[(unsigned char)from]) {
349	case BT_LEAD2:	357	case BT_LEAD2:
		358	if (fromLim - from < 2) {
		359	res = XML_CONVERT_INPUT_INCOMPLETE;
		360	break;
		361	}
350	*to++ = (unsigned short)(((from[0] & 0x1f) << 6) \| (from[1] & 0x3f));	362	*to++ = (unsigned short)(((from[0] & 0x1f) << 6) \| (from[1] & 0x3f));
351	from += 2;	363	from += 2;
352	break;	364	break;
353	case BT_LEAD3:	365	case BT_LEAD3:
		366	if (fromLim - from < 3) {
		367	res = XML_CONVERT_INPUT_INCOMPLETE;
		368	break;
		369	}
354	*to++ = (unsigned short)(((from[0] & 0xf) << 12)	370	*to++ = (unsigned short)(((from[0] & 0xf) << 12)
355	\| ((from[1] & 0x3f) << 6) \| (from[2] & 0x3f));	371	\| ((from[1] & 0x3f) << 6) \| (from[2] & 0x3f));
356	from += 3;	372	from += 3;
Lines 358-365 utf8_toUtf16(const ENCODING *enc, Link Here
358	case BT_LEAD4:	374	case BT_LEAD4:
359	{	375	{
360	unsigned long n;	376	unsigned long n;
361	if (to + 1 == toLim)	377	if (toLim - to < 2) {
		378	res = XML_CONVERT_OUTPUT_EXHAUSTED;
362	goto after;	379	goto after;
		380	}
		381	if (fromLim - from < 4) {
		382	res = XML_CONVERT_INPUT_INCOMPLETE;
		383	goto after;
		384	}
363	n = ((from[0] & 0x7) << 18) \| ((from[1] & 0x3f) << 12)	385	n = ((from[0] & 0x7) << 18) \| ((from[1] & 0x3f) << 12)
364	\| ((from[2] & 0x3f) << 6) \| (from[3] & 0x3f);	386	\| ((from[2] & 0x3f) << 6) \| (from[3] & 0x3f);
365	n -= 0x10000;	387	n -= 0x10000;
Lines 377-382 utf8_toUtf16(const ENCODING *enc, Link Here
377	after:	399	after:
378	*fromP = from;	400	*fromP = from;
379	*toP = to;	401	*toP = to;
		402	return res;
380	}	403	}
381		404
382	#ifdef XML_NS	405	#ifdef XML_NS
Lines 425-431 static const struct normal_encoding internal_utf8_encoding = { Link Here
425	STANDARD_VTABLE(sb_) NORMAL_VTABLE(utf8_)	448	STANDARD_VTABLE(sb_) NORMAL_VTABLE(utf8_)
426	};	449	};
427		450
428	static void PTRCALL	451	static enum XML_Convert_Result PTRCALL
429	latin1_toUtf8(const ENCODING *enc,	452	latin1_toUtf8(const ENCODING *enc,
430	const char *fromP, const char fromLim,	453	const char *fromP, const char fromLim,
431	char *toP, const char toLim)	454	char *toP, const char toLim)
Lines 433-462 latin1_toUtf8(const ENCODING *enc, Link Here
433	for (;;) {	456	for (;;) {
434	unsigned char c;	457	unsigned char c;
435	if (*fromP == fromLim)	458	if (*fromP == fromLim)
436	break;	459	return XML_CONVERT_COMPLETED;
437	c = (unsigned char)**fromP;	460	c = (unsigned char)**fromP;
438	if (c & 0x80) {	461	if (c & 0x80) {
439	if (toLim - *toP < 2)	462	if (toLim - *toP < 2)
440	break;	463	return XML_CONVERT_OUTPUT_EXHAUSTED;
441	(toP)++ = (char)((c >> 6) \| UTF8_cval2);	464	(toP)++ = (char)((c >> 6) \| UTF8_cval2);
442	(toP)++ = (char)((c & 0x3f) \| 0x80);	465	(toP)++ = (char)((c & 0x3f) \| 0x80);
443	(*fromP)++;	466	(*fromP)++;
444	}	467	}
445	else {	468	else {
446	if (*toP == toLim)	469	if (*toP == toLim)
447	break;	470	return XML_CONVERT_OUTPUT_EXHAUSTED;
448	(toP)++ = (fromP)++;	471	(toP)++ = (fromP)++;
449	}	472	}
450	}	473	}
451	}	474	}
452		475
453	static void PTRCALL	476	static enum XML_Convert_Result PTRCALL
454	latin1_toUtf16(const ENCODING *enc,	477	latin1_toUtf16(const ENCODING *enc,
455	const char *fromP, const char fromLim,	478	const char *fromP, const char fromLim,
456	unsigned short *toP, const unsigned short toLim)	479	unsigned short *toP, const unsigned short toLim)
457	{	480	{
458	while (fromP != fromLim && toP != toLim)	481	while (fromP < fromLim && toP < toLim)
459	(toP)++ = (unsigned char)(fromP)++;	482	(toP)++ = (unsigned char)(fromP)++;
		483
		484	if ((toP == toLim) && (fromP < fromLim))
		485	return XML_CONVERT_OUTPUT_EXHAUSTED;
		486	else
		487	return XML_CONVERT_COMPLETED;
460	}	488	}
461		489
462	#ifdef XML_NS	490	#ifdef XML_NS
Lines 483-495 static const struct normal_encoding latin1_encoding = { Link Here
483	STANDARD_VTABLE(sb_)	511	STANDARD_VTABLE(sb_)
484	};	512	};
485		513
486	static void PTRCALL	514	static enum XML_Convert_Result PTRCALL
487	ascii_toUtf8(const ENCODING *enc,	515	ascii_toUtf8(const ENCODING *enc,
488	const char *fromP, const char fromLim,	516	const char *fromP, const char fromLim,
489	char *toP, const char toLim)	517	char *toP, const char toLim)
490	{	518	{
491	while (fromP != fromLim && toP != toLim)	519	while (fromP < fromLim && toP < toLim)
492	(toP)++ = (fromP)++;	520	(toP)++ = (fromP)++;
		521
		522	if ((toP == toLim) && (fromP < fromLim))
		523	return XML_CONVERT_OUTPUT_EXHAUSTED;
		524	else
		525	return XML_CONVERT_COMPLETED;
493	}	526	}
494		527
495	#ifdef XML_NS	528	#ifdef XML_NS
Lines 536-548 unicode_byte_type(char hi, char lo) Link Here
536	}	569	}
537		570
538	#define DEFINE_UTF16_TO_UTF8(E) \	571	#define DEFINE_UTF16_TO_UTF8(E) \
539	static void PTRCALL \	572	static enum XML_Convert_Result PTRCALL \
540	E ## toUtf8(const ENCODING *enc, \	573	E ## toUtf8(const ENCODING *enc, \
541	const char *fromP, const char fromLim, \	574	const char *fromP, const char fromLim, \
542	char *toP, const char toLim) \	575	char *toP, const char toLim) \
543	{ \	576	{ \
544	const char *from; \	577	const char from = fromP; \
545	for (from = *fromP; from != fromLim; from += 2) { \	578	fromLim = from + (((fromLim - from) >> 1) << 1); /* shrink to even */ \
		579	for (; from < fromLim; from += 2) { \
546	int plane; \	580	int plane; \
547	unsigned char lo2; \	581	unsigned char lo2; \
548	unsigned char lo = GET_LO(from); \	582	unsigned char lo = GET_LO(from); \
Lines 552-558 E ## toUtf8(const ENCODING *enc, \ Link Here
552	if (lo < 0x80) { \	586	if (lo < 0x80) { \
553	if (*toP == toLim) { \	587	if (*toP == toLim) { \
554	*fromP = from; \	588	*fromP = from; \
555	return; \	589	return XML_CONVERT_OUTPUT_EXHAUSTED; \
556	} \	590	} \
557	(toP)++ = lo; \	591	(toP)++ = lo; \
558	break; \	592	break; \
Lines 562-568 E ## toUtf8(const ENCODING *enc, \ Link Here
562	case 0x4: case 0x5: case 0x6: case 0x7: \	596	case 0x4: case 0x5: case 0x6: case 0x7: \
563	if (toLim - *toP < 2) { \	597	if (toLim - *toP < 2) { \
564	*fromP = from; \	598	*fromP = from; \
565	return; \	599	return XML_CONVERT_OUTPUT_EXHAUSTED; \
566	} \	600	} \
567	(toP)++ = ((lo >> 6) \| (hi << 2) \| UTF8_cval2); \	601	(toP)++ = ((lo >> 6) \| (hi << 2) \| UTF8_cval2); \
568	(toP)++ = ((lo & 0x3f) \| 0x80); \	602	(toP)++ = ((lo & 0x3f) \| 0x80); \
Lines 570-576 E ## toUtf8(const ENCODING *enc, \ Link Here
570	default: \	604	default: \
571	if (toLim - *toP < 3) { \	605	if (toLim - *toP < 3) { \
572	*fromP = from; \	606	*fromP = from; \
573	return; \	607	return XML_CONVERT_OUTPUT_EXHAUSTED; \
574	} \	608	} \
575	/* 16 bits divided 4, 6, 6 amongst 3 bytes */ \	609	/* 16 bits divided 4, 6, 6 amongst 3 bytes */ \
576	(toP)++ = ((hi >> 4) \| UTF8_cval3); \	610	(toP)++ = ((hi >> 4) \| UTF8_cval3); \
Lines 580-586 E ## toUtf8(const ENCODING *enc, \ Link Here
580	case 0xD8: case 0xD9: case 0xDA: case 0xDB: \	614	case 0xD8: case 0xD9: case 0xDA: case 0xDB: \
581	if (toLim - *toP < 4) { \	615	if (toLim - *toP < 4) { \
582	*fromP = from; \	616	*fromP = from; \
583	return; \	617	return XML_CONVERT_OUTPUT_EXHAUSTED; \
		618	} \
		619	if (fromLim - from < 4) { \
		620	*fromP = from; \
		621	return XML_CONVERT_INPUT_INCOMPLETE; \
584	} \	622	} \
585	plane = (((hi & 0x3) << 2) \| ((lo >> 6) & 0x3)) + 1; \	623	plane = (((hi & 0x3) << 2) \| ((lo >> 6) & 0x3)) + 1; \
586	(toP)++ = ((plane >> 2) \| UTF8_cval4); \	624	(toP)++ = ((plane >> 2) \| UTF8_cval4); \
Lines 596-615 E ## toUtf8(const ENCODING *enc, \ Link Here
596	} \	634	} \
597	} \	635	} \
598	*fromP = from; \	636	*fromP = from; \
		637	if (from < fromLim) \
		638	return XML_CONVERT_INPUT_INCOMPLETE; \
		639	else \
		640	return XML_CONVERT_COMPLETED; \
599	}	641	}
600		642
601	#define DEFINE_UTF16_TO_UTF16(E) \	643	#define DEFINE_UTF16_TO_UTF16(E) \
602	static void PTRCALL \	644	static enum XML_Convert_Result PTRCALL \
603	E ## toUtf16(const ENCODING *enc, \	645	E ## toUtf16(const ENCODING *enc, \
604	const char *fromP, const char fromLim, \	646	const char *fromP, const char fromLim, \
605	unsigned short *toP, const unsigned short toLim) \	647	unsigned short *toP, const unsigned short toLim) \
606	{ \	648	{ \
		649	enum XML_Convert_Result res = XML_CONVERT_COMPLETED; \
		650	fromLim = fromP + (((fromLim - fromP) >> 1) << 1); /* shrink to even */ \
607	/* Avoid copying first half only of surrogate */ \	651	/* Avoid copying first half only of surrogate */ \
608	if (fromLim - fromP > ((toLim - toP) << 1) \	652	if (fromLim - fromP > ((toLim - toP) << 1) \
609	&& (GET_HI(fromLim - 2) & 0xF8) == 0xD8) \	653	&& (GET_HI(fromLim - 2) & 0xF8) == 0xD8) { \
610	fromLim -= 2; \	654	fromLim -= 2; \
611	for (; fromP != fromLim && toP != toLim; *fromP += 2) \	655	res = XML_CONVERT_INPUT_INCOMPLETE; \
		656	} \
		657	for (; fromP < fromLim && toP < toLim; *fromP += 2) \
612	(toP)++ = (GET_HI(fromP) << 8) \| GET_LO(fromP); \	658	(toP)++ = (GET_HI(fromP) << 8) \| GET_LO(fromP); \
		659	if ((toP == toLim) && (fromP < fromLim)) \
		660	return XML_CONVERT_OUTPUT_EXHAUSTED; \
		661	else \
		662	return res; \
613	}	663	}
614		664
615	#define SET2(ptr, ch) \	665	#define SET2(ptr, ch) \
Lines 1288-1294 unknown_isInvalid(const ENCODING enc, const char p) Link Here
1288	return (c & ~0xFFFF) \|\| checkCharRefNumber(c) < 0;	1338	return (c & ~0xFFFF) \|\| checkCharRefNumber(c) < 0;
1289	}	1339	}
1290		1340
1291	static void PTRCALL	1341	static enum XML_Convert_Result PTRCALL
1292	unknown_toUtf8(const ENCODING *enc,	1342	unknown_toUtf8(const ENCODING *enc,
1293	const char *fromP, const char fromLim,	1343	const char *fromP, const char fromLim,
1294	char *toP, const char toLim)	1344	char *toP, const char toLim)
Lines 1299-1319 unknown_toUtf8(const ENCODING *enc, Link Here
1299	const char *utf8;	1349	const char *utf8;
1300	int n;	1350	int n;
1301	if (*fromP == fromLim)	1351	if (*fromP == fromLim)
1302	break;	1352	return XML_CONVERT_COMPLETED;
1303	utf8 = uenc->utf8[(unsigned char)**fromP];	1353	utf8 = uenc->utf8[(unsigned char)**fromP];
1304	n = *utf8++;	1354	n = *utf8++;
1305	if (n == 0) {	1355	if (n == 0) {
1306	int c = uenc->convert(uenc->userData, *fromP);	1356	int c = uenc->convert(uenc->userData, *fromP);
1307	n = XmlUtf8Encode(c, buf);	1357	n = XmlUtf8Encode(c, buf);
1308	if (n > toLim - *toP)	1358	if (n > toLim - *toP)
1309	break;	1359	return XML_CONVERT_OUTPUT_EXHAUSTED;
1310	utf8 = buf;	1360	utf8 = buf;
1311	fromP += (AS_NORMAL_ENCODING(enc)->type[(unsigned char)*fromP]	1361	fromP += (AS_NORMAL_ENCODING(enc)->type[(unsigned char)*fromP]
1312	- (BT_LEAD2 - 2));	1362	- (BT_LEAD2 - 2));
1313	}	1363	}
1314	else {	1364	else {
1315	if (n > toLim - *toP)	1365	if (n > toLim - *toP)
1316	break;	1366	return XML_CONVERT_OUTPUT_EXHAUSTED;
1317	(*fromP)++;	1367	(*fromP)++;
1318	}	1368	}
1319	do {	1369	do {
Lines 1322-1334 unknown_toUtf8(const ENCODING *enc, Link Here
1322	}	1372	}
1323	}	1373	}
1324		1374
1325	static void PTRCALL	1375	static enum XML_Convert_Result PTRCALL
1326	unknown_toUtf16(const ENCODING *enc,	1376	unknown_toUtf16(const ENCODING *enc,
1327	const char *fromP, const char fromLim,	1377	const char *fromP, const char fromLim,
1328	unsigned short *toP, const unsigned short toLim)	1378	unsigned short *toP, const unsigned short toLim)
1329	{	1379	{
1330	const struct unknown_encoding *uenc = AS_UNKNOWN_ENCODING(enc);	1380	const struct unknown_encoding *uenc = AS_UNKNOWN_ENCODING(enc);
1331	while (fromP != fromLim && toP != toLim) {	1381	while (fromP < fromLim && toP < toLim) {
1332	unsigned short c = uenc->utf16[(unsigned char)**fromP];	1382	unsigned short c = uenc->utf16[(unsigned char)**fromP];
1333	if (c == 0) {	1383	if (c == 0) {
1334	c = (unsigned short)	1384	c = (unsigned short)
Lines 1340-1345 unknown_toUtf16(const ENCODING *enc, Link Here
1340	(*fromP)++;	1390	(*fromP)++;
1341	(toP)++ = c;	1391	(toP)++ = c;
1342	}	1392	}
		1393
		1394	if ((toP == toLim) && (fromP < fromLim))
		1395	return XML_CONVERT_OUTPUT_EXHAUSTED;
		1396	else
		1397	return XML_CONVERT_COMPLETED;
1343	}	1398	}
1344		1399
1345	ENCODING *	1400	ENCODING *
Lines 1503-1509 initScan(const ENCODING * const *encodingTable, Link Here
1503	{	1558	{
1504	const ENCODING **encPtr;	1559	const ENCODING **encPtr;
1505		1560
1506	if (ptr == end)	1561	if (ptr >= end)
1507	return XML_TOK_NONE;	1562	return XML_TOK_NONE;
1508	encPtr = enc->encPtr;	1563	encPtr = enc->encPtr;
1509	if (ptr + 1 == end) {	1564	if (ptr + 1 == end) {

Lines 93-105 static int PTRCALL Link Here

(-)a/expat/lib/xmltok_impl.c (-32 / +31 lines)
93	PREFIX(scanComment)(const ENCODING enc, const char ptr,	93	PREFIX(scanComment)(const ENCODING enc, const char ptr,
94	const char end, const char *nextTokPtr)	94	const char end, const char *nextTokPtr)
95	{	95	{
96	if (ptr != end) {	96	if (ptr < end) {
97	if (!CHAR_MATCHES(enc, ptr, ASCII_MINUS)) {	97	if (!CHAR_MATCHES(enc, ptr, ASCII_MINUS)) {
98	*nextTokPtr = ptr;	98	*nextTokPtr = ptr;
99	return XML_TOK_INVALID;	99	return XML_TOK_INVALID;
100	}	100	}
101	ptr += MINBPC(enc);	101	ptr += MINBPC(enc);
102	while (ptr != end) {	102	while (ptr < end) {
103	switch (BYTE_TYPE(enc, ptr)) {	103	switch (BYTE_TYPE(enc, ptr)) {
104	INVALID_CASES(ptr, nextTokPtr)	104	INVALID_CASES(ptr, nextTokPtr)
105	case BT_MINUS:	105	case BT_MINUS:
Lines 147-153 PREFIX(scanDecl)(const ENCODING enc, const char ptr, Link Here
147	*nextTokPtr = ptr;	147	*nextTokPtr = ptr;
148	return XML_TOK_INVALID;	148	return XML_TOK_INVALID;
149	}	149	}
150	while (ptr != end) {	150	while (ptr < end) {
151	switch (BYTE_TYPE(enc, ptr)) {	151	switch (BYTE_TYPE(enc, ptr)) {
152	case BT_PERCNT:	152	case BT_PERCNT:
153	if (ptr + MINBPC(enc) == end)	153	if (ptr + MINBPC(enc) == end)
Lines 233-239 PREFIX(scanPi)(const ENCODING enc, const char ptr, Link Here
233	*nextTokPtr = ptr;	233	*nextTokPtr = ptr;
234	return XML_TOK_INVALID;	234	return XML_TOK_INVALID;
235	}	235	}
236	while (ptr != end) {	236	while (ptr < end) {
237	switch (BYTE_TYPE(enc, ptr)) {	237	switch (BYTE_TYPE(enc, ptr)) {
238	CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)	238	CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
239	case BT_S: case BT_CR: case BT_LF:	239	case BT_S: case BT_CR: case BT_LF:
Lines 242-248 PREFIX(scanPi)(const ENCODING enc, const char ptr, Link Here
242	return XML_TOK_INVALID;	242	return XML_TOK_INVALID;
243	}	243	}
244	ptr += MINBPC(enc);	244	ptr += MINBPC(enc);
245	while (ptr != end) {	245	while (ptr < end) {
246	switch (BYTE_TYPE(enc, ptr)) {	246	switch (BYTE_TYPE(enc, ptr)) {
247	INVALID_CASES(ptr, nextTokPtr)	247	INVALID_CASES(ptr, nextTokPtr)
248	case BT_QUEST:	248	case BT_QUEST:
Lines 305-311 static int PTRCALL Link Here
305	PREFIX(cdataSectionTok)(const ENCODING enc, const char ptr,	305	PREFIX(cdataSectionTok)(const ENCODING enc, const char ptr,
306	const char end, const char *nextTokPtr)	306	const char end, const char *nextTokPtr)
307	{	307	{
308	if (ptr == end)	308	if (ptr >= end)
309	return XML_TOK_NONE;	309	return XML_TOK_NONE;
310	if (MINBPC(enc) > 1) {	310	if (MINBPC(enc) > 1) {
311	size_t n = end - ptr;	311	size_t n = end - ptr;
Lines 348-354 PREFIX(cdataSectionTok)(const ENCODING enc, const char ptr, Link Here
348	ptr += MINBPC(enc);	348	ptr += MINBPC(enc);
349	break;	349	break;
350	}	350	}
351	while (ptr != end) {	351	while (ptr < end) {
352	switch (BYTE_TYPE(enc, ptr)) {	352	switch (BYTE_TYPE(enc, ptr)) {
353	#define LEAD_CASE(n) \	353	#define LEAD_CASE(n) \
354	case BT_LEAD ## n: \	354	case BT_LEAD ## n: \
Lines 391-401 PREFIX(scanEndTag)(const ENCODING enc, const char ptr, Link Here
391	*nextTokPtr = ptr;	391	*nextTokPtr = ptr;
392	return XML_TOK_INVALID;	392	return XML_TOK_INVALID;
393	}	393	}
394	while (ptr != end) {	394	while (ptr < end) {
395	switch (BYTE_TYPE(enc, ptr)) {	395	switch (BYTE_TYPE(enc, ptr)) {
396	CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)	396	CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
397	case BT_S: case BT_CR: case BT_LF:	397	case BT_S: case BT_CR: case BT_LF:
398	for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) {	398	for (ptr += MINBPC(enc); ptr < end; ptr += MINBPC(enc)) {
399	switch (BYTE_TYPE(enc, ptr)) {	399	switch (BYTE_TYPE(enc, ptr)) {
400	case BT_S: case BT_CR: case BT_LF:	400	case BT_S: case BT_CR: case BT_LF:
401	break;	401	break;
Lines 432-438 static int PTRCALL Link Here
432	PREFIX(scanHexCharRef)(const ENCODING enc, const char ptr,	432	PREFIX(scanHexCharRef)(const ENCODING enc, const char ptr,
433	const char end, const char *nextTokPtr)	433	const char end, const char *nextTokPtr)
434	{	434	{
435	if (ptr != end) {	435	if (ptr < end) {
436	switch (BYTE_TYPE(enc, ptr)) {	436	switch (BYTE_TYPE(enc, ptr)) {
437	case BT_DIGIT:	437	case BT_DIGIT:
438	case BT_HEX:	438	case BT_HEX:
Lines 441-447 PREFIX(scanHexCharRef)(const ENCODING enc, const char ptr, Link Here
441	*nextTokPtr = ptr;	441	*nextTokPtr = ptr;
442	return XML_TOK_INVALID;	442	return XML_TOK_INVALID;
443	}	443	}
444	for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) {	444	for (ptr += MINBPC(enc); ptr < end; ptr += MINBPC(enc)) {
445	switch (BYTE_TYPE(enc, ptr)) {	445	switch (BYTE_TYPE(enc, ptr)) {
446	case BT_DIGIT:	446	case BT_DIGIT:
447	case BT_HEX:	447	case BT_HEX:
Lines 464-470 static int PTRCALL Link Here
464	PREFIX(scanCharRef)(const ENCODING enc, const char ptr,	464	PREFIX(scanCharRef)(const ENCODING enc, const char ptr,
465	const char end, const char *nextTokPtr)	465	const char end, const char *nextTokPtr)
466	{	466	{
467	if (ptr != end) {	467	if (ptr < end) {
468	if (CHAR_MATCHES(enc, ptr, ASCII_x))	468	if (CHAR_MATCHES(enc, ptr, ASCII_x))
469	return PREFIX(scanHexCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);	469	return PREFIX(scanHexCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
470	switch (BYTE_TYPE(enc, ptr)) {	470	switch (BYTE_TYPE(enc, ptr)) {
Lines 474-480 PREFIX(scanCharRef)(const ENCODING enc, const char ptr, Link Here
474	*nextTokPtr = ptr;	474	*nextTokPtr = ptr;
475	return XML_TOK_INVALID;	475	return XML_TOK_INVALID;
476	}	476	}
477	for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) {	477	for (ptr += MINBPC(enc); ptr < end; ptr += MINBPC(enc)) {
478	switch (BYTE_TYPE(enc, ptr)) {	478	switch (BYTE_TYPE(enc, ptr)) {
479	case BT_DIGIT:	479	case BT_DIGIT:
480	break;	480	break;
Lines 506-512 PREFIX(scanRef)(const ENCODING enc, const char ptr, const char *end, Link Here
506	*nextTokPtr = ptr;	506	*nextTokPtr = ptr;
507	return XML_TOK_INVALID;	507	return XML_TOK_INVALID;
508	}	508	}
509	while (ptr != end) {	509	while (ptr < end) {
510	switch (BYTE_TYPE(enc, ptr)) {	510	switch (BYTE_TYPE(enc, ptr)) {
511	CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)	511	CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
512	case BT_SEMI:	512	case BT_SEMI:
Lines 529-535 PREFIX(scanAtts)(const ENCODING enc, const char ptr, const char *end, Link Here
529	#ifdef XML_NS	529	#ifdef XML_NS
530	int hadColon = 0;	530	int hadColon = 0;
531	#endif	531	#endif
532	while (ptr != end) {	532	while (ptr < end) {
533	switch (BYTE_TYPE(enc, ptr)) {	533	switch (BYTE_TYPE(enc, ptr)) {
534	CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)	534	CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
535	#ifdef XML_NS	535	#ifdef XML_NS
Lines 716-722 PREFIX(scanLt)(const ENCODING enc, const char ptr, const char *end, Link Here
716	hadColon = 0;	716	hadColon = 0;
717	#endif	717	#endif
718	/* we have a start-tag */	718	/* we have a start-tag */
719	while (ptr != end) {	719	while (ptr < end) {
720	switch (BYTE_TYPE(enc, ptr)) {	720	switch (BYTE_TYPE(enc, ptr)) {
721	CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)	721	CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
722	#ifdef XML_NS	722	#ifdef XML_NS
Lines 740-746 PREFIX(scanLt)(const ENCODING enc, const char ptr, const char *end, Link Here
740	case BT_S: case BT_CR: case BT_LF:	740	case BT_S: case BT_CR: case BT_LF:
741	{	741	{
742	ptr += MINBPC(enc);	742	ptr += MINBPC(enc);
743	while (ptr != end) {	743	while (ptr < end) {
744	switch (BYTE_TYPE(enc, ptr)) {	744	switch (BYTE_TYPE(enc, ptr)) {
745	CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)	745	CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
746	case BT_GT:	746	case BT_GT:
Lines 785-791 static int PTRCALL Link Here
785	PREFIX(contentTok)(const ENCODING enc, const char ptr, const char *end,	785	PREFIX(contentTok)(const ENCODING enc, const char ptr, const char *end,
786	const char **nextTokPtr)	786	const char **nextTokPtr)
787	{	787	{
788	if (ptr == end)	788	if (ptr >= end)
789	return XML_TOK_NONE;	789	return XML_TOK_NONE;
790	if (MINBPC(enc) > 1) {	790	if (MINBPC(enc) > 1) {
791	size_t n = end - ptr;	791	size_t n = end - ptr;
Lines 832-838 PREFIX(contentTok)(const ENCODING enc, const char ptr, const char *end, Link Here
832	ptr += MINBPC(enc);	832	ptr += MINBPC(enc);
833	break;	833	break;
834	}	834	}
835	while (ptr != end) {	835	while (ptr < end) {
836	switch (BYTE_TYPE(enc, ptr)) {	836	switch (BYTE_TYPE(enc, ptr)) {
837	#define LEAD_CASE(n) \	837	#define LEAD_CASE(n) \
838	case BT_LEAD ## n: \	838	case BT_LEAD ## n: \
Lines 895-901 PREFIX(scanPercent)(const ENCODING enc, const char ptr, const char *end, Link Here
895	*nextTokPtr = ptr;	895	*nextTokPtr = ptr;
896	return XML_TOK_INVALID;	896	return XML_TOK_INVALID;
897	}	897	}
898	while (ptr != end) {	898	while (ptr < end) {
899	switch (BYTE_TYPE(enc, ptr)) {	899	switch (BYTE_TYPE(enc, ptr)) {
900	CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)	900	CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
901	case BT_SEMI:	901	case BT_SEMI:
Lines 921-927 PREFIX(scanPoundName)(const ENCODING enc, const char ptr, const char *end, Link Here
921	*nextTokPtr = ptr;	921	*nextTokPtr = ptr;
922	return XML_TOK_INVALID;	922	return XML_TOK_INVALID;
923	}	923	}
924	while (ptr != end) {	924	while (ptr < end) {
925	switch (BYTE_TYPE(enc, ptr)) {	925	switch (BYTE_TYPE(enc, ptr)) {
926	CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)	926	CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
927	case BT_CR: case BT_LF: case BT_S:	927	case BT_CR: case BT_LF: case BT_S:
Lines 941-947 PREFIX(scanLit)(int open, const ENCODING *enc, Link Here
941	const char ptr, const char end,	941	const char ptr, const char end,
942	const char **nextTokPtr)	942	const char **nextTokPtr)
943	{	943	{
944	while (ptr != end) {	944	while (ptr < end) {
945	int t = BYTE_TYPE(enc, ptr);	945	int t = BYTE_TYPE(enc, ptr);
946	switch (t) {	946	switch (t) {
947	INVALID_CASES(ptr, nextTokPtr)	947	INVALID_CASES(ptr, nextTokPtr)
Lines 973-979 PREFIX(prologTok)(const ENCODING enc, const char ptr, const char *end, Link Here
973	const char **nextTokPtr)	973	const char **nextTokPtr)
974	{	974	{
975	int tok;	975	int tok;
976	if (ptr == end)	976	if (ptr >= end)
977	return XML_TOK_NONE;	977	return XML_TOK_NONE;
978	if (MINBPC(enc) > 1) {	978	if (MINBPC(enc) > 1) {
979	size_t n = end - ptr;	979	size_t n = end - ptr;
Lines 1141-1147 PREFIX(prologTok)(const ENCODING enc, const char ptr, const char *end, Link Here
1141	*nextTokPtr = ptr;	1141	*nextTokPtr = ptr;
1142	return XML_TOK_INVALID;	1142	return XML_TOK_INVALID;
1143	}	1143	}
1144	while (ptr != end) {	1144	while (ptr < end) {
1145	switch (BYTE_TYPE(enc, ptr)) {	1145	switch (BYTE_TYPE(enc, ptr)) {
1146	CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)	1146	CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
1147	case BT_GT: case BT_RPAR: case BT_COMMA:	1147	case BT_GT: case BT_RPAR: case BT_COMMA:
Lines 1204-1213 PREFIX(attributeValueTok)(const ENCODING enc, const char ptr, Link Here
1204	const char end, const char *nextTokPtr)	1204	const char end, const char *nextTokPtr)
1205	{	1205	{
1206	const char *start;	1206	const char *start;
1207	if (ptr == end)	1207	if (ptr >= end)
1208	return XML_TOK_NONE;	1208	return XML_TOK_NONE;
1209	start = ptr;	1209	start = ptr;
1210	while (ptr != end) {	1210	while (ptr < end) {
1211	switch (BYTE_TYPE(enc, ptr)) {	1211	switch (BYTE_TYPE(enc, ptr)) {
1212	#define LEAD_CASE(n) \	1212	#define LEAD_CASE(n) \
1213	case BT_LEAD ## n: ptr += n; break;	1213	case BT_LEAD ## n: ptr += n; break;
Lines 1262-1271 PREFIX(entityValueTok)(const ENCODING enc, const char ptr, Link Here
1262	const char end, const char *nextTokPtr)	1262	const char end, const char *nextTokPtr)
1263	{	1263	{
1264	const char *start;	1264	const char *start;
1265	if (ptr == end)	1265	if (ptr >= end)
1266	return XML_TOK_NONE;	1266	return XML_TOK_NONE;
1267	start = ptr;	1267	start = ptr;
1268	while (ptr != end) {	1268	while (ptr < end) {
1269	switch (BYTE_TYPE(enc, ptr)) {	1269	switch (BYTE_TYPE(enc, ptr)) {
1270	#define LEAD_CASE(n) \	1270	#define LEAD_CASE(n) \
1271	case BT_LEAD ## n: ptr += n; break;	1271	case BT_LEAD ## n: ptr += n; break;
Lines 1326-1332 PREFIX(ignoreSectionTok)(const ENCODING enc, const char ptr, Link Here
1326	end = ptr + n;	1326	end = ptr + n;
1327	}	1327	}
1328	}	1328	}
1329	while (ptr != end) {	1329	while (ptr < end) {
1330	switch (BYTE_TYPE(enc, ptr)) {	1330	switch (BYTE_TYPE(enc, ptr)) {
1331	INVALID_CASES(ptr, nextTokPtr)	1331	INVALID_CASES(ptr, nextTokPtr)
1332	case BT_LT:	1332	case BT_LT:
Lines 1373-1379 PREFIX(isPublicId)(const ENCODING enc, const char ptr, const char *end, Link Here
1373	{	1373	{
1374	ptr += MINBPC(enc);	1374	ptr += MINBPC(enc);
1375	end -= MINBPC(enc);	1375	end -= MINBPC(enc);
1376	for (; ptr != end; ptr += MINBPC(enc)) {	1376	for (; ptr < end; ptr += MINBPC(enc)) {
1377	switch (BYTE_TYPE(enc, ptr)) {	1377	switch (BYTE_TYPE(enc, ptr)) {
1378	case BT_DIGIT:	1378	case BT_DIGIT:
1379	case BT_HEX:	1379	case BT_HEX:
Lines 1760-1766 PREFIX(updatePosition)(const ENCODING *enc, Link Here
1760	case BT_CR:	1760	case BT_CR:
1761	pos->lineNumber++;	1761	pos->lineNumber++;
1762	ptr += MINBPC(enc);	1762	ptr += MINBPC(enc);
1763	if (ptr != end && BYTE_TYPE(enc, ptr) == BT_LF)	1763	if (ptr < end && BYTE_TYPE(enc, ptr) == BT_LF)
1764	ptr += MINBPC(enc);	1764	ptr += MINBPC(enc);
1765	pos->columnNumber = (XML_Size)-1;	1765	pos->columnNumber = (XML_Size)-1;
1766	break;	1766	break;
1767	-