/************************************************************************
* 函数名: my_xml_parse
* 作  者: sx
* 描  述: 1.封装了expat的解析函数,供xml2struct内部调用
*         2.内部函数
* 输入参数: PARSER_FUN_PARAM *pf,数据集合
*           char *xml_string,顾名思义
* 输出参数: 无
* 返回值: 0表示成功,>0表示错误编号
************************************************************************/
int my_xml_parse(PARSER_FUN_PARAM *pf, char *xml_string, int xml_len)
{
    XML_Parser p;

    p = XML_ParserCreate( NULL );
    if (!p)
    {
        logger(TLOG_ERROR,  "XML_ParserCreate failed!\n" );
        return -1;
    }

//	logger(TLOG_NOTICE,  "XML_ParserCreate success!\n" );

    /* 向句柄上设定准备开始和结束签条 */
    XML_SetElementHandler( p, start_xml, end_xml );

    /* 设置元素内文本的处理函数 */
    XML_SetCharacterDataHandler( p, chardatahandle );

    /* 一次性解析完 */
    //xml_len = strlen( xml_string );

    /* 设置一个共享的数据结构给各各处理函数使用 */
    XML_SetUserData( p, pf );

    /* 把GBK,GB2312等不识别的编码，过滤掉，因为目前仅认为传过来的是英文 */
    XML_SetUnknownEncodingHandler( p, XMLEncodingHandle, 0 );
    if (XML_Parse( p, xml_string, xml_len, 1 ) == XML_STATUS_ERROR)
    {
#if 1
        logger(TLOG_ERROR, "Parse error at line %" XML_FMT_INT_MOD "u:\n%s\n",
            XML_GetCurrentLineNumber( p ),
            XML_ErrorString(XML_GetErrorCode( p ) ) );
        /* 释放被解析器使用的内存。*/
#endif
        XML_ParserFree( p );
		logger(TLOG_ERROR,  "XML_Parse failed!\n" );
        return -1;
    }
    /* 释放被解析器使用的内存。*/
    XML_ParserFree( p );
    return pf->ret_err;
}

static void PullAllNewsItems(urlconnection *urlconn, rssFeedData *dataPtr)
{
  streamtokenizer st;
  char buffer[2048];

  XML_Parser rssFeedParser = XML_ParserCreate(NULL);
  XML_SetUserData(rssFeedParser, dataPtr);
  XML_SetElementHandler(rssFeedParser, ProcessStartTag, ProcessEndTag);
  XML_SetCharacterDataHandler(rssFeedParser, ProcessTextData);

  STNew(&st, urlconn->dataStream, "\n", false);
  while (STNextToken(&st, buffer, sizeof(buffer))) {
    XML_Parse(rssFeedParser, buffer, strlen(buffer), false);
  }
  STDispose(&st);
  
  XML_Parse(rssFeedParser, "", 0, true);
  XML_ParserFree(rssFeedParser);  
}

APR_DECLARE(apr_xml_parser *) apr_xml_parser_create_ex(apr_pool_t *pool,
    void *start_func, void *end_func, void *cdata_func)
{
    apr_xml_parser *parser = apr_pcalloc(pool, sizeof(*parser));

    parser->impl = apr_xml_get_parser_impl();

    parser->p = pool;
    parser->doc = apr_pcalloc(pool, sizeof(*parser->doc));

    parser->doc->namespaces = apr_array_make(pool, 5, sizeof(const char *));

    /* ### is there a way to avoid hard-coding this? */
    apr_xml_insert_uri(parser->doc->namespaces, APR_KW_DAV);

    parser->xp = XML_ParserCreate(NULL);
    if (parser->xp == NULL) {
        (*apr_pool_abort_get(pool))(APR_ENOMEM);
        return NULL;
    }

    apr_pool_cleanup_register(pool, parser, cleanup_parser,
                              apr_pool_cleanup_null);

    XML_SetUserData(parser->xp, parser);
    XML_SetElementHandler(parser->xp, start_func, end_func);
    XML_SetCharacterDataHandler(parser->xp, cdata_func);

    /* Prevent the "billion laughs" attack against expat by disabling
     * internal entity expansion.  With 2.x, forcibly stop the parser
     * if an entity is declared - this is safer and a more obvious
     * failure mode.  With older versions, installing a noop
     * DefaultHandler means that internal entities will be expanded as
     * the empty string, which is also sufficient to prevent the
     * attack. */
#if XML_MAJOR_VERSION > 1
    XML_SetEntityDeclHandler(parser->xp, entity_declaration);
#else
    XML_SetDefaultHandler(parser->xp, default_handler);
#endif

    return parser;
}

