Esempio n. 1
0
/************************************************************************
* 函数名: 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;
}
Esempio n. 2
0
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);  
}
Esempio n. 3
0
int main(int argc, char **argv) {
    AppData *ad;
    XML_Parser p = XML_ParserCreateNS(NULL, '|');
    if (! p) {
        fprintf(stderr, "Couldn't allocate memory for parser\n");
        exit(-1);
    }

    ad = newAppData();

    XML_SetUserData(p, (void *) ad);
    XML_SetElementHandler(p, start, end);
    XML_SetNamespaceDeclHandler(p, ns_start, ns_end);

    for (;;) {
        char *buff;
        int len;

        buff = XML_GetBuffer(p, CHUNK_SIZE);
        if (! buff) {
            fprintf(stderr, "Ran out of memory for parse buffer\n");
            exit(-1);
        }

        len = read(0, buff, CHUNK_SIZE);
        if (len < 0) {
            perror("namespace - read error");
            exit(-1);
        }

        if (! XML_ParseBuffer(p, len, len == 0)) {
            fprintf(stderr, "Parse error at line %lu:\n%s\n",
                    XML_GetCurrentLineNumber(p),
                    XML_ErrorString(XML_GetErrorCode(p)));
            exit(-1);
        }

        if (len == 0)
            break;
    }

    return 0;
}  /* End main */
Esempio n. 4
0
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;
}
Esempio n. 5
0
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);
}
Esempio n. 6
0
//////////////////////////////////////////////////////////////////////////////////
/// 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    
}
Esempio n. 7
0
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);
}
Esempio n. 8
0
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);
	}
}
Esempio n. 9
0
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;
}
Esempio n. 10
0
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;
	}
}
Esempio n. 11
0
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;

}
Esempio n. 12
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;
}
Esempio n. 13
0
/// 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;
}
Esempio n. 14
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);  
}
Esempio n. 15
0
/* 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;
}
Esempio n. 16
0
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;
}
Esempio n. 17
0
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;
}
Esempio n. 18
0
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;
}
Esempio n. 19
0
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;
}
Esempio n. 20
0
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);
}
Esempio n. 22
0
FLOPPY* hxcfe_generateXmlFloppy (XmlFloppyBuilder* context,unsigned char * rambuffer,unsigned buffersize)
{
	AppData *ad;

	ad = context->ad;

	ad->xmlcheck = 0;
	
	ad->image_data = rambuffer;
	ad->buffer_size = buffersize;

	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[ad->layout_id]->unpacked_data, disklayout_list[ad->layout_id]->size, 1);

	return ad->floppy;
}
bool SkXMLPullParser::onInit()
{
    fImpl = new Impl;

    XML_Parser p = XML_ParserCreate(NULL);
    SkASSERT(p);

    fImpl->fData.fParser = p;
    fImpl->fData.fCurr = &fCurr;

    XML_SetElementHandler(p, start_proc, end_proc);
    XML_SetCharacterDataHandler(p, text_proc);
    XML_SetUserData(p, &fImpl->fData);

    size_t len = fStream->read(NULL, 0);
    fImpl->fBufferLen = len;
    fImpl->fBuffer = sk_malloc_throw(len);
    fStream->rewind();
    size_t  len2 = fStream->read(fImpl->fBuffer, len);
    return len2 == len;
}
Esempio n. 24
0
CDOMDocument::CDOMDocument()
{
	this->onKeyword = NULL;
	this->currentNode = this->documentElement = NULL;

	this->path  = NULL;
	this->upath = NULL;
	this->path_msize  = 0;
	this->upath_msize = 0;
	this->onStart = NULL;
	this->onEnd = NULL;
	this->onKeyword = NULL;

	if(	(this->parser = XML_ParserCreate(NULL)) )
	{
		XML_SetUserData(this->parser, this);
		XML_SetElementHandler(this->parser, this->start, this->end );
		XML_SetCharacterDataHandler(this->parser, this->charHandler);
		XML_SetCdataSectionHandler(this->parser, this->startCdata, this->endCdata);
	}
}
Esempio n. 25
0
Component::Component(const char *hostname, const char *port, const char *component_name, const char *password, bool silent): ExpatWrapper(), socket(), stack() {
	this->hostname = strdup(hostname);
	this->port = strdup(port);
	this->component_name = strdup(component_name);
	this->password = strdup(password);
	
	parser = XML_ParserCreate((XML_Char *) "UTF-8");
	XML_SetUserData(parser, (void*) this);
	XML_SetElementHandler(parser, startElementCallback, endElementCallback);
	XML_SetCharacterDataHandler(parser, characterDataCallback);
	
	depth = 0;
	presence_handler = 0;
	message_handler = 0;
	iq_query_handler = 0;
	auth_success_handler = 0;
	stream_error_handler = 0;
	exit_code = 0;
	
	this->silent = silent;
}
Esempio n. 26
0
static void validate(int start,int fd) {
  void *buf; int len;
  previous=current=start;

  expat=XML_ParserCreateNS(NULL,':');
  XML_SetElementHandler(expat,&start_element,&end_element);
  XML_SetCharacterDataHandler(expat,&characters);
  ok=1; any=0;
  for(;;) {
    buf=XML_GetBuffer(expat,BUFSIZE);
    len=read(fd,buf,BUFSIZE);
    if(len<0) {
      (*er_printf)("error (%s): %s\n",xml,strerror(errno));
      wf=ok=0; break;
    }
    if(!XML_ParseBuffer(expat,len,len==0)) wf=ok=0;
    if(!ok||any||len==0) break;
  }
  XML_ParserFree(expat);
  return;
}
Esempio n. 27
0
static void
add_code11_product(struct parsedata *pd, FILE *fp)
{
  char buf[BUFF_SIZE];
  int l;
  struct stat st;
  XML_Parser parser;

  if (!fstat(fileno(fp), &st))
    {
      pd->currentproduct = st.st_ino;
      pd->ctime = (unsigned int)st.st_ctime;
    }
  else
    {
      pd->currentproduct = pd->baseproduct + 1; /* make it != baseproduct if stat fails */
      pool_error(pd->pool, 0, "fstat: %s", strerror(errno));
      pd->ctime = 0;
    }

  parser = XML_ParserCreate(NULL);
  XML_SetUserData(parser, pd);
  XML_SetElementHandler(parser, startElement, endElement);
  XML_SetCharacterDataHandler(parser, characterData);

  for (;;)
    {
      l = fread(buf, 1, sizeof(buf), fp);
      if (XML_Parse(parser, buf, l, l == 0) == XML_STATUS_ERROR)
	{
	  pool_debug(pd->pool, SOLV_ERROR, "%s: %s at line %u:%u\n", pd->filename, XML_ErrorString(XML_GetErrorCode(parser)), (unsigned int)XML_GetCurrentLineNumber(parser), (unsigned int)XML_GetCurrentColumnNumber(parser));
	  pool_debug(pd->pool, SOLV_ERROR, "skipping this product\n");
	  XML_ParserFree(parser);
	  return;
	}
      if (l == 0)
	break;
    }
  XML_ParserFree(parser);
}
Esempio n. 28
0
/**
 * Parse an XML string into a nested list.
 * The second parameter indicates if body text (text within XML tags)
 * should show up among the children of the tag or in its own
 * section.
 *
 * See documentation (ext-xml.README) for examples.
 */
