自学教程：C++ xmlStrncmp函数代码示例

static intxmlconfig_load_timer( xmlTextReaderPtr reader ){	int ret;	const xmlChar *name;        	ret = xmlTextReaderRead( reader );	while ( ret == 1 ) {		name = xmlTextReaderConstName( reader );		if ( name &&                    (XML_READER_TYPE_END_ELEMENT != xmlTextReaderNodeType( reader )) &&                    ( 0 == xmlStrncmp( name, (const xmlChar *)"Timer", 7 ) ) )		{			const xmlChar *nodeid = xmlTextReaderGetAttribute( reader, (const xmlChar*)"node" );			const xmlChar *tname = xmlTextReaderGetAttribute( reader, (const xmlChar*)"name" );			const xmlChar *on = xmlTextReaderGetAttribute( reader, (const xmlChar*)"on" );			const xmlChar *off = xmlTextReaderGetAttribute( reader, (const xmlChar*)"off" );                        			SYSLOG_DEBUG( "xmlconfig_load_timer: Name=%s Id=%s ON=%s, OFF=%s",                                     tname, nodeid, on, off );                }		if ( (XML_READER_TYPE_END_ELEMENT == xmlTextReaderNodeType( reader )) &&			(0 == xmlStrncmp(name, (const xmlChar *)"TimerConfig", 11)))			break;		ret = xmlTextReaderRead( reader );	}	return ret;}

MANSCDP_xml_type get_xml_type(char* xml_type_string){    if(NULL == xml_type_string)    {        return MANSCDP_xml_Unknown;    }    if(0 == xmlStrncmp(xml_type_string, "Control", xmlStrlen("Control")))    {        return MANSCDP_xml_Control;    }    if(0 == xmlStrncmp(xml_type_string, "Query", xmlStrlen("Query")))    {        return MANSCDP_xml_Query;    }    if(0 == xmlStrncmp(xml_type_string, "Notify", xmlStrlen("Notify")))    {        return MANSCDP_xml_Notify;    }    if(0 == xmlStrncmp(xml_type_string, "Response", xmlStrlen("Response")))    {        return MANSCDP_xml_Response;    }    return MANSCDP_xml_Unknown;}

static intxmlconfig_load_node( xmlTextReaderPtr reader ){	int ret;	const xmlChar *name;        	ret = xmlTextReaderRead( reader );	while ( ret == 1 ) {		name = xmlTextReaderConstName( reader );		if ( name &&                    (XML_READER_TYPE_END_ELEMENT != xmlTextReaderNodeType( reader )) &&                    ( 0 == xmlStrncmp( name, (const xmlChar *)"Node", 7 ) ) )		{			const xmlChar *id = xmlTextReaderGetAttribute( reader, (const xmlChar*)"id" );			const xmlChar *nname = xmlTextReaderGetAttribute( reader, (const xmlChar*)"name" );			const xmlChar *type = xmlTextReaderGetAttribute( reader, (const xmlChar*)"type" );                        			SYSLOG_DEBUG( "xmlconfig_load_node: Name=%s Id=%s Type=%s",                                     	nname, id, type );                                                ret = zw_node_set_label( atoi((const char*)id), (char *)nname );                        if ( ret )                                SYSLOG_DEBUG( "xmlconfig_load_node: set label for node(%d) failed %d", atoi((const char*)id), ret );		}		if ( (XML_READER_TYPE_END_ELEMENT == xmlTextReaderNodeType( reader )) &&			(0 == xmlStrncmp(name, (const xmlChar *)"NodeConfig", 10)))			break;                		ret = xmlTextReaderRead( reader );	}	return ret;}

MANSCDP_result_type get_MANSCDP_statues(char* MANSCDP_string){    if(0 == xmlStrncmp(MANSCDP_string, "OK", xmlStrlen("OK")))    {        return MANSCDP_OK;    }    if(0 == xmlStrncmp(MANSCDP_string, "ERROR", xmlStrlen("ERROR")))    {        return MANSCDP_ERROR;    }    return MANSCDP_UNKNOWN_RESULT_TYPE;}

MANSCDP_on_off_line get_MANSCDP_online(char* MANSCDP_string){    if(0 == xmlStrncmp(MANSCDP_string, "ONLINE", xmlStrlen("ONLINE")))    {        return MANSCDP_ONLINE;    }    if(0 == xmlStrncmp(MANSCDP_string, "OFFLINE", xmlStrlen("OFFLINE")))    {        return MANSCDP_OFFLINE;    }    return MANSCDP_UNKNOWN_ON_OFF_LINE;}