void ParserEngine::init()
{
	if (_parser)
		XML_ParserFree(_parser);

	if (!_pBuffer)
		_pBuffer  = new char[PARSE_BUFFER_SIZE];

	if (dynamic_cast<NoNamespacePrefixesStrategy*>(_pNamespaceStrategy))
	{
		_parser = XML_ParserCreateNS(_encodingSpecified ? _encoding.c_str() : 0, '\t');
		XML_SetNamespaceDeclHandler(_parser, handleStartNamespaceDecl, handleEndNamespaceDecl);
	}
	else if (dynamic_cast<NamespacePrefixesStrategy*>(_pNamespaceStrategy))
	{
		_parser = XML_ParserCreateNS(_encodingSpecified ? _encoding.c_str() : 0, '\t');
		XML_SetReturnNSTriplet(_parser, 1);
		XML_SetNamespaceDeclHandler(_parser, handleStartNamespaceDecl, handleEndNamespaceDecl);
	}
	else
	{
		_parser = XML_ParserCreate(_encodingSpecified ? _encoding.c_str() : 0);
	}

	XML_SetUserData(_parser, this);
	XML_SetElementHandler(_parser, handleStartElement, handleEndElement);
	XML_SetCharacterDataHandler(_parser, handleCharacterData);
	XML_SetProcessingInstructionHandler(_parser, handleProcessingInstruction);
	if (_expandInternalEntities)
		XML_SetDefaultHandlerExpand(_parser, handleDefault);
	else
		XML_SetDefaultHandler(_parser, handleDefault);
	XML_SetUnparsedEntityDeclHandler(_parser, handleUnparsedEntityDecl);
	XML_SetNotationDeclHandler(_parser, handleNotationDecl);
	XML_SetExternalEntityRefHandler(_parser, handleExternalEntityRef);
	XML_SetCommentHandler(_parser, handleComment);
	XML_SetCdataSectionHandler(_parser, handleStartCdataSection, handleEndCdataSection);
	XML_SetDoctypeDeclHandler(_parser, handleStartDoctypeDecl, handleEndDoctypeDecl);
	XML_SetEntityDeclHandler(_parser, handleEntityDecl);
	XML_SetSkippedEntityHandler(_parser, handleSkippedEntity);
	XML_SetParamEntityParsing(_parser, _externalParameterEntities ? XML_PARAM_ENTITY_PARSING_ALWAYS : XML_PARAM_ENTITY_PARSING_NEVER);
	XML_SetUnknownEncodingHandler(_parser, handleUnknownEncoding, this);
}

//////////////////////////////////////////////////////////////////////////////////
/// Parse the fmu. The receiver must call freeElement(md) to release AST memory.
///
///\param xmlPath The xml file to be parsed
///\return the root node md of the AST if no error occurred. NULL to indicate failure
/////////////////////////////////////////////////////////////////////////////////
ModelDescription* parse(const char* xmlPath) {
  ModelDescription* md = NULL;
  FILE *file;
  int done = 0;

  stack = stackNew(100, 10); // Allocate stack memory	  
  if (checkPointer(stack)) return NULL;  // Check if the stack is creatted

  parser = XML_ParserCreate(NULL); // Create an parser
  if (checkPointer(parser)) return NULL;  // Check if the parser is created

  XML_SetElementHandler(parser, startElement, endElement); // Set handler for start and end tags
  XML_SetCharacterDataHandler(parser, handleData); // Set handler for text

	file = fopen(xmlPath, "rb");

	if (file == NULL) {
    printfError("Cannot open file '%s'\n", xmlPath);
    XML_ParserFree(parser); // Free the memory for parser
    return NULL; // Failure
  }

  while (!done) {
    int n = fread(text, sizeof(char), XMLBUFSIZE, file); // Read XMLBUFSIZE characters from file
    if (n != XMLBUFSIZE) done = 1; // Reach the end of file
    if (!XML_Parse(parser, text, n, done)){
      printf("Parse error in file %s at line %d:\n%s\n",
             xmlPath,
             (int)XML_GetCurrentLineNumber(parser),
              XML_ErrorString(XML_GetErrorCode(parser)));
      while (!stackIsEmpty(stack)) md = stackPop(stack);
      if (md) freeElement(md);
      cleanup(file);
      return NULL; // failure
    }
  }

  md = stackPop(stack);
  assert(stackIsEmpty(stack));
  cleanup(file);
  //printElement(1, md); // Print the element for debugging
  return md; // Success if all refs are valid    
}

