Exemplo n.º 1
0
int htmllex()
{
#ifdef HAVE_EXPAT
    static char *begin_html = "<HTML>";
    static char *end_html = "</HTML>";

    char *s;
    char *endp = 0;
    int len, llen;
    int rv;

    state.tok = 0;
    do {
	if (state.mode == 2)
	    return EOF;
	if (state.mode == 0) {
	    state.mode = 1;
	    s = begin_html;
	    len = strlen(s);
	    endp = 0;
	} else {
	    s = state.ptr;
	    if (*s == '\0') {
		state.mode = 2;
		s = end_html;
		len = strlen(s);
	    } else {
		endp = findNext(s,&state.lb);
		len = endp - s;
	    }
	}
	state.prevtok = state.currtok;
	state.prevtoklen = state.currtoklen;
	state.currtok = s;
	state.currtoklen = len;
	if ((llen = agxblen(&state.lb)))
	    rv = XML_Parse(state.parser, agxbuse(&state.lb),llen, 0);
	else
	    rv = XML_Parse(state.parser, s, len, (len ? 0 : 1));
	if (rv == XML_STATUS_ERROR) {
	    if (!state.error) {
		agerr(AGERR, "%s in line %d \n",
		      XML_ErrorString(XML_GetErrorCode(state.parser)),
		      htmllineno());
		error_context();
		state.error = 1;
		state.tok = T_error;
	    }
	}
	if (endp)
	    state.ptr = endp;
    } while (state.tok == 0);
#if DEBUG
    printTok (state.tok);
#endif
    return state.tok;
#else
    return EOF;
#endif
}
Exemplo n.º 2
0
Arquivo: snp.c Projeto: jfjlaros/snp
int main(int argc, char *argv[]) {
  XML_Parser p = XML_ParserCreate(NULL);
  int done = 0,
      len;

  if (!p) {
    fprintf(stderr, "Couldn't allocate memory for parser\n");
    exit(-1);
  }//if
  if (argv[1])
    FreqThreshold = atof(argv[1]) / 100;

  XML_SetElementHandler(p, start, end);

  while (!done) {
    len = fread(Buff, 1, BUFFSIZE, stdin);
    if (ferror(stdin)) {
      fprintf(stderr, "Read error\n");
      return -1;
    }//if
    done = feof(stdin);
    if (XML_Parse(p, Buff, len, done) == XML_STATUS_ERROR) {
      fprintf(stderr, "Parse error at line %d:\n%s\n",
              (int)XML_GetCurrentLineNumber(p),
              XML_ErrorString(XML_GetErrorCode(p)));
      return -1;
    }//if
  }//while

  return 0;
}//main
Exemplo n.º 3
0
rhcs_clustat *parse_rhcs_clustat(FILE *in) {
    char *buf;
    size_t len;
    int done = 0;
    XML_Parser parser;
    rhcs_clustat *clustat;

    nodes = 0;
    services = 0;

    clustat = mp_calloc(1, sizeof(rhcs_clustat));

    // Create Parser
    parser = XML_ParserCreate(NULL);
    XML_SetUserData(parser, clustat);
    XML_SetElementHandler(parser, rhcs_clustat_startElement, rhcs_clustat_stopElement);

    buf = mp_calloc(BUFFERSIZE, 1);

    do {
        len = fread(buf, 1, BUFFERSIZE, in);
        if (!XML_Parse(parser, buf, len, done)) {
            fprintf(stderr,
                    "%s at line %d\n",
                    XML_ErrorString(XML_GetErrorCode(parser)),
                    (int) XML_GetCurrentLineNumber(parser));
            return NULL;
        }
    } while (len == BUFFERSIZE && done == 0);
    XML_ParserFree(parser);

    return clustat;
}
Exemplo n.º 4
0
int build_sampl_pkts_from_xml (GW_SCRIPT_PKT_T * pkts, int max_pkts,
                               char *xml_buf, int size)
{
  char c;
  int i;
  XML_Parser p;

  pb_state = WAIT_STATE;
  pb_cnt = 0;
  pb_gw_pkt = pkts;
  pb_gw_pkt_max = max_pkts;
  //Creates an instance of the XML Parser to parse the event packet
  p = XML_ParserCreate (NULL);
  if (!p) {
    log_write ("Couldnt allocate memory for XML Parser\n");
    return -1;
  }
  //Sets the handlers to call when parsing the start and end of an XML element
  XML_SetElementHandler (p, startElement, endElement);
//  XML_SetCharacterDataHandler (p, charData);

  if (XML_Parse (p, xml_buf, size, 1) == XML_STATUS_ERROR) {
    sprintf (global_error_msg, "XML config file parse error at line %u: %s\n",
             XML_GetCurrentLineNumber (p),
             XML_ErrorString (XML_GetErrorCode (p)));
    log_write (global_error_msg);
    XML_ParserFree (p);
    return -1;
  }

  XML_ParserFree (p);


  return pb_cnt;
}
Exemplo n.º 5
0
int
main(int argc, char *argv[])
{
  char buf[BUFSIZ];
  XML_Parser parser = XML_ParserCreate(NULL);
  int done;
  int depth = 0;
  (void)argc;
  (void)argv;

  XML_SetUserData(parser, &depth);
  XML_SetElementHandler(parser, startElement, endElement);
  do {
    size_t len = fread(buf, 1, sizeof(buf), stdin);
    done = len < sizeof(buf);
    if (XML_Parse(parser, buf, len, done) == XML_STATUS_ERROR) {
      fprintf(stderr,
              "%s at line %" XML_FMT_INT_MOD "u\n",
              XML_ErrorString(XML_GetErrorCode(parser)),
              XML_GetCurrentLineNumber(parser));
      return 1;
    }
  } while (!done);
  XML_ParserFree(parser);
  return 0;
}
Exemplo n.º 6
0
/*
 * Function
 *	xmlReadFile
 *
 * Description
 *	Read a config file
 *
 * Parameters
 *	file	name of the config file
 *
 * Return
 *	root of the tree
 *	NULL	error.
 *
 * Remarks
 *	
 */