voidags_count_beats_audio_run_read(AgsFile *file, xmlNode *node, AgsPlugin *plugin){  AgsCountBeatsAudioRun *count_beats_audio_run;  AgsFileLookup *file_lookup;  xmlNode *iter;  /* read parent */  ags_count_beats_audio_run_parent_plugin_interface->read(file, node, plugin);  count_beats_audio_run = AGS_COUNT_BEATS_AUDIO_RUN(plugin);  /* read depenendency */  iter = node->children;  while(iter != NULL){    if(iter->type == XML_ELEMENT_NODE){      if(!xmlStrncmp(iter->name,		     "ags-dependency-list/0",		     19)){	xmlNode *dependency_node;	dependency_node = iter->children;	while(dependency_node != NULL){	  if(dependency_node->type == XML_ELEMENT_NODE){	    if(!xmlStrncmp(dependency_node->name,			   "ags-dependency/0",			   15)){	      file_lookup = (AgsFileLookup *) g_object_new(AGS_TYPE_FILE_LOOKUP,							   "file/0", file,							   "node/0", dependency_node,							   "reference/0", count_beats_audio_run,							   NULL);	      ags_file_add_lookup(file, (GObject *) file_lookup);	      g_signal_connect(G_OBJECT(file_lookup), "resolve/0",			       G_CALLBACK(ags_count_beats_audio_run_read_resolve_dependency), count_beats_audio_run);	    }	  }	  	  dependency_node = dependency_node->next;	}      }    }    iter = iter->next;  }}

/** * xmlUTF8Strloc: * @utf:  the input UTF8 * * @utfchar:  the UTF8 character to be found * * a function to provide the relative location of a UTF8 char * * Returns the relative character position of the desired char * or -1 if not found */intxmlUTF8Strloc(const xmlChar *utf, const xmlChar *utfchar){  int i, size;  xmlChar ch;  if (utf==NULL || utfchar==NULL) return -1;  size = xmlUTF8Strsize(utfchar, 1);  for (i=0; (ch=*utf) != 0; i++)  {    if (xmlStrncmp(utf, utfchar, size)==0)      return(i);    utf++;    if ( ch & 0x80 )    {      /* if not simple ascii, verify proper format */      if ( (ch & 0xc0) != 0xc0 )        return(-1);      /* then skip over remaining bytes for this char */      while ( (ch <<= 1) & 0x80 )        if ( (*utf++ & 0xc0) != 0x80 )          return(-1);    }  }  return(-1);}

static voidhandle_start_sync (GstSamiContext * sctx, const xmlChar ** atts){  int i;  sami_context_pop_state (sctx, CLEAR_TAG);  if (atts != NULL) {    for (i = 0; (atts[i] != NULL); i += 2) {      const xmlChar *key, *value;      key = atts[i];      value = atts[i + 1];      if (!value)        continue;      if (!xmlStrncmp ((const xmlChar *) "start", key, 5)) {        /* Only set a new start time if we don't have text pending */        if (sctx->resultbuf->len == 0)          sctx->time1 = sctx->time2;        sctx->time2 = atoi ((const char *) value) * GST_MSECOND;        g_string_append (sctx->resultbuf, sctx->buf->str);        sctx->has_result = (sctx->resultbuf->len != 0) ? TRUE : FALSE;        g_string_truncate (sctx->buf, 0);      }    }  }}

guint*ags_script_object_read_index(gchar *xpath, guint *index_length){  guint *index;  gchar *offset;  guint i;  index = NULL;  offset = xpath;  i = 0;  while((offset = strchr(offset, '[')) != NULL && offset[0] != '/0'){    if(i == 0){      index = (guint *) malloc(sizeof(guint));    }else{      index = (guint *) realloc(index, (i + 1) * sizeof(guint));    }    if(!xmlStrncmp(offset, "last()/0", 7)){      index[i] = AGS_SCRIPT_OBJECT_XPATH_NaN;    }else{      sscanf(xpath, "%d/0", &(index[i]));    }    offset = &(offset[1]);    i++;  }  *index_length = i;  return(index);}