void document_imp::parse(
	istream&		data)
{
	XML_Parser p = XML_ParserCreateNS(NULL, '=');
	
	if (p == NULL)
		THROW_EXCEPTION(("failed to create expat parser object"));
	
	try
	{
		XML_SetUserData(p, this);
		XML_SetElementHandler(p, XML_StartElementHandler, XML_EndElementHandler);
		XML_SetCharacterDataHandler(p, XML_CharacterDataHandler);
//		XML_SetProcessingInstructionHandler(p, XML_ProcessingInstructionHandler);
//		XML_SetCommentHandler(p, XML_CommentHandler);
//		XML_SetCdataSectionHandler(p, XML_StartCdataSectionHandler, XML_EndCdataSectionHandler);
//		XML_SetDefaultHandler(p, XML_DefaultHandler);
//		XML_SetDoctypeDeclHandler(p, XML_StartDoctypeDeclHandler, XML_EndDoctypeDeclHandler);
//		XML_SetUnparsedEntityDeclHandler(p, XML_UnparsedEntityDeclHandler);
//		XML_SetNotationDeclHandler(p, XML_NotationDeclHandler);
		XML_SetNamespaceDeclHandler(p, XML_StartNamespaceDeclHandler, XML_EndNamespaceDeclHandler);
		XML_SetReturnNSTriplet(p, true);
		
		while (not data.eof())
		{
			string line;
			getline(data, line);
			line += '\n';

			XML_Status err = XML_Parse(p, line.c_str(), line.length(), data.eof() or line.empty());
			if (err != XML_STATUS_OK)
				THROW_EXCEPTION((p));
		}
	}
	catch (std::exception& e)
	{
		XML_ParserFree(p);
		throw;
	}

	XML_ParserFree(p);
}

static void
controlanswer_stop_callback(
		void *data, 
		const char *el)
{
	struct controlanswer_parsercontext *context = 
		(struct controlanswer_parsercontext *)data;

	(void)el;
	
	switch(context->state) {
	case START:
		context->state = MALFORMED;
		break;
	case END:
		break;
	case CONTROLANSWER:
		context->state = END;
		break;
	case CONTROLANSWER_VARIABLE:
	case CONTROLANSWER_OTHER:
		context->state = CONTROLANSWER;
		break;
	case CONTROLANSWER_VARIABLE_VALUE:
		XML_SetCharacterDataHandler(
				context->parser,
				NULL);
	case CONTROLANSWER_VARIABLE_OTHER:
		context->state = CONTROLANSWER_VARIABLE;
		break;
	default:
		context->state = MALFORMED;
		break;
	}

	if (context->state == MALFORMED) {
		XML_SetElementHandler(
				context->parser,
				NULL,
				NULL);
	}
}

BOOL
loadconfig (config_t * currentconfig, const char *filename)
{
	FILE *fp;
	char *contents;
	unsigned int len;

	config_init_config (currentconfig);
	if (filename)
		fp = fopen (filename, "r");
	else
		fp = fopen (sysconfdir "/antinat.xml", "r");
	if (!fp)
		return FALSE;

	fseek (fp, 0, SEEK_END);
	len = ftell (fp);
	fseek (fp, 0, SEEK_SET);
	contents = (char *) malloc (len);
	if (contents == NULL) {
		fclose (fp);
		return FALSE;
	}
	if (fread (contents, 1, len, fp) == 0) {
		free (contents);
		fclose (fp);
		return FALSE;
	}
	fclose (fp);

	p = XML_ParserCreate (NULL);

	XML_SetElementHandler (p, config_xml_start, config_xml_end);
	XML_SetUserData (p, currentconfig);

	XML_Parse (p, contents, len, 1);
	XML_ParserFree (p);

	free (contents);

	return TRUE;
}

