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

boxpath *       boxpath_from_string(const char * path){	char * dir = dirname(strdup(path));	char * file = basename(strdup(path));	boxpath * bpath = (boxpath*) malloc(sizeof(boxpath));  	bpath->dir = xmlHashLookup(allDirs, dir);	bpath->base = strdup(file);	bpath->file = (strcmp(path,"/") ? NULL : rootDir);	bpath->is_dir = (xmlHashLookup(allDirs, path)!=NULL);	free(dir);	return bpath; }

/** * xsltCopyNamespace: * @ctxt:  a transformation context * @node:  the target node * @cur:  the namespace node * * Do a copy of an namespace node. If @node is non-NULL the * new namespaces are added automatically. This handles namespaces * aliases * * Returns: a new xmlNsPtr, or NULL in case of error. */xmlNsPtrxsltCopyNamespace(xsltTransformContextPtr ctxt, xmlNodePtr node,	          xmlNsPtr cur) {    xmlNsPtr ret = NULL;    const xmlChar *URI;    if (cur == NULL)	return(NULL);    if (cur->type != XML_NAMESPACE_DECL)	return(NULL);    /*     * One can add namespaces only on element nodes     */    if ((node != NULL) && (node->type != XML_ELEMENT_NODE))	node = NULL;    if (!xmlStrEqual(cur->href, XSLT_NAMESPACE)) {	URI = (const xmlChar *) xmlHashLookup(ctxt->style->nsAliases,					      cur->href);	if (URI != NULL) {	    ret = xmlNewNs(node, URI, cur->prefix);	} else {	    ret = xmlNewNs(node, cur->href, cur->prefix);	}    }    return(ret);}

static HRESULT WINAPI schema_cache_get(IXMLDOMSchemaCollection2* iface, BSTR uri,                                       IXMLDOMNode** node){    schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);    cache_entry* entry;    xmlChar* name;    TRACE("(%p)->(%s %p)/n", This, debugstr_w(uri), node);    if (This->version == MSXML6)    {        if (node) *node = NULL;        return E_NOTIMPL;    }    if (!node)        return E_POINTER;    *node = NULL;    name = uri ? xmlchar_from_wchar(uri) : xmlchar_from_wchar(emptyW);    entry = (cache_entry*) xmlHashLookup(This->cache, name);    heap_free(name);    /* TODO: this should be read-only */    if (entry && entry->doc)        return get_domdoc_from_xmldoc(entry->doc, (IXMLDOMDocument3**)node);    return S_OK;}

static xmlSchemaElementPtr lookup_schema_elemDecl(xmlSchemaPtr schema, xmlNodePtr node){    xmlSchemaElementPtr decl = NULL;    xmlChar const* nsURI = get_node_nsURI(node);    TRACE("(%p, %p)/n", schema, node);    if (xmlStrEqual(nsURI, schema->targetNamespace))        decl = xmlHashLookup(schema->elemDecl, node->name);    if (!decl && xmlHashSize(schema->schemasImports) > 1)    {        FIXME("declaration not found in main schema - need to check schema imports!/n");        /*xmlSchemaImportPtr import;        if (nsURI == NULL)            import = xmlHashLookup(schema->schemasImports, XML_SCHEMAS_NO_NAMESPACE);        else            import = xmlHashLookup(schema->schemasImports, node->ns->href);        if (import != NULL)            decl = xmlHashLookup(import->schema->elemDecl, node->name);*/    }    return decl;}

