const ENCODING *encoding;
const ENCODING *parserEncoding;
static Processor externalEntityInitProcessor2;static Processor externalEntityInitProcessor3;static Processor externalEntityContentProcessor;static enum XML_ErrorhandleUnknownEncoding(XML_Parser parser, const XML_Char *encodingName);static enum XML_ErrorprocessXmlDecl(XML_Parser parser, int isGeneralTextEntity, const char *, const char *);static enum XML_ErrorinitializeEncoding(XML_Parser parser);static enum XML_ErrordoContent(XML_Parser parser, int startTagLevel, const ENCODING *enc,	  const char *start, const char *end, const char **endPtr);static enum XML_ErrordoCdataSection(XML_Parser parser, const ENCODING *, const char **startPtr, const char *end, const char **nextPtr);static enum XML_Error storeAtts(XML_Parser parser, const ENCODING *, const char *s,				TAG_NAME *tagNamePtr, BINDING **bindingsPtr);staticint addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId, const XML_Char *uri, BINDING **bindingsPtr);static intdefineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *, int isCdata, const XML_Char *dfltValue);static enum XML_ErrorstoreAttributeValue(XML_Parser parser, const ENCODING *, int isCdata, const char *, const char *,		    STRING_POOL *);static enum XML_ErrorappendAttributeValue(XML_Parser parser, const ENCODING *, int isCdata, const char *, const char *,		    STRING_POOL *);static ATTRIBUTE_ID *getAttributeId(XML_Parser parser, const ENCODING *enc, const char *start, const char *end);static int setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *);static enum XML_ErrorstoreEntityValue(XML_Parser parser, const char *start, const char *end);static intreportProcessingInstruction(XML_Parser parser, const ENCODING *enc, const char *start, const char *end);static intreportComment(XML_Parser parser, const ENCODING *enc, const char *start, const char *end);static voidreportDefault(XML_Parser parser, const ENCODING *enc, const char *start, const char *end);static const XML_Char *getContext(XML_Parser parser);static int setContext(XML_Parser parser, const XML_Char *context);static void normalizePublicId(XML_Char *s);static int dtdInit(DTD *);static void dtdDestroy(DTD *);static int dtdCopy(DTD *newDtd, const DTD *oldDtd);static void poolInit(STRING_POOL *);static void poolClear(STRING_POOL *);static void poolDestroy(STRING_POOL *);static XML_Char *poolAppend(STRING_POOL *pool, const ENCODING *enc,			    const char *ptr, const char *end);static XML_Char *poolStoreString(STRING_POOL *pool, const ENCODING *enc,				  const char *ptr, const char *end);static int poolGrow(STRING_POOL *pool);static const XML_Char *poolCopyString(STRING_POOL *pool, const XML_Char *s);static const XML_Char *poolCopyStringN(STRING_POOL *pool, const XML_Char *s, int n);#define poolStart(pool) ((pool)->start)#define poolEnd(pool) ((pool)->ptr)#define poolLength(pool) ((pool)->ptr - (pool)->start)#define poolChop(pool) ((void)--(pool->ptr))#define poolLastChar(pool) (((pool)->ptr)[-1])#define poolDiscard(pool) ((pool)->ptr = (pool)->start)#define poolFinish(pool) ((pool)->start = (pool)->ptr)#define poolAppendChar(pool, c) \  (((pool)->ptr == (pool)->end && !poolGrow(pool)) \   ? 0 \   : ((*((pool)->ptr)++ = c), 1))typedef struct {  /* The first member must be userData so that the XML_GetUserData macro works. */  void *userData;  void *handlerArg;  char *buffer;  /* first character to be parsed */  const char *bufferPtr;  /* past last character to be parsed */  char *bufferEnd;  /* allocated end of buffer */  const char *bufferLim;  long parseEndByteIndex;  const char *parseEndPtr;  XML_Char *dataBuf;  XML_Char *dataBufEnd;  XML_StartElementHandler startElementHandler;  XML_EndElementHandler endElementHandler;  XML_CharacterDataHandler characterDataHandler;  XML_ProcessingInstructionHandler processingInstructionHandler;  XML_CommentHandler commentHandler;  XML_StartCdataSectionHandler startCdataSectionHandler;  XML_EndCdataSectionHandler endCdataSectionHandler;  XML_DefaultHandler defaultHandler;  XML_UnparsedEntityDeclHandler unparsedEntityDeclHandler;  XML_NotationDeclHandler notationDeclHandler;  XML_StartNamespaceDeclHandler startNamespaceDeclHandler;  XML_EndNamespaceDeclHandler endNamespaceDeclHandler;  XML_ExternalEntityRefHandler externalEntityRefHandler;  void *externalEntityRefHandlerArg;  XML_UnknownEncodingHandler unknownEncodingHandler;  const ENCODING *encoding;  INIT_ENCODING initEncoding;  const XML_Char *protocolEncodingName;  int ns;  void *unknownEncodingMem;  void *unknownEncodingData;  void *unknownEncodingHandlerData;  void (*unknownEncodingRelease)(void *);  PROLOG_STATE prologState;  Processor *processor;  enum XML_Error errorCode;  const char *eventPtr;  const char *eventEndPtr;  const char *positionPtr;  OPEN_INTERNAL_ENTITY *openInternalEntities;  int defaultExpandInternalEntities;  int tagLevel;  ENTITY *declEntity;  const XML_Char *declNotationName;  const XML_Char *declNotationPublicId;  ELEMENT_TYPE *declElementType;  ATTRIBUTE_ID *declAttributeId;  char declAttributeIsCdata;  DTD dtd;  TAG *tagStack;  TAG *freeTagList;  BINDING *inheritedBindings;  BINDING *freeBindingList;  int attsSize;  ATTRIBUTE *atts;  POSITION position;  STRING_POOL tempPool;  STRING_POOL temp2Pool;  char *groupConnector;  unsigned groupSize;  int hadExternalDoctype;  XML_Char namespaceSeparator;} Parser;#define userData (((Parser *)parser)->userData)#define handlerArg (((Parser *)parser)->handlerArg)#define startElementHandler (((Parser *)parser)->startElementHandler)#define endElementHandler (((Parser *)parser)->endElementHandler)#define characterDataHandler (((Parser *)parser)->characterDataHandler)#define processingInstructionHandler (((Parser *)parser)->processingInstructionHandler)#define commentHandler (((Parser *)parser)->commentHandler)#define startCdataSectionHandler (((Parser *)parser)->startCdataSectionHandler)#define endCdataSectionHandler (((Parser *)parser)->endCdataSectionHandler)#define defaultHandler (((Parser *)parser)->defaultHandler)#define unparsedEntityDeclHandler (((Parser *)parser)->unparsedEntityDeclHandler)#define notationDeclHandler (((Parser *)parser)->notationDeclHandler)#define startNamespaceDeclHandler (((Parser *)parser)->startNamespaceDeclHandler)#define endNamespaceDeclHandler (((Parser *)parser)->endNamespaceDeclHandler)#define externalEntityRefHandler (((Parser *)parser)->externalEntityRefHandler)#define externalEntityRefHandlerArg (((Parser *)parser)->externalEntityRefHandlerArg)#define unknownEncodingHandler (((Parser *)parser)->unknownEncodingHandler)#define encoding (((Parser *)parser)->encoding)#define initEncoding (((Parser *)parser)->initEncoding)#define unknownEncodingMem (((Parser *)parser)->unknownEncodingMem)#define unknownEncodingData (((Parser *)parser)->unknownEncodingData)#define unknownEncodingHandlerData \  (((Parser *)parser)->unknownEncodingHandlerData)#define unknownEncodingRelease (((Parser *)parser)->unknownEncodingRelease)#define protocolEncodingName (((Parser *)parser)->protocolEncodingName)#define ns (((Parser *)parser)->ns)#define prologState (((Parser *)parser)->prologState)#define processor (((Parser *)parser)->processor)#define errorCode (((Parser *)parser)->errorCode)#define eventPtr (((Parser *)parser)->eventPtr)#define eventEndPtr (((Parser *)parser)->eventEndPtr)#define positionPtr (((Parser *)parser)->positionPtr)#define position (((Parser *)parser)->position)#define openInternalEntities (((Parser *)parser)->openInternalEntities)#define defaultExpandInternalEntities (((Parser *)parser)->defaultExpandInternalEntities)#define tagLevel (((Parser *)parser)->tagLevel)#define buffer (((Parser *)parser)->buffer)#define bufferPtr (((Parser *)parser)->bufferPtr)#define bufferEnd (((Parser *)parser)->bufferEnd)#define parseEndByteIndex (((Parser *)parser)->parseEndByteIndex)#define parseEndPtr (((Parser *)parser)->parseEndPtr)#define bufferLim (((Parser *)parser)->bufferLim)#define dataBuf (((Parser *)parser)->dataBuf)#define dataBufEnd (((Parser *)parser)->dataBufEnd)#define dtd (((Parser *)parser)->dtd)#define declEntity (((Parser *)parser)->declEntity)#define declNotationName (((Parser *)parser)->declNotationName)#define declNotationPublicId (((Parser *)parser)->declNotationPublicId)#define declElementType (((Parser *)parser)->declElementType)#define declAttributeId (((Parser *)parser)->declAttributeId)#define declAttributeIsCdata (((Parser *)parser)->declAttributeIsCdata)#define freeTagList (((Parser *)parser)->freeTagList)#define freeBindingList (((Parser *)parser)->freeBindingList)#define inheritedBindings (((Parser *)parser)->inheritedBindings)#define tagStack (((Parser *)parser)->tagStack)#define atts (((Parser *)parser)->atts)#define attsSize (((Parser *)parser)->attsSize)#define tempPool (((Parser *)parser)->tempPool)#define temp2Pool (((Parser *)parser)->temp2Pool)#define groupConnector (((Parser *)parser)->groupConnector)#define groupSize (((Parser *)parser)->groupSize)#define hadExternalDoctype (((Parser *)parser)->hadExternalDoctype)#define namespaceSeparator (((Parser *)parser)->namespaceSeparator)#ifdef _MSC_VER#ifdef _DEBUGParser *asParser(XML_Parser parser){  return parser;}#endif#endifXML_Parser XML_ParserCreate(const XML_Char *encodingName){  XML_Parser parser = malloc(sizeof(Parser));  if (!parser)    return parser;  processor = prologInitProcessor;  XmlPrologStateInit(&prologState);  userData = 0;  handlerArg = 0;  startElementHandler = 0;  endElementHandler = 0;  characterDataHandler = 0;  processingInstructionHandler = 0;  commentHandler = 0;  startCdataSectionHandler = 0;  endCdataSectionHandler = 0;  defaultHandler = 0;  unparsedEntityDeclHandler = 0;  notationDeclHandler = 0;  startNamespaceDeclHandler = 0;  endNamespaceDeclHandler = 0;  externalEntityRefHandler = 0;  externalEntityRefHandlerArg = parser;  unknownEncodingHandler = 0;  buffer = 0;  bufferPtr = 0;  bufferEnd = 0;  parseEndByteIndex = 0;  parseEndPtr = 0;  bufferLim = 0;  declElementType = 0;  declAttributeId = 0;  declEntity = 0;  declNotationName = 0;  declNotationPublicId = 0;  memset(&position, 0, sizeof(POSITION));  errorCode = XML_ERROR_NONE;  eventPtr = 0;  eventEndPtr = 0;  positionPtr = 0;  openInternalEntities = 0;  tagLevel = 0;  tagStack = 0;  freeTagList = 0;  freeBindingList = 0;  inheritedBindings = 0;  attsSize = INIT_ATTS_SIZE;  atts = malloc(attsSize * sizeof(ATTRIBUTE));  dataBuf = malloc(INIT_DATA_BUF_SIZE * sizeof(XML_Char));  groupSize = 0;  groupConnector = 0;  hadExternalDoctype = 0;  unknownEncodingMem = 0;  unknownEncodingRelease = 0;  unknownEncodingData = 0;  unknownEncodingHandlerData = 0;  namespaceSeparator = '!';  ns = 0;  poolInit(&tempPool);  poolInit(&temp2Pool);  protocolEncodingName = encodingName ? poolCopyString(&tempPool, encodingName) : 0;  if (!dtdInit(&dtd) || !atts || !dataBuf      || (encodingName && !protocolEncodingName)) {    XML_ParserFree(parser);    return 0;  }  dataBufEnd = dataBuf + INIT_DATA_BUF_SIZE;  XmlInitEncoding(&initEncoding, &encoding, 0);  return parser;}XML_Parser XML_ParserCreateNS(const XML_Char *encodingName, XML_Char nsSep){  static  const XML_Char implicitContext[] = {    XML_T('x'), XML_T('m'), XML_T('l'), XML_T('='),    XML_T('h'), XML_T('t'), XML_T('t'), XML_T('p'), XML_T(':'),    XML_T('/'), XML_T('/'), XML_T('w'), XML_T('w'), XML_T('w'),    XML_T('.'), XML_T('w'), XML_T('3'),    XML_T('.'), XML_T('o'), XML_T('r'), XML_T('g'),    XML_T('/'), XML_T('X'), XML_T('M'), XML_T('L'),    XML_T('/'), XML_T('1'), XML_T('9'), XML_T('9'), XML_T('8'),    XML_T('/'), XML_T('n'), XML_T('a'), XML_T('m'), XML_T('e'),    XML_T('s'), XML_T('p'), XML_T('a'), XML_T('c'), XML_T('e'),    XML_T('\0')  };  XML_Parser parser = XML_ParserCreate(encodingName);  if (parser) {    XmlInitEncodingNS(&initEncoding, &encoding, 0);    ns = 1;    namespaceSeparator = nsSep;  }  if (!setContext(parser, implicitContext)) {    XML_ParserFree(parser);    return 0;  }  return parser;}int XML_SetEncoding(XML_Parser parser, const XML_Char *encodingName){  if (!encodingName)    protocolEncodingName = 0;  else {    protocolEncodingName = poolCopyString(&tempPool, encodingName);    if (!protocolEncodingName)      return 0;  }  return 1;}XML_Parser XML_ExternalEntityParserCreate(XML_Parser oldParser,					  const XML_Char *context,					  const XML_Char *encodingName){  XML_Parser parser = oldParser;  DTD *oldDtd = &dtd;  XML_StartElementHandler oldStartElementHandler = startElementHandler;  XML_EndElementHandler oldEndElementHandler = endElementHandler;  XML_CharacterDataHandler oldCharacterDataHandler = characterDataHandler;  XML_ProcessingInstructionHandler oldProcessingInstructionHandler = processingInstructionHandler;  XML_CommentHandler oldCommentHandler = commentHandler;  XML_StartCdataSectionHandler oldStartCdataSectionHandler = startCdataSectionHandler;  XML_EndCdataSectionHandler oldEndCdataSectionHandler = endCdataSectionHandler;  XML_DefaultHandler oldDefaultHandler = defaultHandler;  XML_StartNamespaceDeclHandler oldStartNamespaceDeclHandler = startNamespaceDeclHandler;  XML_EndNamespaceDeclHandler oldEndNamespaceDeclHandler = endNamespaceDeclHandler;  XML_ExternalEntityRefHandler oldExternalEntityRefHandler = externalEntityRefHandler;  XML_UnknownEncodingHandler oldUnknownEncodingHandler = unknownEncodingHandler;  void *oldUserData = userData;  void *oldHandlerArg = handlerArg;  int oldDefaultExpandInternalEntities = defaultExpandInternalEntities;  void *oldExternalEntityRefHandlerArg = externalEntityRefHandlerArg;   parser = (ns            ? XML_ParserCreateNS(encodingName, namespaceSeparator)	    : XML_ParserCreate(encodingName));  if (!parser)    return 0;  startElementHandler = oldStartElementHandler;  endElementHandler = oldEndElementHandler;  characterDataHandler = oldCharacterDataHandler;  processingInstructionHandler = oldProcessingInstructionHandler;  commentHandler = oldCommentHandler;  startCdataSectionHandler = oldStartCdataSectionHandler;  endCdataSectionHandler = oldEndCdataSectionHandler;  defaultHandler = oldDefaultHandler;  startNamespaceDeclHandler = oldStartNamespaceDeclHandler;  endNamespaceDeclHandler = oldEndNamespaceDeclHandler;  externalEntityRefHandler = oldExternalEntityRefHandler;  unknownEncodingHandler = oldUnknownEncodingHandler;  userData = oldUserData;  if (oldUserData == oldHandlerArg)    handlerArg = userData;  else    handlerArg = parser;  if (oldExternalEntityRefHandlerArg != oldParser)    externalEntityRefHandlerArg = oldExternalEntityRefHandlerArg;  defaultExpandInternalEntities = oldDefaultExpandInternalEntities;  if (!dtdCopy(&dtd, oldDtd) || !setContext(parser, context)) {    XML_ParserFree(parser);    return 0;  }  processor = externalEntityInitProcessor;  return parser;}staticvoid destroyBindings(BINDING *bindings){  for (;;) {    BINDING *b = bindings;    if (!b)      break;    bindings = b->nextTagBinding;    free(b->uri);    free(b);  }}void XML_ParserFree(XML_Parser parser){  for (;;) {    TAG *p;    if (tagStack == 0) {      if (freeTagList == 0)	break;      tagStack = freeTagList;      freeTagList = 0;    }    p = tagStack;    tagStack = tagStack->parent;    free(p->buf);    destroyBindings(p->bindings);    free(p);  }  destroyBindings(freeBindingList);  destroyBindings(inheritedBindings);  poolDestroy(&tempPool);  poolDestroy(&temp2Pool);  dtdDestroy(&dtd);  free((void *)atts);  free(groupConnector);  free(buffer);  free(dataBuf);  free(unknownEncodingMem);  if (unknownEncodingRelease)    unknownEncodingRelease(unknownEncodingData);  free(parser);}void XML_UseParserAsHandlerArg(XML_Parser parser){  handlerArg = parser;}void XML_SetUserData(XML_Parser parser, void *p){  if (handlerArg == userData)    handlerArg = userData = p;  else    userData = p;}int XML_SetBase(XML_Parser parser, const XML_Char *p){  if (p) {    p = poolCopyString(&dtd.pool, p);    if (!p)      return 0;    dtd.base = p;  }  else    dtd.base = 0;  return 1;}const XML_Char *XML_GetBase(XML_Parser parser){  return dtd.base;}void XML_SetElementHandler(XML_Parser parser,			   XML_StartElementHandler start,			   XML_EndElementHandler end){  startElementHandler = start;  endElementHandler = end;}void XML_SetCharacterDataHandler(XML_Parser parser,				 XML_CharacterDataHandler handler){  characterDataHandler = handler;}void XML_SetProcessingInstructionHandler(XML_Parser parser,					 XML_ProcessingInstructionHandler handler){  processingInstructionHandler = handler;}void XML_SetCommentHandler(XML_Parser parser,			   XML_CommentHandler handler){  commentHandler = handler;}void XML_SetCdataSectionHandler(XML_Parser parser,				XML_StartCdataSectionHandler start,			        XML_EndCdataSectionHandler end){  startCdataSectionHandler = start;  endCdataSectionHandler = end;}void XML_SetDefaultHandler(XML_Parser parser,			   XML_DefaultHandler handler){  defaultHandler = handler;  defaultExpandInternalEntities = 0;}void XML_SetDefaultHandlerExpand(XML_Parser parser,				 XML_DefaultHandler handler){  defaultHandler = handler;  defaultExpandInternalEntities = 1;}void XML_SetUnparsedEntityDeclHandler(XML_Parser parser,				      XML_UnparsedEntityDeclHandler handler){  unparsedEntityDeclHandler = handler;}void XML_SetNotationDeclHandler(XML_Parser parser,				XML_NotationDeclHandler handler){  notationDeclHandler = handler;}void XML_SetNamespaceDeclHandler(XML_Parser parser,				 XML_StartNamespaceDeclHandler start,				 XML_EndNamespaceDeclHandler end){  startNamespaceDeclHandler = start;  endNamespaceDeclHandler = end;}void XML_SetExternalEntityRefHandler(XML_Parser parser,				     XML_ExternalEntityRefHandler handler){  externalEntityRefHandler = handler;}void XML_SetExternalEntityRefHandlerArg(XML_Parser parser, void *arg){  if (arg)    externalEntityRefHandlerArg = arg;  else    externalEntityRefHandlerArg = parser;}void XML_SetUnknownEncodingHandler(XML_Parser parser,				   XML_UnknownEncodingHandler handler,				   void *data){  unknownEncodingHandler = handler;  unknownEncodingHandlerData = data;}int XML_Parse(XML_Parser parser, const char *s, int len, int isFinal){  if (len == 0) {    if (!isFinal)      return 1;    errorCode = processor(parser, bufferPtr, parseEndPtr = bufferEnd, 0);    if (errorCode == XML_ERROR_NONE)      return 1;    eventEndPtr = eventPtr;    return 0;  }  else if (bufferPtr == bufferEnd) {    const char *end;    int nLeftOver;    parseEndByteIndex += len;    positionPtr = s;    if (isFinal) {      errorCode = processor(parser, s, parseEndPtr = s + len, 0);      if (errorCode == XML_ERROR_NONE)	return 1;      eventEndPtr = eventPtr;      return 0;    }    errorCode = processor(parser, s, parseEndPtr = s + len, &end);    if (errorCode != XML_ERROR_NONE) {      eventEndPtr = eventPtr;      return 0;    }    XmlUpdatePosition(encoding, positionPtr, end, &position);    nLeftOver = s + len - end;    if (nLeftOver) {      if (buffer == 0 || nLeftOver > bufferLim - buffer) {	/* FIXME avoid integer overflow */	buffer = buffer == 0 ? malloc(len * 2) : realloc(buffer, len * 2);	if (!buffer) {	  errorCode = XML_ERROR_NO_MEMORY;	  eventPtr = eventEndPtr = 0;	  return 0;	}	bufferLim = buffer + len * 2;      }      memcpy(buffer, end, nLeftOver);      bufferPtr = buffer;      bufferEnd = buffer + nLeftOver;    }    return 1;  }  else {    memcpy(XML_GetBuffer(parser, len), s, len);    return XML_ParseBuffer(parser, len, isFinal);  }}int XML_ParseBuffer(XML_Parser parser, int len, int isFinal){  const char *start = bufferPtr;  positionPtr = start;  bufferEnd += len;  parseEndByteIndex += len;  errorCode = processor(parser, start, parseEndPtr = bufferEnd,			isFinal ? (const char **)0 : &bufferPtr);  if (errorCode == XML_ERROR_NONE) {    if (!isFinal)      XmlUpdatePosition(encoding, positionPtr, bufferPtr, &position);    return 1;  }  else {    eventEndPtr = eventPtr;    return 0;  }}void *XML_GetBuffer(XML_Parser parser, int len){  if (len > bufferLim - bufferEnd) {    /* FIXME avoid integer overflow */    int neededSize = len + (bufferEnd - bufferPtr);    if (neededSize  <= bufferLim - buffer) {      memmove(buffer, bufferPtr, bufferEnd - bufferPtr);      bufferEnd = buffer + (bufferEnd - bufferPtr);      bufferPtr = buffer;    }    else {      char *newBuf;      int bufferSize = bufferLim - bufferPtr;      if (bufferSize == 0)	bufferSize = INIT_BUFFER_SIZE;      do {	bufferSize *= 2;      } while (bufferSize < neededSize);      newBuf = malloc(bufferSize);      if (newBuf == 0) {	errorCode = XML_ERROR_NO_MEMORY;	return 0;      }      bufferLim = newBuf + bufferSize;      if (bufferPtr) {	memcpy(newBuf, bufferPtr, bufferEnd - bufferPtr);	free(buffer);      }      bufferEnd = newBuf + (bufferEnd - bufferPtr);      bufferPtr = buffer = newBuf;    }  }  return bufferEnd;}enum XML_Error XML_GetErrorCode(XML_Parser parser){  return errorCode;}long XML_GetCurrentByteIndex(XML_Parser parser){  if (eventPtr)    return parseEndByteIndex - (parseEndPtr - eventPtr);  return -1;}int XML_GetCurrentLineNumber(XML_Parser parser){  if (eventPtr) {    XmlUpdatePosition(encoding, positionPtr, eventPtr, &position);    positionPtr = eventPtr;  }  return position.lineNumber + 1;}int XML_GetCurrentColumnNumber(XML_Parser parser){  if (eventPtr) {    XmlUpdatePosition(encoding, positionPtr, eventPtr, &position);    positionPtr = eventPtr;  }  return position.columnNumber;}void XML_DefaultCurrent(XML_Parser parser){  if (defaultHandler) {    if (openInternalEntities)      reportDefault(parser,	            ns ? XmlGetInternalEncodingNS() : XmlGetInternalEncoding(),		    openInternalEntities->internalEventPtr,		    openInternalEntities->internalEventEndPtr);    else      reportDefault(parser, encoding, eventPtr, eventEndPtr);  }}const XML_LChar *XML_ErrorString(int code){  static const XML_LChar *message[] = {    0,    XML_T("out of memory"),    XML_T("syntax error"),    XML_T("no element found"),    XML_T("not well-formed"),    XML_T("unclosed token"),    XML_T("unclosed token"),    XML_T("mismatched tag"),    XML_T("duplicate attribute"),    XML_T("junk after document element"),    XML_T("illegal parameter entity reference"),    XML_T("undefined entity"),    XML_T("recursive entity reference"),    XML_T("asynchronous entity"),    XML_T("reference to invalid character number"),    XML_T("reference to binary entity"),    XML_T("reference to external entity in attribute"),    XML_T("xml processing instruction not at start of external entity"),    XML_T("unknown encoding"),    XML_T("encoding specified in XML declaration is incorrect"),    XML_T("unclosed CDATA section"),    XML_T("error in processing external entity reference")  };  if (code > 0 && code < sizeof(message)/sizeof(message[0]))    return message[code];  return 0;}staticenum XML_Error contentProcessor(XML_Parser parser,				const char *start,				const char *end,				const char **endPtr){  return doContent(parser, 0, encoding, start, end, endPtr);}staticenum XML_Error externalEntityInitProcessor(XML_Parser parser,					   const char *start,					   const char *end,					   const char **endPtr){  enum XML_Error result = initializeEncoding(parser);  if (result != XML_ERROR_NONE)    return result;  processor = externalEntityInitProcessor2;  return externalEntityInitProcessor2(parser, start, end, endPtr);}staticenum XML_Error externalEntityInitProcessor2(XML_Parser parser,					    const char *start,					    const char *end,					    const char **endPtr){  const char *next;  int tok = XmlContentTok(encoding, start, end, &next);  switch (tok) {  case XML_TOK_BOM:    start = next;    break;  case XML_TOK_PARTIAL:    if (endPtr) {      *endPtr = start;      return XML_ERROR_NONE;    }    eventPtr = start;    return XML_ERROR_UNCLOSED_TOKEN;  case XML_TOK_PARTIAL_CHAR:    if (endPtr) {      *endPtr = start;      return XML_ERROR_NONE;    }    eventPtr = start;    return XML_ERROR_PARTIAL_CHAR;  }  processor = externalEntityInitProcessor3;  return externalEntityInitProcessor3(parser, start, end, endPtr);}