/* {{{ proto bool XMLReader::next([string localname])
Moves the position of the current instance to the next node in the stream. */
PHP_METHOD(xmlreader, next)
{
zval *id;
int retval;
size_t name_len=0;
xmlreader_object *intern;
char *name = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "|s", &name, &name_len) == FAILURE) {
return;
}
id = ZEND_THIS;
intern = Z_XMLREADER_P(id);
if (intern != NULL && intern->ptr != NULL) {
retval = xmlTextReaderNext(intern->ptr);
while (name != NULL && retval == 1) {
if (xmlStrEqual(xmlTextReaderConstLocalName(intern->ptr), (xmlChar *)name)) {
RETURN_TRUE;
}
retval = xmlTextReaderNext(intern->ptr);
}
if (retval == -1) {
RETURN_FALSE;
} else {
RETURN_BOOL(retval);
}
}
php_error_docref(NULL, E_WARNING, "Load Data before trying to read");
RETURN_FALSE;
}
bool HHVM_METHOD(XMLReader, next,
const Variant& localname /*= null_variant*/) {
auto* data = Native::data<XMLReader>(this_);
const String& str_localname = localname.isNull()
? null_string
: localname.toString();
SYNC_VM_REGS_SCOPED();
if (data->m_ptr) {
int ret = xmlTextReaderNext(data->m_ptr);
while (!str_localname.empty() && ret == 1) {
if (xmlStrEqual(xmlTextReaderConstLocalName(data->m_ptr),
(xmlChar *)str_localname.data())) {
return true;
}
ret = xmlTextReaderNext(data->m_ptr);
}
if (ret == -1) {
raise_warning("An Error Occurred while reading");
return false;
} else {
return ret;
}
}
raise_warning("Load Data before trying to read");
return false;
}
static GWeatherTimezone *
parse_timezone (GWeatherParser *parser)
{
GWeatherTimezone *zone = NULL;
char *id = NULL;
char *name = NULL;
int offset = 0, dst_offset = 0;
gboolean has_dst = FALSE;
id = (char *) xmlTextReaderGetAttribute (parser->xml, (xmlChar *) "id");
if (!id) {
xmlTextReaderNext (parser->xml);
return NULL;
}
if (!xmlTextReaderIsEmptyElement (parser->xml)) {
if (xmlTextReaderRead (parser->xml) != 1) {
xmlFree (id);
return NULL;
}
while (xmlTextReaderNodeType (parser->xml) != XML_READER_TYPE_END_ELEMENT) {
if (xmlTextReaderNodeType (parser->xml) != XML_READER_TYPE_ELEMENT) {
if (xmlTextReaderRead (parser->xml) != 1)
break;
continue;
}
if (!strcmp ((const char *) xmlTextReaderConstName (parser->xml), "name"))
name = _gweather_parser_get_localized_value (parser);
else {
if (xmlTextReaderNext (parser->xml) != 1)
break;
}
}
}
if (parse_tzdata (id, parser->year_start, parser->year_end,
&offset, &has_dst, &dst_offset)) {
zone = g_slice_new0 (GWeatherTimezone);
zone->ref_count = 1;
zone->id = g_strdup (id);
zone->name = name;
zone->offset = offset;
zone->has_dst = has_dst;
zone->dst_offset = dst_offset;
g_hash_table_insert (parser->timezone_cache, zone->id, zone);
name = NULL;
}
g_free (name);
xmlFree (id);
return zone;
}
int cDataMap::processData(xmlTextReaderPtr reader)
{
// element callback from read_xmlfile
// args: pointer to the xmlTextreader
xmlNodePtr node ;
xmlChar *content;
string value;
int epgdataid;
int retval;
// get name, type and depth in the xml structure
string name = string((char *)xmlTextReaderConstName(reader));
int type = xmlTextReaderNodeType(reader) ;
int depth = xmlTextReaderDepth(reader) ;
// get ca0/ca1 or g0/g1 depending which file we read
if (type == XML_READER_TYPE_ELEMENT && depth == 2 && (name.compare("ca0") == 0)) {
node = xmlTextReaderExpand(reader);
content = xmlXPathCastNodeToString(node);
node = NULL ;
epgdataid = atoi((char *)content);
xmlFree(content);
retval = xmlTextReaderNext(reader); // jump to end element
retval = xmlTextReaderNext(reader); // jump to next start element
node = xmlTextReaderExpand(reader);
content = xmlXPathCastNodeToString(node);
node = NULL ;
value = string((char *)content);
xmlFree(content);
datamap[epgdataid] = value;
} else if (type == XML_READER_TYPE_ELEMENT && depth == 2 && ( name.compare("g0") == 0 )) {
node = xmlTextReaderExpand(reader);
content = xmlXPathCastNodeToString(node);
node = NULL ;
epgdataid = atoi((char *)content);
xmlFree(content);
retval = xmlTextReaderNext(reader); // jump to end element
retval = xmlTextReaderNext(reader); // jump to next start element
node = xmlTextReaderExpand(reader);
content = xmlXPathCastNodeToString(node);
node = NULL ;
value = string((char *)content);
xmlFree(content);
datamap[epgdataid] = value;
}
return 0 ;
}
/*
xar_process_subdocument - check TOC for xml subdocument. If found, extract and
scan in memory.
Parameters:
reader - xmlTextReaderPtr
ctx - pointer to cli_ctx
Returns:
CL_SUCCESS - subdoc found and clean scan (or virus found and SCAN_ALL), or no subdocument
other - error return code from cli_mem_scandesc()
*/
static int xar_scan_subdocuments(xmlTextReaderPtr reader, cli_ctx *ctx)
{
int rc = CL_SUCCESS, subdoc_len, fd;
xmlChar * subdoc;
const xmlChar *name;
char * tmpname;
while (xmlTextReaderRead(reader) == 1) {
name = xmlTextReaderConstLocalName(reader);
if (name == NULL) {
cli_dbgmsg("cli_scanxar: xmlTextReaderConstLocalName() no name.\n");
rc = CL_EFORMAT;
break;
}
if (xmlStrEqual(name, (const xmlChar *)"toc") &&
xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT)
return CL_SUCCESS;
if (xmlStrEqual(name, (const xmlChar *)"subdoc") &&
xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT) {
subdoc = xmlTextReaderReadInnerXml(reader);
if (subdoc == NULL) {
cli_dbgmsg("cli_scanxar: no content in subdoc element.\n");
xmlTextReaderNext(reader);
continue;
}
subdoc_len = xmlStrlen(subdoc);
cli_dbgmsg("cli_scanxar: in-memory scan of xml subdocument, len %i.\n", subdoc_len);
rc = cli_mem_scandesc(subdoc, subdoc_len, ctx);
if (rc == CL_VIRUS && SCAN_ALL)
rc = CL_SUCCESS;
/* make a file to leave if --leave-temps in effect */
if(ctx->engine->keeptmp) {
if ((rc = cli_gentempfd(ctx->engine->tmpdir, &tmpname, &fd)) != CL_SUCCESS) {
cli_dbgmsg("cli_scanxar: Can't create temporary file for subdocument.\n");
} else {
cli_dbgmsg("cli_scanxar: Writing subdoc to temp file %s.\n", tmpname);
if (cli_writen(fd, subdoc, subdoc_len) < 0) {
cli_dbgmsg("cli_scanxar: cli_writen error writing subdoc temporary file.\n");
rc = CL_EWRITE;
}
rc = xar_cleanup_temp_file(ctx, fd, tmpname);
}
}
xmlFree(subdoc);
if (rc != CL_SUCCESS)
return rc;
xmlTextReaderNext(reader);
}
}
return rc;
}
static int xmlTextReaderSkipElement(xmlTextReaderPtr reader) {
int status = xmlTextReaderNext(reader);
while (status && xmlTextReaderNodeType(reader) != XML_READER_TYPE_ELEMENT && xmlTextReaderNodeType(reader) != XML_READER_TYPE_END_ELEMENT) {
status = xmlTextReaderRead(reader);
}
return status;
}
gboolean
xml_reader_read_to_next (XmlReader *reader)
{
g_return_val_if_fail (XML_IS_READER (reader), FALSE);
return (xmlTextReaderNext (reader->xml) == 1);
}
static int parse_properties(xmlTextReaderPtr reader, tmx_property **prop_headadr) {
tmx_property *res;
int curr_depth;
const char *name;
curr_depth = xmlTextReaderDepth(reader);
/* Parse each child */
do {
if (xmlTextReaderRead(reader) != 1) return 0; /* error_handler has been called */
if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT) {
name = (char*)xmlTextReaderConstName(reader);
if (!strcmp(name, "property")) {
if (!(res = alloc_prop())) return 0;
res->next = *prop_headadr;
*prop_headadr = res;
if (!parse_property(reader, res)) return 0;
} else { /* Unknow element, skip its tree */
if (xmlTextReaderNext(reader) != 1) return 0;
}
}
} while (xmlTextReaderNodeType(reader) != XML_READER_TYPE_END_ELEMENT ||
xmlTextReaderDepth(reader) != curr_depth);
return 1;
}
/**
* Gets the title from the parser. Returns true if success, false if EOF
*/
bool getTitle (xmlTextReaderPtr xmlReader, int *moreWiki, GString* articleTitle) {
// loops until it finds the title tag or EOF
// one tree at a time, skips sub trees
while (1 == *moreWiki) {
// loops until xmlReader is back down to level 2
// one node at a time
while (1 == *moreWiki && 2 > xmlTextReaderDepth (xmlReader)) {
*moreWiki = xmlTextReaderRead (xmlReader);
}
// loops until it finds the title tag, end of subtree or EOF
// one tree at a time, skips sub trees
while (1 == *moreWiki && 2 <= xmlTextReaderDepth (xmlReader)) {
if (xmlStrEqual(xmlTextReaderConstName(xmlReader), (const unsigned char *) "title")) {
*moreWiki = xmlTextReaderRead(xmlReader);
articleTitle = g_string_assign(articleTitle, (gchar *) xmlTextReaderConstValue(xmlReader));
return (1 == *moreWiki);
}
*moreWiki = xmlTextReaderNext(xmlReader);
}
}
// this should only happen at the end of the document
return (1 == *moreWiki);
}
void XmlTextReader::Skip() const {
XmlCheck(xmlTextReaderNext(ToReader(m_p)));
/*!!!
int depth = Depth();
while (Read() && Depth()>depth)
;
if (Depth() > depth)
throw runtime_error("invalid XML");*/
}
xmlNodePtr ProtoXml::IterParser::GetNext()
{
//TRACE("enter ProtoXml::IterParser::GetNext() prev_node:%s\n", prev_node ? (const char*)prev_node->name : "(null)");
int result;
// If we didn't just return a "prev_node", then read the
// very next sequential node w/ xmlTextReaderRead(), else
// skip entire "prev_node" sub-tree w/ xmlTextReaderNext()
if (NULL == prev_node)
result = xmlTextReaderRead(reader_ptr);
else
result = xmlTextReaderNext(reader_ptr);
prev_node = NULL;
switch (result)
{
case 0:
return NULL;
case -1:
PLOG(PL_ERROR, "ProtoXml::IterParser::GetNext() xmlTextReaderRead error!\n");
return NULL;
default:
break;
}
do
{
int nodeType = xmlTextReaderNodeType(reader_ptr);
if (XML_READER_TYPE_ELEMENT != nodeType)
continue;
const char* nodeName = (const char*)xmlTextReaderConstLocalName(reader_ptr);
if (NULL == nodeName)
{
PLOG(PL_ERROR, "ProtoXml::IterParser::GetNext() xmlTextReaderConstLocalName() error\n");
return NULL;
}
int nodeDepth = xmlTextReaderDepth(reader_ptr);
if (nodeDepth < 0)
{
PLOG(PL_ERROR, "ProtoXml::IterParser::GetNext() xmlTextReaderDepth() error\n");
return NULL;
}
if (!IterFilterBase::UpdateCurrentPath(nodeDepth, nodeName))
{
PLOG(PL_WARN, "ProtoXml::IterParser::GetNext() error: unable to update current path\n");
continue;
}
if (!IterFilterBase::IsMatch())
continue; // no match, so continue
prev_node = xmlTextReaderExpand(reader_ptr);
if (NULL == prev_node)
PLOG(PL_ERROR, "ProtoXml::IterParser::GetNext() xmlTextReaderExpand() error!\n");
return prev_node;
} while ((result = xmlTextReaderRead(reader_ptr)) > 0);
if (result < 0)
PLOG(PL_ERROR, "ProtoXml::IterParser::GetNext() xmlTextReaderRead() error!\n");
return NULL;
} // end ProtoXml::IterParser::GetNext()
//Parse dl values
void parse_ac_settings(int DevNameIndex, char *filename) {
xmlTextReaderPtr reader;
int ret;
reader = xmlReaderForFile(filename, NULL, XML_PARSE_NOWARNING | XML_PARSE_NOERROR); /* Dont validate with the DTD */
// Init some variables (-1 means no settings in xml file)
DevNames[DevNameIndex].dl_launch_ind = -1;
DevNames[DevNameIndex].kill_thr_ind = -1;
DevNames[DevNameIndex].flight_altitude_ind = -1;
xmlChar *name, *value;
if (reader != NULL) {
ret = xmlTextReaderRead(reader);
int valind = 0;
while (ret == 1) {
name = xmlTextReaderName(reader);
if (name == NULL) {
name = xmlStrdup(BAD_CAST "--");
}
if (xmlStrEqual(name, (const xmlChar *)"dl_setting")) {
xmlTextReaderMoveToAttribute(reader,(const xmlChar *)"var");
value = xmlTextReaderValue(reader);
if (xmlStrEqual(value, (const xmlChar *)"launch")) {
DevNames[DevNameIndex].dl_launch_ind=valind;
}
if (xmlStrEqual(value, (const xmlChar *)"kill_throttle")) {
DevNames[DevNameIndex].kill_thr_ind=valind;
}
if (xmlStrEqual(value, (const xmlChar *)"flight_altitude")) {
DevNames[DevNameIndex].flight_altitude_ind=valind;
}
xmlTextReaderNext(reader);
valind+=1;
}
ret = xmlTextReaderRead(reader);
}
xmlFreeTextReader(reader);
if (ret != 0) {
if (verbose) {
printf("App Server: %s : failed to parse\n", filename);
fflush(stdout);
}
}
}
else {
if (verbose) {
printf("App Server: Unable to open %s\n", filename);
fflush(stdout);
}
}
}
bool c_XMLReader::t_next(const String& localname /*= null_string*/) {
if (m_ptr) {
int ret = xmlTextReaderNext(m_ptr);
while (!localname.empty() && ret == 1) {
if (xmlStrEqual(xmlTextReaderConstLocalName(m_ptr), (xmlChar *)localname.data())) {
return true;
}
ret = xmlTextReaderNext(m_ptr);
}
if (ret == -1) {
raise_warning("An Error Occured while reading");
return false;
} else {
return ret;
}
}
raise_warning("Load Data before trying to read");
return false;
}
/**
* Parses the XML tree until it finds an article body, and sets the article body to what is found in the XML
*/
void getArticleBody (xmlTextReaderPtr xmlReader, int *moreWiki, GString* articleBody) {
*moreWiki = xmlTextReaderRead(xmlReader); // at level 2, need to drop to 3
// loops until it finds the text tag or EOF
// one tree at a time, skips sub trees
do {*moreWiki = xmlTextReaderNext(xmlReader);}
while (1 == *moreWiki && !(xmlStrEqual(xmlTextReaderConstName(xmlReader), (const unsigned char *) "text")));
*moreWiki = xmlTextReaderRead(xmlReader);
articleBody = g_string_assign(articleBody, (gchar *) xmlTextReaderConstValue(xmlReader));
}
/* {{{ proto boolean XMLReader::next([string localname])
Moves the position of the current instance to the next node in the stream. */
PHP_METHOD(xmlreader, next)
{
zval *id;
int retval;
size_t name_len=0;
xmlreader_object *intern;
char *name = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "|s", &name, &name_len) == FAILURE) {
return;
}
id = getThis();
intern = Z_XMLREADER_P(id);
if (intern != NULL && intern->ptr != NULL) {
#if LIBXML_VERSION <= 20617
/* Bug in libxml prevents a next in certain cases when positioned on end of element */
if (xmlTextReaderNodeType(intern->ptr) == XML_READER_TYPE_END_ELEMENT) {
retval = xmlTextReaderRead(intern->ptr);
} else
#endif
retval = xmlTextReaderNext(intern->ptr);
while (name != NULL && retval == 1) {
if (xmlStrEqual(xmlTextReaderConstLocalName(intern->ptr), (xmlChar *)name)) {
RETURN_TRUE;
}
retval = xmlTextReaderNext(intern->ptr);
}
if (retval == -1) {
RETURN_FALSE;
} else {
RETURN_BOOL(retval);
}
}
php_error_docref(NULL, E_WARNING, "Load Data before trying to read");
RETURN_FALSE;
}
/**
* Determines if the page is a redirect
* returns true if the page is a redirect
*/
bool isNotRedirect (xmlTextReaderPtr xmlReader, int *moreWiki) {
// loops until it finds the redirect tag, revision tag, or EOF
// one tree at a time, skips sub trees
while (1 == *moreWiki) {
// printf("loc31\n");
if (xmlStrEqual(xmlTextReaderConstName(xmlReader), (const unsigned char *) "revision")) {
return TRUE;} // drop out of loop, assign body
else if (xmlStrEqual(xmlTextReaderConstName(xmlReader), (const unsigned char *) "redirect")) {
return FALSE;} //redirect tag, to to next page
*moreWiki = xmlTextReaderNext(xmlReader);
}
// this should never happen
return FALSE;
}
/**
* Determines if the namespace is 0 (namespace of articles)
* returns true if the NS is 0
*/
bool isNameSpaceZero (xmlTextReaderPtr xmlReader, int *moreWiki) {
// loops until it finds the NS tag or EOF
// one tree at a time, skips sub trees
while (1 == *moreWiki) {
*moreWiki = xmlTextReaderNext(xmlReader);
//printf("loc21\n");
if (xmlStrEqual(xmlTextReaderConstName(xmlReader), (const unsigned char *) "ns")) {
break;}
}
*moreWiki = xmlTextReaderRead(xmlReader);
return (xmlStrEqual(xmlTextReaderConstValue(xmlReader), (const unsigned char *) "0")
&& (1 == *moreWiki));
}
static int parse_tile(xmlTextReaderPtr reader, tmx_tile **tile_headadr, const char *filename) {
tmx_tile *res = NULL;
int curr_depth;
const char *name;
char *value;
curr_depth = xmlTextReaderDepth(reader);
if (!(res = alloc_tile())) return 0;
while (*tile_headadr) {
tile_headadr = &((*tile_headadr)->next);
}
*tile_headadr = res;
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"id"))) { /* id */
res->id = atoi(value);
tmx_free_func(value);
}
else {
tmx_err(E_MISSEL, "xml parser: missing 'id' attribute in the 'tile' element");
return 0;
}
do {
if (xmlTextReaderRead(reader) != 1) return 0; /* error_handler has been called */
if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT) {
name = (char*)xmlTextReaderConstName(reader);
if (!strcmp(name, "properties")) {
if (!parse_properties(reader, &(res->properties))) return 0;
}
else if (!strcmp(name, "image")) {
if (!parse_image(reader, &(res->image), 0, filename)) return 0;
}
else {
/* Unknow element, skip its tree */
if (xmlTextReaderNext(reader) != 1) return 0;
}
}
} while (xmlTextReaderNodeType(reader) != XML_READER_TYPE_END_ELEMENT ||
xmlTextReaderDepth(reader) != curr_depth);
return 1;
}
static gboolean
read_service_file (xmlTextReaderPtr reader, AgService *service)
{
const xmlChar *name;
int ret;
ret = xmlTextReaderRead (reader);
while (ret == 1)
{
name = xmlTextReaderConstName (reader);
if (G_LIKELY (name &&
strcmp ((const gchar *)name, "service") == 0))
{
return parse_service (reader, service);
}
ret = xmlTextReaderNext (reader);
}
return FALSE;
}
daeElementRef
daeLIBXMLPlugin::nextElement(daeMetaElement* thisMetaElement, xmlTextReaderPtr reader)
{
int ret;
// Process the current element
// Skip over things we don't understand
while(xmlTextReaderNodeType(reader) != XML_READER_TYPE_ELEMENT)
{
ret = xmlTextReaderRead(reader);
if(ret != 1)
return(NULL);
}
// Create the element that we found
daeElementRef element = thisMetaElement->create((const daeString)xmlTextReaderConstName(reader));
if(!element)
{
const xmlChar * mine =xmlTextReaderConstName(reader);
char err[256];
memset( err, 0, 256 );
#if LIBXML_VERSION >= 20620
sprintf(err,"The DOM was unable to create an element type %s at line %d\nProbably a schema violation.\n", mine,xmlTextReaderGetParserLineNumber(reader));
#else
sprintf(err,"The DOM was unable to create an element type %s\nProbably a schema violation.\n", mine);
#endif
daeErrorHandler::get()->handleWarning( err );
if ( xmlTextReaderNext(reader) == -1 ) {
int x = 12312412;
}
return NULL;
}
int currentDepth = xmlTextReaderDepth(reader);
//try and read attributes
readAttributes( element, reader );
ret = xmlTextReaderRead(reader);
// If we're out of data, return the element
if(ret != 1)
return(element);
// Read all the tags that are part of this tag
bool trew = true;
while(trew)
{
int thisType = xmlTextReaderNodeType(reader);
if(thisType == XML_READER_TYPE_ELEMENT)
{
// Is the new element at the same depth as this one?
if(currentDepth == xmlTextReaderDepth(reader))
{
// Same depth means the current element ended in a /> so this is a sibling
// so we return and let our parent process it.
return(element);
}
else
{
// The element is a child of this one, so we recurse
if(!element->placeElement(nextElement(element->getMeta(), reader)))
{
char err[256];
memset( err, 0, 256 );
#if LIBXML_VERSION >= 20620
sprintf(err,"placeElement failed at line %d\n", xmlTextReaderGetParserLineNumber(reader));
#else
sprintf(err,"placeElement failed\n");
#endif
daeErrorHandler::get()->handleWarning( err );
ret = xmlTextReaderRead(reader);
if ( ret != 1 ) {
return element;
}
}
}
}
else if(thisType == XML_READER_TYPE_TEXT)
{
readValue( element, reader );
}
else if(thisType == XML_READER_TYPE_END_ELEMENT)
{
// Done with this element so read again and return
ret = xmlTextReaderRead(reader);
return(element);
}
else
{ // Skip element types we don't care about
ret = xmlTextReaderRead(reader);
// If we're out of data, return the element
if(ret != 1)
return(element);
}
}
//program will never get here but this line is needed to supress a warning
return NULL;
}
static tmx_map *parse_root_map(xmlTextReaderPtr reader, const char *filename) {
tmx_map *res = NULL;
int curr_depth;
const char *name;
char *value;
name = (char*) xmlTextReaderConstName(reader);
curr_depth = xmlTextReaderDepth(reader);
if (strcmp(name, "map")) {
tmx_err(E_XDATA, "xml parser: root is not a 'map' element");
return NULL;
}
if (!(res = alloc_map())) return NULL;
/* parses each attribute */
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"orientation"))) { /* orientation */
if (res->orient = parse_orient(value), res->orient == O_NONE) {
tmx_err(E_XDATA, "xml parser: unsupported 'orientation' '%s'", value);
goto cleanup;
}
tmx_free_func(value);
} else {
tmx_err(E_MISSEL, "xml parser: missing 'orientation' attribute in the 'map' element");
goto cleanup;
}
value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"renderorder"); /* renderorder */
if (res->renderorder = parse_renderorder(value), res->renderorder == R_NONE) {
tmx_err(E_XDATA, "xml parser: unsupported 'renderorder' '%s'", value);
goto cleanup;
}
tmx_free_func(value);
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"height"))) { /* height */
res->height = atoi(value);
tmx_free_func(value);
} else {
tmx_err(E_MISSEL, "xml parser: missing 'height' attribute in the 'map' element");
goto cleanup;
}
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"width"))) { /* width */
res->width = atoi(value);
tmx_free_func(value);
} else {
tmx_err(E_MISSEL, "xml parser: missing 'width' attribute in the 'map' element");
goto cleanup;
}
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"tileheight"))) { /* tileheight */
res->tile_height = atoi(value);
tmx_free_func(value);
} else {
tmx_err(E_MISSEL, "xml parser: missing 'tileheight' attribute in the 'map' element");
goto cleanup;
}
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"tilewidth"))) { /* tilewidth */
res->tile_width = atoi(value);
tmx_free_func(value);
} else {
tmx_err(E_MISSEL, "xml parser: missing 'tilewidth' attribute in the 'map' element");
goto cleanup;
}
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"backgroundcolor"))) { /* backgroundcolor */
res->backgroundcolor = get_color_rgb(value);
tmx_free_func(value);
}
/* Parse each child */
do {
if (xmlTextReaderRead(reader) != 1) goto cleanup; /* error_handler has been called */
if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT) {
name = (char*)xmlTextReaderConstName(reader);
if (!strcmp(name, "tileset")) {
if (!parse_tileset(reader, &(res->ts_head), filename)) goto cleanup;
} else if (!strcmp(name, "layer")) {
if (!parse_layer(reader, &(res->ly_head), res->height, res->width, L_LAYER, filename)) goto cleanup;
} else if (!strcmp(name, "objectgroup")) {
if (!parse_layer(reader, &(res->ly_head), res->height, res->width, L_OBJGR, filename)) goto cleanup;
} else if (!strcmp(name, "imagelayer")) {
if (!parse_layer(reader, &(res->ly_head), res->height, res->width, L_IMAGE, filename)) goto cleanup;
} else if (!strcmp(name, "properties")) {
if (!parse_properties(reader, &(res->properties))) goto cleanup;
} else {
/* Unknow element, skip its tree */
if (xmlTextReaderNext(reader) != 1) goto cleanup;
}
}
} while (xmlTextReaderNodeType(reader) != XML_READER_TYPE_END_ELEMENT ||
xmlTextReaderDepth(reader) != curr_depth);
return res;
cleanup:
tmx_map_free(res);
return NULL;
}
/* Parse the configuration file. */
int sechk_lib_parse_xml_file(const char *filename, sechk_lib_t * lib)
{
xmlTextReaderPtr reader = NULL;
xmlDtdPtr dtd = NULL;
xmlDocPtr xml = NULL;
xmlValidCtxtPtr ctxt = NULL;
int tmp, ret = 0;
char *dtd_path = NULL;
/* this initializes the XML library and checks potential ABI mismatches
* between the version it was compiled for and the actual shared
* library used. */
LIBXML_TEST_VERSION;
reader = xmlReaderForFile(filename, NULL, 0);
if (!reader) {
ret = errno;
if (ret != ENOENT)
fprintf(stderr, "Error: Could not create xmlReader.\n");
goto exit_err;
}
dtd_path = build_dtd_path();
if (!dtd_path) {
fprintf(stderr, "Error: getting DTD path\n");
goto exit_err;
}
dtd = xmlParseDTD(NULL, (const xmlChar *)dtd_path);
free(dtd_path);
if (!dtd) {
fprintf(stderr, "Error: parsing DTD\n");
goto exit_err;
}
xml = xmlParseFile(filename);
if (!xml) {
fprintf(stderr, "Error: parsing sechecker profile\n");
goto exit_err;
}
ctxt = xmlNewValidCtxt();
if (!ctxt) {
fprintf(stderr, "Error: out of memory\n");
goto exit_err;
}
/* validate profile against the DTD */
if (xmlValidateDtd(ctxt, xml, dtd) == 0) {
fprintf(stderr, "Error: SEChecker profile contains invalid XML. Aborting.\n");
goto exit_err;
}
xmlFreeValidCtxt(ctxt);
xmlFreeDoc(xml);
xmlFreeDtd(dtd);
while (1) {
ret = xmlTextReaderRead(reader);
if (ret == -1) {
ret = errno;
fprintf(stderr, "Error: Error reading xml.\n");
goto exit_err;
}
if (ret == 0) /* no more nodes to read */
break;
tmp = sechk_lib_process_xml_node(reader, lib);
if (tmp == -1)
goto exit_err;
if (tmp == 1) {
ret = xmlTextReaderNext(reader);
if (ret == 0)
break;
if (ret == -1) {
ret = errno;
fprintf(stderr, "Error in xmlTextReaderNext()\n");
goto exit_err;
}
}
}
/* cleanup function for the XML library */
xmlCleanupParser();
xmlFreeTextReader(reader);
return 0;
exit_err:
xmlCleanupParser();
if (reader)
xmlFreeTextReader(reader);
if (ret)
errno = ret;
return -1;
}
daeElementRef
daeLIBXMLPlugin::startParse(daeMetaElement* thisMetaElement, xmlTextReaderPtr reader)
{
// The original parsing system would drop everything up to the first element open, usually <COLLADA>
// This behavior will have to be replicated here till we have someplace to put the headers/comments
int ret = xmlTextReaderRead(reader);
if(ret != 1)
{
// empty or hit end of file
return NULL;
}
//printf("xmlTextReaderConstBaseUri is %s\n",xmlTextReaderConstBaseUri(reader));
//printf("xmlTextReaderConstNamespaceUri is %s\n",xmlTextReaderConstNamespaceUri(reader));
//printf("xmlTextReaderConstPrefix is %s\n",xmlTextReaderConstPrefix(reader));
//printf("xmlTextReaderName is %s\n",xmlTextReaderName(reader));
// Process the current element
// Skip over things we don't understand
while(xmlTextReaderNodeType(reader) != XML_READER_TYPE_ELEMENT)
{
ret = xmlTextReaderRead(reader);
if(ret != 1)
return(NULL);
}
// Create the element that we found
daeElementRef element = thisMetaElement->create((const daeString)xmlTextReaderConstName(reader));
if(!element)
{
char err[256];
memset( err, 0, 256 );
const xmlChar * mine =xmlTextReaderConstName(reader);
#if LIBXML_VERSION >= 20620
sprintf(err,"The DOM was unable to create an element type %s at line %d\nProbably a schema violation.\n", mine,xmlTextReaderGetParserLineNumber(reader));
#else
sprintf(err,"The DOM was unable to create an element type %s\nProbably a schema violation.\n", mine);
#endif
daeErrorHandler::get()->handleWarning( err );
xmlTextReaderNext(reader);
return NULL;
}
int currentDepth = xmlTextReaderDepth(reader);
//try and read attributes
readAttributes( element, reader );
//Check COLLADA Version
if ( strcmp( element->getTypeName(), "COLLADA" ) != 0 ) {
//invalid root
daeErrorHandler::get()->handleError("Loading document with invalid root element!");
return NULL;
}
daeURI *xmlns = (daeURI*)(element->getMeta()->getMetaAttribute( "xmlns" )->getWritableMemory( element ));
if ( strcmp( xmlns->getURI(), COLLADA_NAMESPACE ) != 0 ) {
//invalid COLLADA version
daeErrorHandler::get()->handleError("Trying to load an invalid COLLADA version for this DOM build!");
return NULL;
}
ret = xmlTextReaderRead(reader);
// If we're out of data, return the element
if(ret != 1)
return(element);
// Read all the tags that are part of this tag
bool trew = true;
while(trew)
{
int thisType = xmlTextReaderNodeType(reader);
if(thisType == XML_READER_TYPE_ELEMENT)
{
// Is the new element at the same depth as this one?
if(currentDepth == xmlTextReaderDepth(reader))
{
// Same depth means the current element ended in a /> so this is a sibling
// so we return and let our parent process it.
return(element);
}
else
{
// The element is a child of this one, so we recurse
if(!element->placeElement(nextElement(element->getMeta(), reader)))
{
char err[256];
memset( err, 0, 256 );
#if LIBXML_VERSION >= 20620
sprintf(err,"placeElement failed at line %d\n", xmlTextReaderGetParserLineNumber(reader));
#else
sprintf(err,"placeElement failed\n");
#endif
daeErrorHandler::get()->handleWarning(err);
ret = xmlTextReaderRead(reader);
if ( ret != 1 ) {
return element;
}
}
}
}
else if(thisType == XML_READER_TYPE_TEXT)
{
readValue( element, reader );
}
else if(thisType == XML_READER_TYPE_END_ELEMENT)
{
// Done with this element so read again and return
ret = xmlTextReaderRead(reader);
return(element);
}
else
{ // Skip element types we don't care about
ret = xmlTextReaderRead(reader);
// If we're out of data, return the element
if(ret != 1)
return(element);
}
}
// Return NULL on an error
return NULL;
}
void nextNode()
{
xmlTextReaderNext(reader);
}
/*
* call-seq:
* reader.next -> code
*
* Skip to the node following the current one in document order while avoiding
* the subtree if any.
*/
static VALUE rxml_reader_next(VALUE self)
{
return INT2FIX(xmlTextReaderNext(rxml_text_reader_get(self)));
}
/*
* call-seq:
* reader.next -> code
*
* Skip to the node following the current one in document order while avoiding
* the subtree if any.
*/
static VALUE rxml_reader_next(VALUE self)
{
xmlTextReaderPtr xreader = rxml_text_reader_get(self);
return INT2FIX(xmlTextReaderNext(xreader));
}
/* reader:next_node() */
static int xmlreader_next_node(lua_State *L) {
xmlreader xr = check_xmlreader(L, 1);
int ret = xmlTextReaderNext(xr);
BOOL_OR_ERROR(L, ret);
}
static int parse_object(xmlTextReaderPtr reader, tmx_object *obj) {
int curr_depth;
const char *name;
char *value;
/* parses each attribute */
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"x"))) { /* x */
obj->x = atof(value);
tmx_free_func(value);
} else {
tmx_err(E_MISSEL, "xml parser: missing 'x' attribute in the 'object' element");
return 0;
}
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"y"))) { /* y */
obj->y = atof(value);
tmx_free_func(value);
} else {
tmx_err(E_MISSEL, "xml parser: missing 'y' attribute in the 'object' element");
return 0;
}
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"name"))) { /* name */
obj->name = value;
}
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"visible"))) { /* visible */
obj->visible = (char)atoi(value);
tmx_free_func(value);
}
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"height"))) { /* height */
obj->shape = S_SQUARE;
obj->height = atof(value);
tmx_free_func(value);
}
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"width"))) { /* width */
obj->width = atof(value);
tmx_free_func(value);
}
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"gid"))) { /* gid */
obj->shape = S_TILE;
obj->gid = atoi(value);
tmx_free_func(value);
}
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"rotation"))) { /* rotation */
obj->rotation = atof(value);
tmx_free_func(value);
}
/* If it has a child, then it's a polygon or a polyline or an ellipse */
curr_depth = xmlTextReaderDepth(reader);
if (!xmlTextReaderIsEmptyElement(reader)) {
do {
if (xmlTextReaderRead(reader) != 1) return 0; /* error_handler has been called */
if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT) {
name = (char*)xmlTextReaderConstName(reader);
if (!strcmp(name, "properties")) {
if (!parse_properties(reader, &(obj->properties))) return 0;
} else if (!strcmp(name, "ellipse")) {
obj->shape = S_ELLIPSE;
} else {
if (!strcmp(name, "polygon")) {
obj->shape = S_POLYGON;
} else if (!strcmp(name, "polyline")) {
obj->shape = S_POLYLINE;
}
/* Unknow element, skip its tree */
else if (xmlTextReaderNext(reader) != 1) return 0;
if (!parse_points(reader, &(obj->points), &(obj->points_len))) return 0;
}
}
} while (xmlTextReaderNodeType(reader) != XML_READER_TYPE_END_ELEMENT ||
xmlTextReaderDepth(reader) != curr_depth);
}
return 1;
}
/* parse layers and objectgroups */
static int parse_layer(xmlTextReaderPtr reader, tmx_layer **layer_headadr, int map_h, int map_w, enum tmx_layer_type type, const char *filename) {
tmx_layer *res;
tmx_object *obj;
int curr_depth;
const char *name;
char *value;
curr_depth = xmlTextReaderDepth(reader);
if (!(res = alloc_layer())) return 0;
res->type = type;
while(*layer_headadr) {
layer_headadr = &((*layer_headadr)->next);
}
*layer_headadr = res;
/* parses each attribute */
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"name"))) { /* name */
res->name = value;
} else {
tmx_err(E_MISSEL, "xml parser: missing 'name' attribute in the 'layer' element");
return 0;
}
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"visible"))) { /* visible */
res->visible = (char)atoi(value);
tmx_free_func(value);
}
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"opacity"))) { /* opacity */
res->opacity = (float)strtod(value, NULL);
tmx_free_func(value);
}
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"color"))) { /* color */
res->color = get_color_rgb(value);
tmx_free_func(value);
}
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"x"))) { /* x_offset */
res->x_offset = (int)atoi(value);
tmx_free_func(value);
}
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"y"))) { /* y_offset */
res->y_offset = (int)atoi(value);
tmx_free_func(value);
}
do {
if (xmlTextReaderRead(reader) != 1) return 0; /* error_handler has been called */
if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT) {
name = (char*)xmlTextReaderConstName(reader);
if (!strcmp(name, "properties")) {
if (!parse_properties(reader, &(res->properties))) return 0;
} else if (!strcmp(name, "data")) {
if (!parse_data(reader, &(res->content.gids), map_h * map_w)) return 0;
} else if (!strcmp(name, "image")) {
if (!parse_image(reader, &(res->content.image), 0, filename)) return 0;
} else if (!strcmp(name, "object")) {
if (!(obj = alloc_object())) return 0;
obj->next = res->content.head;
res->content.head = obj;
if (!parse_object(reader, obj)) return 0;
} else {
/* Unknow element, skip its tree */
if (xmlTextReaderNext(reader) != 1) return 0;
}
}
} while (xmlTextReaderNodeType(reader) != XML_READER_TYPE_END_ELEMENT ||
xmlTextReaderDepth(reader) != curr_depth);
return 1;
}
/* parses a tileset within the tmx file or in a dedicated tsx file */
static int parse_tileset_sub(xmlTextReaderPtr reader, tmx_tileset *ts_addr, const char *filename) {
int curr_depth;
const char *name;
char *value;
curr_depth = xmlTextReaderDepth(reader);
/* parses each attribute */
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"name"))) { /* name */
ts_addr->name = value;
} else {
tmx_err(E_MISSEL, "xml parser: missing 'name' attribute in the 'tileset' element");
return 0;
}
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"tilewidth"))) { /* tile_width */
ts_addr->tile_width = atoi(value);
tmx_free_func(value);
} else {
tmx_err(E_MISSEL, "xml parser: missing 'tilewidth' attribute in the 'tileset' element");
return 0;
}
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"tileheight"))) { /* tile_height */
ts_addr->tile_height = atoi(value);
tmx_free_func(value);
} else {
tmx_err(E_MISSEL, "xml parser: missing 'tileheight' attribute in the 'tileset' element");
return 0;
}
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"spacing"))) { /* spacing */
ts_addr->spacing = atoi(value);
tmx_free_func(value);
}
if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"margin"))) { /* margin */
ts_addr->margin = atoi(value);
tmx_free_func(value);
}
/* Parse each child */
do {
if (xmlTextReaderRead(reader) != 1) return 0; /* error_handler has been called */
if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT) {
name = (char*)xmlTextReaderConstName(reader);
if (!strcmp(name, "image")) {
if (!parse_image(reader, &(ts_addr->image), 1, filename)) return 0;
} else if (!strcmp(name, "tileoffset")) {
if (!parse_tileoffset(reader, &(ts_addr->x_offset), &(ts_addr->y_offset))) return 0;
} else if (!strcmp(name, "properties")) {
if (!parse_properties(reader, &(ts_addr->properties))) return 0;
} else if (!strcmp(name, "tile")) {
if (!parse_tile(reader, &(ts_addr->tiles), filename)) return 0;
} else {
/* Unknown element, skip its tree */
if (xmlTextReaderNext(reader) != 1) return 0;
}
}
} while (xmlTextReaderNodeType(reader) != XML_READER_TYPE_END_ELEMENT ||
xmlTextReaderDepth(reader) != curr_depth);
return 1;
}
