/*
* _gweather_parser_get_value:
* @parser: a #GWeatherParser
*
* Gets the text of the element whose start tag @parser is pointing to.
* Leaves @parser pointing at the next node after the element's end tag.
*
* Return value: the text of the current node, as a libxml-allocated
* string, or %NULL if the node is empty.
**/
char *
_gweather_parser_get_value (GWeatherParser *parser)
{
char *value;
/* check for null node */
if (xmlTextReaderIsEmptyElement (parser->xml))
return NULL;
/* the next "node" is the text node containing the value we want to get */
if (xmlTextReaderRead (parser->xml) != 1)
return NULL;
value = (char *) xmlTextReaderValue (parser->xml);
/* move on to the end of this node */
while (xmlTextReaderNodeType (parser->xml) != XML_READER_TYPE_END_ELEMENT) {
if (xmlTextReaderRead (parser->xml) != 1) {
xmlFree (value);
return NULL;
}
}
/* consume the end element too */
if (xmlTextReaderRead (parser->xml) != 1) {
xmlFree (value);
return NULL;
}
return value;
}
gboolean
xml_reader_is_empty_element (XmlReader *reader)
{
g_return_val_if_fail (XML_IS_READER (reader), FALSE);
return xmlTextReaderIsEmptyElement (reader->xml);
}
/**
* processNode:
* @reader: the xmlReader
*
* Dump information about the current node
*/
static void
processNode(xmlTextReaderPtr reader) {
const xmlChar *name, *value;
name = xmlTextReaderConstName(reader);
if (name == NULL)
name = BAD_CAST "--";
value = xmlTextReaderConstValue(reader);
printf("Depth: %d; Type: %d; Name: %s; %d|%d",
xmlTextReaderDepth(reader),
xmlTextReaderNodeType(reader),
name,
xmlTextReaderIsEmptyElement(reader),
xmlTextReaderHasValue(reader));
if (value == NULL)
printf("\n");
else {
if (xmlStrlen(value) > 40)
printf("|-> %.40s...\n", value);
else
printf(" %s\n", value);
}
}
/**
* Reads a SubnetConfigs from XML. The reader is assumed to be at the start element.
*
* @return the SubnetConfigs, or NULL in case of error.
*/
static struct full_ns0_subnetConfigs *xmlTextReaderReadNs0SubnetConfigsType(xmlTextReaderPtr reader) {
int status, depth;
void *_child_accessor;
struct full_ns0_subnetConfigs *_subnetConfigs = calloc(1, sizeof(struct full_ns0_subnetConfigs));
if (xmlTextReaderIsEmptyElement(reader) == 0) {
depth = xmlTextReaderDepth(reader);//track the depth.
status = xmlTextReaderAdvanceToNextStartOrEndElement(reader);
while (xmlTextReaderDepth(reader) > depth) {
if (status < 1) {
//panic: XML read error.
#if DEBUG_ENUNCIATE
printf("Failure to advance to next child element.\n");
#endif
freeNs0SubnetConfigsType(_subnetConfigs);
free(_subnetConfigs);
return NULL;
}
else if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT
&& xmlStrcmp(BAD_CAST "subnetConfig", xmlTextReaderConstLocalName(reader)) == 0
&& xmlTextReaderConstNamespaceUri(reader) == NULL) {
#if DEBUG_ENUNCIATE > 1
printf("Attempting to read choice {}subnetConfig of type {}subnetConfig.\n");
#endif
_child_accessor = xmlTextReaderReadNs0SubnetConfigType(reader);
if (_child_accessor == NULL) {
#if DEBUG_ENUNCIATE
printf("Failed to read choice {}subnetConfig of type {}subnetConfig.\n");
#endif
//panic: unable to read the child element for some reason.
freeNs0SubnetConfigsType(_subnetConfigs);
free(_subnetConfigs);
return NULL;
}
_subnetConfigs->subnetConfig = realloc(_subnetConfigs->subnetConfig, (_subnetConfigs->_sizeof_subnetConfig + 1) * sizeof(struct full_ns0_subnetConfig));
memcpy(&(_subnetConfigs->subnetConfig[_subnetConfigs->_sizeof_subnetConfig++]), _child_accessor, sizeof(struct full_ns0_subnetConfig));
free(_child_accessor);
status = xmlTextReaderAdvanceToNextStartOrEndElement(reader);
}
else {
#if DEBUG_ENUNCIATE > 1
if (xmlTextReaderConstNamespaceUri(reader) == NULL) {
printf("unknown child element {}%s for type {}subnetConfigs. Skipping...\n", xmlTextReaderConstLocalName(reader));
}
else {
printf("unknown child element {%s}%s for type {}subnetConfigs. Skipping...\n", xmlTextReaderConstNamespaceUri(reader), xmlTextReaderConstLocalName(reader));
}
#endif
status = xmlTextReaderSkipElement(reader);
}
}
}
return _subnetConfigs;
}
static void processNode(xmlTextReaderPtr reader, struct osmdata_t *osmdata) {
xmlChar *name;
name = xmlTextReaderName(reader);
if (name == NULL)
name = xmlStrdup(BAD_CAST "--");
switch(xmlTextReaderNodeType(reader)) {
case XML_READER_TYPE_ELEMENT:
StartElement(reader, name, osmdata);
if (xmlTextReaderIsEmptyElement(reader))
EndElement(name, osmdata); /* No end_element for self closing tags! */
break;
case XML_READER_TYPE_END_ELEMENT:
EndElement(name, osmdata);
break;
case XML_READER_TYPE_SIGNIFICANT_WHITESPACE:
/* Ignore */
break;
default:
fprintf(stderr, "Unknown node type %d\n", xmlTextReaderNodeType(reader));
break;
}
xmlFree(name);
}
// Return value: -1 if "state end found", otherwise depth of node
int XMLReader::gobbleUntilStartElement(xmlTextReaderPtr &reader, const string &name)
{
bool state_begin_found = false;
bool state_end_found = false;
int depth = -1;
int r = xmlTextReaderRead(reader);
while ( (r==1) && (!state_begin_found) && (!state_end_found) ) {
const int type = xmlTextReaderNodeType( reader );
depth = xmlTextReaderDepth(reader);
xmlChar *localName = xmlTextReaderLocalName(reader);
if (type==1) {
state_begin_found = (xmlStrEqual(localName, BAD_CAST name.c_str()) != 0);
if (state_begin_found)
state_end_found = (xmlTextReaderIsEmptyElement(reader) != 0);
} else
if (type==15) {
state_end_found = (xmlStrEqual(localName, BAD_CAST name.c_str()) != 0);
}
xmlFree(localName);
r=xmlTextReaderRead(reader);
}
if ( r==0)
state_end_found = true; // It makes no sense to have gotten to the beginning with r==0 at the same time
return state_begin_found && (!state_end_found) ? depth : -1;
}
/* -1 error; 0 OK */
int oscap_parser_text_value(xmlTextReaderPtr reader, oscap_xml_value_consumer consumer, void *user)
{
int depth = xmlTextReaderDepth(reader);
bool has_value = false;
int ret = 0;
if (xmlTextReaderIsEmptyElement(reader)) {
return ret;
}
xmlTextReaderRead(reader);
while (xmlTextReaderDepth(reader) > depth) {
int nodetype = xmlTextReaderNodeType(reader);
if (nodetype == XML_READER_TYPE_CDATA || nodetype == XML_READER_TYPE_TEXT) {
char *value = (char *)xmlTextReaderValue(reader);
(*consumer) (value, user);
oscap_free(value);
has_value = true;
}
if (xmlTextReaderRead(reader) != 1) {
ret = -1;
break;
}
}
if (!has_value)
(*consumer) ("", user);
return ret;
}
bool BEXMLTextReader::empty()
{
int empty = xmlTextReaderIsEmptyElement ( reader );
if ( empty == kBE_XMLReaderError ) {
throw BEXMLReaderInterface_Exception ( last_error() );
}
return empty == 1;
}
EPUB3Error EPUB3ProcessXMLReaderNodeForManifestInOPF(EPUB3Ref epub, xmlTextReaderPtr reader, EPUB3XMLParseContextPtr *context)
{
assert(epub != NULL);
assert(reader != NULL);
EPUB3Error error = kEPUB3Success;
const xmlChar *name = xmlTextReaderConstLocalName(reader);
xmlReaderTypes nodeType = xmlTextReaderNodeType(reader);
switch(nodeType)
{
case XML_READER_TYPE_ELEMENT:
{
if(!xmlTextReaderIsEmptyElement(reader)) {
(void)EPUB3SaveParseContext(context, kEPUB3OPFStateManifest, name, 0, NULL, kEPUB3_YES, NULL);
} else {
if(xmlStrcmp(name, BAD_CAST "item") == 0) {
EPUB3ManifestItemRef newItem = EPUB3ManifestItemCreate();
newItem->itemId = (char *)xmlTextReaderGetAttribute(reader, BAD_CAST "id");
newItem->href = (char *)xmlTextReaderGetAttribute(reader, BAD_CAST "href");
newItem->mediaType = (char *)xmlTextReaderGetAttribute(reader, BAD_CAST "media-type");
newItem->properties = (char *)xmlTextReaderGetAttribute(reader, BAD_CAST "properties");
if(newItem->properties != NULL) {
// Look for the cover-image property
char *prop, *props, *tofree;
tofree = props = strdup(newItem->properties);
while((prop = strsep(&props, " ")) != NULL) {
if(strcmp(prop, "cover-image") == 0) {
EPUB3MetadataSetCoverImageId(epub->metadata, newItem->itemId);
}
}
EPUB3_FREE_AND_NULL(tofree);
}
if(newItem->mediaType != NULL && strcmp(newItem->mediaType, "application/x-dtbncx+xml") == 0) {
//This is the ref for the ncx document. Set it for v2 epubs
//if(epub->metadata->version == kEPUB3Version_2) {
EPUB3MetadataSetNCXItem(epub->metadata, newItem);
//}
}
EPUB3ManifestInsertItem(epub->manifest, newItem);
}
}
break;
}
case XML_READER_TYPE_TEXT:
{
break;
}
case XML_READER_TYPE_END_ELEMENT:
{
(void)EPUB3PopAndFreeParseContext(context);
break;
}
default: break;
}
return error;
}
static int _exml_read(EXML *xml, xmlTextReaderPtr reader)
{
int empty;
xmlChar *name, *value;
if (!reader)
return -1;
exml_clear( xml );
while( xmlTextReaderRead( reader ) == 1 ) {
name = xmlTextReaderName(reader);
value = xmlTextReaderValue(reader);
empty = xmlTextReaderIsEmptyElement(reader);
switch( xmlTextReaderNodeType(reader) ) {
case XML_READER_TYPE_ELEMENT:
exml_start(xml);
exml_tag_set(xml, (char *) name);
if (xmlTextReaderHasAttributes(reader)) {
xmlTextReaderMoveToFirstAttribute(reader);
do {
xmlChar *attr_name, *attr_value;
attr_name = xmlTextReaderName(reader);
attr_value = xmlTextReaderValue(reader);
exml_attribute_set(xml, (char *) attr_name, (char *) attr_value);
xmlFree(attr_name);
xmlFree(attr_value);
} while( xmlTextReaderMoveToNextAttribute(reader) == 1 );
}
if (!empty)
break;
case XML_READER_TYPE_END_ELEMENT:
exml_end(xml);
break;
case XML_READER_TYPE_WHITESPACE:
break;
case XML_READER_TYPE_TEXT:
exml_value_set(xml, (char *) value);
break;
}
xmlFree(name);
xmlFree(value);
}
xmlTextReaderClose(reader);
xmlFreeTextReader(reader);
exml_goto_top( xml );
return TRUE;
}
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;
}
bool sc_xmltv_check_current_reader_node(xmlTextReaderPtr reader, int node_type, const char *node_name, int node_depth) {
xmlChar *name = NULL;
bool result;
name = xmlTextReaderName(reader);
result = !xmlTextReaderIsEmptyElement(reader) &&
xmlTextReaderNodeType(reader) == node_type &&
(!xmlStrcmp(name, (const xmlChar *) node_name)) &&
xmlTextReaderDepth(reader) == node_depth;
xmlFree(name);
return result;
}
/*
* call-seq:
* reader.empty_element? # => true or false
*
* Returns true if the current node is empty, otherwise false.
*/
static VALUE empty_element_p(VALUE self)
{
xmlTextReaderPtr reader;
Data_Get_Struct(self, xmlTextReader, reader);
if(xmlTextReaderIsEmptyElement(reader))
return Qtrue;
return Qfalse;
}
void Parse()
{
ReadNextNode();
WriteElement();
int nDepth = GetDepth();
if ( 0 == xmlTextReaderIsEmptyElement(reader) )
{
XmlNodeType eNodeType = XmlNodeType_None;
int nCurDepth = -1;
// У закрывающего тэга глубина на 1 больше, чем у открывающего
while( true )
{
if ( 1 != xmlTextReaderRead(reader) )
break;
int nTempType = xmlTextReaderNodeType(reader);
if(-1 == nTempType)
break;
eNodeType = (XmlNodeType)nTempType;
nCurDepth = GetDepth();
if ( eNodeType == XmlNodeType_Text || eNodeType == XmlNodeType_Whitespace || eNodeType == XmlNodeType_SIGNIFICANT_WHITESPACE )
m_pCurrentNode->m_sText += GetText();
else if (eNodeType == XmlNodeType_Element)
WriteElement();
else if (eNodeType == XmlNodeType_EndElement)
{
m_list.pop_back();
if (0 != m_list.size())
{
std::list<CXmlNodeBase*>::iterator iter = m_list.end();
--iter;
m_pCurrentNode = *iter;
}
else
{
m_pCurrentNode = m_pNode;
}
}
nCurDepth = GetDepth();
if ( nCurDepth < nDepth )
break;
if ( XmlNodeType_EndElement == eNodeType && nCurDepth == nDepth )
break;
}
}
}
ExtractionWay XMLParser::_ReadXMLWay() {
ExtractionWay way;
if ( xmlTextReaderIsEmptyElement( inputReader ) != 1 ) {
const int depth = xmlTextReaderDepth( inputReader );
while ( xmlTextReaderRead( inputReader ) == 1 ) {
const int childType = xmlTextReaderNodeType( inputReader );
if ( childType != 1 && childType != 15 ) {
continue;
}
const int childDepth = xmlTextReaderDepth( inputReader );
xmlChar* childName = xmlTextReaderName( inputReader );
if ( childName == NULL ) {
continue;
}
if ( depth == childDepth && childType == 15 && xmlStrEqual( childName, ( const xmlChar* ) "way" ) == 1 ) {
xmlChar* id = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "id" );
way.id = stringToUint((char*)id);
xmlFree(id);
xmlFree( childName );
break;
}
if ( childType != 1 ) {
xmlFree( childName );
continue;
}
if ( xmlStrEqual( childName, ( const xmlChar* ) "tag" ) == 1 ) {
xmlChar* k = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "k" );
xmlChar* value = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "v" );
// cout << "->k=" << k << ", v=" << value << endl;
if ( k != NULL && value != NULL ) {
way.keyVals.Add(std::string( (char *) k ), std::string( (char *) value));
}
if ( k != NULL ) {
xmlFree( k );
}
if ( value != NULL ) {
xmlFree( value );
}
} else if ( xmlStrEqual( childName, ( const xmlChar* ) "nd" ) == 1 ) {
xmlChar* ref = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "ref" );
if ( ref != NULL ) {
way.path.push_back( stringToUint(( const char* ) ref ) );
xmlFree( ref );
}
}
xmlFree( childName );
}
}
return way;
}
EPUB3Error EPUB3ProcessXMLReaderNodeForSpineInOPF(EPUB3Ref epub, xmlTextReaderPtr reader, EPUB3XMLParseContextPtr *context)
{
assert(epub != NULL);
assert(reader != NULL);
EPUB3Error error = kEPUB3Success;
const xmlChar *name = xmlTextReaderConstLocalName(reader);
xmlReaderTypes nodeType = xmlTextReaderNodeType(reader);
switch(nodeType)
{
case XML_READER_TYPE_ELEMENT:
{
if(!xmlTextReaderIsEmptyElement(reader)) {
(void)EPUB3SaveParseContext(context, kEPUB3OPFStateManifest, name, 0, NULL, kEPUB3_YES, NULL);
} else {
if(xmlStrcmp(name, BAD_CAST "itemref") == 0) {
EPUB3SpineItemRef newItem = EPUB3SpineItemCreate();
xmlChar * linear = xmlTextReaderGetAttribute(reader, BAD_CAST "linear");
if(linear == NULL || xmlStrcmp(linear, BAD_CAST "yes") == 0) {
newItem->isLinear = kEPUB3_YES;
epub->spine->linearItemCount++;
}
EPUB3_XML_FREE_AND_NULL(linear);
newItem->idref = (char *)xmlTextReaderGetAttribute(reader, BAD_CAST "idref");
if(newItem->idref != NULL) {
EPUB3ManifestItemListItemPtr manifestPtr = EPUB3ManifestFindItemWithId(epub->manifest, newItem->idref);
if(manifestPtr == NULL) {
newItem->manifestItem = NULL;
} else {
newItem->manifestItem = manifestPtr->item;
}
}
EPUB3SpineAppendItem(epub->spine, newItem);
}
}
break;
}
case XML_READER_TYPE_TEXT:
{
break;
}
case XML_READER_TYPE_END_ELEMENT:
{
(void)EPUB3PopAndFreeParseContext(context);
break;
}
default: break;
}
return error;
}
char *oscap_element_string_copy(xmlTextReaderPtr reader)
{
int t;
if (xmlTextReaderIsEmptyElement(reader))
return NULL;
t = xmlTextReaderNodeType(reader);
if (t == XML_ELEMENT_NODE || t == XML_ATTRIBUTE_NODE)
xmlTextReaderRead(reader);
if (xmlTextReaderHasValue(reader))
return (char *)xmlTextReaderValue(reader);
else
return (char *) calloc(1,1);
}
/**
* processNode:
* @reader: the xmlReader
*
* Dump information about the current node
*/
static void
processNode(xmlTextReaderPtr reader) {
const xmlChar *name, *value;
int nodetype;
static char spaces[33]=" ";
name = xmlTextReaderConstName(reader);
if (name == NULL)
name = BAD_CAST "--";
value = xmlTextReaderConstValue(reader);
nodetype = xmlTextReaderNodeType(reader);
if (nodetype!=14 && nodetype!=15) // Skip all text bodies and "/" entities.
{
#ifdef DETAILS
printf("%s%d %d %s %d %d",
(spaces + (32-2*xmlTextReaderDepth(reader))),
xmlTextReaderDepth(reader),
nodetype,
name,
xmlTextReaderIsEmptyElement(reader),
xmlTextReaderHasValue(reader));
#else
printf("%s%s", (spaces + (32-2*xmlTextReaderDepth(reader))), name);
#endif
if (value == NULL)
printf("\n");
else {
if (xmlStrlen(value) > 40)
printf(" %.40s...\n", value);
else
printf(" %s\n", value);
}
}
if (nodetype==1) // Element - possibly has attributes
{
while (xmlTextReaderMoveToNextAttribute(reader))
printf("%s Attrib: %s=\"%s\"\n",
(spaces + (32-2*xmlTextReaderDepth(reader))),
xmlTextReaderConstName(reader),
xmlTextReaderConstValue(reader));
}
}
static struct cpe_ext_deprecation *cpe_ext_deprecation_parse(xmlTextReaderPtr reader)
{
__attribute__nonnull__(reader);
if (xmlStrcmp(xmlTextReaderConstLocalName(reader), BAD_CAST TAG_CPE_EXT_DEPRECATION_STR) != 0 ||
xmlTextReaderNodeType(reader) != 1) {
oscap_seterr(OSCAP_EFAMILY_OSCAP, "Found '%s' node when expecting: '%s'!",
xmlTextReaderConstLocalName(reader), TAG_CPE_EXT_DEPRECATION_STR);
}
const xmlChar* nsuri = xmlTextReaderConstNamespaceUri(reader);
if (nsuri && xmlStrcmp(nsuri, BAD_CAST XMLNS_CPE2D3_EXTENSION) != 0) {
oscap_seterr(OSCAP_EFAMILY_OSCAP, "Found '%s' namespace when expecting: '%s'!",
nsuri, XMLNS_CPE2D3_EXTENSION);
return NULL;
}
struct cpe_ext_deprecation *deprecation = cpe_ext_deprecation_new();
deprecation->date = (char *) xmlTextReaderGetAttribute(reader, BAD_CAST ATTR_DATE_STR);
if (xmlTextReaderIsEmptyElement(reader) == 0) { // the element contains child nodes
xmlTextReaderNextNode(reader);
while (xmlStrcmp(xmlTextReaderConstLocalName(reader), BAD_CAST TAG_CPE_EXT_DEPRECATION_STR) != 0) {
if (xmlTextReaderNodeType(reader) != XML_READER_TYPE_ELEMENT) {
xmlTextReaderNextNode(reader);
continue;
}
if (xmlStrcmp(xmlTextReaderConstLocalName(reader), BAD_CAST TAG_CPE_EXT_DEPRECATEDBY_STR) == 0) {
struct cpe_ext_deprecatedby *deprecatedby = cpe_ext_deprecatedby_parse(reader);
if (deprecatedby == NULL) {
cpe_ext_deprecation_free(deprecation);
return NULL;
}
oscap_list_add(deprecation->deprecatedbys, deprecatedby);
}
else {
oscap_seterr(OSCAP_EFAMILY_OSCAP, "Unexpected element within deprecation element: '%s'",
xmlTextReaderConstLocalName(reader));
cpe_ext_deprecation_free(deprecation);
return NULL;
}
xmlTextReaderNextNode(reader);
}
}
return deprecation;
}
static xmlChar *xmlTextReaderReadEntireNodeValue(xmlTextReaderPtr reader) {
xmlChar *buffer = calloc(1, sizeof(xmlChar));
const xmlChar *snippet;
int status;
if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ATTRIBUTE) {
return xmlTextReaderValue(reader);
}
else if (xmlTextReaderIsEmptyElement(reader) == 0) {
status = xmlTextReaderRead(reader);
while (status && (xmlTextReaderNodeType(reader) == XML_READER_TYPE_TEXT || xmlTextReaderNodeType(reader) == XML_READER_TYPE_CDATA || xmlTextReaderNodeType(reader) == XML_READER_TYPE_ENTITY_REFERENCE)) {
snippet = xmlTextReaderConstValue(reader);
buffer = realloc(buffer, (xmlStrlen(buffer) + xmlStrlen(snippet) + 1) * sizeof(xmlChar));
xmlStrcat(buffer, snippet);
status = xmlTextReaderRead(reader);
}
}
return buffer;
}
cxTypes cxHashRootReadString(cxHashRoot root,xmlTextReaderPtr reader)
{
cxTypes types = cxStringTypesCreate();
cxString bytes = NULL;
cxConstChars src = cxXMLAttr(reader, "src");
if(src != NULL){
cxStream stream = cxAssetsStreamCreate(src);
bytes = cxStreamAllBytes(stream);
}else if(!xmlTextReaderIsEmptyElement(reader)) {
bytes = cxXMLReadString(reader);
}else{
bytes = NULL;
}
if(bytes == NULL){
return NULL;
}
CX_RETAIN_SWAP(types->any, bytes);
return types;
}
queryMacroList::queryMacroList(xmlTextReaderPtr reader)
{
// Element of type <foo />, meaning empty folder
if (xmlTextReaderIsEmptyElement(reader))
return;
while (xmlTextReaderRead(reader))
{
int type = xmlTextReaderNodeType(reader);
if (type == 15)
return; // Close on parent element
if (xmlTextReaderNodeType(reader) != 1)
continue; // Any unknown element type
wxString nodename = WXSTRING_FROM_XML(xmlTextReaderConstName(reader));
xmlChar *ckey = xmlTextReaderGetAttribute(reader, XML_STR("key"));
if (!ckey)
continue;
wxString key = WXSTRING_FROM_XML(ckey);
xmlFree(ckey);
xmlChar *cname = xmlTextReaderGetAttribute(reader, XML_STR("name"));
if (!cname)
continue;
wxString name = WXSTRING_FROM_XML(cname);
xmlFree(cname);
if (nodename == wxT("macro"))
{
xmlChar *cquery = xmlTextReaderReadString(reader);
if (!cquery)
continue;
wxString query = WXSTRING_FROM_XML(cquery);
xmlFree(cquery);
macros.Add(new queryMacroItem(key, name, query));
SkipToEndElement(reader);
}
}
}
queryFavouriteFolder::queryFavouriteFolder(xmlTextReaderPtr reader, wxString title) : queryFavouriteItem(title, wxT(""))
{
id = -2;
// Element of type <foo />, meaning empty folder
if (xmlTextReaderIsEmptyElement(reader))
return;
while (xmlTextReaderRead(reader))
{
int type = xmlTextReaderNodeType(reader);
if (type == 15)
return; // Close on parent element
if (xmlTextReaderNodeType(reader) != 1)
continue; // Any unknown element type
wxString nodename = WXSTRING_FROM_XML(xmlTextReaderConstName(reader));
xmlChar *ctitle = xmlTextReaderGetAttribute(reader, XML_STR("title"));
if (!ctitle)
continue; // We ignore nodes without title
wxString title = WXSTRING_FROM_XML(ctitle);
xmlFree(ctitle);
if (nodename == wxT("favourite"))
{
xmlChar *cont = xmlTextReaderReadString(reader);
if (!cont)
continue; // No contents, so ignore node
favourites.Add(new queryFavouriteItem(title, WXSTRING_FROM_XML(cont)));
xmlFree(cont);
SkipToEndElement(reader);
}
else if (nodename == wxT("folder"))
{
favourites.Add(new queryFavouriteFolder(reader, title));
}
}
}
static void
processPathElement(xmlTextReaderPtr const xmlReaderP,
canvas * const canvasP) {
style style;
const char * pathData;
path * pathP;
bool endOfPath;
assert(xmlTextReaderNodeType(xmlReaderP) == XML_READER_TYPE_ELEMENT);
assert(streq(currentNodeName(xmlReaderP), "path"));
getPathAttributes(xmlReaderP, &style, &pathData);
createPath(pathData, style, &pathP);
if (pathP) {
drawPath(canvasP, pathP);
destroyPath(pathP);
}
endOfPath = xmlTextReaderIsEmptyElement(xmlReaderP);
while (!endOfPath) {
int rc;
rc = xmlTextReaderRead(xmlReaderP);
switch (rc) {
case 1:
processSubPathNode(xmlReaderP, &endOfPath);
break;
case 0:
pm_error("Input file ends in the middle of a <path>");
break;
default:
pm_error("xmlTextReaderRead() failed, rc=%d", rc);
}
}
}
static void
processSvgElement(xmlTextReaderPtr const xmlReaderP,
FILE * const ofP) {
unsigned int width, height;
bool endOfSvg;
canvas * canvasP;
assert(xmlTextReaderNodeType(xmlReaderP) == XML_READER_TYPE_ELEMENT);
assert(streq(currentNodeName(xmlReaderP), "svg"));
getSvgAttributes(xmlReaderP, &width, &height);
createCanvas(width, height, 255, &canvasP);
endOfSvg = xmlTextReaderIsEmptyElement(xmlReaderP);
while (!endOfSvg) {
int rc;
rc = xmlTextReaderRead(xmlReaderP);
switch (rc) {
case 1:
processSubSvgNode(xmlReaderP, canvasP, &endOfSvg);
break;
case 0:
pm_error("Input file ends in the middle of a <svg>");
break;
default:
pm_error("xmlTextReaderRead() failed, rc=%d", rc);
}
}
writePam(ofP, canvasP);
destroyCanvas(canvasP);
}
void sc_xmltv_parse_credits(xmlTextReaderPtr reader, sc_list_t **list) {
sc_xmltv_credit_t *cred = NULL;
int ret;
xmlChar *val;
sc_xmltv_credit_type_t type;
sc_list_node_t *node = NULL;
for (ret = xmlTextReaderRead(reader); ret == 1; ret = xmlTextReaderRead(reader)) {
if (sc_xmltv_check_current_reader_node(reader, XML_READER_TYPE_END_ELEMENT, SC_XMLTV_CREDIT_NAME,
SC_XMLTV_CREDIT_DEPTH)) {
break;
}
val = xmlTextReaderName(reader);
type = SC_XMLTV_CREDIT_TYPE_UNKNOWN;
if ((!xmlStrcmp(val, (const xmlChar *) "actor"))) type = SC_XMLTV_CREDIT_TYPE_ACTOR;
if ((!xmlStrcmp(val, (const xmlChar *) "director"))) type = SC_XMLTV_CREDIT_TYPE_DIRECTOR;
if ((!xmlStrcmp(val, (const xmlChar *) "guest"))) type = SC_XMLTV_CREDIT_TYPE_GUEST;
if ((!xmlStrcmp(val, (const xmlChar *) "presenter"))) type = SC_XMLTV_CREDIT_TYPE_PRESENTER;
if ((!xmlStrcmp(val, (const xmlChar *) "producer"))) type = SC_XMLTV_CREDIT_TYPE_PRODUCER;
if ((!xmlStrcmp(val, (const xmlChar *) "writer"))) type = SC_XMLTV_CREDIT_TYPE_WRITER;
xmlFree(val);
if (!xmlTextReaderIsEmptyElement(reader) &&
xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT &&
type > 0 &&
xmlTextReaderDepth(reader) == SC_XMLTV_CREDIT_DEPTH + 1) {
cred = (sc_xmltv_credit_t *) sc_xmltv_create(SC_XMLTV_CREDIT);
cred->type = type;
sc_xmltv_get_reader_element_value(reader, &cred->name);
node = sc_list_node_create(cred);
sc_list_node_append(*list, node);
}
}
// node = NULL;
}
// ref: http://xmlsoft.org/examples/index.html#reader1.c
void xml::xmlreader(const char *filename) {
LIBXML_TEST_VERSION
xmlTextReaderPtr reader;
if((reader = xmlReaderForFile(filename, NULL, 0)) != NULL) {
while(xmlTextReaderRead(reader) == 1) {
const xmlChar *name;
const xmlChar *value;
if((name = xmlTextReaderConstName(reader)) != NULL) {
value = xmlTextReaderConstValue(reader);
cout << xmlTextReaderDepth(reader)
<< " " << xmlTextReaderNodeType(reader)
<< " " << name
<< " " << xmlTextReaderIsEmptyElement(reader)
<< " " << xmlTextReaderHasValue(reader);
if(value != NULL)
cout << endl;
cout.flush();
}
}
xmlFreeTextReader(reader);
}
xmlCleanupParser();
}
bool XMLReader::isEndNode() const
{
return (xmlTextReaderNodeType(m_reader) == libxml::NodeType::end_element)
|| (isBeginNode() && xmlTextReaderIsEmptyElement(m_reader)) ;
}
int readxml
(
const char *xmlfile, /* filename to read */
const struct elemdesc *elems, /* array terminated by entry with null elemname field */
const struct elemattr *attrs /* array terminated by entry with null elem field */
)
/* opens and reads an XML file according to the given element and attribute definitions. */
{
enum
{
maxdepth = 10, /* should be enough */
};
int curstate = 0, statehistory[maxdepth];
xmlTextReaderPtr f;
struct vfile fd;
fd = varied_open(xmlfile, O_RDONLY, "XML file");
f = xmlReaderForIO(xml_varied_read, xml_varied_close, &fd, xmlfile, NULL, 0);
if (!f)
{
fprintf(stderr, "ERR: Unable to open XML file %s\n", xmlfile);
return 1;
} /*if*/
while (true)
{
int r = xmlTextReaderRead(f);
if (!r)
{
fprintf(stderr, "ERR: Read premature EOF\n");
return 1;
} /*if*/
if (r != 1)
{
fprintf(stderr, "ERR: Error in parsing XML\n");
return 1;
} /*if*/
switch (xmlTextReaderNodeType(f))
{
case XML_READER_TYPE_SIGNIFICANT_WHITESPACE:
case XML_READER_TYPE_WHITESPACE:
case XML_READER_TYPE_COMMENT:
/* ignore */
break;
case XML_READER_TYPE_ELEMENT:
{
const char * const elemname = (const char *)xmlTextReaderName(f);
int tagindex;
assert(!parser_body);
for (tagindex = 0; elems[tagindex].elemname; tagindex++)
if
(
curstate == elems[tagindex].parentstate
&&
!strcmp(elemname, elems[tagindex].elemname)
)
{
// reading the attributes causes these values to change
// so if you want to use them later, save them now
const bool empty = xmlTextReaderIsEmptyElement(f);
const int depth = xmlTextReaderDepth(f);
if (depth >= maxdepth)
{
fprintf
(
stderr,
"ERR: max XML parsing depth of %d exceeded\n",
maxdepth - 1
);
exit(1);
} /*if*/
if (elems[tagindex].start)
{
elems[tagindex].start();
if (parser_err)
return 1;
} /*if*/
while (xmlTextReaderMoveToNextAttribute(f))
{
const char * const nm = (const char *)xmlTextReaderName(f);
const char * const v = (const char *)xmlTextReaderValue(f);
int attrindex;
for (attrindex = 0; attrs[attrindex].elem; attrindex++)
if
(
!strcmp(attrs[attrindex].elem, elems[tagindex].elemname)
&&
!strcmp(attrs[attrindex].attr, nm)
)
{
attrs[attrindex].f(v);
if (parser_err)
return 1;
break;
} /*if*/
if (!attrs[attrindex].elem)
{
bool gotattr = false;
fprintf
(
stderr,
"ERR: Cannot match attribute '%s' in tag '%s'."
" Valid attributes are:\n",
nm,
elems[tagindex].elemname
);
for (attrindex = 0; attrs[attrindex].elem; attrindex++)
if (!strcmp(attrs[attrindex].elem, elems[tagindex].elemname))
{
fprintf(stderr, "ERR: %s\n", attrs[attrindex]. attr);
gotattr = true;
} /*if*/
if (!gotattr)
{
fprintf(stderr, "ERR: (none)\n");
} /*if*/
return 1;
} /*if*/
xmlFree((xmlChar *)nm);
xmlFree((xmlChar *)v);
} /*while*/
if (empty)
{
/* tag ends immediately */
if (elems[tagindex].end)
{
elems[tagindex].end();
if (parser_err)
return 1;
} /*if*/
}
else
{
statehistory[depth] = tagindex;
curstate = elems[tagindex].newstate;
} /*if*/
break;
} /*if; for*/
if (!elems[tagindex].elemname)
{
fprintf(stderr, "ERR: Cannot match start tag '%s'. Valid tags are:\n", elemname);
for (tagindex = 0; elems[tagindex].elemname; tagindex++)
if (curstate == elems[tagindex].parentstate)
fprintf(stderr, "ERR: %s\n", elems[tagindex].elemname);
return 1;
} /*if*/
xmlFree((xmlChar *)elemname);
}
break;
case XML_READER_TYPE_END_ELEMENT:
{
const int tagindex = statehistory[xmlTextReaderDepth(f)];
if (elems[tagindex].end)
{
elems[tagindex].end();
if (parser_err)
return 1;
} /*if*/
curstate = elems[tagindex].parentstate;
/* Note I don't handle sub-tags mixed with content! */
free(parser_body);
parser_body = 0;
parser_acceptbody = false;
if (!curstate)
goto done_parsing;
}
break;
case XML_READER_TYPE_TEXT:
case XML_READER_TYPE_CDATA:
{
const char * const v = (const char *)xmlTextReaderValue(f);
if (!parser_body)
{
// stupid buggy libxml2 2.5.4 that ships with RedHat 9.0!
// we must manually check if this is just whitespace
int i;
for (i = 0; v[i]; i++)
if
(
v[i] != '\r'
&&
v[i] != '\n'
&&
v[i] != ' '
&&
v[i] != '\t'
)
goto has_nonws_body;
xmlFree((xmlChar *)v);
break;
} /*if*/
has_nonws_body:
if (!parser_acceptbody)
{
fprintf(stderr, "ERR: text not allowed here\n");
return 1;
} /*if*/
if (!parser_body)
parser_body = strdup(v); /* first lot of tag content */
else
{
/* append to previous tag content */
parser_body = realloc(parser_body, strlen(parser_body) + strlen(v) + 1);
strcat(parser_body, v);
} /*if*/
xmlFree((xmlChar *)v);
}
break;
default:
fprintf(stderr, "ERR: Unknown XML node type %d\n", xmlTextReaderNodeType(f));
exit(1);
} /*switch*/
} /*while*/
done_parsing:
xmlFreeTextReader(f);
return 0;
} /*readxml*/
/*
* call-seq:
* reader.empty_element? -> bool
*
* Check if the current node is empty.
*/
static VALUE rxml_reader_empty_element(VALUE self)
{
return xmlTextReaderIsEmptyElement(rxml_text_reader_get(self)) ? Qtrue
: Qfalse;
}