/** * /brief Remove input plugin from supportedCollectors tag *  * /param info tool configuration * /return 0 on success */int remove_supported(conf_info_t *info){	int i;	xmlNodePtr children1;	xmlXPathObjectPtr xpath_obj_file = eval_xpath(info, TAG_SUPPORTED);	if (!xpath_obj_file) {		return 1;	}		for (i = 0; i < xpath_obj_file->nodesetval->nodeNr; i++) {		children1 = xpath_obj_file->nodesetval->nodeTab[i]->children;		while (children1) {			if ((!strncmp ((char*) children1->name, "name", strlen ("name") + 1))			        && (!xmlStrncmp (children1->children->content, (xmlChar *) info->name, xmlStrlen ((xmlChar *)info->name) + 1))) {				/* element found*/				xmlUnlinkNode(children1);				xmlFreeNode(children1);				return 0;			}			children1 = children1->next;		}	}		return 0;}

static gbooleanmate_da_xml_get_bool (const xmlNode *parent, const gchar *val_name){    xmlNode *element;    gboolean ret_val = FALSE;    xmlChar *xml_val_name;    gint len;    g_return_val_if_fail (parent != NULL, FALSE);    g_return_val_if_fail (parent->children != NULL, ret_val);    g_return_val_if_fail (val_name != NULL, FALSE);    xml_val_name = xmlCharStrdup (val_name);    len = xmlStrlen (xml_val_name);    for (element = parent->children; element != NULL; element = element->next) {	if (!xmlStrncmp (element->name, xml_val_name, len)) {	    xmlChar *cont = xmlNodeGetContent (element);	    if (!xmlStrcasecmp (cont, "true") || !xmlStrcasecmp (cont, "1"))		ret_val = TRUE;	    else		ret_val = FALSE;	    xmlFree (cont);	}    }    xmlFree (xml_val_name);    return ret_val;}

static voidstart_sami_element (void *ctx, const xmlChar * name, const xmlChar ** atts){  GstSamiContext *sctx = (GstSamiContext *) ctx;  GST_LOG ("name:%s", name);  if (!xmlStrncmp ((const xmlChar *) "sync", name, 4)) {    handle_start_sync (sctx, atts);    sctx->in_sync = TRUE;  } else if (!xmlStrncmp ((const xmlChar *) "font", name, 4)) {    handle_start_font (sctx, atts);  } else if (!xmlStrncmp ((const xmlChar *) "ruby", name, 4)) {    sami_context_push_state (sctx, RUBY_TAG);  } else if (!xmlStrncmp ((const xmlChar *) "br", name, 2)) {    g_string_append_c (sctx->buf, '/n');    /* FIXME: support for furigana/ruby once implemented in pango */  } else if (!xmlStrncmp ((const xmlChar *) "rt", name, 2)) {    if (has_tag (sctx->state, ITALIC_TAG)) {      g_string_append (sctx->rubybuf, "<i>");    }    g_string_append (sctx->rubybuf, "<span size='xx-small' rise='-100'>");    sami_context_push_state (sctx, RT_TAG);  } else if (!xmlStrncmp ((const xmlChar *) "p", name, 1)) {  } else if (!xmlStrncmp ((const xmlChar *) "i", name, 1)) {    g_string_append (sctx->buf, "<i>");    sami_context_push_state (sctx, ITALIC_TAG);  }}

/** * xmlUTF8Charcmp: * @utf1: pointer to first UTF8 char * @utf2: pointer to second UTF8 char * * compares the two UCS4 values * * returns result of the compare as with xmlStrncmp */intxmlUTF8Charcmp(const xmlChar *utf1, const xmlChar *utf2) {    if (utf1 == NULL ) {        if (utf2 == NULL)            return 0;        return -1;    }    return xmlStrncmp(utf1, utf2, xmlUTF8Size(utf1));}

