Ejemplo n.º 1
0
int QgsGml::getFeatures( const QByteArray &data, QGis::WkbType* wkbType, QgsRectangle* extent )
{
  mWkbType = wkbType;
  mExtent.setMinimal();

  XML_Parser p = XML_ParserCreateNS( NULL, NS_SEPARATOR );
  XML_SetUserData( p, this );
  XML_SetElementHandler( p, QgsGml::start, QgsGml::end );
  XML_SetCharacterDataHandler( p, QgsGml::chars );
  int atEnd = 1;
  XML_Parse( p, data.constData(), data.size(), atEnd );

  if ( extent )
    *extent = mExtent;

  return 0;
}
Ejemplo n.º 2
0
XMPPStanza*
stanza_parse(char *stanza_text)
{
    ParseState *state = malloc(sizeof(ParseState));
    state->depth = 0;
    state->curr_stanza = NULL;

    XML_Parser parser = XML_ParserCreate(NULL);
    XML_SetElementHandler(parser, _start_element, _end_element);
    XML_SetCharacterDataHandler(parser, _handle_data);
    XML_SetUserData(parser, state);

    XML_Parse(parser, stanza_text, strlen(stanza_text), 0);
    XML_ParserFree(parser);

    return state->curr_stanza;
}
Ejemplo n.º 3
0
int loadGameConfig(void)
{
  char buf[BUFSIZ];
  XML_Parser parser = XML_ParserCreate(NULL);
  int done, i, depth = 0;
  FILE *config = NULL;

  totalGames = 0;

  XML_SetUserData(parser, &depth);
  XML_SetElementHandler(parser, startElement, endElement);
  XML_SetCharacterDataHandler(parser, characterData);

  config = fopen("/boot/uboot/beaglesnes/games.xml", "r");
  if (!config) {
    fprintf(stderr, "Unable to open game configuration file games.xml\n");
    return 1;
  }

  /* Initialize the flags for tag in use and defined */
  for (i = TAG_FIRST; i < TAG_LAST; i++) {
    inTagFlag[i] = 0;
    definedTagFlag[i] = 0;
  }

  /* Initialize the dummy head sentinel */
  fprintf(stderr, "Creating sentinel\n");
  gameInfo = (gameInfo_t *)calloc(1, sizeof(gameInfo_t)); 
  currentGame = gameInfo;

  do {
    int len = (int)fread(buf, 1, sizeof(buf), config);
    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));
      fclose(config);
      return 1;
    }
  } while (!done);
  XML_ParserFree(parser);
  fclose(config);
  return 0;
}
Ejemplo n.º 4
0
int
main(int argc, char *argv[])
{
  int done;
  char buf[BUFSIZ];
  FILE *infile, *outfile;
  
  XML_Parser parser = XML_ParserCreate(NULL);
  ESIS_Writer writer = ESIS_WriterCreate(stdout, 0U);
  
  if (argc == 2) {
    infile = fopen(argv[1], "r");
    if (infile == NULL) {
      perror(argv[1]);
      return 1;
    }
  } else 
    infile = stdin;
    
  outfile = stdout;
  
  XML_SetUserData(parser, writer);
  XML_SetElementHandler(parser,
      ESIS_Start,
      ESIS_End);
  XML_SetCharacterDataHandler(parser,
      (XML_CharacterDataHandler)ESIS_Cdata);
  
  do {
    size_t len = fread(buf, 1, sizeof(buf), infile);
    done = len < sizeof(buf);
    
    if (XML_Parse(parser, buf, (int)len, done) == 0) {
      fprintf(stderr,
              "%s at line %d\n",
              XML_ErrorString(XML_GetErrorCode(parser)),
              XML_GetCurrentLineNumber(parser));
      return 1;
    }
  } while (!done);
  
  XML_ParserFree(parser);
  ESIS_WriterFree(writer);
  
  return 0;
}
Ejemplo n.º 5
0
/****************************************************************************************************************
 * Parse configuration
*****************************************************************************************************************/
NFcompModel_p NFmodelParse (FILE *inFile, bool report)
{
	char *doc;

	NFdata_t      data;
	XML_Parser parser;

	data.SkipName   = "root";
	data.Abort      = false;
	data.Buffer     = (char *) NULL;
	data.BufferLen  = 0;
	data.Skip       = false;
	data.Stack      =
	data.StackSize  =
	data.SkipLevel  = 0;
	data.Model      = (NFcompModel_p) NULL;
	data.Objects    = (NFobject_p *)  NULL;

	if ((doc = _NFreadDoc (inFile)) == (char *) NULL) {
		CMmsgPrint (CMmsgAppError, "Document reading error in %s:%d\n",__FILE__,__LINE__);
		return ((NFcompModel_p) NULL);
	}

	if ((parser = XML_ParserCreate(NULL)) == (XML_Parser) NULL) {
		CMmsgPrint (CMmsgSysError, "Memory allocation in %s:%d\n",__FILE__,__LINE__);
		return ((NFcompModel_p) NULL);
	}

	XML_SetUserData             (parser, &data);
	XML_SetElementHandler       (parser, _NFentryStart, _NFentryEnd);
	XML_SetCharacterDataHandler (parser, _NFentryText);
	XML_UseParserAsHandlerArg   (parser);

	if (XML_Parse(parser, doc, strlen (doc), true) == XML_STATUS_ERROR) {
		CMmsgPrint (CMmsgAppError,"Parse error at line %d\n", XML_GetCurrentLineNumber(parser));
		return ((NFcompModel_p) NULL);
	}
	XML_ParserFree (parser);
	if (data.Objects != (NFobject_p *) NULL) free (data.Objects);
	if ((data.Abort) && (data.Model != (NFcompModel_p) NULL)) {
		NFobjectFree ((NFobject_p) data.Model);
		return ((NFcompModel_p) NULL);
	}
	if (report) NFobjectPrint ((NFobject_p) (data.Model));
	return (data.Model);
}
Ejemplo n.º 6
0
void ExpatAdapter::ParseBuffer ( const void * buffer, size_t length, bool last /* = true */ )
{
    enum XML_Status status;

    if ( length == 0 ) {	// Expat does not like empty buffers.
        if ( ! last ) return;
        buffer = kOneSpace;
        length = 1;
    }

    status = XML_Parse ( this->parser, (const char *)buffer, length, last );

    #if BanAllEntityUsage
        if ( this->isAborted ) XMP_Throw ( "DOCTYPE is not allowed", kXMPErr_BadXML );
    #endif

    if ( status != XML_STATUS_OK ) {

        XMP_StringPtr errMsg = "XML parsing failure";

        #if 0	// XMP_DebugBuild	// Disable for now to make test output uniform. Restore later with thread safety.

            // *** This is a good candidate for a callback error notification mechanism.
            // *** This code is not thread safe, the sExpatMessage isn't locked. But that's OK for debug usage.

            enum XML_Error expatErr = XML_GetErrorCode ( this->parser );
            const char *   expatMsg = XML_ErrorString ( expatErr );
            int errLine = XML_GetCurrentLineNumber ( this->parser );

            char msgBuffer[1000];
            // AUDIT: Use of sizeof(msgBuffer) for snprintf length is safe.
            snprintf ( msgBuffer, sizeof(msgBuffer), "# Expat error %d at line %d, \"%s\"", expatErr, errLine, expatMsg );
            sExpatMessage = msgBuffer;
            errMsg = sExpatMessage.c_str();

            #if  DumpXMLParseEvents
                if ( this->parseLog != 0 ) fprintf ( this->parseLog, "%s\n", errMsg, expatErr, errLine, expatMsg );
            #endif

        #endif

        XMP_Throw ( errMsg, kXMPErr_BadXML );

    }

}	// ExpatAdapter::ParseBuffer
Ejemplo n.º 7
0
static void
parse_position(Eina_List **cache, const char *filename, const char *state_file)
{
    dbg("Checking current position of %s", filename);

    int fd = open(state_file, O_RDONLY);
    if (fd == -1)
        return;

    XML_Parser parser = XML_ParserCreate(NULL);
    XML_SetStartElementHandler(parser, _start_element);

    _context_t ctx = { .cache = cache, .filename = NULL, .parser = parser };

    XML_SetUserData(parser, &ctx);

    dbg("Parsing");

    char buffer[4096];
    for (;;)
    {
        int read_ = read(fd, buffer, 4096);
        dbg("Read %d bytes from state.xml: %.*s", read_, read_, buffer);
        if (read_ < 0)
        {
            dbg("Got error %s", strerror(errno));
            if (errno == EINTR || errno == EAGAIN)
                continue;
            else
                break;
        }
        else
        {
            int res = XML_Parse(parser, buffer, read_, read_ == 0);
            dbg("Got %d (%d: %s, %d:%d) from XML_Parse", res, XML_GetErrorCode(parser),
                XML_ErrorString(XML_GetErrorCode(parser)),
                XML_GetCurrentLineNumber(parser),
                XML_GetCurrentColumnNumber(parser));
            if (read_ == 0 || res == XML_STATUS_ERROR)
                break;
        }
    }


    close(fd);
}
static void parseDTD(XML_Parser parser, const std::string &fileName) {
	XML_Parser entityParser = XML_ExternalEntityParserCreate(parser, 0, 0);
	ZLFile dtdFile(fileName);
	shared_ptr<ZLInputStream> entityStream = dtdFile.inputStream();
	if (!entityStream.isNull() && entityStream->open()) {
		const size_t BUFSIZE = 2048;
		char buffer[BUFSIZE];
		size_t length;
		do {
			length = entityStream->read(buffer, BUFSIZE);
			if (XML_Parse(entityParser, buffer, length, 0) == XML_STATUS_ERROR) {
				break;
			}
		} while (length == BUFSIZE);
	}
	XML_ParserFree(entityParser);
}
Ejemplo n.º 9
0
static int expat_erl_control(ErlDrvData drv_data,
			     unsigned int command,
			     char *buf, int len,
			     char **rbuf, int rlen)
{
   expat_data* d = (expat_data*)drv_data;
   int res, errcode;
   char *errstring;
   ErlDrvBinary *b;
   size_t size;

   switch (command)
   {
      case PARSE_COMMAND:
      case PARSE_FINAL_COMMAND:
	 ei_x_new_with_version(&event_buf);
	 res = XML_Parse(d->parser, buf, len, command == PARSE_FINAL_COMMAND);

	 if(!res)
	 {
	    errcode = XML_GetErrorCode(d->parser);
	    errstring = (char *)XML_ErrorString(errcode);

	    ei_x_encode_list_header(&event_buf, 1);
	    ei_x_encode_tuple_header(&event_buf, 2);
	    ei_x_encode_long(&event_buf, XML_ERROR);
	    ei_x_encode_tuple_header(&event_buf, 2);
	    ei_x_encode_long(&event_buf, errcode);
	    ei_x_encode_string(&event_buf, errstring);
	 }

	 ei_x_encode_empty_list(&event_buf);

	 size = event_buf.index;

	 b = driver_alloc_binary(size);
	 memcpy(b->orig_bytes, event_buf.buff, size);

	 ei_x_free(&event_buf);
 
	 *rbuf = (char *)b;
	 return size;
      default:
	 return 0;
   }
}
bool CCSAXParser::parse(const char *pszFile)
{
	bool bRet = false;
	char* buf = NULL;
	s3eFile* file = NULL;
	
	do
	{
		file = s3eFileOpen(pszFile, "r");
		
		if (!file)
		{
			IwAssertMsg(GAME, file, ("Open file %s Failed. s3eFileError Code : %i", pszFile, s3eFileGetError()));
			break;
		}
		
		s3eFileSeek(file, 0, S3E_FILESEEK_END);
		int	size = s3eFileTell(file);
		s3eFileSeek(file, 0,  S3E_FILESEEK_SET);
		buf = new char[size];
		int done =0;
		int len = (int)s3eFileRead(buf, 1, size, file);
		if (XML_Parse(s_pParser, buf, len, 1) == XML_STATUS_ERROR)
		{
			CCLog("GAME: cocos2d: plist err: %s at line %d", XML_ErrorString(XML_GetErrorCode(s_pParser)), XML_GetCurrentLineNumber(s_pParser));
			break;
		}
		
		bRet = true;
		
	} while(0);
	
	// cleanup
	if (file)
	{
		s3eFileClose(file);
	}
	if (buf)
	{
		delete []buf;
	}
	
	return bRet;

}
Ejemplo n.º 11
0
int
xps_parse_metadata(xps_context_t *ctx, xps_part_t *part)
{
    XML_Parser xp;
    int code;
    char buf[1024];
    char *s;

    /* Save directory name part */
    xps_strlcpy(buf, part->name, sizeof buf);
    s = strrchr(buf, '/');
    if (s)
        s[0] = 0;

    /* _rels parts are voodoo: their URI references are from
     * the part they are associated with, not the actual _rels
     * part being parsed.
     */
    s = strstr(buf, "/_rels");
    if (s)
        *s = 0;

    ctx->base_uri = buf;
    ctx->part_uri = part->name;

    xp = XML_ParserCreate(NULL);
    if (!xp)
        return gs_throw(-1, "cannot create XML parser");

    XML_SetUserData(xp, ctx);
    XML_SetParamEntityParsing(xp, XML_PARAM_ENTITY_PARSING_NEVER);
    XML_SetStartElementHandler(xp, (XML_StartElementHandler)xps_parse_metadata_imp);

    code = XML_Parse(xp, (char*)part->data, part->size, 1);

    XML_ParserFree(xp);

    ctx->base_uri = NULL;
    ctx->part_uri = NULL;

    if (code == 0)
        return gs_throw1(-1, "cannot parse XML in part: %s", part->name);

    return 0;
}
Ejemplo n.º 12
0
int
mb_kbd_config_load(MBKeyboard *kbd, char *variant)
{
  char                  *data;
  XML_Parser             p;
  MBKeyboardConfigState *state;

  if (!(data = load_config_file ("keyboard", variant, 1, &kbd->config_file)))
    util_fatal_error("Couldn't find a keyboard config file\n");

  p = XML_ParserCreate(NULL);

  if (!p)
    util_fatal_error("Couldn't allocate memory for XML parser\n");

  if (variant && !strstr(kbd->config_file, variant))
    fprintf(stderr,
	    "matchbox-keyboard: *Warning* Unable to locate variant: %s\n"
	    "                   falling back to %s\n",
	    variant, kbd->config_file);

  state = util_malloc0(sizeof(MBKeyboardConfigState));

  state->keyboard = kbd;
  state->parser = p;

  XML_SetElementHandler(p, config_xml_start_cb, NULL);

  /* XML_SetCharacterDataHandler(p, chars); */

  XML_SetUserData(p, (void *)state);

  if (! XML_Parse(p, data, strlen(data), 1)) {
    fprintf(stderr,
	    "matchbox-keyboard:%s:%d: XML Parse error:%s\n",
	    kbd->config_file,
	    (int)XML_GetCurrentLineNumber(p),
	    XML_ErrorString(XML_GetErrorCode(p)));
    util_fatal_error("XML Parse failed.\n");
  }

  XML_ParserFree (p);

  return 1;
}
Ejemplo n.º 13
0
int
main(int argc, char * argv[])
{
    char buf[BUFSIZ];
    FILE *in;
    XML_Parser parser;


    if (!argv[1]) {
        in = stdin;

    } else if (!(in = fopen (argv[1], "r"))) {
        printf ("Unable to open input file %s\n", argv[1]);
        return (2);
    }

  
    /*  Create the parser and set the input handlers.
    */
    parser = XML_ParserCreate(NULL);
    XML_SetElementHandler (parser, startElement, endElement);
    XML_SetCharacterDataHandler (parser, charData);

    vot = (VOTable *) newType (TY_VOTABLE);

    do {
        size_t len = fread (buf, 1, sizeof(buf), in);
        done = len < sizeof(buf);
        if (!XML_Parse (parser, buf, len, done)) {
            fprintf (stderr, "Error: %s at line %d\n",
                XML_ErrorString(XML_GetErrorCode(parser)),
                XML_GetCurrentLineNumber(parser));
            return (1);
        }
    } while (!done);

    XML_ParserFree(parser);

    if (in != stdin) 
	fclose (in);

    free ((void *)vot);

    return (0);
}
Ejemplo n.º 14
0
nad_t nad_parse(const char *buf, int len) {
    struct build_data bd;
    XML_Parser p;

    if(len == 0)
        len = strlen(buf);

    p = XML_ParserCreateNS(NULL, '|');
    if(p == NULL)
        return NULL;
    bd.p = p;

    XML_SetReturnNSTriplet(p, 1);
    /* 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, simply prevent expenansion
     * of such entities. */
#ifdef HAVE_XML_STOPPARSER
    XML_SetEntityDeclHandler(p, (void *) _nad_parse_entity_declaration);
#else
    XML_SetDefaultHandler(p, NULL);
#endif

    bd.nad = nad_new();
    bd.depth = 0;

    XML_SetUserData(p, (void *) &bd);
    XML_SetElementHandler(p, _nad_parse_element_start, _nad_parse_element_end);
    XML_SetCharacterDataHandler(p, _nad_parse_cdata);
    XML_SetStartNamespaceDeclHandler(p, _nad_parse_namespace_start);

    if(!XML_Parse(p, buf, len, 1)) {
        XML_ParserFree(p);
        nad_free(bd.nad);
        return NULL;
    }

    XML_ParserFree(p);

    if(bd.depth != 0)
        return NULL;

    return bd.nad;
}
Ejemplo n.º 15
0
sp<XMLNode> XMLNode::parse(const sp<AaptFile>& file)
{
    char buf[16384];
    int fd = open(file->getSourceFile().string(), O_RDONLY | O_BINARY);
    if (fd < 0) {
        SourcePos(file->getSourceFile(), -1).error("Unable to open file for read: %s",
                strerror(errno));
        return NULL;
    }

    XML_Parser parser = XML_ParserCreateNS(NULL, 1);
    ParseState state;
    state.filename = file->getPrintableSource();
    state.parser = parser;
    XML_SetUserData(parser, &state);
    XML_SetElementHandler(parser, startElement, endElement);
    XML_SetNamespaceDeclHandler(parser, startNamespace, endNamespace);
    XML_SetCharacterDataHandler(parser, characterData);
    XML_SetCommentHandler(parser, commentData);

    ssize_t len;
    bool done;
    do {
        len = read(fd, buf, sizeof(buf));
        done = len < (ssize_t)sizeof(buf);
        if (len < 0) {
            SourcePos(file->getSourceFile(), -1).error("Error reading file: %s\n", strerror(errno));
            close(fd);
            return NULL;
        }
        if (XML_Parse(parser, buf, len, done) == XML_STATUS_ERROR) {
            SourcePos(file->getSourceFile(), (int)XML_GetCurrentLineNumber(parser)).error(
                    "Error parsing XML: %s\n", XML_ErrorString(XML_GetErrorCode(parser)));
            close(fd);
            return NULL;
        }
    } while (!done);

    XML_ParserFree(parser);
    if (state.root == NULL) {
        SourcePos(file->getSourceFile(), -1).error("No XML data generated when parsing");
    }
    close(fd);
    return state.root;
}
Ejemplo n.º 16
0
BrokerMessage *sb_parser_process(XML_Parser p, char *buffer, int len)
{
    BrokerParserData *bp = (BrokerParserData *) XML_GetUserData(p);
    bp->msg = calloc(1, sizeof(BrokerMessage));
    XML_ParserReset(p, NULL);
    XML_SetUserData(p, bp);
    XML_SetElementHandler(p, sbx_start, sbx_end);
    XML_SetCharacterDataHandler(p, getText);

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

    return bp->msg;
}
Ejemplo n.º 17
0
END_TEST

