PyObject *keysmngr_KeyStoreIdCreate(PyObject *self, PyObject *args) { PyObject *initialize_obj, *finalize_obj, *findKey_obj; xmlSecSize klassSize; xmlSecSize objSize; const xmlChar *name; struct _xmlSecKeyStoreKlass *storeId; if (CheckArgs(args, "IISccc:keyStoreIdCreate")) { if(!PyArg_ParseTuple(args, (char *) "iisOOO:keyStoreIdCreate", &klassSize, &objSize, &name, &initialize_obj, &finalize_obj, &findKey_obj)) return NULL; } else return NULL; if (KeyStoreInitializeMethods == NULL && initialize_obj != Py_None) KeyStoreInitializeMethods = xmlHashCreate(HASH_TABLE_SIZE); if (KeyStoreFinalizeMethods == NULL && finalize_obj != Py_None) KeyStoreFinalizeMethods = xmlHashCreate(HASH_TABLE_SIZE); if (KeyStoreFindKeyMethods == NULL && findKey_obj != Py_None) KeyStoreFindKeyMethods = xmlHashCreate(HASH_TABLE_SIZE); if (initialize_obj != Py_None) xmlHashAddEntry(KeyStoreInitializeMethods, name, initialize_obj); if (finalize_obj != Py_None) xmlHashAddEntry(KeyStoreFinalizeMethods, name, finalize_obj); if (findKey_obj != Py_None) xmlHashAddEntry(KeyStoreFindKeyMethods, name, findKey_obj); storeId = xmlMalloc(sizeof(xmlSecKeyStoreKlass)); /* FIXME storeId->klassSize = klassSize; storeId->objSize = objSize; */ storeId->klassSize = sizeof(xmlSecKeyStoreKlass); storeId->objSize = sizeof(xmlSecKeyStore); storeId->name = (xmlChar *)strdup((const char *)name); if (initialize_obj != Py_None) storeId->initialize = (xmlSecKeyStoreInitializeMethod)xmlsec_KeyStoreInitializeMethod; else storeId->initialize = NULL; if (finalize_obj != Py_None) storeId->finalize = (xmlSecKeyStoreFinalizeMethod)xmlsec_KeyStoreFinalizeMethod; else storeId->finalize = NULL; if (findKey_obj != Py_None) storeId->findKey = (xmlSecKeyStoreFindKeyMethod)xmlsec_KeyStoreFindKeyMethod; else storeId->findKey = NULL; Py_XINCREF(initialize_obj); Py_XINCREF(finalize_obj); Py_XINCREF(findKey_obj); return (wrap_xmlSecKeyStoreId(storeId)); }
PyObject *xmlsec_PtrListIdCreate(PyObject *self, PyObject *args) { PyObject *duplicateItem_obj, *destroyItem_obj; PyObject *debugDumpItem_obj, *debugXmlDumpItem_obj; const xmlChar *name; struct _xmlSecPtrListKlass *listId; if (CheckArgs(args, "Scccc:ptrListIdCreate")) { if(!PyArg_ParseTuple(args, (char *) "sOOOO:ptrListIdCreate", &name, &duplicateItem_obj, &destroyItem_obj, &debugDumpItem_obj, &debugXmlDumpItem_obj)) return NULL; } else return NULL; if (PtrDuplicateItemMethods == NULL && duplicateItem_obj != Py_None) PtrDuplicateItemMethods = xmlHashCreate(HASH_TABLE_SIZE); if (PtrDestroyItemMethods == NULL && destroyItem_obj != Py_None) PtrDestroyItemMethods = xmlHashCreate(HASH_TABLE_SIZE); if (PtrDebugDumpItemMethods == NULL && debugDumpItem_obj != Py_None) PtrDebugDumpItemMethods = xmlHashCreate(HASH_TABLE_SIZE); if (PtrDebugXmlDumpItemMethods == NULL && debugXmlDumpItem_obj != Py_None) PtrDebugXmlDumpItemMethods = xmlHashCreate(HASH_TABLE_SIZE); if (duplicateItem_obj != Py_None) xmlHashAddEntry(PtrDuplicateItemMethods, name, duplicateItem_obj); if (destroyItem_obj != Py_None) xmlHashAddEntry(PtrDestroyItemMethods, name, destroyItem_obj); if (debugDumpItem_obj != Py_None) xmlHashAddEntry(PtrDebugDumpItemMethods, name, debugDumpItem_obj); if (debugXmlDumpItem_obj != Py_None) xmlHashAddEntry(PtrDebugXmlDumpItemMethods, name, debugXmlDumpItem_obj); listId = xmlMalloc(sizeof(xmlSecPtrListKlass)); listId->name = name; if (duplicateItem_obj != Py_None) listId->duplicateItem = xmlsec_PtrDuplicateItemMethod; else listId->duplicateItem = NULL; if (destroyItem_obj != Py_None) listId->destroyItem = xmlsec_PtrDestroyItemMethod; else listId->destroyItem = NULL; if (debugDumpItem_obj != Py_None) listId->debugDumpItem = xmlsec_PtrDebugDumpItemMethod; else listId->debugDumpItem = NULL; if (debugXmlDumpItem_obj != Py_None) listId->debugXmlDumpItem = xmlsec_PtrDebugXmlDumpItemMethod; else listId->debugXmlDumpItem = NULL; Py_XINCREF(duplicateItem_obj); Py_XINCREF(destroyItem_obj); Py_XINCREF(debugDumpItem_obj); Py_XINCREF(debugXmlDumpItem_obj); return (wrap_xmlSecPtrListId(listId)); }
/* }}} */ ContactList *cl_new(Account *ac, const char *ticket)/*{{{*/ { CL *cl; cl = (CL*)xmalloc(sizeof(CL)); memset(cl, 0, sizeof(CL)); cl->account = ac; cl->ticket = (char*)xmalloc(strlen(ticket)+1); strcpy(cl->ticket, ticket); cl->table = xmlHashCreate(30); cl->emailtable = xmlHashCreate(250); return cl; }/*}}}*/
xmlHashTablePtr hash_icons_yrno_table_create(){ xmlHashTablePtr hash; hash = xmlHashCreate(6); #include "hash_icons.data" return hash; }
PyObject *xmlSecKeysMngr_setattr(PyObject *self, PyObject *args) { PyObject *mngr_obj, *value_obj; xmlSecKeysMngrPtr mngr; const char *name; if (CheckArgs(args, "OS?:keysMngrSetAttr")) { if (!PyArg_ParseTuple(args, "OsO:keysMngrSetAttr", &mngr_obj, &name, &value_obj)) return NULL; } else return NULL; mngr = xmlSecKeysMngrPtr_get(mngr_obj); if (!strcmp(name, "keysStore")) mngr->keysStore = xmlSecKeyStorePtr_get(value_obj); else if (!strcmp(name, "storesList")) mngr->storesList = *(xmlSecPtrListPtr_get(value_obj)); else if (!strcmp(name, "getKey")) { if (value_obj != Py_None) { if (GetKeyCallbacks == NULL) GetKeyCallbacks = xmlHashCreate(HASH_TABLE_SIZE); xmlHashAddEntry(GetKeyCallbacks, mngr->keysStore->id->name, value_obj); Py_XINCREF(value_obj); mngr->getKey = xmlsec_GetKeyCallback; } else mngr->getKey = NULL; } Py_INCREF(Py_None); return (Py_None); }
PyObject *xmlsec_NodeSetWalk(PyObject *self, PyObject *args) { PyObject *nset_obj, *walkFunc_obj, *data_obj; xmlSecNodeSetPtr nset; int ret; if (CheckArgs(args, "OC?:nodeSetWalk")) { if (!PyArg_ParseTuple(args, "OOO:nodeSetWalk", &nset_obj, &walkFunc_obj, &data_obj)) return NULL; } else return NULL; nset = xmlSecNodeSetPtr_get(nset_obj); if (NodeSetWalkCallbacks == NULL && walkFunc_obj != Py_None) NodeSetWalkCallbacks = xmlHashCreate(HASH_TABLE_SIZE); if (walkFunc_obj != Py_None) xmlHashAddEntry2(NodeSetWalkCallbacks, (const xmlChar *)nset->doc->name, nset->doc->URL, walkFunc_obj); Py_XINCREF(walkFunc_obj); ret = xmlSecNodeSetWalk(nset, xmlsec_NodeSetWalkCallback, PyCObject_AsVoidPtr(data_obj)); return (wrap_int(ret)); }
xmlHashTablePtr hash_description_yrno_table_create(){ xmlHashTablePtr hash; hash = xmlHashCreate(6); #include "hash_description.data" return hash; }
static void dlinit(void) { int locked; /** *** Initialize the package. *** Should be call once per process. **/ locked = !pthread_mutex_lock(&dlmutex); if (!(dlflags & INITED)) { dlflags &= ~THREADS; if (locked) dlflags |= THREADS; Qp0zInitEnv(); dldir = xmlHashCreate(16); dlflags &= ~MULTIBUF; if (dlflags & THREADS) if (!pthread_key_create(&dlkey, dlthreadterm)) dlflags |= MULTIBUF; atexit(dlterm); dlflags |= INITED; } if (locked) pthread_mutex_unlock(&dlmutex); }
/** * xmlHashCopy: * @table: the hash table * @f: the copier function for items in the hash * * Scan the hash @table and applied @f to each value. * * Returns the new table or NULL in case of error. */ xmlHashTablePtr xmlHashCopy(xmlHashTablePtr table, xmlHashCopier f) { int i; xmlHashEntryPtr iter; xmlHashEntryPtr next; xmlHashTablePtr ret; if (table == NULL) return(NULL); if (f == NULL) return(NULL); ret = xmlHashCreate(table->size); if (table->table) { for(i = 0; i < table->size; i++) { iter = table->table[i]; while (iter) { next = iter->next; xmlHashAddEntry3(ret, iter->name, iter->name2, iter->name3, f(iter->payload, iter->name)); iter = next; } } } ret->nbElems = table->nbElems; return(ret); }
bool XSLTProcessor::transformToString(Node* sourceNode, String& mimeType, String& resultString, String& resultEncoding) { RefPtr<Document> ownerDocument = sourceNode->document(); setXSLTLoadCallBack(docLoaderFunc, this, ownerDocument->docLoader()); xsltStylesheetPtr sheet = xsltStylesheetPointer(m_stylesheet, m_stylesheetRootNode.get()); if (!sheet) { setXSLTLoadCallBack(0, 0, 0); return false; } m_stylesheet->clearDocuments(); xmlChar* origMethod = sheet->method; if (!origMethod && mimeType == "text/html") sheet->method = (xmlChar*)"html"; bool success = false; bool shouldFreeSourceDoc = false; if (xmlDocPtr sourceDoc = xmlDocPtrFromNode(sourceNode, shouldFreeSourceDoc)) { // The XML declaration would prevent parsing the result as a fragment, and it's not needed even for documents, // as the result of this function is always immediately parsed. sheet->omitXmlDeclaration = true; xsltTransformContextPtr transformContext = xsltNewTransformContext(sheet, sourceDoc); registerXSLTExtensions(transformContext); // <http://bugs.webkit.org/show_bug.cgi?id=16077>: XSLT processor <xsl:sort> algorithm only compares by code point. xsltSetCtxtSortFunc(transformContext, xsltUnicodeSortFunction); // This is a workaround for a bug in libxslt. // The bug has been fixed in version 1.1.13, so once we ship that this can be removed. if (!transformContext->globalVars) transformContext->globalVars = xmlHashCreate(20); const char** params = xsltParamArrayFromParameterMap(m_parameters); xsltQuoteUserParams(transformContext, params); xmlDocPtr resultDoc = xsltApplyStylesheetUser(sheet, sourceDoc, 0, 0, 0, transformContext); xsltFreeTransformContext(transformContext); freeXsltParamArray(params); if (shouldFreeSourceDoc) xmlFreeDoc(sourceDoc); if ((success = saveResultToString(resultDoc, sheet, resultString))) { mimeType = resultMIMEType(resultDoc, sheet); resultEncoding = (char*)resultDoc->encoding; } xmlFreeDoc(resultDoc); } sheet->method = origMethod; setXSLTLoadCallBack(0, 0, 0); xsltFreeStylesheet(sheet); m_stylesheet = 0; return success; }
/** * lineNoItemNew: * * Returns a new hash table for break points */ xmlHashTablePtr lineNoItemNew(void) { xmlHashTablePtr hash; hash = xmlHashCreate(4); return hash; }
static VXdoc& _transform(Request& r, const String* stylesheet_source, VXdoc& vdoc, xsltStylesheetPtr stylesheet, const xmlChar** transform_params) { xmlDoc& xmldoc=vdoc.get_xmldoc(); xsltTransformContext_auto_ptr transformContext( xsltNewTransformContext(stylesheet, &xmldoc)); // make params literal if (transformContext->globalVars == NULL) // strangly not initialized by xsltNewTransformContext transformContext->globalVars = xmlHashCreate(20); xsltQuoteUserParams(transformContext.get(), (const char**)transform_params); // do transform xmlDoc *transformed=xsltApplyStylesheetUser( stylesheet, &xmldoc, 0/*already quoted-inserted transform_params*/, 0/*const char* output*/, 0/*FILE *profile*/, transformContext.get()); if(!transformed || xmlHaveGenericErrors()) throw XmlException(stylesheet_source, r); //gdome_xml_doc_mkref dislikes XML_HTML_DOCUMENT_NODE type, fixing transformed->type=XML_DOCUMENT_NODE; // constructing result VXdoc& result=*new VXdoc(r.charsets, *transformed); /* grabbing options <xsl:output !method = "xml" | "html" | "text" X| qname-but-not-ncname !version = nmtoken !encoding = string !omit-xml-declaration = "yes" | "no" !standalone = "yes" | "no" !doctype-public = string !doctype-system = string Xcdata-section-elements = qnames !indent = "yes" | "no" !media-type = string /> */ XDocOutputOptions& oo=result.output_options; oo.method=stylesheet->method?&r.transcode(stylesheet->method):0; oo.encoding=stylesheet->encoding?&r.transcode(stylesheet->encoding):0; oo.mediaType=stylesheet->mediaType?&r.transcode(stylesheet->mediaType):0; oo.indent=stylesheet->indent; oo.version=stylesheet->version?&r.transcode(stylesheet->version):0; oo.standalone=stylesheet->standalone; oo.omitXmlDeclaration=stylesheet->omitXmlDeclaration; // return return result; }
/*********************************** * Function Name: InitXmlModHashTable * Desription : This functions Initializes the HashTable for Modset * Input : None * Output : xmlHashTableptr * Return Value : None ***************************************/ t_int32 InitXmlModHashTable (t_void) { hTable = xmlHashCreate (MAX_HASH_SIZE); if (hTable == NULL) { XML_Debug ("A xml Modset Table is not created"); return -1; } return 0; }
/********************************************************************** * Function Name: PSPInitXmlModsetTable * Desription : This functions Initializes the HashTable for Modset * Input : None * Output : xmlHashTableptr * Return Value : None ***********************************************************************/ t_int32 PSPInitXmlModsetTable (t_void) { pModSetTable = xmlHashCreate (MAX_HASH_SIZE); if (pModSetTable == NULL) { XML_Error ("xml Modset Table is not created"); return CNTRLXML_FAILURE; } /* XMLMain_RegisterAll(); *//*This will be called from xmlhtphdlr.c. */ return CNTRLXML_SUCCESS; }
HRESULT SchemaCache_create(IUnknown* pUnkOuter, void** ppObj) { schema_cache* This = heap_alloc(sizeof(schema_cache)); if (!This) return E_OUTOFMEMORY; This->lpVtbl = &schema_cache_vtbl; This->cache = xmlHashCreate(DEFAULT_HASHTABLE_SIZE); This->ref = 1; *ppObj = &This->lpVtbl; return S_OK; }
PyObject *xmlSecTransformCtx_setattr(PyObject *self, PyObject *args) { PyObject *transformCtx_obj, *value_obj; xmlSecTransformCtxPtr transformCtx; const char *name; if (CheckArgs(args, "OS?:transformCtxSetAttr")) { if (!PyArg_ParseTuple(args, "OsO:transformCtxSetAttr", &transformCtx_obj, &name, &value_obj)) return NULL; } else return NULL; transformCtx = xmlSecTransformCtxPtr_get(transformCtx_obj); if (!strcmp(name, "flags")) transformCtx->flags = PyInt_AsLong(value_obj); else if (!strcmp(name, "flags2")) transformCtx->flags2 = PyInt_AsLong(value_obj); else if (!strcmp(name, "enabledUris")) transformCtx->enabledUris = PyInt_AsLong(value_obj); else if (!strcmp(name, "enabledTransforms")) transformCtx->enabledTransforms = *(xmlSecPtrListPtr_get(value_obj)); else if (!strcmp(name, "preExecCallback")) if (value_obj != Py_None) { if (TransformCtxPreExecuteCallbacks == NULL) TransformCtxPreExecuteCallbacks = xmlHashCreate(HASH_TABLE_SIZE); xmlHashAddEntry2(TransformCtxPreExecuteCallbacks, transformCtx->uri, transformCtx->xptrExpr, value_obj); Py_XINCREF(value_obj); transformCtx->preExecCallback = xmlsec_TransformCtxPreExecuteCallback; } else transformCtx->preExecCallback = NULL; else if (!strcmp(name, "result")) transformCtx->result = xmlSecBufferPtr_get(value_obj); else if (!strcmp(name, "status")) transformCtx->status = PyInt_AsLong(value_obj); else if (!strcmp(name, "uri")) transformCtx->uri = (xmlChar *)PyString_AsString(value_obj); else if (!strcmp(name, "xptrExpr")) transformCtx->xptrExpr = (xmlChar *)PyString_AsString(value_obj); else if (!strcmp(name, "first")) transformCtx->first = xmlSecTransformPtr_get(value_obj); else if (!strcmp(name, "last")) transformCtx->last = xmlSecTransformPtr_get(value_obj); Py_INCREF(Py_None); return (Py_None); }
/** * xsltNewKeyTable: * @name: the key name or NULL * @nameURI: the name URI or NULL * * Create a new XSLT KeyTable * * Returns the newly allocated xsltKeyTablePtr or NULL in case of error */ static xsltKeyTablePtr xsltNewKeyTable(const xmlChar *name, const xmlChar *nameURI) { xsltKeyTablePtr cur; cur = (xsltKeyTablePtr) xmlMalloc(sizeof(xsltKeyTable)); if (cur == NULL) { xsltTransformError(NULL, NULL, NULL, "xsltNewKeyTable : malloc failed\n"); return(NULL); } memset(cur, 0, sizeof(xsltKeyTable)); if (name != NULL) cur->name = xmlStrdup(name); if (nameURI != NULL) cur->nameURI = xmlStrdup(nameURI); cur->keys = xmlHashCreate(0); return(cur); }
/** * xsltResolveStylesheetAttributeSet: * @style: the XSLT stylesheet * * resolve the references between attribute sets. */ void xsltResolveStylesheetAttributeSet(xsltStylesheetPtr style) { xsltStylesheetPtr cur; #ifdef WITH_XSLT_DEBUG_ATTRIBUTES xsltGenericDebug(xsltGenericDebugContext, "Resolving attribute sets references\n"); #endif /* * First aggregate all the attribute sets definitions from the imports */ cur = xsltNextImport(style); while (cur != NULL) { if (cur->attributeSets != NULL) { if (style->attributeSets == NULL) { #ifdef WITH_XSLT_DEBUG_ATTRIBUTES xsltGenericDebug(xsltGenericDebugContext, "creating attribute set table\n"); #endif style->attributeSets = xmlHashCreate(10); } xmlHashScanFull(cur->attributeSets, (xmlHashScannerFull) xsltMergeSASCallback, style); /* * the attribute lists have either been migrated to style * or freed directly in xsltMergeSASCallback() */ xmlHashFree(cur->attributeSets, NULL); cur->attributeSets = NULL; } cur = xsltNextImport(cur); } /* * Then resolve all the references and computes the resulting sets */ if (style->attributeSets != NULL) { xmlHashScanFull(style->attributeSets, (xmlHashScannerFull) xsltResolveSASCallback, style); } }
HRESULT SchemaCache_create(MSXML_VERSION version, void** obj) { schema_cache* This = heap_alloc(sizeof(schema_cache)); if (!This) return E_OUTOFMEMORY; TRACE("(%d %p)\n", version, obj); This->IXMLDOMSchemaCollection2_iface.lpVtbl = &XMLDOMSchemaCollection2Vtbl; This->cache = xmlHashCreate(DEFAULT_HASHTABLE_SIZE); This->allocated = 10; This->count = 0; This->uris = heap_alloc(This->allocated*sizeof(xmlChar*)); This->ref = 1; This->version = version; This->validateOnLoad = VARIANT_TRUE; This->read_only = 0; init_dispex(&This->dispex, (IUnknown*)&This->IXMLDOMSchemaCollection2_iface, &schemacache_dispex); *obj = &This->IXMLDOMSchemaCollection2_iface; return S_OK; }
HRESULT SchemaCache_create(const GUID *clsid, IUnknown* pUnkOuter, void** ppObj) { schema_cache* This = heap_alloc(sizeof(schema_cache)); if (!This) return E_OUTOFMEMORY; This->lpVtbl = &schema_cache_vtbl; This->cache = xmlHashCreate(DEFAULT_HASHTABLE_SIZE); This->ref = 1; if (IsEqualCLSID(clsid, &CLSID_XMLSchemaCache30)) This->version = MSXML3; else if (IsEqualCLSID(clsid, &CLSID_DOMDocument40)) This->version = MSXML4; else if (IsEqualCLSID(clsid, &CLSID_DOMDocument60)) This->version = MSXML6; else This->version = MSXML_DEFAULT; *ppObj = &This->lpVtbl; return S_OK; }
/** * xsltResolveStylesheetAttributeSet: * @style: the XSLT stylesheet * * resolve the references between attribute sets. */ void xsltResolveStylesheetAttributeSet(xsltStylesheetPtr style) { xsltStylesheetPtr cur; xsltAttrSetContext asctx; #ifdef WITH_XSLT_DEBUG_ATTRIBUTES xsltGenericDebug(xsltGenericDebugContext, "Resolving attribute sets references\n"); #endif asctx.topStyle = style; cur = style; while (cur != NULL) { if (cur->attributeSets != NULL) { if (style->attributeSets == NULL) { #ifdef WITH_XSLT_DEBUG_ATTRIBUTES xsltGenericDebug(xsltGenericDebugContext, "creating attribute set table\n"); #endif style->attributeSets = xmlHashCreate(10); } asctx.style = cur; xmlHashScanFull(cur->attributeSets, (xmlHashScannerFull) xsltResolveSASCallback, &asctx); if (cur != style) { /* * the attribute lists have either been migrated to style * or freed directly in xsltResolveSASCallback() */ xmlHashFree(cur->attributeSets, NULL); cur->attributeSets = NULL; } } cur = xsltNextImport(cur); } }
.name = "textarea", .add_prompt = add_textarea }, { .prompt_type = text_array, .name = "text_array", .add_prompt = add_text_array }, { .prompt_type = none, .name = NULL, .add_prompt = NULL } }; prompt_type_hash = xmlHashCreate(31); int n; for(n=0; static_prompt_types[n].name != NULL; n++){ xmlHashAddEntry( prompt_type_hash, static_prompt_types[n].name, (void*) &static_prompt_types[n]); } } /* * fetch_options * * * options[] as in select options or radio button labels * as a null termintated array of strings.
/** * xmlCreateEntitiesTable: * * create and initialize an empty entities hash table. * This really doesn't make sense and should be deprecated * * Returns the xmlEntitiesTablePtr just created or NULL in case of error. */ xmlEntitiesTablePtr xmlCreateEntitiesTable(void) { return((xmlEntitiesTablePtr) xmlHashCreate(0)); }
void xsltParseStylesheetAttributeSet(xsltStylesheetPtr style, xmlNodePtr cur) { const xmlChar *ncname; const xmlChar *prefix; xmlChar *value; xmlNodePtr child; xsltAttrElemPtr attrItems; if ((cur == NULL) || (style == NULL) || (cur->type != XML_ELEMENT_NODE)) return; value = xmlGetNsProp(cur, (const xmlChar *)"name", NULL); if ((value == NULL) || (*value == 0)) { xsltGenericError(xsltGenericErrorContext, "xsl:attribute-set : name is missing\n"); if (value) xmlFree(value); return; } ncname = xsltSplitQName(style->dict, value, &prefix); xmlFree(value); value = NULL; if (style->attributeSets == NULL) { #ifdef WITH_XSLT_DEBUG_ATTRIBUTES xsltGenericDebug(xsltGenericDebugContext, "creating attribute set table\n"); #endif style->attributeSets = xmlHashCreate(10); } if (style->attributeSets == NULL) return; attrItems = xmlHashLookup2(style->attributeSets, ncname, prefix); /* * Parse the content. Only xsl:attribute elements are allowed. */ child = cur->children; while (child != NULL) { /* * Report invalid nodes. */ if ((child->type != XML_ELEMENT_NODE) || (child->ns == NULL) || (! IS_XSLT_ELEM(child))) { if (child->type == XML_ELEMENT_NODE) xsltTransformError(NULL, style, child, "xsl:attribute-set : unexpected child %s\n", child->name); else xsltTransformError(NULL, style, child, "xsl:attribute-set : child of unexpected type\n"); } else if (!IS_XSLT_NAME(child, "attribute")) { xsltTransformError(NULL, style, child, "xsl:attribute-set : unexpected child xsl:%s\n", child->name); } else { #ifdef XSLT_REFACTORED xsltAttrElemPtr nextAttr, curAttr; /* * Process xsl:attribute * --------------------- */ #ifdef WITH_XSLT_DEBUG_ATTRIBUTES xsltGenericDebug(xsltGenericDebugContext, "add attribute to list %s\n", ncname); #endif /* * The following was taken over from * xsltAddAttrElemList(). */ if (attrItems == NULL) { attrItems = xsltNewAttrElem(child); } else { curAttr = attrItems; while (curAttr != NULL) { nextAttr = curAttr->next; if (curAttr->attr == child) { /* * URGENT TODO: Can somebody explain * why attrItems is set to curAttr * here? Is this somehow related to * avoidance of recursions? */ attrItems = curAttr; goto next_child; } if (curAttr->next == NULL) curAttr->next = xsltNewAttrElem(child); curAttr = nextAttr; } } /* * Parse the xsl:attribute and its content. */ xsltParseAnyXSLTElem(XSLT_CCTXT(style), child); #else #ifdef WITH_XSLT_DEBUG_ATTRIBUTES xsltGenericDebug(xsltGenericDebugContext, "add attribute to list %s\n", ncname); #endif /* * OLD behaviour: */ attrItems = xsltAddAttrElemList(attrItems, child); #endif } #ifdef XSLT_REFACTORED next_child: #endif child = child->next; } /* * Process attribue "use-attribute-sets". */ /* TODO check recursion */ value = xmlGetNsProp(cur, (const xmlChar *)"use-attribute-sets", NULL); if (value != NULL) { const xmlChar *curval, *endval; curval = value; while (*curval != 0) { while (IS_BLANK(*curval)) curval++; if (*curval == 0) break; endval = curval; while ((*endval != 0) && (!IS_BLANK(*endval))) endval++; curval = xmlDictLookup(style->dict, curval, endval - curval); if (curval) { const xmlChar *ncname2 = NULL; const xmlChar *prefix2 = NULL; xsltAttrElemPtr refAttrItems; #ifdef WITH_XSLT_DEBUG_ATTRIBUTES xsltGenericDebug(xsltGenericDebugContext, "xsl:attribute-set : %s adds use %s\n", ncname, curval); #endif ncname2 = xsltSplitQName(style->dict, curval, &prefix2); refAttrItems = xsltNewAttrElem(NULL); if (refAttrItems != NULL) { refAttrItems->set = ncname2; refAttrItems->ns = prefix2; attrItems = xsltMergeAttrElemList(style, attrItems, refAttrItems); xsltFreeAttrElem(refAttrItems); } } curval = endval; } xmlFree(value); value = NULL; } /* * Update the value */ /* * TODO: Why is this dummy entry needed.? */ if (attrItems == NULL) attrItems = xsltNewAttrElem(NULL); xmlHashUpdateEntry2(style->attributeSets, ncname, prefix, attrItems, NULL); #ifdef WITH_XSLT_DEBUG_ATTRIBUTES xsltGenericDebug(xsltGenericDebugContext, "updated attribute list %s\n", ncname); #endif }
/** * This is the main function for 'el' option */ int elMain(int argc, char **argv) { int errorno = 0; char* inp_file = "-"; if (argc <= 1) elUsage(argc, argv, EXIT_BAD_ARGS); elInitOptions(&elOps); if (argc == 2) errorno = parse_xml_file("-"); else { if (!strcmp(argv[2], "--help") || !strcmp(argv[2], "-h") || !strcmp(argv[2], "-?") || !strcmp(argv[2], "-Z")) { elUsage(argc, argv, EXIT_SUCCESS); } else if (!strcmp(argv[2], "-a")) { elOps.show_attr = 1; if (argc >= 4) inp_file = argv[3]; errorno = parse_xml_file(inp_file); } else if (!strcmp(argv[2], "-v")) { elOps.show_attr_and_val = 1; if (argc >= 4) inp_file = argv[3]; errorno = parse_xml_file(inp_file); } else if (!strcmp(argv[2], "-u")) { elOps.sort_uniq = 1; if (argc >= 4) inp_file = argv[3]; uniq = xmlHashCreate(0); errorno = parse_xml_file(inp_file); } else if (!strncmp(argv[2], "-d", 2)) { elOps.check_depth = atoi(argv[2]+2); /* printf("Checking depth (%d)\n", elOps.check_depth); */ elOps.sort_uniq = 1; if (argc >= 4) inp_file = argv[3]; uniq = xmlHashCreate(0); errorno = parse_xml_file(inp_file); } else if (argv[2][0] != '-') { errorno = parse_xml_file(argv[2]); } else elUsage(argc, argv, EXIT_BAD_ARGS); } if (uniq) { int i; ArrayDest lines; lines.array = xmlMalloc(sizeof(xmlChar*) * xmlHashSize(uniq)); lines.offset = 0; xmlHashScan(uniq, hash_key_put, &lines); qsort(lines.array, lines.offset, sizeof(xmlChar*), compare_string_ptr); for (i = 0; i < lines.offset; i++) { printf("%s\n", lines.array[i]); } xmlFree(lines.array); xmlHashFree(uniq, NULL); } return errorno; }
ourfa_hash_t *ourfa_hash_new(int size) { return xmlHashCreate(size ? size : 10); }
int test (const char* base) { xmlDocPtr docPtr = NULL; char filename[100]; xmlSchemaPtr wxschemas = NULL; Handle2Path = xmlHashCreate(0); /* Read the schema. */ { /* There is no visitibility into parserCtxt. */ xmlSchemaParserCtxtPtr parserCtxt; /* parserCtxt->ctxtType is xmlSchemaTypePtr */ snprintf(filename, 100, "%s.xsd", base); printf("\n\n\n----------------------------------------------------------------\n\n\n"); printf("\n----> Reading schema %s...\n", filename); parserCtxt = xmlSchemaNewParserCtxt(filename); xmlSchemaSetParserErrors(parserCtxt, (xmlSchemaValidityErrorFunc) fprintf, (xmlSchemaValidityWarningFunc) fprintf, stdout); xmlSchemaSetParserAnnotation(parserCtxt, schema_annotation_callback, NULL); wxschemas = xmlSchemaParse(parserCtxt); if (wxschemas == NULL) { printf("***** schema parsing failed!\n"); } xmlSchemaFreeParserCtxt(parserCtxt); printf("\n<---- Schema read!\n\n"); } /* Read the XML. */ { snprintf(filename, 100, "%s.xml", base); if ((docPtr = xmlReadFile(filename, NULL, 0)) == NULL) { printf("failed to parse \"%s\".\n", filename); return -1; } } if (!SKIP) { /* There is no visibility into schemaCtxt. */ xmlSchemaValidCtxtPtr schemaCtxt; int ret; printf("\n----------------------------------------------------------------\n"); printf("\n----> Validating document %s...\n", filename); /* This sets up the schemaCtxt, including a pointer to wxschemas. */ schemaCtxt = xmlSchemaNewValidCtxt(wxschemas); xmlSchemaSetValidErrors(schemaCtxt, (xmlSchemaValidityErrorFunc) fprintf, (xmlSchemaValidityWarningFunc) fprintf, stdout); ret = xmlSchemaValidateDoc(schemaCtxt, docPtr); /* read me! */ if (ret == 0) { /* printf("%s validates\n", filename); */ } else if (ret > 0) { printf("%s fails to validate\n", filename); } else { printf("%s validation generated an internal error\n", filename); } xmlSchemaFreeValidCtxt(schemaCtxt); printf("\n<---- Document validated!\n"); } /* Generate a doc and validate it. */ { xmlDocPtr newDoc = xmlNewDoc(BAD_CAST "1.0"); { xmlSchemaValidCtxtPtr schemaCtxt; int ret; schemaCtxt = xmlSchemaNewValidCtxt(wxschemas); xmlSchemaSetValidErrors(schemaCtxt, (xmlSchemaValidityErrorFunc) fprintf, (xmlSchemaValidityWarningFunc) fprintf, stdout); xmlSchemaSetGeneratorCallback(schemaCtxt, BAD_CAST "people", NULL, &generation_callback, newDoc); ret = xmlSchemaValidateDoc(schemaCtxt, newDoc); if (ret == 0) { /* xmlDocSetRootElement(newDoc, vctxt->node); */ dump_doc(newDoc, NULL); } else if (ret > 0) printf("%s fails to validate\n", filename); else printf("%s validation generated an internal error\n", filename); xmlSchemaFreeValidCtxt(schemaCtxt); printf("\n<---- Schema read!\n\n"); } { xmlSchemaValidCtxtPtr schemaCtxt; int ret; schemaCtxt = xmlSchemaNewValidCtxt(wxschemas); xmlSchemaSetValidErrors(schemaCtxt, (xmlSchemaValidityErrorFunc) fprintf, (xmlSchemaValidityWarningFunc) fprintf, stdout); ret = xmlSchemaValidateDoc(schemaCtxt, newDoc); if (ret == 0) ; else if (ret > 0) printf("%s fails to validate\n", filename); else printf("%s validation generated an internal error\n", filename); xmlSchemaFreeValidCtxt(schemaCtxt); printf("\n<---- Schema read!\n\n"); } xmlFreeDoc(newDoc); } #if 0 /* why can't I just start with doc->children? */ tree_trunk = xmlDocGetRootElement(docPtr); #endif #if 0 tree_trunk = docPtr->children; printf("\n\n\n----------------------------------------------------------------\n\n\n"); printf("\nWalking doc tree...\n"); walk_doc_tree(tree_trunk, 0); printf("\n"); #endif printf("\n\n\n----------------------------------------------------------------\n\n\n"); printf("\nWalking schema tree...\n"); walk_schema_tree(wxschemas); printf("\n"); /*****************************************************************/ /*****************************************************************/ /*****************************************************************/ /*****************************************************************/ /* This will tell me, for example, how to decode sequences. */ printf("\n\n\n----------------------------------------------------------------\n\n\n"); xmlSchemaDump(stdout, wxschemas); /*****************************************************************/ /*****************************************************************/ /*****************************************************************/ /*****************************************************************/ xmlFreeDoc(docPtr); xmlCleanupParser(); xmlHashFree(Handle2Path, NULL); return 0; }
/** * xsltNamespaceAlias: * @style: the XSLT stylesheet * @node: the xsl:namespace-alias node * * Read the stylesheet-prefix and result-prefix attributes, register * them as well as the corresponding namespace. */ void xsltNamespaceAlias(xsltStylesheetPtr style, xmlNodePtr node) { xmlChar *resultPrefix = NULL; xmlChar *stylePrefix = NULL; xmlNsPtr literalNs = NULL; xmlNsPtr targetNs = NULL; #ifdef XSLT_REFACTORED xsltNsAliasPtr alias; if ((style == NULL) || (node == NULL)) return; /* * SPEC XSLT 1.0: * "If a namespace URI is declared to be an alias for multiple * different namespace URIs, then the declaration with the highest * import precedence is used. It is an error if there is more than * one such declaration. An XSLT processor may signal the error; * if it does not signal the error, it must recover by choosing, * from amongst the declarations with the highest import precedence, * the one that occurs last in the stylesheet." * * SPEC TODO: Check for the errors mentioned above. */ /* * NOTE that the XSLT 2.0 also *does* use the NULL namespace if * "#default" is used and there's no default namespace is scope. * I.e., this is *not* an error. * Most XSLT 1.0 implementations work this way. * The XSLT 1.0 spec has nothing to say on the subject. */ /* * Attribute "stylesheet-prefix". */ stylePrefix = xmlGetNsProp(node, (const xmlChar *)"stylesheet-prefix", NULL); if (stylePrefix == NULL) { xsltTransformError(NULL, style, node, "The attribute 'stylesheet-prefix' is missing.\n"); return; } if (xmlStrEqual(stylePrefix, (const xmlChar *)"#default")) literalNs = xmlSearchNs(node->doc, node, NULL); else { literalNs = xmlSearchNs(node->doc, node, stylePrefix); if (literalNs == NULL) { xsltTransformError(NULL, style, node, "Attribute 'stylesheet-prefix': There's no namespace " "declaration in scope for the prefix '%s'.\n", stylePrefix); goto error; } } /* * Attribute "result-prefix". */ resultPrefix = xmlGetNsProp(node, (const xmlChar *)"result-prefix", NULL); if (resultPrefix == NULL) { xsltTransformError(NULL, style, node, "The attribute 'result-prefix' is missing.\n"); goto error; } if (xmlStrEqual(resultPrefix, (const xmlChar *)"#default")) targetNs = xmlSearchNs(node->doc, node, NULL); else { targetNs = xmlSearchNs(node->doc, node, resultPrefix); if (targetNs == NULL) { xsltTransformError(NULL, style, node, "Attribute 'result-prefix': There's no namespace " "declaration in scope for the prefix '%s'.\n", stylePrefix); goto error; } } /* * * Same alias for multiple different target namespace URIs: * TODO: The one with the highest import precedence is used. * Example: * <xsl:namespace-alias stylesheet-prefix="foo" * result-prefix="bar"/> * * <xsl:namespace-alias stylesheet-prefix="foo" * result-prefix="zar"/> * * Same target namespace URI for multiple different aliases: * All alias-definitions will be used. * Example: * <xsl:namespace-alias stylesheet-prefix="bar" * result-prefix="foo"/> * * <xsl:namespace-alias stylesheet-prefix="zar" * result-prefix="foo"/> * Cases using #default: * <xsl:namespace-alias stylesheet-prefix="#default" * result-prefix="#default"/> * TODO: Has this an effect at all? * * <xsl:namespace-alias stylesheet-prefix="foo" * result-prefix="#default"/> * From namespace to no namespace. * * <xsl:namespace-alias stylesheet-prefix="#default" * result-prefix="foo"/> * From no namespace to namespace. */ /* * Store the ns-node in the alias-object. */ alias = xsltNewNsAlias(XSLT_CCTXT(style)); if (alias == NULL) return; alias->literalNs = literalNs; alias->targetNs = targetNs; XSLT_CCTXT(style)->hasNsAliases = 1; #else /* XSLT_REFACTORED */ const xmlChar *literalNsName; const xmlChar *targetNsName; if ((style == NULL) || (node == NULL)) return; stylePrefix = xmlGetNsProp(node, (const xmlChar *)"stylesheet-prefix", NULL); if (stylePrefix == NULL) { xsltTransformError(NULL, style, node, "namespace-alias: stylesheet-prefix attribute missing\n"); return; } resultPrefix = xmlGetNsProp(node, (const xmlChar *)"result-prefix", NULL); if (resultPrefix == NULL) { xsltTransformError(NULL, style, node, "namespace-alias: result-prefix attribute missing\n"); goto error; } if (xmlStrEqual(stylePrefix, (const xmlChar *)"#default")) { literalNs = xmlSearchNs(node->doc, node, NULL); if (literalNs == NULL) { literalNsName = NULL; } else literalNsName = literalNs->href; /* Yes - set for nsAlias table */ } else { literalNs = xmlSearchNs(node->doc, node, stylePrefix); if ((literalNs == NULL) || (literalNs->href == NULL)) { xsltTransformError(NULL, style, node, "namespace-alias: prefix %s not bound to any namespace\n", stylePrefix); goto error; } else literalNsName = literalNs->href; } /* * When "#default" is used for result, if a default namespace has not * been explicitly declared the special value UNDEFINED_DEFAULT_NS is * put into the nsAliases table */ if (xmlStrEqual(resultPrefix, (const xmlChar *)"#default")) { targetNs = xmlSearchNs(node->doc, node, NULL); if (targetNs == NULL) { targetNsName = UNDEFINED_DEFAULT_NS; } else targetNsName = targetNs->href; } else { targetNs = xmlSearchNs(node->doc, node, resultPrefix); if ((targetNs == NULL) || (targetNs->href == NULL)) { xsltTransformError(NULL, style, node, "namespace-alias: prefix %s not bound to any namespace\n", resultPrefix); goto error; } else targetNsName = targetNs->href; } /* * Special case: if #default is used for * the stylesheet-prefix (literal namespace) and there's no default * namespace in scope, we'll use style->defaultAlias for this. */ if (literalNsName == NULL) { if (targetNs != NULL) { /* * BUG TODO: Is it not sufficient to have only 1 field for * this, since subsequently alias declarations will * overwrite this. * Example: * <xsl:namespace-alias result-prefix="foo" * stylesheet-prefix="#default"/> * <xsl:namespace-alias result-prefix="bar" * stylesheet-prefix="#default"/> * The mapping for "foo" won't be visible anymore. */ style->defaultAlias = targetNs->href; } } else { if (style->nsAliases == NULL) style->nsAliases = xmlHashCreate(10); if (style->nsAliases == NULL) { xsltTransformError(NULL, style, node, "namespace-alias: cannot create hash table\n"); goto error; } xmlHashAddEntry((xmlHashTablePtr) style->nsAliases, literalNsName, (void *) targetNsName); } #endif /* else of XSLT_REFACTORED */ error: if (stylePrefix != NULL) xmlFree(stylePrefix); if (resultPrefix != NULL) xmlFree(resultPrefix); }
void xsltParseStylesheetAttributeSet(xsltStylesheetPtr style, xmlNodePtr cur) { const xmlChar *ncname; const xmlChar *prefix; const xmlChar *nsUri = NULL; xmlChar *value; xmlNodePtr child; xsltAttrSetPtr set; if ((cur == NULL) || (style == NULL) || (cur->type != XML_ELEMENT_NODE)) return; value = xmlGetNsProp(cur, (const xmlChar *)"name", NULL); if ((value == NULL) || (*value == 0)) { xsltGenericError(xsltGenericErrorContext, "xsl:attribute-set : name is missing\n"); if (value) xmlFree(value); return; } if (xmlValidateQName(value, 0)) { xsltTransformError(NULL, style, cur, "xsl:attribute-set : The name '%s' is not a valid QName.\n", value); style->errors++; xmlFree(value); return; } ncname = xsltSplitQName(style->dict, value, &prefix); xmlFree(value); value = NULL; if (prefix != NULL) { xmlNsPtr ns = xmlSearchNs(style->doc, cur, prefix); if (ns == NULL) { xsltTransformError(NULL, style, cur, "xsl:attribute-set : No namespace found for QName '%s:%s'\n", prefix, ncname); style->errors++; return; } nsUri = ns->href; } if (style->attributeSets == NULL) { #ifdef WITH_XSLT_DEBUG_ATTRIBUTES xsltGenericDebug(xsltGenericDebugContext, "creating attribute set table\n"); #endif style->attributeSets = xmlHashCreate(10); } if (style->attributeSets == NULL) return; set = xmlHashLookup2(style->attributeSets, ncname, nsUri); if (set == NULL) { set = xsltNewAttrSet(); if (set == NULL) return; xmlHashAddEntry2(style->attributeSets, ncname, nsUri, set); } /* * Parse the content. Only xsl:attribute elements are allowed. */ child = cur->children; while (child != NULL) { /* * Report invalid nodes. */ if ((child->type != XML_ELEMENT_NODE) || (child->ns == NULL) || (! IS_XSLT_ELEM(child))) { if (child->type == XML_ELEMENT_NODE) xsltTransformError(NULL, style, child, "xsl:attribute-set : unexpected child %s\n", child->name); else xsltTransformError(NULL, style, child, "xsl:attribute-set : child of unexpected type\n"); } else if (!IS_XSLT_NAME(child, "attribute")) { xsltTransformError(NULL, style, child, "xsl:attribute-set : unexpected child xsl:%s\n", child->name); } else { #ifdef WITH_XSLT_DEBUG_ATTRIBUTES xsltGenericDebug(xsltGenericDebugContext, "add attribute to list %s\n", ncname); #endif if (child->psvi == NULL) { xsltTransformError(NULL, style, child, "xsl:attribute-set : internal error, attribute %s not " "compiled\n", child->name); } else { set->attrs = xsltAddAttrElemList(set->attrs, child); } } child = child->next; } /* * Process attribute "use-attribute-sets". */ value = xmlGetNsProp(cur, BAD_CAST "use-attribute-sets", NULL); if (value != NULL) { const xmlChar *curval, *endval; curval = value; while (*curval != 0) { while (IS_BLANK(*curval)) curval++; if (*curval == 0) break; endval = curval; while ((*endval != 0) && (!IS_BLANK(*endval))) endval++; curval = xmlDictLookup(style->dict, curval, endval - curval); if (curval) { const xmlChar *ncname2 = NULL; const xmlChar *prefix2 = NULL; const xmlChar *nsUri2 = NULL; #ifdef WITH_XSLT_DEBUG_ATTRIBUTES xsltGenericDebug(xsltGenericDebugContext, "xsl:attribute-set : %s adds use %s\n", ncname, curval); #endif if (xmlValidateQName(curval, 0)) { xsltTransformError(NULL, style, cur, "xsl:attribute-set : The name '%s' in " "use-attribute-sets is not a valid QName.\n", curval); style->errors++; xmlFree(value); return; } ncname2 = xsltSplitQName(style->dict, curval, &prefix2); if (prefix2 != NULL) { xmlNsPtr ns2 = xmlSearchNs(style->doc, cur, prefix2); if (ns2 == NULL) { xsltTransformError(NULL, style, cur, "xsl:attribute-set : No namespace found for QName " "'%s:%s' in use-attribute-sets\n", prefix2, ncname2); style->errors++; xmlFree(value); return; } nsUri2 = ns2->href; } set->useAttrSets = xsltAddUseAttrSetList(set->useAttrSets, ncname2, nsUri2); } curval = endval; } xmlFree(value); value = NULL; } #ifdef WITH_XSLT_DEBUG_ATTRIBUTES xsltGenericDebug(xsltGenericDebugContext, "updated attribute list %s\n", ncname); #endif }
/* * xmlAddEntity : register a new entity for an entities table. */ static xmlEntityPtr xmlAddEntity(xmlDtdPtr dtd, const xmlChar *name, int type, const xmlChar *ExternalID, const xmlChar *SystemID, const xmlChar *content) { xmlEntitiesTablePtr table = NULL; xmlEntityPtr ret; if (name == NULL) return(NULL); switch (type) { case XML_INTERNAL_GENERAL_ENTITY: case XML_EXTERNAL_GENERAL_PARSED_ENTITY: case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY: if (dtd->entities == NULL) dtd->entities = xmlHashCreate(0); table = (xmlEntitiesTablePtr)dtd->entities; break; case XML_INTERNAL_PARAMETER_ENTITY: case XML_EXTERNAL_PARAMETER_ENTITY: if (dtd->pentities == NULL) dtd->pentities = xmlHashCreate(0); table = (xmlEntitiesTablePtr)dtd->pentities; break; case XML_INTERNAL_PREDEFINED_ENTITY: return(NULL); } if (table == NULL) return(NULL); ret = (xmlEntityPtr) xmlMalloc(sizeof(xmlEntity)); if (ret == NULL) { xmlGenericError(xmlGenericErrorContext, "xmlAddEntity: out of memory\n"); return(NULL); } memset(ret, 0, sizeof(xmlEntity)); ret->type = XML_ENTITY_DECL; /* * fill the structure. */ ret->name = xmlStrdup(name); ret->etype = (xmlEntityType) type; if (ExternalID != NULL) ret->ExternalID = xmlStrdup(ExternalID); if (SystemID != NULL) ret->SystemID = xmlStrdup(SystemID); if (content != NULL) { ret->length = xmlStrlen(content); ret->content = xmlStrndup(content, ret->length); } else { ret->length = 0; ret->content = NULL; } ret->URI = NULL; /* to be computed by the layer knowing the defining entity */ ret->orig = NULL; ret->owner = 0; if (xmlHashAddEntry(table, name, ret)) { /* * entity was already defined at another level. */ xmlFreeEntity(ret); return(NULL); } return(ret); }