static void
propclose(void *dat, const XML_Char *s)
{
	struct parse	*p = dat;
	enum calelem	 elem;

	switch ((elem = calelem_find(s))) {
	case (CALELEM__MAX):
		break;
	case (CALELEM_PROP):
		XML_SetElementHandler(p->xp, parseopen, parseclose);
		break;
	default:
		if (PROP__MAX == calprops[elem])
			break;
		propadd(p, s, calprops[elem], p->buf.buf);
		XML_SetDefaultHandler(p->xp, NULL);
		break;
	}
}

int feed_init(struct feed **feedp, struct evbuffer *sink)
{
	struct feed *feed;

	if ((feed = malloc(sizeof(*feed))) == NULL) {
		return ENOMEM;
	}
	memset(feed, 0, sizeof(*feed));

	feed->parser = XML_ParserCreate(NULL);
	XML_SetUserData(feed->parser, feed);
	XML_SetElementHandler(feed->parser, element_start, element_end);
	XML_SetCharacterDataHandler(feed->parser, cdata);

	feed->sink = sink;

	*feedp = feed;
	return 0;

}

const char* hxcfe_getXmlLayoutName(XmlFloppyBuilder* context,int moduleID)
{
	AppData	*ad = (AppData *) context->ad;

	if(hxcfe_numberOfXmlLayout(context) > moduleID)
	{
		ad->xmlcheck = 1;
		XML_ParserReset(context->xml_parser, NULL);
		XML_SetUserData(context->xml_parser, (void *) ad);
		XML_SetElementHandler(context->xml_parser, start, end);
		XML_SetCharacterDataHandler(context->xml_parser, charhandler);
		XML_SetNamespaceDeclHandler(context->xml_parser, ns_start, ns_end);

		XML_Parse(context->xml_parser, disklayout_list[moduleID]->unpacked_data, disklayout_list[moduleID]->size, 1);

		return (const char*)ad->name;
	}

	return NULL;
}

/// do actual parse, firing events a& returning true if all went well
/// need to create expat parser each time we dparse as its a one shot device
bool ParserImpl :: Parse( const string & s ) {

    if ( mExpat ) {
        XML_ParserFree( mExpat );
    }

    mExpat = XML_ParserCreate( 0 );
    XML_SetElementHandler( mExpat, StartElementHandler, EndElementHandler );
    XML_SetCharacterDataHandler( mExpat, CharDataHandler );
    XML_SetUserData( mExpat, this );

    unsigned int err = XML_Parse(  mExpat, s.c_str(), s.size(), 1 );
    if ( err == 0 ) {
        mErrorCode = XML_GetErrorCode( mExpat );
        mErrorMsg  = XML_ErrorString( XML_Error( err ) );
        mErrorLine = XML_GetCurrentLineNumber( mExpat );
    }

    return err != 0;
}

static void PullAllNewsItems(rssDatabase *db, urlconnection *urlconn)
{
  rssFeedState state = {db}; // passed through the parser by address as auxiliary data.
  streamtokenizer st;
  char buffer[2048];

  XML_Parser rssFeedParser = XML_ParserCreate(NULL);
  XML_SetUserData(rssFeedParser, &state);
  XML_SetElementHandler(rssFeedParser, ProcessStartTag, ProcessEndTag);
  XML_SetCharacterDataHandler(rssFeedParser, ProcessTextData);

  STNew(&st, urlconn->dataStream, "\n", false);
  while (STNextToken(&st, buffer, sizeof(buffer))) {
    XML_Parse(rssFeedParser, buffer, strlen(buffer), false);
  }
  STDispose(&st);
  
  XML_Parse(rssFeedParser, "", 0, true); // instructs the xml parser that we're done parsing..
  XML_ParserFree(rssFeedParser);  
}