static voidend_sami_element (void *ctx, const xmlChar * name){  GstSamiContext *sctx = (GstSamiContext *) ctx;  GST_LOG ("name:%s", name);  if (!xmlStrncmp ((const xmlChar *) "sync", name, 4)) {    sctx->in_sync = FALSE;  } else if ((!xmlStrncmp ((const xmlChar *) "body", name, 4)) ||      (!xmlStrncmp ((const xmlChar *) "sami", name, 4))) {    /* We will usually have one buffer left when the body is closed     * as we need the next sync to actually send it */    if (sctx->buf->len != 0) {      /* Only set a new start time if we don't have text pending */      if (sctx->resultbuf->len == 0)        sctx->time1 = sctx->time2;      sctx->time2 = GST_CLOCK_TIME_NONE;      g_string_append (sctx->resultbuf, sctx->buf->str);      sctx->has_result = (sctx->resultbuf->len != 0) ? TRUE : FALSE;      g_string_truncate (sctx->buf, 0);    }  } else if (!xmlStrncmp ((const xmlChar *) "font", name, 4)) {    sami_context_pop_state (sctx, SPAN_TAG);  } else if (!xmlStrncmp ((const xmlChar *) "ruby", name, 4)) {    sami_context_pop_state (sctx, RUBY_TAG);  } else if (!xmlStrncmp ((const xmlChar *) "i", name, 1)) {    sami_context_pop_state (sctx, ITALIC_TAG);  }}

/** * xsltUTF8Charcmp * @utf1: pointer to first UTF8 char * @utf2: pointer to second UTF8 char * * returns result of comparing the two UCS4 values * as with xmlStrncmp */static intxsltUTF8Charcmp(xmlChar *utf1, xmlChar *utf2) {    int len = xmlUTF8Strsize(utf1, 1);    if (len < 1)        return -1;    if (utf1 == NULL ) {        if (utf2 == NULL)            return 0;        return -1;    }    return xmlStrncmp(utf1, utf2, len);}

MANSCDP_command_type get_MANSCDP_command_type(char* MANSCDP_command_string){    if(NULL == MANSCDP_command_string)    {        return MANSCDP_command_type_unknown;    }    if(0 == xmlStrncmp(MANSCDP_command_string, "DeviceInfo", xmlStrlen("DeviceInfo")))    {        return MANSCDP_DeviceInfo;    }    if(0 == xmlStrncmp(MANSCDP_command_string, "DeviceStatus", xmlStrlen("DeviceStatus")))    {        return MANSCDP_DeviceStatus;    }    if(0 == xmlStrncmp(MANSCDP_command_string, "Catalog", xmlStrlen("Catalog")))    {        return MANSCDP_Catalog;    }    return MANSCDP_command_type_unknown;}

int xmlconfig_load( const char *filename ){	int rc = -1;	int ret;	xmlTextReaderPtr reader;	const xmlChar *name;        	reader = xmlReaderForFile( filename, NULL, 0 );	if ( reader != NULL ) {		ret = xmlTextReaderRead( reader );		while (ret == 1) {			name = xmlTextReaderConstName( reader );			if ( name &&                            (XML_READER_TYPE_ELEMENT == xmlTextReaderNodeType( reader )) &&                            ( 0 == xmlStrncmp( name, (const xmlChar *)"NodeConfig", 10 ) ) )			{				xmlconfig_load_node( reader );			}			else if ( name &&                            (XML_READER_TYPE_ELEMENT == xmlTextReaderNodeType( reader )) &&                            ( 0 == xmlStrncmp( name, (const xmlChar *)"TimerConfig", 10 ) ) )			{				xmlconfig_load_timer( reader );			}			ret = xmlTextReaderRead( reader );		}		xmlFreeTextReader( reader );		if (ret != 0) {			fprintf( stderr, "%s : failed to parse/n", filename );			goto out;		}		rc = 0;	} else {		fprintf( stderr, "Unable to open %s/n", filename );	}out:	return rc;}

voidags_drum_input_pad_launch_task(AgsFileLaunch *file_launch, AgsDrumInputPad *drum_input_pad){  xmlNode *node;  node = file_launch->node;  if(!xmlStrncmp(xmlGetProp(node,			    "edit"),		 AGS_FILE_TRUE,		 5)){    gtk_button_clicked((GtkButton *) drum_input_pad->edit);  }}