txmlElement *
xmlReadFile(const char *file)
{
    FILE		*in;
    char		buf[BUFSIZ];
    XML_Parser		parser;
    int			done;
    txmlElement		*retElt;
	
    if ((in = fopen(file, "r")) == NULL) {
        fprintf(stderr, "xmlReadFile: file %s has pb (access rights ?)\n", file);
	return (txmlElement*)NULL;
    }
    
    parser = XML_ParserCreate((XML_Char*)NULL);
    XML_SetUserData(parser, &retElt);
    XML_SetElementHandler(parser, startElement, endElement);
    XML_SetCharacterDataHandler(parser, CharacterData);
    do {
	size_t len = fread(buf, 1, sizeof(buf), in);
	done = len < sizeof(buf);
	if (!XML_Parse(parser, buf, len, done)) {
	    fprintf(stderr, "file: %s -> %s at line %d\n",
		   file,
		   XML_ErrorString(XML_GetErrorCode(parser)),
		   XML_GetCurrentLineNumber(parser));
	    return (txmlElement*)NULL;
	}
    } while (!done);
    XML_ParserFree(parser);

    return retElt;
}
Exemplo n.º 7
0
int main()
{	
	myParser parser;
	char filename[80];
	FILE* xmlFile;
	for (;;) {	  
		int depth = 0;
		
		puts("\n\nXML test: enter filename");
		gets(filename);
		if (strlen(filename)==0)
			break;
		
		xmlFile = fopen(filename, "r");
		if (!xmlFile)
			break;
		
		if (!parser.parseFile(xmlFile)) {
			fprintf(stderr,
				"%s at line %d\n",
				XML_ErrorString(parser.XML_GetErrorCode()),
				parser.XML_GetCurrentLineNumber()
			);
			return 1;
		}
	}  // loop asking for and parsing files
	puts("\nfinished!");
}
Exemplo n.º 8
0
int GameList::Load(const char *filename)
{
    char buf[1024];
    FILE *f;

    // Clear first
    Clear();

    // Parse XML
    f = fopen(filename, "rb");
    if( f == NULL ) {
        fprintf(stderr, "Unable to open XML file\n");
    }else{
        XML_Parser parser = XML_ParserCreate(NULL);
        int done;
        XML_SetUserData(parser, this);
        XML_SetElementHandler(parser, startElement, endElement);
        XML_SetCharacterDataHandler(parser, dataHandler);
        do {
            unsigned len = (int)fread(buf, 1, sizeof(buf), f);
            done = len < sizeof(buf);
            if (XML_Parse(parser, buf, len, done) == XML_STATUS_ERROR) {
              fprintf(stderr,
                      "%s at line %lu\n",
                      XML_ErrorString(XML_GetErrorCode(parser)),
                      XML_GetCurrentLineNumber(parser));
              break;
            }
        } while (!done);
        XML_ParserFree(parser);
        fclose(f);
    }
    return elements;
}
Exemplo n.º 9
0
struct cmd_result *parse_command(char * buf,struct cmd_result *(*treat_func)(),void *sdata) {