/* Regression test for SF bug #824420.
   Checks that an xmlns:prefix attribute set in an attribute's default
   value isn't misinterpreted.
*/
START_TEST(test_ns_in_attribute_default_without_namespaces)
{
    char *text =
        "<!DOCTYPE e:element [\n"
        "  <!ATTLIST e:element\n"
        "    xmlns:e CDATA 'http://example.com/'>\n"
        "      ]>\n"
        "<e:element/>";

    if (XML_Parse(parser, text, strlen(text), XML_TRUE) == XML_STATUS_ERROR)
        xml_failure(parser);
}
Ejemplo n.º 18
0
END_TEST

/* See related SF bug #673791.
   When namespace processing is enabled, setting the namespace URI for
   a prefix is not allowed; this test ensures that it *is* allowed
   when namespace processing is not enabled.
   (See Namespaces in XML, section 2.)
*/
START_TEST(test_empty_ns_without_namespaces)
{
    char *text =
        "<doc xmlns:prefix='http://www.example.com/'>\n"
        "  <e xmlns:prefix=''/>\n"
        "</doc>";

    if (XML_Parse(parser, text, strlen(text), XML_TRUE) == XML_STATUS_ERROR)
        xml_failure(parser);
}
Ejemplo n.º 19
0
END_TEST