struct cspay_config *read_cspay_xml(char *fname){	/*TODO	 * validarea fisierului	 */	struct cspay_config *cfg;	xmlDoc *doc = NULL;	xmlNode *root_element = NULL;		LIBXML_TEST_VERSION		doc = xmlReadFile(fname, NULL, 0);	if (!doc){		fprintf(stderr, "*.xml file not found, try cspay.xml/n");		doc = xmlReadFile("cspay.xml", NULL, 0);		if (!doc) {			fprintf(stderr, "cspay.xml not found, bye!/n");			return NULL;		}	}		Dprintf("Read *.xml/n");		root_element = xmlDocGetRootElement(doc);	if (!root_element){		fprintf(stderr, "root_element/n");		return NULL;	}	if (xmlStrncmp(root_element->name, (xmlChar *)"cspay-config", 12)) {		fprintf(stderr, "This is not cspay-config xml file/n");		return NULL;	}	cfg = malloc(sizeof (struct cspay_config));	if (!cfg) {		fprintf(stderr, "malloc cspay_config");		return NULL;	}	cfg->vac_no = 0;	cfg->fac_no = 0;		Dprintf("Read root_element/n");		cspay_xml_extract_from_tree(root_element, cfg);		xmlFreeDoc(doc);	xmlCleanupParser();	return cfg;}

/* * process_enumerate_request_from_doc -- *	    looks for the object through the context ptr and sets the *	    request with object type. * * ctext: context ptr for the original doc to parse request info. * req: request to be filled up. * * Returns 0 if successful or an error code otherwise. */static intprocess_enumerate_request_from_doc(xmlXPathContextPtr ctext, request_t *req){	xmlChar expr[ISNS_MAX_LABEL_LEN + 13];	xmlXPathObjectPtr xpath_obj = NULL;	int i;	int obj = 0;	isnslog(LOG_DEBUG, "process_enumerate_request_from_doc", "entered");	(void) xmlStrPrintf(expr, ISNS_MAX_LABEL_LEN + 13,	    XMLSTRING_CAST "%s/"%s/"]", "//*[name()=", ISNSOBJECTTYPE);	xpath_obj = xmlXPathEvalExpression(expr, ctext);	isnslog(LOG_DEBUG, "process_enumerate_request_from_doc",	"xpath obj->nodesetval->nodeNR: %d", xpath_obj->nodesetval->nodeNr);	if ((xpath_obj) && (xpath_obj->nodesetval) &&	    (xpath_obj->nodesetval->nodeNr > 0) &&	    (xpath_obj->nodesetval->nodeTab)) {	    for (i = 0; obj_table[i].obj_str != NULL; i++) {		if (xmlStrncmp(		    xpath_obj->nodesetval->nodeTab[0]->children->content,		    (xmlChar *)obj_table[i].obj_str, xmlStrlen((xmlChar *)		    xpath_obj->nodesetval->nodeTab[0]->children->content))		    == 0) {		    obj = obj_table[i].obj_id;		    break;		}	    }	} else {	    if (xpath_obj) xmlXPathFreeObject(xpath_obj);	    return (ERR_XML_VALID_OBJECT_NOT_FOUND);	}	if (xpath_obj) xmlXPathFreeObject(xpath_obj);	if (obj == 0) {	    return (ERR_XML_VALID_OBJECT_NOT_FOUND);	}	req->op_info.obj = obj;	if (ISNS_MGMT_OBJECT_TYPE_ENABLED()) {	    ISNS_MGMT_OBJECT_TYPE(obj);	}	return (0);}