static package 
parse_xml(const char *data, int bool_stream)
  {
  /*
   * FIXME: Feed expat smaller chunks of the string and 
   * check for task timeout between chunks
   *
   */
  int decoded_length;
  const char *decoded;
  package result; 
  XML_Parser parser = XML_ParserCreate(NULL);
  XMLdata *root = new_node(NULL, "");
  XMLdata *child = root;
  
  decoded_length = strlen(data);
  decoded = data;
  XML_SetUserData(parser, &child);
  XML_SetElementHandler(parser, xml_startElement, xml_endElement);
  if(bool_stream) {
    XML_SetCharacterDataHandler(parser, xml_streamCharacterDataHandler);
  } else {
    XML_SetCharacterDataHandler(parser, xml_characterDataHandler);
  }
  if (!XML_Parse(parser, decoded, decoded_length, 1)) {
    Var r;
    r.type = TYPE_INT;
    r.v.num = XML_GetCurrentByteIndex(parser);
    flush_nodes(child);
    result = make_raise_pack(E_INVARG, 
			     XML_ErrorString(XML_GetErrorCode(parser)),
			     r);
  } else {
    finish_node(root);
    result = make_var_pack(var_ref(root->element.v.list[4].v.list[1]));
    free_node(root);
  }
  XML_ParserFree(parser);
  return result; 
}
Esempio n. 29
0
static int setup_parser(xml_parse_info *parse_info, xml_parse_options *opts)
{
	/* setup parse_info structure */
	memset(parse_info, 0, sizeof(*parse_info));
	if (opts)
	{
		parse_info->flags = opts->flags;
		if (opts->error)
		{
			opts->error->error_message = NULL;
			opts->error->error_line = 0;
			opts->error->error_column = 0;
		}
	}

	/* create a root node */
	parse_info->rootnode = xml_file_create();
	if (!parse_info->rootnode)
		return FALSE;
	parse_info->curnode = parse_info->rootnode;

	/* create the XML parser */
	parse_info->parser = XML_ParserCreate(NULL);
	if (!parse_info->parser)
	{
		free(parse_info->rootnode);
		return FALSE;
	}

	/* configure the parser */
	XML_SetElementHandler(parse_info->parser, xml_element_start, xml_element_end);
	XML_SetCharacterDataHandler(parse_info->parser, xml_data);
	XML_SetUserData(parse_info->parser, parse_info);

	/* optional parser initialization step */
	if (opts && opts->init_parser)
		opts->init_parser(parse_info->parser);
	return TRUE;
}
Esempio n. 30
0
int64_t f_xml_parse_into_struct(CObjRef parser, CStrRef data, VRefParam values,
                            VRefParam index /* = null */) {
  int ret;
  XmlParser * p = parser.getTyped<XmlParser>();
  values = Array::Create();
  p->data.assignRef(values);
  index = Array::Create();
  p->info.assignRef(index);
  p->level = 0;
  p->ltags = (char**)malloc(XML_MAXLEVEL * sizeof(char*));

  XML_SetDefaultHandler(p->parser, _xml_defaultHandler);
  XML_SetElementHandler(p->parser, _xml_startElementHandler,
                        _xml_endElementHandler);
  XML_SetCharacterDataHandler(p->parser, _xml_characterDataHandler);

  p->isparsing = 1;
  ret = XML_Parse(p->parser, (const XML_Char*)data.data(), data.size(), 1);
  p->isparsing = 0;

  return ret;
}