/**
* 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 response_element_t *
parse_propfind_response (xmlTextReaderPtr reader)
{
parser_strings_t strings;
response_element_t *elements;
/* get internalized versions of some strings to avoid strcmp while
* parsing */
strings.multistatus
= xmlTextReaderConstString (reader, BAD_CAST "multistatus");
strings.dav = xmlTextReaderConstString (reader, BAD_CAST "DAV:");
strings.href = xmlTextReaderConstString (reader, BAD_CAST "href");
strings.response = xmlTextReaderConstString (reader, BAD_CAST "response");
strings.propstat = xmlTextReaderConstString (reader, BAD_CAST "propstat");
strings.prop = xmlTextReaderConstString (reader, BAD_CAST "prop");
strings.getetag = xmlTextReaderConstString (reader, BAD_CAST "getetag");
while (xmlTextReaderRead (reader) == 1 && xmlTextReaderNodeType (reader) != XML_READER_TYPE_ELEMENT) {
}
if (xmlTextReaderConstLocalName (reader) != strings.multistatus
|| xmlTextReaderConstNamespaceUri (reader) != strings.dav) {
g_warning ("webdav PROPFIND result is not <DAV:multistatus>");
return NULL;
}
elements = NULL;
/* parse all DAV:response tags */
while (xmlTextReaderRead (reader) == 1 && xmlTextReaderDepth (reader) > 0) {
response_element_t *element;
if (xmlTextReaderNodeType (reader) != XML_READER_TYPE_ELEMENT)
continue;
if (xmlTextReaderConstLocalName (reader) != strings.response
|| xmlTextReaderConstNamespaceUri (reader) != strings.dav)
continue;
element = parse_response_tag (&strings, reader);
if (element == NULL)
continue;
element->next = elements;
elements = element;
}
return elements;
}
static struct cpe_ext_deprecatedby *cpe_ext_deprecatedby_parse(xmlTextReaderPtr reader)
{
__attribute__nonnull__(reader);
if (xmlStrcmp(xmlTextReaderConstLocalName(reader), BAD_CAST TAG_CPE_EXT_DEPRECATEDBY_STR) != 0 ||
xmlTextReaderNodeType(reader) != 1) {
oscap_seterr(OSCAP_EFAMILY_OSCAP, "Found '%s' node when expecting: '%s'!",
xmlTextReaderConstLocalName(reader), TAG_CPE_EXT_DEPRECATEDBY_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_deprecatedby *deprecatedby = cpe_ext_deprecatedby_new();
deprecatedby->name = (char *) xmlTextReaderGetAttribute(reader, BAD_CAST ATTR_NAME_STR);
const char *type = (const char *) xmlTextReaderGetAttribute(reader, BAD_CAST ATTR_TYPE_STR);
if (type == NULL) {
oscap_seterr(OSCAP_EFAMILY_OSCAP, "Compulsory attribute '%s' missing at '%s' element.",
ATTR_TYPE_STR, TAG_CPE_EXT_DEPRECATEDBY_STR);
cpe_ext_deprecatedby_free(deprecatedby);
return NULL;
}
deprecatedby->type = oscap_string_to_enum(CPE_EXT_DEPRECATION_MAP, type);
return deprecatedby;
}
/*
* call-seq:
* reader.namespace_uri -> URI
*
* Determine the namespace URI of the node.
*/
static VALUE rxml_reader_namespace_uri(VALUE self)
{
xmlTextReaderPtr xReader = rxml_text_reader_get(self);
const xmlChar *result = xmlTextReaderConstNamespaceUri(xReader);
const xmlChar *xencoding = xmlTextReaderConstEncoding(xReader);
return (result == NULL ? Qnil : rxml_new_cstr(result, xencoding));
}
gboolean
xml_reader_is_namespace (XmlReader *reader,
const gchar *ns)
{
g_return_val_if_fail (XML_IS_READER (reader), FALSE);
return (g_strcmp0 (XML_TO_CHAR(xmlTextReaderConstNamespaceUri (reader->xml)), ns) == 0);
}
/*
* call-seq:
* namespace_uri
*
* Get the URI defining the namespace associated with the node
*/
static VALUE namespace_uri(VALUE self)
{
xmlTextReaderPtr reader;
Data_Get_Struct(self, xmlTextReader, reader);
const char * uri = (const char *)xmlTextReaderConstNamespaceUri(reader);
if(uri == NULL) return Qnil;
VALUE MAYBE_UNUSED(enc) = rb_iv_get(self, "@encoding");
return NOKOGIRI_STR_NEW2(uri,
RTEST(enc) ? StringValuePtr(enc) : NULL);
}
/*
* call-seq:
* namespace_uri
*
* Get the URI defining the namespace associated with the node
*/
static VALUE namespace_uri(VALUE self)
{
xmlTextReaderPtr reader;
const char *uri;
Data_Get_Struct(self, xmlTextReader, reader);
uri = (const char *)xmlTextReaderConstNamespaceUri(reader);
if(uri == NULL) return Qnil;
return NOKOGIRI_STR_NEW2(uri);
}
/**
* Reads a NetworkCapabilities element from XML. The element to be read is "networkCapabilities", and
* it is assumed that the reader is pointing to that element.
*
* @param reader The XML reader.
* @return The NetworkCapabilities, or NULL in case of error.
*/
struct full_ns0_networkCapabilities *xmlTextReaderReadNs0NetworkCapabilitiesElement(xmlTextReaderPtr reader) {
struct full_ns0_networkCapabilities *_networkCapabilities = NULL;
if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT
&& xmlStrcmp(BAD_CAST "networkCapabilities", xmlTextReaderConstLocalName(reader)) == 0
&& xmlTextReaderConstNamespaceUri(reader) == NULL) {
#if DEBUG_ENUNCIATE > 1
printf("Attempting to read root element {}networkCapabilities.\n");
#endif
_networkCapabilities = xmlTextReaderReadNs0NetworkCapabilitiesType(reader);
}
#if DEBUG_ENUNCIATE
if (_networkCapabilities == NULL) {
if (xmlTextReaderConstNamespaceUri(reader) == NULL) {
printf("attempt to read {}networkCapabilities failed. current element: {}%s\n", xmlTextReaderConstLocalName(reader));
}
else {
printf("attempt to read {}networkCapabilities failed. current element: {%s}%s\n", xmlTextReaderConstNamespaceUri(reader), xmlTextReaderConstLocalName(reader));
}
}
#endif
return _networkCapabilities;
}
const struct xccdf_version_info* xccdf_detect_version_parser(xmlTextReaderPtr reader)
{
const struct xccdf_version_info *mapptr;
const char* namespace_uri = (const char*)xmlTextReaderConstNamespaceUri(reader);
if (!namespace_uri) {
oscap_setxmlerr(xmlGetLastError());
return NULL;
}
mapptr = _namespace_get_xccdf_version_info(namespace_uri);
if (mapptr == NULL)
oscap_seterr(OSCAP_EFAMILY_XML, "This is not known XCCDF namespace: %s.", namespace_uri);
return mapptr;
}
/**
* Reads a SubnetConfig element from XML. The element to be read is "subnetConfig", and
* it is assumed that the reader is pointing to that element.
*
* @param reader The XML reader.
* @return The SubnetConfig, or NULL in case of error.
*/
struct full_ns0_subnetConfig *xmlTextReaderReadNs0SubnetConfigElement(xmlTextReaderPtr reader) {
struct full_ns0_subnetConfig *_subnetConfig = NULL;
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 root element {}subnetConfig.\n");
#endif
_subnetConfig = xmlTextReaderReadNs0SubnetConfigType(reader);
}
#if DEBUG_ENUNCIATE
if (_subnetConfig == NULL) {
if (xmlTextReaderConstNamespaceUri(reader) == NULL) {
printf("attempt to read {}subnetConfig failed. current element: {}%s\n", xmlTextReaderConstLocalName(reader));
}
else {
printf("attempt to read {}subnetConfig failed. current element: {%s}%s\n", xmlTextReaderConstNamespaceUri(reader), xmlTextReaderConstLocalName(reader));
}
}
#endif
return _subnetConfig;
}
/**
* Reads a Persona element from XML. The element to be read is "{http://api.ifyouwannabecool.com/persona}persona", and
* it is assumed that the reader is pointing to that element.
*
* @param reader The XML reader.
* @return The Persona, or NULL in case of error.
*/
struct ifyouwannabecool_persona_persona *xmlTextReaderReadPersonaPersonaElement(xmlTextReaderPtr reader) {
struct ifyouwannabecool_persona_persona *_persona = NULL;
if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT
&& xmlStrcmp(BAD_CAST "persona", xmlTextReaderConstLocalName(reader)) == 0
&& xmlStrcmp(BAD_CAST "http://api.ifyouwannabecool.com/persona", xmlTextReaderConstNamespaceUri(reader)) == 0) {
#if DEBUG_ENUNCIATE > 1
printf("Attempting to read root element {http://api.ifyouwannabecool.com/persona}persona.\n");
#endif
_persona = xmlTextReaderReadPersonaPersonaType(reader);
}
#if DEBUG_ENUNCIATE
if (_persona == NULL) {
if (xmlTextReaderConstNamespaceUri(reader) == NULL) {
printf("attempt to read {http://api.ifyouwannabecool.com/persona}persona failed. current element: {}%s\n", xmlTextReaderConstLocalName(reader));
}
else {
printf("attempt to read {http://api.ifyouwannabecool.com/persona}persona failed. current element: {%s}%s\n", xmlTextReaderConstNamespaceUri(reader), xmlTextReaderConstLocalName(reader));
}
}
#endif
return _persona;
}
/**
* Reads a SocialGroup element from XML. The element to be read is "{http://api.ifyouwannabecool.com/link}socialGroup", and
* it is assumed that the reader is pointing to that element.
*
* @param reader The XML reader.
* @return The SocialGroup, or NULL in case of error.
*/
struct ifyouwannabecool_link_socialGroup *xmlTextReaderReadLinkSocialGroupElement(xmlTextReaderPtr reader) {
struct ifyouwannabecool_link_socialGroup *_socialGroup = NULL;
if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT
&& xmlStrcmp(BAD_CAST "socialGroup", xmlTextReaderConstLocalName(reader)) == 0
&& xmlStrcmp(BAD_CAST "http://api.ifyouwannabecool.com/link", xmlTextReaderConstNamespaceUri(reader)) == 0) {
#if DEBUG_ENUNCIATE > 1
printf("Attempting to read root element {http://api.ifyouwannabecool.com/link}socialGroup.\n");
#endif
_socialGroup = xmlTextReaderReadLinkSocialGroupType(reader);
}
#if DEBUG_ENUNCIATE
if (_socialGroup == NULL) {
if (xmlTextReaderConstNamespaceUri(reader) == NULL) {
printf("attempt to read {http://api.ifyouwannabecool.com/link}socialGroup failed. current element: {}%s\n", xmlTextReaderConstLocalName(reader));
}
else {
printf("attempt to read {http://api.ifyouwannabecool.com/link}socialGroup failed. current element: {%s}%s\n", xmlTextReaderConstNamespaceUri(reader), xmlTextReaderConstLocalName(reader));
}
}
#endif
return _socialGroup;
}
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;
}
xccdf_element_t xccdf_element_get(xmlTextReaderPtr reader)
{
if (xmlTextReaderNodeType(reader) != XML_READER_TYPE_ELEMENT)
return XCCDFE_ERROR;
const struct xccdf_element_spec *mapptr;
const char *name = (const char *)xmlTextReaderConstLocalName(reader);
const char *nsuri = (const char *)xmlTextReaderConstNamespaceUri(reader);
for (mapptr = XCCDF_ELEMENT_MAP; mapptr->id != 0; ++mapptr) {
if (name && strcmp(mapptr->name, name) == 0) {
// element name exists and matches
if (!nsuri && !mapptr->ns)
// no namespace for the element and no namespace defined in the table
return mapptr->id;
if (nsuri && strcmp(mapptr->ns, nsuri) == 0)
// namespace exists and matches the table
return mapptr->id;
if (nsuri && (strcmp(mapptr->ns, XCCDF_XMLNS_PREFIX) == 0 || strcmp(mapptr->ns, XCCDF_OR_TAILORING_EXTENSION_XMLNS) == 0) &&
strncmp(XCCDF_XMLNS_PREFIX, nsuri, strlen(XCCDF_XMLNS_PREFIX)) == 0)
// Namespace exists and XCCDF version-less namespace prefix matches
// it. This is done to support multiple XCCDF versions.
//
// XSD schema will make sure there is no XCCDF version mixing in
// the document. The only thing we are solving here is making sure
// the element is some kind of an XCCDF element.
return mapptr->id;
if (nsuri && strcmp(mapptr->ns, XCCDF_OR_TAILORING_EXTENSION_XMLNS) == 0 &&
strcmp(XCCDF_OR_TAILORING_EXTENSION_XMLNS, nsuri) == 0)
// In case we are supposed to accept XCCDF tailoring extension
return mapptr->id;
}
}
return XCCDFE_UNMATCHED;
}
/**
* Reads a NetworkCapabilities from XML. The reader is assumed to be at the start element.
*
* @return the NetworkCapabilities, or NULL in case of error.
*/
static struct full_ns0_networkCapabilities *xmlTextReaderReadNs0NetworkCapabilitiesType(xmlTextReaderPtr reader) {
int status, depth;
void *_child_accessor;
struct full_ns0_networkCapabilities *_networkCapabilities = calloc(1, sizeof(struct full_ns0_networkCapabilities));
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
freeNs0NetworkCapabilitiesType(_networkCapabilities);
free(_networkCapabilities);
return NULL;
}
else if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT
&& xmlStrcmp(BAD_CAST "node", xmlTextReaderConstLocalName(reader)) == 0
&& xmlTextReaderConstNamespaceUri(reader) == NULL) {
#if DEBUG_ENUNCIATE > 1
printf("Attempting to read choice {}node of type {http://www.w3.org/2001/XMLSchema}string.\n");
#endif
_child_accessor = xmlTextReaderReadXsStringType(reader);
if (_child_accessor == NULL) {
#if DEBUG_ENUNCIATE
printf("Failed to read choice {}node of type {http://www.w3.org/2001/XMLSchema}string.\n");
#endif
//panic: unable to read the child element for some reason.
freeNs0NetworkCapabilitiesType(_networkCapabilities);
free(_networkCapabilities);
return NULL;
}
_networkCapabilities->node = realloc(_networkCapabilities->node, (_networkCapabilities->_sizeof_node + 1) * sizeof(xmlChar));
memcpy(&(_networkCapabilities->node[_networkCapabilities->_sizeof_node++]), _child_accessor, sizeof(xmlChar));
free(_child_accessor);
status = xmlTextReaderAdvanceToNextStartOrEndElement(reader);
}
else if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT
&& xmlStrcmp(BAD_CAST "latency", xmlTextReaderConstLocalName(reader)) == 0
&& xmlTextReaderConstNamespaceUri(reader) == NULL) {
#if DEBUG_ENUNCIATE > 1
printf("Attempting to read choice {}latency of type {http://www.w3.org/2001/XMLSchema}string.\n");
#endif
_child_accessor = xmlTextReaderReadXsStringType(reader);
if (_child_accessor == NULL) {
#if DEBUG_ENUNCIATE
printf("Failed to read choice {}latency of type {http://www.w3.org/2001/XMLSchema}string.\n");
#endif
//panic: unable to read the child element for some reason.
freeNs0NetworkCapabilitiesType(_networkCapabilities);
free(_networkCapabilities);
return NULL;
}
_networkCapabilities->latency = realloc(_networkCapabilities->latency, (_networkCapabilities->_sizeof_latency + 1) * sizeof(xmlChar));
memcpy(&(_networkCapabilities->latency[_networkCapabilities->_sizeof_latency++]), _child_accessor, sizeof(xmlChar));
free(_child_accessor);
status = xmlTextReaderAdvanceToNextStartOrEndElement(reader);
}
else if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT
&& xmlStrcmp(BAD_CAST "macAddressList", xmlTextReaderConstLocalName(reader)) == 0
&& xmlTextReaderConstNamespaceUri(reader) == NULL) {
#if DEBUG_ENUNCIATE > 1
printf("Attempting to read choice {}macAddressList of type {http://www.w3.org/2001/XMLSchema}string.\n");
#endif
_child_accessor = xmlTextReaderReadXsStringType(reader);
if (_child_accessor == NULL) {
#if DEBUG_ENUNCIATE
printf("Failed to read choice {}macAddressList of type {http://www.w3.org/2001/XMLSchema}string.\n");
#endif
//panic: unable to read the child element for some reason.
freeNs0NetworkCapabilitiesType(_networkCapabilities);
free(_networkCapabilities);
return NULL;
}
_networkCapabilities->macAddressList = realloc(_networkCapabilities->macAddressList, (_networkCapabilities->_sizeof_macAddressList + 1) * sizeof(xmlChar));
memcpy(&(_networkCapabilities->macAddressList[_networkCapabilities->_sizeof_macAddressList++]), _child_accessor, sizeof(xmlChar));
free(_child_accessor);
status = xmlTextReaderAdvanceToNextStartOrEndElement(reader);
}
else if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT
&& xmlStrcmp(BAD_CAST "bandwidth", xmlTextReaderConstLocalName(reader)) == 0
&& xmlTextReaderConstNamespaceUri(reader) == NULL) {
#if DEBUG_ENUNCIATE > 1
printf("Attempting to read choice {}bandwidth of type {http://www.w3.org/2001/XMLSchema}string.\n");
#endif
_child_accessor = xmlTextReaderReadXsStringType(reader);
if (_child_accessor == NULL) {
#if DEBUG_ENUNCIATE
printf("Failed to read choice {}bandwidth of type {http://www.w3.org/2001/XMLSchema}string.\n");
#endif
//panic: unable to read the child element for some reason.
freeNs0NetworkCapabilitiesType(_networkCapabilities);
free(_networkCapabilities);
return NULL;
}
_networkCapabilities->bandwidth = realloc(_networkCapabilities->bandwidth, (_networkCapabilities->_sizeof_bandwidth + 1) * sizeof(xmlChar));
memcpy(&(_networkCapabilities->bandwidth[_networkCapabilities->_sizeof_bandwidth++]), _child_accessor, sizeof(xmlChar));
free(_child_accessor);
status = xmlTextReaderAdvanceToNextStartOrEndElement(reader);
}
else if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT
&& xmlStrcmp(BAD_CAST "link", xmlTextReaderConstLocalName(reader)) == 0
&& xmlTextReaderConstNamespaceUri(reader) == NULL) {
#if DEBUG_ENUNCIATE > 1
printf("Attempting to read choice {}link of type {http://www.w3.org/2001/XMLSchema}string.\n");
#endif
_child_accessor = xmlTextReaderReadXsStringType(reader);
if (_child_accessor == NULL) {
#if DEBUG_ENUNCIATE
printf("Failed to read choice {}link of type {http://www.w3.org/2001/XMLSchema}string.\n");
#endif
//panic: unable to read the child element for some reason.
freeNs0NetworkCapabilitiesType(_networkCapabilities);
free(_networkCapabilities);
return NULL;
}
_networkCapabilities->link = realloc(_networkCapabilities->link, (_networkCapabilities->_sizeof_link + 1) * sizeof(xmlChar));
memcpy(&(_networkCapabilities->link[_networkCapabilities->_sizeof_link++]), _child_accessor, sizeof(xmlChar));
free(_child_accessor);
status = xmlTextReaderAdvanceToNextStartOrEndElement(reader);
}
else if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT
&& xmlStrcmp(BAD_CAST "controller", xmlTextReaderConstLocalName(reader)) == 0
&& xmlTextReaderConstNamespaceUri(reader) == NULL) {
#if DEBUG_ENUNCIATE > 1
printf("Attempting to read choice {}controller of type {http://www.w3.org/2001/XMLSchema}string.\n");
#endif
_child_accessor = xmlTextReaderReadXsStringType(reader);
if (_child_accessor == NULL) {
#if DEBUG_ENUNCIATE
printf("Failed to read choice {}controller of type {http://www.w3.org/2001/XMLSchema}string.\n");
#endif
//panic: unable to read the child element for some reason.
freeNs0NetworkCapabilitiesType(_networkCapabilities);
free(_networkCapabilities);
return NULL;
}
_networkCapabilities->controller = realloc(_networkCapabilities->controller, (_networkCapabilities->_sizeof_controller + 1) * sizeof(xmlChar));
memcpy(&(_networkCapabilities->controller[_networkCapabilities->_sizeof_controller++]), _child_accessor, sizeof(xmlChar));
free(_child_accessor);
status = xmlTextReaderAdvanceToNextStartOrEndElement(reader);
}
else if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT
&& xmlStrcmp(BAD_CAST "host", xmlTextReaderConstLocalName(reader)) == 0
&& xmlTextReaderConstNamespaceUri(reader) == NULL) {
#if DEBUG_ENUNCIATE > 1
printf("Attempting to read choice {}host of type {http://www.w3.org/2001/XMLSchema}string.\n");
#endif
_child_accessor = xmlTextReaderReadXsStringType(reader);
if (_child_accessor == NULL) {
#if DEBUG_ENUNCIATE
printf("Failed to read choice {}host of type {http://www.w3.org/2001/XMLSchema}string.\n");
#endif
//panic: unable to read the child element for some reason.
freeNs0NetworkCapabilitiesType(_networkCapabilities);
free(_networkCapabilities);
return NULL;
}
_networkCapabilities->host = realloc(_networkCapabilities->host, (_networkCapabilities->_sizeof_host + 1) * sizeof(xmlChar));
memcpy(&(_networkCapabilities->host[_networkCapabilities->_sizeof_host++]), _child_accessor, sizeof(xmlChar));
free(_child_accessor);
status = xmlTextReaderAdvanceToNextStartOrEndElement(reader);
}
else if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT
&& xmlStrcmp(BAD_CAST "ipAddressList", xmlTextReaderConstLocalName(reader)) == 0
&& xmlTextReaderConstNamespaceUri(reader) == NULL) {
#if DEBUG_ENUNCIATE > 1
printf("Attempting to read choice {}ipAddressList of type {http://www.w3.org/2001/XMLSchema}string.\n");
#endif
_child_accessor = xmlTextReaderReadXsStringType(reader);
if (_child_accessor == NULL) {
#if DEBUG_ENUNCIATE
printf("Failed to read choice {}ipAddressList of type {http://www.w3.org/2001/XMLSchema}string.\n");
#endif
//panic: unable to read the child element for some reason.
freeNs0NetworkCapabilitiesType(_networkCapabilities);
free(_networkCapabilities);
return NULL;
}
_networkCapabilities->ipAddressList = realloc(_networkCapabilities->ipAddressList, (_networkCapabilities->_sizeof_ipAddressList + 1) * sizeof(xmlChar));
memcpy(&(_networkCapabilities->ipAddressList[_networkCapabilities->_sizeof_ipAddressList++]), _child_accessor, sizeof(xmlChar));
free(_child_accessor);
status = xmlTextReaderAdvanceToNextStartOrEndElement(reader);
}
else {
#if DEBUG_ENUNCIATE > 1
if (xmlTextReaderConstNamespaceUri(reader) == NULL) {
printf("unknown child element {}%s for type {}networkCapabilities. Skipping...\n", xmlTextReaderConstLocalName(reader));
}
else {
printf("unknown child element {%s}%s for type {}networkCapabilities. Skipping...\n", xmlTextReaderConstNamespaceUri(reader), xmlTextReaderConstLocalName(reader));
}
#endif
status = xmlTextReaderSkipElement(reader);
}
}
}
return _networkCapabilities;
}
/*
* call-seq:
* reader.namespace_uri -> URI
*
* Determine the namespace URI of the node.
*/
static VALUE rxml_reader_namespace_uri(VALUE self)
{
const xmlChar *result = xmlTextReaderConstNamespaceUri(rxml_text_reader_get(self));
return (result == NULL ? Qnil : rb_str_new2((const char*)result));
}
bool XMLConversion::ReadXML(XMLBaseFormat* pFormat, OBBase* pOb)
{
if(_requestedpos)
{
//The initial stream position was not at the start, probably because of fastsearch
//Read and discard the first object to synchronize the reader,
//then continue getting the requested object.
//Assumes the objects are all at the same level in the DOM tree.
SetOneObjectOnly(); //probably already set
streampos SavedReqestedPos = _requestedpos;
_requestedpos=0;//don't do this again
ReadXML(pFormat,pOb);
GetInStream()->seekg(SavedReqestedPos);
}
//**Parse
int result=1;
while(GetInStream()->good() && (_SkipNextRead || (result=xmlTextReaderRead(_reader))==1)) //read may not be called
{
_SkipNextRead=false;
if(_LookingForNamespace)
{
const xmlChar* puri = xmlTextReaderConstNamespaceUri(_reader);
if(puri)
{
string uri((const char*)puri);
//Look up appropriate format class from the namespace URI
NsMapType::iterator nsiter;
nsiter = Namespaces().find(uri);
if(nsiter!=Namespaces().end())
{
XMLBaseFormat* pNewFormat = nsiter->second;
//Must have same target, e.g. OBMol, as current format
if(pNewFormat->GetType() == pFormat->GetType())
{
_LookingForNamespace=false;
_SkipNextRead=true;
SetInFormat(pNewFormat);
pNewFormat->ReadMolecule(pOb,this);
return true;
}
}
}
}
const xmlChar* pname = xmlTextReaderConstLocalName(_reader);
int typ = xmlTextReaderNodeType(_reader);
if(typ==XML_READER_TYPE_SIGNIFICANT_WHITESPACE || !pname)
continue; //Text nodes handled in format class
string ElName((const char*)pname);
//Pass the node on to the appropriate format class
bool ret;
if(typ==XML_READER_TYPE_ELEMENT)
ret= pFormat->DoElement(ElName);
else if(typ==XML_READER_TYPE_END_ELEMENT)
ret= pFormat->EndElement(ElName);
else
continue;
_lastpos = GetInStream()->tellg();
if(!ret)
//derived format callback has stopped processing by returning false;
//leave reader intact so it can be continued to be used.
if(!IsOption("n",OBConversion::INOPTIONS))
{
_LookingForNamespace = true;
return true;
}
}
if(result==-1)
{
xmlError* perr = xmlGetLastError();
if(perr && perr->level!=XML_ERR_NONE)
{
obErrorLog.ThrowError("XML Parser " + GetInFilename(),
perr->message, obError);
}
xmlResetError(perr);
GetInStream()->setstate(ios::eofbit);
return false;
}
return GetInStream()->good() && result!=0;
}
static response_element_t *
parse_response_tag (const parser_strings_t *strings,
xmlTextReaderPtr reader)
{
xmlChar *href = NULL;
xmlChar *etag = NULL;
gint depth = xmlTextReaderDepth (reader);
response_element_t *element;
while (xmlTextReaderRead (reader) == 1 && xmlTextReaderDepth (reader) > depth) {
const xmlChar *tag_name;
if (xmlTextReaderNodeType (reader) != XML_READER_TYPE_ELEMENT)
continue;
if (xmlTextReaderConstNamespaceUri (reader) != strings->dav)
continue;
tag_name = xmlTextReaderConstLocalName (reader);
if (tag_name == strings->href) {
if (href != NULL) {
/* multiple href elements?!? */
xmlFree (href);
}
href = xmlTextReaderReadString (reader);
} else if (tag_name == strings->propstat) {
/* find <propstat><prop><getetag> hierarchy */
gint depth2 = xmlTextReaderDepth (reader);
while (xmlTextReaderRead (reader) == 1 && xmlTextReaderDepth (reader) > depth2) {
gint depth3;
if (xmlTextReaderNodeType (reader) != XML_READER_TYPE_ELEMENT)
continue;
if (xmlTextReaderConstNamespaceUri (reader) != strings->dav
|| xmlTextReaderConstLocalName (reader) != strings->prop)
continue;
depth3 = xmlTextReaderDepth (reader);
while (xmlTextReaderRead (reader) == 1 && xmlTextReaderDepth (reader) > depth3) {
if (xmlTextReaderNodeType (reader) != XML_READER_TYPE_ELEMENT)
continue;
if (xmlTextReaderConstNamespaceUri (reader) != strings->dav
|| xmlTextReaderConstLocalName (reader)
!= strings->getetag)
continue;
if (etag != NULL) {
/* multiple etag elements?!? */
xmlFree (etag);
}
etag = xmlTextReaderReadString (reader);
}
}
}
}
if (href == NULL) {
g_warning ("webdav returned response element without href");
return NULL;
}
/* append element to list */
element = g_malloc (sizeof (element[0]));
element->href = href;
element->etag = etag;
return element;
}
/**
* Reads a Persona from XML. The reader is assumed to be at the start element.
*
* @return the Persona, or NULL in case of error.
*/
static struct ifyouwannabecool_persona_persona *xmlTextReaderReadPersonaPersonaType(xmlTextReaderPtr reader) {
int status, depth;
void *_child_accessor;
struct ifyouwannabecool_persona_persona *_persona = calloc(1, sizeof(struct ifyouwannabecool_persona_persona));
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
freePersonaPersonaType(_persona);
free(_persona);
return NULL;
}
else if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT
&& xmlStrcmp(BAD_CAST "id", xmlTextReaderConstLocalName(reader)) == 0
&& xmlTextReaderConstNamespaceUri(reader) == NULL) {
#if DEBUG_ENUNCIATE > 1
printf("Attempting to read choice {}id of type {http://www.w3.org/2001/XMLSchema}string.\n");
#endif
_child_accessor = xmlTextReaderReadXsStringType(reader);
if (_child_accessor == NULL) {
#if DEBUG_ENUNCIATE
printf("Failed to read choice {}id of type {http://www.w3.org/2001/XMLSchema}string.\n");
#endif
//panic: unable to read the child element for some reason.
freePersonaPersonaType(_persona);
free(_persona);
return NULL;
}
_persona->id = ((xmlChar*)_child_accessor);
status = xmlTextReaderAdvanceToNextStartOrEndElement(reader);
}
else if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT
&& xmlStrcmp(BAD_CAST "email", xmlTextReaderConstLocalName(reader)) == 0
&& xmlTextReaderConstNamespaceUri(reader) == NULL) {
#if DEBUG_ENUNCIATE > 1
printf("Attempting to read choice {}email of type {http://www.w3.org/2001/XMLSchema}string.\n");
#endif
_child_accessor = xmlTextReaderReadXsStringType(reader);
if (_child_accessor == NULL) {
#if DEBUG_ENUNCIATE
printf("Failed to read choice {}email of type {http://www.w3.org/2001/XMLSchema}string.\n");
#endif
//panic: unable to read the child element for some reason.
freePersonaPersonaType(_persona);
free(_persona);
return NULL;
}
_persona->email = ((xmlChar*)_child_accessor);
status = xmlTextReaderAdvanceToNextStartOrEndElement(reader);
}
else if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT
&& xmlStrcmp(BAD_CAST "alias", xmlTextReaderConstLocalName(reader)) == 0
&& xmlTextReaderConstNamespaceUri(reader) == NULL) {
#if DEBUG_ENUNCIATE > 1
printf("Attempting to read choice {}alias of type {http://www.w3.org/2001/XMLSchema}string.\n");
#endif
_child_accessor = xmlTextReaderReadXsStringType(reader);
if (_child_accessor == NULL) {
#if DEBUG_ENUNCIATE
printf("Failed to read choice {}alias of type {http://www.w3.org/2001/XMLSchema}string.\n");
#endif
//panic: unable to read the child element for some reason.
freePersonaPersonaType(_persona);
free(_persona);
return NULL;
}
_persona->alias = ((xmlChar*)_child_accessor);
status = xmlTextReaderAdvanceToNextStartOrEndElement(reader);
}
else if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT
&& xmlStrcmp(BAD_CAST "name", xmlTextReaderConstLocalName(reader)) == 0
&& xmlTextReaderConstNamespaceUri(reader) == NULL) {
#if DEBUG_ENUNCIATE > 1
printf("Attempting to read choice {}name of type {http://api.ifyouwannabecool.com/persona}name.\n");
#endif
_child_accessor = xmlTextReaderReadPersonaNameType(reader);
if (_child_accessor == NULL) {
#if DEBUG_ENUNCIATE
printf("Failed to read choice {}name of type {http://api.ifyouwannabecool.com/persona}name.\n");
#endif
//panic: unable to read the child element for some reason.
freePersonaPersonaType(_persona);
free(_persona);
return NULL;
}
_persona->name = ((struct ifyouwannabecool_persona_name*)_child_accessor);
status = xmlTextReaderAdvanceToNextStartOrEndElement(reader);
}
else if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT
&& xmlStrcmp(BAD_CAST "picture", xmlTextReaderConstLocalName(reader)) == 0
&& xmlTextReaderConstNamespaceUri(reader) == NULL) {
#if DEBUG_ENUNCIATE > 1
printf("Attempting to read binary data of choice {}picture.\n");
#endif
_child_accessor = xmlTextReaderReadEntireNodeValue(reader);
_persona->picture = _decode_base64((xmlChar *) _child_accessor, &(_persona->_sizeof_picture));
free(_child_accessor);
status = xmlTextReaderAdvanceToNextStartOrEndElement(reader);
}
else {
#if DEBUG_ENUNCIATE > 1
if (xmlTextReaderConstNamespaceUri(reader) == NULL) {
printf("unknown child element {}%s for type {http://api.ifyouwannabecool.com/persona}persona. Skipping...\n", xmlTextReaderConstLocalName(reader));
}
else {
printf("unknown child element {%s}%s for type {http://api.ifyouwannabecool.com/persona}persona. Skipping...\n", xmlTextReaderConstNamespaceUri(reader), xmlTextReaderConstLocalName(reader));
}
#endif
status = xmlTextReaderSkipElement(reader);
}
}
}
return _persona;
}
int XMIResource::processElement(xmlTextReaderPtr reader)
{
const xmlChar *name = xmlTextReaderConstLocalName(reader);
parent = NB_XCOS_NAMES;
// lookup for known node names
// thanks to the string intern-ing, the pointer comparison could be used
auto found = std::find(constXcosNames.begin(), constXcosNames.end(), name);
enum xcosNames current = static_cast<enum xcosNames>(std::distance(constXcosNames.begin(), found));
switch (current)
{
case e_Diagram:
{
// the root diagram should be decoded
model::BaseObject o(root, DIAGRAM);
processed.push_back(o);
return loadDiagram(reader, o);
}
case e_child:
{
// this is a child of a diagram, resolve the type and call the loaders
// iterate on attributes to lookup for EMF type
// iterate on attributes
for (int rc = xmlTextReaderMoveToFirstAttribute(reader); rc > 0; rc = xmlTextReaderMoveToNextAttribute(reader))
{
const xmlChar* nsURI = xmlTextReaderConstNamespaceUri(reader);
if (nsURI != xsiNamespaceUri)
{
continue;
}
auto foundName = std::find(constXcosNames.begin(), constXcosNames.end(), xmlTextReaderConstLocalName(reader));
enum xcosNames currentName = static_cast<enum xcosNames>(std::distance(constXcosNames.begin(), foundName));
if (currentName != e_type)
{
continue;
}
const xmlChar* value = xmlTextReaderConstValue(reader);
const xmlChar* valueWithoutPrefix = BAD_CAST(std::strchr((const char*) value, ':'));
if (valueWithoutPrefix == nullptr)
{
valueWithoutPrefix = value;
}
else
{
// remove the leading ':'
valueWithoutPrefix = valueWithoutPrefix + 1;
}
const xmlChar* interned = xmlTextReaderConstString(reader, valueWithoutPrefix);
auto found = std::find(constXcosNames.begin(), constXcosNames.end(), interned);
enum xcosNames current = static_cast<enum xcosNames>(std::distance(constXcosNames.begin(), found));
switch (current)
{
case e_Block:
{
ScicosID o = controller.createObject(BLOCK);
// assign the child
model::BaseObject parent = processed.back();
std::vector<ScicosID> children;
controller.getObjectProperty(parent.id(), parent.kind(), CHILDREN, children);
children.push_back(o);
controller.setObjectProperty(parent.id(), parent.kind(), CHILDREN, children);
model::BaseObject child(o, BLOCK);
processed.push_back(child);
return loadBlock(reader, child);
}
case e_Link:
{
ScicosID o = controller.createObject(LINK);
// assign the child
model::BaseObject parent = processed.back();
std::vector<ScicosID> children;
controller.getObjectProperty(parent.id(), parent.kind(), CHILDREN, children);
children.push_back(o);
controller.setObjectProperty(parent.id(), parent.kind(), CHILDREN, children);
model::BaseObject child(o, LINK);
processed.push_back(child);
return loadLink(reader, child);
}
case e_Annotation:
{
ScicosID o = controller.createObject(ANNOTATION);
// assign the child
model::BaseObject parent = processed.back();
std::vector<ScicosID> children;
controller.getObjectProperty(parent.id(), parent.kind(), CHILDREN, children);
children.push_back(o);
controller.setObjectProperty(parent.id(), parent.kind(), CHILDREN, children);
model::BaseObject child(o, ANNOTATION);
return loadAnnotation(reader, child);
}
default:
sciprint("Not handled child type=%s at line %d\n", *found,
xmlTextReaderGetParserLineNumber(reader) - 1);
return -1;
}
}
break;
}
case e_in: // no break on purpose
case e_out: // no break on purpose
case e_ein: // no break on purpose
case e_eout:
{
ScicosID o = controller.createObject(PORT);
enum object_properties_t p;
switch (current)
{
case e_in:
p = INPUTS;
break;
case e_out:
p = OUTPUTS;
break;
case e_ein:
p = EVENT_INPUTS;
break;
case e_eout:
p = EVENT_OUTPUTS;
break;
default:
return -1;
}
model::BaseObject parent = processed.back();
// add the port them to the parent
std::vector<ScicosID> ports;
controller.getObjectProperty(parent.id(), parent.kind(), p, ports);
ports.push_back(o);
controller.setObjectProperty(parent.id(), parent.kind(), p, ports);
// decode content
model::BaseObject child(o, PORT);
return loadPort(reader, child);
}
case e_geometry:
// geometry is used for rectangle coordinates of its parent
return loadGeometry(reader, processed.back());
case e_nzcross:
// nzcross is a Block property
if (!xmlTextReaderIsEmptyElement(reader))
{
parent = current;
}
return 1;
case e_nmode:
// nmode is a Block property
if (!xmlTextReaderIsEmptyElement(reader))
{
parent = current;
}
return 1;
case e_rpar:
// rpar is a Block property
if (!xmlTextReaderIsEmptyElement(reader))
{
parent = current;
}
return 1;
case e_ipar:
// ipar is a Block property
if (!xmlTextReaderIsEmptyElement(reader))
{
parent = current;
}
return 1;
case e_opar:
// ipar is a Block property
return loadBase64(reader, OPAR, processed.back());
case e_state:
// state is a Block property
if (!xmlTextReaderIsEmptyElement(reader))
{
parent = current;
}
return 1;
case e_dstate:
// dstate is a Block property
if (!xmlTextReaderIsEmptyElement(reader))
{
parent = current;
}
return 1;
case e_odstate:
// odstate is a Block property
return loadBase64(reader, ODSTATE, processed.back());
case e_equations:
// equation is a Block property
return loadBase64(reader, EQUATIONS, processed.back());
case e_expression:
// expression is a Block property
if (!xmlTextReaderIsEmptyElement(reader))
{
parent = current;
}
return 1;
case e_exprs:
// exprs is a Block property
return loadBase64(reader, EXPRS, processed.back());
case e_controlPoint:
// controlPoint is a link property
return loadPoint(reader, processed.back());
case e_context:
// context is a Layer property
if (!xmlTextReaderIsEmptyElement(reader))
{
parent = current;
}
return 1;
case e_properties:
// properties is a Diagram property
return loadSimulationConfig(reader, processed.back());
case e_datatype:
// datatype is a Port property
if (!xmlTextReaderIsEmptyElement(reader))
{
parent = current;
}
return 1;
default:
sciprint("Unknown \"%s\" element name at line %d\n", name, xmlTextReaderGetParserLineNumber(reader) - 1);
return -1;
}
return 1;
}
//## @Native String XmlReader.constNamespaceUri();
static KMETHOD XmlReader_constNamespaceUri(KonohaContext *kctx, KonohaStack *sfp)
{
xmlTextReaderPtr reader = getRawXmlReader(sfp[0]);
char* ret = (reader != NULL) ? (char *) xmlTextReaderConstNamespaceUri(reader) : NULL;
KReturn(KLIB new_kString(kctx, GcUnsafe, ret, strlen(ret), 0));
}
bool IWORKParser::parse()
{
const shared_ptr<xmlTextReader> sharedReader(xmlReaderForIO(readFromStream, closeStream, m_input.get(), "", nullptr, 0), xmlFreeTextReader);
if (!sharedReader)
return false;
xmlTextReaderPtr reader = sharedReader.get();
assert(reader);
const IWORKTokenizer &tokenizer = getTokenizer();
stack<IWORKXMLContextPtr_t> contextStack;
int ret = xmlTextReaderRead(reader);
contextStack.push(createDocumentContext());
bool keynoteDocTypeChecked=false;
char const *defaultNS=nullptr;
while ((1 == ret))
{
switch (xmlTextReaderNodeType(reader))
{
case XML_READER_TYPE_ELEMENT:
{
if (!keynoteDocTypeChecked)
{
// check for keynote 1 file with doctype node and not a namespace in first node
keynoteDocTypeChecked=true;
if (xmlTextReaderNodeType(reader)==XML_READER_TYPE_ELEMENT &&
xmlTextReaderConstNamespaceUri(reader)==nullptr)
defaultNS="http://developer.apple.com/schemas/APXL";
}
const int id = tokenizer.getQualifiedId(char_cast(xmlTextReaderConstLocalName(reader)),
defaultNS ? defaultNS : char_cast(xmlTextReaderConstNamespaceUri(reader)));
IWORKXMLContextPtr_t newContext = contextStack.top()->element(id);
if (!newContext)
newContext = createDiscardContext();
const bool isEmpty = xmlTextReaderIsEmptyElement(reader);
newContext->startOfElement();
if (xmlTextReaderHasAttributes(reader))
{
ret = xmlTextReaderMoveToFirstAttribute(reader);
while (1 == ret)
{
processAttribute(reader, newContext, tokenizer);
ret = xmlTextReaderMoveToNextAttribute(reader);
}
}
if (isEmpty)
newContext->endOfElement();
else
contextStack.push(newContext);
break;
}
case XML_READER_TYPE_END_ELEMENT:
{
contextStack.top()->endOfElement();
contextStack.pop();
break;
}
case XML_READER_TYPE_CDATA :
{
const xmlChar *text = xmlTextReaderConstValue(reader);
if (text) contextStack.top()->CDATA(char_cast(text));
break;
}
case XML_READER_TYPE_TEXT :
{
xmlChar *const text = xmlTextReaderReadString(reader);
contextStack.top()->text(char_cast(text));
xmlFree(text);
break;
}
default:
break;
}
ret = xmlTextReaderRead(reader);
}
while (!contextStack.empty()) // finish parsing in case of broken XML
{
contextStack.top()->endOfElement();
contextStack.pop();
}
xmlTextReaderClose(reader);
return true;
}
int XMIResource::processNode(xmlTextReaderPtr reader)
{
// manage only xcos related XML nodes
const xmlChar* nsURI = xmlTextReaderConstNamespaceUri(reader);
if (nsURI == xcosNamespaceUri || nsURI == nullptr)
{
xmlReaderTypes nodeType = (xmlReaderTypes) xmlTextReaderNodeType(reader);
switch (nodeType)
{
case XML_READER_TYPE_NONE:
return 1;
case XML_READER_TYPE_ELEMENT:
return processElement(reader);
case XML_READER_TYPE_ATTRIBUTE:
sciprint("xmlReader attributes node not supported\n");
return -1;
case XML_READER_TYPE_TEXT:
return processText(reader);
case XML_READER_TYPE_CDATA:
return processText(reader);
case XML_READER_TYPE_ENTITY_REFERENCE:
sciprint("xmlReader entity reference not supported\n");
return -1;
case XML_READER_TYPE_ENTITY:
sciprint("xmlReader entity not supported\n");
return -1;
case XML_READER_TYPE_PROCESSING_INSTRUCTION:
sciprint("xmlReader processing instruction not supported\n");
return -1;
case XML_READER_TYPE_COMMENT:
return 1;
case XML_READER_TYPE_DOCUMENT:
return 1;
case XML_READER_TYPE_DOCUMENT_TYPE:
sciprint("xmlReader document type not supported\n");
return -1;
case XML_READER_TYPE_DOCUMENT_FRAGMENT:
sciprint("xmlReader document fragment not supported\n");
return -1;
case XML_READER_TYPE_NOTATION:
sciprint("xmlReader notation not supported\n");
return -1;
case XML_READER_TYPE_WHITESPACE:
sciprint("xmlReader whitespace not supported\n");
return -1;
case XML_READER_TYPE_SIGNIFICANT_WHITESPACE:
return 1; // ignore indent or end-of-line
case XML_READER_TYPE_END_ELEMENT:
return processEndElement(reader);
case XML_READER_TYPE_END_ENTITY:
sciprint("xmlReader end entity not supported\n");
return -1;
case XML_READER_TYPE_XML_DECLARATION:
sciprint("xmlReader XML declaration not supported\n");
return -1;
}
}
else
{
// TODO mixed model should be preserved in some way and restored back on XMIResource_save.cpp .
}
sciprint("unable to process node\n");
return -1;
}
/**
* Reads a Name from XML. The reader is assumed to be at the start element.
*
* @return the Name, or NULL in case of error.
*/
static struct ifyouwannabecool_persona_name *xmlTextReaderReadPersonaNameType(xmlTextReaderPtr reader) {
int status, depth;
void *_child_accessor;
struct ifyouwannabecool_persona_name *_name = calloc(1, sizeof(struct ifyouwannabecool_persona_name));
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
freePersonaNameType(_name);
free(_name);
return NULL;
}
else if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT
&& xmlStrcmp(BAD_CAST "givenName", xmlTextReaderConstLocalName(reader)) == 0
&& xmlTextReaderConstNamespaceUri(reader) == NULL) {
#if DEBUG_ENUNCIATE > 1
printf("Attempting to read choice {}givenName of type {http://www.w3.org/2001/XMLSchema}string.\n");
#endif
_child_accessor = xmlTextReaderReadXsStringType(reader);
if (_child_accessor == NULL) {
#if DEBUG_ENUNCIATE
printf("Failed to read choice {}givenName of type {http://www.w3.org/2001/XMLSchema}string.\n");
#endif
//panic: unable to read the child element for some reason.
freePersonaNameType(_name);
free(_name);
return NULL;
}
_name->givenName = ((xmlChar*)_child_accessor);
status = xmlTextReaderAdvanceToNextStartOrEndElement(reader);
}
else if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT
&& xmlStrcmp(BAD_CAST "surname", xmlTextReaderConstLocalName(reader)) == 0
&& xmlTextReaderConstNamespaceUri(reader) == NULL) {
#if DEBUG_ENUNCIATE > 1
printf("Attempting to read choice {}surname of type {http://www.w3.org/2001/XMLSchema}string.\n");
#endif
_child_accessor = xmlTextReaderReadXsStringType(reader);
if (_child_accessor == NULL) {
#if DEBUG_ENUNCIATE
printf("Failed to read choice {}surname of type {http://www.w3.org/2001/XMLSchema}string.\n");
#endif
//panic: unable to read the child element for some reason.
freePersonaNameType(_name);
free(_name);
return NULL;
}
_name->surname = ((xmlChar*)_child_accessor);
status = xmlTextReaderAdvanceToNextStartOrEndElement(reader);
}
else {
#if DEBUG_ENUNCIATE > 1
if (xmlTextReaderConstNamespaceUri(reader) == NULL) {
printf("unknown child element {}%s for type {http://api.ifyouwannabecool.com/persona}name. Skipping...\n", xmlTextReaderConstLocalName(reader));
}
else {
printf("unknown child element {%s}%s for type {http://api.ifyouwannabecool.com/persona}name. Skipping...\n", xmlTextReaderConstNamespaceUri(reader), xmlTextReaderConstLocalName(reader));
}
#endif
status = xmlTextReaderSkipElement(reader);
}
}
}
return _name;
}
/* @method String XmlReader.constNamespaceUri() */
METHOD XmlReader_constNamespaceUri(Ctx *ctx, knh_sfp_t *sfp)
{
xmlTextReaderPtr reader = (xmlTextReaderPtr) p_cptr(sfp[0]);
char* ret = (char*) xmlTextReaderConstNamespaceUri(reader);
KNH_RETURN(ctx,sfp,new_String(ctx,B(ret),NULL));
}
/**
* Reads a ControllerProperties from XML. The reader is assumed to be at the start element.
*
* @return the ControllerProperties, or NULL in case of error.
*/
static struct full_ns0_controllerProperties *xmlTextReaderReadNs0ControllerPropertiesType(xmlTextReaderPtr reader) {
int status, depth;
void *_child_accessor;
struct full_ns0_controllerProperties *_controllerProperties = calloc(1, sizeof(struct full_ns0_controllerProperties));
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
freeNs0ControllerPropertiesType(_controllerProperties);
free(_controllerProperties);
return NULL;
}
else if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT
&& xmlStrcmp(BAD_CAST "properties", xmlTextReaderConstLocalName(reader)) == 0
&& xmlTextReaderConstNamespaceUri(reader) == NULL) {
if (xmlTextReaderIsEmptyElement(reader) == 0) {
#if DEBUG_ENUNCIATE > 1
printf("Unwrapping wrapper element {}properties...\n");
#endif
//start wrapper element "{}properties"
status = xmlTextReaderAdvanceToNextStartOrEndElement(reader);
while (xmlTextReaderDepth(reader) > (depth + 1)) {
if (status < 1) {
//panic: XML read error.
#if DEBUG_ENUNCIATE
printf("Failure to advance to next child element.\n");
#endif
freeNs0ControllerPropertiesType(_controllerProperties);
free(_controllerProperties);
return NULL;
}
else if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT
&& xmlStrcmp(BAD_CAST "property", xmlTextReaderConstLocalName(reader)) == 0
&& xmlTextReaderConstNamespaceUri(reader) == NULL) {
#if DEBUG_ENUNCIATE > 1
printf("Attempting to read choice {}property of element {}property.\n");
#endif
_child_accessor = xmlTextReaderReadNs0PropertyElement(reader);
if (_child_accessor == NULL) {
#if DEBUG_ENUNCIATE
printf("Failed to read choice {}property of element {}property.\n");
#endif
//panic: unable to read the child element for some reason.
freeNs0ControllerPropertiesType(_controllerProperties);
free(_controllerProperties);
return NULL;
}
_controllerProperties->properties = realloc(_controllerProperties->properties, (_controllerProperties->_sizeof_properties + 1) * sizeof(struct full_ns0_property));
memcpy(&(_controllerProperties->properties[_controllerProperties->_sizeof_properties++]), _child_accessor, sizeof(struct full_ns0_property));
free(_child_accessor);
status = xmlTextReaderAdvanceToNextStartOrEndElement(reader);
}
} // end "while in wrapper element" loop
} //end "if empty element" clause
if (status < 1) {
//panic: XML read error.
#if DEBUG_ENUNCIATE
printf("Failed to advance to end wrapper element {}properties.\n");
#endif
freeNs0ControllerPropertiesType(_controllerProperties);
free(_controllerProperties);
return NULL;
}
else {
//end wrapper element "{}properties"
status = xmlTextReaderAdvanceToNextStartOrEndElement(reader);
}
} // end "if wrapper element" clause
else {
#if DEBUG_ENUNCIATE > 1
if (xmlTextReaderConstNamespaceUri(reader) == NULL) {
printf("unknown child element {}%s for type {}controllerProperties. Skipping...\n", xmlTextReaderConstLocalName(reader));
}
else {
printf("unknown child element {%s}%s for type {}controllerProperties. Skipping...\n", xmlTextReaderConstNamespaceUri(reader), xmlTextReaderConstLocalName(reader));
}
#endif
status = xmlTextReaderSkipElement(reader);
}
}
}
return _controllerProperties;
}
/**
* Reads a UserConfig from XML. The reader is assumed to be at the start element.
*
* @return the UserConfig, or NULL in case of error.
*/
static struct full_ns0_userConfig *xmlTextReaderReadNs0UserConfigType(xmlTextReaderPtr reader) {
int status, depth;
void *_child_accessor;
struct full_ns0_userConfig *_userConfig = calloc(1, sizeof(struct full_ns0_userConfig));
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
freeNs0UserConfigType(_userConfig);
free(_userConfig);
return NULL;
}
else if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT
&& xmlStrcmp(BAD_CAST "user", xmlTextReaderConstLocalName(reader)) == 0
&& xmlTextReaderConstNamespaceUri(reader) == NULL) {
#if DEBUG_ENUNCIATE > 1
printf("Attempting to read choice {}user of type {http://www.w3.org/2001/XMLSchema}string.\n");
#endif
_child_accessor = xmlTextReaderReadXsStringType(reader);
if (_child_accessor == NULL) {
#if DEBUG_ENUNCIATE
printf("Failed to read choice {}user of type {http://www.w3.org/2001/XMLSchema}string.\n");
#endif
//panic: unable to read the child element for some reason.
freeNs0UserConfigType(_userConfig);
free(_userConfig);
return NULL;
}
_userConfig->user = ((xmlChar*)_child_accessor);
status = xmlTextReaderAdvanceToNextStartOrEndElement(reader);
}
else if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT
&& xmlStrcmp(BAD_CAST "roles", xmlTextReaderConstLocalName(reader)) == 0
&& xmlTextReaderConstNamespaceUri(reader) == NULL) {
#if DEBUG_ENUNCIATE > 1
printf("Attempting to read choice {}roles of type {http://www.w3.org/2001/XMLSchema}string.\n");
#endif
_child_accessor = xmlTextReaderReadXsStringType(reader);
if (_child_accessor == NULL) {
#if DEBUG_ENUNCIATE
printf("Failed to read choice {}roles of type {http://www.w3.org/2001/XMLSchema}string.\n");
#endif
//panic: unable to read the child element for some reason.
freeNs0UserConfigType(_userConfig);
free(_userConfig);
return NULL;
}
_userConfig->roles = realloc(_userConfig->roles, (_userConfig->_sizeof_roles + 1) * sizeof(xmlChar));
memcpy(&(_userConfig->roles[_userConfig->_sizeof_roles++]), _child_accessor, sizeof(xmlChar));
free(_child_accessor);
status = xmlTextReaderAdvanceToNextStartOrEndElement(reader);
}
else if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT
&& xmlStrcmp(BAD_CAST "password", xmlTextReaderConstLocalName(reader)) == 0
&& xmlTextReaderConstNamespaceUri(reader) == NULL) {
#if DEBUG_ENUNCIATE > 1
printf("Attempting to read choice {}password of type {http://www.w3.org/2001/XMLSchema}string.\n");
#endif
_child_accessor = xmlTextReaderReadXsStringType(reader);
if (_child_accessor == NULL) {
#if DEBUG_ENUNCIATE
printf("Failed to read choice {}password of type {http://www.w3.org/2001/XMLSchema}string.\n");
#endif
//panic: unable to read the child element for some reason.
freeNs0UserConfigType(_userConfig);
free(_userConfig);
return NULL;
}
_userConfig->password = ((xmlChar*)_child_accessor);
status = xmlTextReaderAdvanceToNextStartOrEndElement(reader);
}
else {
#if DEBUG_ENUNCIATE > 1
if (xmlTextReaderConstNamespaceUri(reader) == NULL) {
printf("unknown child element {}%s for type {}userConfig. Skipping...\n", xmlTextReaderConstLocalName(reader));
}
else {
printf("unknown child element {%s}%s for type {}userConfig. Skipping...\n", xmlTextReaderConstNamespaceUri(reader), xmlTextReaderConstLocalName(reader));
}
#endif
status = xmlTextReaderSkipElement(reader);
}
}
}
return _userConfig;
}
bool IWORKParser::parse()
{
const shared_ptr<xmlTextReader> sharedReader(xmlReaderForIO(readFromStream, closeStream, m_input.get(), "", 0, 0), xmlFreeTextReader);
if (!sharedReader)
return false;
xmlTextReaderPtr reader = sharedReader.get();
assert(reader);
const IWORKTokenizer &tokenizer = getTokenizer();
stack<IWORKXMLContextPtr_t> contextStack;
int ret = xmlTextReaderRead(reader);
contextStack.push(createDocumentContext());
while ((1 == ret))
{
switch (xmlTextReaderNodeType(reader))
{
case XML_READER_TYPE_ELEMENT:
{
const int id = tokenizer.getQualifiedId(char_cast(xmlTextReaderConstLocalName(reader)), char_cast(xmlTextReaderConstNamespaceUri(reader)));
IWORKXMLContextPtr_t newContext = contextStack.top()->element(id);
if (!newContext)
newContext = createDiscardContext();
const bool isEmpty = xmlTextReaderIsEmptyElement(reader);
newContext->startOfElement();
if (xmlTextReaderHasAttributes(reader))
{
ret = xmlTextReaderMoveToFirstAttribute(reader);
while (1 == ret)
{
processAttribute(reader, newContext, tokenizer);
ret = xmlTextReaderMoveToNextAttribute(reader);
}
}
if (isEmpty)
newContext->endOfElement();
else
contextStack.push(newContext);
break;
}
case XML_READER_TYPE_END_ELEMENT:
{
contextStack.top()->endOfElement();
contextStack.pop();
break;
}
case XML_READER_TYPE_TEXT :
{
xmlChar *const text = xmlTextReaderReadString(reader);
contextStack.top()->text(char_cast(text));
xmlFree(text);
break;
}
default:
break;
}
ret = xmlTextReaderRead(reader);
}
while (!contextStack.empty()) // finish parsing in case of broken XML
{
contextStack.top()->endOfElement();
contextStack.pop();
}
xmlTextReaderClose(reader);
return true;
}
static void
dax_dom_document_read_node (DaxDomDocument *document,
ParserContext *ctx)
{
int type;
type = xmlTextReaderNodeType (ctx->reader);
switch (type) {
case DAX_DOM_NODE_TYPE_ELEMENT:
{
const xmlChar *local_name = xmlTextReaderConstLocalName (ctx->reader);
const gchar *name = (const gchar *)local_name;
DaxDomElement *new_element;
gboolean is_empty = FALSE;
new_element = dax_dom_document_create_element (document, name, NULL);
if (G_UNLIKELY (new_element == NULL)) {
g_message ("Unsupported element %s", name);
new_element =
dax_dom_document_create_element (document, "desc", NULL);
}
DAX_NOTE (PARSING, "Append %s to %s",
G_OBJECT_TYPE_NAME (new_element),
G_OBJECT_TYPE_NAME (ctx->current_node));
dax_dom_node_append_child (ctx->current_node,
DAX_DOM_NODE (new_element),
NULL);
ctx->current_node = DAX_DOM_NODE (new_element);
if (xmlTextReaderIsEmptyElement (ctx->reader))
is_empty = TRUE;
/* Parse attributes */
while (xmlTextReaderMoveToNextAttribute (ctx->reader) == 1) {
const xmlChar *_name = xmlTextReaderConstName (ctx->reader);
const xmlChar *_value = xmlTextReaderConstValue (ctx->reader);
const xmlChar *_ns = xmlTextReaderConstNamespaceUri (ctx->reader);
dax_dom_element_set_attribute_ns (new_element,
(const gchar *)_ns,
(const gchar *)_name,
(const gchar *)_value,
NULL);
}
/* if the element is empty a DAX_DOM_NODE_TYPE_END_ELEMENT won't
* be emited, so update current_node here */
if (is_empty)
dax_dom_document_end_element (ctx);
break;
}
case DAX_DOM_NODE_TYPE_END_ELEMENT:
dax_dom_document_end_element (ctx);
break;
case DAX_DOM_NODE_TYPE_TEXT_NODE:
case DAX_DOM_NODE_TYPE_CDATA_SECTION:
{
const xmlChar *value = xmlTextReaderConstValue (ctx->reader);
const gchar *data = (const gchar *)value;
DaxDomText *new_text;
new_text = dax_dom_document_create_text_node (document, data);
/* Happens if we are short on memory, hopefully never */
if (G_UNLIKELY (new_text == NULL)) {
g_critical ("Cannot create text node");
break;
}
DAX_NOTE (PARSING, "Append text node to %s",
G_OBJECT_TYPE_NAME (ctx->current_node));
dax_dom_node_append_child (ctx->current_node,
DAX_DOM_NODE (new_text),
NULL);
break;
}
default:
break;
}
}
/**
* Reads a SocialGroup from XML. The reader is assumed to be at the start element.
*
* @return the SocialGroup, or NULL in case of error.
*/
static struct ifyouwannabecool_link_socialGroup *xmlTextReaderReadLinkSocialGroupType(xmlTextReaderPtr reader) {
int status, depth;
void *_child_accessor;
struct ifyouwannabecool_link_socialGroup *_socialGroup = calloc(1, sizeof(struct ifyouwannabecool_link_socialGroup));
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
freeLinkSocialGroupType(_socialGroup);
free(_socialGroup);
return NULL;
}
else if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT
&& xmlStrcmp(BAD_CAST "id", xmlTextReaderConstLocalName(reader)) == 0
&& xmlTextReaderConstNamespaceUri(reader) == NULL) {
#if DEBUG_ENUNCIATE > 1
printf("Attempting to read choice {}id of type {http://www.w3.org/2001/XMLSchema}string.\n");
#endif
_child_accessor = xmlTextReaderReadXsStringType(reader);
if (_child_accessor == NULL) {
#if DEBUG_ENUNCIATE
printf("Failed to read choice {}id of type {http://www.w3.org/2001/XMLSchema}string.\n");
#endif
//panic: unable to read the child element for some reason.
freeLinkSocialGroupType(_socialGroup);
free(_socialGroup);
return NULL;
}
_socialGroup->id = ((xmlChar*)_child_accessor);
status = xmlTextReaderAdvanceToNextStartOrEndElement(reader);
}
else if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT
&& xmlStrcmp(BAD_CAST "memberIds", xmlTextReaderConstLocalName(reader)) == 0
&& xmlTextReaderConstNamespaceUri(reader) == NULL) {
#if DEBUG_ENUNCIATE > 1
printf("Attempting to read choice {}memberIds of type {http://www.w3.org/2001/XMLSchema}string.\n");
#endif
_child_accessor = xmlTextReaderReadXsStringType(reader);
if (_child_accessor == NULL) {
#if DEBUG_ENUNCIATE
printf("Failed to read choice {}memberIds of type {http://www.w3.org/2001/XMLSchema}string.\n");
#endif
//panic: unable to read the child element for some reason.
freeLinkSocialGroupType(_socialGroup);
free(_socialGroup);
return NULL;
}
_socialGroup->memberIds = realloc(_socialGroup->memberIds, (_socialGroup->_sizeof_memberIds + 1) * sizeof(xmlChar));
memcpy(&(_socialGroup->memberIds[_socialGroup->_sizeof_memberIds++]), _child_accessor, sizeof(xmlChar));
free(_child_accessor);
status = xmlTextReaderAdvanceToNextStartOrEndElement(reader);
}
else if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT
&& xmlStrcmp(BAD_CAST "groupLeaderId", xmlTextReaderConstLocalName(reader)) == 0
&& xmlTextReaderConstNamespaceUri(reader) == NULL) {
#if DEBUG_ENUNCIATE > 1
printf("Attempting to read choice {}groupLeaderId of type {http://www.w3.org/2001/XMLSchema}string.\n");
#endif
_child_accessor = xmlTextReaderReadXsStringType(reader);
if (_child_accessor == NULL) {
#if DEBUG_ENUNCIATE
printf("Failed to read choice {}groupLeaderId of type {http://www.w3.org/2001/XMLSchema}string.\n");
#endif
//panic: unable to read the child element for some reason.
freeLinkSocialGroupType(_socialGroup);
free(_socialGroup);
return NULL;
}
_socialGroup->groupLeaderId = ((xmlChar*)_child_accessor);
status = xmlTextReaderAdvanceToNextStartOrEndElement(reader);
}
else if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT
&& xmlStrcmp(BAD_CAST "exclusive", xmlTextReaderConstLocalName(reader)) == 0
&& xmlTextReaderConstNamespaceUri(reader) == NULL) {
#if DEBUG_ENUNCIATE > 1
printf("Attempting to read choice {}exclusive of type {http://www.w3.org/2001/XMLSchema}boolean.\n");
#endif
_child_accessor = xmlTextReaderReadXsBooleanType(reader);
if (_child_accessor == NULL) {
#if DEBUG_ENUNCIATE
printf("Failed to read choice {}exclusive of type {http://www.w3.org/2001/XMLSchema}boolean.\n");
#endif
//panic: unable to read the child element for some reason.
freeLinkSocialGroupType(_socialGroup);
free(_socialGroup);
return NULL;
}
_socialGroup->exclusive = *((int*)_child_accessor);
free(_child_accessor);
status = xmlTextReaderAdvanceToNextStartOrEndElement(reader);
}
else {
#if DEBUG_ENUNCIATE > 1
if (xmlTextReaderConstNamespaceUri(reader) == NULL) {
printf("unknown child element {}%s for type {http://api.ifyouwannabecool.com/link}socialGroup. Skipping...\n", xmlTextReaderConstLocalName(reader));
}
else {
printf("unknown child element {%s}%s for type {http://api.ifyouwannabecool.com/link}socialGroup. Skipping...\n", xmlTextReaderConstNamespaceUri(reader), xmlTextReaderConstLocalName(reader));
}
#endif
status = xmlTextReaderSkipElement(reader);
}
}
}
return _socialGroup;
}