  //allocate the command structure to fill with data from xml
  struct cmd *toparse=malloc(sizeof(struct cmd));
  toparse->name=malloc(1024*sizeof(char));
  bzero(toparse->name,1024);
  toparse->nb_params=0;
  toparse->params=malloc(MAX_PARAMS*sizeof(char *));
  memset(toparse->params,0,MAX_PARAMS*sizeof(char*));
  struct cmd_result *result;
  
  XML_Parser parser = XML_ParserCreate(NULL);
  XML_SetUserData(parser,toparse);
  XML_SetElementHandler(parser,cmd_handler_start,cmd_handler_end);
  XML_SetCharacterDataHandler(parser,cmd_handler_data);

  if (!XML_Parse(parser,buf,strlen(buf),1)) {
    printf("error in command XML_Parse : error=%d\n",XML_GetErrorCode(parser));
    printf("%s\n",XML_ErrorString(XML_GetErrorCode(parser)));
    printf("buffer=%s\n",buf);
    result=malloc(sizeof(struct cmd_result));
    result->retcode=0;
    result->str=NULL;
  } else {
    result=treat_func(toparse,sdata);
  }
  free_cmd(toparse);
  XML_ParserFree(parser);
  if (result->str==NULL)
    result->str=strdup("Malformed command");
  return result;
}
Exemplo n.º 10
0
int xml_main(int argc, const char *argv)
{
  char *buf = NULL;
  int depth = 0;
  if (argv == NULL){
	 printf("no element parse\n");
	 return 1;
  }
  
  XML_Parser parser = XML_ParserCreate(NULL);
  if (parser){
	  XML_SetUserData(parser, &depth);
	  XML_SetElementHandler(parser, startElement, endElement);
	  buf = (char*)malloc(argc + 1);
	  bzero(buf, argc + 1);
	  memcpy(buf, argv, argc);
	  if (XML_Parse(parser, buf, argc, 0) == XML_STATUS_ERROR) {
	      printf( "%s at line %" XML_FMT_INT_MOD "u\n",
	              XML_ErrorString(XML_GetErrorCode(parser)),
	              XML_GetCurrentLineNumber(parser));
	  }else{
		  printf("XML_Parse Sucessful\n ");
	  }	  
  }

  XML_ParserFree(parser);
  return 0;
}
Exemplo n.º 11
0
bool HippoGridInfo::retrieveGridInfo()
{
	if (mLoginUri == "") return false;

	// If last character in uri is not "/"
	std::string uri = mLoginUri;
	if (uri.compare(uri.length()-1, 1, "/") != 0) 
	{
	 	uri += '/';
	}
	std::string reply;
	int result = HippoRestRequest::getBlocking(uri + "get_grid_info", &reply);
	if (result != 200) return false;

	llinfos << "Received: " << reply << llendl;

	bool success = true;
	XML_Parser parser = XML_ParserCreate(0);
	XML_SetUserData(parser, this);
	XML_SetElementHandler(parser, onXmlElementStart, onXmlElementEnd);
	XML_SetCharacterDataHandler(parser, onXmlCharacterData);
	mXmlState = XML_VOID;
	if (!XML_Parse(parser, reply.data(), reply.size(), TRUE)) {
		llwarns << "XML Parse Error: " << XML_ErrorString(XML_GetErrorCode(parser)) << llendl;
		success = false;
	}
	XML_ParserFree(parser);

	return success;
}
Exemplo n.º 12
0
void XML_Parser::raise(const char* format, ...)
{
    if (_rep->error)
        return;

    _rep->error = true;

    XML_Error code = XML_GetErrorCode(_rep->parser);
    int line = XML_GetCurrentLineNumber(_rep->parser);
    Buffer buffer;

    if (code)
        buffer.format("line %d: %s: ", line, XML_ErrorString(code));
    else
        buffer.format("line %d: error: ", line);

    va_list ap;
    va_start(ap, format);
    buffer.vformat(format, ap);
    va_end(ap);

    _rep->error_msg = buffer.data();

    XML_StopParser(_rep->parser, XML_FALSE);
}
Exemplo n.º 13
0
/* --------------------------------------------------------
 * this function "umount" a awareness protocol message and
 * returns a tree with the message information.
 * 
 * Parameters :
 *      AwString message : the awareness protocol message
 * Return :
 *      AwTree * : the tree with awareness protocol message
 *                      information.
 *                 (NULL if an allocation problem occurs)
 * Note :
 *      Even when a parser error occurs, a tree with the
 *      information already parsed is returned.
 * --------------------------------------------------------
 */
