summaryrefslogtreecommitdiffstats
path: root/tclxml/docObj.c
diff options
context:
space:
mode:
Diffstat (limited to 'tclxml/docObj.c')
-rw-r--r--tclxml/docObj.c1832
1 files changed, 1832 insertions, 0 deletions
diff --git a/tclxml/docObj.c b/tclxml/docObj.c
new file mode 100644
index 0000000..b91ab1f
--- /dev/null
+++ b/tclxml/docObj.c
@@ -0,0 +1,1832 @@
+/* docObj.c --
+ *
+ * This module manages libxml2 xmlDocPtr Tcl objects.
+ *
+ * Copyright (c) 2005 by Explain.
+ * http://www.explain.com.au/
+ * Copyright (c) 2003-2004 Zveno Pty Ltd
+ * http://www.zveno.com/
+ *
+ * See the file "LICENSE" for information on usage and
+ * redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ *
+ * $Id: docObj.c,v 1.1.1.1 2009/01/16 22:11:49 joye Exp $
+ */
+
+#include <tclxml-libxml2/tclxml-libxml2.h>
+#include <libxml/xmlerror.h>
+#include <string.h>
+
+#define TCL_DOES_STUBS \
+ (TCL_MAJOR_VERSION > 8 || TCL_MAJOR_VERSION == 8 && (TCL_MINOR_VERSION > 1 || \
+ (TCL_MINOR_VERSION == 1 && TCL_RELEASE_LEVEL == TCL_FINAL_RELEASE)))
+
+#undef TCL_STORAGE_CLASS
+#define TCL_STORAGE_CLASS DLLEXPORT
+
+/*
+ * Basic list for tracking Tcl_Obj's for a document.
+ */
+
+typedef struct ObjList {
+ Tcl_Obj *objPtr;
+ struct ObjList *next;
+} ObjList;
+
+/*
+ * Prototypes for procedures defined later in this file:
+ */
+
+static void DestroyTclDoc _ANSI_ARGS_((TclXML_libxml2_Document *tDocPtr));
+
+Tcl_FreeInternalRepProc TclXMLlibxml2_DocFree;
+Tcl_DupInternalRepProc TclXMLlibxml2_DocDup;
+Tcl_UpdateStringProc TclXMLlibxml2_DocUpdate;
+Tcl_SetFromAnyProc TclXMLlibxml2_DocSetFromAny;
+
+Tcl_ObjType TclXMLlibxml2_DocObjType = {
+ "libxml2-doc",
+ TclXMLlibxml2_DocFree,
+ TclXMLlibxml2_DocDup,
+ TclXMLlibxml2_DocUpdate,
+ TclXMLlibxml2_DocSetFromAny
+};
+
+typedef struct ThreadSpecificData {
+ int initialized;
+
+ /*
+ * Hash table for mapping string rep to doc structure.
+ */
+
+ Tcl_HashTable *documents;
+ int docCntr;
+
+ /*
+ * Hash table for tracking doc objects.
+ */
+
+ Tcl_HashTable *docByPtr;
+
+ /*
+ * Structured error handling
+ */
+
+ TclXML_ErrorInfo *errorInfoPtr;
+
+} ThreadSpecificData;
+static Tcl_ThreadDataKey dataKey;
+
+/*
+ * libxml2 is mostly thread-safe, but just-in-case use a mutex to control access.
+ */
+
+TCL_DECLARE_MUTEX(libxml2)
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * TclXML_libxml2_InitDocObj --
+ *
+ * Initialise this module.
+ *
+ * Results:
+ * Returns success code
+ *
+ * Side effects:
+ * Memory may be allocated
+ *
+ *----------------------------------------------------------------------------
+ */
+
+int
+TclXML_libxml2_InitDocObj(interp)
+ Tcl_Interp *interp;
+{
+ ThreadSpecificData *tsdPtr = Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
+
+ tsdPtr->initialized = 1;
+ tsdPtr->documents = (Tcl_HashTable *) Tcl_Alloc(sizeof(Tcl_HashTable));
+ Tcl_InitHashTable(tsdPtr->documents, TCL_STRING_KEYS);
+ tsdPtr->docByPtr = (Tcl_HashTable *) Tcl_Alloc(sizeof(Tcl_HashTable));
+ Tcl_InitHashTable(tsdPtr->docByPtr, TCL_ONE_WORD_KEYS);
+
+ tsdPtr->docCntr = 0;
+
+ /*
+ * Setup an error handler that stores structured error info
+ */
+
+ tsdPtr->errorInfoPtr = (TclXML_ErrorInfo *) Tcl_Alloc(sizeof(TclXML_ErrorInfo));
+ tsdPtr->errorInfoPtr->interp = interp;
+ tsdPtr->errorInfoPtr->listPtr = NULL;
+ tsdPtr->errorInfoPtr->nodeHandlerProc = NULL;
+ xmlSetStructuredErrorFunc((void *) tsdPtr->errorInfoPtr, TclXML_libxml2_ErrorHandler);
+
+ return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * TclXML_libxml2_NewDocObj --
+ *
+ * Creates a new xmlDocPtr and wraps it in a Tcl_Obj.
+ *
+ * Results:
+ * Returns a *TclObj
+ *
+ * Side effects:
+ * Objects allocated.
+ *
+ *----------------------------------------------------------------------------
+ */
+
+Tcl_Obj *
+TclXML_libxml2_NewDocObj(interp)
+ Tcl_Interp *interp;
+{
+ xmlDocPtr new;
+
+ Tcl_MutexLock(&libxml2);
+ new = xmlNewDoc((const xmlChar *) "1.0");
+ Tcl_MutexUnlock(&libxml2);
+ if (!new) {
+ Tcl_SetResult(interp, "unable to create document", NULL);
+ return NULL;
+ }
+
+ return TclXML_libxml2_CreateObjFromDoc(new);
+}
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * TclXML_libxml2_CreateObjFromDoc --
+ *
+ * Create a Tcl_Obj to wrap a xmlDocPtr.
+ *
+ * Results:
+ * Returns Tcl_Obj*.
+ *
+ * Side effects:
+ * Allocates object.
+ *
+ *----------------------------------------------------------------------------
+ */
+
+Tcl_Obj *
+TclXML_libxml2_CreateObjFromDoc (docPtr)
+ xmlDocPtr docPtr;
+{
+ ThreadSpecificData *tsdPtr = Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
+ TclXML_libxml2_Document *tDocPtr;
+ Tcl_HashEntry *entryPtr;
+ Tcl_Obj *objPtr;
+ ObjList *listPtr;
+
+ /*
+ * This xmlDocPtr may already have been wrapped by a Tcl object.
+ * If so, return an already existing wrapper.
+ * If not, create a new wrapper.
+ */
+
+ entryPtr = Tcl_FindHashEntry(tsdPtr->docByPtr, (ClientData) docPtr);
+ if (entryPtr) {
+ tDocPtr = (TclXML_libxml2_Document *) Tcl_GetHashValue(entryPtr);
+
+ if (tDocPtr->objs) {
+ /* The first object is sufficient */
+ listPtr = (ObjList *) tDocPtr->objs;
+ objPtr = listPtr->objPtr;
+ } else {
+ /* Create a new Tcl_Obj to refer to existing structure */
+ objPtr = Tcl_NewObj();
+
+ listPtr = (ObjList *) Tcl_Alloc(sizeof(ObjList));
+ listPtr->objPtr = objPtr;
+ listPtr->next = NULL;
+ tDocPtr->objs = (void *) listPtr;
+
+ objPtr->length = strlen(tDocPtr->token);
+ objPtr->bytes = Tcl_Alloc(objPtr->length + 1);
+ strcpy(objPtr->bytes, tDocPtr->token);
+ objPtr->internalRep.twoPtrValue.ptr1 = (void *) tDocPtr;
+ objPtr->internalRep.twoPtrValue.ptr2 = NULL;
+ objPtr->typePtr = &TclXMLlibxml2_DocObjType;
+ }
+
+ } else {
+ int new;
+
+ objPtr = Tcl_NewObj();
+
+ tDocPtr = (TclXML_libxml2_Document *) Tcl_Alloc(sizeof(TclXML_libxml2_Document));
+ tDocPtr->docPtr = docPtr;
+ tDocPtr->token = Tcl_Alloc(20);
+ sprintf(tDocPtr->token, "doc%d", tsdPtr->docCntr++);
+ tDocPtr->keep = TCLXML_LIBXML2_DOCUMENT_IMPLICIT;
+ tDocPtr->dom = NULL;
+ tDocPtr->domfree = NULL;
+ tDocPtr->apphook = NULL;
+ tDocPtr->appfree = NULL;
+
+ listPtr = (ObjList *) Tcl_Alloc(sizeof(ObjList));
+ listPtr->objPtr = objPtr;
+ listPtr->next = NULL;
+ tDocPtr->objs = (void *) listPtr;
+
+ entryPtr = Tcl_CreateHashEntry(tsdPtr->documents, tDocPtr->token, &new);
+ Tcl_SetHashValue(entryPtr, (ClientData) tDocPtr);
+ entryPtr = Tcl_CreateHashEntry(tsdPtr->docByPtr, (ClientData) docPtr, &new);
+ Tcl_SetHashValue(entryPtr, (ClientData) tDocPtr);
+
+ objPtr->length = strlen(tDocPtr->token);
+ objPtr->bytes = Tcl_Alloc(objPtr->length + 1);
+ strcpy(objPtr->bytes, tDocPtr->token);
+ objPtr->internalRep.twoPtrValue.ptr1 = (void *) tDocPtr;
+ objPtr->internalRep.twoPtrValue.ptr2 = NULL;
+ objPtr->typePtr = &TclXMLlibxml2_DocObjType;
+ }
+
+ /* Bug fix #1032660. David Welton. */
+ Tcl_IncrRefCount(objPtr);
+
+ return objPtr;
+}
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * TclXML_libxml2_GetDocFromObj --
+ *
+ * Retrieve the xmlDocPtr from a Tcl object.
+ *
+ * Results:
+ * Returns success code.
+ *
+ * Side effects:
+ * May set internal rep of object.
+ *
+ *----------------------------------------------------------------------------
+ */
+
+int
+TclXML_libxml2_GetDocFromObj (interp, objPtr, docPtr)
+ Tcl_Interp *interp;
+ Tcl_Obj *objPtr;
+ xmlDocPtr *docPtr;
+{
+ TclXML_libxml2_Document *tDocPtr;
+
+ if (TclXML_libxml2_GetTclDocFromObj(interp, objPtr, &tDocPtr) != TCL_OK) {
+ return TCL_ERROR;
+ }
+
+ *docPtr = tDocPtr->docPtr;
+
+ return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * TclXML_libxml2_GetTclDocFromNode --
+ *
+ * Retrieve a pointer to the TclXML Doc structure from a xmlNodePtr.
+ *
+ * Results:
+ * Returns success code.
+ *
+ * Side effects:
+ * Sets pointer
+ *
+ *----------------------------------------------------------------------------
+ */
+
+int
+TclXML_libxml2_GetTclDocFromNode (interp, nodePtr, tDocPtrPtr)
+ Tcl_Interp *interp;
+ xmlNodePtr nodePtr;
+ TclXML_libxml2_Document **tDocPtrPtr;
+{
+ ThreadSpecificData *tsdPtr = Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
+ Tcl_HashEntry *entryPtr;
+
+ entryPtr = Tcl_FindHashEntry(tsdPtr->docByPtr, (ClientData) nodePtr->doc);
+ if (!entryPtr) {
+ *tDocPtrPtr = NULL;
+ Tcl_SetResult(interp, "document not known", NULL);
+ return TCL_ERROR;
+ }
+
+ *tDocPtrPtr = (TclXML_libxml2_Document *) Tcl_GetHashValue(entryPtr);
+
+ return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * TclXML_libxml2_GetTclDocFromObj --
+ *
+ * Retrieve the TclXML_libxml2_Document from a Tcl object.
+ *
+ * Results:
+ * Returns success code.
+ *
+ * Side effects:
+ * May set internal rep of object.
+ *
+ *----------------------------------------------------------------------------
+ */
+
+int
+TclXML_libxml2_GetTclDocFromObj (interp, objPtr, tDocPtr)
+ Tcl_Interp *interp;
+ Tcl_Obj *objPtr;
+ TclXML_libxml2_Document **tDocPtr;
+{
+ if (objPtr->typePtr == &TclXMLlibxml2_DocObjType) {
+ *tDocPtr = (TclXML_libxml2_Document *) objPtr->internalRep.twoPtrValue.ptr1;
+ } else if (TclXMLlibxml2_DocSetFromAny(interp, objPtr) == TCL_OK) {
+ *tDocPtr = (TclXML_libxml2_Document *) objPtr->internalRep.twoPtrValue.ptr1;
+ } else {
+ return TCL_ERROR;
+ }
+
+ return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * TclXML_libxml2_DestroyDocument --
+ *
+ * Manage destruction of a document.
+ * The trick here is to make sure that all Tcl_Obj's
+ * that reference this document have their internal rep
+ * invalidated.
+ *
+ * Results:
+ * None.
+ *
+ * Side effects:
+ * Memory deallocated, object internal reps changed.
+ *
+ *----------------------------------------------------------------------------
+ */
+
+void
+TclXML_libxml2_DestroyDocument (tDocPtr)
+ TclXML_libxml2_Document *tDocPtr;
+{
+ ObjList *listPtr = (ObjList *) tDocPtr->objs;
+ ObjList *next;
+
+ /*
+ * Invalidate the internal representation of all Tcl_Obj's
+ * that refer to this document.
+ */
+ while (listPtr) {
+ next = listPtr->next;
+ TclXMLlibxml2_DocFree(listPtr->objPtr);
+ listPtr = next;
+ }
+
+ if (tDocPtr->keep == TCLXML_LIBXML2_DOCUMENT_KEEP) {
+ DestroyTclDoc(tDocPtr);
+ }
+}
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * TclXML_libxml2_DocKeep --
+ *
+ * Changes how the document's destruction is handled.
+ *
+ * Results:
+ * None.
+ *
+ * Side effects:
+ * Changes document configuration.
+ *
+ *----------------------------------------------------------------------------
+ */
+
+void
+TclXML_libxml2_DocKeep(objPtr, keep)
+ Tcl_Obj *objPtr;
+ TclXML_libxml2_DocumentHandling keep;
+{
+ TclXML_libxml2_Document *tDocPtr;
+
+ if (TclXML_libxml2_GetTclDocFromObj(NULL, objPtr, &tDocPtr) != TCL_OK) {
+ return;
+ }
+
+ tDocPtr->keep = keep;
+}
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * TclXMLlibxml2_DocSetFromAny --
+ *
+ * Finds the xmlDocPtr wrapper for a Tcl object.
+ *
+ * Results:
+ * Returns success code.
+ *
+ * Side effects:
+ * Changes the Tcl_Obj's internal rep.
+ *
+ *----------------------------------------------------------------------------
+ */
+
+int
+TclXMLlibxml2_DocSetFromAny(interp, objPtr)
+ Tcl_Interp *interp;
+ Tcl_Obj *objPtr;
+{
+ ThreadSpecificData *tsdPtr = Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
+ Tcl_HashEntry *entryPtr;
+ TclXML_libxml2_Document *tDocPtr;
+ ObjList *listPtr;
+
+ entryPtr = Tcl_FindHashEntry(tsdPtr->documents, Tcl_GetStringFromObj(objPtr, NULL));
+
+ if (entryPtr) {
+
+ if (objPtr->typePtr != NULL && objPtr->typePtr->freeIntRepProc != NULL) {
+ objPtr->typePtr->freeIntRepProc(objPtr);
+ }
+
+ objPtr->internalRep.twoPtrValue.ptr1 = Tcl_GetHashValue(entryPtr);
+ objPtr->typePtr = &TclXMLlibxml2_DocObjType;
+
+ tDocPtr = (TclXML_libxml2_Document *) objPtr->internalRep.twoPtrValue.ptr1;
+
+ /*
+ * Add this object to the Tcl_Obj list.
+ * NB. There should be no duplicates.
+ */
+ listPtr = (ObjList *) tDocPtr->objs;
+ if (listPtr == NULL) {
+ listPtr = (ObjList *) Tcl_Alloc(sizeof(ObjList));
+ listPtr->objPtr = objPtr;
+ listPtr->next = NULL;
+ tDocPtr->objs = listPtr;
+ } else {
+ ObjList *newPtr;
+
+ newPtr = (ObjList *) Tcl_Alloc(sizeof(ObjList));
+ newPtr->objPtr = objPtr;
+ newPtr->next = listPtr;
+ tDocPtr->objs = (void *) newPtr;
+ }
+ /* SANITY CHECK NEEDED: no duplicates in the list */
+
+ } else {
+
+ if (interp) {
+ Tcl_ResetResult(interp);
+ Tcl_AppendResult(interp, "token \"", Tcl_GetStringFromObj(objPtr, NULL), "\" is not a libxml2 document", NULL);
+ }
+
+ return TCL_ERROR;
+ }
+
+ return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * TclXMLlibxml2_DocUpdate --
+ *
+ * Finds the token for a xmlDocPtr wrapper.
+ *
+ * Results:
+ * None.
+ *
+ * Side effects:
+ * Changes the Tcl_Obj's string rep.
+ *
+ *----------------------------------------------------------------------------
+ */
+
+void
+TclXMLlibxml2_DocUpdate(objPtr)
+ Tcl_Obj *objPtr;
+{
+ ThreadSpecificData *tsdPtr = Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
+ Tcl_HashEntry *entryPtr;
+
+ entryPtr = Tcl_FindHashEntry(tsdPtr->docByPtr, objPtr->internalRep.twoPtrValue.ptr1);
+ Tcl_InvalidateStringRep(objPtr);
+ if (entryPtr != NULL) {
+ TclXML_libxml2_Document *tDocPtr = (TclXML_libxml2_Document *) Tcl_GetHashValue(entryPtr);
+ objPtr->length = strlen(tDocPtr->token);
+ objPtr->bytes = Tcl_Alloc(objPtr->length + 1);
+ strcpy(objPtr->bytes, tDocPtr->token);
+ }
+}
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * TclXMLlibxml2_DocDup --
+ *
+ * Duplicates the Tcl wrapper.
+ * NB. This does *not* copy the document itself - it simply creates
+ * another reference to the same document.
+ *
+ * Results:
+ * None.
+ *
+ * Side effects:
+ * Changes the target Tcl_Obj.
+ *
+ *----------------------------------------------------------------------------
+ */
+
+void
+TclXMLlibxml2_DocDup(srcPtr, dstPtr)
+ Tcl_Obj *srcPtr;
+ Tcl_Obj *dstPtr;
+{
+ TclXML_libxml2_Document *tDocPtr;
+ ObjList *listPtr;
+
+ if (dstPtr->typePtr != NULL && dstPtr->typePtr->freeIntRepProc != NULL) {
+ dstPtr->typePtr->freeIntRepProc(dstPtr);
+ }
+
+ tDocPtr = (TclXML_libxml2_Document *) srcPtr->internalRep.twoPtrValue.ptr1;
+ listPtr = (ObjList *) Tcl_Alloc(sizeof(ObjList));
+ listPtr->objPtr = dstPtr;
+ listPtr->next = ((ObjList *) tDocPtr->objs)->next;
+ tDocPtr->objs = listPtr;
+
+ Tcl_InvalidateStringRep(dstPtr);
+
+ dstPtr->internalRep.twoPtrValue.ptr1 = srcPtr->internalRep.twoPtrValue.ptr1;
+ dstPtr->internalRep.twoPtrValue.ptr2 = NULL;
+ dstPtr->typePtr = srcPtr->typePtr;
+}
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * TclXMLlibxml2_DocFree --
+ *
+ * Removes a Tcl wrapper to a libxml2 document.
+ *
+ * Results:
+ * None.
+ *
+ * Side effects:
+ * May free the document.
+ *
+ *----------------------------------------------------------------------------
+ */
+
+void
+TclXMLlibxml2_DocFree(objPtr)
+ Tcl_Obj *objPtr;
+{
+ TclXML_libxml2_Document *tDocPtr = (TclXML_libxml2_Document *) objPtr->internalRep.twoPtrValue.ptr1;
+ ObjList *listPtr = tDocPtr->objs;
+ ObjList *prevPtr = NULL;
+
+ while (listPtr) {
+ if (listPtr->objPtr == objPtr) {
+ break;
+ }
+ prevPtr = listPtr;
+ listPtr = listPtr->next;
+ }
+
+ if (listPtr == NULL) {
+ /* internal error */
+ } else if (prevPtr == NULL) {
+ tDocPtr->objs = listPtr->next;
+ } else {
+ prevPtr->next = listPtr->next;
+ }
+ Tcl_Free((char *) listPtr);
+
+ if (tDocPtr->objs == NULL && tDocPtr->keep == TCLXML_LIBXML2_DOCUMENT_IMPLICIT) {
+ DestroyTclDoc(tDocPtr);
+ }
+
+ objPtr->internalRep.twoPtrValue.ptr1 = NULL;
+ objPtr->internalRep.twoPtrValue.ptr2 = NULL;
+ objPtr->typePtr = NULL;
+}
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * DestroyTclDoc --
+ *
+ * Destroy the Tcl wrapper for a document.
+ *
+ * Results:
+ * None.
+ *
+ * Side effects:
+ * Free memory.
+ *
+ *----------------------------------------------------------------------------
+ */
+
+void
+DestroyTclDoc(tDocPtr)
+ TclXML_libxml2_Document *tDocPtr;
+{
+ ThreadSpecificData *tsdPtr = Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
+ Tcl_HashEntry *entryPtr;
+
+ if (tDocPtr->domfree) {
+ (tDocPtr->domfree)(tDocPtr->dom);
+ }
+ if (tDocPtr->appfree) {
+ (tDocPtr->appfree)(tDocPtr->dom);
+ }
+
+ entryPtr = Tcl_FindHashEntry(tsdPtr->documents, tDocPtr->token);
+ if (entryPtr) {
+ Tcl_DeleteHashEntry(entryPtr);
+ } else {
+ /* Internal error */
+ }
+
+ entryPtr = Tcl_FindHashEntry(tsdPtr->docByPtr, (ClientData) tDocPtr->docPtr);
+ if (entryPtr) {
+ Tcl_DeleteHashEntry(entryPtr);
+ } else {
+ /* Internal error */
+ }
+
+ Tcl_MutexLock(&libxml2);
+ xmlFreeDoc(tDocPtr->docPtr);
+ Tcl_MutexUnlock(&libxml2);
+
+ Tcl_Free(tDocPtr->token);
+ Tcl_Free((char *) tDocPtr);
+}
+
+/*
+ *----------------------------------------------------------------------------
+ *
+ * TclXML_libxml2_ErrorHandler --
+ *
+ * Handler for structured error reports
+ *
+ * Results:
+ * None.
+ *
+ * Side effects:
+ * Creates a Tcl_Obj to store the error information.
+ *
+ *----------------------------------------------------------------------------
+ */
+
+static Tcl_Obj *
+ErrorDomainToString(domain)
+ int domain;
+{
+ switch ((xmlErrorDomain) domain) {
+ case XML_FROM_NONE:
+ return Tcl_NewStringObj("none", -1);
+ case XML_FROM_PARSER:
+ return Tcl_NewStringObj("parser", -1);
+ case XML_FROM_TREE:
+ return Tcl_NewStringObj("tree", -1);
+ case XML_FROM_NAMESPACE:
+ return Tcl_NewStringObj("namespace", -1);
+ case XML_FROM_DTD:
+ return Tcl_NewStringObj("dtd-validation", -1);
+ case XML_FROM_HTML:
+ return Tcl_NewStringObj("html-parser", -1);
+ case XML_FROM_MEMORY:
+ return Tcl_NewStringObj("memory", -1);
+ case XML_FROM_OUTPUT:
+ return Tcl_NewStringObj("output", -1);
+ case XML_FROM_IO:
+ return Tcl_NewStringObj("io", -1);
+ case XML_FROM_FTP:
+ return Tcl_NewStringObj("ftp", -1);
+ case XML_FROM_HTTP:
+ return Tcl_NewStringObj("http", -1);
+ case XML_FROM_XINCLUDE:
+ return Tcl_NewStringObj("XInclude", -1);
+ case XML_FROM_XPOINTER:
+ return Tcl_NewStringObj("XPointer", -1);
+ case XML_FROM_REGEXP:
+ return Tcl_NewStringObj("regexp", -1);
+ case XML_FROM_DATATYPE:
+ return Tcl_NewStringObj("schemas-datatype", -1);
+ case XML_FROM_SCHEMASP:
+ return Tcl_NewStringObj("schemas-parser", -1);
+ case XML_FROM_SCHEMASV:
+ return Tcl_NewStringObj("schemas-validation", -1);
+ case XML_FROM_RELAXNGP:
+ return Tcl_NewStringObj("relaxng-parser", -1);
+ case XML_FROM_RELAXNGV:
+ return Tcl_NewStringObj("relaxng-validation", -1);
+ case XML_FROM_CATALOG:
+ return Tcl_NewStringObj("catalog", -1);
+ case XML_FROM_C14N:
+ return Tcl_NewStringObj("canonicalization", -1);
+ case XML_FROM_XSLT:
+ return Tcl_NewStringObj("xslt", -1);
+ default:
+ return Tcl_NewObj();
+ }
+}
+
+static Tcl_Obj *
+ErrorLevelToString(level)
+ xmlErrorLevel level;
+{
+ switch (level) {
+ case XML_ERR_WARNING:
+ return Tcl_NewStringObj("warning", -1);
+ case XML_ERR_ERROR:
+ return Tcl_NewStringObj("error", -1);
+ case XML_ERR_FATAL:
+ return Tcl_NewStringObj("fatal", -1);
+ case XML_ERR_NONE:
+ default:
+ return Tcl_NewStringObj("none", -1);
+ }
+}
+
+static Tcl_Obj *
+ErrorCodeToString(code)
+ int code;
+{
+ switch ((xmlParserErrors) code) {
+ case XML_ERR_OK:
+ return Tcl_NewObj();
+ case XML_ERR_INTERNAL_ERROR:
+ return Tcl_NewStringObj("internal-error", -1);
+ case XML_ERR_NO_MEMORY:
+ return Tcl_NewStringObj("no-memory", -1);
+ case XML_ERR_DOCUMENT_START:
+ return Tcl_NewStringObj("document-start", -1);
+ case XML_ERR_DOCUMENT_EMPTY:
+ return Tcl_NewStringObj("document-empty", -1);
+ case XML_ERR_DOCUMENT_END:
+ return Tcl_NewStringObj("document-end", -1);
+ case XML_ERR_INVALID_HEX_CHARREF:
+ return Tcl_NewStringObj("invalid-hex-character-reference", -1);
+ case XML_ERR_INVALID_DEC_CHARREF:
+ return Tcl_NewStringObj("invalid-decimal-character-reference", -1);
+ case XML_ERR_INVALID_CHARREF:
+ return Tcl_NewStringObj("invalid-character-reference", -1);
+ case XML_ERR_INVALID_CHAR:
+ return Tcl_NewStringObj("invalid-character", -1);
+ case XML_ERR_CHARREF_AT_EOF:
+ return Tcl_NewStringObj("character-reference-at-eof", -1);
+ case XML_ERR_CHARREF_IN_PROLOG:
+ return Tcl_NewStringObj("character-reference-in-prolog", -1);
+ case XML_ERR_CHARREF_IN_EPILOG:
+ return Tcl_NewStringObj("character-reference-in-epilog", -1);
+ case XML_ERR_CHARREF_IN_DTD:
+ return Tcl_NewStringObj("character-reference-in-dtd", -1);
+ case XML_ERR_ENTITYREF_AT_EOF:
+ return Tcl_NewStringObj("entity-reference-at-eof", -1);
+ case XML_ERR_ENTITYREF_IN_PROLOG:
+ return Tcl_NewStringObj("entity-reference-in-prolog", -1);
+ case XML_ERR_ENTITYREF_IN_EPILOG:
+ return Tcl_NewStringObj("entity-reference-in-epilog", -1);
+ case XML_ERR_ENTITYREF_IN_DTD:
+ return Tcl_NewStringObj("entity-reference-in-dtd", -1);
+ case XML_ERR_PEREF_AT_EOF:
+ return Tcl_NewStringObj("parameter-entity-reference-at-eof", -1);
+ case XML_ERR_PEREF_IN_PROLOG:
+ return Tcl_NewStringObj("parameter-entity-reference-in-prolog", -1);
+ case XML_ERR_PEREF_IN_EPILOG:
+ return Tcl_NewStringObj("parameter-entity-reference-in-epilog", -1);
+ case XML_ERR_PEREF_IN_INT_SUBSET:
+ return Tcl_NewStringObj("parameter-entity-reference-in-internal-subset", -1);
+ case XML_ERR_ENTITYREF_NO_NAME:
+ return Tcl_NewStringObj("entity-reference-no-name", -1);
+ case XML_ERR_ENTITYREF_SEMICOL_MISSING:
+ return Tcl_NewStringObj("entity-reference-semicolon-missing", -1);
+ case XML_ERR_PEREF_NO_NAME:
+ return Tcl_NewStringObj("parameter-entity-reference-no-name", -1);
+ case XML_ERR_PEREF_SEMICOL_MISSING:
+ return Tcl_NewStringObj("parameter-entity-reference-semicolon-missing", -1);
+ case XML_ERR_UNDECLARED_ENTITY:
+ return Tcl_NewStringObj("undeclared-entity", -1);
+ case XML_WAR_UNDECLARED_ENTITY:
+ return Tcl_NewStringObj("undeclared-entity", -1);
+ case XML_ERR_UNPARSED_ENTITY:
+ return Tcl_NewStringObj("unparsed-entity", -1);
+ case XML_ERR_ENTITY_IS_EXTERNAL:
+ return Tcl_NewStringObj("entity-is-external", -1);
+ case XML_ERR_ENTITY_IS_PARAMETER:
+ return Tcl_NewStringObj("entity-is-parameter", -1);
+ case XML_ERR_UNKNOWN_ENCODING:
+ return Tcl_NewStringObj("unknown-encoding", -1);
+ case XML_ERR_UNSUPPORTED_ENCODING:
+ return Tcl_NewStringObj("unsupported-encoding", -1);
+ case XML_ERR_STRING_NOT_STARTED:
+ return Tcl_NewStringObj("string-not-started", -1);
+ case XML_ERR_STRING_NOT_CLOSED:
+ return Tcl_NewStringObj("string-not-closed", -1);
+ case XML_ERR_NS_DECL_ERROR:
+ return Tcl_NewStringObj("namespace-declaration-error", -1);
+ case XML_ERR_ENTITY_NOT_STARTED:
+ return Tcl_NewStringObj("entity-not-started", -1);
+ case XML_ERR_ENTITY_NOT_FINISHED:
+ return Tcl_NewStringObj("entity-not-finished", -1);
+ case XML_ERR_LT_IN_ATTRIBUTE:
+ return Tcl_NewStringObj("less-than-character-in-attribute", -1);
+ case XML_ERR_ATTRIBUTE_NOT_STARTED:
+ return Tcl_NewStringObj("attribute-not-started", -1);
+ case XML_ERR_ATTRIBUTE_NOT_FINISHED:
+ return Tcl_NewStringObj("attribute-not-finished", -1);
+ case XML_ERR_ATTRIBUTE_WITHOUT_VALUE:
+ return Tcl_NewStringObj("attribute-without-value", -1);
+ case XML_ERR_ATTRIBUTE_REDEFINED:
+ return Tcl_NewStringObj("attribute-redefined", -1);
+ case XML_ERR_LITERAL_NOT_STARTED:
+ return Tcl_NewStringObj("literal-not-started", -1);
+ case XML_ERR_LITERAL_NOT_FINISHED:
+ return Tcl_NewStringObj("literal-not-finished", -1);
+ case XML_ERR_COMMENT_NOT_FINISHED:
+ return Tcl_NewStringObj("comment-not-finished", -1);
+ case XML_ERR_PI_NOT_STARTED:
+ return Tcl_NewStringObj("processing-instruction-not-started", -1);
+ case XML_ERR_PI_NOT_FINISHED:
+ return Tcl_NewStringObj("processing-instruction-not-finished", -1);
+ case XML_ERR_NOTATION_NOT_STARTED:
+ return Tcl_NewStringObj("notation-not-started", -1);
+ case XML_ERR_NOTATION_NOT_FINISHED:
+ return Tcl_NewStringObj("notation-not-finished", -1);
+ case XML_ERR_ATTLIST_NOT_STARTED:
+ return Tcl_NewStringObj("attribute-list-not-started", -1);
+ case XML_ERR_ATTLIST_NOT_FINISHED:
+ return Tcl_NewStringObj("attribute-list-not-finished", -1);
+ case XML_ERR_MIXED_NOT_STARTED:
+ return Tcl_NewStringObj("mixed-content-not-started", -1);
+ case XML_ERR_MIXED_NOT_FINISHED:
+ return Tcl_NewStringObj("mixed-content-not-finished", -1);
+ case XML_ERR_ELEMCONTENT_NOT_STARTED:
+ return Tcl_NewStringObj("element-content-not-started", -1);
+ case XML_ERR_ELEMCONTENT_NOT_FINISHED:
+ return Tcl_NewStringObj("element-content-not-finished", -1);
+ case XML_ERR_XMLDECL_NOT_STARTED:
+ return Tcl_NewStringObj("xml-declaration-not-started", -1);
+ case XML_ERR_XMLDECL_NOT_FINISHED:
+ return Tcl_NewStringObj("xml-declaration-not-finished", -1);
+ case XML_ERR_CONDSEC_NOT_STARTED:
+ return Tcl_NewStringObj("conditional-section-not-started", -1);
+ case XML_ERR_CONDSEC_NOT_FINISHED:
+ return Tcl_NewStringObj("conditional-section-not-finished", -1);
+ case XML_ERR_EXT_SUBSET_NOT_FINISHED:
+ return Tcl_NewStringObj("external-dtd-subset-not-finished", -1);
+ case XML_ERR_DOCTYPE_NOT_FINISHED:
+ return Tcl_NewStringObj("document-type-declaration-not-finished", -1);
+ case XML_ERR_MISPLACED_CDATA_END:
+ return Tcl_NewStringObj("misplaced-cdata-section-end", -1);
+ case XML_ERR_CDATA_NOT_FINISHED:
+ return Tcl_NewStringObj("cdata-section-not-finished", -1);
+ case XML_ERR_RESERVED_XML_NAME:
+ return Tcl_NewStringObj("reserved-xml-name", -1);
+ case XML_ERR_SPACE_REQUIRED:
+ return Tcl_NewStringObj("space-required", -1);
+ case XML_ERR_SEPARATOR_REQUIRED:
+ return Tcl_NewStringObj("separator-required", -1);
+ case XML_ERR_NMTOKEN_REQUIRED:
+ return Tcl_NewStringObj("NMTOKEN-required", -1);
+ case XML_ERR_NAME_REQUIRED:
+ return Tcl_NewStringObj("NAME-required", -1);
+ case XML_ERR_PCDATA_REQUIRED:
+ return Tcl_NewStringObj("PCDATA-required", -1);
+ case XML_ERR_URI_REQUIRED:
+ return Tcl_NewStringObj("URI-required", -1);
+ case XML_ERR_PUBID_REQUIRED:
+ return Tcl_NewStringObj("public-identifier-required", -1);
+ case XML_ERR_LT_REQUIRED:
+ return Tcl_NewStringObj("less-than-character-required", -1);
+ case XML_ERR_GT_REQUIRED:
+ return Tcl_NewStringObj("greater-than-character-required", -1);
+ case XML_ERR_LTSLASH_REQUIRED:
+ return Tcl_NewStringObj("less-than-and-slash-characters-required", -1);
+ case XML_ERR_EQUAL_REQUIRED:
+ return Tcl_NewStringObj("equal-character-required", -1);
+ case XML_ERR_TAG_NAME_MISMATCH:
+ return Tcl_NewStringObj("tag-name-mismatch", -1);
+ case XML_ERR_TAG_NOT_FINISHED:
+ return Tcl_NewStringObj("tag-not-finished", -1);
+ case XML_ERR_STANDALONE_VALUE:
+ return Tcl_NewStringObj("standalone-value", -1);
+ case XML_ERR_ENCODING_NAME:
+ return Tcl_NewStringObj("encoding-name", -1);
+ case XML_ERR_HYPHEN_IN_COMMENT:
+ return Tcl_NewStringObj("hyphen-in-comment", -1);
+ case XML_ERR_INVALID_ENCODING:
+ return Tcl_NewStringObj("invalid-encoding", -1);
+ case XML_ERR_EXT_ENTITY_STANDALONE:
+ return Tcl_NewStringObj("external-entity-standalone", -1);
+ case XML_ERR_CONDSEC_INVALID:
+ return Tcl_NewStringObj("conditional-section-invalid", -1);
+ case XML_ERR_VALUE_REQUIRED:
+ return Tcl_NewStringObj("value-required", -1);
+ case XML_ERR_NOT_WELL_BALANCED:
+ return Tcl_NewStringObj("not-well-balanced", -1);
+ case XML_ERR_EXTRA_CONTENT:
+ return Tcl_NewStringObj("extra-content", -1);
+ case XML_ERR_ENTITY_CHAR_ERROR:
+ return Tcl_NewStringObj("entity-character-error", -1);
+ case XML_ERR_ENTITY_PE_INTERNAL:
+ return Tcl_NewStringObj("parameter-entity-internal-error", -1);
+ case XML_ERR_ENTITY_LOOP:
+ return Tcl_NewStringObj("entity-loop", -1);
+ case XML_ERR_ENTITY_BOUNDARY:
+ return Tcl_NewStringObj("entity-boundary", -1);
+ case XML_ERR_INVALID_URI:
+ return Tcl_NewStringObj("invalid-URI", -1);
+ case XML_ERR_URI_FRAGMENT:
+ return Tcl_NewStringObj("URI-fragment", -1);
+ case XML_WAR_CATALOG_PI:
+ return Tcl_NewStringObj("catalog-processing-instruction", -1);
+ case XML_ERR_NO_DTD:
+ return Tcl_NewStringObj("no-document-type-definition", -1);
+ case XML_ERR_CONDSEC_INVALID_KEYWORD:
+ return Tcl_NewStringObj("conditional-section-invalid-keyword", -1);
+ case XML_ERR_VERSION_MISSING:
+ return Tcl_NewStringObj("version-missing", -1);
+ case XML_WAR_UNKNOWN_VERSION:
+ return Tcl_NewStringObj("unknown-version", -1);
+ case XML_WAR_LANG_VALUE:
+ return Tcl_NewStringObj("lang-value", -1);
+ case XML_WAR_NS_URI:
+ return Tcl_NewStringObj("namespace-uri", -1);
+ case XML_WAR_NS_URI_RELATIVE:
+ return Tcl_NewStringObj("namespace-uri-relative", -1);
+ case XML_NS_ERR_XML_NAMESPACE:
+ return Tcl_NewStringObj("xml-namespace", -1);
+ case XML_NS_ERR_UNDEFINED_NAMESPACE:
+ return Tcl_NewStringObj("undefined-namespace", -1);
+ case XML_NS_ERR_QNAME:
+ return Tcl_NewStringObj("qualified-name", -1);
+ case XML_NS_ERR_ATTRIBUTE_REDEFINED:
+ return Tcl_NewStringObj("attribute-redefined", -1);
+ case XML_DTD_ATTRIBUTE_DEFAULT:
+ return Tcl_NewStringObj("attribute-default", -1);
+ case XML_DTD_ATTRIBUTE_REDEFINED:
+ return Tcl_NewStringObj("attribute-redefined", -1);
+ case XML_DTD_ATTRIBUTE_VALUE:
+ return Tcl_NewStringObj("attribute-value", -1);
+ case XML_DTD_CONTENT_ERROR:
+ return Tcl_NewStringObj("content-error", -1);
+ case XML_DTD_CONTENT_MODEL:
+ return Tcl_NewStringObj("content-model", -1);
+ case XML_DTD_CONTENT_NOT_DETERMINIST:
+ return Tcl_NewStringObj("content-model-not-deterministic", -1);
+ case XML_DTD_DIFFERENT_PREFIX:
+ return Tcl_NewStringObj("different-prefix", -1);
+ case XML_DTD_ELEM_DEFAULT_NAMESPACE:
+ return Tcl_NewStringObj("element-default-namespace", -1);
+ case XML_DTD_ELEM_NAMESPACE:
+ return Tcl_NewStringObj("element-namespace", -1);
+ case XML_DTD_ELEM_REDEFINED:
+ return Tcl_NewStringObj("element-type-redefined", -1);
+ case XML_DTD_EMPTY_NOTATION:
+ return Tcl_NewStringObj("empty-notation", -1);
+ case XML_DTD_ENTITY_TYPE:
+ return Tcl_NewStringObj("entity-type", -1);
+ case XML_DTD_ID_FIXED:
+ return Tcl_NewStringObj("ID-fixed", -1);
+ case XML_DTD_ID_REDEFINED:
+ return Tcl_NewStringObj("ID-redefined", -1);
+ case XML_DTD_ID_SUBSET:
+ return Tcl_NewStringObj("ID-subset", -1);
+ case XML_DTD_INVALID_CHILD:
+ return Tcl_NewStringObj("invalid-child", -1);
+ case XML_DTD_INVALID_DEFAULT:
+ return Tcl_NewStringObj("invalid-default", -1);
+ case XML_DTD_LOAD_ERROR:
+ return Tcl_NewStringObj("load-error", -1);
+ case XML_DTD_MISSING_ATTRIBUTE:
+ return Tcl_NewStringObj("missing-attribute", -1);
+ case XML_DTD_MIXED_CORRUPT:
+ return Tcl_NewStringObj("mixed-content-corrupt", -1);
+ case XML_DTD_MULTIPLE_ID:
+ return Tcl_NewStringObj("multiple-ID", -1);
+ case XML_DTD_NO_DOC:
+ return Tcl_NewStringObj("no-document", -1);
+ case XML_DTD_NO_DTD:
+ return Tcl_NewStringObj("no-document-type-definition", -1);
+ case XML_DTD_NO_ELEM_NAME:
+ return Tcl_NewStringObj("no-element-name", -1);
+ case XML_DTD_NO_PREFIX:
+ return Tcl_NewStringObj("no-prefix", -1);
+ case XML_DTD_NO_ROOT:
+ return Tcl_NewStringObj("no-root", -1);
+ case XML_DTD_NOTATION_REDEFINED:
+ return Tcl_NewStringObj("notation-redefined", -1);
+ case XML_DTD_NOTATION_VALUE:
+ return Tcl_NewStringObj("notation-value", -1);
+ case XML_DTD_NOT_EMPTY:
+ return Tcl_NewStringObj("not-empty", -1);
+ case XML_DTD_NOT_PCDATA:
+ return Tcl_NewStringObj("not-PCDATA", -1);
+ case XML_DTD_NOT_STANDALONE:
+ return Tcl_NewStringObj("not-standalone", -1);
+ case XML_DTD_ROOT_NAME:
+ return Tcl_NewStringObj("root-name", -1);
+ case XML_DTD_STANDALONE_WHITE_SPACE:
+ return Tcl_NewStringObj("standalone-white-space", -1);
+ case XML_DTD_UNKNOWN_ATTRIBUTE:
+ return Tcl_NewStringObj("unknown-attribute", -1);
+ case XML_DTD_UNKNOWN_ELEM:
+ return Tcl_NewStringObj("unknown-element-type", -1);
+ case XML_DTD_UNKNOWN_ENTITY:
+ return Tcl_NewStringObj("unknown-entity", -1);
+ case XML_DTD_UNKNOWN_ID:
+ return Tcl_NewStringObj("unknown-ID", -1);
+ case XML_DTD_UNKNOWN_NOTATION:
+ return Tcl_NewStringObj("unknown-notation", -1);
+ case XML_HTML_STRUCURE_ERROR:
+ return Tcl_NewStringObj("structure-error", -1);
+ case XML_HTML_UNKNOWN_TAG:
+ return Tcl_NewStringObj("unknown-tag", -1);
+ case XML_RNGP_ANYNAME_ATTR_ANCESTOR:
+ return Tcl_NewStringObj("anyname-attribute-ancestor", -1);
+ case XML_RNGP_ATTR_CONFLICT:
+ return Tcl_NewStringObj("attribute-conflict", -1);
+ case XML_RNGP_ATTRIBUTE_CHILDREN:
+ return Tcl_NewStringObj("attribute-children", -1);
+ case XML_RNGP_ATTRIBUTE_CONTENT:
+ return Tcl_NewStringObj("attribute-content", -1);
+ case XML_RNGP_ATTRIBUTE_EMPTY:
+ return Tcl_NewStringObj("attribute-empty", -1);
+ case XML_RNGP_ATTRIBUTE_NOOP:
+ return Tcl_NewStringObj("attribute-noop", -1);
+ case XML_RNGP_CHOICE_CONTENT:
+ return Tcl_NewStringObj("choice-content", -1);
+ case XML_RNGP_CREATE_FAILURE:
+ return Tcl_NewStringObj("create-failure", -1);
+ case XML_RNGP_DATA_CONTENT:
+ return Tcl_NewStringObj("data-content", -1);
+ case XML_RNGP_DEF_CHOICE_AND_INTERLEAVE:
+ return Tcl_NewStringObj("def-choice-and-interleave", -1);
+ case XML_RNGP_DEFINE_CREATE_FAILED:
+ return Tcl_NewStringObj("define-create-failed", -1);
+ case XML_RNGP_DEFINE_EMPTY:
+ return Tcl_NewStringObj("define-empty", -1);
+ case XML_RNGP_DEFINE_MISSING:
+ return Tcl_NewStringObj("define-missing", -1);
+ case XML_RNGP_DEFINE_NAME_MISSING:
+ return Tcl_NewStringObj("define-name-missing", -1);
+ case XML_RNGP_ELEM_CONTENT_EMPTY:
+ return Tcl_NewStringObj("elem-content-empty", -1);
+ case XML_RNGP_ELEM_CONTENT_ERROR:
+ return Tcl_NewStringObj("elem-content-error", -1);
+ case XML_RNGP_ELEMENT_EMPTY:
+ return Tcl_NewStringObj("element-empty", -1);
+ case XML_RNGP_ELEMENT_CONTENT:
+ return Tcl_NewStringObj("element-content", -1);
+ case XML_RNGP_ELEMENT_NAME:
+ return Tcl_NewStringObj("element-name", -1);
+ case XML_RNGP_ELEMENT_NO_CONTENT:
+ return Tcl_NewStringObj("element-no-content", -1);
+ case XML_RNGP_ELEM_TEXT_CONFLICT:
+ return Tcl_NewStringObj("element-text-conflict", -1);
+ case XML_RNGP_EMPTY:
+ return Tcl_NewStringObj("empty", -1);
+ case XML_RNGP_EMPTY_CONSTRUCT:
+ return Tcl_NewStringObj("empty-construct", -1);
+ case XML_RNGP_EMPTY_CONTENT:
+ return Tcl_NewStringObj("empty-content", -1);
+ case XML_RNGP_EMPTY_NOT_EMPTY:
+ return Tcl_NewStringObj("empty-not-empty", -1);
+ case XML_RNGP_ERROR_TYPE_LIB:
+ return Tcl_NewStringObj("error-type-library", -1);
+ case XML_RNGP_EXCEPT_EMPTY:
+ return Tcl_NewStringObj("except-empty", -1);
+ case XML_RNGP_EXCEPT_MISSING:
+ return Tcl_NewStringObj("except-missing", -1);
+ case XML_RNGP_EXCEPT_MULTIPLE:
+ return Tcl_NewStringObj("except-multiple", -1);
+ case XML_RNGP_EXCEPT_NO_CONTENT:
+ return Tcl_NewStringObj("except-no-content", -1);
+ case XML_RNGP_EXTERNALREF_EMTPY:
+ return Tcl_NewStringObj("external-reference-empty", -1);
+ case XML_RNGP_EXTERNAL_REF_FAILURE:
+ return Tcl_NewStringObj("external-reference-failure", -1);
+ case XML_RNGP_EXTERNALREF_RECURSE:
+ return Tcl_NewStringObj("external-reference-recursive", -1);
+ case XML_RNGP_FORBIDDEN_ATTRIBUTE:
+ return Tcl_NewStringObj("forbidden-attribute", -1);
+ case XML_RNGP_FOREIGN_ELEMENT:
+ return Tcl_NewStringObj("foreign-element", -1);
+ case XML_RNGP_GRAMMAR_CONTENT:
+ return Tcl_NewStringObj("grammar-content", -1);
+ case XML_RNGP_GRAMMAR_EMPTY:
+ return Tcl_NewStringObj("grammar-empty", -1);
+ case XML_RNGP_GRAMMAR_MISSING:
+ return Tcl_NewStringObj("grammar-missing", -1);
+ case XML_RNGP_GRAMMAR_NO_START:
+ return Tcl_NewStringObj("grammar-no-start", -1);
+ case XML_RNGP_GROUP_ATTR_CONFLICT:
+ return Tcl_NewStringObj("group-attribute-conflict-", -1);
+ case XML_RNGP_HREF_ERROR:
+ return Tcl_NewStringObj("href-error", -1);
+ case XML_RNGP_INCLUDE_EMPTY:
+ return Tcl_NewStringObj("include-empty", -1);
+ case XML_RNGP_INCLUDE_FAILURE:
+ return Tcl_NewStringObj("include-failure", -1);
+ case XML_RNGP_INCLUDE_RECURSE:
+ return Tcl_NewStringObj("include-recurse", -1);
+ case XML_RNGP_INTERLEAVE_ADD:
+ return Tcl_NewStringObj("interleave-add", -1);
+ case XML_RNGP_INTERLEAVE_CREATE_FAILED:
+ return Tcl_NewStringObj("interleave-create-failed", -1);
+ case XML_RNGP_INTERLEAVE_EMPTY:
+ return Tcl_NewStringObj("interleave-empty", -1);
+ case XML_RNGP_INTERLEAVE_NO_CONTENT:
+ return Tcl_NewStringObj("interleave-no-content", -1);
+ case XML_RNGP_INVALID_DEFINE_NAME:
+ return Tcl_NewStringObj("invalid-define-name", -1);
+ case XML_RNGP_INVALID_URI:
+ return Tcl_NewStringObj("invalid-URI", -1);
+ case XML_RNGP_INVALID_VALUE:
+ return Tcl_NewStringObj("invalid-value", -1);
+ case XML_RNGP_MISSING_HREF:
+ return Tcl_NewStringObj("missing-href", -1);
+ case XML_RNGP_NAME_MISSING:
+ return Tcl_NewStringObj("NAME-missing", -1);
+ case XML_RNGP_NEED_COMBINE:
+ return Tcl_NewStringObj("need-combine", -1);
+ case XML_RNGP_NOTALLOWED_NOT_EMPTY:
+ return Tcl_NewStringObj("notallowed-not-empty", -1);
+ case XML_RNGP_NSNAME_ATTR_ANCESTOR:
+ return Tcl_NewStringObj("nsname-attr-ancestor", -1);
+ case XML_RNGP_NSNAME_NO_NS:
+ return Tcl_NewStringObj("nsname-no-namespace", -1);
+ case XML_RNGP_PARAM_FORBIDDEN:
+ return Tcl_NewStringObj("param-forbidden", -1);
+ case XML_RNGP_PARAM_NAME_MISSING:
+ return Tcl_NewStringObj("param-name-missing", -1);
+ case XML_RNGP_PARENTREF_CREATE_FAILED:
+ return Tcl_NewStringObj("parentref-create-failed", -1);
+ case XML_RNGP_PARENTREF_NAME_INVALID:
+ return Tcl_NewStringObj("parentref-name-invalid", -1);
+ case XML_RNGP_PARENTREF_NO_NAME:
+ return Tcl_NewStringObj("parentref-no-name", -1);
+ case XML_RNGP_PARENTREF_NO_PARENT:
+ return Tcl_NewStringObj("parentref-no-parent", -1);
+ case XML_RNGP_PARENTREF_NOT_EMPTY:
+ return Tcl_NewStringObj("parentref-not-empty", -1);
+ case XML_RNGP_PARSE_ERROR:
+ return Tcl_NewStringObj("parse-error", -1);
+ case XML_RNGP_PAT_ANYNAME_EXCEPT_ANYNAME:
+ return Tcl_NewStringObj("pat-anyname-except-anyname", -1);
+ case XML_RNGP_PAT_ATTR_ATTR:
+ return Tcl_NewStringObj("par-attr-attr", -1);
+ case XML_RNGP_PAT_ATTR_ELEM:
+ return Tcl_NewStringObj("pat-attr-elem", -1);
+ case XML_RNGP_PAT_DATA_EXCEPT_ATTR:
+ return Tcl_NewStringObj("pat-data-except-attr", -1);
+ case XML_RNGP_PAT_DATA_EXCEPT_ELEM:
+ return Tcl_NewStringObj("pat-data-except-elem", -1);
+ case XML_RNGP_PAT_DATA_EXCEPT_EMPTY:
+ return Tcl_NewStringObj("pat-data-except-empty", -1);
+ case XML_RNGP_PAT_DATA_EXCEPT_GROUP:
+ return Tcl_NewStringObj("pat-data-except-group", -1);
+ case XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE:
+ return Tcl_NewStringObj("pat-data-except-interleave", -1);
+ case XML_RNGP_PAT_DATA_EXCEPT_LIST:
+ return Tcl_NewStringObj("pat-data-except-list", -1);
+ case XML_RNGP_PAT_DATA_EXCEPT_ONEMORE:
+ return Tcl_NewStringObj("pat-data-except-onemore", -1);
+ case XML_RNGP_PAT_DATA_EXCEPT_REF:
+ return Tcl_NewStringObj("pat-data-except-ref", -1);
+ case XML_RNGP_PAT_DATA_EXCEPT_TEXT:
+ return Tcl_NewStringObj("pat-data-except-text", -1);
+ case XML_RNGP_PAT_LIST_ATTR:
+ return Tcl_NewStringObj("pat-list-attr", -1);
+ case XML_RNGP_PAT_LIST_ELEM:
+ return Tcl_NewStringObj("pat-list-elem", -1);
+ case XML_RNGP_PAT_LIST_INTERLEAVE:
+ return Tcl_NewStringObj("pat-list-interleave", -1);
+ case XML_RNGP_PAT_LIST_LIST:
+ return Tcl_NewStringObj("pat-list-list", -1);
+ case XML_RNGP_PAT_LIST_REF:
+ return Tcl_NewStringObj("pat-list-ref", -1);
+ case XML_RNGP_PAT_LIST_TEXT:
+ return Tcl_NewStringObj("pat-list-text", -1);
+ case XML_RNGP_PAT_NSNAME_EXCEPT_ANYNAME:
+ return Tcl_NewStringObj("pat-nsname-except-anyname", -1);
+ case XML_RNGP_PAT_NSNAME_EXCEPT_NSNAME:
+ return Tcl_NewStringObj("pat-nsname-except-nsname", -1);
+ case XML_RNGP_PAT_ONEMORE_GROUP_ATTR:
+ return Tcl_NewStringObj("pat-onemore-group-attr", -1);
+ case XML_RNGP_PAT_ONEMORE_INTERLEAVE_ATTR:
+ return Tcl_NewStringObj("pat-onemore-interleave-attr", -1);
+ case XML_RNGP_PAT_START_ATTR:
+ return Tcl_NewStringObj("pat-start-attr", -1);
+ case XML_RNGP_PAT_START_DATA:
+ return Tcl_NewStringObj("pat-start-data", -1);
+ case XML_RNGP_PAT_START_EMPTY:
+ return Tcl_NewStringObj("pat-start-empty", -1);
+ case XML_RNGP_PAT_START_GROUP:
+ return Tcl_NewStringObj("pat-start-group", -1);
+ case XML_RNGP_PAT_START_INTERLEAVE:
+ return Tcl_NewStringObj("pat-start-interleave", -1);
+ case XML_RNGP_PAT_START_LIST:
+ return Tcl_NewStringObj("pat-start-list", -1);
+ case XML_RNGP_PAT_START_ONEMORE:
+ return Tcl_NewStringObj("pat-start-onemore", -1);
+ case XML_RNGP_PAT_START_TEXT:
+ return Tcl_NewStringObj("pat-start-text", -1);
+ case XML_RNGP_PAT_START_VALUE:
+ return Tcl_NewStringObj("pat-start-value", -1);
+ case XML_RNGP_PREFIX_UNDEFINED:
+ return Tcl_NewStringObj("prefix-undefined", -1);
+ case XML_RNGP_REF_CREATE_FAILED:
+ return Tcl_NewStringObj("ref-create-failed", -1);
+ case XML_RNGP_REF_CYCLE:
+ return Tcl_NewStringObj("ref-cycle", -1);
+ case XML_RNGP_REF_NAME_INVALID:
+ return Tcl_NewStringObj("ref-name-invalid", -1);
+ case XML_RNGP_REF_NO_DEF:
+ return Tcl_NewStringObj("ref-no-def", -1);
+ case XML_RNGP_REF_NO_NAME:
+ return Tcl_NewStringObj("ref-no-name", -1);
+ case XML_RNGP_REF_NOT_EMPTY:
+ return Tcl_NewStringObj("ref-not-empty", -1);
+ case XML_RNGP_START_CHOICE_AND_INTERLEAVE:
+ return Tcl_NewStringObj("start-choice-and-interleave", -1);
+ case XML_RNGP_START_CONTENT:
+ return Tcl_NewStringObj("start-content", -1);
+ case XML_RNGP_START_EMPTY:
+ return Tcl_NewStringObj("start-empty", -1);
+ case XML_RNGP_START_MISSING:
+ return Tcl_NewStringObj("start-missing", -1);
+ case XML_RNGP_TEXT_EXPECTED:
+ return Tcl_NewStringObj("text-expected", -1);
+ case XML_RNGP_TEXT_HAS_CHILD:
+ return Tcl_NewStringObj("text-has-child", -1);
+ case XML_RNGP_TYPE_MISSING:
+ return Tcl_NewStringObj("type-missing", -1);
+ case XML_RNGP_TYPE_NOT_FOUND:
+ return Tcl_NewStringObj("type-not-found", -1);
+ case XML_RNGP_UNKNOWN_ATTRIBUTE:
+ return Tcl_NewStringObj("unknown-attribute", -1);
+ case XML_RNGP_UNKNOWN_COMBINE:
+ return Tcl_NewStringObj("unknown-combine", -1);
+ case XML_RNGP_UNKNOWN_CONSTRUCT:
+ return Tcl_NewStringObj("unknown-construct", -1);
+ case XML_RNGP_UNKNOWN_TYPE_LIB:
+ return Tcl_NewStringObj("unknown-type-lib", -1);
+ case XML_RNGP_URI_FRAGMENT:
+ return Tcl_NewStringObj("URI-fragment", -1);
+ case XML_RNGP_URI_NOT_ABSOLUTE:
+ return Tcl_NewStringObj("URI-not-absolute", -1);
+ case XML_RNGP_VALUE_EMPTY:
+ return Tcl_NewStringObj("value-empty", -1);
+ case XML_RNGP_VALUE_NO_CONTENT:
+ return Tcl_NewStringObj("value-no-content", -1);
+ case XML_RNGP_XMLNS_NAME:
+ return Tcl_NewStringObj("xmlns-name", -1);
+ case XML_RNGP_XML_NS:
+ return Tcl_NewStringObj("xml-ns", -1);
+ case XML_XPATH_EXPRESSION_OK:
+ return Tcl_NewStringObj("expression-ok", -1);
+ case XML_XPATH_NUMBER_ERROR:
+ return Tcl_NewStringObj("number-error", -1);
+ case XML_XPATH_UNFINISHED_LITERAL_ERROR:
+ return Tcl_NewStringObj("unfinished-literal", -1);
+ case XML_XPATH_START_LITERAL_ERROR:
+ return Tcl_NewStringObj("start-literal", -1);
+ case XML_XPATH_VARIABLE_REF_ERROR:
+ return Tcl_NewStringObj("variable-reference", -1);
+ case XML_XPATH_UNDEF_VARIABLE_ERROR:
+ return Tcl_NewStringObj("undefined-variable", -1);
+ case XML_XPATH_INVALID_PREDICATE_ERROR:
+ return Tcl_NewStringObj("invalid-predicate", -1);
+ case XML_XPATH_EXPR_ERROR:
+ return Tcl_NewStringObj("expression-error", -1);
+ case XML_XPATH_UNCLOSED_ERROR:
+ return Tcl_NewStringObj("unclosed", -1);
+ case XML_XPATH_UNKNOWN_FUNC_ERROR:
+ return Tcl_NewStringObj("unknown-function", -1);
+ case XML_XPATH_INVALID_OPERAND:
+ return Tcl_NewStringObj("invalid-operand", -1);
+ case XML_XPATH_INVALID_TYPE:
+ return Tcl_NewStringObj("invalid-type", -1);
+ case XML_XPATH_INVALID_ARITY:
+ return Tcl_NewStringObj("invalid-arity", -1);
+ case XML_XPATH_INVALID_CTXT_SIZE:
+ return Tcl_NewStringObj("invalid-context-size", -1);
+ case XML_XPATH_INVALID_CTXT_POSITION:
+ return Tcl_NewStringObj("invalid-context-position", -1);
+ case XML_XPATH_MEMORY_ERROR:
+ return Tcl_NewStringObj("memory-error", -1);
+ case XML_XPTR_SYNTAX_ERROR:
+ return Tcl_NewStringObj("syntax-error", -1);
+ case XML_XPTR_RESOURCE_ERROR:
+ return Tcl_NewStringObj("resource-error", -1);
+ case XML_XPTR_SUB_RESOURCE_ERROR:
+ return Tcl_NewStringObj("sub-resource-error", -1);
+ case XML_XPATH_UNDEF_PREFIX_ERROR:
+ return Tcl_NewStringObj("undefined-prefix", -1);
+ case XML_XPATH_ENCODING_ERROR:
+ return Tcl_NewStringObj("encoding-error", -1);
+ case XML_XPATH_INVALID_CHAR_ERROR:
+ return Tcl_NewStringObj("invalid-character", -1);
+ case XML_TREE_INVALID_HEX:
+ return Tcl_NewStringObj("invalid-hex", -1);
+ case XML_TREE_INVALID_DEC:
+ return Tcl_NewStringObj("invalid-decimal", -1);
+ case XML_TREE_UNTERMINATED_ENTITY:
+ return Tcl_NewStringObj("unterminated-entity", -1);
+ case XML_SAVE_NOT_UTF8:
+ return Tcl_NewStringObj("not-utf8", -1);
+ case XML_SAVE_CHAR_INVALID:
+ return Tcl_NewStringObj("invalid-character", -1);
+ case XML_SAVE_NO_DOCTYPE:
+ return Tcl_NewStringObj("no-document-type-declaration", -1);
+ case XML_SAVE_UNKNOWN_ENCODING:
+ return Tcl_NewStringObj("unknown-encoding", -1);
+ case XML_REGEXP_COMPILE_ERROR:
+ return Tcl_NewStringObj("compile-error", -1);
+ case XML_IO_UNKNOWN:
+ return Tcl_NewStringObj("unknown", -1);
+ case XML_IO_EACCES:
+ return Tcl_NewStringObj("eacces", -1);
+ case XML_IO_EAGAIN:
+ return Tcl_NewStringObj("eagain", -1);
+ case XML_IO_EBADF:
+ return Tcl_NewStringObj("ebadf", -1);
+ case XML_IO_EBADMSG:
+ return Tcl_NewStringObj("ebadmsg", -1);
+ case XML_IO_EBUSY:
+ return Tcl_NewStringObj("ebusy", -1);
+ case XML_IO_ECANCELED:
+ return Tcl_NewStringObj("ecanceled", -1);
+ case XML_IO_ECHILD:
+ return Tcl_NewStringObj("echild", -1);
+ case XML_IO_EDEADLK:
+ return Tcl_NewStringObj("edeadlk", -1);
+ case XML_IO_EDOM:
+ return Tcl_NewStringObj("edom", -1);
+ case XML_IO_EEXIST:
+ return Tcl_NewStringObj("eexist", -1);
+ case XML_IO_EINPROGRESS:
+ return Tcl_NewStringObj("einprogress", -1);
+ case XML_IO_EINTR:
+ return Tcl_NewStringObj("eintr", -1);
+ case XML_IO_EINVAL:
+ return Tcl_NewStringObj("einval", -1);
+ case XML_IO_EIO:
+ return Tcl_NewStringObj("eio", -1);
+ case XML_IO_EISDIR:
+ return Tcl_NewStringObj("eisdir", -1);
+ case XML_IO_EMFILE:
+ return Tcl_NewStringObj("emfile", -1);
+ case XML_IO_EMLINK:
+ return Tcl_NewStringObj("emlink", -1);
+ case XML_IO_EMSGSIZE:
+ return Tcl_NewStringObj("emsgsize", -1);
+ case XML_IO_ENAMETOOLONG:
+ return Tcl_NewStringObj("enametoolong", -1);
+ case XML_IO_ENFILE:
+ return Tcl_NewStringObj("enfile", -1);
+ case XML_IO_ENODEV:
+ return Tcl_NewStringObj("enodev", -1);
+ case XML_IO_ENOENT:
+ return Tcl_NewStringObj("enoent", -1);
+ case XML_IO_ENOEXEC:
+ return Tcl_NewStringObj("enoexec", -1);
+ case XML_IO_ENOLCK:
+ return Tcl_NewStringObj("enolck", -1);
+ case XML_IO_ENOMEM:
+ return Tcl_NewStringObj("enomem", -1);
+ case XML_IO_ENOSPC:
+ return Tcl_NewStringObj("enospc", -1);
+ case XML_IO_ENOSYS:
+ return Tcl_NewStringObj("enosys", -1);
+ case XML_IO_ENOTDIR:
+ return Tcl_NewStringObj("enotdir", -1);
+ case XML_IO_ENOTEMPTY:
+ return Tcl_NewStringObj("enotempty", -1);
+ case XML_IO_ENOTSUP:
+ return Tcl_NewStringObj("enotsup", -1);
+ case XML_IO_ENOTTY:
+ return Tcl_NewStringObj("enotty", -1);
+ case XML_IO_ENXIO:
+ return Tcl_NewStringObj("enxio", -1);
+ case XML_IO_EPERM:
+ return Tcl_NewStringObj("eperm", -1);
+ case XML_IO_EPIPE:
+ return Tcl_NewStringObj("epipe", -1);
+ case XML_IO_ERANGE:
+ return Tcl_NewStringObj("erange", -1);
+ case XML_IO_EROFS:
+ return Tcl_NewStringObj("erofs", -1);
+ case XML_IO_ESPIPE:
+ return Tcl_NewStringObj("espipe", -1);
+ case XML_IO_ESRCH:
+ return Tcl_NewStringObj("esrch", -1);
+ case XML_IO_ETIMEDOUT:
+ return Tcl_NewStringObj("etimedout", -1);
+ case XML_IO_EXDEV:
+ return Tcl_NewStringObj("exdev", -1);
+ case XML_IO_NETWORK_ATTEMPT:
+ return Tcl_NewStringObj("network-attempt", -1);
+ case XML_IO_ENCODER:
+ return Tcl_NewStringObj("encoder", -1);
+ case XML_IO_FLUSH:
+ return Tcl_NewStringObj("flush", -1);
+ case XML_IO_WRITE:
+ return Tcl_NewStringObj("write", -1);
+ case XML_IO_NO_INPUT:
+ return Tcl_NewStringObj("no-input", -1);
+ case XML_IO_BUFFER_FULL:
+ return Tcl_NewStringObj("buffer-full", -1);
+ case XML_IO_LOAD_ERROR:
+ return Tcl_NewStringObj("load-error", -1);
+ case XML_IO_ENOTSOCK:
+ return Tcl_NewStringObj("enotsock", -1);
+ case XML_IO_EISCONN:
+ return Tcl_NewStringObj("eisconn", -1);
+ case XML_IO_ECONNREFUSED:
+ return Tcl_NewStringObj("econnrefused", -1);
+ case XML_IO_ENETUNREACH:
+ return Tcl_NewStringObj("enetunreach", -1);
+ case XML_IO_EADDRINUSE:
+ return Tcl_NewStringObj("eaddrinuse", -1);
+ case XML_IO_EALREADY:
+ return Tcl_NewStringObj("ealready", -1);
+ case XML_IO_EAFNOSUPPORT:
+ return Tcl_NewStringObj("eafnosupport", -1);
+ case XML_XINCLUDE_RECURSION:
+ return Tcl_NewStringObj("recursion", -1);
+ case XML_XINCLUDE_PARSE_VALUE:
+ return Tcl_NewStringObj("parse-value", -1);
+ case XML_XINCLUDE_ENTITY_DEF_MISMATCH:
+ return Tcl_NewStringObj("entity-def-mismatch", -1);
+ case XML_XINCLUDE_NO_HREF:
+ return Tcl_NewStringObj("no-href", -1);
+ case XML_XINCLUDE_NO_FALLBACK:
+ return Tcl_NewStringObj("no-fallback", -1);
+ case XML_XINCLUDE_HREF_URI:
+ return Tcl_NewStringObj("href-URI", -1);
+ case XML_XINCLUDE_TEXT_FRAGMENT:
+ return Tcl_NewStringObj("text-fragment", -1);
+ case XML_XINCLUDE_TEXT_DOCUMENT:
+ return Tcl_NewStringObj("text-document", -1);
+ case XML_XINCLUDE_INVALID_CHAR:
+ return Tcl_NewStringObj("invalid-character", -1);
+ case XML_XINCLUDE_BUILD_FAILED:
+ return Tcl_NewStringObj("build-failed", -1);
+ case XML_XINCLUDE_UNKNOWN_ENCODING:
+ return Tcl_NewStringObj("unknown-encoding", -1);
+ case XML_XINCLUDE_MULTIPLE_ROOT:
+ return Tcl_NewStringObj("multiple-root", -1);
+ case XML_XINCLUDE_XPTR_FAILED:
+ return Tcl_NewStringObj("XPointer-failed", -1);
+ case XML_XINCLUDE_XPTR_RESULT:
+ return Tcl_NewStringObj("XPointer-result", -1);
+ case XML_XINCLUDE_INCLUDE_IN_INCLUDE:
+ return Tcl_NewStringObj("include-in-include", -1);
+ case XML_XINCLUDE_FALLBACKS_IN_INCLUDE:
+ return Tcl_NewStringObj("fallbacks-in-include", -1);
+ case XML_XINCLUDE_FALLBACK_NOT_IN_INCLUDE:
+ return Tcl_NewStringObj("fallback-not-in-include", -1);
+ case XML_CATALOG_MISSING_ATTR:
+ return Tcl_NewStringObj("missing-attribute", -1);
+ case XML_CATALOG_ENTRY_BROKEN:
+ return Tcl_NewStringObj("entry-broken", -1);
+ case XML_CATALOG_PREFER_VALUE:
+ return Tcl_NewStringObj("prefer-value", -1);
+ case XML_CATALOG_NOT_CATALOG:
+ return Tcl_NewStringObj("not-catalog", -1);
+ case XML_CATALOG_RECURSION:
+ return Tcl_NewStringObj("recursion", -1);
+ case XML_SCHEMAP_PREFIX_UNDEFINED:
+ return Tcl_NewStringObj("prefix-undefined", -1);
+ case XML_SCHEMAP_ATTRFORMDEFAULT_VALUE:
+ return Tcl_NewStringObj("attribute-form-default-value", -1);
+ case XML_SCHEMAP_ATTRGRP_NONAME_NOREF:
+ return Tcl_NewStringObj("attribute-group-noname-noref", -1);
+ case XML_SCHEMAP_ATTR_NONAME_NOREF:
+ return Tcl_NewStringObj("attribute-noname-noref", -1);
+ case XML_SCHEMAP_COMPLEXTYPE_NONAME_NOREF:
+ return Tcl_NewStringObj("complexType-noname-noref", -1);
+ case XML_SCHEMAP_ELEMFORMDEFAULT_VALUE:
+ return Tcl_NewStringObj("element-form-default-value", -1);
+ case XML_SCHEMAP_ELEM_NONAME_NOREF:
+ return Tcl_NewStringObj("element-noname-noref", -1);
+ case XML_SCHEMAP_EXTENSION_NO_BASE:
+ return Tcl_NewStringObj("extension-no-base", -1);
+ case XML_SCHEMAP_FACET_NO_VALUE:
+ return Tcl_NewStringObj("facet-no-value", -1);
+ case XML_SCHEMAP_FAILED_BUILD_IMPORT:
+ return Tcl_NewStringObj("failed-build-import", -1);
+ case XML_SCHEMAP_GROUP_NONAME_NOREF:
+ return Tcl_NewStringObj("group-noname-noref", -1);
+ case XML_SCHEMAP_IMPORT_NAMESPACE_NOT_URI:
+ return Tcl_NewStringObj("import-namespace-not-URI", -1);
+ case XML_SCHEMAP_IMPORT_REDEFINE_NSNAME:
+ return Tcl_NewStringObj("import-redefine-nsname", -1);
+ case XML_SCHEMAP_IMPORT_SCHEMA_NOT_URI:
+ return Tcl_NewStringObj("import-schema-not-URI", -1);
+ case XML_SCHEMAP_INVALID_BOOLEAN:
+ return Tcl_NewStringObj("invalid-boolean", -1);
+ case XML_SCHEMAP_INVALID_ENUM:
+ return Tcl_NewStringObj("invalid-enumeration", -1);
+ case XML_SCHEMAP_INVALID_FACET:
+ return Tcl_NewStringObj("invalid-facet", -1);
+ case XML_SCHEMAP_INVALID_FACET_VALUE:
+ return Tcl_NewStringObj("invalid-facet-value", -1);
+ case XML_SCHEMAP_INVALID_MAXOCCURS:
+ return Tcl_NewStringObj("invalid-maxOccurs", -1);
+ case XML_SCHEMAP_INVALID_MINOCCURS:
+ return Tcl_NewStringObj("invalid-minOccurs", -1);
+ case XML_SCHEMAP_INVALID_REF_AND_SUBTYPE:
+ return Tcl_NewStringObj("invalid-ref-and-subtype", -1);
+ case XML_SCHEMAP_INVALID_WHITE_SPACE:
+ return Tcl_NewStringObj("invalid-white-space", -1);
+ case XML_SCHEMAP_NOATTR_NOREF:
+ return Tcl_NewStringObj("noattr-noref", -1);
+ case XML_SCHEMAP_NOTATION_NO_NAME:
+ return Tcl_NewStringObj("notation-no-name", -1);
+ case XML_SCHEMAP_NOTYPE_NOREF:
+ return Tcl_NewStringObj("notype-noref", -1);
+ case XML_SCHEMAP_REF_AND_SUBTYPE:
+ return Tcl_NewStringObj("ref-and-subtype", -1);
+ case XML_SCHEMAP_RESTRICTION_NONAME_NOREF:
+ return Tcl_NewStringObj("restriction-noname-noref", -1);
+ case XML_SCHEMAP_SIMPLETYPE_NONAME:
+ return Tcl_NewStringObj("simpleType-noname", -1);
+ case XML_SCHEMAP_TYPE_AND_SUBTYPE:
+ return Tcl_NewStringObj("type-and-subtype", -1);
+ case XML_SCHEMAP_UNKNOWN_ALL_CHILD:
+ return Tcl_NewStringObj("unknown-all-child", -1);
+ case XML_SCHEMAP_UNKNOWN_ANYATTRIBUTE_CHILD:
+ return Tcl_NewStringObj("unknown-anyattribute-child", -1);
+ case XML_SCHEMAP_UNKNOWN_ATTR_CHILD:
+ return Tcl_NewStringObj("unknown-attribute-child", -1);
+ case XML_SCHEMAP_UNKNOWN_ATTRGRP_CHILD:
+ return Tcl_NewStringObj("unknown-attributeGroup-child", -1);
+ case XML_SCHEMAP_UNKNOWN_ATTRIBUTE_GROUP:
+ return Tcl_NewStringObj("unknown-attributeGroup", -1);
+ case XML_SCHEMAP_UNKNOWN_BASE_TYPE:
+ return Tcl_NewStringObj("unknown-base-type", -1);
+ case XML_SCHEMAP_UNKNOWN_CHOICE_CHILD:
+ return Tcl_NewStringObj("unknown-choice-child", -1);
+ case XML_SCHEMAP_UNKNOWN_COMPLEXCONTENT_CHILD:
+ return Tcl_NewStringObj("unknown-complexContent-child", -1);
+ case XML_SCHEMAP_UNKNOWN_COMPLEXTYPE_CHILD:
+ return Tcl_NewStringObj("unknown-complexType-child", -1);
+ case XML_SCHEMAP_UNKNOWN_ELEM_CHILD:
+ return Tcl_NewStringObj("unknown-element-child", -1);
+ case XML_SCHEMAP_UNKNOWN_EXTENSION_CHILD:
+ return Tcl_NewStringObj("unknown-extension-child", -1);
+ case XML_SCHEMAP_UNKNOWN_FACET_CHILD:
+ return Tcl_NewStringObj("unknown-facet-child", -1);
+ case XML_SCHEMAP_UNKNOWN_FACET_TYPE:
+ return Tcl_NewStringObj("unknown-facet-type", -1);
+ case XML_SCHEMAP_UNKNOWN_GROUP_CHILD:
+ return Tcl_NewStringObj("unknown-group-child", -1);
+ case XML_SCHEMAP_UNKNOWN_IMPORT_CHILD:
+ return Tcl_NewStringObj("unknown-import-child", -1);
+ case XML_SCHEMAP_UNKNOWN_LIST_CHILD:
+ return Tcl_NewStringObj("unknown-list-child", -1);
+ case XML_SCHEMAP_UNKNOWN_NOTATION_CHILD:
+ return Tcl_NewStringObj("unknown-notation-child", -1);
+ case XML_SCHEMAP_UNKNOWN_PROCESSCONTENT_CHILD:
+ return Tcl_NewStringObj("unknown-processContent-child", -1);
+ case XML_SCHEMAP_UNKNOWN_REF:
+ return Tcl_NewStringObj("unknown-ref", -1);
+ case XML_SCHEMAP_UNKNOWN_RESTRICTION_CHILD:
+ return Tcl_NewStringObj("unknown-restriction-child", -1);
+ case XML_SCHEMAP_UNKNOWN_SCHEMAS_CHILD:
+ return Tcl_NewStringObj("unknown-schemas-child", -1);
+ case XML_SCHEMAP_UNKNOWN_SEQUENCE_CHILD:
+ return Tcl_NewStringObj("unknown-sequence-child", -1);
+ case XML_SCHEMAP_UNKNOWN_SIMPLETYPE_CHILD:
+ return Tcl_NewStringObj("unknown-simpleType-child", -1);
+ case XML_SCHEMAP_UNKNOWN_TYPE:
+ return Tcl_NewStringObj("unknown-type", -1);
+ case XML_SCHEMAP_UNKNOWN_UNION_CHILD:
+ return Tcl_NewStringObj("unknown-union-child", -1);
+ case XML_SCHEMAP_ELEM_DEFAULT_FIXED:
+ return Tcl_NewStringObj("element-default-fixed", -1);
+ case XML_SCHEMAP_REGEXP_INVALID:
+ return Tcl_NewStringObj("regexp-invalid", -1);
+ case XML_SCHEMAP_FAILED_LOAD:
+ return Tcl_NewStringObj("failed-load", -1);
+ case XML_SCHEMAP_NOTHING_TO_PARSE:
+ return Tcl_NewStringObj("nothing-to-parse", -1);
+ case XML_SCHEMAP_NOROOT:
+ return Tcl_NewStringObj("no-root", -1);
+ case XML_SCHEMAP_REDEFINED_GROUP:
+ return Tcl_NewStringObj("redefined-group", -1);
+ case XML_SCHEMAP_REDEFINED_TYPE:
+ return Tcl_NewStringObj("redefined-type", -1);
+ case XML_SCHEMAP_REDEFINED_ELEMENT:
+ return Tcl_NewStringObj("redefined-element", -1);
+ case XML_SCHEMAP_REDEFINED_ATTRGROUP:
+ return Tcl_NewStringObj("redefined-attributeGroup", -1);
+ case XML_SCHEMAP_REDEFINED_ATTR:
+ return Tcl_NewStringObj("redefined-attribute", -1);
+ case XML_SCHEMAP_REDEFINED_NOTATION:
+ return Tcl_NewStringObj("redefined-notation", -1);
+ case XML_SCHEMAP_FAILED_PARSE:
+ return Tcl_NewStringObj("failed-parse", -1);
+ case XML_SCHEMAV_NOROOT:
+ return Tcl_NewStringObj("no-root", -1);
+ case XML_SCHEMAV_UNDECLAREDELEM:
+ return Tcl_NewStringObj("undeclared-element", -1);
+ case XML_SCHEMAV_NOTTOPLEVEL:
+ return Tcl_NewStringObj("not-toplevel", -1);
+ case XML_SCHEMAV_MISSING:
+ return Tcl_NewStringObj("missing", -1);
+ case XML_SCHEMAV_WRONGELEM:
+ return Tcl_NewStringObj("wrong-element", -1);
+ case XML_SCHEMAV_NOTYPE:
+ return Tcl_NewStringObj("no-type", -1);
+ case XML_SCHEMAV_NOROLLBACK:
+ return Tcl_NewStringObj("no-rollback", -1);
+ case XML_SCHEMAV_ISABSTRACT:
+ return Tcl_NewStringObj("is-abstract", -1);
+ case XML_SCHEMAV_NOTEMPTY:
+ return Tcl_NewStringObj("not-empty", -1);
+ case XML_SCHEMAV_ELEMCONT:
+ return Tcl_NewStringObj("element-content", -1);
+ case XML_SCHEMAV_HAVEDEFAULT:
+ return Tcl_NewStringObj("have-default", -1);
+ case XML_SCHEMAV_NOTNILLABLE:
+ return Tcl_NewStringObj("not-nillable", -1);
+ case XML_SCHEMAV_EXTRACONTENT:
+ return Tcl_NewStringObj("extra-content", -1);
+ case XML_SCHEMAV_INVALIDATTR:
+ return Tcl_NewStringObj("invalid-attribute", -1);
+ case XML_SCHEMAV_INVALIDELEM:
+ return Tcl_NewStringObj("invalid-element", -1);
+ case XML_SCHEMAV_NOTDETERMINIST:
+ return Tcl_NewStringObj("not-deterministic", -1);
+ case XML_SCHEMAV_CONSTRUCT:
+ return Tcl_NewStringObj("construct", -1);
+ case XML_SCHEMAV_INTERNAL:
+ return Tcl_NewStringObj("internal", -1);
+ case XML_SCHEMAV_NOTSIMPLE:
+ return Tcl_NewStringObj("not-simple", -1);
+ case XML_SCHEMAV_ATTRUNKNOWN:
+ return Tcl_NewStringObj("attribute-unknown", -1);
+ case XML_SCHEMAV_ATTRINVALID:
+ return Tcl_NewStringObj("attribute-invalid", -1);
+ case XML_SCHEMAV_VALUE:
+ return Tcl_NewStringObj("value", -1);
+ case XML_SCHEMAV_FACET:
+ return Tcl_NewStringObj("facet", -1);
+ case XML_XPTR_UNKNOWN_SCHEME:
+ return Tcl_NewStringObj("unknown-scheme", -1);
+ case XML_XPTR_CHILDSEQ_START:
+ return Tcl_NewStringObj("child-sequence-start", -1);
+ case XML_XPTR_EVAL_FAILED:
+ return Tcl_NewStringObj("eval-failed", -1);
+ case XML_XPTR_EXTRA_OBJECTS:
+ return Tcl_NewStringObj("extra-objects", -1);
+ case XML_C14N_CREATE_CTXT:
+ return Tcl_NewStringObj("create-context", -1);
+ case XML_C14N_REQUIRES_UTF8:
+ return Tcl_NewStringObj("requires-utf-8", -1);
+ case XML_C14N_CREATE_STACK:
+ return Tcl_NewStringObj("create-stack", -1);
+ case XML_C14N_INVALID_NODE:
+ return Tcl_NewStringObj("invalid-node", -1);
+ case XML_FTP_PASV_ANSWER:
+ return Tcl_NewStringObj("pasv-answer", -1);
+ case XML_FTP_EPSV_ANSWER:
+ return Tcl_NewStringObj("epsv-answer", -1);
+ case XML_FTP_ACCNT:
+ return Tcl_NewStringObj("account", -1);
+ case XML_HTTP_URL_SYNTAX:
+ return Tcl_NewStringObj("URL-syntax", -1);
+ case XML_HTTP_USE_IP:
+ return Tcl_NewStringObj("use-IP", -1);
+ case XML_HTTP_UNKNOWN_HOST:
+ return Tcl_NewStringObj("unknown-host", -1);
+ default:
+ return Tcl_NewIntObj(code);
+ }
+}
+
+void
+TclXML_libxml2_ErrorHandler (ctx, error)
+ void *ctx; /* ignore - depends on context */
+ xmlErrorPtr error;
+{
+ ThreadSpecificData *tsdPtr = Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
+ Tcl_Obj *objPtr;
+
+ if (tsdPtr->errorInfoPtr->listPtr == NULL) {
+ tsdPtr->errorInfoPtr->listPtr = Tcl_NewObj();
+ Tcl_IncrRefCount(tsdPtr->errorInfoPtr->listPtr);
+ }
+
+ objPtr = Tcl_NewListObj(0, NULL);
+
+ Tcl_ListObjAppendElement(tsdPtr->errorInfoPtr->interp, objPtr,
+ ErrorDomainToString(error->domain));
+ Tcl_ListObjAppendElement(tsdPtr->errorInfoPtr->interp, objPtr,
+ ErrorLevelToString(error->level));
+ Tcl_ListObjAppendElement(tsdPtr->errorInfoPtr->interp, objPtr,
+ ErrorCodeToString(error->code));
+
+ if (error->node == NULL) {
+ Tcl_ListObjAppendElement(tsdPtr->errorInfoPtr->interp, objPtr, Tcl_NewObj());
+ } else if (((xmlDocPtr) error->node)->type == XML_DOCUMENT_NODE) {
+ Tcl_ListObjAppendElement(tsdPtr->errorInfoPtr->interp, objPtr,
+ TclXML_libxml2_CreateObjFromDoc((xmlDocPtr) error->node));
+ } else if (tsdPtr->errorInfoPtr->nodeHandlerProc != NULL) {
+ Tcl_Obj *nodeObjPtr;
+
+ nodeObjPtr = (tsdPtr->errorInfoPtr->nodeHandlerProc)(tsdPtr->errorInfoPtr->interp, (ClientData) error->node);
+ if (nodeObjPtr != NULL) {
+ Tcl_ListObjAppendElement(tsdPtr->errorInfoPtr->interp, objPtr, nodeObjPtr);
+ } else {
+ Tcl_ListObjAppendElement(tsdPtr->errorInfoPtr->interp, objPtr, Tcl_NewObj());
+ }
+ } else {
+ Tcl_ListObjAppendElement(tsdPtr->errorInfoPtr->interp, objPtr, Tcl_NewObj());
+ }
+
+ Tcl_ListObjAppendElement(tsdPtr->errorInfoPtr->interp, objPtr,
+ Tcl_NewIntObj(error->line));
+ Tcl_ListObjAppendElement(tsdPtr->errorInfoPtr->interp, objPtr,
+ Tcl_NewStringObj(error->message, -1));
+
+ Tcl_ListObjAppendElement(tsdPtr->errorInfoPtr->interp, objPtr,
+ Tcl_NewIntObj(error->int1));
+ Tcl_ListObjAppendElement(tsdPtr->errorInfoPtr->interp, objPtr,
+ Tcl_NewIntObj(error->int2));
+ if (error->str1) {
+ Tcl_ListObjAppendElement(tsdPtr->errorInfoPtr->interp, objPtr,
+ Tcl_NewStringObj(error->str1, -1));
+ }
+ if (error->str2) {
+ Tcl_ListObjAppendElement(tsdPtr->errorInfoPtr->interp, objPtr,
+ Tcl_NewStringObj(error->str2, -1));
+ }
+ if (error->str3) {
+ Tcl_ListObjAppendElement(tsdPtr->errorInfoPtr->interp, objPtr,
+ Tcl_NewStringObj(error->str3, -1));
+ }
+
+ Tcl_ListObjAppendElement(tsdPtr->errorInfoPtr->interp, tsdPtr->errorInfoPtr->listPtr, objPtr);
+}
+
+void
+TclXML_libxml2_ResetError(interp)
+ Tcl_Interp *interp;
+{
+ ThreadSpecificData *tsdPtr = Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
+
+ if (tsdPtr->errorInfoPtr->listPtr != NULL) {
+ Tcl_DecrRefCount(tsdPtr->errorInfoPtr->listPtr);
+ tsdPtr->errorInfoPtr->listPtr = NULL;
+ }
+}
+
+Tcl_Obj *
+TclXML_libxml2_GetErrorObj(interp)
+ Tcl_Interp *interp;
+{
+ ThreadSpecificData *tsdPtr = Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
+
+ return tsdPtr->errorInfoPtr->listPtr;
+}
+
+void
+TclXML_libxml2_SetErrorNodeFunc(interp, proc)
+ Tcl_Interp *interp;
+ TclXML_ErrorNodeHandlerProc *proc;
+{
+ ThreadSpecificData *tsdPtr = Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
+
+ if (!tsdPtr->initialized) {
+ Tcl_SetObjResult(interp, Tcl_NewStringObj("internal error: docObj data not initialized", -1));
+ Tcl_BackgroundError(interp);
+ return;
+ }
+
+ tsdPtr->errorInfoPtr->nodeHandlerProc = proc;
+}
+