/* shuts down and restarts XML parser.  true on success */
int parser_reset(parser_t *parser)
{
    if (parser->expat)
	XML_ParserFree(parser->expat);

    if (parser->stanza) 
	xmpp_stanza_release(parser->stanza);

    parser->expat = XML_ParserCreateNS(NULL, NAMESPACE_SEP);
    if (!parser->expat) return 0;

    parser->depth = 0;
    parser->stanza = NULL;

    XML_SetUserData(parser->expat, parser);
    XML_SetElementHandler(parser->expat, _start_element, _end_element);
    XML_SetCharacterDataHandler(parser->expat, _characters);

    return 1;
}

plist_item *plist_item_from_file(char *fileName) {
	FILE *f;
	int isFinal;
	user_data u;
	u.s = (char *)malloc(1);
	u.s[0] = 0;
	u.key = (char *)malloc(1);
	u.key[0] = 0;
	XML_Parser xml = XML_ParserCreate(NULL);
	u.xml = xml;
	XML_SetUserData(xml,&u);
	XML_SetElementHandler(xml,startElement,endElement);
	XML_SetCharacterDataHandler(xml,charHandler);
	f = fopen(fileName,"r");
	if (f) {
		char buffer[BUF_SIZE];
		int firstRun=1;
		do {
			int bytesRead = fread(buffer,1,BUF_SIZE,f);
			if(firstRun==1 && bytesRead==0) {
				XML_ParserFree(xml);
				free(u.root);
				return NULL;
			}
			else firstRun=0;
			isFinal = !(bytesRead==BUF_SIZE);
			XML_Parse(xml,buffer,bytesRead,isFinal);
		} while (!isFinal);
		fclose(f);
	}
	else {
		fprintf(stderr,"plist_item_from_file(): Couldn't open file %s\n",fileName);
		XML_ParserFree(xml);
		free(u.root);
		return NULL;
	}
	XML_ParserFree(xml);
	free(u.key);
	free(u.s);
	return u.root;
}

static int lxp_make_parser (lua_State *L) {
  XML_Parser p;
  char sep = *luaL_optstring(L, 2, "");
  lxp_userdata *xpu = createlxp(L);
  p = xpu->parser = (sep == '\0') ? XML_ParserCreate(NULL) :
                                    XML_ParserCreateNS(NULL, sep);
  if (!p)
    luaL_error(L, "XML_ParserCreate failed");
  luaL_checktype(L, 1, LUA_TTABLE);
  checkcallbacks(L);
  lua_pushvalue(L, 1);
  xpu->tableref = luaL_ref(L, LUA_REGISTRYINDEX);
  XML_SetUserData(p, xpu);
  if (hasfield(L, StartCdataKey) || hasfield(L, EndCdataKey))
    XML_SetCdataSectionHandler(p, f_StartCdata, f_EndCdataKey);
  if (hasfield(L, CharDataKey))
    XML_SetCharacterDataHandler(p, f_CharData);
  if (hasfield(L, CommentKey))
    XML_SetCommentHandler(p, f_Comment);
  if (hasfield(L, DefaultKey))
    XML_SetDefaultHandler(p, f_Default);
  if (hasfield(L, DefaultExpandKey))
    XML_SetDefaultHandlerExpand(p, f_DefaultExpand);
  if (hasfield(L, StartElementKey) || hasfield(L, EndElementKey))
    XML_SetElementHandler(p, f_StartElement, f_EndElement);
  if (hasfield(L, ExternalEntityKey))
    XML_SetExternalEntityRefHandler(p, f_ExternaEntity);
  if (hasfield(L, StartNamespaceDeclKey) || hasfield(L, EndNamespaceDeclKey))
    XML_SetNamespaceDeclHandler(p, f_StartNamespaceDecl, f_EndNamespaceDecl);
  if (hasfield(L, NotationDeclKey))
    XML_SetNotationDeclHandler(p, f_NotationDecl);
  if (hasfield(L, NotStandaloneKey))
    XML_SetNotStandaloneHandler(p, f_NotStandalone);
  if (hasfield(L, ProcessingInstructionKey))
    XML_SetProcessingInstructionHandler(p, f_ProcessingInstruction);
  if (hasfield(L, UnparsedEntityDeclKey))
    XML_SetUnparsedEntityDeclHandler(p, f_UnparsedEntityDecl);
  if (hasfield(L, StartDoctypeDeclKey))
    XML_SetStartDoctypeDeclHandler(p, f_StartDoctypeDecl);
  return 1;
}