START_TEST(test_utf16)
{
    /* <?xml version="1.0" encoding="UTF-16"?>
       <doc a='123'>some text</doc>
    */
    char text[] =
        "\000<\000?\000x\000m\000\154\000 \000v\000e\000r\000s\000i\000o"
        "\000n\000=\000'\0001\000.\000\060\000'\000 \000e\000n\000c\000o"
        "\000d\000i\000n\000g\000=\000'\000U\000T\000F\000-\0001\000\066"
        "\000'\000?\000>\000\n"
        "\000<\000d\000o\000c\000 \000a\000=\000'\0001\0002\0003\000'"
        "\000>\000s\000o\000m\000e\000 \000t\000e\000x\000t\000<\000/"
        "\000d\000o\000c\000>";
    if (XML_Parse(parser, text, sizeof(text)-1, XML_TRUE) == XML_STATUS_ERROR)
        xml_failure(parser);
}
Ejemplo n.º 20
0
CXmlDocument& CXmlLoader::Load(CXmlDocument & doc){
    bool done;
    m_ctx.root = m_ctx.node = NULL;

    do {
        size_t len = GetIOHandler().LoadBuffer(m_buf, BUFSIZE);
        done = (len < BUFSIZE);
        if (!XML_Parse(m_parser, m_buf, len, done)) {
            CXmlLoadException ex(XML_ErrorString(XML_GetErrorCode(m_parser)), 
                              XML_GetErrorCode(m_parser), 
                              XML_GetCurrentLineNumber(m_parser));
            throw ex;
        }
    } while (!done);

    doc.SetRoot(m_ctx.root);
    return doc;
};
Ejemplo n.º 21
0
END_TEST