/* * This is called by ??? when reading an annotation is encountered * while reading the instance data. */xmlParserErrors instance_annotation_callback(void *handle, xmlNodePtr node){    int i;    char key[20];    xmlChar* path;    xmlDocPtr doc = node->doc;    xmlXPathContextPtr xpathCtx = xmlXPathNewContext(doc);    xmlXPathObjectPtr xpathObj;    sprintf(key, "%p", handle);    path = (xmlChar*)xmlHashLookup(Handle2Path, (xmlChar*)key);    assert(path != NULL);    printf("/noooooooooooo %s: %p/n", __FUNCTION__, handle);    dump_doc(node->doc, node);    /* walk_doc_tree(node, 0); */    printf("/n");    xpathCtx->node = node;    xpathObj = xmlXPathEvalExpression(path, xpathCtx);    if (xpathObj->nodesetval != NULL)	for (i = 0; i < xpathObj->nodesetval->nodeNr; ++i)	    printf("xpath(/"%s/") => %s/n", path,		   xmlNodeGetContent(xpathObj->nodesetval->nodeTab[i]));    return XML_ERR_OK;}

/** * xsltGetNamespace: * @ctxt:  a transformation context * @cur:  the input node * @ns:  the namespace * @out:  the output node (or its parent) * * Find a matching (prefix and ns-name) ns-declaration * for the requested @ns->prefix and @ns->href in the result tree. * If none is found then a new ns-declaration will be * added to @resultElem. If, in this case, the given prefix is * already in use, then a ns-declaration with a modified ns-prefix * be we created. * * Called by: *  - xsltCopyPropList() (*not*  anymore) *  - xsltShallowCopyElement() *  - xsltCopyTreeInternal() (*not*  anymore) *  - xsltApplySequenceConstructor() (*not* in the refactored code), *  - xsltElement() (*not* anymore) * * Returns a namespace declaration or NULL in case of *         namespace fixup failures or API or internal errors. */xmlNsPtrxsltGetNamespace(xsltTransformContextPtr ctxt, xmlNodePtr cur, xmlNsPtr ns,	         xmlNodePtr out){    if (ns == NULL)	return(NULL);#ifdef XSLT_REFACTORED    /*    * Namespace exclusion and ns-aliasing is performed at    * compilation-time in the refactored code.    * Additionally, aliasing is not intended for non Literal    * Result Elements.    */    return(xsltGetSpecialNamespace(ctxt, cur, ns->href, ns->prefix, out));#else    {	xsltStylesheetPtr style;	const xmlChar *URI = NULL; /* the replacement URI */	if ((ctxt == NULL) || (cur == NULL) || (out == NULL))	    return(NULL);	style = ctxt->style;	while (style != NULL) {	    if (style->nsAliases != NULL)		URI = (const xmlChar *)		xmlHashLookup(style->nsAliases, ns->href);	    if (URI != NULL)		break;	    style = xsltNextImport(style);	}	if (URI == UNDEFINED_DEFAULT_NS) {	    return(xsltGetSpecialNamespace(ctxt, cur, NULL, NULL, out));#if 0	    /*	    * TODO: Removed, since wrong. If there was no default	    * namespace in the stylesheet then this must resolve to	    * the NULL namespace.	    */	    xmlNsPtr dflt;	    dflt = xmlSearchNs(cur->doc, cur, NULL);	    if (dflt != NULL)		URI = dflt->href;	    else		return NULL;#endif	} else if (URI == NULL)	    URI = ns->href;	return(xsltGetSpecialNamespace(ctxt, cur, URI, ns->prefix, out));    }#endif}

HRESULT SchemaCache_validate_tree(IXMLDOMSchemaCollection2* iface, xmlNodePtr tree){    schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);    cache_entry* entry;    xmlChar const* ns = NULL;    TRACE("(%p, %p)/n", This, tree);    if (!tree)        return E_POINTER;    if ((xmlNodePtr)tree->doc == tree)    {        xmlNodePtr root = xmlDocGetRootElement(tree->doc);        if (root && root->ns)            ns = root->ns->href;    }    else if (tree->ns)    {        ns = tree->ns->href;    }    entry = xmlHashLookup(This->cache, ns);    /* TODO: if the ns is not in the cache, and it's a URL,     *       do we try to load from that? */    if (entry)    {        if (entry->type == SCHEMA_TYPE_XDR)        {            FIXME("partial stub: XDR schema support not implemented/n");            return S_OK;        }        else if (entry->type == SCHEMA_TYPE_XSD)        {            xmlSchemaValidCtxtPtr svctx;            int err;            /* TODO: if validateOnLoad property is false,             *       we probably need to validate the schema here. */            svctx = xmlSchemaNewValidCtxt(entry->schema);            xmlSchemaSetValidErrors(svctx, validate_error, validate_warning, NULL);#ifdef HAVE_XMLSCHEMASSETVALIDSTRUCTUREDERRORS            xmlSchemaSetValidStructuredErrors(svctx, validate_serror, NULL);#endif            if ((xmlNodePtr)tree->doc == tree)                err = xmlSchemaValidateDoc(svctx, (xmlDocPtr)tree);            else                err = xmlSchemaValidateOneElement(svctx, tree);            xmlSchemaFreeValidCtxt(svctx);            return err? S_FALSE : S_OK;        }    }    return E_FAIL;}

static void cache_copy(void* data, void* dest, xmlChar* name){    schema_cache* This = (schema_cache*) dest;    cache_entry* entry = (cache_entry*) data;    if (xmlHashLookup(This->cache, name) == NULL)    {        cache_entry_add_ref(entry);        xmlHashAddEntry(This->cache, name, entry);    }}

/** * xsltGetKey: * @ctxt: an XSLT transformation context * @name:  the key name or NULL * @nameURI:  the name URI or NULL * @value:  the key value to look for * * Looks up a key of the in current source doc (the document info * on @ctxt->document). Computes the key if not already done * for the current source doc. * * Returns the nodeset resulting from the query or NULL */xmlNodeSetPtrxsltGetKey(xsltTransformContextPtr ctxt, const xmlChar *name,	   const xmlChar *nameURI, const xmlChar *value) {    xmlNodeSetPtr ret;    xsltKeyTablePtr table;    int init_table = 0;    if ((ctxt == NULL) || (name == NULL) || (value == NULL) ||	(ctxt->document == NULL))	return(NULL);#ifdef WITH_XSLT_DEBUG_KEYS    xsltGenericDebug(xsltGenericDebugContext,	"Get key %s, value %s/n", name, value);#endif    /*     * keys are computed only on-demand on first key access for a document     */    if ((ctxt->document->nbKeysComputed < ctxt->nbKeys) &&        (ctxt->keyInitLevel == 0)) {        /*	 * If non-recursive behaviour, just try to initialize all keys	 */	if (xsltInitAllDocKeys(ctxt))	    return(NULL);    }retry:    table = (xsltKeyTablePtr) ctxt->document->keys;    while (table != NULL) {	if (((nameURI != NULL) == (table->nameURI != NULL)) &&	    xmlStrEqual(table->name, name) &&	    xmlStrEqual(table->nameURI, nameURI))	{	    ret = (xmlNodeSetPtr)xmlHashLookup(table->keys, value);	    return(ret);	}	table = table->next;    }    if ((ctxt->keyInitLevel != 0) && (init_table == 0)) {        /*	 * Apparently one key is recursive and this one is needed,	 * initialize just it, that time and retry	 */        xsltInitDocKeyTable(ctxt, name, nameURI);	init_table = 1;	goto retry;    }    return(NULL);}

/*********************************************************************** * Function Name : CNTRLXMLGETReqHandler * Description   : This function calls the registered callback functions 				   against the XML file URL * Input         : regUrl - XML file URL *				   pOutXMLStr - Response XML buffer * Output		 : none * Return value  : CNTRLXML_SUCCESS, CNTRLXML_FAILURE, CNTRLXML_BADPARAM ***********************************************************************/t_char8CNTRLXMLGETReqHandler (t_char8 * pInXMLFile, t_void * pAppData,                     t_char8 ** pOutXMLStr){  XMLTEMPLATE_CALLBACK_HANDLER pCbfun;  t_int32 retStatus = CNTRLXML_SUCCESS;  if (!pInXMLFile)  {    XML_Error ("pInXMLFile is NULL");    return CNTRLXML_BADPARAM;  }  XML_DebugArg ("Look up for tag = ", pInXMLFile);  pCbfun = xmlHashLookup (hTable, pInXMLFile);  if (pCbfun != NULL)  {    XML_DebugArg ("Found function for tag =", pInXMLFile);    retStatus = (*pCbfun) (pInXMLFile, pAppData);    if (retStatus != CNTRLXML_SUCCESS)    {      XML_Error ("GET Request CbkFunction Failed");      if(pXMLErrorStr)      {        *pOutXMLStr = xmlStrdup ((const xmlChar *) pXMLErrorStr);        XML_DebugArg ("*pOutXMLStr=", *pOutXMLStr);        XMLBUFFERFREE (pXMLErrorStr);        pXMLErrorStr = NULL;        return CNTRLXML_SUCCESS;      }      *pOutXMLStr = NULL;      return CNTRLXML_FAILURE;    }    /**pOutXMLStr = (t_char8*) T_malloc(T_strlen(pXMLResultStr)+1);    of_strcpy(*pOutXMLStr, pXMLResultStr);*/    *pOutXMLStr = xmlStrdup ((const xmlChar *) pXMLResultStr);    XML_DebugArg ("*pOutXMLStr=", *pOutXMLStr);    XMLBUFFERFREE (pXMLResultStr);    pXMLResultStr = NULL;    return CNTRLXML_SUCCESS;  }  return CNTRLXML_FAILURE;}

/* *  session_from_hargs * *  Return a session from a handler struct session key */struct session* session_from_hargs(struct handler_args* hargs,     xmlHashTablePtr sessions, struct qz_config* conf){     uint64_t etag_payload;    unsigned char session_id[9];        struct session* this_session;    etag_payload = validate_etag(hargs->conf->tagger_socket_path,         hargs->session_key);    if (etag_payload == 0){        fprintf(hargs->log, "%f %d %s:%d session key not validated/n",             gettime(), hargs->request_id, __func__, __LINE__);        return NULL;    }    memcpy(session_id, &etag_payload, 8);    session_id[8] = '/0';    this_session = xmlHashLookup(sessions, session_id);    if (this_session==NULL){        fprintf(hargs->log, "%f %d %s:%d null session from hash lookup/n",             gettime(), hargs->request_id, __func__, __LINE__);                return NULL;    }        if (this_session->integrity_token != conf->integrity_token){        // The last 64 bits of the session struct have been         // altered.  The session record is corrupted.        // Clean up the session        close_session(hargs, this_session);        fprintf(hargs->log,"%f %d %s:%d session closed for bad integrity token",            gettime(), hargs->request_id, __func__, __LINE__);                return NULL;    }    fprintf(hargs->log, "%f %d %s:%d user=%s/n",        gettime(), hargs->request_id, __func__, __LINE__,        this_session->user);    return this_session;}

static xar_file_t xar_link_lookup(xar_t x, dev_t dev, ino_t ino, xar_file_t f) {	char key[32];	xar_file_t ret;	memset(key, 0, sizeof(key));	snprintf(key, sizeof(key)-1, "%08" DEV_HEXSTRING "%08" INO_HEXSTRING, DEV_CAST dev, INO_CAST ino);	ret = xmlHashLookup(XAR(x)->ino_hash, BAD_CAST(key));	if( ret == NULL ) {		xmlHashAddEntry(XAR(x)->ino_hash, BAD_CAST(key), XAR_FILE(f));		return NULL;	}	return ret;}

USER_OBJECT_R_libxmlTypeTable_lookup(USER_OBJECT_ table, USER_OBJECT_ name, USER_OBJECT_ s_elType){   xmlHashTablePtr t;   USER_OBJECT_ ans;   void *p;   t = R_getExternalRef(table, NULL); /* R_libxmlTypeTableGetRef(table); */   p = xmlHashLookup(t, CHAR_DEREF(STRING_ELT(name, 0)));   ans = R_makeRefObject(p, CHAR_DEREF(STRING_ELT(s_elType, 0)));   return(ans);}

static void xmlsec_KeyStoreFinalizeMethod(xmlSecKeyStorePtr store) {  PyObject *args, *result;  PyObject *func = NULL;  func = xmlHashLookup(KeyStoreFinalizeMethods, store->id->name);  args = Py_BuildValue((char *) "O", wrap_xmlSecKeyStorePtr(store));  Py_INCREF(func);  result = PyEval_CallObject(func, args);  Py_DECREF(func);  Py_DECREF(args);  Py_XDECREF(result);}

static xmlSecKeyDataType xmlsec_KeyDataGetSizeMethod(xmlSecKeyDataPtr data) {  PyObject *args, *result;  PyObject *func = NULL;  func = xmlHashLookup(KeyDataGetSizeMethods, data->id->name);  args = Py_BuildValue((char *) "O", wrap_xmlSecKeyDataPtr(data));  Py_INCREF(func);  result = PyEval_CallObject(func, args);  Py_DECREF(func);  Py_DECREF(args);  return (PyInt_AsLong(result));}

static const xmlChar* xmlsec_KeyDataGetIdentifierMethod(xmlSecKeyDataPtr data) {  PyObject *args, *result;  PyObject *func = NULL;  func = xmlHashLookup(KeyDataGetIdentifierMethods, data->id->name);  args = Py_BuildValue((char *) "O", wrap_xmlSecKeyDataPtr(data));  Py_INCREF(func);  result = PyEval_CallObject(func, args);  Py_DECREF(func);  Py_DECREF(args);  return ((const xmlChar*)PyString_AsString(result));}

static int xmlsec_KeyStoreInitializeMethod(xmlSecKeyStorePtr store) {  PyObject *args, *result;  PyObject *func = NULL;  func = xmlHashLookup(KeyStoreInitializeMethods, store->id->name);  args = Py_BuildValue((char *) "O", wrap_xmlSecKeyStorePtr(store));  /* Protect refcount against reentrant manipulation of callback hash */  Py_INCREF(func);  result = PyEval_CallObject(func, args);  Py_DECREF(func);  Py_DECREF(args);  return (PyInt_AsLong(result));}

static void xmlsec_KeyDataDebugDumpMethod(xmlSecKeyDataPtr data, FILE *output) {  PyObject *args, *result;  PyObject *func = NULL;  func = xmlHashLookup(KeyDataDebugDumpMethods, data->id->name);  args = Py_BuildValue((char *) "OO", wrap_xmlSecKeyDataPtr(data),		       PyFile_FromFile(output, NULL, NULL, NULL));  Py_INCREF(func);  result = PyEval_CallObject(func, args);  Py_DECREF(func);  Py_DECREF(args);  Py_XDECREF(result);}

static int xmlsec_KeyDataDuplicateMethod(xmlSecKeyDataPtr dst,					 xmlSecKeyDataPtr src) {  PyObject *args, *result;  PyObject *func = NULL;  func = xmlHashLookup(KeyDataDuplicateMethods, src->id->name);  args = Py_BuildValue((char *) "OO", wrap_xmlSecKeyDataPtr(dst),		       wrap_xmlSecKeyDataPtr(src));  Py_INCREF(func);  result = PyEval_CallObject(func, args);  Py_DECREF(func);  Py_DECREF(args);  return (PyInt_AsLong(result));}

/*********************************************************************** * Function Name : CNTRLXMLGetRegHandler * Description   : This function retrives registered callback functions 				   for the given Module name. * Input         : pInModule	- Module name * Output		 : pOutFunLst	- Registered function list * Return value  : CNTRLXML_SUCCESS, CNTRLXML_FAILURE, CNTRLXML_BADPARAM ***********************************************************************/t_char8CNTRLXMLGetRegHandler (t_char8 * pInModule, t_void ** pOutFunLst){  XML_DebugArg ("Look up for tag = ", pInModule);  *pOutFunLst = (t_void *) xmlHashLookup (pModSetTable, pInModule);  if (*pOutFunLst == NULL)  {    XML_DebugArg ("Could not find function for tag", pInModule);    return CNTRLXML_FAILURE;  }  XML_DebugArg ("Found function for tag = %s", pInModule);  return CNTRLXML_SUCCESS;}

static xmlSecKeyPtr xmlsec_GetKeyCallback(xmlNodePtr keyInfoNode,					  xmlSecKeyInfoCtxPtr keyInfoCtx) {  PyObject *args, *result;  PyObject *func = NULL;  func = xmlHashLookup(GetKeyCallbacks,		       keyInfoCtx->keysMngr->keysStore->id->name);  args = Py_BuildValue((char *) "OO", wrap_xmlNodePtr(keyInfoNode),		       wrap_xmlSecKeyInfoCtxPtr(keyInfoCtx));  Py_INCREF(func);  result = PyEval_CallObject(func, args);  Py_DECREF(func);  Py_DECREF(args);  return (xmlSecKeyPtr_get(result));}

static void xmlsec_PtrDestroyItemMethod(xmlSecPtr ptr) {  xmlSecPtrListPtr list;  PyObject *args, *result;  PyObject *func = NULL;  list = (xmlSecPtrListPtr) ptr;  func = xmlHashLookup(PtrDestroyItemMethods, list->id->name);  args = Py_BuildValue((char *) "O", wrap_xmlSecPtr(ptr));  /* Protect refcount against reentrant manipulation of callback hash */  Py_INCREF(func);  result = PyEval_CallObject(func, args);  Py_DECREF(func);  Py_DECREF(args);  Py_XDECREF(result);}

static int xmlsec_KeyDataXmlWriteMethod(xmlSecKeyDataId id, xmlSecKeyPtr key,					xmlNodePtr node,					xmlSecKeyInfoCtxPtr keyInfoCtx) {  PyObject *args, *result;  PyObject *func = NULL;  func = xmlHashLookup(KeyDataXmlWriteMethods, id->name);  args = Py_BuildValue((char *) "OOOO", wrap_xmlSecKeyDataId(id),		       wrap_xmlSecKeyPtr(key), wrap_xmlNodePtr(node),		       wrap_xmlSecKeyInfoCtxPtr(keyInfoCtx));  Py_INCREF(func);  result = PyEval_CallObject(func, args);  Py_DECREF(func);  Py_DECREF(args);  return (PyInt_AsLong(result));}

static void xmlsec_PtrDebugXmlDumpItemMethod(xmlSecPtr ptr, FILE *output) {  xmlSecPtrListPtr list;  PyObject *args, *result;  PyObject *func = NULL;  list = (xmlSecPtrListPtr) ptr;  func = xmlHashLookup(PtrDebugXmlDumpItemMethods, list->id->name);  /* FIXME */  args = Py_BuildValue((char *) "OO", wrap_xmlSecPtr(ptr),		       PyFile_FromFile(output, NULL, NULL, NULL));  /* Protect refcount against reentrant manipulation of callback hash */  Py_INCREF(func);  result = PyEval_CallObject(func, args);  Py_DECREF(func);  Py_DECREF(args);  Py_XDECREF(result);}

/** * xsltCopyNamespaceList: * @ctxt:  a transformation context * @node:  the target node * @cur:  the first namespace * * Do a copy of an namespace list. If @node is non-NULL the * new namespaces are added automatically. This handles namespaces * aliases * * Returns: a new xmlNsPtr, or NULL in case of error. */xmlNsPtrxsltCopyNamespaceList(xsltTransformContextPtr ctxt, xmlNodePtr node,	              xmlNsPtr cur) {    xmlNsPtr ret = NULL;    xmlNsPtr p = NULL,q;    const xmlChar *URI;    if (cur == NULL)	return(NULL);    if (cur->type != XML_NAMESPACE_DECL)	return(NULL);    /*     * One can add namespaces only on element nodes     */    if ((node != NULL) && (node->type != XML_ELEMENT_NODE))	node = NULL;    while (cur != NULL) {	if (cur->type != XML_NAMESPACE_DECL)	    break;	if (!xmlStrEqual(cur->href, XSLT_NAMESPACE)) {	    /* TODO apply cascading */	    URI = (const xmlChar *) xmlHashLookup(ctxt->style->nsAliases,		                                  cur->href);	    if (URI != NULL) {		q = xmlNewNs(node, URI, cur->prefix);	    } else {		q = xmlNewNs(node, cur->href, cur->prefix);	    }	    if (p == NULL) {		ret = p = q;	    } else {		p->next = q;		p = q;	    }	}	cur = cur->next;    }    return(ret);}

// Move a dir to another path in the tree,// recursively updating all the child entries in allDirsvoid	boxtree_movedir(const char * from, const char * to){	boxdir * aDir = xmlHashLookup(allDirs, from);        list_iter it;        char * newfrom, * newto, *name;	if(!aDir) {	  syslog(LOG_ERR, "no such directory %s", from);	  return;	}        for (it=list_get_iter(aDir->folders); it; it = list_iter_next(it)) {            name = ((boxfile*)list_iter_getval(it))->name;            newfrom = pathappend(from, name);            newto   = pathappend(to,   name);            boxtree_movedir(newfrom, newto);            free(newfrom); free(newto);        }	//LOCKDIR(aDir);	xmlHashRemoveEntry(allDirs, from, NULL);	xmlHashAddEntry(allDirs, to, aDir);	//UNLOCKDIR(aDir);}

static int xmlsec_KeyDataBinReadMethod(xmlSecKeyDataId id,				      xmlSecKeyPtr key,				      const xmlSecByte *buf,				      xmlSecSize bufSize,				      xmlSecKeyInfoCtxPtr keyInfoCtx) {  PyObject *args, *result;  PyObject *func = NULL;  func = xmlHashLookup(KeyDataBinReadMethods, id->name);  args = Py_BuildValue((char *) "OOsiO", wrap_xmlSecKeyDataId(id),		       wrap_xmlSecKeyPtr(key), buf, bufSize,		       wrap_xmlSecKeyInfoCtxPtr(keyInfoCtx));  Py_INCREF(func);  result = PyEval_CallObject(func, args);  Py_DECREF(func);  Py_DECREF(args);  return (PyInt_AsLong(result));}

static xmlSecKeyPtr xmlsec_KeyStoreFindKeyMethod(xmlSecKeyStorePtr store,						 xmlChar *name,						 xmlSecKeyInfoCtxPtr keyInfoCtx) {  PyObject *args, *result;  PyObject *func = NULL;  func = xmlHashLookup(KeyStoreFindKeyMethods, store->id->name);  args = Py_BuildValue((char *) "OsO", wrap_xmlSecKeyStorePtr(store), name,		       wrap_xmlSecKeyInfoCtxPtr(keyInfoCtx));  Py_INCREF(func);  result = PyEval_CallObject(func, args);  if (result == NULL) {    return (NULL);  }  Py_DECREF(func);  Py_DECREF(args);  return (xmlSecKeyPtr_get(result));}

static HRESULT WINAPI schema_cache_get(IXMLDOMSchemaCollection2* iface, BSTR uri,                                       IXMLDOMNode** node){    schema_cache* This = impl_from_IXMLDOMSchemaCollection2(iface);    xmlChar* name;    cache_entry* entry;    TRACE("(%p)->(%s, %p)/n", This, wine_dbgstr_w(uri), node);    if (!node)        return E_POINTER;    name = xmlChar_from_wchar(uri);    entry = (cache_entry*) xmlHashLookup(This->cache, name);    heap_free(name);    /* TODO: this should be read-only */    if (entry)        return DOMDocument_create_from_xmldoc(entry->doc, (IXMLDOMDocument3**)node);    *node = NULL;    return S_OK;}