framer_t *
framer_create()
{
	framer_t *framer = (framer_t*) malloc(sizeof(*framer));
	
	if (framer == NULL)
		goto Error;
	memset(framer, 0, sizeof(*framer));
	framer->parser = XML_ParserCreateNS(NULL, /* ':' */ '\xFF');
	if (framer->parser == NULL)
		goto Error;
	XML_SetElementHandler(
		framer->parser,
		framer_start,
		framer_end);
	XML_SetUserData(
		framer->parser,
		framer);
	framer->level = 0;
	framer->error = 0;
	framer->index = 0;
	framer->buffer_index = 0;
	framer->head = framer->tail = NULL;
	
	/* TODO: create buffers with limited maximum length */
	framer->buffer = buffer_create(0);
	if (framer->buffer == NULL)
		goto Error;

	return framer;

Error:
	if (framer != NULL)
	{
		if (framer->buffer != NULL)
			buffer_delete(framer->buffer);
		if (framer->parser != NULL)
			XML_ParserFree(framer->parser);
	}
	return NULL;
}

int Encode (CFileReader &p_coFileReader)
{
	int iRetVal = 0;
	XML_Parser psoParser;

	psoParser = XML_ParserCreate ("UTF-8");
	if (NULL == psoParser) {
		iRetVal = ENOMEM;
		return iRetVal;
	}

	SDoc soDoc;

	/* регистрация обработчика данных */
	XML_SetElementHandler (psoParser, StartElementHandler, EndElementHandler);
	XML_SetXmlDeclHandler (psoParser, XmlDeclHandler);
	XML_SetDoctypeDeclHandler (psoParser, StartDoctypeDeclHandler, EndDoctypeDeclHandler);
	XML_SetUserData (psoParser, &soDoc);

	/* парсинг данных */
	char mcBuf[256];
	int iDataLen;
	int iIsFinal = 0;
	do {
		iDataLen = sizeof (mcBuf);
		if (p_coFileReader.ReadData ((unsigned char*)mcBuf, iDataLen))
			iIsFinal = 1;
		XML_Parse (psoParser, mcBuf, iDataLen, iIsFinal);
		if (iIsFinal)
			break;
	} while (1);

	Tokenize (soDoc);

	if (psoParser) {
		XML_ParserFree (psoParser);
		psoParser = NULL;
	}

	return iRetVal;
}

bool Graph::graphload(FILE * fptr)
{
  const int BUFFSIZE = 2000;
  char buffer[BUFFSIZE];
  int done;
  int len;
  bool result;

  XML_Parser p = XML_ParserCreate(NULL);
  if (! p)
  {
    fprintf(stderr, "Couldn't allocate memory for parser\n");
    return false;
  }
  XML_SetUserData(p, this);
  XML_SetElementHandler(p, Graph::startGraphTag, Graph::endGraphTag);

  do
  {
    len = fread(buffer, 1, BUFFSIZE, fptr);
    printf("Read length = %d\n", len);

    if (ferror(fptr))
    {
      fprintf(stderr, "Read error\n");
      return false;
    }
    done = feof(fptr);

    if (! XML_Parse(p, buffer, len, done))
    {
      fprintf(stderr, "Parse error at line %d:\n%s\n", (int) XML_GetCurrentLineNumber(p), XML_ErrorString(XML_GetErrorCode(p)));
      fclose(fptr);
      return false;
    }
  } while(!done);

  XML_ParserFree(p);
  result = rootNode.connectEdges();
  return result;
}

void LLSDXMLParser::Impl::reset()
{
	mResult.clear();
	mParseCount = 0;

	mInLLSDElement = false;
	mDepth = 0;

	mGracefullStop = false;

	mStack.clear();
	
	mSkipping = false;
	
	mCurrentKey.clear();
	
	XML_ParserReset(mParser, "utf-8");
	XML_SetUserData(mParser, this);
	XML_SetElementHandler(mParser, sStartElementHandler, sEndElementHandler);
	XML_SetCharacterDataHandler(mParser, sCharacterDataHandler);
}