/* Regression test #2 for SF bug #653180. */
START_TEST(test_column_number_after_parse)
{
    char *text = "<tag></tag>";
    XML_Size colno;

    if (XML_Parse(parser, text, strlen(text), XML_FALSE) == XML_STATUS_ERROR)
        xml_failure(parser);
    colno = XML_GetCurrentColumnNumber(parser);
    if (colno != 11) {
        char buffer[100];
        sprintf(buffer, 
            "expected 11 columns, saw %" XML_FMT_INT_MOD "u", colno);
        fail(buffer);
    }
}
	//--------------------------------------------------------------------
	bool ExpatSaxParser::parseBuffer(const char* uri, const char* buffer, int length)
	{
		
		mParser = XML_ParserCreate(0);

		XML_SetUserData(mParser, this);
		XML_SetElementHandler(mParser, startElement, endElement);
		XML_SetCharacterDataHandler(mParser, characters);


		XML_Status status = XML_STATUS_OK;
		bool isFinal = true;
		XML_Parse(mParser, buffer, (int)length, isFinal);

		XML_ParserFree(mParser);

		return status != XML_STATUS_ERROR;
	}
Ejemplo n.º 23
0
Archivo: xmlstream.c Proyecto: 2px/curl
static size_t parseStreamCallback(void *contents, size_t length, size_t nmemb,
                                  void *userp)
{
  XML_Parser parser = (XML_Parser) userp;
  size_t real_size = length * nmemb;
  struct ParserStruct *state = (struct ParserStruct *) XML_GetUserData(parser);

  /* Only parse if we're not already in a failure state. */
  if(state->ok && XML_Parse(parser, contents, real_size, 0) == 0) {
    int error_code = XML_GetErrorCode(parser);
    fprintf(stderr, "Parsing response buffer of length %lu failed"
            " with error code %d (%s).\n",
            real_size, error_code, XML_ErrorString(error_code));
    state->ok = 0;
  }

  return real_size;
}
Ejemplo n.º 24
0
BOOLEAN ReadInSoundArray(STR fileName)
{
    HWFILE		hFile;
    UINT32		uiBytesRead;
    UINT32		uiFSize;
    CHAR8 *		lpcBuffer;
    XML_Parser	parser = XML_ParserCreate(NULL);
    soundParseData pData;
    DebugMsg(TOPIC_JA2, DBG_LEVEL_3, String("Loading %s",SOUNDSFILENAME ) );

    // Open sounds file
    hFile = FileOpen( fileName, FILE_ACCESS_READ, FALSE );
    if ( !hFile )
        return( FALSE );

    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, soundStartElementHandle, soundEndElementHandle);
    XML_SetCharacterDataHandler(parser, soundCharacterDataHandle);
    memset(&pData,0,sizeof(pData));
    pData.maxArraySize = MAX_SAMPLES;
    pData.curIndex = -1;
    XML_SetUserData(parser, &pData);
    if(!XML_Parse(parser, lpcBuffer, uiFSize, TRUE))
    {
        CHAR8 errorBuf[511];
        sprintf(errorBuf, "XML Parser Error in %s.xml: %s at line %d", SOUNDSFILENAME, XML_ErrorString(XML_GetErrorCode(parser)), XML_GetCurrentLineNumber(parser));
        LiveMessage(errorBuf);
        MemFree(lpcBuffer);
        return FALSE;
    }
    MemFree(lpcBuffer);
    XML_ParserFree(parser);
    return( TRUE );
}
Ejemplo n.º 25
0
//XmlNodeRef XmlParserImp::parse( const std::vector<char> &buffer,String &errorString )
XmlNodeRef XmlParserImp::parse( const char * buffer, int buffersize,String &errorString )
{
	m_parser = XML_ParserCreate(NULL);

  XML_SetUserData( m_parser, this );
  XML_SetElementHandler( m_parser, startElement,endElement );
	XML_SetCharacterDataHandler( m_parser,characterData );

	XmlNodeRef root = 0;

	/*
	int size = file->size();
	char *buf = (char*)memory::malloc( size );
	file->read( buf,size );
	if (!XML_Parse( parser,buf,size,1 ))
	{
		error( "XML Error (%s): %s at line %d\n",filename.c_str(),XML_ErrorString(XML_GetErrorCode(parser)),XML_GetCurrentLineNumber(parser) );
		return false;
	}
	memory::free( buf );

	XMLParser::parse( fileName );
	*/

//	if (XML_Parse( m_parser,buffer,buffer.size(),1 ))
		if (XML_Parse( m_parser,buffer,buffersize,1 ))
	{
		root = m_root;
	} else {
		char str[32768];
#if _MSC_VER<=1200
		sprintf( str,"XML Error: %s at line %d",XML_ErrorString(XML_GetErrorCode(m_parser)),XML_GetCurrentLineNumber(m_parser) );
#else
		sprintf_s( str,sizeof(str),"XML Error: %s at line %d",XML_ErrorString(XML_GetErrorCode(m_parser)),XML_GetCurrentLineNumber(m_parser) );
#endif
		errorString = str;
	}
	
	XML_ParserFree( m_parser );

	m_root = 0;

	return root;
}
Ejemplo n.º 26
0
int QgsWFSData::getWFSData()
{
  XML_Parser p = XML_ParserCreateNS( NULL, NS_SEPARATOR );
  XML_SetUserData( p, this );
  XML_SetElementHandler( p, QgsWFSData::start, QgsWFSData::end );
  XML_SetCharacterDataHandler( p, QgsWFSData::chars );


  //separate host from query string
  QUrl requestUrl( mUri );
  int portNr = requestUrl.port();
  if ( portNr != -1 )
  {
    mHttp.setHost( requestUrl.host(), portNr );
  }
  else
  {
    mHttp.setHost( requestUrl.host() );
  }

  //mHttp.get( mUri );
  mHttp.get( requestUrl.path() + "?" + QString( requestUrl.encodedQuery() ) );


  //loop to read the data
  QByteArray readData;
  int atEnd = 0;
  qWarning( "Entering loop" );
  while ( !mFinished || mHttp.bytesAvailable() > 0 )
  {
    if ( mFinished )
    {
      atEnd = 1;
    }
    if ( mHttp.bytesAvailable() != 0 )
    {
      readData = mHttp.readAll();
      XML_Parse( p, readData.data(), readData.size(), atEnd );
    }
    qApp->processEvents( QEventLoop::ExcludeUserInputEvents );
  }
  qWarning( "Left loop" );
  return 0; //soon
}
Ejemplo 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));
	  XML_ParserFree(parser);
	  if (pd->solvable)
	    {
	      repo_free_solvable(pd->repo, pd->solvable - pd->pool->solvables, 1);
	      pd->solvable = 0;
	    }
	  return;
	}
      if (l == 0)
	break;
    }
  XML_ParserFree(parser);
}
Ejemplo n.º 28
0
Appcast Appcast::Load(const std::string& xml)
{
    XML_Parser p = XML_ParserCreateNS(NULL, NS_SEP);
    if ( !p )
        throw std::runtime_error("Failed to create XML parser.");

    ContextData ctxt(p);

    XML_SetUserData(p, &ctxt);
    XML_SetElementHandler(p, OnStartElement, OnEndElement);
    XML_SetCharacterDataHandler(p, OnText);

    XML_Status st = XML_Parse(p, xml.c_str(), xml.size(), XML_TRUE);

    if ( st == XML_STATUS_ERROR )
    {
        std::string msg("XML parser error: ");
        msg.append(XML_ErrorString(XML_GetErrorCode(p)));
        XML_ParserFree(p);
        throw std::runtime_error(msg);
    }

    XML_ParserFree(p);

    if (ctxt.items.empty())
        return Appcast(); // invalid

    /*
     * Search for first <item> which specifies with the attribute sparkle:os set to "windows"
     * or "windows-x64"/"windows-x86" based on this modules bitness and meets the minimum
     * os version, if set. If none, use the first item that meets the minimum os version, if set.
     */
    std::vector<Appcast>::iterator it = std::find_if(ctxt.items.begin(), ctxt.items.end(), is_suitable_windows_item);
    if (it != ctxt.items.end())
        return *it;
    else
    {
        it = std::find_if(ctxt.items.begin(), ctxt.items.end(), is_windows_version_acceptable);
        if (it != ctxt.items.end())
            return *it;
        else 
            return Appcast(); // There are no items that meet the set minimum os version
    }
}
Ejemplo n.º 29
0
int
main(int argc, char **argv)
{
	if (argc != 3) {
    	fprintf(stderr, "Usage: %s formname,filename\n", argv[0]);
    	return (1);
    }
	
    char *form_name=argv[1];
    FILE *f=fopen(argv[2],"r");
    XML_Parser parser;
    size_t size;
    char *xmltext;
    
    
    //ParserCreation
    parser = XML_ParserCreate(NULL);
    if (parser == NULL) {
    	fprintf(stderr, "Parser not created\n");
    	return (1);
    }
    
    // Tell expat to use functions start() and end() each times it encounters the start or end of an element.
    XML_SetElementHandler(parser, start, end);
    XML_SetCharacterDataHandler(parser, characterdata);
    XML_SetUserData(parser, form_name);
    //Open XML File
    xmltext = malloc(MAXCHARS);
    size = fread(xmltext, sizeof(char), MAXCHARS, f);
    
    //Parse Xml Text
    if (XML_Parse(parser, xmltext, strlen(xmltext), XML_TRUE) ==
        XML_STATUS_ERROR) {
    	fprintf(stderr,
    		"Cannot parse , file may be too large or not well-formed XML\n");
    	return (1);
    }
    
    //Close
    fclose(f);
    XML_ParserFree(parser);
    fprintf(stdout, "Successfully parsed %i characters !\n", size);
    return (0);
}
SkXMLPullParser::EventType SkXMLPullParser::onNextToken()
{
    if (Data::RETURN_END_TAG == fImpl->fData.fState)
    {
        fImpl->fData.fState = Data::NORMAL;
        fCurr.fName = fImpl->fData.fEndTag; // restore name from (below) save
        return SkXMLPullParser::END_TAG;
    }

    fImpl->fData.fAlloc.reuse();

    XML_Parser p = fImpl->fData.fParser;
    XML_Status status;

    status = XML_ResumeParser(p);
    
CHECK_STATUS:
    switch (status) {
    case XML_STATUS_OK:
        return SkXMLPullParser::END_DOCUMENT;

    case XML_STATUS_ERROR:
        if (XML_GetErrorCode(p) != XML_ERROR_NOT_SUSPENDED)
        {
            reportError(p);
            return SkXMLPullParser::ERROR;
        }
        status = XML_Parse(p, (const char*)fImpl->fBuffer, fImpl->fBufferLen, true);
        goto CHECK_STATUS;

    case XML_STATUS_SUSPENDED:
        if (Data::MISSED_START_TAG == fImpl->fData.fState)
        {
            // return a start_tag, and clear the flag so we return end_tag next
            SkASSERT(SkXMLPullParser::END_TAG == fCurr.fEventType);
            fImpl->fData.fState = Data::RETURN_END_TAG;
            fImpl->fData.fEndTag = fCurr.fName;  // save this pointer            
            return SkXMLPullParser::START_TAG;
        }
        break;
    }
    return fCurr.fEventType;
}