static gchar*mate_da_xml_get_string (const xmlNode *parent, const gchar *val_name){    const gchar * const *sys_langs;    xmlChar *node_lang;    xmlNode *element;    gchar *ret_val = NULL;    xmlChar *xml_val_name;    gint len;    gint i;    g_return_val_if_fail (parent != NULL, ret_val);    g_return_val_if_fail (parent->children != NULL, ret_val);    g_return_val_if_fail (val_name != NULL, ret_val);#if GLIB_CHECK_VERSION (2, 6, 0)    sys_langs = g_get_language_names ();#endif    xml_val_name = xmlCharStrdup (val_name);    len = xmlStrlen (xml_val_name);    for (element = parent->children; element != NULL; element = element->next) {	if (!xmlStrncmp (element->name, xml_val_name, len)) {	    node_lang = xmlNodeGetLang (element);	    if (node_lang == NULL) {		ret_val = (gchar *) xmlNodeGetContent (element);	    }	    else {		for (i = 0; sys_langs[i] != NULL; i++) {		    if (!strcmp (sys_langs[i], node_lang)) {			ret_val = (gchar *) xmlNodeGetContent (element);			/* since sys_langs is sorted from most desirable to			 * least desirable, exit at first match			 */			break;		    }		}	    }	    xmlFree (node_lang);	}    }    xmlFree (xml_val_name);    return ret_val;}

const xmlChar *xmlStrstr(const xmlChar *str, const xmlChar *val) {    int n;    if (str == NULL) return(NULL);    if (val == NULL) return(NULL);    n = xmlStrlen(val);    if (n == 0) return(str);    while (*str != 0) { /* non input consuming */        if (*str == *val) {            if (!xmlStrncmp(str, val, n)) return((const xmlChar *) str);        }        str++;    }    return(NULL);}

/** * /brief Check element existence */xmlNodePtr get_node(xmlXPathObjectPtr xpath_obj_file, char *nameval, char *nametag){	int i;	xmlNodePtr children1;		for (i = 0; i < xpath_obj_file->nodesetval->nodeNr; i++) {		children1 = xpath_obj_file->nodesetval->nodeTab[i]->children;		while (children1) {			if ((!strncmp ((char*) children1->name, nametag, strlen (nametag) + 1))					&& (!xmlStrncmp (children1->children->content, (xmlChar *) nameval, xmlStrlen ((xmlChar *)nameval) + 1))) {				/* element found*/				return xpath_obj_file->nodesetval->nodeTab[i];			}			children1 = children1->next;		}	}	return NULL;}

/** * /brief Get the node's children node with given name. * @param[in] node Search in the children nodes of this node. * @param[in] children_name Name of the requested children node. * @return Pointer to the children node with requested name. It should not be * freed since it is children of given node. */static inline xmlNodePtr get_children(xmlNodePtr node, const xmlChar* children_name){	/* check validity of parameters */	if (!node || !children_name) {		return (NULL);	}	xmlNodePtr children = node->children;	while (children) {		if (!xmlStrncmp(children->name, children_name, xmlStrlen(children_name) + 1)) {			return (children);		}		children = children->next;	}	return (children);}

voidags_synth_input_line_read(AgsFile *file, xmlNode *node, AgsPlugin *plugin){  AgsSynthInputLine *gobject;  AgsFileLookup *file_lookup;  xmlNode *child;  gobject = AGS_SYNTH_INPUT_LINE(plugin);  ags_file_add_id_ref(file,		      g_object_new(AGS_TYPE_FILE_ID_REF,				   "application-context", file->application_context,				   "file", file,				   "node", node,				   "xpath", g_strdup_printf("xpath=//*[@id='%s']", xmlGetProp(node, AGS_FILE_ID_PROP)),				   "reference", gobject,				   NULL));  gobject->oscillator = ags_oscillator_new();  file_lookup = (AgsFileLookup *) g_object_new(AGS_TYPE_FILE_LOOKUP,					       "file", file,					       "node", node,					       "reference", gobject,					       NULL);  ags_file_add_lookup(file, (GObject *) file_lookup);  g_signal_connect(G_OBJECT(file_lookup), "resolve",		   G_CALLBACK(ags_synth_input_line_resolve_line), gobject);  /* child elements */  child = node->children;  while(child != NULL){    if(XML_ELEMENT_NODE == child->type){      if(!xmlStrncmp(child->name,		     "ags-oscillator",		     15)){	ags_file_read_oscillator(file, child, &(gobject->oscillator));      }    }    child = child->next;  }}

/** * soap_walk_tree * @node:       pointer to an XML subtree * @colonstring: node name strings that are being searched; for example, to *              search for nodes "a", then "b", then "c", pass "a:b:c" * * Searches an XML subtree, looking for a named node.  Very similar to * soap_find_node() above, but uses an entirely different algorithm, both for * efficiency and to make response parsing more pedantic. * * The passed colonstring is a list of tree node names separated by ':'.  At * each level of the tree, the corresponding name must match.  This means that * the whole XML tree doesn't need to be searched, and that you know you've * found the right node, not one that is similarly-named but is in a different * part of the XML tree. * * Return value: the XML node, if found, or NULL. **/xmlNode         *soap_walk_tree(xmlNode *node, char *colonstring){        char            *next;        char            *c;        int             len;            /* Length of node name string */        if ((! node) ||            (! colonstring) ||            (! *colonstring) ||            (*colonstring == ':')) {                return(NULL);        }        /* Break string at ':' */        c = strchr(colonstring, ':');        if (c) {                len = c - colonstring;                next = c + 1;        }        else {                len = strlen(colonstring);                next = colonstring + len;        }        /* Look for this in the node tree's children */        node = node->children;        while (node) {                if ((! xmlStrncmp(node->name,                                  (const xmlChar *)colonstring,                                  len)) &&                    (xmlStrlen(node->name) == len)) {                        if (*next) {                                return(soap_walk_tree(node, next));                        }                        else {                                /* Done searching */                                return(node);                        }                }                node = node->next;        }        return(NULL);}

xmlDocPtr find_element(xmlDocPtr xml_document_pointer, char* element_name){    if(NULL != xml_document_pointer &&       NULL != element_name)    {        while(true)        {            if(NULL == xml_document_pointer)            {                break;            }            if(0 == xmlStrncmp(xml_document_pointer->name, element_name, xmlStrlen(element_name)))            {                return (xmlDocPtr)xml_document_pointer;            }            xml_document_pointer = (xmlDocPtr)xml_document_pointer->next;        }    }    return NULL;}

/** * /brief Get the text content of the node's children node with given children_name. * * Return value is just a pointer into the part of xmlNode so it  should not be * freed. * * @param[in] node Search in the children nodes of this node. * @param[in] children_name Name of the node which content will be returned. * @return Content (string) of the requested element or NULL if such element. * doesn't exist. It should not be freed since it is a part of given node. */static inline xmlChar *get_children_content(xmlNodePtr node, xmlChar *children_name){	/* check validity of parameters */	if (!node || !children_name) {		return (NULL);	}	/* init variables */	xmlNodePtr cur = node->children;	/* search in children nodes */	while (cur) {		if (!xmlStrncmp(cur->name, children_name, xmlStrlen(children_name) + 1)) {			if (cur->children && (cur->children->type == XML_TEXT_NODE)) {				return (cur->children->content);			}		}		/* go to sibling node (next children) */		cur = cur->next;	}	/* nothing found */	return (NULL);}

/** * xmlDictLookup: * @param dict the dictionnary * @param name the name of the userdata * @param len the length of the name, if -1 it is recomputed * * Add the name to the hash dict if not present. * * Returns the internal copy of the name or NULL in case of internal error * * OOM: possible --> returns NULL and OOM flag is set */XMLPUBFUNEXPORT const xmlChar*xmlDictLookup(xmlDictPtr dict, const xmlChar *name, int len) {    unsigned long key, okey, nbi = 0;    xmlDictEntryPtr entry;    xmlDictEntryPtr insert;    const xmlChar *ret;    if (!dict || !name)        return(NULL);    if (len < 0)        len = xmlStrlen(name);    /*     * Check for duplicate and insertion location.     */    okey = xmlDictComputeKey(name, len);    key = okey % dict->size;    if (dict->dict[key].valid == 0) {        insert = NULL;    } else {        for (insert = &(dict->dict[key]);             insert->next;             insert = insert->next)        {#ifdef __GNUC__            if (insert->len == len) {                if (!memcmp(insert->name, name, len))                    return(insert->name);            }#else            if ((insert->len == len) && (!xmlStrncmp(insert->name, name, len)))                return(insert->name);#endif            nbi++;        }#ifdef __GNUC__        if (insert->len == len) {            if (!memcmp(insert->name, name, len))                return(insert->name);        }#else        if ((insert->len == len) && (!xmlStrncmp(insert->name, name, len)))            return(insert->name);#endif    }    if (dict->subdict) {        key = okey % dict->subdict->size;        if (dict->subdict->dict[key].valid != 0) {            xmlDictEntryPtr tmp;            for (tmp = &(dict->subdict->dict[key]); tmp->next != NULL; tmp = tmp->next)            {#ifdef __GNUC__                if (tmp->len == len) {                    if (!memcmp(tmp->name, name, len))                        return(tmp->name);                }#else                if ((tmp->len == len) && (!xmlStrncmp(tmp->name, name, len)))                        return(tmp->name);#endif                nbi++;            }#ifdef __GNUC__            if (tmp->len == len) {                if (!memcmp(tmp->name, name, len))                    return(tmp->name);            }#else            if ((tmp->len == len) && (!xmlStrncmp(tmp->name, name, len)))                return(tmp->name);#endif        } // if (dict->subdict->dict[key].valid != 0)        key = okey % dict->size;    } // if (dict->subdict)    ret = xmlDictAddString(dict, name, len); // may set OOM flag    if (!ret)        return(NULL);    if (!insert) {        entry = &(dict->dict[key]);    } else {        entry = (xmlDictEntryPtr)xmlMalloc(sizeof(xmlDictEntry));//.........这里部分代码省略.........