extern AwTree *AwParser_umountMessage (AwString message) 
{
   AwTree *tree = NULL;
   XML_Parser parser;
   char *input;

   tree = AwTree_new ();
   if (tree != NULL) 
    {
#ifdef DEBUG
       fprintf (stderr,"Creating XML parser for %s \n",(char *) message);
#endif       
       parser = XML_ParserCreate(NULL);
       XML_SetUserData(parser, tree);
       XML_SetElementHandler(parser, AwParser_startElement, AwParser_endElement);
       XML_SetCharacterDataHandler(parser,AwParser_textElement);

       input = AwString_get (message);
       /*do {*/
           if (!XML_Parse(parser, input, strlen(input), 0 )) 
            {
               fprintf(stderr, "%s at line %d\n", \
                              XML_ErrorString(XML_GetErrorCode(parser)), \
                              XML_GetCurrentLineNumber(parser));
            }
       /*while ();*/

#ifdef DEBUG
       fprintf (stderr,"Message parsed\n");
#endif       
       XML_ParserFree(parser);
       AW_FREE(input);
    }   
   return tree;
}
Exemplo n.º 14
0
bool Xml::Parse(const wxFileName& filename)
{
    Xml::filename = filename;
    XML_Parser parser = XML_ParserCreate(0);
    XML_SetElementHandler(parser, processStartTag, processEndTag);
    XML_SetCharacterDataHandler(parser, processData);

    FILE* xml = fopen(filename.GetFullPath(), "r");
    if (!xml)
        return false;

    char buffer[1024];
    int done;
    do {
        fgets(buffer, sizeof(buffer), xml);
        done = feof(xml);
        if (!done && XML_Parse(parser, buffer, strlen(buffer), 0) == XML_STATUS_ERROR)
            wxGetApp().Errorf("XML parse error at line %d:\n%s\n",
                    XML_GetCurrentLineNumber(parser),
                    XML_ErrorString(XML_GetErrorCode(parser)));
    } while (!done);
    fclose(xml);
    XML_ParserFree(parser);
    return true;
}
Exemplo n.º 15
0
void ParseXML::parseXML() {
  parser = XML_ParserCreate(NULL);
  if (!parser) {
    throw string("Couldn't allocate memory for parser");
  }

  XML_SetUserData(parser, this);
  XML_SetElementHandler(parser, wrapper4Start, wrapper4End);
  XML_SetCharacterDataHandler(parser, wrapper4Chars);
  std::fstream in;
  in.open(filename.c_str(), std::ios::in);
  if (!in) { 
    throw string("Cannot open xml file: ")+filename;
  }

  int length = 0;
  in.getline(buff, BUFSIZE);
  while ( true ) {
    if (! XML_Parse(parser, buff, strlen(buff), length)) {
      std::cout << "Parse error at line "
	         << XML_GetCurrentLineNumber(parser)
	         << XML_ErrorString(XML_GetErrorCode(parser))
           << std::endl;
      throw string("Couldn't parse file: ") + filename;
    }

    if ( in.eof() ) break;
    else in.getline(buff, BUFSIZE);
  }
}
Exemplo n.º 16
0
static ERL_NIF_TERM parse(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
    XML_Parser **parser;
    int is_final, res, errcode;
    ErlNifBinary stream;
    char *errstring;

    assert(argc == 3);

    if (!enif_get_resource(env, argv[0], PARSER_POINTER, (void **)&parser))
        return enif_make_badarg(env);

    if (!enif_is_binary(env, argv[1]))
        return enif_make_badarg(env);

    enif_get_int(env, argv[2], &is_final);
    enif_inspect_binary(env, argv[1], &stream);

    expat_parser *parser_data = XML_GetUserData((XML_Parser)(*parser));
    parser_data->result = enif_make_list(env, 0);
    parser_data->env = env;
    XML_SetUserData((XML_Parser)(*parser), parser_data);

    res = XML_Parse((XML_Parser)(*parser), (const char *)stream.data, stream.size, is_final);
    if(!res)
        {
            errcode = XML_GetErrorCode((XML_Parser)(*parser));
            errstring = (char *)XML_ErrorString(errcode);

            return enif_make_tuple(env, 2, ERROR,
                                   enif_make_string(env, errstring, ERL_NIF_LATIN1));
        }

    return enif_make_tuple(env, 2, OK, parser_data->result);
};
Exemplo n.º 17
0
BOOLEAN ReadInFoodOpinionStats(STR fileName)
{
	HWFILE		hFile;
	UINT32		uiBytesRead;
	UINT32		uiFSize;
	CHAR8 *		lpcBuffer;
	XML_Parser	parser = XML_ParserCreate(NULL);

	foodopinionParseData pData;

	DebugMsg(TOPIC_JA2, DBG_LEVEL_3, "Loading FoodOpinion.xml" );

	// Open file
	hFile = FileOpen( fileName, FILE_ACCESS_READ, FALSE );

	// if the file does not exist, exit
	// Flugente: no need to quit the game if the xml does not exist - this data just won't be there, but the game will still work
	if ( !hFile )
		return( TRUE );

	uiFSize = FileGetSize(hFile);
	lpcBuffer = (CHAR8 *) MemAlloc(uiFSize+1);

	//Read in block
	if ( !FileRead( hFile, lpcBuffer, uiFSize, &uiBytesRead ) )
	{
		MemFree(lpcBuffer);
		return( FALSE );
	}

	lpcBuffer[uiFSize] = 0; //add a null terminator

	FileClose( hFile );

	XML_SetElementHandler(parser, foodopinionStartElementHandle, foodopinionEndElementHandle);
	XML_SetCharacterDataHandler(parser, foodopinionCharacterDataHandle);

	memset(&pData,0,sizeof(pData));
	pData.curArray = FoodOpinions;
	pData.maxArraySize = NUM_PROFILES;

	XML_SetUserData(parser, &pData);

	if(!XML_Parse(parser, lpcBuffer, uiFSize, TRUE))
	{
		CHAR8 errorBuf[511];

		sprintf(errorBuf, "XML Parser Error in FoodOpinion.xml: %s at line %d", XML_ErrorString(XML_GetErrorCode(parser)), XML_GetCurrentLineNumber(parser));
		LiveMessage(errorBuf);

		MemFree(lpcBuffer);
		return FALSE;
	}

	MemFree(lpcBuffer);

	XML_ParserFree(parser);

	return( TRUE );
}
Exemplo n.º 18
0
static void
buildMenu(void)
{
    /* XML parsing is done using expat */
    int done = 1;
    int len = strlen(crut_api.menuBuffer);

    XML_Parser p = XML_ParserCreate(NULL);

    if (! p) 
    {
	fprintf(stderr, "Couldn't allocate memory for parser\n");
	exit(-1);
    }
    
    XML_UseParserAsHandlerArg(p);
    XML_SetElementHandler(p, start_hndl, end_hndl);

    if (! XML_Parse(p, crut_api.menuBuffer, len, done)) 
    {
	crError("Parse error at line %d:\n%s\n",
	      XML_GetCurrentLineNumber(p),
	      XML_ErrorString(XML_GetErrorCode(p)));
    }

    buildGLUTMenu( crut_server.stack );

    buildValueArray();
}
Exemplo n.º 19
0
void ExpatParser::parseXML(XMLHandler& handler, const RawDataContainer& source, const String& /*schemaName*/, bool /*allowXmlValidation*/)
{
    // All stuff goes here
    XML_Parser parser = XML_ParserCreate(0); // Create a parser

    if (!parser)
    {
        CEGUI_THROW(GenericException("Unable to create a new Expat Parser"));
    }

    XML_SetUserData(parser, (void*)&handler); // Initialise user data
    XML_SetElementHandler(parser, startElement, endElement); // Register callback for elements
    XML_SetCharacterDataHandler(parser, characterData); // Register callback for character data

    // Parse the data (note that the last true parameter tels Expat that this is the last chunk of the document
    if (!XML_Parse(parser, reinterpret_cast<const char*>(source.getDataPtr()), source.getSize(), true))
    {
        String exception (String((const encoded_char*)"XML Parsing error '") +
                          String((const encoded_char*)XML_ErrorString(XML_GetErrorCode(parser))) +
                          String((const encoded_char*)"' at line ") +
                          PropertyHelper<uint>::toString(XML_GetCurrentLineNumber(parser)));
        // (We know it is a valid pointer, otherwise an exception would have been thrown above.)
        XML_ParserFree(parser);
        CEGUI_THROW(GenericException(exception));
    }

    // (We know it is a valid pointer, otherwise an exception would have been thrown above.)
    XML_ParserFree(parser);
}
Exemplo n.º 20
0
void main(int argc, char **argv) {

  p = XML_ParserCreate(NULL);

  if (! p) {
    fprintf(stderr, "Couldn't allocate memory for parser\n");
    exit(-1);
  }

  XML_SetElementHandler(p, start, end);

  for (;;) {
    int done;
    int len;

    len = fread(Buff, 1, BUFFSIZE, stdin);
    if (ferror(stdin)) {
      fprintf(stderr, "Read error\n");
      exit(-1);
    }
    done = feof(stdin);

    if (! XML_Parse(p, Buff, len, done)) {
      fprintf(stderr, "Parse error at line %d:\n%s\n",
	      XML_GetCurrentLineNumber(p),
	      XML_ErrorString(XML_GetErrorCode(p)));
      exit(-1);
    }

    if (done)
      break;
  }
}  /* End of main */
Exemplo n.º 21
0
xml_data_node *xml_string_read(const char *string, xml_parse_options *opts)
{
	xml_parse_info parse_info;
	int length = (int)strlen(string);

	/* set up the parser */
	if (!expat_setup_parser(&parse_info, opts))
		return NULL;

	/* parse the data */
	if (XML_Parse(parse_info.parser, string, length, TRUE) == XML_STATUS_ERROR)
	{
		if (opts != NULL && opts->error != NULL)
		{
			opts->error->error_message = XML_ErrorString(XML_GetErrorCode(parse_info.parser));
			opts->error->error_line = XML_GetCurrentLineNumber(parse_info.parser);
			opts->error->error_column = XML_GetCurrentColumnNumber(parse_info.parser);
		}

		xml_file_free(parse_info.rootnode);
		XML_ParserFree(parse_info.parser);
		return NULL;
	}

	/* free the parser */
	XML_ParserFree(parse_info.parser);

	/* return the root node */
	return parse_info.rootnode;
}
Exemplo n.º 22
0
result_t XmlParser::parse(XmlDocument *doc, exlib::string source)
{
    XmlParser parser(doc, true);

    parser.m_now = doc;
    parser.m_list.push_back(doc);

    XML_Parser xml_parser = XML_ParserCreate(NULL);

    XML_SetParamEntityParsing(xml_parser, XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE);
    XML_SetUserData(xml_parser, &parser);

    XML_SetXmlDeclHandler(xml_parser, XmlDeclHandler);
    XML_SetElementHandler(xml_parser, StartElementHandler, EndElementHandler);
    XML_SetCharacterDataHandler(xml_parser, CharacterDataHandler);
    XML_SetProcessingInstructionHandler(xml_parser, ProcessingInstructionHandler);
    XML_SetCommentHandler(xml_parser, CommentHandler);
    XML_SetCdataSectionHandler(xml_parser, StartCdataSectionHandler, EndCdataSectionHandler);
    XML_SetStartDoctypeDeclHandler(xml_parser, StartDoctypeDeclHandler);

    if (XML_Parse(xml_parser, source.c_str(), (int32_t)source.length(), true) != XML_STATUS_OK)
    {
        char msg[128];
        sprintf(msg, "XmlParser: error on line %lu at colum %lu: %s", XML_GetCurrentLineNumber(xml_parser),
                XML_GetCurrentColumnNumber(xml_parser) + 1,
                XML_ErrorString(XML_GetErrorCode(xml_parser)));

        XML_ParserFree(xml_parser);
        return CHECK_ERROR(Runtime::setError(msg));
    }

    XML_ParserFree(xml_parser);

    return 0;
}
Exemplo n.º 23
0
xml_data_node *xml_data_node::string_read(const char *string, xml_parse_options const *opts)
{
	xml_parse_info info;
	int length = (int)strlen(string);

	/* set up the parser */
	if (!expat_setup_parser(info, opts))
		return nullptr;

	/* parse the data */
	if (XML_Parse(info.parser, string, length, 1) == XML_STATUS_ERROR)
	{
		if (opts != nullptr && opts->error != nullptr)
		{
			opts->error->error_message = XML_ErrorString(XML_GetErrorCode(info.parser));
			opts->error->error_line = XML_GetCurrentLineNumber(info.parser);
			opts->error->error_column = XML_GetCurrentColumnNumber(info.parser);
		}

		info.rootnode->file_free();
		XML_ParserFree(info.parser);
		return nullptr;
	}

	/* free the parser */
	XML_ParserFree(info.parser);

	/* return the root node */
	return info.rootnode;
}
Exemplo n.º 24
0
int
gcode_svg_import (gcode_t *gcode, gcode_block_t *sketch_block, char * filename)
{
  gcode_svg_t svg;
  XML_Parser p = XML_ParserCreate ("US-ASCII");
  FILE *fh;
  int len;
  char *buffer;

  svg.gcode = gcode;
  svg.sketch_block = sketch_block;
  svg.width = 0.0;
  svg.height = 0.0;

  if(!p)
  {
#if DEBUG
    fprintf (stderr, "Couldn't create parser for SVG!");
#endif
    return (1);
  }

  XML_SetElementHandler (p, svg_start, svg_end);
  XML_SetUserData (p, (void *) &svg);
 
  fh = fopen(filename, "r");
  if (!fh)
  {
#if DEBUG
    fprintf (stderr, "Couldn't load file: %s\n", filename);
#endif
    XML_ParserFree (p);
    return (1);
  }
 
  fseek (fh, 0, SEEK_END);
  len = ftell (fh);
  buffer = (char *) malloc (len);
  fseek (fh, 0, SEEK_SET);
  fread (buffer, len, 1, fh);

  //File read, create sketch

  if (XML_Parse (p, buffer, len, 1) == XML_STATUS_ERROR)
  {
#if DEBUG
    fprintf (stderr, "Parse error at line %d:\n%s\n", XML_GetCurrentLineNumber(p), XML_ErrorString(XML_GetErrorCode(p)));
#endif
    return (1);
  }
 
  fclose (fh);
  free (buffer);
  XML_ParserFree (p);

  svg.gcode->material_size[0] = svg.width * SCALEFACTOR;
  svg.gcode->material_size[1] = svg.height * SCALEFACTOR;
  gcode_prep (svg.gcode);
}
Exemplo n.º 25
0
void KML::parse()
{
    std::size_t nDone = 0;
    std::size_t nLen = 0;
    char aBuf[BUFSIZ] = { 0 };

    if( NULL == pKMLFile_ )
    {
        sError_ = "No file given";
        return;
    }

    if(poTrunk_ != NULL) {
        delete poTrunk_;
        poTrunk_ = NULL;
    }

    if(poCurrent_ != NULL)
    {
        delete poCurrent_;
        poCurrent_ = NULL;
    }

    XML_Parser oParser = OGRCreateExpatXMLParser();
    XML_SetUserData(oParser, this);
    XML_SetElementHandler(oParser, startElement, endElement);
    XML_SetCharacterDataHandler(oParser, dataHandler);
    oCurrentParser = oParser;
    nWithoutEventCounter = 0;

    do
    {
        nDataHandlerCounter = 0;
        nLen = (int)VSIFReadL( aBuf, 1, sizeof(aBuf), pKMLFile_ );
        nDone = VSIFEofL(pKMLFile_);
        if (XML_Parse(oParser, aBuf, nLen, nDone) == XML_STATUS_ERROR)
        {
            CPLError(CE_Failure, CPLE_AppDefined,
                        "XML parsing of KML file failed : %s at line %d, column %d",
                        XML_ErrorString(XML_GetErrorCode(oParser)),
                        (int)XML_GetCurrentLineNumber(oParser),
                        (int)XML_GetCurrentColumnNumber(oParser));
            XML_ParserFree(oParser);
            VSIRewindL(pKMLFile_);
            return;
        }
        nWithoutEventCounter ++;
    } while (!nDone && nLen > 0 && nWithoutEventCounter < 10);

    XML_ParserFree(oParser);
    VSIRewindL(pKMLFile_);
    poCurrent_ = NULL;

    if (nWithoutEventCounter == 10)
    {
        CPLError(CE_Failure, CPLE_AppDefined,
                 "Too much data inside one element. File probably corrupted");
    }
}
static void reportError(XML_Parser parser)
{
    XML_Error code = XML_GetErrorCode(parser);
    int lineNumber = XML_GetCurrentLineNumber(parser);
    const char* msg = XML_ErrorString(code);
    
    printf("-------- XML error [%d] on line %d, %s\n", code, lineNumber, msg);
}
Exemplo n.º 27
0
/*
 * Proxy:parse()
 *
 * upvalue 1: Method
 * upvalue 2: Signal
 *
 * argument 1: proxy
 * argument 2: xml string
 */
EXPORT int proxy_parse(lua_State *L)
{
	XML_Parser p;
	struct parsedata data;
	const char *xml;

	/* drop extra arguments */
	lua_settop(L, 2);

	/* get the xml string */
	xml = luaL_checkstring(L, 2);

	/* put the object name on the stack */
	lua_getfield(L, 1, "object");
	if (lua_isnil(L, 3))
		return luaL_argerror(L, 2, "no object set in the proxy");

	/* create parser and initialise it */
	p = XML_ParserCreate("UTF-8");
	if (!p) {
		lua_pushnil(L);
		lua_pushliteral(L, "Out of memory");
		return 2;
	}

	data.L = L;
	data.level = 0;
	data.interface = 0;
	data.type = 0;
	*data.signature = '\0';
	*data.result = '\0';
	data.sig_next = data.signature;
	data.res_next = data.result;

	XML_SetUserData(p, &data);
	XML_SetElementHandler(p,
			(XML_StartElementHandler)start_element_handler,
			(XML_EndElementHandler)end_element_handler);

	/* now parse the xml document inserting methods as we go */
	if (!XML_Parse(p, xml, strlen(xml), 1)) {
#ifdef DEBUG
		fprintf(stderr, "Parse error at line %d:\n%s\n",
				(int)XML_GetCurrentLineNumber(p),
				XML_ErrorString(XML_GetErrorCode(p)));
#endif
		lua_pushnil(L);
		lua_pushliteral(L, "Error parsing introspection data");
		return 2;
	}

	/* free the parser */
	XML_ParserFree(p);

	/* return true */
	lua_pushboolean(L, 1);
	return 1;
}
Exemplo n.º 28
0
xml_node *xml_parse( const char *filename ) {
	int done = 0;
	FILE *xptr;
	XML_Parser p;
	static char buf[BUFSIZE];
	xml_node root, *ret;

	if( (xptr = fopen( filename, "r" )) == NULL ) {
		fprintf( stderr, "Unable to open file: %s\n", filename );
		return NULL;
	}

	root.child = NULL;
	if( (ret = xml_alloc(&root)) == NULL ) {
		fclose( xptr );
		fprintf( stderr, "Out of memory\n" );
		return NULL;
	}

	if( (p = XML_ParserCreate( NULL )) == NULL ) {
		fclose( xptr );
		fprintf( stderr, "Out of memory\n" );
		return NULL;
	}

	XML_SetUserData( p, &ret );
	XML_SetElementHandler( p, xml_el_start, xml_el_end );
	XML_SetCharacterDataHandler( p, xml_charhndl );

	while( !done ) {
		int len;

		len = fread( buf, 1, BUFSIZE, xptr );
		if( ferror( xptr ) ) {
			fprintf( stderr, "Read error\n" );
			xml_free( ret );
			ret = NULL;
			break;
		}
		done = feof( xptr );

		if( XML_Parse(p, buf, len, done) == 0 ) {
			fprintf( stderr, "Parse error at line %d:\n%s\n",
							 (int) XML_GetCurrentLineNumber(p),
							 XML_ErrorString( XML_GetErrorCode(p) ) );
			xml_free( ret );
			ret = NULL;
			break;
		}
	}

	if( ret != NULL )
		ret->parent = NULL;

	fclose( xptr );
	XML_ParserFree( p );
	return ret;
}
Exemplo n.º 29
0
// Load the tree control with data from the XML file.
BOOL CPrefEditView::LoadTreeControl()
{
  CTreeCtrl &treeCtrl = GetTreeCtrl();
  m_hgroup = treeCtrl.GetRootItem();

  XML_Parser parser = XML_ParserCreate(NULL);
  XML_SetElementHandler(parser, startElementC, endElementC);
  XML_SetCharacterDataHandler(parser, characterDataC);
  XML_SetUserData(parser, this);

  // Load the XML from the file.
  CString strPrefsXML;
  FILE* pFile = fopen(m_strXMLFile, "r");
  if (!pFile)
  {
    CString strMsg;
    strMsg.Format("Can't open the file %s.",  m_strXMLFile);
    AfxMessageBox(strMsg, MB_OK);
    return FALSE;
  }

  // obtain file size.
  fseek(pFile , 0 , SEEK_END);
  long lSize = ftell(pFile);
  rewind(pFile);

  // allocate memory to contain the whole file.
  char* buffer = (char*) malloc (lSize + 1);
  if (buffer == NULL)
  {
    AfxMessageBox("Memory allocation error.", MB_OK);
    return FALSE;
  }

  buffer[lSize] = '\0';

  // copy the file into the buffer.
  size_t len = fread(buffer,1,lSize,pFile);
  
  // The whole file is loaded in the buffer.

  int done = 0;
  if (!XML_Parse(parser, buffer, len, done)) 
  {
    CString strMsg;
    strMsg.Format("%s in file %s at line %d.",XML_ErrorString(XML_GetErrorCode(parser)), m_strXMLFile, XML_GetCurrentLineNumber(parser));
    AfxMessageBox(strMsg, MB_OK);
    free(buffer);
    return FALSE;  
  }

  XML_ParserFree(parser);

  free(buffer);
  return TRUE;
  
}
Exemplo n.º 30
0
const char* LLXmlParser::getErrorString()
{
	const char* error_string = XML_ErrorString(XML_GetErrorCode( mParser ));
	if( !error_string )
	{
		error_string = mAuxErrorString.c_str();
	}
	return error_string;
}