Update libxml to 2.7.7.

third_party/libxml/xmlschemas.c

 /*
  * schemas.c : implementation of the XML Schema handling and
  *             schema validity checking
  *
  * See Copyright for the status of this software.
  *
  * Daniel Veillard <veillard@redhat.com>
  */
 
 /*
@@ skipping 72 matching lines @@
 /* #define DEBUG_IDC */
 
 /* #define DEBUG_IDC_NODE_TABLE */
 
 /* #define WXS_ELEM_DECL_CONS_ENABLED */
 
 #ifdef DEBUG_IDC
  #ifndef DEBUG_IDC_NODE_TABLE
   #define DEBUG_IDC_NODE_TABLE
  #endif
-#endif   
+#endif
 
 /* #define ENABLE_PARTICLE_RESTRICTION 1 */
 
 #define ENABLE_REDEFINE
 
 /* #define ENABLE_NAMED_LOCALS */
 
 /* #define ENABLE_IDC_NODE_TABLES_TEST */
 
 #define DUMP_CONTENT_MODEL
@@ skipping 263 matching lines @@
 
 typedef struct _xmlSchemaBucket xmlSchemaBucket;
 typedef xmlSchemaBucket *xmlSchemaBucketPtr;
 
 #define XML_SCHEMA_SCHEMA_MAIN 0
 #define XML_SCHEMA_SCHEMA_IMPORT 1
 #define XML_SCHEMA_SCHEMA_INCLUDE 2
 #define XML_SCHEMA_SCHEMA_REDEFINE 3
 
 /**
- * xmlSchemaSchemaRelation: 
+ * xmlSchemaSchemaRelation:
  *
  * Used to create a graph of schema relationships.
  */
 typedef struct _xmlSchemaSchemaRelation xmlSchemaSchemaRelation;
 typedef xmlSchemaSchemaRelation *xmlSchemaSchemaRelationPtr;
 struct _xmlSchemaSchemaRelation {
     xmlSchemaSchemaRelationPtr next;
     int type; /* E.g. XML_SCHEMA_SCHEMA_IMPORT */
     const xmlChar *importNamespace;
     xmlSchemaBucketPtr bucket;
 };
 
 #define XML_SCHEMA_BUCKET_MARKED 1<<0
 #define XML_SCHEMA_BUCKET_COMPS_ADDED 1<<1
 
 struct _xmlSchemaBucket {
     int type;
     int flags;
     const xmlChar *schemaLocation;
     const xmlChar *origTargetNamespace;
     const xmlChar *targetNamespace;
     xmlDocPtr doc;
     xmlSchemaSchemaRelationPtr relations;
     int located;
     int parsed;
     int imported;
     int preserveDoc;
-    xmlSchemaItemListPtr globals; /* Global components. */ 
+    xmlSchemaItemListPtr globals; /* Global components. */
     xmlSchemaItemListPtr locals; /* Local components. */
 };
 
 /**
- * xmlSchemaImport: 
+ * xmlSchemaImport:
  * (extends xmlSchemaBucket)
  *
  * Reflects a schema. Holds some information
  * about the schema and its toplevel components. Duplicate
  * toplevel components are not checked at this level.
  */
 typedef struct _xmlSchemaImport xmlSchemaImport;
 typedef xmlSchemaImport *xmlSchemaImportPtr;
 struct _xmlSchemaImport {
     int type; /* Main OR import OR include. */
     int flags;
     const xmlChar *schemaLocation; /* The URI of the schema document. */
     /* For chameleon includes, @origTargetNamespace will be NULL */
     const xmlChar *origTargetNamespace;
-    /* 
+    /*
     * For chameleon includes, @targetNamespace will be the
-    * targetNamespace of the including schema. 
+    * targetNamespace of the including schema.
     */
     const xmlChar *targetNamespace;
     xmlDocPtr doc; /* The schema node-tree. */
     /* @relations will hold any included/imported/redefined schemas. */
     xmlSchemaSchemaRelationPtr relations;
     int located;
     int parsed;
     int imported;
     int preserveDoc;
     xmlSchemaItemListPtr globals;
@@ skipping 12 matching lines @@
     int flags;
     const xmlChar *schemaLocation;
     const xmlChar *origTargetNamespace;
     const xmlChar *targetNamespace;
     xmlDocPtr doc;
     xmlSchemaSchemaRelationPtr relations;
     int located;
     int parsed;
     int imported;
     int preserveDoc;
-    xmlSchemaItemListPtr globals; /* Global components. */ 
+    xmlSchemaItemListPtr globals; /* Global components. */
     xmlSchemaItemListPtr locals; /* Local components. */
 
     /* The owning main or import schema bucket. */
     xmlSchemaImportPtr ownerImport;
 };
 
 /**
  * xmlSchemaBasicItem:
  *
  * The abstract base type for schema components.
@@ skipping 39 matching lines @@
  *
  * The abstract base type for tree-like structured schema components.
  * (Extends xmlSchemaTreeItem)
  */
 typedef struct _xmlSchemaAttributeUse xmlSchemaAttributeUse;
 typedef xmlSchemaAttributeUse *xmlSchemaAttributeUsePtr;
 struct _xmlSchemaAttributeUse {
     xmlSchemaTypeType type;
     xmlSchemaAnnotPtr annot;
     xmlSchemaAttributeUsePtr next; /* The next attr. use. */
-    /* 
+    /*
     * The attr. decl. OR a QName-ref. to an attr. decl. OR
     * a QName-ref. to an attribute group definition.
     */
     xmlSchemaAttributePtr attrDecl;
 
     int flags;
     xmlNodePtr node;
     int occurs; /* required, optional */
     const xmlChar * defValue;
     xmlSchemaValPtr defVal;
@@ skipping 35 matching lines @@
  * xmlSchemaConstructionCtxt:
  */
 typedef struct _xmlSchemaConstructionCtxt xmlSchemaConstructionCtxt;
 typedef xmlSchemaConstructionCtxt *xmlSchemaConstructionCtxtPtr;
 struct _xmlSchemaConstructionCtxt {
     xmlSchemaPtr mainSchema; /* The main schema. */
     xmlSchemaBucketPtr mainBucket; /* The main schema bucket */
     xmlDictPtr dict;
     xmlSchemaItemListPtr buckets; /* List of schema buckets. */
     /* xmlSchemaItemListPtr relations; */ /* List of schema relations. */
-    xmlSchemaBucketPtr bucket; /* The current schema bucket */    
+    xmlSchemaBucketPtr bucket; /* The current schema bucket */
     xmlSchemaItemListPtr pending; /* All Components of all schemas that
                                      need to be fixed. */
     xmlHashTablePtr substGroups;
     xmlSchemaRedefPtr redefs;
     xmlSchemaRedefPtr lastRedef;
 };
 
 #define XML_SCHEMAS_PARSE_ERROR         1
 #define SCHEMAS_PARSE_OPTIONS XML_PARSE_NOENT
 
@@ skipping 35 matching lines @@
     int options;
     xmlSchemaValidCtxtPtr vctxt;
     int isS4S;
     int isRedefine;
     int xsiAssemble;
     int stop; /* If the parser should stop; i.e. a critical error. */
     const xmlChar *targetNamespace;
     xmlSchemaBucketPtr redefined; /* The schema to be redefined. */
 
     xmlSchemaRedefPtr redef; /* Used for redefinitions. */
-    int redefCounter; /* Used for redefinitions. */ 
+    int redefCounter; /* Used for redefinitions. */
     xmlSchemaItemListPtr attrProhibs;
 };
 
 /**
  * xmlSchemaQNameRef:
  *
  * A component reference item (not a schema component)
  * (Extends xmlSchemaBasicItem)
  */
 typedef struct _xmlSchemaQNameRef xmlSchemaQNameRef;
@@ skipping 133 matching lines @@
  * xmlSchemaPSVIIDCNode:
  *
  * The node table item of a node table.
  */
 typedef struct _xmlSchemaPSVIIDCNode xmlSchemaPSVIIDCNode;
 typedef xmlSchemaPSVIIDCNode *xmlSchemaPSVIIDCNodePtr;
 struct _xmlSchemaPSVIIDCNode {
     xmlNodePtr node;
     xmlSchemaPSVIIDCKeyPtr *keys;
     int nodeLine;
-    int nodeQNameID;    
+    int nodeQNameID;
 
 };
 
 /**
  * xmlSchemaPSVIIDCBinding:
  *
  * The identity-constraint binding item of the [identity-constraint table].
  */
 typedef struct _xmlSchemaPSVIIDCBinding xmlSchemaPSVIIDCBinding;
 typedef xmlSchemaPSVIIDCBinding *xmlSchemaPSVIIDCBindingPtr;
@@ skipping 75 matching lines @@
 #define XML_SCHEMA_NODE_INFO_ERR_BAD_TYPE  1<<10
 
 /**
  * xmlSchemaNodeInfo:
  *
  * Holds information of an element node.
  */
 struct _xmlSchemaNodeInfo {
     int nodeType;
     xmlNodePtr node;
-    int nodeLine;    
+    int nodeLine;
     const xmlChar *localName;
     const xmlChar *nsName;
     const xmlChar *value;
     xmlSchemaValPtr val; /* the pre-computed value if any */
     xmlSchemaTypePtr typeDef; /* the complex/simple type definition if any */
 
     int flags; /* combination of node info flags */
 
     int valNeeded;
     int normVal;
 
     xmlSchemaElementPtr decl; /* the element/attribute declaration */
     int depth;
     xmlSchemaPSVIIDCBindingPtr idcTable; /* the table of PSVI IDC bindings
                                             for the scope element*/
     xmlSchemaIDCMatcherPtr idcMatchers; /* the IDC matchers for the scope
                                            element */
     xmlRegExecCtxtPtr regexCtxt;
 
     const xmlChar **nsBindings; /* Namespace bindings on this element */
     int nbNsBindings;
-    int sizeNsBindings;    
+    int sizeNsBindings;
 
     int hasKeyrefs;
     int appliedXPath; /* Indicates that an XPath has been applied. */
 };
 
 #define XML_SCHEMAS_ATTR_UNKNOWN 1
 #define XML_SCHEMAS_ATTR_ASSESSED 2
 #define XML_SCHEMAS_ATTR_PROHIBITED 3
 #define XML_SCHEMAS_ATTR_ERR_MISSING 4
 #define XML_SCHEMAS_ATTR_INVALID_VALUE 5
@@ skipping 16 matching lines @@
 #define XML_SCHEMA_ATTR_INFO_META_XSI_NIL 2
 #define XML_SCHEMA_ATTR_INFO_META_XSI_SCHEMA_LOC 3
 #define XML_SCHEMA_ATTR_INFO_META_XSI_NO_NS_SCHEMA_LOC 4
 #define XML_SCHEMA_ATTR_INFO_META_XMLNS 5
 
 typedef struct _xmlSchemaAttrInfo xmlSchemaAttrInfo;
 typedef xmlSchemaAttrInfo *xmlSchemaAttrInfoPtr;
 struct _xmlSchemaAttrInfo {
     int nodeType;
     xmlNodePtr node;
-    int nodeLine;    
+    int nodeLine;
     const xmlChar *localName;
     const xmlChar *nsName;
     const xmlChar *value;
     xmlSchemaValPtr val; /* the pre-computed value if any */
     xmlSchemaTypePtr typeDef; /* the complex/simple type definition if any */
     int flags; /* combination of node info flags */
 
     xmlSchemaAttributePtr decl; /* the attribute declaration */
     xmlSchemaAttributeUsePtr use;  /* the attribute use */
     int state;
@@ skipping 213 matching lines @@
  * Returns the component name of a schema item.
  */
 static const xmlChar *
 xmlSchemaGetComponentTypeStr(xmlSchemaBasicItemPtr item)
 {
     switch (item->type) {
         case XML_SCHEMA_TYPE_BASIC:
             if (WXS_IS_COMPLEX(WXS_TYPE_CAST item))
                 return(BAD_CAST "complex type definition");
             else
-                return(BAD_CAST "simple type definition");      
+                return(BAD_CAST "simple type definition");
         default:
             return(xmlSchemaItemTypeToStr(item->type));
     }
 }
 
 /**
  * xmlSchemaGetComponentNode:
  * @item: a schema component
  *
  * Returns node associated with the schema component.
@@ skipping 107 matching lines @@
         *buf = xmlStrdup(BAD_CAST "{");
         *buf = xmlStrcat(*buf, namespaceName);
         *buf = xmlStrcat(*buf, BAD_CAST "}");
     }
     if (localName != NULL) {
         if (namespaceName == NULL)
             return(localName);
         *buf = xmlStrcat(*buf, localName);
     } else {
         *buf = xmlStrcat(*buf, BAD_CAST "(NULL)");
-    }    
+    }
     return ((const xmlChar *) *buf);
 }
 
-static const xmlChar*   
+static const xmlChar*
 xmlSchemaFormatQNameNs(xmlChar **buf, xmlNsPtr ns, const xmlChar *localName)
 {
     if (ns != NULL)
         return (xmlSchemaFormatQName(buf, ns->href, localName));
     else
         return (xmlSchemaFormatQName(buf, NULL, localName));
 }
 
 static const xmlChar *
 xmlSchemaGetComponentName(xmlSchemaBasicItemPtr item)
@@ skipping 155 matching lines @@
  *         API errors or if the value type is not supported yet.
  */
 static int
 xmlSchemaGetCanonValueWhtspExt(xmlSchemaValPtr val,
                                xmlSchemaWhitespaceValueType ws,
                                xmlChar **retValue)
 {
     int list;
     xmlSchemaValType valType;
     const xmlChar *value, *value2 = NULL;
-    
+
 
     if ((retValue == NULL) || (val == NULL))
         return (-1);
     list = xmlSchemaValueGetNext(val) ? 1 : 0;
     *retValue = NULL;
     do {
-        value = NULL;   
-        valType = xmlSchemaGetValType(val);    
-        switch (valType) {          
+        value = NULL;
+        valType = xmlSchemaGetValType(val);
+        switch (valType) {
             case XML_SCHEMAS_STRING:
             case XML_SCHEMAS_NORMSTRING:
             case XML_SCHEMAS_ANYSIMPLETYPE:
                 value = xmlSchemaValueGetAsString(val);
                 if (value != NULL) {
                     if (ws == XML_SCHEMA_WHITESPACE_COLLAPSE)
                         value2 = xmlSchemaCollapseString(value);
                     else if (ws == XML_SCHEMA_WHITESPACE_REPLACE)
                         value2 = xmlSchemaWhiteSpaceReplace(value);
                     if (value2 != NULL)
                         value = value2;
                 }
-                break;     
+                break;
             default:
                 if (xmlSchemaGetCanonValue(val, &value2) == -1) {
                     if (value2 != NULL)
                         xmlFree((xmlChar *) value2);
                     goto internal_error;
                 }
                 value = value2;
         }
         if (*retValue == NULL)
             if (value == NULL) {
@@ skipping 17 matching lines @@
     if (value2 != NULL)
         xmlFree((xmlChar *) value2);
     return (-1);
 }
 
 /**
  * xmlSchemaFormatItemForReport:
  * @buf: the string buffer
  * @itemDes: the designation of the item
  * @itemName: the name of the item
- * @item: the item as an object 
+ * @item: the item as an object
  * @itemNode: the node of the item
  * @local: the local name
  * @parsing: if the function is used during the parse
  *
  * Returns a representation of the given item used
- * for error reports. 
+ * for error reports.
  *
- * The following order is used to build the resulting 
+ * The following order is used to build the resulting
  * designation if the arguments are not NULL:
  * 1a. If itemDes not NULL -> itemDes
  * 1b. If (itemDes not NULL) and (itemName not NULL)
  *     -> itemDes + itemName
  * 2. If the preceding was NULL and (item not NULL) -> item
  * 3. If the preceding was NULL and (itemNode not NULL) -> itemNode
- * 
+ *
  * If the itemNode is an attribute node, the name of the attribute
  * will be appended to the result.
  *
  * Returns the formatted string and sets @buf to the resulting value.
- */  
-static xmlChar*   
-xmlSchemaFormatItemForReport(xmlChar **buf,                  
+ */
+static xmlChar*
+xmlSchemaFormatItemForReport(xmlChar **buf,
                      const xmlChar *itemDes,
                      xmlSchemaBasicItemPtr item,
                      xmlNodePtr itemNode)
 {
     xmlChar *str = NULL;
     int named = 1;
 
     if (*buf != NULL) {
         xmlFree(*buf);
         *buf = NULL;
     }
-            
+
     if (itemDes != NULL) {
-        *buf = xmlStrdup(itemDes);      
+        *buf = xmlStrdup(itemDes);
     } else if (item != NULL) {
         switch (item->type) {
         case XML_SCHEMA_TYPE_BASIC: {
             xmlSchemaTypePtr type = WXS_TYPE_CAST item;
 
             if (WXS_IS_ATOMIC(type))
                 *buf = xmlStrdup(BAD_CAST "atomic type 'xs:");
             else if (WXS_IS_LIST(type))
                 *buf = xmlStrdup(BAD_CAST "list type 'xs:");
             else if (WXS_IS_UNION(type))
@@ skipping 37 matching lines @@
             *buf = xmlStrcat(*buf, BAD_CAST "complex type");
             if (type->flags & XML_SCHEMAS_TYPE_GLOBAL) {
                 *buf = xmlStrcat(*buf, BAD_CAST " '");
                 *buf = xmlStrcat(*buf, type->name);
                 *buf = xmlStrcat(*buf, BAD_CAST "'");
             }
             }
             break;
         case XML_SCHEMA_TYPE_ATTRIBUTE_USE: {
                 xmlSchemaAttributeUsePtr ause;
-            
+
                 ause = WXS_ATTR_USE_CAST item;
                 *buf = xmlStrdup(BAD_CAST "attribute use ");
                 if (WXS_ATTRUSE_DECL(ause) != NULL) {
                     *buf = xmlStrcat(*buf, BAD_CAST "'");
                     *buf = xmlStrcat(*buf,
                         xmlSchemaGetComponentQName(&str, WXS_ATTRUSE_DECL(ause)));
                     FREE_AND_NULL(str)
                         *buf = xmlStrcat(*buf, BAD_CAST "'");
                 } else {
                     *buf = xmlStrcat(*buf, BAD_CAST "(unknown)");
                 }
             }
             break;
         case XML_SCHEMA_TYPE_ATTRIBUTE: {
                 xmlSchemaAttributePtr attr;
-            
+
                 attr = (xmlSchemaAttributePtr) item;
                 *buf = xmlStrdup(BAD_CAST "attribute decl.");
                 *buf = xmlStrcat(*buf, BAD_CAST " '");
                 *buf = xmlStrcat(*buf, xmlSchemaFormatQName(&str,
                     attr->targetNamespace, attr->name));
                 FREE_AND_NULL(str)
                     *buf = xmlStrcat(*buf, BAD_CAST "'");
             }
             break;
         case XML_SCHEMA_TYPE_ATTRIBUTEGROUP:
             xmlSchemaGetComponentDesignation(buf, item);
             break;
         case XML_SCHEMA_TYPE_ELEMENT: {
                 xmlSchemaElementPtr elem;
 
-                elem = (xmlSchemaElementPtr) item;          
+                elem = (xmlSchemaElementPtr) item;
                 *buf = xmlStrdup(BAD_CAST "element decl.");
                 *buf = xmlStrcat(*buf, BAD_CAST " '");
                 *buf = xmlStrcat(*buf, xmlSchemaFormatQName(&str,
                     elem->targetNamespace, elem->name));
                 *buf = xmlStrcat(*buf, BAD_CAST "'");
             }
             break;
         case XML_SCHEMA_TYPE_IDC_UNIQUE:
         case XML_SCHEMA_TYPE_IDC_KEY:
-        case XML_SCHEMA_TYPE_IDC_KEYREF:                
+        case XML_SCHEMA_TYPE_IDC_KEYREF:
             if (item->type == XML_SCHEMA_TYPE_IDC_UNIQUE)
                 *buf = xmlStrdup(BAD_CAST "unique '");
             else if (item->type == XML_SCHEMA_TYPE_IDC_KEY)
                 *buf = xmlStrdup(BAD_CAST "key '");
             else
                 *buf = xmlStrdup(BAD_CAST "keyRef '");
             *buf = xmlStrcat(*buf, ((xmlSchemaIDCPtr) item)->name);
             *buf = xmlStrcat(*buf, BAD_CAST "'");
             break;
         case XML_SCHEMA_TYPE_ANY:
@@ skipping 35 matching lines @@
         case XML_SCHEMA_TYPE_NOTATION: {
                 *buf = xmlStrdup(WXS_ITEM_TYPE_NAME(item));
                 *buf = xmlStrcat(*buf, BAD_CAST " '");
                 *buf = xmlStrcat(*buf, xmlSchemaGetComponentQName(&str, item));
                 *buf = xmlStrcat(*buf, BAD_CAST "'");
                 FREE_AND_NULL(str);
             }
         default:
             named = 0;
         }
-    } else 
+    } else
         named = 0;
 
     if ((named == 0) && (itemNode != NULL)) {
         xmlNodePtr elem;
 
         if (itemNode->type == XML_ATTRIBUTE_NODE)
             elem = itemNode->parent;
-        else 
+        else
             elem = itemNode;
         *buf = xmlStrdup(BAD_CAST "Element '");
         if (elem->ns != NULL) {
             *buf = xmlStrcat(*buf,
                 xmlSchemaFormatQName(&str, elem->ns->href, elem->name));
             FREE_AND_NULL(str)
         } else
             *buf = xmlStrcat(*buf, elem->name);
         *buf = xmlStrcat(*buf, BAD_CAST "'");
-        
+
     }
     if ((itemNode != NULL) && (itemNode->type == XML_ATTRIBUTE_NODE)) {
         *buf = xmlStrcat(*buf, BAD_CAST ", attribute '");
         if (itemNode->ns != NULL) {
             *buf = xmlStrcat(*buf, xmlSchemaFormatQName(&str,
                 itemNode->ns->href, itemNode->name));
             FREE_AND_NULL(str)
         } else
             *buf = xmlStrcat(*buf, itemNode->name);
         *buf = xmlStrcat(*buf, BAD_CAST "'");
     }
     FREE_AND_NULL(str)
-    
+
     return (*buf);
 }
 
 /**
  * xmlSchemaFormatFacetEnumSet:
  * @buf: the string buffer
  * @type: the type holding the enumeration facets
  *
  * Builds a string consisting of all enumeration elements.
  *
  * Returns a string of all enumeration elements.
  */
 static const xmlChar *
 xmlSchemaFormatFacetEnumSet(xmlSchemaAbstractCtxtPtr actxt,
                             xmlChar **buf, xmlSchemaTypePtr type)
 {
     xmlSchemaFacetPtr facet;
     xmlSchemaWhitespaceValueType ws;
     xmlChar *value = NULL;
     int res, found = 0;
 
     if (*buf != NULL)
-        xmlFree(*buf);    
+        xmlFree(*buf);
     *buf = NULL;
 
     do {
         /*
         * Use the whitespace type of the base type.
-        */      
+        */
         ws = xmlSchemaGetWhiteSpaceFacetValue(type->baseType);
         for (facet = type->facets; facet != NULL; facet = facet->next) {
             if (facet->type != XML_SCHEMA_FACET_ENUMERATION)
                 continue;
             found = 1;
             res = xmlSchemaGetCanonValueWhtspExt(facet->val,
                 ws, &value);
             if (res == -1) {
                 xmlSchemaInternalErr(actxt,
                     "xmlSchemaFormatFacetEnumSet",
@@ skipping 68 matching lines @@
 }
 
 /**
  * xmlSchemaPErr:
  * @ctxt: the parsing context
  * @node: the context node
  * @error: the error code
  * @msg: the error message
  * @str1: extra data
  * @str2: extra data
- * 
+ *
  * Handle a parser error
  */
 static void
 xmlSchemaPErr(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node, int error,
               const char *msg, const xmlChar * str1, const xmlChar * str2)
 {
     xmlGenericErrorFunc channel = NULL;
     xmlStructuredErrorFunc schannel = NULL;
     void *data = NULL;
 
@@ skipping 12 matching lines @@
 
 /**
  * xmlSchemaPErr2:
  * @ctxt: the parsing context
  * @node: the context node
  * @node: the current child
  * @error: the error code
  * @msg: the error message
  * @str1: extra data
  * @str2: extra data
- * 
+ *
  * Handle a parser error
  */
 static void
 xmlSchemaPErr2(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node,
                xmlNodePtr child, int error,
                const char *msg, const xmlChar * str1, const xmlChar * str2)
 {
     if (child != NULL)
         xmlSchemaPErr(ctxt, child, error, msg, str1, str2);
     else
         xmlSchemaPErr(ctxt, node, error, msg, str1, str2);
 }
 
 
 /**
  * xmlSchemaPErrExt:
  * @ctxt: the parsing context
  * @node: the context node
- * @error: the error code 
+ * @error: the error code
  * @strData1: extra data
  * @strData2: extra data
  * @strData3: extra data
  * @msg: the message
  * @str1:  extra parameter for the message display
  * @str2:  extra parameter for the message display
  * @str3:  extra parameter for the message display
  * @str4:  extra parameter for the message display
  * @str5:  extra parameter for the message display
- * 
+ *
  * Handle a parser error
  */
 static void
 xmlSchemaPErrExt(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node, int error,
-                const xmlChar * strData1, const xmlChar * strData2, 
-                const xmlChar * strData3, const char *msg, const xmlChar * str1, 
+                const xmlChar * strData1, const xmlChar * strData2,
+                const xmlChar * strData3, const char *msg, const xmlChar * str1,
                 const xmlChar * str2, const xmlChar * str3, const xmlChar * str4,
                 const xmlChar * str5)
 {
 
     xmlGenericErrorFunc channel = NULL;
     xmlStructuredErrorFunc schannel = NULL;
     void *data = NULL;
 
     if (ctxt != NULL) {
         ctxt->nberrors++;
         ctxt->err = error;
         channel = ctxt->error;
         data = ctxt->errCtxt;
         schannel = ctxt->serror;
     }
     __xmlRaiseError(schannel, channel, data, ctxt, node, XML_FROM_SCHEMASP,
                     error, XML_ERR_ERROR, NULL, 0,
-                    (const char *) strData1, (const char *) strData2, 
-                    (const char *) strData3, 0, 0, msg, str1, str2, 
+                    (const char *) strData1, (const char *) strData2,
+                    (const char *) strData3, 0, 0, msg, str1, str2,
                     str3, str4, str5);
 }
 
 /************************************************************************
  *                                                                      *
  *                      Allround error functions                        *
  *                                                                      *
  ************************************************************************/
 
 /**
@@ skipping 27 matching lines @@
 #define WXS_ERROR_TYPE_WARNING 2
 /**
  * xmlSchemaErr3:
  * @ctxt: the validation context
  * @node: the context node
  * @error: the error code
  * @msg: the error message
  * @str1: extra data
  * @str2: extra data
  * @str3: extra data
- * 
+ *
  * Handle a validation error
  */
 static void
 xmlSchemaErr4Line(xmlSchemaAbstractCtxtPtr ctxt,
                   xmlErrorLevel errorLevel,
                   int error, xmlNodePtr node, int line, const char *msg,
                   const xmlChar *str1, const xmlChar *str2,
                   const xmlChar *str3, const xmlChar *str4)
 {
     xmlStructuredErrorFunc schannel = NULL;
     xmlGenericErrorFunc channel = NULL;
-    void *data = NULL;    
-    
+    void *data = NULL;
+
     if (ctxt != NULL) {
         if (ctxt->type == XML_SCHEMA_CTXT_VALIDATOR) {
             xmlSchemaValidCtxtPtr vctxt = (xmlSchemaValidCtxtPtr) ctxt;
             const char *file = NULL;
             if (errorLevel != XML_ERR_WARNING) {
                 vctxt->nberrors++;
                 vctxt->err = error;
-                channel = vctxt->error;         
+                channel = vctxt->error;
             } else {
                 channel = vctxt->warning;
             }
             schannel = vctxt->serror;
             data = vctxt->errCtxt;
 
             /*
             * Error node. If we specify a line number, then
             * do not channel any node to the error function.
             */
@@ skipping 19 matching lines @@
                 */
                 node = NULL;
                 /*
                 * Get filename.
                 */
                 if (vctxt->doc != NULL)
                     file = (const char *) vctxt->doc->URL;
                 else if ((vctxt->parserCtxt != NULL) &&
                     (vctxt->parserCtxt->input != NULL))
                     file = vctxt->parserCtxt->input->filename;
-            }          
+            }
             __xmlRaiseError(schannel, channel, data, ctxt,
                 node, XML_FROM_SCHEMASV,
                 error, errorLevel, file, line,
                 (const char *) str1, (const char *) str2,
                 (const char *) str3, 0, 0, msg, str1, str2, str3, str4);
 
         } else if (ctxt->type == XML_SCHEMA_CTXT_PARSER) {
             xmlSchemaParserCtxtPtr pctxt = (xmlSchemaParserCtxtPtr) ctxt;
             if (errorLevel != XML_ERR_WARNING) {
                 pctxt->nberrors++;
                 pctxt->err = error;
-                channel = pctxt->error;         
+                channel = pctxt->error;
             } else {
                 channel = pctxt->warning;
             }
             schannel = pctxt->serror;
             data = pctxt->errCtxt;
             __xmlRaiseError(schannel, channel, data, ctxt,
                 node, XML_FROM_SCHEMASP, error,
                 errorLevel, NULL, 0,
                 (const char *) str1, (const char *) str2,
                 (const char *) str3, 0, 0, msg, str1, str2, str3, str4);
         } else {
             TODO
         }
     }
 }
 
 /**
  * xmlSchemaErr3:
  * @ctxt: the validation context
  * @node: the context node
  * @error: the error code
  * @msg: the error message
  * @str1: extra data
  * @str2: extra data
  * @str3: extra data
- * 
+ *
  * Handle a validation error
  */
 static void
-xmlSchemaErr3(xmlSchemaAbstractCtxtPtr actxt,  
+xmlSchemaErr3(xmlSchemaAbstractCtxtPtr actxt,
               int error, xmlNodePtr node, const char *msg,
               const xmlChar *str1, const xmlChar *str2, const xmlChar *str3)
 {
     xmlSchemaErr4Line(actxt, XML_ERR_ERROR, error, node, 0,
         msg, str1, str2, str3, NULL);
 }
 
 static void
-xmlSchemaErr4(xmlSchemaAbstractCtxtPtr actxt,  
+xmlSchemaErr4(xmlSchemaAbstractCtxtPtr actxt,
               int error, xmlNodePtr node, const char *msg,
               const xmlChar *str1, const xmlChar *str2,
               const xmlChar *str3, const xmlChar *str4)
 {
     xmlSchemaErr4Line(actxt, XML_ERR_ERROR, error, node, 0,
         msg, str1, str2, str3, str4);
 }
 
 static void
 xmlSchemaErr(xmlSchemaAbstractCtxtPtr actxt,
              int error, xmlNodePtr node, const char *msg,
              const xmlChar *str1, const xmlChar *str2)
 {
     xmlSchemaErr4(actxt, error, node, msg, str1, str2, NULL, NULL);
 }
 
 static xmlChar *
 xmlSchemaFormatNodeForError(xmlChar ** msg,
                             xmlSchemaAbstractCtxtPtr actxt,
                             xmlNodePtr node)
 {
     xmlChar *str = NULL;
 
     *msg = NULL;
     if ((node != NULL) &&
         (node->type != XML_ELEMENT_NODE) &&
         (node->type != XML_ATTRIBUTE_NODE))
     {
-        /* 
+        /*
         * Don't try to format other nodes than element and
         * attribute nodes.
         * Play save and return an empty string.
         */
         *msg = xmlStrdup(BAD_CAST "");
         return(*msg);
     }
     if (node != NULL) {
         /*
         * Work on tree nodes.
         */
         if (node->type == XML_ATTRIBUTE_NODE) {
             xmlNodePtr elem = node->parent;
-            
+
             *msg = xmlStrdup(BAD_CAST "Element '");
             if (elem->ns != NULL)
                 *msg = xmlStrcat(*msg, xmlSchemaFormatQName(&str,
                     elem->ns->href, elem->name));
             else
                 *msg = xmlStrcat(*msg, xmlSchemaFormatQName(&str,
                     NULL, elem->name));
             FREE_AND_NULL(str);
             *msg = xmlStrcat(*msg, BAD_CAST "', ");
-            *msg = xmlStrcat(*msg, BAD_CAST "attribute '");         
+            *msg = xmlStrcat(*msg, BAD_CAST "attribute '");
         } else {
             *msg = xmlStrdup(BAD_CAST "Element '");
         }
         if (node->ns != NULL)
             *msg = xmlStrcat(*msg, xmlSchemaFormatQName(&str,
             node->ns->href, node->name));
         else
             *msg = xmlStrcat(*msg, xmlSchemaFormatQName(&str,
             NULL, node->name));
         FREE_AND_NULL(str);
         *msg = xmlStrcat(*msg, BAD_CAST "': ");
     } else if (actxt->type == XML_SCHEMA_CTXT_VALIDATOR) {
         xmlSchemaValidCtxtPtr vctxt = (xmlSchemaValidCtxtPtr) actxt;
         /*
         * Work on node infos.
-        */      
+        */
         if (vctxt->inode->nodeType == XML_ATTRIBUTE_NODE) {
             xmlSchemaNodeInfoPtr ielem =
                 vctxt->elemInfos[vctxt->depth];
 
             *msg = xmlStrdup(BAD_CAST "Element '");
             *msg = xmlStrcat(*msg, xmlSchemaFormatQName(&str,
                 ielem->nsName, ielem->localName));
             FREE_AND_NULL(str);
             *msg = xmlStrcat(*msg, BAD_CAST "', ");
-            *msg = xmlStrcat(*msg, BAD_CAST "attribute '");         
+            *msg = xmlStrcat(*msg, BAD_CAST "attribute '");
         } else {
             *msg = xmlStrdup(BAD_CAST "Element '");
         }
         *msg = xmlStrcat(*msg, xmlSchemaFormatQName(&str,
             vctxt->inode->nsName, vctxt->inode->localName));
         FREE_AND_NULL(str);
         *msg = xmlStrcat(*msg, BAD_CAST "': ");
     } else if (actxt->type == XML_SCHEMA_CTXT_PARSER) {
-        /* 
+        /*
         * Hmm, no node while parsing?
         * Return an empty string, in case NULL will break something.
         */
         *msg = xmlStrdup(BAD_CAST "");
     } else {
         TODO
         return (NULL);
     }
     /*
     * VAL TODO: The output of the given schema component is currently
@@ skipping 17 matching lines @@
                      const char *message,
                      const xmlChar *str1,
                      const xmlChar *str2)
 {
     xmlChar *msg = NULL;
 
     if (actxt == NULL)
         return;
     msg = xmlStrdup(BAD_CAST "Internal error: ");
     msg = xmlStrcat(msg, BAD_CAST funcName);
-    msg = xmlStrcat(msg, BAD_CAST ", ");    
+    msg = xmlStrcat(msg, BAD_CAST ", ");
     msg = xmlStrcat(msg, BAD_CAST message);
     msg = xmlStrcat(msg, BAD_CAST ".\n");
 
     if (actxt->type == XML_SCHEMA_CTXT_VALIDATOR)
         xmlSchemaErr(actxt, XML_SCHEMAV_INTERNAL, NULL,
             (const char *) msg, str1, str2);
 
-    else if (actxt->type == XML_SCHEMA_CTXT_PARSER)     
+    else if (actxt->type == XML_SCHEMA_CTXT_PARSER)
         xmlSchemaErr(actxt, XML_SCHEMAP_INTERNAL, NULL,
             (const char *) msg, str1, str2);
 
     FREE_AND_NULL(msg)
 }
 
 static void
 xmlSchemaInternalErr(xmlSchemaAbstractCtxtPtr actxt,
                      const char *funcName,
                      const char *message)
@@ skipping 26 matching lines @@
     xmlChar *msg = NULL;
 
     if ((node == NULL) && (item != NULL) &&
         (actxt->type == XML_SCHEMA_CTXT_PARSER)) {
         node = WXS_ITEM_NODE(item);
         xmlSchemaFormatItemForReport(&msg, NULL, item, NULL);
         msg = xmlStrcat(msg, BAD_CAST ": ");
     } else
         xmlSchemaFormatNodeForError(&msg, actxt, node);
     msg = xmlStrcat(msg, (const xmlChar *) message);
-    msg = xmlStrcat(msg, BAD_CAST ".\n");   
+    msg = xmlStrcat(msg, BAD_CAST ".\n");
     xmlSchemaErr4(actxt, error, node,
         (const char *) msg, str1, str2, str3, str4);
     FREE_AND_NULL(msg)
 }
 
 static void
 xmlSchemaCustomErr(xmlSchemaAbstractCtxtPtr actxt,
                    xmlParserErrors error,
                    xmlNodePtr node,
                    xmlSchemaBasicItemPtr item,
                    const char *message,
                    const xmlChar *str1,
                    const xmlChar *str2)
 {
     xmlSchemaCustomErr4(actxt, error, node, item,
-        message, str1, str2, NULL, NULL);    
+        message, str1, str2, NULL, NULL);
 }
 
 
 
 static void
 xmlSchemaCustomWarning(xmlSchemaAbstractCtxtPtr actxt,
                    xmlParserErrors error,
                    xmlNodePtr node,
                    xmlSchemaTypePtr type ATTRIBUTE_UNUSED,
                    const char *message,
                    const xmlChar *str1,
                    const xmlChar *str2,
                    const xmlChar *str3)
 {
     xmlChar *msg = NULL;
 
     xmlSchemaFormatNodeForError(&msg, actxt, node);
     msg = xmlStrcat(msg, (const xmlChar *) message);
-    msg = xmlStrcat(msg, BAD_CAST ".\n"); 
-    
+    msg = xmlStrcat(msg, BAD_CAST ".\n");
+
     /* URGENT TODO: Set the error code to something sane. */
     xmlSchemaErr4Line(actxt, XML_ERR_WARNING, error, node, 0,
         (const char *) msg, str1, str2, str3, NULL);
 
     FREE_AND_NULL(msg)
 }
 
 
 
 static void
 xmlSchemaKeyrefErr(xmlSchemaValidCtxtPtr vctxt,
                    xmlParserErrors error,
                    xmlSchemaPSVIIDCNodePtr idcNode,
                    xmlSchemaTypePtr type ATTRIBUTE_UNUSED,
                    const char *message,
                    const xmlChar *str1,
                    const xmlChar *str2)
 {
     xmlChar *msg = NULL, *qname = NULL;
-    
-    msg = xmlStrdup(BAD_CAST "Element '%s': ");        
+
+    msg = xmlStrdup(BAD_CAST "Element '%s': ");
     msg = xmlStrcat(msg, (const xmlChar *) message);
     msg = xmlStrcat(msg, BAD_CAST ".\n");
     xmlSchemaErr4Line(ACTXT_CAST vctxt, XML_ERR_ERROR,
         error, NULL, idcNode->nodeLine, (const char *) msg,
         xmlSchemaFormatQName(&qname,
             vctxt->nodeQNames->items[idcNode->nodeQNameID +1],
-            vctxt->nodeQNames->items[idcNode->nodeQNameID]), 
+            vctxt->nodeQNames->items[idcNode->nodeQNameID]),
         str1, str2, NULL);
     FREE_AND_NULL(qname);
     FREE_AND_NULL(msg);
 }
 
 static int
 xmlSchemaEvalErrorNodeType(xmlSchemaAbstractCtxtPtr actxt,
                            xmlNodePtr node)
 {
     if (node != NULL)
@@ skipping 62 matching lines @@
         msg = xmlStrcat(msg, BAD_CAST "list type");
     else if (WXS_IS_UNION(type))
         msg = xmlStrcat(msg, BAD_CAST "union type");
 
     if (xmlSchemaIsGlobalItem(type)) {
         xmlChar *str = NULL;
         msg = xmlStrcat(msg, BAD_CAST " '");
         if (type->builtInType != 0) {
             msg = xmlStrcat(msg, BAD_CAST "xs:");
             msg = xmlStrcat(msg, type->name);
-        } else 
+        } else
             msg = xmlStrcat(msg,
                 xmlSchemaFormatQName(&str,
                     type->targetNamespace, type->name));
         msg = xmlStrcat(msg, BAD_CAST "'");
         FREE_AND_NULL(str);
     }
     msg = xmlStrcat(msg, BAD_CAST ".\n");
     if (displayValue || (xmlSchemaEvalErrorNodeType(actxt, node) ==
             XML_ATTRIBUTE_NODE))
         xmlSchemaErr(actxt, error, node, (const char *) msg, value, NULL);
@@ skipping 17 matching lines @@
     return (NULL);
 }
 
 static void
 xmlSchemaIllegalAttrErr(xmlSchemaAbstractCtxtPtr actxt,
                         xmlParserErrors error,
                         xmlSchemaAttrInfoPtr ni,
                         xmlNodePtr node)
 {
     xmlChar *msg = NULL, *str = NULL;
-    
+
     xmlSchemaFormatNodeForError(&msg, actxt, node);
     msg = xmlStrcat(msg, BAD_CAST "The attribute '%s' is not allowed.\n");
     xmlSchemaErr(actxt, error, node, (const char *) msg,
         xmlSchemaFormatErrorNodeQName(&str, (xmlSchemaNodeInfoPtr) ni, node),
-        NULL);        
+        NULL);
     FREE_AND_NULL(str)
     FREE_AND_NULL(msg)
 }
 
 static void
 xmlSchemaComplexTypeErr(xmlSchemaAbstractCtxtPtr actxt,
                         xmlParserErrors error,
                         xmlNodePtr node,
                         xmlSchemaTypePtr type ATTRIBUTE_UNUSED,
                         const char *message,
                         int nbval,
                         int nbneg,
                         xmlChar **values)
 {
     xmlChar *str = NULL, *msg = NULL;
     xmlChar *localName, *nsName;
     const xmlChar *cur, *end;
     int i;
-    
+
     xmlSchemaFormatNodeForError(&msg, actxt, node);
     msg = xmlStrcat(msg, (const xmlChar *) message);
     msg = xmlStrcat(msg, BAD_CAST ".");
     /*
     * Note that is does not make sense to report that we have a
     * wildcard here, since the wildcard might be unfolded into
     * multiple transitions.
     */
     if (nbval + nbneg > 0) {
         if (nbval + nbneg > 1) {
             str = xmlStrdup(BAD_CAST " Expected is one of ( ");
         } else
             str = xmlStrdup(BAD_CAST " Expected is ( ");
         nsName = NULL;
-            
+
         for (i = 0; i < nbval + nbneg; i++) {
             cur = values[i];
             if (cur == NULL)
                 continue;
             if ((cur[0] == 'n') && (cur[1] == 'o') && (cur[2] == 't') &&
                 (cur[3] == ' ')) {
                 cur += 4;
                 str = xmlStrcat(str, BAD_CAST "##other");
             }
             /*
             * Get the local name.
             */
             localName = NULL;
-            
+
             end = cur;
             if (*end == '*') {
                 localName = xmlStrdup(BAD_CAST "*");
                 end++;
             } else {
                 while ((*end != 0) && (*end != '|'))
                     end++;
                 localName = xmlStrncat(localName, BAD_CAST cur, end - cur);
-            }           
-            if (*end != 0) {                
+            }
+            if (*end != 0) {
                 end++;
                 /*
                 * Skip "*|*" if they come with negated expressions, since
                 * they represent the same negated wildcard.
                 */
                 if ((nbneg == 0) || (*end != '*') || (*localName != '*')) {
                     /*
                     * Get the namespace name.
                     */
                     cur = end;
                     if (*end == '*') {
                         nsName = xmlStrdup(BAD_CAST "{*}");
                     } else {
                         while (*end != 0)
                             end++;
-                        
+
                         if (i >= nbval)
                             nsName = xmlStrdup(BAD_CAST "{##other:");
                         else
                             nsName = xmlStrdup(BAD_CAST "{");
-                        
+
                         nsName = xmlStrncat(nsName, BAD_CAST cur, end - cur);
                         nsName = xmlStrcat(nsName, BAD_CAST "}");
                     }
                     str = xmlStrcat(str, BAD_CAST nsName);
                     FREE_AND_NULL(nsName)
                 } else {
                     FREE_AND_NULL(localName);
                     continue;
                 }
-            }           
+            }
             str = xmlStrcat(str, BAD_CAST localName);
             FREE_AND_NULL(localName);
-                
+
             if (i < nbval + nbneg -1)
                 str = xmlStrcat(str, BAD_CAST ", ");
-        }       
+        }
         str = xmlStrcat(str, BAD_CAST " ).\n");
         msg = xmlStrcat(msg, BAD_CAST str);
         FREE_AND_NULL(str)
     } else
       msg = xmlStrcat(msg, BAD_CAST "\n");
     xmlSchemaErr(actxt, error, node, (const char *) msg, NULL, NULL);
     xmlFree(msg);
 }
 
 static void
@@ skipping 11 matching lines @@
     xmlChar *str = NULL, *msg = NULL;
     xmlSchemaTypeType facetType;
     int nodeType = xmlSchemaEvalErrorNodeType(actxt, node);
 
     xmlSchemaFormatNodeForError(&msg, actxt, node);
     if (error == XML_SCHEMAV_CVC_ENUMERATION_VALID) {
         facetType = XML_SCHEMA_FACET_ENUMERATION;
         /*
         * If enumerations are validated, one must not expect the
         * facet to be given.
-        */      
-    } else      
+        */
+    } else
         facetType = facet->type;
     msg = xmlStrcat(msg, BAD_CAST "[");
     msg = xmlStrcat(msg, BAD_CAST "facet '");
     msg = xmlStrcat(msg, xmlSchemaFacetTypeToString(facetType));
     msg = xmlStrcat(msg, BAD_CAST "'] ");
     if (message == NULL) {
         /*
         * Use a default message.
         */
         if ((facetType == XML_SCHEMA_FACET_LENGTH) ||
             (facetType == XML_SCHEMA_FACET_MINLENGTH) ||
             (facetType == XML_SCHEMA_FACET_MAXLENGTH)) {
 
             char len[25], actLen[25];
 
             /* FIXME, TODO: What is the max expected string length of the
             * this value?
             */
             if (nodeType == XML_ATTRIBUTE_NODE)
                 msg = xmlStrcat(msg, BAD_CAST "The value '%s' has a length of '%s'; ");
             else
                 msg = xmlStrcat(msg, BAD_CAST "The value has a length of '%s'; ");
 
             snprintf(len, 24, "%lu", xmlSchemaGetFacetValueAsULong(facet));
             snprintf(actLen, 24, "%lu", length);
 
             if (facetType == XML_SCHEMA_FACET_LENGTH)
-                msg = xmlStrcat(msg, 
-                BAD_CAST "this differs from the allowed length of '%s'.\n");     
+                msg = xmlStrcat(msg,
+                BAD_CAST "this differs from the allowed length of '%s'.\n");
             else if (facetType == XML_SCHEMA_FACET_MAXLENGTH)
-                msg = xmlStrcat(msg, 
+                msg = xmlStrcat(msg,
                 BAD_CAST "this exceeds the allowed maximum length of '%s'.\n");
             else if (facetType == XML_SCHEMA_FACET_MINLENGTH)
-                msg = xmlStrcat(msg, 
+                msg = xmlStrcat(msg,
                 BAD_CAST "this underruns the allowed minimum length of '%s'.\n");
-            
+
             if (nodeType == XML_ATTRIBUTE_NODE)
                 xmlSchemaErr3(actxt, error, node, (const char *) msg,
                     value, (const xmlChar *) actLen, (const xmlChar *) len);
-            else 
+            else
                 xmlSchemaErr(actxt, error, node, (const char *) msg,
                     (const xmlChar *) actLen, (const xmlChar *) len);
-        
+
         } else if (facetType == XML_SCHEMA_FACET_ENUMERATION) {
             msg = xmlStrcat(msg, BAD_CAST "The value '%s' is not an element "
                 "of the set {%s}.\n");
-            xmlSchemaErr(actxt, error, node, (const char *) msg, value, 
+            xmlSchemaErr(actxt, error, node, (const char *) msg, value,
                 xmlSchemaFormatFacetEnumSet(actxt, &str, type));
         } else if (facetType == XML_SCHEMA_FACET_PATTERN) {
             msg = xmlStrcat(msg, BAD_CAST "The value '%s' is not accepted "
                 "by the pattern '%s'.\n");
-            xmlSchemaErr(actxt, error, node, (const char *) msg, value, 
+            xmlSchemaErr(actxt, error, node, (const char *) msg, value,
                 facet->value);
         } else if (facetType == XML_SCHEMA_FACET_MININCLUSIVE) {
             msg = xmlStrcat(msg, BAD_CAST "The value '%s' is less than the "
                 "minimum value allowed ('%s').\n");
             xmlSchemaErr(actxt, error, node, (const char *) msg, value,
                 facet->value);
         } else if (facetType == XML_SCHEMA_FACET_MAXINCLUSIVE) {
             msg = xmlStrcat(msg, BAD_CAST "The value '%s' is greater than the "
                 "maximum value allowed ('%s').\n");
             xmlSchemaErr(actxt, error, node, (const char *) msg, value,
@@ skipping 11 matching lines @@
         } else if (facetType == XML_SCHEMA_FACET_TOTALDIGITS) {
             msg = xmlStrcat(msg, BAD_CAST "The value '%s' has more "
                 "digits than are allowed ('%s').\n");
             xmlSchemaErr(actxt, error, node, (const char*) msg, value,
                 facet->value);
         } else if (facetType == XML_SCHEMA_FACET_FRACTIONDIGITS) {
             msg = xmlStrcat(msg, BAD_CAST "The value '%s' has more fractional "
                 "digits than are allowed ('%s').\n");
             xmlSchemaErr(actxt, error, node, (const char*) msg, value,
                 facet->value);
-        } else if (nodeType == XML_ATTRIBUTE_NODE) {            
+        } else if (nodeType == XML_ATTRIBUTE_NODE) {
             msg = xmlStrcat(msg, BAD_CAST "The value '%s' is not facet-valid.\n");
-            xmlSchemaErr(actxt, error, node, (const char *) msg, value, NULL);  
-        } else {            
+            xmlSchemaErr(actxt, error, node, (const char *) msg, value, NULL);
+        } else {
             msg = xmlStrcat(msg, BAD_CAST "The value is not facet-valid.\n");
             xmlSchemaErr(actxt, error, node, (const char *) msg, NULL, NULL);
         }
     } else {
         msg = xmlStrcat(msg, (const xmlChar *) message);
         msg = xmlStrcat(msg, BAD_CAST ".\n");
         xmlSchemaErr(actxt, error, node, (const char *) msg, str1, str2);
-    }        
+    }
     FREE_AND_NULL(str)
     xmlFree(msg);
 }
 
 #define VERROR(err, type, msg) \
     xmlSchemaCustomErr(ACTXT_CAST vctxt, err, NULL, type, msg, NULL, NULL);
 
 #define VERROR_INT(func, msg) xmlSchemaInternalErr(ACTXT_CAST vctxt, func, msg);
 
 #define PERROR_INT(func, msg) xmlSchemaInternalErr(ACTXT_CAST pctxt, func, msg);
@@ skipping 224 matching lines @@
 xmlSchemaPAttrUseErr4(xmlSchemaParserCtxtPtr ctxt,
                     xmlParserErrors error,
                     xmlNodePtr node,
                     xmlSchemaBasicItemPtr ownerItem,
                     const xmlSchemaAttributeUsePtr attruse,
                     const char *message,
                     const xmlChar *str1, const xmlChar *str2,
                     const xmlChar *str3,const xmlChar *str4)
 {
     xmlChar *str = NULL, *msg = NULL;
-    
+
     xmlSchemaFormatItemForReport(&msg, NULL, ownerItem, NULL);
-    msg = xmlStrcat(msg, BAD_CAST ", ");    
+    msg = xmlStrcat(msg, BAD_CAST ", ");
     msg = xmlStrcat(msg,
         BAD_CAST xmlSchemaFormatItemForReport(&str, NULL,
         WXS_BASIC_CAST attruse, NULL));
     FREE_AND_NULL(str);
     msg = xmlStrcat(msg, BAD_CAST ": ");
     msg = xmlStrcat(msg, (const xmlChar *) message);
     msg = xmlStrcat(msg, BAD_CAST ".\n");
-    xmlSchemaErr4(ACTXT_CAST ctxt, error, node, 
+    xmlSchemaErr4(ACTXT_CAST ctxt, error, node,
         (const char *) msg, str1, str2, str3, str4);
     xmlFree(msg);
 }
 
 /**
  * xmlSchemaPIllegalFacetAtomicErr:
  * @ctxt: the schema parser context
  * @error: the error code
  * @type: the schema type
  * @baseType: the base type of type
@@ skipping 73 matching lines @@
         BAD_CAST des, BAD_CAST name1, BAD_CAST name2, NULL, NULL);
     FREE_AND_NULL(des);
 }
 
 /**
  * xmlSchemaPSimpleTypeErr:
  * @ctxt:  the schema validation context
  * @error: the error code
  * @type: the type specifier
  * @ownerDes: the designation of the owner
- * @ownerItem: the schema object if existent 
+ * @ownerItem: the schema object if existent
  * @node: the validated node
  * @value: the validated value
  *
  * Reports a simple type validation error.
  * TODO: Should this report the value of an element as well?
  */
 static void
-xmlSchemaPSimpleTypeErr(xmlSchemaParserCtxtPtr ctxt, 
+xmlSchemaPSimpleTypeErr(xmlSchemaParserCtxtPtr ctxt,
                         xmlParserErrors error,
                         xmlSchemaBasicItemPtr ownerItem ATTRIBUTE_UNUSED,
                         xmlNodePtr node,
                         xmlSchemaTypePtr type,
                         const char *expected,
                         const xmlChar *value,
                         const char *message,
                         const xmlChar *str1,
                         const xmlChar *str2)
 {
     xmlChar *msg = NULL;
-    
+
     xmlSchemaFormatNodeForError(&msg, ACTXT_CAST ctxt, node);
     if (message == NULL) {
         /*
         * Use default messages.
-        */      
+        */
         if (type != NULL) {
             if (node->type == XML_ATTRIBUTE_NODE)
                 msg = xmlStrcat(msg, BAD_CAST "'%s' is not a valid value of ");
             else
                 msg = xmlStrcat(msg, BAD_CAST "The character content is not a "
-                "valid value of ");     
+                "valid value of ");
             if (! xmlSchemaIsGlobalItem(type))
                 msg = xmlStrcat(msg, BAD_CAST "the local ");
             else
                 msg = xmlStrcat(msg, BAD_CAST "the ");
-            
+
             if (WXS_IS_ATOMIC(type))
                 msg = xmlStrcat(msg, BAD_CAST "atomic type");
             else if (WXS_IS_LIST(type))
                 msg = xmlStrcat(msg, BAD_CAST "list type");
             else if (WXS_IS_UNION(type))
                 msg = xmlStrcat(msg, BAD_CAST "union type");
-            
+
             if (xmlSchemaIsGlobalItem(type)) {
                 xmlChar *str = NULL;
                 msg = xmlStrcat(msg, BAD_CAST " '");
                 if (type->builtInType != 0) {
                     msg = xmlStrcat(msg, BAD_CAST "xs:");
                     msg = xmlStrcat(msg, type->name);
-                } else 
+                } else
                     msg = xmlStrcat(msg,
                         xmlSchemaFormatQName(&str,
                             type->targetNamespace, type->name));
                 msg = xmlStrcat(msg, BAD_CAST "'.");
                 FREE_AND_NULL(str);
             }
         } else {
             if (node->type == XML_ATTRIBUTE_NODE)
                 msg = xmlStrcat(msg, BAD_CAST "The value '%s' is not valid.");
             else
                 msg = xmlStrcat(msg, BAD_CAST "The character content is not "
                 "valid.");
-        }       
+        }
         if (expected) {
             msg = xmlStrcat(msg, BAD_CAST " Expected is '");
             msg = xmlStrcat(msg, BAD_CAST expected);
             msg = xmlStrcat(msg, BAD_CAST "'.\n");
         } else
             msg = xmlStrcat(msg, BAD_CAST "\n");
         if (node->type == XML_ATTRIBUTE_NODE)
             xmlSchemaPErr(ctxt, node, error, (const char *) msg, value, NULL);
         else
             xmlSchemaPErr(ctxt, node, error, (const char *) msg, NULL, NULL);
     } else {
         msg = xmlStrcat(msg, BAD_CAST message);
         msg = xmlStrcat(msg, BAD_CAST ".\n");
         xmlSchemaPErrExt(ctxt, node, error, NULL, NULL, NULL,
              (const char*) msg, str1, str2, NULL, NULL, NULL);
     }
-    /* Cleanup. */    
+    /* Cleanup. */
     FREE_AND_NULL(msg)
 }
 
 /**
  * xmlSchemaPContentErr:
  * @ctxt: the schema parser context
  * @error: the error code
  * @onwerDes: the designation of the holder of the content
  * @ownerItem: the owner item of the holder of the content
  * @ownerElem: the node of the holder of the content
@@ skipping 200 matching lines @@
             list->sizeItems = 0;
             return(-1);
         }
     }
     list->items[list->nbItems++] = item;
     return(0);
 }
 
 static int
 xmlSchemaItemListInsert(xmlSchemaItemListPtr list, void *item, int idx)
-{    
+{
     if (list->items == NULL) {
         list->items = (void **) xmlMalloc(
             20 * sizeof(void *));
         if (list->items == NULL) {
             xmlSchemaPErrMemory(NULL, "allocating new item list", NULL);
             return(-1);
         }
         list->sizeItems = 20;
     } else if (list->sizeItems <= list->nbItems) {
         list->sizeItems *= 2;
@@ skipping 19 matching lines @@
     }
     return(0);
 }
 
 #if 0 /* enable if ever needed */
 static int
 xmlSchemaItemListInsertSize(xmlSchemaItemListPtr list,
                             int initialSize,
                             void *item,
                             int idx)
-{    
+{
     if (list->items == NULL) {
         if (initialSize <= 0)
             initialSize = 1;
         list->items = (void **) xmlMalloc(
             initialSize * sizeof(void *));
         if (list->items == NULL) {
             xmlSchemaPErrMemory(NULL, "allocating new item list", NULL);
             return(-1);
         }
         list->sizeItems = initialSize;
@@ skipping 34 matching lines @@
     }
 
     if (list->nbItems == 1) {
         /* TODO: Really free the list? */
         xmlFree(list->items);
         list->items = NULL;
         list->nbItems = 0;
         list->sizeItems = 0;
     } else if (list->nbItems -1 == idx) {
         list->nbItems--;
-    } else {    
+    } else {
         for (i = idx; i < list->nbItems -1; i++)
             list->items[i] = list->items[i+1];
         list->nbItems--;
     }
     return(0);
 }
 
 /**
  * xmlSchemaItemListFree:
  * @annot:  a schema type structure
@@ skipping 14 matching lines @@
 xmlSchemaBucketFree(xmlSchemaBucketPtr bucket)
 {
     if (bucket == NULL)
         return;
     if (bucket->globals != NULL) {
         xmlSchemaComponentListFree(bucket->globals);
         xmlSchemaItemListFree(bucket->globals);
     }
     if (bucket->locals != NULL) {
         xmlSchemaComponentListFree(bucket->locals);
-        xmlSchemaItemListFree(bucket->locals);  
+        xmlSchemaItemListFree(bucket->locals);
     }
     if (bucket->relations != NULL) {
         xmlSchemaSchemaRelationPtr prev, cur = bucket->relations;
         do {
-            prev = cur;     
+            prev = cur;
             cur = cur->next;
             xmlFree(prev);
         } while (cur != NULL);
     }
     if ((! bucket->preserveDoc) && (bucket->doc != NULL)) {
         xmlFreeDoc(bucket->doc);
-    } 
+    }
     if (bucket->type == XML_SCHEMA_SCHEMA_IMPORT) {
         if (WXS_IMPBUCKET(bucket)->schema != NULL)
             xmlSchemaFree(WXS_IMPBUCKET(bucket)->schema);
     }
     xmlFree(bucket);
 }
 
 static xmlSchemaBucketPtr
 xmlSchemaBucketCreate(xmlSchemaParserCtxtPtr pctxt,
                          int type, const xmlChar *targetNamespace)
@@ skipping 24 matching lines @@
     ret->globals = xmlSchemaItemListCreate();
     if (ret->globals == NULL) {
         xmlFree(ret);
         return(NULL);
     }
     ret->locals = xmlSchemaItemListCreate();
     if (ret->locals == NULL) {
         xmlFree(ret);
         return(NULL);
     }
-    /* 
+    /*
     * The following will assure that only the first bucket is marked as
     * XML_SCHEMA_SCHEMA_MAIN and it points to the *main* schema.
     * For each following import buckets an xmlSchema will be created.
     * An xmlSchema will be created for every distinct targetNamespace.
     * We assign the targetNamespace to the schemata here.
     */
     if (! WXS_HAS_BUCKETS(pctxt)) {
         if (WXS_IS_BUCKET_INCREDEF(type)) {
             PERROR_INT("xmlSchemaBucketCreate",
                 "first bucket but it's an include or redefine");
             xmlSchemaBucketFree(ret);
             return(NULL);
         }
-        /* Force the type to be XML_SCHEMA_SCHEMA_MAIN. */ 
+        /* Force the type to be XML_SCHEMA_SCHEMA_MAIN. */
         ret->type = XML_SCHEMA_SCHEMA_MAIN;
         /* Point to the *main* schema. */
         WXS_CONSTRUCTOR(pctxt)->mainBucket = ret;
         WXS_IMPBUCKET(ret)->schema = mainSchema;
         /*
         * Ensure that the main schema gets a targetNamespace.
         */
         mainSchema->targetNamespace = targetNamespace;
     } else {
-        if (type == XML_SCHEMA_SCHEMA_MAIN) {       
+        if (type == XML_SCHEMA_SCHEMA_MAIN) {
             PERROR_INT("xmlSchemaBucketCreate",
                 "main bucket but it's not the first one");
             xmlSchemaBucketFree(ret);
             return(NULL);
-        } else if (type == XML_SCHEMA_SCHEMA_IMPORT) {      
+        } else if (type == XML_SCHEMA_SCHEMA_IMPORT) {
             /*
             * Create a schema for imports and assign the
             * targetNamespace.
             */
             WXS_IMPBUCKET(ret)->schema = xmlSchemaNewSchema(pctxt);
             if (WXS_IMPBUCKET(ret)->schema == NULL) {
                 xmlSchemaBucketFree(ret);
                 return(NULL);
             }
             WXS_IMPBUCKET(ret)->schema->targetNamespace = targetNamespace;
         }
-    }    
+    }
     if (WXS_IS_BUCKET_IMPMAIN(type)) {
         int res;
         /*
         * Imports go into the "schemasImports" slot of the main *schema*.
         * Note that we create an import entry for the main schema as well; i.e.,
         * even if there's only one schema, we'll get an import.
         */
         if (mainSchema->schemasImports == NULL) {
             mainSchema->schemasImports = xmlHashCreateDict(5,
                 WXS_CONSTRUCTOR(pctxt)->dict);
@@ skipping 22 matching lines @@
         else
             WXS_INCBUCKET(ret)->ownerImport =
                 WXS_INCBUCKET(WXS_CONSTRUCTOR(pctxt)->bucket)->ownerImport;
 
         /* Includes got into the "includes" slot of the *main* schema. */
         if (mainSchema->includes == NULL) {
             mainSchema->includes = xmlSchemaItemListCreate();
             if (mainSchema->includes == NULL) {
                 xmlSchemaBucketFree(ret);
                 return(NULL);
-            }       
+            }
         }
         xmlSchemaItemListAdd(mainSchema->includes, ret);
     }
-    /* 
+    /*
     * Add to list of all buckets; this is used for lookup
     * during schema construction time only.
     */
     if (xmlSchemaItemListAdd(WXS_CONSTRUCTOR(pctxt)->buckets, ret) == -1)
         return(NULL);
     return(ret);
 }
 
 static int
 xmlSchemaAddItemSize(xmlSchemaItemListPtr *list, int initialSize, void *item)
@@ skipping 347 matching lines @@
     if ((list == NULL) || (list->nbItems == 0))
         return;
     {
         xmlSchemaTreeItemPtr item;
         xmlSchemaTreeItemPtr *items = (xmlSchemaTreeItemPtr *) list->items;
         int i;
 
         for (i = 0; i < list->nbItems; i++) {
             item = items[i];
             if (item == NULL)
-                continue;           
+                continue;
             switch (item->type) {
                 case XML_SCHEMA_TYPE_SIMPLE:
                 case XML_SCHEMA_TYPE_COMPLEX:
                     xmlSchemaFreeType((xmlSchemaTypePtr) item);
                     break;
                 case XML_SCHEMA_TYPE_ATTRIBUTE:
                     xmlSchemaFreeAttribute((xmlSchemaAttributePtr) item);
                     break;
                 case XML_SCHEMA_TYPE_ATTRIBUTE_USE:
                     xmlSchemaFreeAttributeUse((xmlSchemaAttributeUsePtr) item);
@@ skipping 86 matching lines @@
     if (schema->idcDef != NULL)
         xmlHashFree(schema->idcDef, NULL);
 
     if (schema->schemasImports != NULL)
         xmlHashFree(schema->schemasImports,
                     (xmlHashDeallocator) xmlSchemaBucketFree);
     if (schema->includes != NULL) {
         xmlSchemaItemListPtr list = (xmlSchemaItemListPtr) schema->includes;
         int i;
         for (i = 0; i < list->nbItems; i++) {
-            xmlSchemaBucketFree((xmlSchemaBucketPtr) list->items[i]);   
+            xmlSchemaBucketFree((xmlSchemaBucketPtr) list->items[i]);
         }
         xmlSchemaItemListFree(list);
     }
     if (schema->annot != NULL)
         xmlSchemaFreeAnnot(schema->annot);
     /* Never free the doc here, since this will be done by the buckets. */
 
     xmlDictFree(schema->dict);
     xmlFree(schema);
 }
@@ skipping 131 matching lines @@
     xmlChar *str = NULL;
     xmlSchemaTreeItemPtr term;
     char shift[100];
     int i;
 
     if (particle == NULL)
         return;
     for (i = 0;((i < depth) && (i < 25));i++)
         shift[2 * i] = shift[2 * i + 1] = ' ';
     shift[2 * i] = shift[2 * i + 1] = 0;
-    fprintf(output, shift);
+    fprintf(output, "%s", shift);
     if (particle->children == NULL) {
         fprintf(output, "MISSING particle term\n");
         return;
     }
     term = particle->children;
     if (term == NULL) {
         fprintf(output, "(NULL)");
     } else {
         switch (term->type) {
             case XML_SCHEMA_TYPE_ELEMENT:
@@ skipping 35 matching lines @@
             output, depth +1);
     }
     if (particle->next != NULL)
         xmlSchemaContentModelDump((xmlSchemaParticlePtr) particle->next,
                 output, depth);
 }
 
 /**
  * xmlSchemaAttrUsesDump:
  * @uses:  attribute uses list
- * @output:  the file output 
+ * @output:  the file output
  *
  * Dumps a list of attribute use components.
  */
 static void
 xmlSchemaAttrUsesDump(xmlSchemaItemListPtr uses, FILE * output)
 {
     xmlSchemaAttributeUsePtr use;
     xmlSchemaAttributeUseProhibPtr prohib;
     xmlSchemaQNameRefPtr ref;
     const xmlChar *name, *tns;
     xmlChar *str = NULL;
     int i;
 
     if ((uses == NULL) || (uses->nbItems == 0))
         return;
 
-    fprintf(output, "  attributes:\n");    
+    fprintf(output, "  attributes:\n");
     for (i = 0; i < uses->nbItems; i++) {
         use = uses->items[i];
         if (use->type == XML_SCHEMA_EXTRA_ATTR_USE_PROHIB) {
             fprintf(output, "  [prohibition] ");
             prohib = (xmlSchemaAttributeUseProhibPtr) use;
             name = prohib->name;
             tns = prohib->targetNamespace;
         } else if (use->type == XML_SCHEMA_EXTRA_QNAMEREF) {
             fprintf(output, "  [reference] ");
             ref = (xmlSchemaQNameRefPtr) use;
@@ skipping 165 matching lines @@
     int i, j, res;
 
     fprintf(output, "IDC: TABLES on '%s'\n",
         xmlSchemaFormatQName(&str, namespaceName, localName));
     FREE_AND_NULL(str)
 
     if (bind == NULL)
         return;
     do {
         fprintf(output, "IDC:   BINDING '%s' (%d)\n",
-            xmlSchemaGetComponentQName(&str, 
+            xmlSchemaGetComponentQName(&str,
                 bind->definition), bind->nbNodes);
         FREE_AND_NULL(str)
         for (i = 0; i < bind->nbNodes; i++) {
             tab = bind->nodeTable[i];
             fprintf(output, "         ( ");
             for (j = 0; j < bind->definition->nbFields; j++) {
                 key = tab->keys[j];
                 if ((key != NULL) && (key->val != NULL)) {
                     res = xmlSchemaGetCanonValue(key->val, &value);
                     if (res >= 0)
@@ skipping 80 matching lines @@
  * a namespace URI of @uri.
  *
  * Returns the attribute or NULL if not present.
  */
 static xmlAttrPtr
 xmlSchemaGetPropNodeNs(xmlNodePtr node, const char *uri, const char *name)
 {
     xmlAttrPtr prop;
 
     if ((node == NULL) || (name == NULL))
-        return(NULL);    
+        return(NULL);
     prop = node->properties;
     while (prop != NULL) {
         if ((prop->ns != NULL) &&
             xmlStrEqual(prop->name, BAD_CAST name) &&
             xmlStrEqual(prop->ns->href, BAD_CAST uri))
             return(prop);
         prop = prop->next;
     }
     return (NULL);
 }
@@ skipping 74 matching lines @@
  *
  * Lookup a global element declaration in the schema.
  *
  * Returns the element declaration or NULL if not found.
  */
 static xmlSchemaElementPtr
 xmlSchemaGetElem(xmlSchemaPtr schema, const xmlChar * name,
                  const xmlChar * nsName)
 {
     xmlSchemaElementPtr ret = NULL;
-    
+
     if ((name == NULL) || (schema == NULL))
         return(NULL);
     if (schema != NULL) {
         WXS_FIND_GLOBAL_ITEM(elemDecl)
-    }   
+    }
 exit:
 #ifdef DEBUG
     if (ret == NULL) {
         if (nsName == NULL)
             fprintf(stderr, "Unable to lookup element decl. %s", name);
         else
             fprintf(stderr, "Unable to lookup element decl. %s:%s", name,
                     nsName);
     }
 #endif
@@ skipping 10 matching lines @@
  *
  * Returns the group definition or NULL if not found.
  */
 static xmlSchemaTypePtr
 xmlSchemaGetType(xmlSchemaPtr schema, const xmlChar * name,
                  const xmlChar * nsName)
 {
     xmlSchemaTypePtr ret = NULL;
 
     if (name == NULL)
-        return (NULL);    
+        return (NULL);
     /* First try the built-in types. */
-    if ((nsName != NULL) && xmlStrEqual(nsName, xmlSchemaNs)) { 
+    if ((nsName != NULL) && xmlStrEqual(nsName, xmlSchemaNs)) {
         ret = xmlSchemaGetPredefinedType(name, nsName);
         if (ret != NULL)
             goto exit;
         /*
         * Note that we try the parsed schemas as well here
         * since one might have parsed the S4S, which contain more
         * than the built-in types.
         * TODO: Can we optimize this?
         */
     }
     if (schema != NULL) {
         WXS_FIND_GLOBAL_ITEM(typeDecl)
-    } 
+    }
 exit:
 
 #ifdef DEBUG
     if (ret == NULL) {
         if (nsName == NULL)
             fprintf(stderr, "Unable to lookup type %s", name);
         else
             fprintf(stderr, "Unable to lookup type %s:%s", name,
                     nsName);
     }
@@ skipping 90 matching lines @@
                  const xmlChar * nsName)
 {
     xmlSchemaModelGroupDefPtr ret = NULL;
 
     if ((name == NULL) || (schema == NULL))
         return (NULL);
     if (schema != NULL) {
         WXS_FIND_GLOBAL_ITEM(groupDecl)
     }
 exit:
-    
+
 #ifdef DEBUG
     if (ret == NULL) {
         if (nsName == NULL)
             fprintf(stderr, "Unable to lookup group %s", name);
         else
             fprintf(stderr, "Unable to lookup group %s:%s", name,
                     nsName);
     }
 #endif
     return (ret);
@@ skipping 88 matching lines @@
             if (!(IS_BLANK_CH(*str)))
                 return (0);
             str++;
         }
     } else while ((*str != 0) && (len != 0)) {
         if (!(IS_BLANK_CH(*str)))
             return (0);
         str++;
         len--;
     }
-    
+
     return (1);
 }
 
 #define WXS_COMP_NAME(c, t) ((t) (c))->name
 #define WXS_COMP_TNS(c, t) ((t) (c))->targetNamespace
 /*
 * xmlSchemaFindRedefCompInGraph:
 * ATTENTION TODO: This uses pointer comp. for strings.
 */
 static xmlSchemaBasicItemPtr
@@ skipping 40 matching lines @@
                             xmlSchemaAttributeGroupPtr) == name) &&
                         (WXS_COMP_TNS(ret,
                             xmlSchemaAttributeGroupPtr) == nsName))
                     {
                         return(ret);
                     }
                     break;
                 default:
                     /* Should not be hit. */
                     return(NULL);
-            }           
+            }
         }
     }
 subschemas:
     /*
     * Process imported/included schemas.
     */
     if (bucket->relations != NULL) {
         xmlSchemaSchemaRelationPtr rel = bucket->relations;
 
         /*
@@ skipping 127 matching lines @@
     return (ret);
 }
 
 /*
 * xmlSchemaAddRedef:
 *
 * Adds a redefinition information. This is used at a later stage to:
 * resolve references to the redefined components and to check constraints.
 */
 static xmlSchemaRedefPtr
-xmlSchemaAddRedef(xmlSchemaParserCtxtPtr pctxt,           
+xmlSchemaAddRedef(xmlSchemaParserCtxtPtr pctxt,
                   xmlSchemaBucketPtr targetBucket,
                   void *item,
                   const xmlChar *refName,
                   const xmlChar *refTargetNs)
 {
     xmlSchemaRedefPtr ret;
 
     ret = (xmlSchemaRedefPtr)
         xmlMalloc(sizeof(xmlSchemaRedef));
     if (ret == NULL) {
@@ skipping 42 matching lines @@
     ret = (xmlSchemaAttributeGroupPtr)
         xmlMalloc(sizeof(xmlSchemaAttributeGroup));
     if (ret == NULL) {
         xmlSchemaPErrMemory(pctxt, "allocating attribute group", NULL);
         return (NULL);
     }
     memset(ret, 0, sizeof(xmlSchemaAttributeGroup));
     ret->type = XML_SCHEMA_TYPE_ATTRIBUTEGROUP;
     ret->name = name;
     ret->targetNamespace = nsName;
-    ret->node = node;   
+    ret->node = node;
 
     /* TODO: Remove the flag. */
     ret->flags |= XML_SCHEMAS_ATTRGROUP_GLOBAL;
     if (pctxt->isRedefine) {
         pctxt->redef = xmlSchemaAddRedef(pctxt, pctxt->redefined,
             ret, name, nsName);
         if (pctxt->redef == NULL) {
             xmlFree(ret);
             return(NULL);
-        }           
+        }
         pctxt->redefCounter = 0;
     }
     WXS_ADD_GLOBAL(pctxt, ret);
     WXS_ADD_PENDING(pctxt, ret);
     return (ret);
 }
 
 /**
  * xmlSchemaAddElement:
  * @ctxt:  a schema parser context
@@ skipping 68 matching lines @@
     ret->name = name;
     ret->targetNamespace = nsName;
     ret->node = node;
     if (topLevel) {
         if (ctxt->isRedefine) {
             ctxt->redef = xmlSchemaAddRedef(ctxt, ctxt->redefined,
                 ret, name, nsName);
             if (ctxt->redef == NULL) {
                 xmlFree(ret);
                 return(NULL);
-            }       
+            }
             ctxt->redefCounter = 0;
         }
         WXS_ADD_GLOBAL(ctxt, ret);
     } else
         WXS_ADD_LOCAL(ctxt, ret);
-    WXS_ADD_PENDING(ctxt, ret);    
+    WXS_ADD_PENDING(ctxt, ret);
     return (ret);
 }
 
 static xmlSchemaQNameRefPtr
 xmlSchemaNewQNameRef(xmlSchemaParserCtxtPtr pctxt,
                      xmlSchemaTypeType refType,
                      const xmlChar *refName,
                      const xmlChar *refNs)
 {
     xmlSchemaQNameRefPtr ret;
@@ skipping 111 matching lines @@
     }
     ret->type = XML_SCHEMA_TYPE_PARTICLE;
     ret->annot = NULL;
     ret->node = node;
     ret->minOccurs = min;
     ret->maxOccurs = max;
     ret->next = NULL;
     ret->children = NULL;
 
     WXS_ADD_LOCAL(ctxt, ret);
-    /* 
+    /*
     * Note that addition to pending components will be done locally
     * to the specific parsing function, since the most particles
     * need not to be fixed up (i.e. the reference to be resolved).
     * REMOVED: WXS_ADD_PENDING(ctxt, ret);
     */
     return (ret);
 }
 
 /**
  * xmlSchemaAddModelGroupDefinition:
@@ skipping 28 matching lines @@
     ret->type = XML_SCHEMA_TYPE_GROUP;
     ret->node = node;
     ret->targetNamespace = nsName;
 
     if (ctxt->isRedefine) {
         ctxt->redef = xmlSchemaAddRedef(ctxt, ctxt->redefined,
             ret, name, nsName);
         if (ctxt->redef == NULL) {
             xmlFree(ret);
             return(NULL);
-        }           
+        }
         ctxt->redefCounter = 0;
     }
     WXS_ADD_GLOBAL(ctxt, ret);
     WXS_ADD_PENDING(ctxt, ret);
     return (ret);
 }
 
 /**
  * xmlSchemaNewWildcardNs:
  * @ctxt:  a schema validation context
@@ skipping 16 matching lines @@
     ret->value = NULL;
     ret->next = NULL;
     return (ret);
 }
 
 static xmlSchemaIDCPtr
 xmlSchemaAddIDC(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
                   const xmlChar *name, const xmlChar *nsName,
                   int category, xmlNodePtr node)
 {
-    xmlSchemaIDCPtr ret = NULL;    
+    xmlSchemaIDCPtr ret = NULL;
 
     if ((ctxt == NULL) || (schema == NULL) || (name == NULL))
         return (NULL);
 
     ret = (xmlSchemaIDCPtr) xmlMalloc(sizeof(xmlSchemaIDC));
     if (ret == NULL) {
         xmlSchemaPErrMemory(ctxt,
             "allocating an identity-constraint definition", NULL);
         return (NULL);
     }
     memset(ret, 0, sizeof(xmlSchemaIDC));
     /* The target namespace of the parent element declaration. */
     ret->targetNamespace = nsName;
     ret->name = name;
     ret->type = category;
-    ret->node = node;        
-    
+    ret->node = node;
+
     WXS_ADD_GLOBAL(ctxt, ret);
     /*
     * Only keyrefs need to be fixup up.
     */
     if (category == XML_SCHEMA_TYPE_IDC_KEYREF)
         WXS_ADD_PENDING(ctxt, ret);
     return (ret);
 }
 
 /**
@@ skipping 15 matching lines @@
     if ((ctxt == NULL) || (schema == NULL))
         return (NULL);
 
     ret = (xmlSchemaWildcardPtr) xmlMalloc(sizeof(xmlSchemaWildcard));
     if (ret == NULL) {
         xmlSchemaPErrMemory(ctxt, "adding wildcard", NULL);
         return (NULL);
     }
     memset(ret, 0, sizeof(xmlSchemaWildcard));
     ret->type = type;
-    ret->node = node;    
+    ret->node = node;
     WXS_ADD_LOCAL(ctxt, ret);
     return (ret);
 }
 
 static void
 xmlSchemaSubstGroupFree(xmlSchemaSubstGroupPtr group)
 {
     if (group == NULL)
         return;
     if (group->members != NULL)
@@ skipping 35 matching lines @@
             "failed to add a new substitution container");
         xmlSchemaSubstGroupFree(ret);
         return(NULL);
     }
     return(ret);
 }
 
 static xmlSchemaSubstGroupPtr
 xmlSchemaSubstGroupGet(xmlSchemaParserCtxtPtr pctxt,
                        xmlSchemaElementPtr head)
-{   
+{
     if (WXS_SUBST_GROUPS(pctxt) == NULL)
         return(NULL);
     return(xmlHashLookup2(WXS_SUBST_GROUPS(pctxt),
         head->name, head->targetNamespace));
 
 }
 
 /**
  * xmlSchemaAddElementSubstitutionMember:
  * @pctxt:  a schema parser context
@@ skipping 395 matching lines @@
 xmlSchemaPGetBoolNodeValue(xmlSchemaParserCtxtPtr ctxt,
                            xmlSchemaBasicItemPtr ownerItem,
                            xmlNodePtr node)
 {
     xmlChar *value = NULL;
     int res = 0;
 
     value = xmlNodeGetContent(node);
     /*
     * 3.2.2.1 Lexical representation
-    * An instance of a datatype that is defined as ·boolean·
+    * An instance of a datatype that is defined as �boolean�
     * can have the following legal literals {true, false, 1, 0}.
     */
     if (xmlStrEqual(BAD_CAST value, BAD_CAST "true"))
         res = 1;
     else if (xmlStrEqual(BAD_CAST value, BAD_CAST "false"))
         res = 0;
     else if (xmlStrEqual(BAD_CAST value, BAD_CAST "1"))
         res = 1;
     else if (xmlStrEqual(BAD_CAST value, BAD_CAST "0"))
         res = 0;
@@ skipping 27 matching lines @@
                   xmlNodePtr node,
                   const char *name, int def)
 {
     const xmlChar *val;
 
     val = xmlSchemaGetProp(ctxt, node, name);
     if (val == NULL)
         return (def);
     /*
     * 3.2.2.1 Lexical representation
-    * An instance of a datatype that is defined as ·boolean·
+    * An instance of a datatype that is defined as �boolean�
     * can have the following legal literals {true, false, 1, 0}.
     */
     if (xmlStrEqual(val, BAD_CAST "true"))
         def = 1;
     else if (xmlStrEqual(val, BAD_CAST "false"))
         def = 0;
     else if (xmlStrEqual(val, BAD_CAST "1"))
         def = 1;
     else if (xmlStrEqual(val, BAD_CAST "0"))
         def = 0;
@@ skipping 99 matching lines @@
     */
     if (ret < 0) {
         PERROR_INT("xmlSchemaPValAttrNodeValue",
             "failed to validate a schema attribute value");
         return (-1);
     } else if (ret > 0) {
         if (WXS_IS_LIST(type))
             ret = XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2;
         else
             ret = XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1;
-        xmlSchemaPSimpleTypeErr(pctxt, 
+        xmlSchemaPSimpleTypeErr(pctxt,
             ret, ownerItem, (xmlNodePtr) attr,
             type, NULL, value, NULL, NULL, NULL);
     }
     return (ret);
 }
 
 /**
  * xmlSchemaPValAttrNode:
  *
  * @ctxt:  a schema parser context
@@ skipping 43 matching lines @@
  * @value: the resulting value if any
  *
  * Extracts and validates a value against the given built-in type.
  * This one is intended to be used internally for validation
  * of schema attribute values during parsing of the schema.
  *
  * Returns 0 if the value is valid, a positive error code
  * number otherwise and -1 in case of an internal or API error.
  */
 static int
-xmlSchemaPValAttr(xmlSchemaParserCtxtPtr ctxt,                 
+xmlSchemaPValAttr(xmlSchemaParserCtxtPtr ctxt,
                        xmlSchemaBasicItemPtr ownerItem,
                        xmlNodePtr ownerElem,
                        const char *name,
                        xmlSchemaTypePtr type,
                        const xmlChar **value)
 {
     xmlAttrPtr attr;
 
     if ((ctxt == NULL) || (type == NULL)) {
         if (value != NULL)
@@ skipping 69 matching lines @@
 }
 
 /**
  * xmlSchemaParseLocalAttributes:
  * @ctxt:  a schema validation context
  * @schema:  the schema being built
  * @node:  a subtree containing XML Schema informations
  * @type:  the hosting type where the attributes will be anchored
  *
  * Parses attribute uses and attribute declarations and
- * attribute group references. 
+ * attribute group references.
  */
 static int
 xmlSchemaParseLocalAttributes(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
                         xmlNodePtr *child, xmlSchemaItemListPtr *list,
                         int parentType, int *hasRefs)
 {
     void *item;
 
     while ((IS_SCHEMA((*child), "attribute")) ||
            (IS_SCHEMA((*child), "attributeGroup"))) {
@@ skipping 334 matching lines @@
                 if (tmp == NULL) {
                     tmp = xmlSchemaNewWildcardNsConstraint(ctxt);
                     if (tmp == NULL) {
                         xmlFree(nsItem);
                         return (-1);
                     }
                     tmp->value = dictnsItem;
                     tmp->next = NULL;
                     if (wildc->nsSet == NULL)
                         wildc->nsSet = tmp;
-                    else
+                    else if (lastNs != NULL)
                         lastNs->next = tmp;
                     lastNs = tmp;
                 }
 
             }
             xmlFree(nsItem);
             cur = end;
         } while (*cur != 0);
     }
     return (ret);
@@ skipping 267 matching lines @@
  * Returns the attribute declaration.
  */
 static xmlSchemaBasicItemPtr
 xmlSchemaParseLocalAttribute(xmlSchemaParserCtxtPtr pctxt,
                              xmlSchemaPtr schema,
                              xmlNodePtr node,
                              xmlSchemaItemListPtr uses,
                              int parentType)
 {
     const xmlChar *attrValue, *name = NULL, *ns = NULL;
-    xmlSchemaAttributeUsePtr use = NULL;    
+    xmlSchemaAttributeUsePtr use = NULL;
     xmlNodePtr child = NULL;
     xmlAttrPtr attr;
     const xmlChar *tmpNs = NULL, *tmpName = NULL, *defValue = NULL;
     int isRef = 0, occurs = XML_SCHEMAS_ATTR_USE_OPTIONAL;
     int nberrors, hasForm = 0, defValueType = 0;
 
 #define WXS_ATTR_DEF_VAL_DEFAULT 1
 #define WXS_ATTR_DEF_VAL_FIXED 2
 
     /*
@@ skipping 33 matching lines @@
                     xmlSchemaPValAttrNodeID(pctxt, attr);
                     goto attr_next;
                 } else if (xmlStrEqual(attr->name, BAD_CAST "type")) {
                     xmlSchemaPValAttrNodeQName(pctxt, schema, NULL,
                         attr, &tmpNs, &tmpName);
                     goto attr_next;
                 } else if (xmlStrEqual(attr->name, BAD_CAST "form")) {
                     /*
                     * Evaluate the target namespace
                     */
-                    hasForm = 1;                    
+                    hasForm = 1;
                     attrValue = xmlSchemaGetNodeContent(pctxt,
                         (xmlNodePtr) attr);
                     if (xmlStrEqual(attrValue, BAD_CAST "qualified")) {
                         ns = pctxt->targetNamespace;
                     } else if (!xmlStrEqual(attrValue, BAD_CAST "unqualified"))
                     {
                         xmlSchemaPSimpleTypeErr(pctxt,
                             XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
                             NULL, (xmlNodePtr) attr,
                             NULL, "(qualified | unqualified)",
@@ skipping 50 matching lines @@
                 goto attr_next;
             }
         } else if (! xmlStrEqual(attr->ns->href, xmlSchemaNs))
             goto attr_next;
 
         xmlSchemaPIllegalAttrErr(pctxt,
             XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
 
 attr_next:
         attr = attr->next;
-    }        
+    }
     /*
     * 3.2.3 : 2
     * If default and use are both present, use must have
     * the actual value optional.
     */
     if ((defValueType == WXS_ATTR_DEF_VAL_DEFAULT) &&
         (occurs != XML_SCHEMAS_ATTR_USE_OPTIONAL)) {
         xmlSchemaPSimpleTypeErr(pctxt,
             XML_SCHEMAP_SRC_ATTRIBUTE_2,
             NULL, node, NULL,
             "(optional | prohibited | required)", NULL,
             "The value of the attribute 'use' must be 'optional' "
             "if the attribute 'default' is present",
             NULL, NULL);
     }
     /*
     * We want correct attributes.
     */
     if (nberrors != pctxt->nberrors)
         return(NULL);
     if (! isRef) {
         xmlSchemaAttributePtr attrDecl;
 
         /* TODO: move XML_SCHEMAS_QUALIF_ATTR to the parser. */
         if ((! hasForm) && (schema->flags & XML_SCHEMAS_QUALIF_ATTR))
-            ns = pctxt->targetNamespace;                
+            ns = pctxt->targetNamespace;
         /*
         * 3.2.6 Schema Component Constraint: xsi: Not Allowed
         * TODO: Move this to the component layer.
         */
         if (xmlStrEqual(ns, xmlSchemaInstanceNs)) {
             xmlSchemaCustomErr(ACTXT_CAST pctxt,
                 XML_SCHEMAP_NO_XSI,
                 node, NULL,
                 "The target namespace must not match '%s'",
                 xmlSchemaInstanceNs, NULL);
@@ skipping 36 matching lines @@
         attrDecl = xmlSchemaAddAttribute(pctxt, schema, name, ns, node, 0);
         if (attrDecl == NULL)
             return (NULL);
         if (tmpName != NULL) {
             attrDecl->typeName = tmpName;
             attrDecl->typeNs = tmpNs;
         }
         use->attrDecl = attrDecl;
         /*
         * Value constraint.
-        */      
+        */
         if (defValue != NULL) {
             attrDecl->defValue = defValue;
             if (defValueType == WXS_ATTR_DEF_VAL_FIXED)
                 attrDecl->flags |= XML_SCHEMAS_ATTR_FIXED;
         }
     } else if (occurs != XML_SCHEMAS_ATTR_USE_PROHIBITED) {
         xmlSchemaQNameRefPtr ref;
 
         /*
         * Create the attribute use component.
@@ skipping 19 matching lines @@
         */
         use->attrDecl = WXS_ATTR_CAST ref;
         /*
         * Value constraint.
         */
         if (defValue != NULL)
             use->defValue = defValue;
             if (defValueType == WXS_ATTR_DEF_VAL_FIXED)
                 use->flags |= XML_SCHEMA_ATTR_USE_FIXED;
     }
-    
+
 check_children:
     /*
     * And now for the children...
     */
     child = node->children;
     if (occurs == XML_SCHEMAS_ATTR_USE_PROHIBITED) {
-        xmlSchemaAttributeUseProhibPtr prohib;  
+        xmlSchemaAttributeUseProhibPtr prohib;
 
         if (IS_SCHEMA(child, "annotation")) {
             xmlSchemaParseAnnotation(pctxt, child, 0);
             child = child->next;
         }
         if (child != NULL) {
             xmlSchemaPContentErr(pctxt,
                 XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
                 NULL, node, child, NULL,
                 "(annotation?)");
         }
         /*
         * Check for pointlessness of attribute prohibitions.
         */
-        if (parentType == XML_SCHEMA_TYPE_ATTRIBUTEGROUP) {             
+        if (parentType == XML_SCHEMA_TYPE_ATTRIBUTEGROUP) {
             xmlSchemaCustomWarning(ACTXT_CAST pctxt,
                 XML_SCHEMAP_WARN_ATTR_POINTLESS_PROH,
                 node, NULL,
                 "Skipping attribute use prohibition, since it is "
                 "pointless inside an <attributeGroup>",
                 NULL, NULL, NULL);
             return(NULL);
         } else if (parentType == XML_SCHEMA_TYPE_EXTENSION) {
             xmlSchemaCustomWarning(ACTXT_CAST pctxt,
                 XML_SCHEMAP_WARN_ATTR_POINTLESS_PROH,
                 node, NULL,
                 "Skipping attribute use prohibition, since it is "
                 "pointless when extending a type",
                 NULL, NULL, NULL);
             return(NULL);
         }
         if (! isRef) {
-            tmpName = name; 
+            tmpName = name;
             tmpNs = ns;
         }
         /*
         * Check for duplicate attribute prohibitions.
         */
         if (uses) {
             int i;
-            
+
             for (i = 0; i < uses->nbItems; i++) {
                 use = uses->items[i];
                 if ((use->type == XML_SCHEMA_EXTRA_ATTR_USE_PROHIB) &&
                     (tmpName == (WXS_ATTR_PROHIB_CAST use)->name) &&
                     (tmpNs == (WXS_ATTR_PROHIB_CAST use)->targetNamespace))
                 {
                     xmlChar *str = NULL;
-                    
+
                     xmlSchemaCustomWarning(ACTXT_CAST pctxt,
                         XML_SCHEMAP_WARN_ATTR_POINTLESS_PROH,
                         node, NULL,
                         "Skipping duplicate attribute use prohibition '%s'",
                         xmlSchemaFormatQName(&str, tmpNs, tmpName),
                         NULL, NULL);
-                    FREE_AND_NULL(str)                  
+                    FREE_AND_NULL(str)
                     return(NULL);
-                }       
+                }
             }
         }
         /*
         * Create the attribute prohibition helper component.
         */
         prohib = xmlSchemaAddAttributeUseProhib(pctxt);
         if (prohib == NULL)
             return(NULL);
         prohib->node = node;
         prohib->name = tmpName;
         prohib->targetNamespace = tmpNs;
         if (isRef) {
             /*
             * We need at least to resolve to the attribute declaration.
             */
             WXS_ADD_PENDING(pctxt, prohib);
         }
         return(WXS_BASIC_CAST prohib);
-    } else {        
+    } else {
         if (IS_SCHEMA(child, "annotation")) {
             /*
             * TODO: Should this go into the attr decl?
             */
             use->annot = xmlSchemaParseAnnotation(pctxt, child, 1);
             child = child->next;
         }
         if (isRef) {
             if (child != NULL) {
                 if (IS_SCHEMA(child, "simpleType"))
@@ skipping 26 matching lines @@
                 } else
                     WXS_ATTRUSE_TYPEDEF(use) =
                         xmlSchemaParseSimpleType(pctxt, schema, child, 0);
                 child = child->next;
             }
             if (child != NULL)
                 xmlSchemaPContentErr(pctxt, XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
                 NULL, node, child, NULL,
                 "(annotation?, simpleType?)");
         }
-    }   
+    }
     return (WXS_BASIC_CAST use);
 }
 
 
 static xmlSchemaAttributePtr
 xmlSchemaParseGlobalAttribute(xmlSchemaParserCtxtPtr pctxt,
                               xmlSchemaPtr schema,
                               xmlNodePtr node)
 {
     const xmlChar *attrValue;
     xmlSchemaAttributePtr ret;
     xmlNodePtr child = NULL;
     xmlAttrPtr attr;
 
     /*
      * Note that the w3c spec assumes the schema to be validated with schema
      * for schemas beforehand.
      *
      * 3.2.3 Constraints on XML Representations of Attribute Declarations
      */
     if ((pctxt == NULL) || (schema == NULL) || (node == NULL))
-        return (NULL);        
+        return (NULL);
     /*
     * 3.2.3 : 3.1
     * One of ref or name must be present, but not both
     */
     attr = xmlSchemaGetPropNode(node, "name");
     if (attr == NULL) {
         xmlSchemaPMissingAttrErr(pctxt, XML_SCHEMAP_S4S_ATTR_MISSING,
             NULL, node, "name", NULL);
         return (NULL);
     }
@@ skipping 25 matching lines @@
             XML_SCHEMAP_NO_XSI, node, NULL,
             "The target namespace must not match '%s'",
             xmlSchemaInstanceNs, NULL);
     }
 
     ret = xmlSchemaAddAttribute(pctxt, schema, attrValue,
         pctxt->targetNamespace, node, 1);
     if (ret == NULL)
         return (NULL);
     ret->flags |= XML_SCHEMAS_ATTR_GLOBAL;
-        
+
     /*
     * Check for illegal attributes.
     */
     attr = node->properties;
     while (attr != NULL) {
         if (attr->ns == NULL) {
             if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
                 (!xmlStrEqual(attr->name, BAD_CAST "default")) &&
                 (!xmlStrEqual(attr->name, BAD_CAST "fixed")) &&
                 (!xmlStrEqual(attr->name, BAD_CAST "name")) &&
                 (!xmlStrEqual(attr->name, BAD_CAST "type")))
             {
                 xmlSchemaPIllegalAttrErr(pctxt,
-                    XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);              
+                    XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
             }
         } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
             xmlSchemaPIllegalAttrErr(pctxt,
                 XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
         }
         attr = attr->next;
     }
     xmlSchemaPValAttrQName(pctxt, schema, NULL,
         node, "type", &ret->typeNs, &ret->typeName);
-    
+
     xmlSchemaPValAttrID(pctxt, node, BAD_CAST "id");
     /*
     * Attribute "fixed".
     */
     ret->defValue = xmlSchemaGetProp(pctxt, node, "fixed");
     if (ret->defValue != NULL)
         ret->flags |= XML_SCHEMAS_ATTR_FIXED;
     /*
     * Attribute "default".
     */
@@ skipping 64 matching lines @@
 
     if ((pctxt == NULL) || (schema == NULL) || (node == NULL))
         return (NULL);
 
     attr = xmlSchemaGetPropNode(node, "ref");
     if (attr == NULL) {
         xmlSchemaPMissingAttrErr(pctxt,
             XML_SCHEMAP_S4S_ATTR_MISSING,
             NULL, node, "ref", NULL);
         return (NULL);
-    }   
+    }
     xmlSchemaPValAttrNodeQName(pctxt, schema,
         NULL, attr, &refNs, &ref);
     if (xmlSchemaCheckReference(pctxt, schema, node, attr, refNs) != 0)
         return(NULL);
-   
+
     /*
     * Check for illegal attributes.
     */
     attr = node->properties;
     while (attr != NULL) {
         if (attr->ns == NULL) {
             if ((!xmlStrEqual(attr->name, BAD_CAST "ref")) &&
                 (!xmlStrEqual(attr->name, BAD_CAST "id")))
             {
                 xmlSchemaPIllegalAttrErr(pctxt,
@@ skipping 31 matching lines @@
     */
     if (pctxt->isRedefine && pctxt->redef &&
         (pctxt->redef->item->type ==
             XML_SCHEMA_TYPE_ATTRIBUTEGROUP) &&
         (ref == pctxt->redef->refName) &&
         (refNs == pctxt->redef->refTargetNs))
     {
         /*
         * SPEC src-redefine:
         * (7.1) "If it has an <attributeGroup> among its contents
-        * the ·actual value· of whose ref [attribute] is the same
-        * as the ·actual value· of its own name attribute plus
+        * the �actual value� of whose ref [attribute] is the same
+        * as the �actual value� of its own name attribute plus
         * target namespace, then it must have exactly one such group."
         */
         if (pctxt->redefCounter != 0) {
             xmlChar *str = NULL;
-            
+
             xmlSchemaCustomErr(ACTXT_CAST pctxt,
                 XML_SCHEMAP_SRC_REDEFINE, node, NULL,
                 "The redefining attribute group definition "
                 "'%s' must not contain more than one "
                 "reference to the redefined definition",
                 xmlSchemaFormatQName(&str, refNs, ref), NULL);
             FREE_AND_NULL(str);
             return(NULL);
         }
         pctxt->redefCounter++;
@@ skipping 13 matching lines @@
         * component for the attribute uses of the referenced attribute group
         * definition.
         */
         ret = xmlSchemaNewQNameRef(pctxt,
             XML_SCHEMA_TYPE_ATTRIBUTEGROUP, ref, refNs);
         if (ret == NULL)
             return(NULL);
         ret->node = node;
         /* Add to pending items, to be able to resolve the reference. */
         WXS_ADD_PENDING(pctxt, ret);
-    }    
+    }
     return (ret);
 }
 
 /**
  * xmlSchemaParseAttributeGroupDefinition:
  * @pctxt:  a schema validation context
  * @schema:  the schema being built
  * @node:  a subtree containing XML Schema informations
  *
  * parse a XML schema Attribute Group declaration
@@ skipping 26 matching lines @@
     * The name is crucial, exit if invalid.
     */
     if (xmlSchemaPValAttrNode(pctxt,
         NULL, attr,
         xmlSchemaGetBuiltInType(XML_SCHEMAS_NCNAME), &name) != 0) {
         return (NULL);
     }
     ret = xmlSchemaAddAttributeGroupDefinition(pctxt, schema,
         name, pctxt->targetNamespace, node);
     if (ret == NULL)
-        return (NULL);  
+        return (NULL);
     /*
     * Check for illegal attributes.
     */
     attr = node->properties;
     while (attr != NULL) {
         if (attr->ns == NULL) {
             if ((!xmlStrEqual(attr->name, BAD_CAST "name")) &&
                 (!xmlStrEqual(attr->name, BAD_CAST "id")))
             {
                 xmlSchemaPIllegalAttrErr(pctxt,
@@ skipping 379 matching lines @@
  * @ctxt:  a schema validation context
  * @schema:  the schema being built
  * @node:  a subtree containing XML Schema informations
  *
  * Parses a XML Schema identity-contraint definition's
  * <selector> and <field> elements.
  *
  * Returns the parsed identity-constraint definition.
  */
 static xmlSchemaIDCSelectPtr
-xmlSchemaParseIDCSelectorAndField(xmlSchemaParserCtxtPtr ctxt,                    
+xmlSchemaParseIDCSelectorAndField(xmlSchemaParserCtxtPtr ctxt,
                           xmlSchemaIDCPtr idc,
                           xmlNodePtr node,
                           int isField)
 {
     xmlSchemaIDCSelectPtr item;
     xmlNodePtr child = NULL;
     xmlAttrPtr attr;
 
     /*
     * Check for illegal attributes.
@@ skipping 642 matching lines @@
     if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
         return (-1);
     /* Not a component, don't create it. */
     type = ctxt->ctxtType;
     /*
     * Mark the simple type as being of variety "union".
     */
     type->flags |= XML_SCHEMAS_TYPE_VARIETY_UNION;
     /*
     * SPEC (Base type) (2) "If the <list> or <union> alternative is chosen,
-    * then the ·simple ur-type definition·."
+    * then the �simple ur-type definition�."
     */
     type->baseType = xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYSIMPLETYPE);
     /*
     * Check for illegal attributes.
     */
     attr = node->properties;
     while (attr != NULL) {
         if (attr->ns == NULL) {
             if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
                 (!xmlStrEqual(attr->name, BAD_CAST "memberTypes"))) {
@@ skipping 147 matching lines @@
     if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
         return (NULL);
     /* Not a component, don't create it. */
     type = ctxt->ctxtType;
     /*
     * Mark the type as being of variety "list".
     */
     type->flags |= XML_SCHEMAS_TYPE_VARIETY_LIST;
     /*
     * SPEC (Base type) (2) "If the <list> or <union> alternative is chosen,
-    * then the ·simple ur-type definition·."
+    * then the �simple ur-type definition�."
     */
     type->baseType = xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYSIMPLETYPE);
     /*
     * Check for illegal attributes.
     */
     attr = node->properties;
     while (attr != NULL) {
         if (attr->ns == NULL) {
             if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
                 (!xmlStrEqual(attr->name, BAD_CAST "itemType"))) {
@@ skipping 124 matching lines @@
                     return(NULL);
                 }
                 biType = xmlSchemaGetPredefinedType(attrValue, xmlSchemaNs);
                 if (biType != NULL)
                     return (biType);
             }
         }
     }
     /*
     * TargetNamespace:
-    * SPEC "The ·actual value· of the targetNamespace [attribute]
+    * SPEC "The �actual value� of the targetNamespace [attribute]
     * of the <schema> ancestor element information item if present,
-    * otherwise ·absent·.
+    * otherwise �absent�.
     */
     if (topLevel == 0) {
 #ifdef ENABLE_NAMED_LOCALS
         char buf[40];
 #endif
         /*
         * Parse as local simple type definition.
         */
 #ifdef ENABLE_NAMED_LOCALS
         snprintf(buf, 39, "#ST%d", ctxt->counter++ + 1);
@@ skipping 11 matching lines @@
         type->type = XML_SCHEMA_TYPE_SIMPLE;
         type->contentType = XML_SCHEMA_CONTENT_SIMPLE;
         /*
         * Check for illegal attributes.
         */
         attr = node->properties;
         while (attr != NULL) {
             if (attr->ns == NULL) {
                 if (!xmlStrEqual(attr->name, BAD_CAST "id")) {
                     xmlSchemaPIllegalAttrErr(ctxt,
-                        XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr); 
+                        XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
                 }
             } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
                     xmlSchemaPIllegalAttrErr(ctxt,
                         XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
             }
             attr = attr->next;
         }
     } else {
         /*
         * Parse as global simple type definition.
@@ skipping 50 matching lines @@
                     attrValue, NULL, NULL, NULL);
             }
         }
     }
     type->targetNamespace = ctxt->targetNamespace;
     xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
     /*
     * And now for the children...
     */
     oldCtxtType = ctxt->ctxtType;
-    
+
     ctxt->ctxtType = type;
-    
+
     child = node->children;
     if (IS_SCHEMA(child, "annotation")) {
         type->annot = xmlSchemaParseAnnotation(ctxt, child, 1);
         child = child->next;
     }
     if (child == NULL) {
         xmlSchemaPContentErr(ctxt, XML_SCHEMAP_S4S_ELEM_MISSING,
             NULL, node, child, NULL,
             "(annotation?, (restriction | list | union))");
-    } else if (IS_SCHEMA(child, "restriction")) {       
+    } else if (IS_SCHEMA(child, "restriction")) {
         xmlSchemaParseRestriction(ctxt, schema, child,
-            XML_SCHEMA_TYPE_SIMPLE);    
-        hasRestriction = 1;     
+            XML_SCHEMA_TYPE_SIMPLE);
+        hasRestriction = 1;
         child = child->next;
     } else if (IS_SCHEMA(child, "list")) {
         xmlSchemaParseList(ctxt, schema, child);
         child = child->next;
     } else if (IS_SCHEMA(child, "union")) {
         xmlSchemaParseUnion(ctxt, schema, child);
         child = child->next;
     }
     if (child != NULL) {
         xmlSchemaPContentErr(ctxt, XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
             NULL, node, child, NULL,
             "(annotation?, (restriction | list | union))");
     }
     /*
     * REDEFINE: SPEC src-redefine (5)
     * "Within the [children], each <simpleType> must have a
-    * <restriction> among its [children] ... the ·actual value· of whose
-    * base [attribute] must be the same as the ·actual value· of its own
+    * <restriction> among its [children] ... the �actual value� of whose
+    * base [attribute] must be the same as the �actual value� of its own
     * name attribute plus target namespace;"
     */
     if (topLevel && ctxt->isRedefine && (! hasRestriction)) {
         xmlSchemaPCustomErr(ctxt, XML_SCHEMAP_SRC_REDEFINE,
             NULL, node, "This is a redefinition, thus the "
             "<simpleType> must have a <restriction> child", NULL);
     }
-    
+
     ctxt->ctxtType = oldCtxtType;
     return (type);
 }
 
 /**
  * xmlSchemaParseModelGroupDefRef:
  * @ctxt:  the parser context
  * @schema: the schema being built
  * @node:  the node
  *
@@ skipping 45 matching lines @@
             }
         } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
             xmlSchemaPIllegalAttrErr(ctxt,
                 XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
         }
         attr = attr->next;
     }
     xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
     item = xmlSchemaAddParticle(ctxt, node, min, max);
     if (item == NULL)
-        return (NULL);    
+        return (NULL);
     /*
     * Create a qname-reference and set as the term; it will be substituted
     * for the model group after the reference has been resolved.
     */
     item->children = (xmlSchemaTreeItemPtr)
-        xmlSchemaNewQNameRef(ctxt, XML_SCHEMA_TYPE_GROUP, ref, refNs);    
+        xmlSchemaNewQNameRef(ctxt, XML_SCHEMA_TYPE_GROUP, ref, refNs);
     xmlSchemaPCheckParticleCorrect_2(ctxt, item, node, min, max);
     /*
     * And now for the children...
     */
     child = node->children;
     /* TODO: Is annotation even allowed for a model group reference? */
     if (IS_SCHEMA(child, "annotation")) {
         /*
         * TODO: What to do exactly with the annotation?
         */
@@ skipping 19 matching lines @@
  * xmlSchemaParseModelGroupDefinition:
  * @ctxt:  a schema validation context
  * @schema:  the schema being built
  * @node:  a subtree containing XML Schema informations
  *
  * Parses a XML schema model group definition.
  *
  * Note that the contraint src-redefine (6.2) can't be applied until
  * references have been resolved. So we will do this at the
  * component fixup level.
- *    
+ *
  * *WARNING* this interface is highly subject to change
  *
  * Returns -1 in case of error, 0 if the declaration is improper and
  *         1 in case of success.
  */
 static xmlSchemaModelGroupDefPtr
 xmlSchemaParseModelGroupDefinition(xmlSchemaParserCtxtPtr ctxt,
                                    xmlSchemaPtr schema,
                                    xmlNodePtr node)
 {
@@ skipping 53 matching lines @@
     } else if (IS_SCHEMA(child, "choice")) {
         item->children = xmlSchemaParseModelGroup(ctxt, schema, child,
             XML_SCHEMA_TYPE_CHOICE, 0);
         child = child->next;
     } else if (IS_SCHEMA(child, "sequence")) {
         item->children = xmlSchemaParseModelGroup(ctxt, schema, child,
             XML_SCHEMA_TYPE_SEQUENCE, 0);
         child = child->next;
     }
 
-   
+
 
     if (child != NULL) {
         xmlSchemaPContentErr(ctxt,
             XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
             NULL, node, child, NULL,
             "(annotation?, (all | choice | sequence)?)");
     }
     return (item);
 }
 
@@ skipping 117 matching lines @@
     HFAILURE;
 
     /*
     * Since the version is of type xs:token, we won't bother to
     * check it.
     */
     /* REMOVED:
     attr = xmlSchemaGetPropNode(node, "version");
     if (attr != NULL) {
         res = xmlSchemaPValAttrNode(ctxt, NULL, NULL, attr,
-            xmlSchemaGetBuiltInType(XML_SCHEMAS_TOKEN), &val);    
+            xmlSchemaGetBuiltInType(XML_SCHEMAS_TOKEN), &val);
         HFAILURE;
     }
     */
     attr = xmlSchemaGetPropNode(node, "targetNamespace");
     if (attr != NULL) {
         res = xmlSchemaPValAttrNode(ctxt, NULL, attr,
             xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYURI), NULL);
         HFAILURE;
         if (res != 0) {
             ctxt->stop = XML_SCHEMAP_S4S_ATTR_INVALID_VALUE;
@@ skipping 39 matching lines @@
         if (res != 0) {
             xmlSchemaPSimpleTypeErr(ctxt,
                 XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
                 NULL, (xmlNodePtr) attr, NULL,
                 "(#all | List of (extension | restriction | list | union))",
                 val, NULL, NULL, NULL);
         }
     }
     attr = xmlSchemaGetPropNode(node, "blockDefault");
     if (attr != NULL) {
-        val = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr); 
+        val = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
         res = xmlSchemaPValAttrBlockFinal(val, &(schema->flags), -1,
             XML_SCHEMAS_BLOCK_DEFAULT_EXTENSION,
             XML_SCHEMAS_BLOCK_DEFAULT_RESTRICTION,
             XML_SCHEMAS_BLOCK_DEFAULT_SUBSTITUTION, -1, -1);
         HFAILURE;
         if (res != 0) {
             xmlSchemaPSimpleTypeErr(ctxt,
                 XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
                 NULL, (xmlNodePtr) attr, NULL,
                 "(#all | List of (extension | restriction | substitution))",
@@ skipping 40 matching lines @@
             if (schema->annot == NULL)
                 schema->annot = annot;
             else
                 xmlSchemaFreeAnnot(annot);
         } else if (IS_SCHEMA(child, "import")) {
             tmpOldErrs = ctxt->nberrors;
             res = xmlSchemaParseImport(ctxt, schema, child);
             HFAILURE;
             HSTOP(ctxt);
             if (tmpOldErrs != ctxt->nberrors)
-                goto exit;          
+                goto exit;
         } else if (IS_SCHEMA(child, "include")) {
             tmpOldErrs = ctxt->nberrors;
             res = xmlSchemaParseInclude(ctxt, schema, child);
             HFAILURE;
             HSTOP(ctxt);
             if (tmpOldErrs != ctxt->nberrors)
-                goto exit;          
+                goto exit;
         } else if (IS_SCHEMA(child, "redefine")) {
             tmpOldErrs = ctxt->nberrors;
             res = xmlSchemaParseRedefine(ctxt, schema, child);
             HFAILURE;
             HSTOP(ctxt);
             if (tmpOldErrs != ctxt->nberrors)
                 goto exit;
         }
         child = child->next;
     }
@@ skipping 104 matching lines @@
     if (con->substGroups != NULL)
         xmlHashFree(con->substGroups,
             (xmlHashDeallocator) xmlSchemaSubstGroupFree);
     if (con->redefs != NULL)
         xmlSchemaRedefListFree(con->redefs);
     if (con->dict != NULL)
         xmlDictFree(con->dict);
     xmlFree(con);
 }
 
-static xmlSchemaConstructionCtxtPtr 
+static xmlSchemaConstructionCtxtPtr
 xmlSchemaConstructionCtxtCreate(xmlDictPtr dict)
 {
     xmlSchemaConstructionCtxtPtr ret;
 
     ret = (xmlSchemaConstructionCtxtPtr)
         xmlMalloc(sizeof(xmlSchemaConstructionCtxt));
     if (ret == NULL) {
         xmlSchemaPErrMemory(NULL,
             "allocating schema construction context", NULL);
         return (NULL);
@@ skipping 49 matching lines @@
  * to contain an XML Schemas file.
  *
  * Returns the parser context or NULL in case of error
  */
 static xmlSchemaParserCtxtPtr
 xmlSchemaNewParserCtxtUseDict(const char *URL, xmlDictPtr dict)
 {
     xmlSchemaParserCtxtPtr ret;
 
     ret = xmlSchemaParserCtxtCreate();
-    if (ret == NULL)        
+    if (ret == NULL)
         return (NULL);
     ret->dict = dict;
-    xmlDictReference(dict);    
+    xmlDictReference(dict);
     if (URL != NULL)
         ret->URL = xmlDictLookup(dict, (const xmlChar *) URL, -1);
     return (ret);
 }
 
 static int
 xmlSchemaCreatePCtxtOnVCtxt(xmlSchemaValidCtxtPtr vctxt)
 {
     if (vctxt->pctxt == NULL) {
         if (vctxt->schema != NULL)
@@ skipping 104 matching lines @@
 static int
 xmlSchemaParseNewDocWithContext(xmlSchemaParserCtxtPtr pctxt,
                      xmlSchemaPtr schema,
                      xmlSchemaBucketPtr bucket)
 {
     int oldFlags;
     xmlDocPtr oldDoc;
     xmlNodePtr node;
     int ret, oldErrs;
     xmlSchemaBucketPtr oldbucket = pctxt->constructor->bucket;
-    
-    /* 
+
+    /*
     * Save old values; reset the *main* schema.
     * URGENT TODO: This is not good; move the per-document information
     * to the parser. Get rid of passing the main schema to the
     * parsing functions.
     */
     oldFlags = schema->flags;
     oldDoc = schema->doc;
     if (schema->flags != 0)
         xmlSchemaClearSchemaDefaults(schema);
-    schema->doc = bucket->doc;    
+    schema->doc = bucket->doc;
     pctxt->schema = schema;
-    /* 
+    /*
     * Keep the current target namespace on the parser *not* on the
     * main schema.
     */
     pctxt->targetNamespace = bucket->targetNamespace;
     WXS_CONSTRUCTOR(pctxt)->bucket = bucket;
 
     if ((bucket->targetNamespace != NULL) &&
         xmlStrEqual(bucket->targetNamespace, xmlSchemaNs)) {
         /*
         * We are parsing the schema for schemas!
         */
         pctxt->isS4S = 1;
-    }    
+    }
     /* Mark it as parsed, even if parsing fails. */
     bucket->parsed++;
     /* Compile the schema doc. */
     node = xmlDocGetRootElement(bucket->doc);
     ret = xmlSchemaParseSchemaElement(pctxt, schema, node);
     if (ret != 0)
         goto exit;
     /* An empty schema; just get out. */
     if (node->children == NULL)
         goto exit;
     oldErrs = pctxt->nberrors;
     ret = xmlSchemaParseSchemaTopLevel(pctxt, schema, node->children);
     if (ret != 0)
         goto exit;
     /*
     * TODO: Not nice, but I'm not 100% sure we will get always an error
     * as a result of the obove functions; so better rely on pctxt->err
     * as well.
     */
     if ((ret == 0) && (oldErrs != pctxt->nberrors)) {
         ret = pctxt->err;
         goto exit;
     }
-    
+
 exit:
     WXS_CONSTRUCTOR(pctxt)->bucket = oldbucket;
     /* Restore schema values. */
     schema->doc = oldDoc;
     schema->flags = oldFlags;
     return(ret);
 }
 
 static int
 xmlSchemaParseNewDoc(xmlSchemaParserCtxtPtr pctxt,
@@ skipping 12 matching lines @@
     }
     if (bucket->doc == NULL) {
         PERROR_INT("xmlSchemaParseNewDoc",
             "parsing a schema doc, but there's no doc");
         return(-1);
     }
     if (pctxt->constructor == NULL) {
         PERROR_INT("xmlSchemaParseNewDoc",
             "no constructor");
         return(-1);
-    }    
+    }
     /* Create and init the temporary parser context. */
     newpctxt = xmlSchemaNewParserCtxtUseDict(
         (const char *) bucket->schemaLocation, pctxt->dict);
     if (newpctxt == NULL)
         return(-1);
     newpctxt->constructor = pctxt->constructor;
     /*
-    * TODO: Can we avoid that the parser knows about the main schema? 
+    * TODO: Can we avoid that the parser knows about the main schema?
     * It would be better if he knows about the current schema bucket
     * only.
     */
     newpctxt->schema = schema;
     xmlSchemaSetParserErrors(newpctxt, pctxt->error, pctxt->warning,
         pctxt->errCtxt);
     xmlSchemaSetParserStructuredErrors(newpctxt, pctxt->serror,
         pctxt->errCtxt);
     newpctxt->counter = pctxt->counter;
-    
+
 
     res = xmlSchemaParseNewDocWithContext(newpctxt, schema, bucket);
-    
+
     /* Channel back errors and cleanup the temporary parser context. */
     if (res != 0)
         pctxt->err = res;
     pctxt->nberrors += newpctxt->nberrors;
     pctxt->counter = newpctxt->counter;
-    newpctxt->constructor = NULL;    
+    newpctxt->constructor = NULL;
     /* Free the parser context. */
     xmlSchemaFreeParserCtxt(newpctxt);
     return(res);
 }
 
 static void
 xmlSchemaSchemaRelationAddChild(xmlSchemaBucketPtr bucket,
                                 xmlSchemaSchemaRelationPtr rel)
 {
     xmlSchemaSchemaRelationPtr cur = bucket->relations;
 
     if (cur == NULL) {
         bucket->relations = rel;
         return;
     }
     while (cur->next != NULL)
         cur = cur->next;
     cur->next = rel;
 }
 
 
 static const xmlChar *
 xmlSchemaBuildAbsoluteURI(xmlDictPtr dict, const xmlChar* location,
                           xmlNodePtr ctxtNode)
-{    
+{
     /*
     * Build an absolue location URI.
     */
-    if (location != NULL) {     
+    if (location != NULL) {
         if (ctxtNode == NULL)
             return(location);
         else {
             xmlChar *base, *URI;
             const xmlChar *ret = NULL;
 
             base = xmlNodeGetBase(ctxtNode->doc, ctxtNode);
             if (base == NULL) {
                 URI = xmlBuildURI(location, ctxtNode->doc->URL);
             } else {
                 URI = xmlBuildURI(location, base);
                 xmlFree(base);
             }
             if (URI != NULL) {
                 ret = xmlDictLookup(dict, URI, -1);
                 xmlFree(URI);
                 return(ret);
             }
         }
     }
     return(NULL);
 }
-    
+
 
 
 /**
  * xmlSchemaAddSchemaDoc:
  * @pctxt:  a schema validation context
  * @schema:  the schema being built
  * @node:  a subtree containing XML Schema informations
  *
  * Parse an included (and to-be-redefined) XML schema document.
  *
  * Returns 0 on success, a positive error code on errors and
  *         -1 in case of an internal or API error.
  */
 
 static int
 xmlSchemaAddSchemaDoc(xmlSchemaParserCtxtPtr pctxt,
                 int type, /* import or include or redefine */
                 const xmlChar *schemaLocation,
                 xmlDocPtr schemaDoc,
                 const char *schemaBuffer,
                 int schemaBufferLen,
                 xmlNodePtr invokingNode,
-                const xmlChar *sourceTargetNamespace,           
-                const xmlChar *importNamespace, 
+                const xmlChar *sourceTargetNamespace,
+                const xmlChar *importNamespace,
                 xmlSchemaBucketPtr *bucket)
 {
     const xmlChar *targetNamespace = NULL;
     xmlSchemaSchemaRelationPtr relation = NULL;
     xmlDocPtr doc = NULL;
     int res = 0, err = 0, located = 0, preserveDoc = 0;
     xmlSchemaBucketPtr bkt = NULL;
 
     if (bucket != NULL)
         *bucket = NULL;
-    
+
     switch (type) {
         case XML_SCHEMA_SCHEMA_IMPORT:
         case XML_SCHEMA_SCHEMA_MAIN:
             err = XML_SCHEMAP_SRC_IMPORT;
             break;
         case XML_SCHEMA_SCHEMA_INCLUDE:
             err = XML_SCHEMAP_SRC_INCLUDE;
             break;
         case XML_SCHEMA_SCHEMA_REDEFINE:
             err = XML_SCHEMAP_SRC_REDEFINE;
             break;
-    }    
-       
+    }
+
 
     /* Special handling for the main schema:
     * skip the location and relation logic and just parse the doc.
     * We need just a bucket to be returned in this case.
-    */    
+    */
     if ((type == XML_SCHEMA_SCHEMA_MAIN) || (! WXS_HAS_BUCKETS(pctxt)))
-        goto doc_load;  
+        goto doc_load;
 
-    /* Note that we expect the location to be an absulute URI. */ 
+    /* Note that we expect the location to be an absulute URI. */
     if (schemaLocation != NULL) {
         bkt = xmlSchemaGetSchemaBucket(pctxt, schemaLocation);
         if ((bkt != NULL) &&
             (pctxt->constructor->bucket == bkt)) {
             /* Report self-imports/inclusions/redefinitions. */
-            
+
             xmlSchemaCustomErr(ACTXT_CAST pctxt, err,
                 invokingNode, NULL,
                 "The schema must not import/include/redefine itself",
                 NULL, NULL);
             goto exit;
         }
     }
     /*
     * Create a relation for the graph of schemas.
     */
     relation = xmlSchemaSchemaRelationCreate();
     if (relation == NULL)
-        return(-1);    
+        return(-1);
     xmlSchemaSchemaRelationAddChild(pctxt->constructor->bucket,
         relation);
     relation->type = type;
 
     /*
     * Save the namespace import information.
     */
     if (WXS_IS_BUCKET_IMPMAIN(type)) {
-        relation->importNamespace = importNamespace;    
+        relation->importNamespace = importNamespace;
         if (schemaLocation == NULL) {
             /*
             * No location; this is just an import of the namespace.
             * Note that we don't assign a bucket to the relation
             * in this case.
             */
             goto exit;
         }
         targetNamespace = importNamespace;
     }
 
     /* Did we already fetch the doc? */
-    if (bkt != NULL) {          
-        /* TODO: The following nasty cases will produce an error. */
+    if (bkt != NULL) {
         if ((WXS_IS_BUCKET_IMPMAIN(type)) && (! bkt->imported)) {
-            /* We included/redefined and then try to import a schema. */
+            /*
+            * We included/redefined and then try to import a schema,
+            * but the new location provided for import was different.
+            */
             if (schemaLocation == NULL)
                 schemaLocation = BAD_CAST "in_memory_buffer";
-            xmlSchemaCustomErr(ACTXT_CAST pctxt, err,
-                invokingNode, NULL,
-                "The schema document '%s' cannot be imported, since "
-                "it was already included or redefined",
-                schemaLocation, NULL);
-            goto exit;
+            if (!xmlStrEqual(schemaLocation,
+                bkt->schemaLocation)) {
+                xmlSchemaCustomErr(ACTXT_CAST pctxt, err,
+                    invokingNode, NULL,
+                    "The schema document '%s' cannot be imported, since "
+                    "it was already included or redefined",
+                    schemaLocation, NULL);
+                goto exit;
+            }
         } else if ((! WXS_IS_BUCKET_IMPMAIN(type)) && (bkt->imported)) {
-            /* We imported and then try to include/redefine a schema. */
+            /*
+            * We imported and then try to include/redefine a schema,
+            * but the new location provided for the include/redefine
+            * was different.
+            */
             if (schemaLocation == NULL)
                 schemaLocation = BAD_CAST "in_memory_buffer";
-            xmlSchemaCustomErr(ACTXT_CAST pctxt, err,
-                invokingNode, NULL,
-                "The schema document '%s' cannot be included or "
-                "redefined, since it was already imported",
-                schemaLocation, NULL);
-            goto exit;
-        }       
+            if (!xmlStrEqual(schemaLocation,
+                bkt->schemaLocation)) {
+                xmlSchemaCustomErr(ACTXT_CAST pctxt, err,
+                    invokingNode, NULL,
+                    "The schema document '%s' cannot be included or "
+                    "redefined, since it was already imported",
+                    schemaLocation, NULL);
+                goto exit;
+            }
+        }
     }
-        
+
     if (WXS_IS_BUCKET_IMPMAIN(type)) {
         /*
         * Given that the schemaLocation [attribute] is only a hint, it is open
         * to applications to ignore all but the first <import> for a given
-        * namespace, regardless of the ·actual value· of schemaLocation, but
+        * namespace, regardless of the �actual value� of schemaLocation, but
         * such a strategy risks missing useful information when new
         * schemaLocations are offered.
         *
         * We will use the first <import> that comes with a location.
         * Further <import>s *with* a location, will result in an error.
         * TODO: Better would be to just report a warning here, but
         * we'll try it this way until someone complains.
         *
         * Schema Document Location Strategy:
         * 3 Based on the namespace name, identify an existing schema document,
         * either as a resource which is an XML document or a <schema> element
         * information item, in some local schema repository;
         * 5 Attempt to resolve the namespace name to locate such a resource.
         *
         * NOTE: (3) and (5) are not supported.
-        */      
+        */
         if (bkt != NULL) {
             relation->bucket = bkt;
             goto exit;
         }
         bkt = xmlSchemaGetSchemaBucketByTNS(pctxt,
             importNamespace, 1);
 
-        if (bkt != NULL) {          
+        if (bkt != NULL) {
             relation->bucket = bkt;
             if (bkt->schemaLocation == NULL) {
                 /* First given location of the schema; load the doc. */
                 bkt->schemaLocation = schemaLocation;
             } else {
                 if (!xmlStrEqual(schemaLocation,
                     bkt->schemaLocation)) {
                     /*
                     * Additional location given; just skip it.
                     * URGENT TODO: We should report a warning here.
                     * res = XML_SCHEMAP_SRC_IMPORT;
                     */
                     if (schemaLocation == NULL)
                         schemaLocation = BAD_CAST "in_memory_buffer";
 
                     xmlSchemaCustomWarning(ACTXT_CAST pctxt,
                         XML_SCHEMAP_WARN_SKIP_SCHEMA,
                         invokingNode, NULL,
                         "Skipping import of schema located at '%s' for the "
                         "namespace '%s', since this namespace was already "
                         "imported with the schema located at '%s'",
                         schemaLocation, importNamespace, bkt->schemaLocation);
                 }
                 goto exit;
             }
-        }       
-        /* 
+        }
+        /*
         * No bucket + first location: load the doc and create a
         * bucket.
         */
     } else {
         /* <include> and <redefine> */
         if (bkt != NULL) {
-                    
+
             if ((bkt->origTargetNamespace == NULL) &&
                 (bkt->targetNamespace != sourceTargetNamespace)) {
                 xmlSchemaBucketPtr chamel;
-                
+
                 /*
                 * Chameleon include/redefine: skip loading only if it was
                 * aleady build for the targetNamespace of the including
                 * schema.
                 */
                 /*
                 * URGENT TODO: If the schema is a chameleon-include then copy
                 * the components into the including schema and modify the
                 * targetNamespace of those components, do nothing otherwise.
                 * NOTE: This is currently worked-around by compiling the
                 * chameleon for every destinct including targetNamespace; thus
                 * not performant at the moment.
                 * TODO: Check when the namespace in wildcards for chameleons
                 * needs to be converted: before we built wildcard intersections
                 * or after.
                 *   Answer: after!
                 */
                 chamel = xmlSchemaGetChameleonSchemaBucket(pctxt,
                     schemaLocation, sourceTargetNamespace);
                 if (chamel != NULL) {
                     /* A fitting chameleon was already parsed; NOP. */
                     relation->bucket = chamel;
                     goto exit;
                 }
-                /* 
+                /*
                 * We need to parse the chameleon again for a different
                 * targetNamespace.
                 * CHAMELEON TODO: Optimize this by only parsing the
                 * chameleon once, and then copying the components to
                 * the new targetNamespace.
                 */
                 bkt = NULL;
             } else {
                 relation->bucket = bkt;
                 goto exit;
-            }       
+            }
         }
     }
     if ((bkt != NULL) && (bkt->doc != NULL)) {
         PERROR_INT("xmlSchemaAddSchemaDoc",
             "trying to load a schema doc, but a doc is already "
             "assigned to the schema bucket");
         goto exit_failure;
     }
 
 doc_load:
@@ skipping 29 matching lines @@
             xmlDictReference(parserCtxt->dict);
         }
         if (schemaLocation != NULL) {
             /* Parse from file. */
             doc = xmlCtxtReadFile(parserCtxt, (const char *) schemaLocation,
                 NULL, SCHEMAS_PARSE_OPTIONS);
         } else if (schemaBuffer != NULL) {
             /* Parse from memory buffer. */
             doc = xmlCtxtReadMemory(parserCtxt, schemaBuffer, schemaBufferLen,
                 NULL, NULL, SCHEMAS_PARSE_OPTIONS);
-            schemaLocation = xmlStrdup(BAD_CAST "in_memory_buffer");
+            schemaLocation = BAD_CAST "in_memory_buffer";
             if (doc != NULL)
-                doc->URL = schemaLocation;          
+                doc->URL = xmlStrdup(schemaLocation);
         }
         /*
         * For <import>:
         * 2.1 The referent is (a fragment of) a resource which is an
         * XML document (see clause 1.1), which in turn corresponds to
         * a <schema> element information item in a well-formed information
         * set, which in turn corresponds to a valid schema.
         * TODO: (2.1) fragments of XML documents are not supported.
         *
         * 2.2 The referent is a <schema> element information item in
@@ skipping 33 matching lines @@
             "given schema parser context.\n",
             NULL, NULL);
         goto exit_failure;
     }
     /*
     * Preprocess the document.
     */
     if (doc != NULL) {
         xmlNodePtr docElem = NULL;
 
-        located = 1;    
+        located = 1;
         docElem = xmlDocGetRootElement(doc);
         if (docElem == NULL) {
             xmlSchemaCustomErr(ACTXT_CAST pctxt, XML_SCHEMAP_NOROOT,
-                invokingNode, NULL, 
+                invokingNode, NULL,
                 "The document '%s' has no document element",
                 schemaLocation, NULL);
             goto exit_error;
         }
         /*
         * Remove all the blank text nodes.
         */
         xmlSchemaCleanupDoc(pctxt, docElem);
         /*
         * Check the schema's top level element.
         */
         if (!IS_SCHEMA(docElem, "schema")) {
             xmlSchemaCustomErr(ACTXT_CAST pctxt, XML_SCHEMAP_NOT_SCHEMA,
                 invokingNode, NULL,
                 "The XML document '%s' is not a schema document",
                 schemaLocation, NULL);
             goto exit_error;
         }
-        /* 
+        /*
         * Note that we don't apply a type check for the
         * targetNamespace value here.
         */
         targetNamespace = xmlSchemaGetProp(pctxt, docElem,
             "targetNamespace");
     }
-    
+
 /* after_doc_loading: */
     if ((bkt == NULL) && located) {
         /* Only create a bucket if the schema was located. */
         bkt = xmlSchemaBucketCreate(pctxt, type,
             targetNamespace);
         if (bkt == NULL)
             goto exit_failure;
     }
     if (bkt != NULL) {
         bkt->schemaLocation = schemaLocation;
         bkt->located = located;
         if (doc != NULL) {
             bkt->doc = doc;
             bkt->targetNamespace = targetNamespace;
             bkt->origTargetNamespace = targetNamespace;
             if (preserveDoc)
                 bkt->preserveDoc = 1;
         }
         if (WXS_IS_BUCKET_IMPMAIN(type))
             bkt->imported++;
             /*
             * Add it to the graph of schemas.
             */
         if (relation != NULL)
             relation->bucket = bkt;
     }
-  
+
 exit:
     /*
     * Return the bucket explicitely; this is needed for the
     * main schema.
     */
     if (bucket != NULL)
-        *bucket = bkt;    
+        *bucket = bkt;
     return (0);
 
 exit_error:
     if ((doc != NULL) && (! preserveDoc)) {
         xmlFreeDoc(doc);
         if (bkt != NULL)
             bkt->doc = NULL;
     }
     return(pctxt->err);
 
 exit_failure:
     if ((doc != NULL) && (! preserveDoc)) {
         xmlFreeDoc(doc);
         if (bkt != NULL)
             bkt->doc = NULL;
-    }    
+    }
     return (-1);
 }
 
 /**
  * xmlSchemaParseImport:
  * @ctxt:  a schema validation context
  * @schema:  the schema being built
  * @node:  a subtree containing XML Schema informations
  *
  * parse a XML schema Import definition
@@ skipping 79 matching lines @@
     * Apply additional constraints.
     *
     * Note that it is important to use the original @targetNamespace
     * (or none at all), to rule out imports of schemas _with_ a
     * @targetNamespace if the importing schema is a chameleon schema
     * (with no @targetNamespace).
     */
     thisTargetNamespace = WXS_BUCKET(pctxt)->origTargetNamespace;
     if (namespaceName != NULL) {
         /*
-        * 1.1 If the namespace [attribute] is present, then its ·actual value·
-        * must not match the ·actual value· of the enclosing <schema>'s
+        * 1.1 If the namespace [attribute] is present, then its �actual value�
+        * must not match the �actual value� of the enclosing <schema>'s
         * targetNamespace [attribute].
         */
         if (xmlStrEqual(thisTargetNamespace, namespaceName)) {
             xmlSchemaPCustomErr(pctxt,
                 XML_SCHEMAP_SRC_IMPORT_1_1,
                 NULL, node,
                 "The value of the attribute 'namespace' must not match "
                 "the target namespace '%s' of the importing schema",
                 thisTargetNamespace);
             return (pctxt->err);
@@ skipping 33 matching lines @@
     * Note that we will get no bucket if the schema could not be
     * located or if there was no schemaLocation.
     */
     if ((bucket == NULL) && (schemaLocation != NULL)) {
         xmlSchemaCustomWarning(ACTXT_CAST pctxt,
             XML_SCHEMAP_WARN_UNLOCATED_SCHEMA,
             node, NULL,
             "Failed to locate a schema at location '%s'. "
             "Skipping the import", schemaLocation, NULL, NULL);
     }
-    
-    if ((bucket != NULL) && CAN_PARSE_SCHEMA(bucket)) { 
+
+    if ((bucket != NULL) && CAN_PARSE_SCHEMA(bucket)) {
         ret = xmlSchemaParseNewDoc(pctxt, schema, bucket);
     }
-    
+
     return (ret);
 }
 
 static int
 xmlSchemaParseIncludeOrRedefineAttrs(xmlSchemaParserCtxtPtr pctxt,
                                      xmlSchemaPtr schema,
                                      xmlNodePtr node,
                                      xmlChar **schemaLocation,
                                      int type)
 {
@@ skipping 61 matching lines @@
     }
     /*
     * Report self-inclusion and self-redefinition.
     */
     if (xmlStrEqual(*schemaLocation, pctxt->URL)) {
         if (type == XML_SCHEMA_SCHEMA_REDEFINE) {
             xmlSchemaPCustomErr(pctxt,
                 XML_SCHEMAP_SRC_REDEFINE,
                 NULL, node,
                 "The schema document '%s' cannot redefine itself.",
-                *schemaLocation);           
+                *schemaLocation);
         } else {
             xmlSchemaPCustomErr(pctxt,
                 XML_SCHEMAP_SRC_INCLUDE,
                 NULL, node,
                 "The schema document '%s' cannot include itself.",
                 *schemaLocation);
         }
         goto exit_error;
     }
-    
+
     return(0);
 exit_error:
     return(pctxt->err);
 exit_failure:
     return(-1);
 }
 
 static int
 xmlSchemaParseIncludeOrRedefine(xmlSchemaParserCtxtPtr pctxt,
                                 xmlSchemaPtr schema,
                                 xmlNodePtr node,
                                 int type)
 {
     xmlNodePtr child = NULL;
     const xmlChar *schemaLocation = NULL;
     int res = 0; /* hasRedefinitions = 0 */
     int isChameleon = 0, wasChameleon = 0;
     xmlSchemaBucketPtr bucket = NULL;
 
     if ((pctxt == NULL) || (schema == NULL) || (node == NULL))
         return (-1);
 
     /*
     * Parse attributes. Note that the returned schemaLocation will
     * be already converted to an absolute URI.
     */
     res = xmlSchemaParseIncludeOrRedefineAttrs(pctxt, schema,
         node, (xmlChar **) (&schemaLocation), type);
     if (res != 0)
-        return(res);               
+        return(res);
     /*
     * Load and add the schema document.
     */
     res = xmlSchemaAddSchemaDoc(pctxt, type, schemaLocation, NULL,
         NULL, 0, node, pctxt->targetNamespace, NULL, &bucket);
     if (res != 0)
-        return(res);    
+        return(res);
     /*
     * If we get no schema bucket back, then this means that the schema
     * document could not be located or was broken XML or was not
     * a schema document.
-    */    
+    */
     if ((bucket == NULL) || (bucket->doc == NULL)) {
         if (type == XML_SCHEMA_SCHEMA_INCLUDE) {
             /*
             * WARNING for <include>:
             * We will raise an error if the schema cannot be located
             * for inclusions, since the that was the feedback from the
             * schema people. I.e. the following spec piece will *not* be
             * satisfied:
-            * SPEC src-include: "It is not an error for the ·actual value· of the
+            * SPEC src-include: "It is not an error for the �actual value� of the
             * schemaLocation [attribute] to fail to resolve it all, in which
             * case no corresponding inclusion is performed.
             * So do we need a warning report here?"
             */
             res = XML_SCHEMAP_SRC_INCLUDE;
             xmlSchemaCustomErr(ACTXT_CAST pctxt, res,
                 node, NULL,
                 "Failed to load the document '%s' for inclusion",
                 schemaLocation, NULL);
         } else {
             /*
             * NOTE: This was changed to raise an error even if no redefinitions
             * are specified.
             *
             * SPEC src-redefine (1)
             * "If there are any element information items among the [children]
-            * other than <annotation> then the ·actual value· of the
+            * other than <annotation> then the �actual value� of the
             * schemaLocation [attribute] must successfully resolve."
             * TODO: Ask the WG if a the location has always to resolve
             * here as well!
             */
             res = XML_SCHEMAP_SRC_REDEFINE;
             xmlSchemaCustomErr(ACTXT_CAST pctxt, res,
                 node, NULL,
                 "Failed to load the document '%s' for redefinition",
                 schemaLocation, NULL);
         }
     } else {
         /*
         * Check targetNamespace sanity before parsing the new schema.
         * TODO: Note that we won't check further content if the
         * targetNamespace was bad.
-        */    
-        if (bucket->origTargetNamespace != NULL) {          
+        */
+        if (bucket->origTargetNamespace != NULL) {
             /*
             * SPEC src-include (2.1)
-            * "SII has a targetNamespace [attribute], and its ·actual
-            * value· is identical to the ·actual value· of the targetNamespace
-            * [attribute] of SII’ (which must have such an [attribute])."
+            * "SII has a targetNamespace [attribute], and its �actual
+            * value� is identical to the �actual value� of the targetNamespace
+            * [attribute] of SII� (which must have such an [attribute])."
             */
             if (pctxt->targetNamespace == NULL) {
                 xmlSchemaCustomErr(ACTXT_CAST pctxt,
                     XML_SCHEMAP_SRC_INCLUDE,
                     node, NULL,
                     "The target namespace of the included/redefined schema "
                     "'%s' has to be absent, since the including/redefining "
                     "schema has no target namespace",
                     schemaLocation, NULL);
                 goto exit_error;
             } else if (!xmlStrEqual(bucket->origTargetNamespace,
                 pctxt->targetNamespace)) {
                 /* TODO: Change error function. */
                 xmlSchemaPCustomErrExt(pctxt,
                     XML_SCHEMAP_SRC_INCLUDE,
                     NULL, node,
                     "The target namespace '%s' of the included/redefined "
                     "schema '%s' differs from '%s' of the "
                     "including/redefining schema",
                     bucket->origTargetNamespace, schemaLocation,
                     pctxt->targetNamespace);
                 goto exit_error;
             }
-        } else if (pctxt->targetNamespace != NULL) {        
+        } else if (pctxt->targetNamespace != NULL) {
             /*
             * Chameleons: the original target namespace will
             * differ from the resulting namespace.
             */
             isChameleon = 1;
             if (bucket->parsed &&
-                (bucket->targetNamespace != pctxt->targetNamespace)) {
-                /*
-                * This is a sanity check, I dunno yet if this can happen.
-                */
-                PERROR_INT("xmlSchemaParseIncludeOrRedefine",
-                    "trying to use an already parsed schema for a "
-                    "different targetNamespace");
-                return(-1);
+                bucket->origTargetNamespace != NULL) {
+                xmlSchemaCustomErr(ACTXT_CAST pctxt,
+                    XML_SCHEMAP_SRC_INCLUDE,
+                    node, NULL,
+                    "The target namespace of the included/redefined schema "
+                    "'%s' has to be absent or the same as the "
+                    "including/redefining schema's target namespace",
+                    schemaLocation, NULL);
+                goto exit_error;
             }
             bucket->targetNamespace = pctxt->targetNamespace;
         }
-    }    
+    }
     /*
     * Parse the schema.
-    */   
+    */
     if (bucket && (!bucket->parsed) && (bucket->doc != NULL)) {
         if (isChameleon) {
             /* TODO: Get rid of this flag on the schema itself. */
             if ((schema->flags & XML_SCHEMAS_INCLUDING_CONVERT_NS) == 0) {
                 schema->flags |= XML_SCHEMAS_INCLUDING_CONVERT_NS;
             } else
                 wasChameleon = 1;
         }
         xmlSchemaParseNewDoc(pctxt, schema, bucket);
         /* Restore chameleon flag. */
         if (isChameleon && (!wasChameleon))
             schema->flags ^= XML_SCHEMAS_INCLUDING_CONVERT_NS;
     }
     /*
     * And now for the children...
     */
-    child = node->children;    
-    if (type == XML_SCHEMA_SCHEMA_REDEFINE) {   
+    child = node->children;
+    if (type == XML_SCHEMA_SCHEMA_REDEFINE) {
         /*
         * Parse (simpleType | complexType | group | attributeGroup))*
         */
         pctxt->redefined = bucket;
         /*
         * How to proceed if the redefined schema was not located?
         */
         pctxt->isRedefine = 1;
         while (IS_SCHEMA(child, "annotation") ||
             IS_SCHEMA(child, "simpleType") ||
             IS_SCHEMA(child, "complexType") ||
             IS_SCHEMA(child, "group") ||
             IS_SCHEMA(child, "attributeGroup")) {
             if (IS_SCHEMA(child, "annotation")) {
                 /*
                 * TODO: discard or not?
                 */
             } else if (IS_SCHEMA(child, "simpleType")) {
                 xmlSchemaParseSimpleType(pctxt, schema, child, 1);
             } else if (IS_SCHEMA(child, "complexType")) {
                 xmlSchemaParseComplexType(pctxt, schema, child, 1);
                 /* hasRedefinitions = 1; */
-            } else if (IS_SCHEMA(child, "group")) {             
+            } else if (IS_SCHEMA(child, "group")) {
                 /* hasRedefinitions = 1; */
                 xmlSchemaParseModelGroupDefinition(pctxt,
                     schema, child);
             } else if (IS_SCHEMA(child, "attributeGroup")) {
                 /* hasRedefinitions = 1; */
                 xmlSchemaParseAttributeGroupDefinition(pctxt, schema,
                     child);
             }
             child = child->next;
         }
         pctxt->redefined = NULL;
         pctxt->isRedefine = 0;
     } else {
         if (IS_SCHEMA(child, "annotation")) {
             /*
             * TODO: discard or not?
             */
             child = child->next;
         }
-    }    
+    }
     if (child != NULL) {
         res = XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED;
         if (type == XML_SCHEMA_SCHEMA_REDEFINE) {
             xmlSchemaPContentErr(pctxt, res,
                 NULL, node, child, NULL,
                 "(annotation | (simpleType | complexType | group | attributeGroup))*");
         } else {
              xmlSchemaPContentErr(pctxt, res,
                 NULL, node, child, NULL,
                 "(annotation?)");
-        }       
-    }       
+        }
+    }
     return(res);
 
 exit_error:
     return(pctxt->err);
 }
 
 static int
 xmlSchemaParseRedefine(xmlSchemaParserCtxtPtr pctxt, xmlSchemaPtr schema,
                        xmlNodePtr node)
 {
@@ skipping 29 matching lines @@
  * @node:  a subtree containing XML Schema informations
  * @type: the "compositor" type
  * @particleNeeded: if a a model group with a particle
  *
  * parse a XML schema Sequence definition.
  * Applies parts of:
  *   Schema Representation Constraint:
  *     Redefinition Constraints and Semantics (src-redefine)
  *     (6.1), (6.1.1), (6.1.2)
  *
- *   Schema Component Constraint: 
+ *   Schema Component Constraint:
  *     All Group Limited (cos-all-limited) (2)
  *     TODO: Actually this should go to component-level checks,
  *     but is done here due to performance. Move it to an other layer
  *     is schema construction via an API is implemented.
  *
  * *WARNING* this interface is highly subject to change
  *
  * Returns -1 in case of error, 0 if the declaration is improper and
  *         1 in case of success.
  */
@@ skipping 158 matching lines @@
                     part && part->children)
                 {
                     if ((xmlSchemaGetQNameRefName(part->children) ==
                             ctxt->redef->refName) &&
                         (xmlSchemaGetQNameRefTargetNs(part->children) ==
                             ctxt->redef->refTargetNs))
                     {
                         /*
                         * SPEC src-redefine:
                         * (6.1) "If it has a <group> among its contents at
-                        * some level the ·actual value· of whose ref
-                        * [attribute] is the same as the ·actual value· of
+                        * some level the �actual value� of whose ref
+                        * [attribute] is the same as the �actual value� of
                         * its own name attribute plus target namespace, then
                         * all of the following must be true:"
                         * (6.1.1) "It must have exactly one such group."
                         */
                         if (ctxt->redefCounter != 0) {
                             xmlChar *str = NULL;
 
                             xmlSchemaCustomErr(ACTXT_CAST ctxt,
                                 XML_SCHEMAP_SRC_REDEFINE, child, NULL,
                                 "The redefining model group definition "
                                 "'%s' must not contain more than one "
                                 "reference to the redefined definition",
                                 xmlSchemaFormatQName(&str,
                                     ctxt->redef->refTargetNs,
                                     ctxt->redef->refName),
                                 NULL);
                             FREE_AND_NULL(str)
                             part = NULL;
                         } else if (((WXS_PARTICLE(part))->minOccurs != 1) ||
                             ((WXS_PARTICLE(part))->maxOccurs != 1))
                         {
                             xmlChar *str = NULL;
                             /*
                             * SPEC src-redefine:
-                            * (6.1.2) "The ·actual value· of both that
+                            * (6.1.2) "The �actual value� of both that
                             * group's minOccurs and maxOccurs [attribute]
-                            * must be 1 (or ·absent·).
+                            * must be 1 (or �absent�).
                             */
                             xmlSchemaCustomErr(ACTXT_CAST ctxt,
                                 XML_SCHEMAP_SRC_REDEFINE, child, NULL,
                                 "The redefining model group definition "
                                 "'%s' must not contain a reference to the "
                                 "redefined definition with a "
                                 "maxOccurs/minOccurs other than 1",
                                 xmlSchemaFormatQName(&str,
                                     ctxt->redef->refTargetNs,
                                     ctxt->redef->refName),
                                 NULL);
                             FREE_AND_NULL(str)
                             part = NULL;
                         }
                         ctxt->redef->reference = WXS_BASIC_CAST part;
                         ctxt->redefCounter++;
-                    }                                      
+                    }
                 }
             } else if (IS_SCHEMA(child, "any")) {
                 part = (xmlSchemaTreeItemPtr)
                     xmlSchemaParseAny(ctxt, schema, child);
             } else if (IS_SCHEMA(child, "choice")) {
                 part = xmlSchemaParseModelGroup(ctxt, schema, child,
                     XML_SCHEMA_TYPE_CHOICE, 1);
             } else if (IS_SCHEMA(child, "sequence")) {
                 part = xmlSchemaParseModelGroup(ctxt, schema, child,
                     XML_SCHEMA_TYPE_SEQUENCE, 1);
@@ skipping 16 matching lines @@
     }
     if ((max == 0) && (min == 0))
         return (NULL);
     if (hasRefs) {
         /*
         * We need to resolve references.
         */
         WXS_ADD_PENDING(ctxt, item);
     }
     if (withParticle)
-        return ((xmlSchemaTreeItemPtr) particle);       
+        return ((xmlSchemaTreeItemPtr) particle);
     else
         return ((xmlSchemaTreeItemPtr) item);
 }
 
 /**
  * xmlSchemaParseRestriction:
  * @ctxt:  a schema validation context
  * @schema:  the schema being built
  * @node:  a subtree containing XML Schema informations
  *
@@ skipping 31 matching lines @@
             xmlSchemaPIllegalAttrErr(ctxt,
                 XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
         }
         attr = attr->next;
     }
     /*
     * Extract and validate attributes.
     */
     xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
     /*
-    * Attribute 
+    * Attribute
     */
     /*
     * Extract the base type. The "base" attribute is mandatory if inside
     * a complex type or if redefining.
     *
     * SPEC (1.2) "...otherwise (<restriction> has no <simpleType> "
     * among its [children]), the simple type definition which is
-    * the {content type} of the type definition ·resolved· to by
-    * the ·actual value· of the base [attribute]"
+    * the {content type} of the type definition �resolved� to by
+    * the �actual value� of the base [attribute]"
     */
     if (xmlSchemaPValAttrQName(ctxt, schema, NULL, node, "base",
         &(type->baseNs), &(type->base)) == 0)
     {
         if ((type->base == NULL) && (type->type == XML_SCHEMA_TYPE_COMPLEX)) {
             xmlSchemaPMissingAttrErr(ctxt,
                 XML_SCHEMAP_S4S_ATTR_MISSING,
                 NULL, node, "base", NULL);
         } else if ((ctxt->isRedefine) &&
             (type->flags & XML_SCHEMAS_TYPE_GLOBAL))
         {
             if (type->base == NULL) {
                 xmlSchemaPMissingAttrErr(ctxt,
                     XML_SCHEMAP_S4S_ATTR_MISSING,
                     NULL, node, "base", NULL);
             } else if ((! xmlStrEqual(type->base, type->name)) ||
                 (! xmlStrEqual(type->baseNs, type->targetNamespace)))
             {
                 xmlChar *str1 = NULL, *str2 = NULL;
                 /*
                 * REDEFINE: SPEC src-redefine (5)
                 * "Within the [children], each <simpleType> must have a
-                * <restriction> among its [children] ... the ·actual value· of
-                * whose base [attribute] must be the same as the ·actual value·
+                * <restriction> among its [children] ... the �actual value� of
+                * whose base [attribute] must be the same as the �actual value�
                 * of its own name attribute plus target namespace;"
                 */
                 xmlSchemaPCustomErrExt(ctxt, XML_SCHEMAP_SRC_REDEFINE,
                     NULL, node, "This is a redefinition, but the QName "
                     "value '%s' of the 'base' attribute does not match the "
                     "type's designation '%s'",
                     xmlSchemaFormatQName(&str1, type->baseNs, type->base),
                     xmlSchemaFormatQName(&str2, type->targetNamespace,
                         type->name), NULL);
                 FREE_AND_NULL(str1);
                 FREE_AND_NULL(str2);
                 /* Avoid confusion and erase the values. */
                 type->base = NULL;
                 type->baseNs = NULL;
             }
-        }               
+        }
     }
     /*
     * And now for the children...
     */
     child = node->children;
     if (IS_SCHEMA(child, "annotation")) {
         /*
         * Add the annotation to the simple type ancestor.
         */
         xmlSchemaAddAnnotation((xmlSchemaAnnotItemPtr) type,
@@ skipping 46 matching lines @@
                     schema, child, XML_SCHEMA_TYPE_CHOICE, 1);
             child = child->next;
         } else if (IS_SCHEMA(child, "sequence")) {
             type->subtypes = (xmlSchemaTypePtr)
                 xmlSchemaParseModelGroup(ctxt, schema, child,
                     XML_SCHEMA_TYPE_SEQUENCE, 1);
             child = child->next;
         /*
         * Model group reference <group>.
         */
-        } else if (IS_SCHEMA(child, "group")) {     
+        } else if (IS_SCHEMA(child, "group")) {
             type->subtypes = (xmlSchemaTypePtr)
                 xmlSchemaParseModelGroupDefRef(ctxt, schema, child);
             /*
             * Note that the reference will be resolved in
             * xmlSchemaResolveTypeReferences();
             */
             child = child->next;
         }
     } else if (parentType == XML_SCHEMA_TYPE_SIMPLE_CONTENT) {
         /*
@@ skipping 317 matching lines @@
         * Add the annotation to the complex type ancestor.
         */
         xmlSchemaAddAnnotation((xmlSchemaAnnotItemPtr) type,
             xmlSchemaParseAnnotation(ctxt, child, 1));
         child = child->next;
     }
     if (child == NULL) {
         xmlSchemaPContentErr(ctxt,
             XML_SCHEMAP_S4S_ELEM_MISSING,
             NULL, node, NULL, NULL,
-            "(annotation?, (restriction | extension))");        
+            "(annotation?, (restriction | extension))");
     }
     if (child == NULL) {
         xmlSchemaPContentErr(ctxt,
             XML_SCHEMAP_S4S_ELEM_MISSING,
             NULL, node, NULL, NULL,
-            "(annotation?, (restriction | extension))");        
+            "(annotation?, (restriction | extension))");
     }
     if (IS_SCHEMA(child, "restriction")) {
         xmlSchemaParseRestriction(ctxt, schema, child,
             XML_SCHEMA_TYPE_SIMPLE_CONTENT);
         (*hasRestrictionOrExtension) = 1;
         child = child->next;
     } else if (IS_SCHEMA(child, "extension")) {
         xmlSchemaParseExtension(ctxt, schema, child,
             XML_SCHEMA_TYPE_SIMPLE_CONTENT);
         (*hasRestrictionOrExtension) = 1;
@@ skipping 136 matching lines @@
 
     if (topLevel) {
         attr = xmlSchemaGetPropNode(node, "name");
         if (attr == NULL) {
             xmlSchemaPMissingAttrErr(ctxt,
                 XML_SCHEMAP_S4S_ATTR_MISSING, NULL, node, "name", NULL);
             return (NULL);
         } else if (xmlSchemaPValAttrNode(ctxt, NULL, attr,
             xmlSchemaGetBuiltInType(XML_SCHEMAS_NCNAME), &name) != 0) {
             return (NULL);
-        }       
+        }
     }
 
     if (topLevel == 0) {
         /*
         * Parse as local complex type definition.
         */
 #ifdef ENABLE_NAMED_LOCALS
         snprintf(buf, 39, "#CT%d", ctxt->counter++ + 1);
         type = xmlSchemaAddType(ctxt, schema,
             XML_SCHEMA_TYPE_COMPLEX,
@@ skipping 68 matching lines @@
                         -1,
                         XML_SCHEMAS_TYPE_FINAL_EXTENSION,
                         XML_SCHEMAS_TYPE_FINAL_RESTRICTION,
                         -1, -1, -1) != 0)
                     {
                         xmlSchemaPSimpleTypeErr(ctxt,
                             XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
                             NULL, (xmlNodePtr) attr, NULL,
                             "(#all | List of (extension | restriction))",
                             attrValue, NULL, NULL, NULL);
-                    } else 
+                    } else
                         final = 1;
                 } else if (xmlStrEqual(attr->name, BAD_CAST "block")) {
                     /*
                     * Attribute "block".
                     */
                     attrValue = xmlSchemaGetNodeContent(ctxt,
                         (xmlNodePtr) attr);
                     if (xmlSchemaPValAttrBlockFinal(attrValue, &(type->flags),
                         -1,
                         XML_SCHEMAS_TYPE_BLOCK_EXTENSION,
                         XML_SCHEMAS_TYPE_BLOCK_RESTRICTION,
                         -1, -1, -1) != 0) {
                         xmlSchemaPSimpleTypeErr(ctxt,
                             XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
                             NULL, (xmlNodePtr) attr, NULL,
                             "(#all | List of (extension | restriction)) ",
                             attrValue, NULL, NULL, NULL);
-                    } else 
+                    } else
                         block = 1;
                 } else {
                         xmlSchemaPIllegalAttrErr(ctxt,
                             XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
                 }
             } else {
                 xmlSchemaPIllegalAttrErr(ctxt,
                     XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
             }
         } else if (xmlStrEqual(attr->ns->href, xmlSchemaNs)) {
-            xmlSchemaPIllegalAttrErr(ctxt, 
+            xmlSchemaPIllegalAttrErr(ctxt,
                 XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, NULL, attr);
         }
         attr = attr->next;
     }
     if (! block) {
         /*
         * Apply default "block" values.
         */
         if (schema->flags & XML_SCHEMAS_BLOCK_DEFAULT_RESTRICTION)
             type->flags |= XML_SCHEMAS_TYPE_BLOCK_RESTRICTION;
@@ skipping 38 matching lines @@
         xmlSchemaParseComplexContent(ctxt, schema, child,
             &hasRestrictionOrExtension);
         child = child->next;
     } else {
         /*
         * E.g <complexType><sequence>... or <complexType><attribute>... etc.
         *
         * SPEC
         * "...the third alternative (neither <simpleContent> nor
         * <complexContent>) is chosen. This case is understood as shorthand
-        * for complex content restricting the ·ur-type definition·, and the
+        * for complex content restricting the �ur-type definition�, and the
         * details of the mappings should be modified as necessary.
         */
         type->baseType = xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYTYPE);
         type->flags |= XML_SCHEMAS_TYPE_DERIVATION_METHOD_RESTRICTION;
         /*
         * Parse model groups.
         */
         if (IS_SCHEMA(child, "all")) {
             type->subtypes = (xmlSchemaTypePtr)
                 xmlSchemaParseModelGroup(ctxt, schema, child,
@@ skipping 156 matching lines @@
 {
     xmlSchemaParserCtxtPtr ret;
 
     if ((buffer == NULL) || (size <= 0))
         return (NULL);
     ret = xmlSchemaParserCtxtCreate();
     if (ret == NULL)
         return(NULL);
     ret->buffer = buffer;
     ret->size = size;
-    ret->dict = xmlDictCreate();    
+    ret->dict = xmlDictCreate();
     return (ret);
 }
 
 /**
  * xmlSchemaNewDocParserCtxt:
  * @doc:  a preparsed document tree
  *
  * Create an XML Schemas parse context for that document.
  * NB. The document may be modified during the parsing process.
  *
@@ skipping 22 matching lines @@
  * @ctxt:  the schema parser context
  *
  * Free the resources associated to the schema parser context
  */
 void
 xmlSchemaFreeParserCtxt(xmlSchemaParserCtxtPtr ctxt)
 {
     if (ctxt == NULL)
         return;
     if (ctxt->doc != NULL && !ctxt->preserve)
-        xmlFreeDoc(ctxt->doc);    
+        xmlFreeDoc(ctxt->doc);
     if (ctxt->vctxt != NULL) {
         xmlSchemaFreeValidCtxt(ctxt->vctxt);
     }
     if (ctxt->ownsConstructor && (ctxt->constructor != NULL)) {
         xmlSchemaConstructionCtxtFree(ctxt->constructor);
         ctxt->constructor = NULL;
         ctxt->ownsConstructor = 0;
     }
     if (ctxt->attrProhibs != NULL)
         xmlSchemaItemListFree(ctxt->attrProhibs);
     xmlDictFree(ctxt->dict);
     xmlFree(ctxt);
 }
 
 /************************************************************************
  *                                                                      *
  *                      Building the content models                     *
  *                                                                      *
  ************************************************************************/
 
-static void
+/**
+ * xmlSchemaBuildContentModelForSubstGroup:
+ *
+ * Returns 1 if nillable, 0 otherwise
+ */
+static int
 xmlSchemaBuildContentModelForSubstGroup(xmlSchemaParserCtxtPtr pctxt,
         xmlSchemaParticlePtr particle, int counter, xmlAutomataStatePtr end)
 {
     xmlAutomataStatePtr start, tmp;
     xmlSchemaElementPtr elemDecl, member;
     xmlSchemaSubstGroupPtr substGroup;
     int i;
+    int ret = 0;
 
     elemDecl = (xmlSchemaElementPtr) particle->children;
     /*
     * Wrap the substitution group with a CHOICE.
     */
     start = pctxt->state;
     if (end == NULL)
         end = xmlAutomataNewState(pctxt->am);
     substGroup = xmlSchemaSubstGroupGet(pctxt, elemDecl);
     if (substGroup == NULL) {
         xmlSchemaPErr(pctxt, WXS_ITEM_NODE(particle),
             XML_SCHEMAP_INTERNAL,
             "Internal error: xmlSchemaBuildContentModelForSubstGroup, "
             "declaration is marked having a subst. group but none "
             "available.\n", elemDecl->name, NULL);
-        return;
+        return(0);
     }
     if (counter >= 0) {
         /*
         * NOTE that we put the declaration in, even if it's abstract.
         * However, an error will be raised during *validation* if an element
         * information item shall be validated against an abstract element
         * declaration.
         */
         tmp = xmlAutomataNewCountedTrans(pctxt->am, start, NULL, counter);
         xmlAutomataNewTransition2(pctxt->am, tmp, end,
@@ skipping 17 matching lines @@
         /*
         * Add subst. group members.
         */
         for (i = 0; i < substGroup->members->nbItems; i++) {
             member = (xmlSchemaElementPtr) substGroup->members->items[i];
             /*
             * NOTE: This fixes bug #341150. xmlAutomataNewOnceTrans2()
             *  was incorrectly used instead of xmlAutomataNewTransition2()
             *  (seems like a copy&paste bug from the XML_SCHEMA_TYPE_ALL
             *  section in xmlSchemaBuildAContentModel() ).
-            * TODO: Check if xmlAutomataNewOnceTrans2() was instead 
+            * TODO: Check if xmlAutomataNewOnceTrans2() was instead
             *  intended for the above "counter" section originally. I.e.,
             *  check xs:all with subst-groups.
             *
             * tmp = xmlAutomataNewOnceTrans2(pctxt->am, start, NULL,
             *                  member->name, member->targetNamespace,
             *                  1, 1, member);
             */
             tmp = xmlAutomataNewTransition2(pctxt->am, start, NULL,
-                member->name, member->targetNamespace, member);     
+                member->name, member->targetNamespace, member);
             xmlAutomataNewEpsilon(pctxt->am, tmp, end);
         }
     } else {
         xmlAutomataStatePtr hop;
         int maxOccurs = particle->maxOccurs == UNBOUNDED ?
             UNBOUNDED : particle->maxOccurs - 1;
         int minOccurs = particle->minOccurs < 1 ? 0 : particle->minOccurs - 1;
 
         counter =
             xmlAutomataNewCounter(pctxt->am, minOccurs,
@@ skipping 12 matching lines @@
             member = (xmlSchemaElementPtr) substGroup->members->items[i];
             xmlAutomataNewEpsilon(pctxt->am,
                 xmlAutomataNewTransition2(pctxt->am,
                 start, NULL,
                 member->name, member->targetNamespace, member),
                 hop);
         }
         xmlAutomataNewCountedTrans(pctxt->am, hop, start, counter);
         xmlAutomataNewCounterTrans(pctxt->am, hop, end, counter);
     }
-    if (particle->minOccurs == 0)
+    if (particle->minOccurs == 0) {
         xmlAutomataNewEpsilon(pctxt->am, start, end);
+        ret = 1;
+    }
     pctxt->state = end;
+    return(ret);
 }
 
-static void
+/**
+ * xmlSchemaBuildContentModelForElement:
+ *
+ * Returns 1 if nillable, 0 otherwise
+ */
+static int
 xmlSchemaBuildContentModelForElement(xmlSchemaParserCtxtPtr ctxt,
                                      xmlSchemaParticlePtr particle)
 {
+    int ret = 0;
+
     if (((xmlSchemaElementPtr) particle->children)->flags &
         XML_SCHEMAS_ELEM_SUBST_GROUP_HEAD) {
         /*
         * Substitution groups.
         */
-        xmlSchemaBuildContentModelForSubstGroup(ctxt, particle, -1, NULL);
+        ret = xmlSchemaBuildContentModelForSubstGroup(ctxt, particle, -1, NULL);
     } else {
         xmlSchemaElementPtr elemDecl;
         xmlAutomataStatePtr start;
 
         elemDecl = (xmlSchemaElementPtr) particle->children;
 
         if (elemDecl->flags & XML_SCHEMAS_ELEM_ABSTRACT)
-            return;
+            return(0);
         if (particle->maxOccurs == 1) {
             start = ctxt->state;
             ctxt->state = xmlAutomataNewTransition2(ctxt->am, start, NULL,
                     elemDecl->name, elemDecl->targetNamespace, elemDecl);
         } else if ((particle->maxOccurs >= UNBOUNDED) &&
                    (particle->minOccurs < 2)) {
             /* Special case. */
-            start = ctxt->state;            
+            start = ctxt->state;
             ctxt->state = xmlAutomataNewTransition2(ctxt->am, start, NULL,
-                elemDecl->name, elemDecl->targetNamespace, elemDecl);       
+                elemDecl->name, elemDecl->targetNamespace, elemDecl);
             ctxt->state = xmlAutomataNewTransition2(ctxt->am, ctxt->state, ctxt->state,
-                elemDecl->name, elemDecl->targetNamespace, elemDecl);       
+                elemDecl->name, elemDecl->targetNamespace, elemDecl);
         } else {
             int counter;
             int maxOccurs = particle->maxOccurs == UNBOUNDED ?
                             UNBOUNDED : particle->maxOccurs - 1;
             int minOccurs = particle->minOccurs < 1 ?
                             0 : particle->minOccurs - 1;
 
             start = xmlAutomataNewEpsilon(ctxt->am, ctxt->state, NULL);
             counter = xmlAutomataNewCounter(ctxt->am, minOccurs, maxOccurs);
             ctxt->state = xmlAutomataNewTransition2(ctxt->am, start, NULL,
                 elemDecl->name, elemDecl->targetNamespace, elemDecl);
             xmlAutomataNewCountedTrans(ctxt->am, ctxt->state, start, counter);
             ctxt->state = xmlAutomataNewCounterTrans(ctxt->am, ctxt->state,
                 NULL, counter);
         }
-        if (particle->minOccurs == 0)
+        if (particle->minOccurs == 0) {
             xmlAutomataNewEpsilon(ctxt->am, start, ctxt->state);
+            ret = 1;
+        }
     }
+    return(ret);
 }
 
 /**
  * xmlSchemaBuildAContentModel:
  * @ctxt:  the schema parser context
  * @particle:  the particle component
  * @name:  the complex type's name whose content is being built
  *
  * Create the automaton for the {content type} of a complex type.
  *
+ * Returns 1 if the content is nillable, 0 otherwise
  */
-static void
+static int
 xmlSchemaBuildAContentModel(xmlSchemaParserCtxtPtr pctxt,
                             xmlSchemaParticlePtr particle)
 {
+    int ret = 0, tmp2;
+
     if (particle == NULL) {
-        PERROR_INT("xmlSchemaBuildAContentModel", "particle is NULL");      
-        return;
+        PERROR_INT("xmlSchemaBuildAContentModel", "particle is NULL");
+        return(1);
     }
     if (particle->children == NULL) {
         /*
         * Just return in this case. A missing "term" of the particle
         * might arise due to an invalid "term" component.
         */
-        return;
+        return(1);
     }
 
     switch (particle->children->type) {
         case XML_SCHEMA_TYPE_ANY: {
             xmlAutomataStatePtr start, end;
             xmlSchemaWildcardPtr wild;
             xmlSchemaWildcardNsPtr ns;
 
             wild = (xmlSchemaWildcardPtr) particle->children;
 
@@ skipping 31 matching lines @@
 
                 } else if (wild->negNsSet != NULL) {
                     pctxt->state = xmlAutomataNewNegTrans(pctxt->am,
                         start, end, BAD_CAST "*", wild->negNsSet->value,
                         wild);
                 }
             } else {
                 int counter;
                 xmlAutomataStatePtr hop;
                 int maxOccurs =
-                    particle->maxOccurs == UNBOUNDED ? UNBOUNDED : particle->maxOccurs - 1;
+                    particle->maxOccurs == UNBOUNDED ? UNBOUNDED :
+                                           particle->maxOccurs - 1;
                 int minOccurs =
                     particle->minOccurs < 1 ? 0 : particle->minOccurs - 1;
 
                 counter = xmlAutomataNewCounter(pctxt->am, minOccurs, maxOccurs);
                 hop = xmlAutomataNewState(pctxt->am);
                 if (wild->any == 1) {
                     pctxt->state =
                         xmlAutomataNewTransition2(pctxt->am,
                         start, NULL, BAD_CAST "*", BAD_CAST "*", wild);
                     xmlAutomataNewEpsilon(pctxt->am, pctxt->state, hop);
@@ skipping 14 matching lines @@
                 } else if (wild->negNsSet != NULL) {
                     pctxt->state = xmlAutomataNewNegTrans(pctxt->am,
                         start, hop, BAD_CAST "*", wild->negNsSet->value,
                         wild);
                 }
                 xmlAutomataNewCountedTrans(pctxt->am, hop, start, counter);
                 xmlAutomataNewCounterTrans(pctxt->am, hop, end, counter);
             }
             if (particle->minOccurs == 0) {
                 xmlAutomataNewEpsilon(pctxt->am, start, end);
+                ret = 1;
             }
             pctxt->state = end;
             break;
         }
         case XML_SCHEMA_TYPE_ELEMENT:
-            xmlSchemaBuildContentModelForElement(pctxt, particle);
+            ret = xmlSchemaBuildContentModelForElement(pctxt, particle);
             break;
         case XML_SCHEMA_TYPE_SEQUENCE:{
-                xmlSchemaTreeItemPtr sub;
-
-                /*
-                 * If max and min occurances are default (1) then
-                 * simply iterate over the particles of the <sequence>.
-                 */
-                if ((particle->minOccurs == 1) && (particle->maxOccurs == 1)) {
-                    sub = particle->children->children;
-                    while (sub != NULL) {
-                        xmlSchemaBuildAContentModel(pctxt,
-                            (xmlSchemaParticlePtr) sub);
-                        sub = sub->next;
-                    }
-                } else {
-                    xmlAutomataStatePtr oldstate = pctxt->state;
-
-                    if (particle->maxOccurs >= UNBOUNDED) {
-                        if (particle->minOccurs > 1) {
-                            xmlAutomataStatePtr tmp;
-                            int counter;
-
-                            pctxt->state = xmlAutomataNewEpsilon(pctxt->am,
-                                oldstate, NULL);
-                            oldstate = pctxt->state;
-
-                            counter = xmlAutomataNewCounter(pctxt->am,
-                                particle->minOccurs - 1, UNBOUNDED);
-
-                            sub = particle->children->children;
-                            while (sub != NULL) {
-                                xmlSchemaBuildAContentModel(pctxt,
-                                    (xmlSchemaParticlePtr) sub);
-                                sub = sub->next;
-                            }
-                            tmp = pctxt->state;
-                            xmlAutomataNewCountedTrans(pctxt->am, tmp,
-                                                       oldstate, counter);
-                            pctxt->state =
-                                xmlAutomataNewCounterTrans(pctxt->am, tmp,
-                                                           NULL, counter);
-
-                        } else {
-                            pctxt->state = xmlAutomataNewEpsilon(pctxt->am,
-                                oldstate, NULL);
-                            oldstate = pctxt->state;
-
-                            sub = particle->children->children;
-                            while (sub != NULL) {
-                                xmlSchemaBuildAContentModel(pctxt,
-                                    (xmlSchemaParticlePtr) sub);
-                                sub = sub->next;
-                            }
-                            xmlAutomataNewEpsilon(pctxt->am, pctxt->state,
-                                                  oldstate);
-                            /*
-                             * epsilon needed to block previous trans from
-                             * being allowed to enter back from another
-                             * construct
-                             */
-                            pctxt->state = xmlAutomataNewEpsilon(pctxt->am,
-                                                pctxt->state, NULL);
-                            if (particle->minOccurs == 0) {
-                                xmlAutomataNewEpsilon(pctxt->am,
-                                    oldstate, pctxt->state);
-                            }
-                        }
-                    } else if ((particle->maxOccurs > 1)
-                               || (particle->minOccurs > 1)) {
+            xmlSchemaTreeItemPtr sub;
+
+            ret = 1;
+            /*
+             * If max and min occurances are default (1) then
+             * simply iterate over the particles of the <sequence>.
+             */
+            if ((particle->minOccurs == 1) && (particle->maxOccurs == 1)) {
+                sub = particle->children->children;
+
+                while (sub != NULL) {
+                    tmp2 = xmlSchemaBuildAContentModel(pctxt,
+                                        (xmlSchemaParticlePtr) sub);
+                    if (tmp2 != 1) ret = 0;
+                    sub = sub->next;
+                }
+            } else {
+                xmlAutomataStatePtr oldstate = pctxt->state;
+
+                if (particle->maxOccurs >= UNBOUNDED) {
+                    if (particle->minOccurs > 1) {
                         xmlAutomataStatePtr tmp;
                         int counter;
 
                         pctxt->state = xmlAutomataNewEpsilon(pctxt->am,
-                            oldstate, NULL);
+                            oldstate, NULL);
                         oldstate = pctxt->state;
 
                         counter = xmlAutomataNewCounter(pctxt->am,
-                            particle->minOccurs - 1,
-                            particle->maxOccurs - 1);
+                            particle->minOccurs - 1, UNBOUNDED);
 
                         sub = particle->children->children;
                         while (sub != NULL) {
-                            xmlSchemaBuildAContentModel(pctxt,
-                                (xmlSchemaParticlePtr) sub);
+                            tmp2 = xmlSchemaBuildAContentModel(pctxt,
+                                            (xmlSchemaParticlePtr) sub);
+                            if (tmp2 != 1) ret = 0;
                             sub = sub->next;
                         }
                         tmp = pctxt->state;
-                        xmlAutomataNewCountedTrans(pctxt->am,
-                            tmp, oldstate, counter);
+                        xmlAutomataNewCountedTrans(pctxt->am, tmp,
+                                                   oldstate, counter);
                         pctxt->state =
-                            xmlAutomataNewCounterTrans(pctxt->am, tmp, NULL,
-                                                       counter);
+                            xmlAutomataNewCounterTrans(pctxt->am, tmp,
+                                                       NULL, counter);
+                        if (ret == 1)
+                            xmlAutomataNewEpsilon(pctxt->am,
+                                                oldstate, pctxt->state);
+
+                    } else {
+                        pctxt->state = xmlAutomataNewEpsilon(pctxt->am,
+                            oldstate, NULL);
+                        oldstate = pctxt->state;
+
+                        sub = particle->children->children;
+                        while (sub != NULL) {
+                            tmp2 = xmlSchemaBuildAContentModel(pctxt,
+                                        (xmlSchemaParticlePtr) sub);
+                            if (tmp2 != 1) ret = 0;
+                            sub = sub->next;
+                        }
+                        xmlAutomataNewEpsilon(pctxt->am, pctxt->state,
+                                              oldstate);
+                        /*
+                         * epsilon needed to block previous trans from
+                         * being allowed to enter back from another
+                         * construct
+                         */
+                        pctxt->state = xmlAutomataNewEpsilon(pctxt->am,
+                                            pctxt->state, NULL);
                         if (particle->minOccurs == 0) {
                             xmlAutomataNewEpsilon(pctxt->am,
-                                oldstate, pctxt->state);
+                                oldstate, pctxt->state);
+                            ret = 1;
                         }
-                    } else {
-                        sub = particle->children->children;
-                        while (sub != NULL) {
-                            xmlSchemaBuildAContentModel(pctxt,
-                                (xmlSchemaParticlePtr) sub);
-                            sub = sub->next;
-                        }
-                        if (particle->minOccurs == 0) {
-                            xmlAutomataNewEpsilon(pctxt->am, oldstate,
-                                                  pctxt->state);
-                        }
-                    }
-                }
-                break;
-            }
+                    }
+                } else if ((particle->maxOccurs > 1)
+                           || (particle->minOccurs > 1)) {
+                    xmlAutomataStatePtr tmp;
+                    int counter;
+
+                    pctxt->state = xmlAutomataNewEpsilon(pctxt->am,
+                        oldstate, NULL);
+                    oldstate = pctxt->state;
+
+                    counter = xmlAutomataNewCounter(pctxt->am,
+                        particle->minOccurs - 1,
+                        particle->maxOccurs - 1);
+
+                    sub = particle->children->children;
+                    while (sub != NULL) {
+                        tmp2 = xmlSchemaBuildAContentModel(pctxt,
+                                        (xmlSchemaParticlePtr) sub);
+                        if (tmp2 != 1) ret = 0;
+                        sub = sub->next;
+                    }
+                    tmp = pctxt->state;
+                    xmlAutomataNewCountedTrans(pctxt->am,
+                        tmp, oldstate, counter);
+                    pctxt->state =
+                        xmlAutomataNewCounterTrans(pctxt->am, tmp, NULL,
+                                                   counter);
+                    if ((particle->minOccurs == 0) || (ret == 1)) {
+                        xmlAutomataNewEpsilon(pctxt->am,
+                                            oldstate, pctxt->state);
+                        ret = 1;
+                    }
+                } else {
+                    sub = particle->children->children;
+                    while (sub != NULL) {
+                        tmp2 = xmlSchemaBuildAContentModel(pctxt,
+                                        (xmlSchemaParticlePtr) sub);
+                        if (tmp2 != 1) ret = 0;
+                        sub = sub->next;
+                    }
+                    if (particle->minOccurs == 0) {
+                        xmlAutomataNewEpsilon(pctxt->am, oldstate,
+                                              pctxt->state);
+                        ret = 1;
+                    }
+                }
+            }
+            break;
+        }
         case XML_SCHEMA_TYPE_CHOICE:{
-                xmlSchemaTreeItemPtr sub;
-                xmlAutomataStatePtr start, end;
-
-                start = pctxt->state;
-                end = xmlAutomataNewState(pctxt->am);
-
-                /*
-                 * iterate over the subtypes and remerge the end with an
-                 * epsilon transition
-                 */
-                if (particle->maxOccurs == 1) {
-                    sub = particle->children->children;
-                    while (sub != NULL) {
-                        pctxt->state = start;
-                        xmlSchemaBuildAContentModel(pctxt,
-                            (xmlSchemaParticlePtr) sub);
-                        xmlAutomataNewEpsilon(pctxt->am, pctxt->state, end);
-                        sub = sub->next;
-                    }
-                } else {
-                    int counter;
-                    xmlAutomataStatePtr hop, base;
-                    int maxOccurs = particle->maxOccurs == UNBOUNDED ?
-                        UNBOUNDED : particle->maxOccurs - 1;
-                    int minOccurs =
-                        particle->minOccurs < 1 ? 0 : particle->minOccurs - 1;
-
-                    /*
-                     * use a counter to keep track of the number of transtions
-                     * which went through the choice.
-                     */
-                    counter =
-                        xmlAutomataNewCounter(pctxt->am, minOccurs, maxOccurs);
-                    hop = xmlAutomataNewState(pctxt->am);
-                    base = xmlAutomataNewState(pctxt->am);
-
-                    sub = particle->children->children;
-                    while (sub != NULL) {
-                        pctxt->state = base;
-                        xmlSchemaBuildAContentModel(pctxt,
-                            (xmlSchemaParticlePtr) sub);
-                        xmlAutomataNewEpsilon(pctxt->am, pctxt->state, hop);
-                        sub = sub->next;
-                    }
-                    xmlAutomataNewEpsilon(pctxt->am, start, base);
-                    xmlAutomataNewCountedTrans(pctxt->am, hop, base, counter);
-                    xmlAutomataNewCounterTrans(pctxt->am, hop, end, counter);
-                }
-                if (particle->minOccurs == 0) {
-                    xmlAutomataNewEpsilon(pctxt->am, start, end);
-                }
-                pctxt->state = end;
-                break;
-            }
-        case XML_SCHEMA_TYPE_ALL:{
-                xmlAutomataStatePtr start;
-                xmlSchemaParticlePtr sub;
-                xmlSchemaElementPtr elemDecl;
-                int lax;
-
-                sub = (xmlSchemaParticlePtr) particle->children->children;
-                if (sub == NULL)
-                    break;
-                start = pctxt->state;
+            xmlSchemaTreeItemPtr sub;
+            xmlAutomataStatePtr start, end;
+
+            ret = 0;
+            start = pctxt->state;
+            end = xmlAutomataNewState(pctxt->am);
+
+            /*
+             * iterate over the subtypes and remerge the end with an
+             * epsilon transition
+             */
+            if (particle->maxOccurs == 1) {
+                sub = particle->children->children;
                 while (sub != NULL) {
                     pctxt->state = start;
-
-                    elemDecl = (xmlSchemaElementPtr) sub->children;
-                    if (elemDecl == NULL) {
-                        PERROR_INT("xmlSchemaBuildAContentModel",
-                            "<element> particle has no term");
-                        return;
-                    };
-                    /*
-                    * NOTE: The {max occurs} of all the particles in the
-                    * {particles} of the group must be 0 or 1; this is
-                    * already ensured during the parse of the content of
-                    * <all>.
-                    */
-                    if (elemDecl->flags & XML_SCHEMAS_ELEM_SUBST_GROUP_HEAD) {
-                        int counter;
-
-                        /*
-                         * This is an abstract group, we need to share
-                         * the same counter for all the element transitions
-                         * derived from the group
-                         */
-                        counter = xmlAutomataNewCounter(pctxt->am,
-                                           sub->minOccurs, sub->maxOccurs);
-                        xmlSchemaBuildContentModelForSubstGroup(pctxt,
-                                           sub, counter, pctxt->state);
-                    } else {
-                        if ((sub->minOccurs == 1) &&
-                            (sub->maxOccurs == 1)) {
-                            xmlAutomataNewOnceTrans2(pctxt->am, pctxt->state,
-                                                    pctxt->state,
-                                                    elemDecl->name,
-                                                    elemDecl->targetNamespace,
-                                                    1, 1, elemDecl);
-                        } else if ((sub->minOccurs == 0) &&
-                            (sub->maxOccurs == 1)) {
-
-                            xmlAutomataNewCountTrans2(pctxt->am, pctxt->state,
-                                                     pctxt->state,
-                                                     elemDecl->name,
-                                                     elemDecl->targetNamespace,
-                                                     0,
-                                                     1,
-                                                     elemDecl);
-                        }
-                    }
-                    sub = (xmlSchemaParticlePtr) sub->next;
-                }
-                lax = particle->minOccurs == 0;
-                pctxt->state =
-                    xmlAutomataNewAllTrans(pctxt->am, pctxt->state, NULL, lax);
+                    tmp2 = xmlSchemaBuildAContentModel(pctxt,
+                                        (xmlSchemaParticlePtr) sub);
+                    if (tmp2 == 1) ret = 1;
+                    xmlAutomataNewEpsilon(pctxt->am, pctxt->state, end);
+                    sub = sub->next;
+                }
+            } else {
+                int counter;
+                xmlAutomataStatePtr hop, base;
+                int maxOccurs = particle->maxOccurs == UNBOUNDED ?
+                    UNBOUNDED : particle->maxOccurs - 1;
+                int minOccurs =
+                    particle->minOccurs < 1 ? 0 : particle->minOccurs - 1;
+
+                /*
+                 * use a counter to keep track of the number of transtions
+                 * which went through the choice.
+                 */
+                counter =
+                    xmlAutomataNewCounter(pctxt->am, minOccurs, maxOccurs);
+                hop = xmlAutomataNewState(pctxt->am);
+                base = xmlAutomataNewState(pctxt->am);
+
+                sub = particle->children->children;
+                while (sub != NULL) {
+                    pctxt->state = base;
+                    tmp2 = xmlSchemaBuildAContentModel(pctxt,
+                                        (xmlSchemaParticlePtr) sub);
+                    if (tmp2 == 1) ret = 1;
+                    xmlAutomataNewEpsilon(pctxt->am, pctxt->state, hop);
+                    sub = sub->next;
+                }
+                xmlAutomataNewEpsilon(pctxt->am, start, base);
+                xmlAutomataNewCountedTrans(pctxt->am, hop, base, counter);
+                xmlAutomataNewCounterTrans(pctxt->am, hop, end, counter);
+                if (ret == 1)
+                    xmlAutomataNewEpsilon(pctxt->am, base, end);
+            }
+            if (particle->minOccurs == 0) {
+                xmlAutomataNewEpsilon(pctxt->am, start, end);
+                ret = 1;
+            }
+            pctxt->state = end;
+            break;
+        }
+        case XML_SCHEMA_TYPE_ALL:{
+            xmlAutomataStatePtr start, tmp;
+            xmlSchemaParticlePtr sub;
+            xmlSchemaElementPtr elemDecl;
+
+            ret = 1;
+
+            sub = (xmlSchemaParticlePtr) particle->children->children;
+            if (sub == NULL)
                 break;
-            }
+
+            ret = 0;
+
+            start = pctxt->state;
+            tmp = xmlAutomataNewState(pctxt->am);
+            xmlAutomataNewEpsilon(pctxt->am, pctxt->state, tmp);
+            pctxt->state = tmp;
+            while (sub != NULL) {
+                pctxt->state = tmp;
+
+                elemDecl = (xmlSchemaElementPtr) sub->children;
+                if (elemDecl == NULL) {
+                    PERROR_INT("xmlSchemaBuildAContentModel",
+                        "<element> particle has no term");
+                    return(ret);
+                };
+                /*
+                * NOTE: The {max occurs} of all the particles in the
+                * {particles} of the group must be 0 or 1; this is
+                * already ensured during the parse of the content of
+                * <all>.
+                */
+                if (elemDecl->flags & XML_SCHEMAS_ELEM_SUBST_GROUP_HEAD) {
+                    int counter;
+
+                    /*
+                     * This is an abstract group, we need to share
+                     * the same counter for all the element transitions
+                     * derived from the group
+                     */
+                    counter = xmlAutomataNewCounter(pctxt->am,
+                                       sub->minOccurs, sub->maxOccurs);
+                    xmlSchemaBuildContentModelForSubstGroup(pctxt,
+                                       sub, counter, pctxt->state);
+                } else {
+                    if ((sub->minOccurs == 1) &&
+                        (sub->maxOccurs == 1)) {
+                        xmlAutomataNewOnceTrans2(pctxt->am, pctxt->state,
+                                                pctxt->state,
+                                                elemDecl->name,
+                                                elemDecl->targetNamespace,
+                                                1, 1, elemDecl);
+                    } else if ((sub->minOccurs == 0) &&
+                        (sub->maxOccurs == 1)) {
+
+                        xmlAutomataNewCountTrans2(pctxt->am, pctxt->state,
+                                                 pctxt->state,
+                                                 elemDecl->name,
+                                                 elemDecl->targetNamespace,
+                                                 0,
+                                                 1,
+                                                 elemDecl);
+                    }
+                }
+                sub = (xmlSchemaParticlePtr) sub->next;
+            }
+            pctxt->state =
+                xmlAutomataNewAllTrans(pctxt->am, pctxt->state, NULL, 0);
+            if (particle->minOccurs == 0) {
+                xmlAutomataNewEpsilon(pctxt->am, start, pctxt->state);
+                ret = 1;
+            }
+            break;
+        }
         case XML_SCHEMA_TYPE_GROUP:
             /*
             * If we hit a model group definition, then this means that
             * it was empty, thus was not substituted for the containing
             * model group. Just do nothing in this case.
             * TODO: But the group should be substituted and not occur at
             * all in the content model at this point. Fix this.
             */
+            ret = 1;
             break;
         default:
             xmlSchemaInternalErr2(ACTXT_CAST pctxt,
                 "xmlSchemaBuildAContentModel",
                 "found unexpected term of type '%s' in content model",
                 WXS_ITEM_TYPE_NAME(particle->children), NULL);
-            return;
+            return(ret);
     }
+    return(ret);
 }
 
 /**
  * xmlSchemaBuildContentModel:
  * @ctxt:  the schema parser context
  * @type:  the complex type definition
  * @name:  the element name
  *
  * Builds the content model of the complex type.
  */
@@ skipping 63 matching lines @@
 {
     if ((ctxt == NULL) || (elemDecl == NULL) ||
         ((elemDecl != NULL) &&
         (elemDecl->flags & XML_SCHEMAS_ELEM_INTERNAL_RESOLVED)))
         return;
     elemDecl->flags |= XML_SCHEMAS_ELEM_INTERNAL_RESOLVED;
 
     if ((elemDecl->subtypes == NULL) && (elemDecl->namedType != NULL)) {
         xmlSchemaTypePtr type;
 
-        /* (type definition) ... otherwise the type definition ·resolved·
-        * to by the ·actual value· of the type [attribute] ...
+        /* (type definition) ... otherwise the type definition �resolved�
+        * to by the �actual value� of the type [attribute] ...
         */
         type = xmlSchemaGetType(ctxt->schema, elemDecl->namedType,
             elemDecl->namedTypeNs);
         if (type == NULL) {
             xmlSchemaPResCompAttrErr(ctxt,
                 XML_SCHEMAP_SRC_RESOLVE,
                 WXS_BASIC_CAST elemDecl, elemDecl->node,
                 "type", elemDecl->namedType, elemDecl->namedTypeNs,
                 XML_SCHEMA_TYPE_BASIC, "type definition");
         } else
@@ skipping 17 matching lines @@
         } else {
             xmlSchemaResolveElementReferences(substHead, ctxt);
             /*
             * Set the "substitution group affiliation".
             * NOTE that now we use the "refDecl" field for this.
             */
             WXS_SUBST_HEAD(elemDecl) = substHead;
             /*
             * The type definitions is set to:
             * SPEC "...the {type definition} of the element
-            * declaration ·resolved· to by the ·actual value·
+            * declaration �resolved� to by the �actual value�
             * of the substitutionGroup [attribute], if present"
             */
             if (elemDecl->subtypes == NULL)
                 elemDecl->subtypes = substHead->subtypes;
         }
     }
     /*
     * SPEC "The definition of anyType serves as the default type definition
     * for element declarations whose XML representation does not specify one."
     */
@@ skipping 17 matching lines @@
 static int
 xmlSchemaResolveUnionMemberTypes(xmlSchemaParserCtxtPtr ctxt,
                                  xmlSchemaTypePtr type)
 {
 
     xmlSchemaTypeLinkPtr link, lastLink, newLink;
     xmlSchemaTypePtr memberType;
 
     /*
     * SPEC (1) "If the <union> alternative is chosen, then [Definition:]
-    * define the explicit members as the type definitions ·resolved·
-    * to by the items in the ·actual value· of the memberTypes [attribute],
+    * define the explicit members as the type definitions �resolved�
+    * to by the items in the �actual value� of the memberTypes [attribute],
     * if any, followed by the type definitions corresponding to the
     * <simpleType>s among the [children] of <union>, if any."
     */
     /*
     * Resolve references.
     */
     link = type->memberTypes;
     lastLink = NULL;
     while (link != NULL) {
         const xmlChar *name, *nsName;
@@ skipping 92 matching lines @@
         return (0);
     if (type->type == XML_SCHEMA_TYPE_BASIC) {
         if (type->builtInType == valType)
             return(1);
         return (0);
     } else
         return(xmlSchemaIsDerivedFromBuiltInType(type->subtypes, valType));
 
     return (0);
 }
-#endif
 
 static xmlSchemaTypePtr
 xmlSchemaQueryBuiltInType(xmlSchemaTypePtr type)
 {
     if (type == NULL)
         return (NULL);
     if (WXS_IS_COMPLEX(type))
         return (NULL);
     if (type->type == XML_SCHEMA_TYPE_BASIC)
         return(type);
     return(xmlSchemaQueryBuiltInType(type->subtypes));
 }
+#endif
 
 /**
  * xmlSchemaGetPrimitiveType:
  * @type:  the simpleType definition
  *
  * Returns the primitive type of the given type or
  * NULL in case of error.
  */
 static xmlSchemaTypePtr
 xmlSchemaGetPrimitiveType(xmlSchemaTypePtr type)
@@ skipping 149 matching lines @@
                 completeWild->nsSet = NULL;
             }
             if (completeWild->negNsSet != NULL) {
                 xmlFree(completeWild->negNsSet);
                 completeWild->negNsSet = NULL;
             }
         }
         return (0);
     }
     /*
-    * 3 If both O1 and O2 are sets of (namespace names or ·absent·),
+    * 3 If both O1 and O2 are sets of (namespace names or �absent�),
     * then the union of those sets must be the value.
     */
     if ((completeWild->nsSet != NULL) && (curWild->nsSet != NULL)) {
         int found;
         xmlSchemaWildcardNsPtr start;
 
         cur = curWild->nsSet;
         start = completeWild->nsSet;
         while (cur != NULL) {
             found = 0;
@@ skipping 13 matching lines @@
                 tmp->next = completeWild->nsSet;
                 completeWild->nsSet = tmp;
             }
             cur = cur->next;
         }
 
         return(0);
     }
     /*
     * 4 If the two are negations of different values (namespace names
-    * or ·absent·), then a pair of not and ·absent· must be the value.
+    * or �absent�), then a pair of not and �absent� must be the value.
     */
     if ((completeWild->negNsSet != NULL) &&
         (curWild->negNsSet != NULL) &&
         (completeWild->negNsSet->value != curWild->negNsSet->value)) {
         completeWild->negNsSet->value = NULL;
 
         return(0);
     }
     /*
      * 5.
@@ skipping 21 matching lines @@
             else if (cur->value == curB->value)
                 nsFound = 1;
             if (nsFound && absentFound)
                 break;
             cur = cur->next;
         }
 
         if (nsFound && absentFound) {
             /*
             * 5.1 If the set S includes both the negated namespace
-            * name and ·absent·, then any must be the value.
+            * name and �absent�, then any must be the value.
             */
             completeWild->any = 1;
             if (completeWild->nsSet != NULL) {
                 xmlSchemaFreeWildcardNsSet(completeWild->nsSet);
                 completeWild->nsSet = NULL;
             }
             if (completeWild->negNsSet != NULL) {
                 xmlFree(completeWild->negNsSet);
                 completeWild->negNsSet = NULL;
             }
         } else if (nsFound && (!absentFound)) {
             /*
             * 5.2 If the set S includes the negated namespace name
-            * but not ·absent·, then a pair of not and ·absent· must
+            * but not �absent�, then a pair of not and �absent� must
             * be the value.
             */
             if (completeWild->nsSet != NULL) {
                 xmlSchemaFreeWildcardNsSet(completeWild->nsSet);
                 completeWild->nsSet = NULL;
             }
             if (completeWild->negNsSet == NULL) {
                 completeWild->negNsSet = xmlSchemaNewWildcardNsConstraint(ctxt);
                 if (completeWild->negNsSet == NULL)
                     return (-1);
             }
             completeWild->negNsSet->value = NULL;
         } else if ((!nsFound) && absentFound) {
             /*
-            * 5.3 If the set S includes ·absent· but not the negated
+            * 5.3 If the set S includes �absent� but not the negated
             * namespace name, then the union is not expressible.
             */
             xmlSchemaPErr(ctxt, completeWild->node,
                 XML_SCHEMAP_UNION_NOT_EXPRESSIBLE,
                 "The union of the wilcard is not expressible.\n",
                 NULL, NULL);
             return(XML_SCHEMAP_UNION_NOT_EXPRESSIBLE);
         } else if ((!nsFound) && (!absentFound)) {
             /*
             * 5.4 If the set S does not include either the negated namespace
-            * name or ·absent·, then whichever of O1 or O2 is a pair of not
+            * name or �absent�, then whichever of O1 or O2 is a pair of not
             * and a namespace name must be the value.
             */
             if (completeWild->negNsSet == NULL) {
                 if (completeWild->nsSet != NULL) {
                     xmlSchemaFreeWildcardNsSet(completeWild->nsSet);
                     completeWild->nsSet = NULL;
                 }
                 completeWild->negNsSet = xmlSchemaNewWildcardNsConstraint(ctxt);
                 if (completeWild->negNsSet == NULL)
                     return (-1);
@@ skipping 13 matching lines @@
         (completeWild->nsSet != NULL))) {
 
         if (completeWild->nsSet != NULL) {
             cur = completeWild->nsSet;
         } else {
             cur = curWild->nsSet;
         }
         while (cur != NULL) {
             if (cur->value == NULL) {
                 /*
-                * 6.1 If the set S includes ·absent·, then any must be the
+                * 6.1 If the set S includes �absent�, then any must be the
                 * value.
                 */
                 completeWild->any = 1;
                 if (completeWild->nsSet != NULL) {
                     xmlSchemaFreeWildcardNsSet(completeWild->nsSet);
                     completeWild->nsSet = NULL;
                 }
                 if (completeWild->negNsSet != NULL) {
                     xmlFree(completeWild->negNsSet);
                     completeWild->negNsSet = NULL;
                 }
                 return (0);
             }
             cur = cur->next;
         }
         if (completeWild->negNsSet == NULL) {
             /*
-            * 6.2 If the set S does not include ·absent·, then a pair of not
-            * and ·absent· must be the value.
+            * 6.2 If the set S does not include �absent�, then a pair of not
+            * and �absent� must be the value.
             */
             if (completeWild->nsSet != NULL) {
                 xmlSchemaFreeWildcardNsSet(completeWild->nsSet);
                 completeWild->nsSet = NULL;
             }
             completeWild->negNsSet = xmlSchemaNewWildcardNsConstraint(ctxt);
             if (completeWild->negNsSet == NULL)
                 return (-1);
             completeWild->negNsSet->value = NULL;
         }
@@ skipping 62 matching lines @@
     /*
     * 2 If either O1 or O2 is any, then the other must be the value.
     */
     if ((completeWild->any != curWild->any) && (completeWild->any)) {
         if (xmlSchemaCloneWildcardNsConstraints(ctxt, completeWild, curWild) == -1)
             return(-1);
         return(0);
     }
     /*
     * 3 If either O1 or O2 is a pair of not and a value (a namespace
-    * name or ·absent·) and the other is a set of (namespace names or
-    * ·absent·), then that set, minus the negated value if it was in
-    * the set, minus ·absent· if it was in the set, must be the value.
+    * name or �absent�) and the other is a set of (namespace names or
+    * �absent�), then that set, minus the negated value if it was in
+    * the set, minus �absent� if it was in the set, must be the value.
     */
     if (((completeWild->negNsSet != NULL) && (curWild->nsSet != NULL)) ||
         ((curWild->negNsSet != NULL) && (completeWild->nsSet != NULL))) {
         const xmlChar *neg;
 
         if (completeWild->nsSet == NULL) {
             neg = completeWild->negNsSet->value;
             if (xmlSchemaCloneWildcardNsConstraints(ctxt, completeWild, curWild) == -1)
                 return(-1);
         } else
@@ skipping 28 matching lines @@
                     break;
                 }
                 prev = cur;
                 cur = cur->next;
             }
         }
 
         return(0);
     }
     /*
-    * 4 If both O1 and O2 are sets of (namespace names or ·absent·),
+    * 4 If both O1 and O2 are sets of (namespace names or �absent�),
     * then the intersection of those sets must be the value.
     */
     if ((completeWild->nsSet != NULL) && (curWild->nsSet != NULL)) {
         int found;
 
         cur = completeWild->nsSet;
         prev = NULL;
         while (cur != NULL) {
             found = 0;
             curB = curWild->nsSet;
@@ skipping 29 matching lines @@
         (completeWild->negNsSet->value != NULL) &&
         (curWild->negNsSet->value != NULL)) {
 
         xmlSchemaPErr(ctxt, completeWild->node, XML_SCHEMAP_INTERSECTION_NOT_EXPRESSIBLE,
             "The intersection of the wilcard is not expressible.\n",
             NULL, NULL);
         return(XML_SCHEMAP_INTERSECTION_NOT_EXPRESSIBLE);
     }
     /*
     * 6 If the one is a negation of a namespace name and the other
-    * is a negation of ·absent·, then the one which is the negation
+    * is a negation of �absent�, then the one which is the negation
     * of a namespace name must be the value.
     */
     if ((completeWild->negNsSet != NULL) && (curWild->negNsSet != NULL) &&
         (completeWild->negNsSet->value != curWild->negNsSet->value) &&
         (completeWild->negNsSet->value == NULL)) {
         completeWild->negNsSet->value =  curWild->negNsSet->value;
     }
     return(0);
 }
 
@@ skipping 11 matching lines @@
 static int
 xmlSchemaCheckCOSNSSubset(xmlSchemaWildcardPtr sub,
                           xmlSchemaWildcardPtr super)
 {
     /*
     * 1 super must be any.
     */
     if (super->any)
         return (0);
     /*
-    * 2.1 sub must be a pair of not and a namespace name or ·absent·.
+    * 2.1 sub must be a pair of not and a namespace name or �absent�.
     * 2.2 super must be a pair of not and the same value.
     */
     if ((sub->negNsSet != NULL) &&
         (super->negNsSet != NULL) &&
         (sub->negNsSet->value == sub->negNsSet->value))
         return (0);
     /*
-    * 3.1 sub must be a set whose members are either namespace names or ·absent·.
+    * 3.1 sub must be a set whose members are either namespace names or �absent�.
     */
     if (sub->nsSet != NULL) {
         /*
         * 3.2.1 super must be the same set or a superset thereof.
         */
         if (super->nsSet != NULL) {
             xmlSchemaWildcardNsPtr cur, curB;
             int found = 0;
 
             cur = sub->nsSet;
@@ skipping 10 matching lines @@
                 if (!found)
                     return (1);
                 cur = cur->next;
             }
             if (found)
                 return (0);
         } else if (super->negNsSet != NULL) {
             xmlSchemaWildcardNsPtr cur;
             /*
             * 3.2.2 super must be a pair of not and a namespace name or
-            * ·absent· and that value must not be in sub's set.
+            * �absent� and that value must not be in sub's set.
             */
             cur = sub->nsSet;
             while (cur != NULL) {
                 if (cur->value == super->negNsSet->value)
                     return (1);
                 cur = cur->next;
             }
             return (0);
         }
     }
     return (1);
 }
 
 static int
 xmlSchemaGetEffectiveValueConstraint(xmlSchemaAttributeUsePtr attruse,
                                      int *fixed,
                                      const xmlChar **value,
                                      xmlSchemaValPtr *val)
 {
     *fixed = 0;
     *value = NULL;
     if (val != 0)
         *val = NULL;
 
-    if (attruse->defValue != NULL) {        
+    if (attruse->defValue != NULL) {
         *value = attruse->defValue;
         if (val != NULL)
             *val = attruse->defVal;
         if (attruse->flags & XML_SCHEMA_ATTR_USE_FIXED)
             *fixed = 1;
         return(1);
     } else if ((attruse->attrDecl != NULL) &&
         (attruse->attrDecl->defValue != NULL)) {
         *value = attruse->attrDecl->defValue;
         if (val != NULL)
@@ skipping 59 matching lines @@
 */
 static int
 xmlSchemaCheckDerivationOKRestriction2to4(xmlSchemaParserCtxtPtr pctxt,
                                        int action,
                                        xmlSchemaBasicItemPtr item,
                                        xmlSchemaBasicItemPtr baseItem,
                                        xmlSchemaItemListPtr uses,
                                        xmlSchemaItemListPtr baseUses,
                                        xmlSchemaWildcardPtr wild,
                                        xmlSchemaWildcardPtr baseWild)
-{        
+{
     xmlSchemaAttributeUsePtr cur = NULL, bcur;
     int i, j, found; /* err = 0; */
     const xmlChar *bEffValue;
     int effFixed;
-    
+
     if (uses != NULL) {
         for (i = 0; i < uses->nbItems; i++) {
             cur = uses->items[i];
             found = 0;
             if (baseUses == NULL)
                 goto not_found;
             for (j = 0; j < baseUses->nbItems; j++) {
-                bcur = baseUses->items[j];      
+                bcur = baseUses->items[j];
                 if ((WXS_ATTRUSE_DECL_NAME(cur) ==
                         WXS_ATTRUSE_DECL_NAME(bcur)) &&
                     (WXS_ATTRUSE_DECL_TNS(cur) ==
                         WXS_ATTRUSE_DECL_TNS(bcur)))
                 {
                     /*
                     * (2.1) "If there is an attribute use in the {attribute
                     * uses} of the {base type definition} (call this B) whose
                     * {attribute declaration} has the same {name} and {target
                     * namespace}, then  all of the following must be true:"
                     */
                     found = 1;
-                    
+
                     if ((cur->occurs == XML_SCHEMAS_ATTR_USE_OPTIONAL) &&
                         (bcur->occurs == XML_SCHEMAS_ATTR_USE_REQUIRED))
                     {
                         xmlChar *str = NULL;
                         /*
                         * (2.1.1) "one of the following must be true:"
                         * (2.1.1.1) "B's {required} is false."
                         * (2.1.1.2) "R's {required} is true."
                         */
                         xmlSchemaPAttrUseErr4(pctxt,
                             XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_1,
                             WXS_ITEM_NODE(item), item, cur,
                             "The 'optional' attribute use is inconsistent "
                             "with the corresponding 'required' attribute use of "
                             "the %s %s",
                             WXS_ACTION_STR(action),
                             xmlSchemaGetComponentDesignation(&str, baseItem),
                             NULL, NULL);
                         FREE_AND_NULL(str);
                         /* err = pctxt->err; */
                     } else if (xmlSchemaCheckCOSSTDerivedOK(ACTXT_CAST pctxt,
                         WXS_ATTRUSE_TYPEDEF(cur),
                         WXS_ATTRUSE_TYPEDEF(bcur), 0) != 0)
                     {
                         xmlChar *strA = NULL, *strB = NULL, *strC = NULL;
-                        
+
                         /*
                         * SPEC (2.1.2) "R's {attribute declaration}'s
                         * {type definition} must be validly derived from
                         * B's {type definition} given the empty set as
-                        * defined in Type Derivation OK (Simple) (§3.14.6)."
+                        * defined in Type Derivation OK (Simple) (�3.14.6)."
                         */
                         xmlSchemaPAttrUseErr4(pctxt,
                             XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_2,
                             WXS_ITEM_NODE(item), item, cur,
                             "The attribute declaration's %s "
                             "is not validly derived from "
                             "the corresponding %s of the "
                             "attribute declaration in the %s %s",
                             xmlSchemaGetComponentDesignation(&strA,
                                 WXS_ATTRUSE_TYPEDEF(cur)),
@@ skipping 11 matching lines @@
                         * 2.1.3 [Definition:]  Let the effective value
                         * constraint of an attribute use be its {value
                         * constraint}, if present, otherwise its {attribute
                         * declaration}'s {value constraint} .
                         */
                         xmlSchemaGetEffectiveValueConstraint(bcur,
                             &effFixed, &bEffValue, NULL);
                         /*
                         * 2.1.3 ... one of the following must be true
                         *
-                        * 2.1.3.1 B's ·effective value constraint· is
-                        * ·absent· or default.
+                        * 2.1.3.1 B's �effective value constraint� is
+                        * �absent� or default.
                         */
                         if ((bEffValue != NULL) &&
                             (effFixed == 1)) {
                             const xmlChar *rEffValue = NULL;
-                            
+
                             xmlSchemaGetEffectiveValueConstraint(bcur,
                                 &effFixed, &rEffValue, NULL);
                             /*
-                            * 2.1.3.2 R's ·effective value constraint· is
+                            * 2.1.3.2 R's �effective value constraint� is
                             * fixed with the same string as B's.
                             * MAYBE TODO: Compare the computed values.
                             *       Hmm, it says "same string" so
                             *       string-equality might really be sufficient.
                             */
                             if ((effFixed == 0) ||
                                 (! WXS_ARE_DEFAULT_STR_EQUAL(rEffValue, bEffValue)))
                             {
                                 xmlChar *str = NULL;
-                                
+
                                 xmlSchemaPAttrUseErr4(pctxt,
                                     XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_3,
                                     WXS_ITEM_NODE(item), item, cur,
                                     "The effective value constraint of the "
                                     "attribute use is inconsistent with "
                                     "its correspondent in the %s %s",
                                     WXS_ACTION_STR(action),
                                     xmlSchemaGetComponentDesignation(&str,
                                         baseItem),
                                     NULL, NULL);
                                 FREE_AND_NULL(str);
                                 /* err = pctxt->err; */
                             }
                         }
                     }
                     break;
                 }
             }
-not_found:      
+not_found:
             if (!found) {
                 /*
                 * (2.2) "otherwise the {base type definition} must have an
                 * {attribute wildcard} and the {target namespace} of the
-                * R's {attribute declaration} must be ·valid· with respect
+                * R's {attribute declaration} must be �valid� with respect
                 * to that wildcard, as defined in Wildcard allows Namespace
-                * Name (§3.10.4)."
+                * Name (�3.10.4)."
                 */
                 if ((baseWild == NULL) ||
                     (xmlSchemaCheckCVCWildcardNamespace(baseWild,
                     (WXS_ATTRUSE_DECL(cur))->targetNamespace) != 0))
                 {
                     xmlChar *str = NULL;
-                    
+
                     xmlSchemaPAttrUseErr4(pctxt,
                         XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_2,
                         WXS_ITEM_NODE(item), item, cur,
                         "Neither a matching attribute use, "
                         "nor a matching wildcard exists in the %s %s",
                         WXS_ACTION_STR(action),
                         xmlSchemaGetComponentDesignation(&str, baseItem),
                         NULL, NULL);
                     FREE_AND_NULL(str);
                     /* err = pctxt->err; */
                 }
             }
         }
     }
     /*
-    * SPEC derivation-ok-restriction (3):    
+    * SPEC derivation-ok-restriction (3):
     * (3) "For each attribute use in the {attribute uses} of the {base type
     * definition} whose {required} is true, there must be an attribute
     * use with an {attribute declaration} with the same {name} and
     * {target namespace} as its {attribute declaration} in the {attribute
     * uses} of the complex type definition itself whose {required} is true.
     */
     if (baseUses != NULL) {
         for (j = 0; j < baseUses->nbItems; j++) {
             bcur = baseUses->items[j];
             if (bcur->occurs != XML_SCHEMAS_ATTR_USE_REQUIRED)
                 continue;
             found = 0;
             if (uses != NULL) {
                 for (i = 0; i < uses->nbItems; i++) {
-                    cur = uses->items[i];       
+                    cur = uses->items[i];
                     if ((WXS_ATTRUSE_DECL_NAME(cur) ==
                         WXS_ATTRUSE_DECL_NAME(bcur)) &&
                         (WXS_ATTRUSE_DECL_TNS(cur) ==
                         WXS_ATTRUSE_DECL_TNS(bcur))) {
                         found = 1;
                         break;
                     }
                 }
             }
             if (!found) {
                 xmlChar *strA = NULL, *strB = NULL;
-                
+
                 xmlSchemaCustomErr4(ACTXT_CAST pctxt,
                     XML_SCHEMAP_DERIVATION_OK_RESTRICTION_3,
                     NULL, item,
                     "A matching attribute use for the "
                     "'required' %s of the %s %s is missing",
                     xmlSchemaGetComponentDesignation(&strA, bcur),
                     WXS_ACTION_STR(action),
                     xmlSchemaGetComponentDesignation(&strB, baseItem),
                     NULL);
                 FREE_AND_NULL(strA);
                 FREE_AND_NULL(strB);
             }
         }
     }
     /*
     * derivation-ok-restriction (4)
     */
     if (wild != NULL) {
         /*
         * (4) "If there is an {attribute wildcard}, all of the
         * following must be true:"
-        */   
+        */
         if (baseWild == NULL) {
             xmlChar *str = NULL;
 
             /*
             * (4.1) "The {base type definition} must also have one."
-            */      
+            */
             xmlSchemaCustomErr4(ACTXT_CAST pctxt,
                 XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_1,
                 NULL, item,
                 "The %s has an attribute wildcard, "
                 "but the %s %s '%s' does not have one",
-                WXS_ITEM_TYPE_NAME(item),                   
+                WXS_ITEM_TYPE_NAME(item),
                 WXS_ACTION_STR(action),
                 WXS_ITEM_TYPE_NAME(baseItem),
                 xmlSchemaGetComponentQName(&str, baseItem));
             FREE_AND_NULL(str);
             return(pctxt->err);
         } else if ((baseWild->any == 0) &&
                 xmlSchemaCheckCOSNSSubset(wild, baseWild))
         {
             xmlChar *str = NULL;
             /*
             * (4.2) "The complex type definition's {attribute wildcard}'s
             * {namespace constraint} must be a subset of the {base type
             * definition}'s {attribute wildcard}'s {namespace constraint},
-            * as defined by Wildcard Subset (§3.10.6)."
+            * as defined by Wildcard Subset (�3.10.6)."
             */
             xmlSchemaCustomErr4(ACTXT_CAST pctxt,
                 XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_2,
                 NULL, item,
                 "The attribute wildcard is not a valid "
                 "subset of the wildcard in the %s %s '%s'",
                 WXS_ACTION_STR(action),
                 WXS_ITEM_TYPE_NAME(baseItem),
                 xmlSchemaGetComponentQName(&str, baseItem),
                 NULL);
             FREE_AND_NULL(str);
             return(pctxt->err);
         }
-        /* 4.3 Unless the {base type definition} is the ·ur-type
-        * definition·, the complex type definition's {attribute
+        /* 4.3 Unless the {base type definition} is the �ur-type
+        * definition�, the complex type definition's {attribute
         * wildcard}'s {process contents} must be identical to or
         * stronger than the {base type definition}'s {attribute
         * wildcard}'s {process contents}, where strict is stronger
         * than lax is stronger than skip.
         */
         if ((! WXS_IS_ANYTYPE(baseItem)) &&
             (wild->processContents < baseWild->processContents)) {
             xmlChar *str = NULL;
             xmlSchemaCustomErr4(ACTXT_CAST pctxt,
                 XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_3,
@@ skipping 30 matching lines @@
  * ATTENTION TODO: Experimantally this uses pointer comparisons for
  * strings, so recheck this if we start to hardcode some schemata, since
  * they might not be in the same dict.
  * NOTE: It is allowed to "extend" the xs:anyType type.
  */
 static int
 xmlSchemaFixupTypeAttributeUses(xmlSchemaParserCtxtPtr pctxt,
                                   xmlSchemaTypePtr type)
 {
     xmlSchemaTypePtr baseType = NULL;
-    xmlSchemaAttributeUsePtr use;    
+    xmlSchemaAttributeUsePtr use;
     xmlSchemaItemListPtr uses, baseUses, prohibs = NULL;
 
     if (type->baseType == NULL) {
         PERROR_INT("xmlSchemaFixupTypeAttributeUses",
             "no base type");
         return (-1);
     }
-    baseType = type->baseType;        
+    baseType = type->baseType;
     if (WXS_IS_TYPE_NOT_FIXED(baseType))
         if (xmlSchemaTypeFixup(baseType, ACTXT_CAST pctxt) == -1)
             return(-1);
 
     uses = type->attrUses;
     baseUses = baseType->attrUses;
     /*
     * Expand attribute group references. And build the 'complete'
     * wildcard, i.e. intersect multiple wildcards.
     * Move attribute prohibitions into a separate list.
     */
-    if (uses != NULL) { 
+    if (uses != NULL) {
         if (WXS_IS_RESTRICTION(type)) {
             /*
             * This one will transfer all attr. prohibitions
             * into pctxt->attrProhibs.
             */
             if (xmlSchemaExpandAttributeGroupRefs(pctxt,
                 WXS_BASIC_CAST type, &(type->attributeWildcard), uses,
                 pctxt->attrProhibs) == -1)
             {
                 PERROR_INT("xmlSchemaFixupTypeAttributeUses",
@@ skipping 13 matching lines @@
     }
     /*
     * Inherit the attribute uses of the base type.
     */
     if (baseUses != NULL) {
         int i, j;
         xmlSchemaAttributeUseProhibPtr pro;
 
         if (WXS_IS_RESTRICTION(type)) {
             int usesCount;
-            xmlSchemaAttributeUsePtr tmp; 
+            xmlSchemaAttributeUsePtr tmp;
 
             if (uses != NULL)
                 usesCount = uses->nbItems;
             else
                 usesCount = 0;
 
             /* Restriction. */
             for (i = 0; i < baseUses->nbItems; i++) {
                 use = baseUses->items[i];
                 if (prohibs) {
@@ skipping 29 matching lines @@
                     type->attrUses = xmlSchemaItemListCreate();
                     if (type->attrUses == NULL)
                         goto exit_failure;
                     uses = type->attrUses;
                 }
                 xmlSchemaItemListAddSize(uses, 2, use);
 inherit_next: {}
             }
         } else {
             /* Extension. */
-            for (i = 0; i < baseUses->nbItems; i++) {       
-                use = baseUses->items[i];               
+            for (i = 0; i < baseUses->nbItems; i++) {
+                use = baseUses->items[i];
                 if (uses == NULL) {
                     type->attrUses = xmlSchemaItemListCreate();
                     if (type->attrUses == NULL)
                         goto exit_failure;
                     uses = type->attrUses;
                 }
-                xmlSchemaItemListAddSize(uses, baseUses->nbItems, use); 
+                xmlSchemaItemListAddSize(uses, baseUses->nbItems, use);
             }
         }
     }
     /*
     * Shrink attr. uses.
     */
     if (uses) {
         if (uses->nbItems == 0) {
             xmlSchemaItemListFree(uses);
             type->attrUses = NULL;
         }
         /*
         * TODO: We could shrink the size of the array
         * to fit the actual number of items.
         */
     }
     /*
     * Compute the complete wildcard.
     */
-    if (WXS_IS_EXTENSION(type)) {       
+    if (WXS_IS_EXTENSION(type)) {
         if (baseType->attributeWildcard != NULL) {
             /*
-            * (3.2.2.1) "If the ·base wildcard· is non-·absent·, then
+            * (3.2.2.1) "If the �base wildcard� is non-�absent�, then
             * the appropriate case among the following:"
             */
             if (type->attributeWildcard != NULL) {
                 /*
                 * Union the complete wildcard with the base wildcard.
                 * SPEC {attribute wildcard}
                 * (3.2.2.1.2) "otherwise a wildcard whose {process contents}
-                * and {annotation} are those of the ·complete wildcard·,
+                * and {annotation} are those of the �complete wildcard�,
                 * and whose {namespace constraint} is the intensional union
-                * of the {namespace constraint} of the ·complete wildcard·
-                * and of the ·base wildcard·, as defined in Attribute
-                * Wildcard Union (§3.10.6)."
+                * of the {namespace constraint} of the �complete wildcard�
+                * and of the �base wildcard�, as defined in Attribute
+                * Wildcard Union (�3.10.6)."
                 */
                 if (xmlSchemaUnionWildcards(pctxt, type->attributeWildcard,
                     baseType->attributeWildcard) == -1)
-                    goto exit_failure;          
+                    goto exit_failure;
             } else {
                 /*
-                * (3.2.2.1.1) "If the ·complete wildcard· is ·absent·,
-                * then the ·base wildcard·."
+                * (3.2.2.1.1) "If the �complete wildcard� is �absent�,
+                * then the �base wildcard�."
                 */
                 type->attributeWildcard = baseType->attributeWildcard;
-            }    
+            }
         } else {
             /*
-            * (3.2.2.2) "otherwise (the ·base wildcard· is ·absent·) the
-            * ·complete wildcard"
+            * (3.2.2.2) "otherwise (the �base wildcard� is �absent�) the
+            * �complete wildcard"
             * NOOP
             */
         }
     } else {
         /*
         * SPEC {attribute wildcard}
         * (3.1) "If the <restriction> alternative is chosen, then the
-        * ·complete wildcard·;"
+        * �complete wildcard�;"
         * NOOP
         */
     }
-    
+
     return (0);
 
 exit_failure:
     return(-1);
 }
 
 /**
  * xmlSchemaTypeFinalContains:
  * @schema:  the schema
  * @type:  the type definition
@@ skipping 83 matching lines @@
                 (part->children->type == XML_SCHEMA_TYPE_ANY))
                 sum += part->minOccurs;
             else
                 sum += xmlSchemaGetParticleTotalRangeMin(part);
             part = (xmlSchemaParticlePtr) part->next;
         } while (part != NULL);
         return (particle->minOccurs * sum);
     }
 }
 
+#if 0
 /**
  * xmlSchemaGetParticleTotalRangeMax:
  * @particle: the particle
  *
  * Schema Component Constraint: Effective Total Range
  * (all and sequence) + (choice)
  *
  * Returns the maximum Effective Total Range.
  */
 static int
@@ skipping 39 matching lines @@
             if (cur == UNBOUNDED)
                 return (UNBOUNDED);
             if ((cur > 0) && (particle->maxOccurs == UNBOUNDED))
                 return (UNBOUNDED);
             sum += cur;
         }
         /* TODO: Handle overflows? */
         return (particle->maxOccurs * sum);
     }
 }
+#endif
 
 /**
  * xmlSchemaIsParticleEmptiable:
  * @particle: the particle
  *
  * Schema Component Constraint: Particle Emptiable
  * Checks whether the given particle is emptiable.
  *
  * Returns 1 if emptiable, 0 otherwise.
  */
@@ skipping 60 matching lines @@
         if (xmlSchemaTypeFixup(baseType, actxt) == -1)
             return(-1);
     if ((subset & SUBSET_RESTRICTION) ||
         (xmlSchemaTypeFinalContains(type->baseType,
             XML_SCHEMAS_TYPE_FINAL_RESTRICTION))) {
         return (XML_SCHEMAP_COS_ST_DERIVED_OK_2_1);
     }
     /* 2.2 */
     if (type->baseType == baseType) {
         /*
-        * 2.2.1 D's ·base type definition· is B.
+        * 2.2.1 D's �base type definition� is B.
         */
         return (0);
     }
     /*
-    * 2.2.2 D's ·base type definition· is not the ·ur-type definition·
+    * 2.2.2 D's �base type definition� is not the �ur-type definition�
     * and is validly derived from B given the subset, as defined by this
     * constraint.
     */
     if ((! WXS_IS_ANYTYPE(type->baseType)) &&
         (xmlSchemaCheckCOSSTDerivedOK(actxt, type->baseType,
             baseType, subset) == 0)) {
         return (0);
     }
     /*
-    * 2.2.3 D's {variety} is list or union and B is the ·simple ur-type
-    * definition·.
+    * 2.2.3 D's {variety} is list or union and B is the �simple ur-type
+    * definition�.
     */
     if (WXS_IS_ANY_SIMPLE_TYPE(baseType) &&
         (WXS_IS_LIST(type) || WXS_IS_UNION(type))) {
         return (0);
     }
     /*
     * 2.2.4 B's {variety} is union and D is validly derived from a type
     * definition in B's {member type definitions} given the subset, as
     * defined by this constraint.
     *
@@ skipping 95 matching lines @@
 *
 * Note that this should work on the *representation* of a component,
 * thus assumes any union types in the member types not being yet
 * substituted. At this stage we need the variety of the types
 * to be already computed.
 */
 static int
 xmlSchemaCheckUnionTypeDefCircularRecur(xmlSchemaParserCtxtPtr pctxt,
                                         xmlSchemaTypePtr ctxType,
                                         xmlSchemaTypeLinkPtr members)
-{    
+{
     xmlSchemaTypeLinkPtr member;
     xmlSchemaTypePtr memberType;
-    
+
     member = members;
     while (member != NULL) {
         memberType = member->type;
         while ((memberType != NULL) &&
             (memberType->type != XML_SCHEMA_TYPE_BASIC)) {
             if (memberType == ctxType) {
                 xmlSchemaPCustomErr(pctxt,
                     XML_SCHEMAP_SRC_SIMPLE_TYPE_4,
                     WXS_BASIC_CAST ctxType, NULL,
                     "The union type definition is circular", NULL);
@@ skipping 80 matching lines @@
                     typeDef->subtypes = NULL;
                     xmlSchemaPResCompAttrErr(ctxt,
                         XML_SCHEMAP_SRC_RESOLVE,
                         WXS_BASIC_CAST typeDef, typeDef->node,
                         "itemType", typeDef->base, typeDef->baseNs,
                         XML_SCHEMA_TYPE_SIMPLE, NULL);
                 }
             }
             return;
         }
-    } 
+    }
     /*
     * The ball of letters below means, that if we have a particle
     * which has a QName-helper component as its {term}, we want
     * to resolve it...
     */
     else if ((WXS_TYPE_CONTENTTYPE(typeDef) != NULL) &&
         ((WXS_TYPE_CONTENTTYPE(typeDef))->type ==
             XML_SCHEMA_TYPE_PARTICLE) &&
         (WXS_TYPE_PARTICLE_TERM(typeDef) != NULL) &&
         ((WXS_TYPE_PARTICLE_TERM(typeDef))->type ==
@@ skipping 22 matching lines @@
             WXS_TYPE_CONTENTTYPE(typeDef) = NULL;
         } else if (WXS_MODELGROUPDEF_MODEL(groupDef) == NULL)
             /* Remove the particle. */
             WXS_TYPE_CONTENTTYPE(typeDef) = NULL;
         else {
             /*
             * Assign the MG definition's {model group} to the
             * particle's {term}.
             */
             WXS_TYPE_PARTICLE_TERM(typeDef) = WXS_MODELGROUPDEF_MODEL(groupDef);
-            
+
             if (WXS_MODELGROUPDEF_MODEL(groupDef)->type == XML_SCHEMA_TYPE_ALL) {
                 /*
                 * SPEC cos-all-limited (1.2)
                 * "1.2 the {term} property of a particle with
                 * {max occurs}=1 which is part of a pair which constitutes
                 * the {content type} of a complex type definition."
                 */
                 if ((WXS_TYPE_PARTICLE(typeDef))->maxOccurs != 1) {
                     xmlSchemaCustomErr(ACTXT_CAST ctxt,
                         /* TODO: error code */
@@ skipping 28 matching lines @@
     xmlSchemaTypePtr baseType = type->baseType;
     xmlChar *str = NULL;
 
     /* STATE: error funcs converted. */
     /*
     * Schema Component Constraint: Simple Type Definition Properties Correct
     *
     * NOTE: This is somehow redundant, since we actually built a simple type
     * to have all the needed information; this acts as an self test.
     */
-    /* Base type: If the datatype has been ·derived· by ·restriction·
-    * then the Simple Type Definition component from which it is ·derived·,
-    * otherwise the Simple Type Definition for anySimpleType (§4.1.6).
+    /* Base type: If the datatype has been �derived� by �restriction�
+    * then the Simple Type Definition component from which it is �derived�,
+    * otherwise the Simple Type Definition for anySimpleType (�4.1.6).
     */
     if (baseType == NULL) {
         /*
         * TODO: Think about: "modulo the impact of Missing
-        * Sub-components (§5.3)."
+        * Sub-components (�5.3)."
         */
         xmlSchemaPCustomErr(ctxt,
             XML_SCHEMAP_ST_PROPS_CORRECT_1,
             WXS_BASIC_CAST type, NULL,
             "No base type existent", NULL);
         return (XML_SCHEMAP_ST_PROPS_CORRECT_1);
 
     }
     if (! WXS_IS_SIMPLE(baseType)) {
         xmlSchemaPCustomErr(ctxt,
             XML_SCHEMAP_ST_PROPS_CORRECT_1,
             WXS_BASIC_CAST type, NULL,
             "The base type '%s' is not a simple type",
             xmlSchemaGetComponentQName(&str, baseType));
         FREE_AND_NULL(str)
         return (XML_SCHEMAP_ST_PROPS_CORRECT_1);
     }
     if ( (WXS_IS_LIST(type) || WXS_IS_UNION(type)) &&
          (WXS_IS_RESTRICTION(type) == 0) &&
          (! WXS_IS_ANY_SIMPLE_TYPE(baseType))) {
         xmlSchemaPCustomErr(ctxt,
             XML_SCHEMAP_ST_PROPS_CORRECT_1,
             WXS_BASIC_CAST type, NULL,
-            "A type, derived by list or union, must have"
+            "A type, derived by list or union, must have "
             "the simple ur-type definition as base type, not '%s'",
             xmlSchemaGetComponentQName(&str, baseType));
         FREE_AND_NULL(str)
         return (XML_SCHEMAP_ST_PROPS_CORRECT_1);
     }
     /*
     * Variety: One of {atomic, list, union}.
     */
     if ((! WXS_IS_ATOMIC(type)) && (! WXS_IS_UNION(type)) &&
         (! WXS_IS_LIST(type))) {
@@ skipping 14 matching lines @@
             XML_SCHEMAP_ST_PROPS_CORRECT_3,
             WXS_BASIC_CAST type, NULL,
             "The 'final' of its base type '%s' must not contain "
             "'restriction'",
             xmlSchemaGetComponentQName(&str, baseType));
         FREE_AND_NULL(str)
         return (XML_SCHEMAP_ST_PROPS_CORRECT_3);
     }
 
     /*
-    * 2 All simple type definitions must be derived ultimately from the ·simple
-    * ur-type definition (so· circular definitions are disallowed). That is, it
-    * must be possible to reach a built-in primitive datatype or the ·simple
-    * ur-type definition· by repeatedly following the {base type definition}.
+    * 2 All simple type definitions must be derived ultimately from the �simple
+    * ur-type definition (so� circular definitions are disallowed). That is, it
+    * must be possible to reach a built-in primitive datatype or the �simple
+    * ur-type definition� by repeatedly following the {base type definition}.
     *
     * NOTE: this is done in xmlSchemaCheckTypeDefCircular().
     */
     return (0);
 }
 
 /**
  * xmlSchemaCheckCOSSTRestricts:
  * @ctxt:  the schema parser context
  * @type:  the simple type definition
@@ skipping 163 matching lines @@
                         xmlSchemaPIllegalFacetListUnionErr(pctxt,
                             XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_2,
                             type, facet);
                         return (XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_2);
                     }
                     facet = facet->next;
                 } while (facet != NULL);
             }
             /*
             * MAYBE TODO: (Hmm, not really) Datatypes states:
-            * A ·list· datatype can be ·derived· from an ·atomic· datatype
-            * whose ·lexical space· allows space (such as string or anyURI)or
-            * a ·union· datatype any of whose {member type definitions}'s
-            * ·lexical space· allows space.
+            * A �list� datatype can be �derived� from an �atomic� datatype
+            * whose �lexical space� allows space (such as string or anyURI)or
+            * a �union� datatype any of whose {member type definitions}'s
+            * �lexical space� allows space.
             */
         } else {
             /*
             * This is the case if we have: <simpleType><restriction ...
             * I.e. the variety of "list" is inherited.
             */
             /*
             * 2.3.2
             * 2.3.2.1 The {base type definition} must have a {variety} of list.
             */
@@ skipping 16 matching lines @@
                     XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_2,
                     WXS_BASIC_CAST type, NULL,
                     "The 'final' of the base type '%s' must not contain 'restriction'",
                     xmlSchemaGetComponentQName(&str, type->baseType));
                 FREE_AND_NULL(str)
                 return (XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_2);
             }
             /*
             * 2.3.2.3 The {item type definition} must be validly derived
             * from the {base type definition}'s {item type definition} given
-            * the empty set, as defined in Type Derivation OK (Simple) (§3.14.6).
+            * the empty set, as defined in Type Derivation OK (Simple) (�3.14.6).
             */
             {
                 xmlSchemaTypePtr baseItemType;
 
                 baseItemType = type->baseType->subtypes;
                 if ((baseItemType == NULL) || (! WXS_IS_SIMPLE(baseItemType))) {
                     PERROR_INT("xmlSchemaCheckCOSSTRestricts",
                         "failed to eval the item type of a base type");
                     return (-1);
                 }
@@ skipping 26 matching lines @@
                 */
                 facet = type->facets;
                 do {
                     switch (facet->type) {
                         case XML_SCHEMA_FACET_LENGTH:
                         case XML_SCHEMA_FACET_MINLENGTH:
                         case XML_SCHEMA_FACET_MAXLENGTH:
                         case XML_SCHEMA_FACET_WHITESPACE:
                             /*
                             * TODO: 2.5.1.2 List datatypes
-                            * The value of ·whiteSpace· is fixed to the value collapse.
+                            * The value of �whiteSpace� is fixed to the value collapse.
                             */
                         case XML_SCHEMA_FACET_PATTERN:
                         case XML_SCHEMA_FACET_ENUMERATION:
                             break;
                         default: {
                             xmlSchemaPIllegalFacetListUnionErr(pctxt,
                                 XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_4,
                                 type, facet);
                             /*
                             * We could return, but it's nicer to report all
@@ skipping 32 matching lines @@
                     XML_SCHEMAP_COS_ST_RESTRICTS_3_1,
                     WXS_BASIC_CAST type, NULL,
                     "The member type '%s' is neither an atomic, nor a list type",
                     xmlSchemaGetComponentQName(&str, member->type));
                 FREE_AND_NULL(str)
                 return (XML_SCHEMAP_COS_ST_RESTRICTS_3_1);
             }
             member = member->next;
         }
         /*
-        * 3.3.1 If the {base type definition} is the ·simple ur-type
-        * definition·
+        * 3.3.1 If the {base type definition} is the �simple ur-type
+        * definition�
         */
         if (type->baseType->builtInType == XML_SCHEMAS_ANYSIMPLETYPE) {
             /*
             * 3.3.1.1 All of the {member type definitions} must have a
             * {final} which does not contain union.
             */
             member = type->memberTypes;
             while (member != NULL) {
                 if (xmlSchemaTypeFinalContains(member->type,
                     XML_SCHEMAS_TYPE_FINAL_UNION)) {
@@ skipping 41 matching lines @@
                     WXS_BASIC_CAST type, NULL,
                     "The 'final' of its base type '%s' must not contain 'restriction'",
                     xmlSchemaGetComponentQName(&str, type->baseType));
                 FREE_AND_NULL(str)
                 return (XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_2);
             }
             /*
             * 3.3.2.3 The {member type definitions}, in order, must be validly
             * derived from the corresponding type definitions in the {base
             * type definition}'s {member type definitions} given the empty set,
-            * as defined in Type Derivation OK (Simple) (§3.14.6).
+            * as defined in Type Derivation OK (Simple) (�3.14.6).
             */
             {
                 xmlSchemaTypeLinkPtr baseMember;
 
                 /*
                 * OPTIMIZE: if the type is restricting, it has no local defined
                 * member types and inherits the member types of the base type;
                 * thus a check for equality can be skipped.
                 */
                 /*
@@ skipping 27 matching lines @@
                                 "type %s of the base type %s",
                                 xmlSchemaGetComponentQName(&str, member->type),
                                 xmlSchemaGetComponentQName(&strBMT, baseMember->type),
                                 xmlSchemaGetComponentQName(&strBT, type->baseType));
                             FREE_AND_NULL(str)
                             FREE_AND_NULL(strBMT)
                             FREE_AND_NULL(strBT)
                             return (XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_3);
                         }
                         member = member->next;
-                        baseMember = baseMember->next;
+                        if (baseMember != NULL)
+                            baseMember = baseMember->next;
                     }
                 }
             }
             /*
             * 3.3.2.4 Only pattern and enumeration facet components are
             * allowed among the {facets}.
             */
             if (type->facets != NULL) {
                 xmlSchemaFacetPtr facet;
                 int ok = 1;
@@ skipping 23 matching lines @@
     }
 
     return (0);
 }
 
 /**
  * xmlSchemaCheckSRCSimpleType:
  * @ctxt:  the schema parser context
  * @type:  the simple type definition
  *
- * Checks crc-simple-type constraints. 
+ * Checks crc-simple-type constraints.
  *
  * Returns 0 if the constraints are satisfied,
  * if not a positive error code and -1 on internal
  * errors.
  */
 #if 0
 static int
 xmlSchemaCheckSRCSimpleType(xmlSchemaParserCtxtPtr ctxt,
                             xmlSchemaTypePtr type)
 {
     /*
     * src-simple-type.1 The corresponding simple type definition, if any,
     * must satisfy the conditions set out in Constraints on Simple Type
-    * Definition Schema Components (§3.14.6).
-    */    
+    * Definition Schema Components (�3.14.6).
+    */
     if (WXS_IS_RESTRICTION(type)) {
         /*
         * src-simple-type.2 "If the <restriction> alternative is chosen,
         * either it must have a base [attribute] or a <simpleType> among its
         * [children], but not both."
         * NOTE: This is checked in the parse function of <restriction>.
         */
         /*
-        * 
+        *
         */
     } else if (WXS_IS_LIST(type)) {
         /* src-simple-type.3 "If the <list> alternative is chosen, either it must have
         * an itemType [attribute] or a <simpleType> among its [children],
         * but not both."
         *
         * NOTE: This is checked in the parse function of <list>.
         */
-    } else if (WXS_IS_UNION(type)) {    
-        /* 
+    } else if (WXS_IS_UNION(type)) {
+        /*
         * src-simple-type.4 is checked in xmlSchemaCheckUnionTypeDefCircular().
         */
     }
     return (0);
 }
 #endif
 
 static int
 xmlSchemaCreateVCtxtOnPCtxt(xmlSchemaParserCtxtPtr ctxt)
 {
@@ skipping 57 matching lines @@
     * For a string to be a valid default with respect to a type
     * definition the appropriate case among the following must be true:
     */
     if WXS_IS_COMPLEX(type) {
         /*
         * Complex type.
         *
         * SPEC (2.1) "its {content type} must be a simple type definition
         * or mixed."
         * SPEC (2.2.2) "If the {content type} is mixed, then the {content
-        * type}'s particle must be ·emptiable· as defined by
-        * Particle Emptiable (§3.9.6)."
+        * type}'s particle must be �emptiable� as defined by
+        * Particle Emptiable (�3.9.6)."
         */
         if ((! WXS_HAS_SIMPLE_CONTENT(type)) &&
             ((! WXS_HAS_MIXED_CONTENT(type)) || (! WXS_EMPTIABLE(type)))) {
             /* NOTE that this covers (2.2.2) as well. */
             xmlSchemaPCustomErr(pctxt,
                 XML_SCHEMAP_COS_VALID_DEFAULT_2_1,
                 WXS_BASIC_CAST type, type->node,
                 "For a string to be a valid default, the type definition "
                 "must be a simple type or a complex type with mixed content "
                 "and a particle emptiable", NULL);
             return(XML_SCHEMAP_COS_VALID_DEFAULT_2_1);
         }
     }
     /*
     * 1 If the type definition is a simple type definition, then the string
-    * must be ·valid· with respect to that definition as defined by String
-    * Valid (§3.14.4).
+    * must be �valid� with respect to that definition as defined by String
+    * Valid (�3.14.4).
     *
     * AND
     *
     * 2.2.1 If the {content type} is a simple type definition, then the
-    * string must be ·valid· with respect to that simple type definition
-    * as defined by String Valid (§3.14.4).
+    * string must be �valid� with respect to that simple type definition
+    * as defined by String Valid (�3.14.4).
     */
     if (WXS_IS_SIMPLE(type))
         ret = xmlSchemaVCheckCVCSimpleType(ACTXT_CAST pctxt, node,
             type, value, val, 1, 1, 0);
     else if (WXS_HAS_SIMPLE_CONTENT(type))
         ret = xmlSchemaVCheckCVCSimpleType(ACTXT_CAST pctxt, node,
             type->contentTypeDef, value, val, 1, 1, 0);
     else
         return (ret);
 
@@ skipping 20 matching lines @@
  */
 static int
 xmlSchemaCheckCTPropsCorrect(xmlSchemaParserCtxtPtr pctxt,
                              xmlSchemaTypePtr type)
 {
     /*
     * TODO: Correct the error code; XML_SCHEMAP_SRC_CT_1 is used temporarily.
     *
     * SPEC (1) "The values of the properties of a complex type definition must
     * be as described in the property tableau in The Complex Type Definition
-    * Schema Component (§3.4.1), modulo the impact of Missing
-    * Sub-components (§5.3)."
+    * Schema Component (�3.4.1), modulo the impact of Missing
+    * Sub-components (�5.3)."
     */
     if ((type->baseType != NULL) &&
         (WXS_IS_SIMPLE(type->baseType)) &&
         (WXS_IS_EXTENSION(type) == 0)) {
         /*
         * SPEC (2) "If the {base type definition} is a simple type definition,
         * the {derivation method} must be extension."
         */
         xmlSchemaCustomErr(ACTXT_CAST pctxt,
             XML_SCHEMAP_SRC_CT_1,
-            NULL, WXS_BASIC_CAST type, 
+            NULL, WXS_BASIC_CAST type,
             "If the base type is a simple type, the derivation method must be "
             "'extension'", NULL, NULL);
         return (XML_SCHEMAP_SRC_CT_1);
     }
     /*
-    * SPEC (3) "Circular definitions are disallowed, except for the ·ur-type
-    * definition·. That is, it must be possible to reach the ·ur-type
+    * SPEC (3) "Circular definitions are disallowed, except for the �ur-type
+    * definition�. That is, it must be possible to reach the �ur-type
     * definition by repeatedly following the {base type definition}."
     *
     * NOTE (3) is done in xmlSchemaCheckTypeDefCircular().
     */
     /*
     * NOTE that (4) and (5) need the following:
     *   - attribute uses need to be already inherited (apply attr. prohibitions)
     *   - attribute group references need to be expanded already
     *   - simple types need to be typefixed already
-    */    
+    */
     if (type->attrUses &&
         (((xmlSchemaItemListPtr) type->attrUses)->nbItems > 1))
     {
         xmlSchemaItemListPtr uses = (xmlSchemaItemListPtr) type->attrUses;
         xmlSchemaAttributeUsePtr use, tmp;
         int i, j, hasId = 0;
 
         for (i = uses->nbItems -1; i >= 0; i--) {
             use = uses->items[i];
-            
-            /* 
+
+            /*
             * SPEC ct-props-correct
             * (4) "Two distinct attribute declarations in the
             * {attribute uses} must not have identical {name}s and
             * {target namespace}s."
             */
             if (i > 0) {
                 for (j = i -1; j >= 0; j--) {
                     tmp = uses->items[j];
                     if ((WXS_ATTRUSE_DECL_NAME(use) ==
                         WXS_ATTRUSE_DECL_NAME(tmp)) &&
@@ skipping 20 matching lines @@
             }
             /*
             * SPEC ct-props-correct
             * (5) "Two distinct attribute declarations in the
             * {attribute uses} must not have {type definition}s which
             * are or are derived from ID."
             */
             if (WXS_ATTRUSE_TYPEDEF(use) != NULL) {
                 if (xmlSchemaIsDerivedFromBuiltInType(
                     WXS_ATTRUSE_TYPEDEF(use), XML_SCHEMAS_ID))
-                {               
+                {
                     if (hasId) {
                         xmlChar *str = NULL;
-                        
+
                         xmlSchemaCustomErr(ACTXT_CAST pctxt,
                             XML_SCHEMAP_AG_PROPS_CORRECT,
                             NULL, WXS_BASIC_CAST type,
                             "There must not exist more than one attribute "
                             "declaration of type 'xs:ID' "
                             "(or derived from 'xs:ID'). The %s violates this "
                             "constraint",
                             xmlSchemaGetComponentDesignation(&str, use),
                             NULL);
                         FREE_AND_NULL(str);
                         if (xmlSchemaItemListRemove(uses, i) == -1)
                             goto exit_failure;
                     }
-                    
+
                     hasId = 1;
                 }
             }
 next_use: {}
         }
     }
     return (0);
 exit_failure:
     return(-1);
 }
@@ skipping 53 matching lines @@
         * SPEC (2.1) "B and D must be the same type definition."
         */
         return (0);
     }
     /*
     * SPEC (2.2) "B must be D's {base type definition}."
     */
     if (type->baseType == baseType)
         return (0);
     /*
-    * SPEC (2.3.1) "D's {base type definition} must not be the ·ur-type
-    * definition·."
+    * SPEC (2.3.1) "D's {base type definition} must not be the �ur-type
+    * definition�."
     */
     if (WXS_IS_ANYTYPE(type->baseType))
         return (1);
 
     if (WXS_IS_COMPLEX(type->baseType)) {
         /*
         * SPEC (2.3.2.1) "If D's {base type definition} is complex, then it
         * must be validly derived from B given the subset as defined by this
         * constraint."
         */
         return (xmlSchemaCheckCOSCTDerivedOK(actxt, type->baseType,
             baseType, set));
     } else {
         /*
         * SPEC (2.3.2.2) "If D's {base type definition} is simple, then it
         * must be validly derived from B given the subset as defined in Type
-        * Derivation OK (Simple) (§3.14.6).
+        * Derivation OK (Simple) (�3.14.6).
         */
         return (xmlSchemaCheckCOSSTDerivedOK(actxt, type->baseType,
             baseType, set));
     }
 }
 
 /**
  * xmlSchemaCheckCOSDerivedOK:
  * @type:  the derived simple type definition
  * @baseType:  the base type definition
@@ skipping 40 matching lines @@
 {
     xmlSchemaTypePtr base = type->baseType;
     /*
     * TODO: Correct the error code; XML_SCHEMAP_COS_CT_EXTENDS_1_1 is used
     * temporarily only.
     */
     /*
     * SPEC (1) "If the {base type definition} is a complex type definition,
     * then all of the following must be true:"
     */
-    if (WXS_IS_COMPLEX(base)) { 
+    if (WXS_IS_COMPLEX(base)) {
         /*
         * SPEC (1.1) "The {final} of the {base type definition} must not
         * contain extension."
         */
         if (base->flags & XML_SCHEMAS_TYPE_FINAL_EXTENSION) {
             xmlSchemaPCustomErr(ctxt,
                 XML_SCHEMAP_COS_CT_EXTENDS_1_1,
                 WXS_BASIC_CAST type, NULL,
                 "The 'final' of the base type definition "
                 "contains 'extension'", NULL);
             return (XML_SCHEMAP_COS_CT_EXTENDS_1_1);
         }
-        
+
         /*
         * ATTENTION: The constrains (1.2) and (1.3) are not applied,
         * since they are automatically satisfied through the
         * inheriting mechanism.
         * Note that even if redefining components, the inheriting mechanism
         * is used.
         */
 #if 0
         /*
         * SPEC (1.2) "Its {attribute uses} must be a subset of the {attribute
@@ skipping 23 matching lines @@
                             (WXS_ATTRUSE_TYPEDEF(use) ==
                                 WXS_ATTRUSE_TYPEDEF(buse))
                         {
                             found = 1;
                             break;
                         }
                     }
                 }
                 if (! found) {
                     xmlChar *str = NULL;
-                
+
                     xmlSchemaCustomErr(ACTXT_CAST ctxt,
                         XML_SCHEMAP_COS_CT_EXTENDS_1_2,
                         NULL, WXS_BASIC_CAST type,
-                        /* 
+                        /*
                         * TODO: The report does not indicate that also the
                         * type needs to be the same.
                         */
                         "This type is missing a matching correspondent "
                         "for its {base type}'s %s in its {attribute uses}",
                         xmlSchemaGetComponentDesignation(&str,
                             buse->children),
                         NULL);
                     FREE_AND_NULL(str)
                 }
             }
         }
         /*
         * SPEC (1.3) "If it has an {attribute wildcard}, the complex type
         * definition must also have one, and the base type definition's
         * {attribute  wildcard}'s {namespace constraint} must be a subset
         * of the complex  type definition's {attribute wildcard}'s {namespace
-        * constraint}, as defined by Wildcard Subset (§3.10.6)."
+        * constraint}, as defined by Wildcard Subset (�3.10.6)."
         */
-  
+
         /*
         * MAYBE TODO: Enable if ever needed. But this will be needed only
         * if created the type via a schema construction API.
         */
         if (base->attributeWildcard != NULL) {
             if (type->attributeWilcard == NULL) {
                 xmlChar *str = NULL;
-                
+
                 xmlSchemaCustomErr(ACTXT_CAST pctxt,
                     XML_SCHEMAP_COS_CT_EXTENDS_1_3,
                     NULL, type,
                     "The base %s has an attribute wildcard, "
                     "but this type is missing an attribute wildcard",
                     xmlSchemaGetComponentDesignation(&str, base));
                 FREE_AND_NULL(str)
 
             } else if (xmlSchemaCheckCOSNSSubset(
                 base->attributeWildcard, type->attributeWildcard))
             {
                 xmlChar *str = NULL;
-                
+
                 xmlSchemaCustomErr(ACTXT_CAST pctxt,
                     XML_SCHEMAP_COS_CT_EXTENDS_1_3,
                     NULL, type,
                     "The attribute wildcard is not a valid "
                     "superset of the one in the base %s",
                     xmlSchemaGetComponentDesignation(&str, base));
                 FREE_AND_NULL(str)
             }
         }
 #endif
@@ skipping 53 matching lines @@
                     */
                     xmlSchemaPCustomErr(ctxt,
                         XML_SCHEMAP_COS_CT_EXTENDS_1_1,
                         WXS_BASIC_CAST type, NULL,
                         "The content type of both, the type and its base "
                         "type, must either 'mixed' or 'element-only'", NULL);
                     return (XML_SCHEMAP_COS_CT_EXTENDS_1_1);
                 }
                 /*
                 * URGENT TODO SPEC (1.4.3.2.2.2) "The particle of the
-                * complex type definition must be a ·valid extension·
+                * complex type definition must be a �valid extension�
                 * of the {base type definition}'s particle, as defined
-                * in Particle Valid (Extension) (§3.9.6)."
+                * in Particle Valid (Extension) (�3.9.6)."
                 *
                 * NOTE that we won't check "Particle Valid (Extension)",
                 * since it is ensured by the derivation process in
                 * xmlSchemaTypeFixup(). We need to implement this when heading
                 * for a construction API
                 * TODO: !! This is needed to be checked if redefining a type !!
                 */
             }
             /*
             * URGENT TODO (1.5)
@@ skipping 57 matching lines @@
                                       xmlSchemaTypePtr type)
 {
     xmlSchemaTypePtr base;
 
     /*
     * TODO: Correct the error code; XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1 is used
     * temporarily only.
     */
     base = type->baseType;
     if (! WXS_IS_COMPLEX(base)) {
-        xmlSchemaCustomErr(ACTXT_CAST ctxt,         
+        xmlSchemaCustomErr(ACTXT_CAST ctxt,
             XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1,
             type->node, WXS_BASIC_CAST type,
             "The base type must be a complex type", NULL, NULL);
         return(ctxt->err);
     }
     if (base->flags & XML_SCHEMAS_TYPE_FINAL_RESTRICTION) {
         /*
         * SPEC (1) "The {base type definition} must be a complex type
         * definition whose {final} does not contain restriction."
         */
-        xmlSchemaCustomErr(ACTXT_CAST ctxt,         
+        xmlSchemaCustomErr(ACTXT_CAST ctxt,
             XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1,
             type->node, WXS_BASIC_CAST type,
             "The 'final' of the base type definition "
             "contains 'restriction'", NULL, NULL);
         return (ctxt->err);
     }
     /*
     * SPEC (2), (3) and (4)
     * Those are handled in a separate function, since the
     * same constraints are needed for redefinition of
     * attribute groups as well.
     */
     if (xmlSchemaCheckDerivationOKRestriction2to4(ctxt,
         XML_SCHEMA_ACTION_DERIVE,
         WXS_BASIC_CAST type, WXS_BASIC_CAST base,
         type->attrUses, base->attrUses,
         type->attributeWildcard,
         base->attributeWildcard) == -1)
     {
         return(-1);
     }
     /*
     * SPEC (5) "One of the following must be true:"
     */
     if (base->builtInType == XML_SCHEMAS_ANYTYPE) {
         /*
         * SPEC (5.1) "The {base type definition} must be the
-        * ·ur-type definition·."
+        * �ur-type definition�."
         * PASS
         */
     } else if ((type->contentType == XML_SCHEMA_CONTENT_SIMPLE) ||
             (type->contentType == XML_SCHEMA_CONTENT_BASIC)) {
         /*
         * SPEC (5.2.1) "The {content type} of the complex type definition
         * must be a simple type definition"
         *
         * SPEC (5.2.2) "One of the following must be true:"
         */
         if ((base->contentType == XML_SCHEMA_CONTENT_SIMPLE) ||
             (base->contentType == XML_SCHEMA_CONTENT_BASIC))
         {
             int err;
             /*
             * SPEC (5.2.2.1) "The {content type} of the {base type
             * definition} must be a simple type definition from which
             * the {content type} is validly derived given the empty
-            * set as defined in Type Derivation OK (Simple) (§3.14.6)."
+            * set as defined in Type Derivation OK (Simple) (�3.14.6)."
             *
             * ATTENTION TODO: This seems not needed if the type implicitely
             * derived from the base type.
-            * 
+            *
             */
             err = xmlSchemaCheckCOSSTDerivedOK(ACTXT_CAST ctxt,
                 type->contentTypeDef, base->contentTypeDef, 0);
             if (err != 0) {
                 xmlChar *strA = NULL, *strB = NULL;
 
                 if (err == -1)
                     return(-1);
                 xmlSchemaCustomErr(ACTXT_CAST ctxt,
                     XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1,
                     NULL, WXS_BASIC_CAST type,
                     "The {content type} %s is not validly derived from the "
                     "base type's {content type} %s",
                     xmlSchemaGetComponentDesignation(&strA,
                         type->contentTypeDef),
                     xmlSchemaGetComponentDesignation(&strB,
                         base->contentTypeDef));
                 FREE_AND_NULL(strA);
                 FREE_AND_NULL(strB);
                 return(ctxt->err);
             }
         } else if ((base->contentType == XML_SCHEMA_CONTENT_MIXED) &&
             (xmlSchemaIsParticleEmptiable(
                 (xmlSchemaParticlePtr) base->subtypes))) {
             /*
             * SPEC (5.2.2.2) "The {base type definition} must be mixed
-            * and have a particle which is ·emptiable· as defined in
-            * Particle Emptiable (§3.9.6)."
+            * and have a particle which is �emptiable� as defined in
+            * Particle Emptiable (�3.9.6)."
             * PASS
             */
         } else {
             xmlSchemaPCustomErr(ctxt,
                 XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1,
                 WXS_BASIC_CAST type, NULL,
                 "The content type of the base type must be either "
                 "a simple type or 'mixed' and an emptiable particle", NULL);
             return (ctxt->err);
         }
     } else if (type->contentType == XML_SCHEMA_CONTENT_EMPTY) {
         /*
         * SPEC (5.3.1) "The {content type} of the complex type itself must
         * be empty"
         */
         if (base->contentType == XML_SCHEMA_CONTENT_EMPTY) {
             /*
             * SPEC (5.3.2.1) "The {content type} of the {base type
             * definition} must also be empty."
             * PASS
             */
         } else if (((base->contentType == XML_SCHEMA_CONTENT_ELEMENTS) ||
             (base->contentType == XML_SCHEMA_CONTENT_MIXED)) &&
             xmlSchemaIsParticleEmptiable(
                 (xmlSchemaParticlePtr) base->subtypes)) {
             /*
             * SPEC (5.3.2.2) "The {content type} of the {base type
             * definition} must be elementOnly or mixed and have a particle
-            * which is ·emptiable· as defined in Particle Emptiable (§3.9.6)."
+            * which is �emptiable� as defined in Particle Emptiable (�3.9.6)."
             * PASS
             */
         } else {
             xmlSchemaPCustomErr(ctxt,
                 XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1,
                 WXS_BASIC_CAST type, NULL,
                 "The content type of the base type must be either "
                 "empty or 'mixed' (or 'elements-only') and an emptiable "
                 "particle", NULL);
             return (ctxt->err);
         }
     } else if ((type->contentType == XML_SCHEMA_CONTENT_ELEMENTS) ||
         WXS_HAS_MIXED_CONTENT(type)) {
         /*
         * SPEC (5.4.1.1) "The {content type} of the complex type definition
         * itself must be element-only"
-        */       
+        */
         if (WXS_HAS_MIXED_CONTENT(type) && (! WXS_HAS_MIXED_CONTENT(base))) {
             /*
             * SPEC (5.4.1.2) "The {content type} of the complex type
             * definition itself and of the {base type definition} must be
             * mixed"
             */
             xmlSchemaPCustomErr(ctxt,
                 XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1,
                 WXS_BASIC_CAST type, NULL,
                 "If the content type is 'mixed', then the content type of the "
                 "base type must also be 'mixed'", NULL);
             return (ctxt->err);
         }
         /*
         * SPEC (5.4.2) "The particle of the complex type definition itself
-        * must be a ·valid restriction· of the particle of the {content
+        * must be a �valid restriction� of the particle of the {content
         * type} of the {base type definition} as defined in Particle Valid
-        * (Restriction) (§3.9.6).
+        * (Restriction) (�3.9.6).
         *
         * URGENT TODO: (5.4.2)
         */
     } else {
         xmlSchemaPCustomErr(ctxt,
             XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1,
             WXS_BASIC_CAST type, NULL,
             "The type is not a valid restriction of its base type", NULL);
         return (ctxt->err);
     }
@@ skipping 48 matching lines @@
     int ret = 0;
 
     /*
     * TODO: Adjust the error codes here, as I used
     * XML_SCHEMAP_SRC_CT_1 only yet.
     */
     base = type->baseType;
     if (! WXS_HAS_SIMPLE_CONTENT(type)) {
         /*
         * 1 If the <complexContent> alternative is chosen, the type definition
-        * ·resolved· to by the ·actual value· of the base [attribute]
+        * �resolved� to by the �actual value� of the base [attribute]
         * must be a complex type definition;
         */
         if (! WXS_IS_COMPLEX(base)) {
             xmlChar *str = NULL;
             xmlSchemaPCustomErr(ctxt,
                 XML_SCHEMAP_SRC_CT_1,
                 WXS_BASIC_CAST type, type->node,
                 "If using <complexContent>, the base type is expected to be "
                 "a complex type. The base type '%s' is a simple type",
                 xmlSchemaFormatQName(&str, base->targetNamespace,
                 base->name));
             FREE_AND_NULL(str)
             return (XML_SCHEMAP_SRC_CT_1);
         }
     } else {
         /*
         * SPEC
         * 2 If the <simpleContent> alternative is chosen, all of the
         * following must be true:
-        * 2.1 The type definition ·resolved· to by the ·actual value· of the
+        * 2.1 The type definition �resolved� to by the �actual value� of the
         * base [attribute] must be one of the following:
         */
         if (WXS_IS_SIMPLE(base)) {
             if (WXS_IS_EXTENSION(type) == 0) {
                 xmlChar *str = NULL;
                 /*
                 * 2.1.3 only if the <extension> alternative is also
                 * chosen, a simple type definition.
                 */
                 /* TODO: Change error code to ..._SRC_CT_2_1_3. */
@@ skipping 29 matching lines @@
                 (WXS_IS_RESTRICTION(type))) {
 
                 /*
                 * 2.1.2 only if the <restriction> alternative is also
                 * chosen, a complex type definition whose {content type}
                 * is mixed and a particle emptiable.
                 */
                 if (! xmlSchemaIsParticleEmptiable(
                     (xmlSchemaParticlePtr) base->subtypes)) {
                     ret = XML_SCHEMAP_SRC_CT_1;
-                } else 
+                } else
                     /*
                     * Attention: at this point the <simpleType> child is in
                     * ->contentTypeDef (put there during parsing).
-                    */              
+                    */
                     if (type->contentTypeDef == NULL) {
                     xmlChar *str = NULL;
                     /*
                     * 2.2 If clause 2.1.2 above is satisfied, then there
                     * must be a <simpleType> among the [children] of
                     * <restriction>.
                     */
                     /* TODO: Change error code to ..._SRC_CT_2_2. */
                     xmlSchemaPCustomErr(ctxt,
                         XML_SCHEMAP_SRC_CT_1,
@@ skipping 31 matching lines @@
                     "is a complex type",
                     xmlSchemaFormatQName(&str, base->targetNamespace,
                     base->name));
             }
             FREE_AND_NULL(str)
         }
     }
     /*
     * SPEC (3) "The corresponding complex type definition component must
     * satisfy the conditions set out in Constraints on Complex Type
-    * Definition Schema Components (§3.4.6);"
+    * Definition Schema Components (�3.4.6);"
     * NOTE (3) will be done in xmlSchemaTypeFixup().
     */
     /*
     * SPEC (4) If clause 2.2.1 or clause 2.2.2 in the correspondence specification
     * above for {attribute wildcard} is satisfied, the intensional
     * intersection must be expressible, as defined in Attribute Wildcard
-    * Intersection (§3.10.6).
+    * Intersection (�3.10.6).
     * NOTE (4) is done in xmlSchemaFixupTypeAttributeUses().
     */
     return (ret);
 }
 
 #ifdef ENABLE_PARTICLE_RESTRICTION
 /**
  * xmlSchemaCheckParticleRangeOK:
  * @ctxt:  the schema parser context
  * @type:  the complex type definition
@@ skipping 50 matching lines @@
     /*
     * SPEC (1) "The declarations' {name}s and {target namespace}s are
     * the same."
     */
     if ((elemR != elemB) &&
         ((! xmlStrEqual(elemR->name, elemB->name)) ||
         (! xmlStrEqual(elemR->targetNamespace, elemB->targetNamespace))))
         return (1);
     /*
     * SPEC (2) "R's occurrence range is a valid restriction of B's
-    * occurrence range as defined by Occurrence Range OK (§3.9.6)."
+    * occurrence range as defined by Occurrence Range OK (�3.9.6)."
     */
     if (xmlSchemaCheckParticleRangeOK(r->minOccurs, r->maxOccurs,
             b->minOccurs, b->maxOccurs) != 0)
         return (1);
     /*
     * SPEC (3.1) "Both B's declaration's {scope} and R's declaration's
     * {scope} are global."
     */
     if (elemR == elemB)
         return (0);
@@ skipping 71 matching lines @@
  * Returns 0 if the constraints are satisfied, a positive
  * error code if not and -1 if an internal error occured.
  */
 static int
 xmlSchemaCheckRCaseNSCompat(xmlSchemaParserCtxtPtr ctxt,
                             xmlSchemaParticlePtr r,
                             xmlSchemaParticlePtr b)
 {
     /* TODO:Error codes (rcase-NSCompat). */
     /*
-    * SPEC "For an element declaration particle to be a ·valid restriction·
+    * SPEC "For an element declaration particle to be a �valid restriction�
     * of a wildcard particle all of the following must be true:"
     *
-    * SPEC (1) "The element declaration's {target namespace} is ·valid·
+    * SPEC (1) "The element declaration's {target namespace} is �valid�
     * with respect to the wildcard's {namespace constraint} as defined by
-    * Wildcard allows Namespace Name (§3.10.4)."
+    * Wildcard allows Namespace Name (�3.10.4)."
     */
     if (xmlSchemaCheckCVCWildcardNamespace((xmlSchemaWildcardPtr) b->children,
         ((xmlSchemaElementPtr) r->children)->targetNamespace) != 0)
         return (1);
     /*
     * SPEC (2) "R's occurrence range is a valid restriction of B's
-    * occurrence range as defined by Occurrence Range OK (§3.9.6)."
+    * occurrence range as defined by Occurrence Range OK (�3.9.6)."
     */
     if (xmlSchemaCheckParticleRangeOK(r->minOccurs, r->maxOccurs,
             b->minOccurs, b->maxOccurs) != 0)
         return (1);
 
     return (0);
 }
 
 /**
  * xmlSchemaCheckRCaseRecurseAsIfGroup:
@@ skipping 39 matching lines @@
  */
 static int
 xmlSchemaCheckRCaseNSSubset(xmlSchemaParserCtxtPtr ctxt,
                                     xmlSchemaParticlePtr r,
                                     xmlSchemaParticlePtr b,
                                     int isAnyTypeBase)
 {
     /* TODO: Error codes (rcase-NSSubset). */
     /*
     * SPEC (1) "R's occurrence range is a valid restriction of B's
-    * occurrence range as defined by Occurrence Range OK (§3.9.6)."
+    * occurrence range as defined by Occurrence Range OK (�3.9.6)."
     */
     if (xmlSchemaCheckParticleRangeOK(r->minOccurs, r->maxOccurs,
             b->minOccurs, b->maxOccurs))
         return (1);
     /*
     * SPEC (2) "R's {namespace constraint} must be an intensional subset
-    * of B's {namespace constraint} as defined by Wildcard Subset (§3.10.6)."
+    * of B's {namespace constraint} as defined by Wildcard Subset (�3.10.6)."
     */
     if (xmlSchemaCheckCOSNSSubset((xmlSchemaWildcardPtr) r->children,
         (xmlSchemaWildcardPtr) b->children))
         return (1);
     /*
-    * SPEC (3) "Unless B is the content model wildcard of the ·ur-type
-    * definition·, R's {process contents} must be identical to or stronger
+    * SPEC (3) "Unless B is the content model wildcard of the �ur-type
+    * definition�, R's {process contents} must be identical to or stronger
     * than B's {process contents}, where strict is stronger than lax is
     * stronger than skip."
     */
     if (! isAnyTypeBase) {
         if ( ((xmlSchemaWildcardPtr) r->children)->processContents <
             ((xmlSchemaWildcardPtr) b->children)->processContents)
             return (1);
     }
 
     return (0);
@@ skipping 29 matching lines @@
     /*
     * SPEC (1) "They are the same particle."
     */
     if (r == b)
         return (0);
 
 
     return (0);
 }
 
+#if 0
 /**
  * xmlSchemaCheckRCaseNSRecurseCheckCardinality:
  * @ctxt:  the schema parser context
  * @r: the model group particle
  * @b: the base wildcard particle
  *
  * (3.9.6) Constraints on Particle Schema Components
  * Schema Component Constraint:
  * Particle Derivation OK (All/Choice/Sequence:Any --
  *                         NSRecurseCheckCardinality)
  * (rcase-NSRecurseCheckCardinality)
  *
  * STATUS: TODO: subst-groups
  *
  * Returns 0 if the constraints are satisfied, a positive
  * error code if not and -1 if an internal error occured.
  */
 static int
 xmlSchemaCheckRCaseNSRecurseCheckCardinality(xmlSchemaParserCtxtPtr ctxt,
                                              xmlSchemaParticlePtr r,
                                              xmlSchemaParticlePtr b)
 {
     xmlSchemaParticlePtr part;
     /* TODO: Error codes (rcase-NSRecurseCheckCardinality). */
     if ((r->children == NULL) || (r->children->children == NULL))
         return (-1);
     /*
-    * SPEC "For a group particle to be a ·valid restriction· of a
+    * SPEC "For a group particle to be a �valid restriction� of a
     * wildcard particle..."
     *
-    * SPEC (1) "Every member of the {particles} of the group is a ·valid
-    * restriction· of the wildcard as defined by
-    * Particle Valid (Restriction) (§3.9.6)."
+    * SPEC (1) "Every member of the {particles} of the group is a �valid
+    * restriction� of the wildcard as defined by
+    * Particle Valid (Restriction) (�3.9.6)."
     */
     part = (xmlSchemaParticlePtr) r->children->children;
     do {
         if (xmlSchemaCheckCOSParticleRestrict(ctxt, part, b))
             return (1);
         part = (xmlSchemaParticlePtr) part->next;
     } while (part != NULL);
     /*
     * SPEC (2) "The effective total range of the group [...] is a
     * valid restriction of B's occurrence range as defined by
-    * Occurrence Range OK (§3.9.6)."
+    * Occurrence Range OK (�3.9.6)."
     */
     if (xmlSchemaCheckParticleRangeOK(
             xmlSchemaGetParticleTotalRangeMin(r),
             xmlSchemaGetParticleTotalRangeMax(r),
             b->minOccurs, b->maxOccurs) != 0)
         return (1);
     return (0);
 }
+#endif
 
 /**
  * xmlSchemaCheckRCaseRecurse:
  * @ctxt:  the schema parser context
  * @r: the <all> or <sequence> model group particle
  * @b: the base <all> or <sequence> model group particle
  *
  * (3.9.6) Constraints on Particle Schema Components
  * Schema Component Constraint:
  * Particle Derivation OK (All:All,Sequence:Sequence --
@@ skipping 10 matching lines @@
 xmlSchemaCheckRCaseRecurse(xmlSchemaParserCtxtPtr ctxt,
                            xmlSchemaParticlePtr r,
                            xmlSchemaParticlePtr b)
 {
     /* xmlSchemaParticlePtr part; */
     /* TODO: Error codes (rcase-Recurse). */
     if ((r->children == NULL) || (b->children == NULL) ||
         (r->children->type != b->children->type))
         return (-1);
     /*
-    * SPEC "For an all or sequence group particle to be a ·valid
-    * restriction· of another group particle with the same {compositor}..."
+    * SPEC "For an all or sequence group particle to be a �valid
+    * restriction� of another group particle with the same {compositor}..."
     *
     * SPEC (1) "R's occurrence range is a valid restriction of B's
-    * occurrence range as defined by Occurrence Range OK (§3.9.6)."
+    * occurrence range as defined by Occurrence Range OK (�3.9.6)."
     */
     if (xmlSchemaCheckParticleRangeOK(r->minOccurs, r->maxOccurs,
             b->minOccurs, b->maxOccurs))
         return (1);
 
 
     return (0);
 }
 
 #endif
@@ skipping 76 matching lines @@
         fmininc = NULL, fmaxinc = NULL,
         fminexc = NULL, fmaxexc = NULL,
         bflength = NULL, bftotdig = NULL, bffracdig = NULL,
         bfmaxlen = NULL, bfminlen = NULL, /* facets of the base type */
         bfmininc = NULL, bfmaxinc = NULL,
         bfminexc = NULL, bfmaxexc = NULL;
     int res; /* err = 0, fixedErr; */
 
     /*
     * SPEC st-restrict-facets 1:
-    * "The {variety} of R is the same as that of B."    
+    * "The {variety} of R is the same as that of B."
     */
     /*
     * SPEC st-restrict-facets 2:
     * "If {variety} is atomic, the {primitive type definition}
     * of R is the same as that of B."
     *
     * NOTE: we leave 1 & 2 out for now, since this will be
     * satisfied by the derivation process.
     * CONSTRUCTION TODO: Maybe needed if using a construction API.
     */
@@ skipping 133 matching lines @@
             FACET_RESTR_FIXED_ERR(fmaxlen)
         }
     }
     /*
     * SCC "length and minLength or maxLength"
     */
     if (! flength)
         flength = bflength;
     if (flength) {
         if (! fminlen)
-            flength = bflength;
+            fminlen = bfminlen;
         if (fminlen) {
             /* (1.1) length >= minLength */
             res = xmlSchemaCompareValues(flength->val, fminlen->val);
             if (res == -2)
                 goto internal_error;
             if (res == -1)
                 xmlSchemaDeriveFacetErr(pctxt, flength, fminlen, 1, 1, 0);
         }
         if (! fmaxlen)
             fmaxlen = bfmaxlen;
@@ skipping 297 matching lines @@
         /* fixedErr = 0; */
         while (link != NULL) {
             facet = link->facet;
             if (facet->type == bfacet->type) {
                 switch (facet->type) {
                     case XML_SCHEMA_FACET_WHITESPACE:
                         /*
                         * The whitespace must be stronger.
                         */
                         if (facet->whitespace < bfacet->whitespace) {
-                            FACET_RESTR_ERR(flength,
+                            FACET_RESTR_ERR(facet,
                                 "The 'whitespace' value has to be equal to "
                                 "or stronger than the 'whitespace' value of "
                                 "the base type")
                         }
                         if ((bfacet->fixed) &&
                             (facet->whitespace != bfacet->whitespace)) {
                             FACET_RESTR_FIXED_ERR(facet)
                         }
                         break;
                     default:
@@ skipping 34 matching lines @@
     return (-1);
 }
 
 static int
 xmlSchemaFinishMemberTypeDefinitionsProperty(xmlSchemaParserCtxtPtr pctxt,
                                              xmlSchemaTypePtr type)
 {
     xmlSchemaTypeLinkPtr link, lastLink, prevLink, subLink, newLink;
     /*
     * The actual value is then formed by replacing any union type
-    * definition in the ·explicit members· with the members of their
+    * definition in the �explicit members� with the members of their
     * {member type definitions}, in order.
     *
     * TODO: There's a bug entry at
     * "http://lists.w3.org/Archives/Public/www-xml-schema-comments/2005JulSep/0287.html"
     * which indicates that we'll keep the union types the future.
     */
     link = type->memberTypes;
     while (link != NULL) {
 
         if (WXS_IS_TYPE_NOT_FIXED(link->type))
@@ skipping 25 matching lines @@
                 }
             }
         }
         link = link->next;
     }
     return (0);
 }
 
 static void
 xmlSchemaTypeFixupOptimFacets(xmlSchemaTypePtr type)
-{       
+{
     int has = 0, needVal = 0, normVal = 0;
 
     has = (type->baseType->flags & XML_SCHEMAS_TYPE_HAS_FACETS) ? 1 : 0;
     if (has) {
         needVal = (type->baseType->flags &
             XML_SCHEMAS_TYPE_FACETSNEEDVALUE) ? 1 : 0;
         normVal = (type->baseType->flags &
             XML_SCHEMAS_TYPE_NORMVALUENEEDED) ? 1 : 0;
     }
     if (type->facets != NULL) {
         xmlSchemaFacetPtr fac;
-        
+
         for (fac = type->facets; fac != NULL; fac = fac->next) {
             switch (fac->type) {
                 case XML_SCHEMA_FACET_WHITESPACE:
                     break;
                 case XML_SCHEMA_FACET_PATTERN:
                     normVal = 1;
                     has = 1;
                     break;
                 case XML_SCHEMA_FACET_ENUMERATION:
                     needVal = 1;
                     normVal = 1;
                     has = 1;
                     break;
                 default:
                     has = 1;
                     break;
             }
-        }       
+        }
     }
     if (normVal)
         type->flags |= XML_SCHEMAS_TYPE_NORMVALUENEEDED;
     if (needVal)
         type->flags |= XML_SCHEMAS_TYPE_FACETSNEEDVALUE;
     if (has)
         type->flags |= XML_SCHEMAS_TYPE_HAS_FACETS;
 
     if (has && (! needVal) && WXS_IS_ATOMIC(type)) {
         xmlSchemaTypePtr prim = xmlSchemaGetPrimitiveType(type);
         /*
         * OPTIMIZE VAL TODO: Some facets need a computed value.
         */
         if ((prim->builtInType != XML_SCHEMAS_ANYSIMPLETYPE) &&
             (prim->builtInType != XML_SCHEMAS_STRING)) {
             type->flags |= XML_SCHEMAS_TYPE_FACETSNEEDVALUE;
-        }       
-    }       
+        }
+    }
 }
 
 static int
 xmlSchemaTypeFixupWhitespace(xmlSchemaTypePtr type)
 {
-    
-    
+
+
     /*
     * Evaluate the whitespace-facet value.
-    */    
+    */
     if (WXS_IS_LIST(type)) {
         type->flags |= XML_SCHEMAS_TYPE_WHITESPACE_COLLAPSE;
         return (0);
     } else if (WXS_IS_UNION(type))
         return (0);
-    
+
     if (type->facetSet != NULL) {
         xmlSchemaFacetLinkPtr lin;
 
         for (lin = type->facetSet; lin != NULL; lin = lin->next) {
             if (lin->facet->type == XML_SCHEMA_FACET_WHITESPACE) {
                 switch (lin->facet->whitespace) {
                 case XML_SCHEMAS_FACET_PRESERVE:
                     type->flags |= XML_SCHEMAS_TYPE_WHITESPACE_PRESERVE;
                     break;
                 case XML_SCHEMAS_FACET_REPLACE:
                     type->flags |= XML_SCHEMAS_TYPE_WHITESPACE_REPLACE;
                     break;
                 case XML_SCHEMAS_FACET_COLLAPSE:
                     type->flags |= XML_SCHEMAS_TYPE_WHITESPACE_COLLAPSE;
                     break;
                 default:
                     return (-1);
                 }
                 return (0);
             }
         }
     }
     /*
-    * For all ·atomic· datatypes other than string (and types ·derived· 
-    * by ·restriction· from it) the value of whiteSpace is fixed to 
+    * For all �atomic� datatypes other than string (and types �derived�
+    * by �restriction� from it) the value of whiteSpace is fixed to
     * collapse
     */
     {
         xmlSchemaTypePtr anc;
 
-        for (anc = type->baseType; anc != NULL && 
+        for (anc = type->baseType; anc != NULL &&
                 anc->builtInType != XML_SCHEMAS_ANYTYPE;
                 anc = anc->baseType) {
 
             if (anc->type == XML_SCHEMA_TYPE_BASIC) {
-                if (anc->builtInType == XML_SCHEMAS_NORMSTRING) {           
+                if (anc->builtInType == XML_SCHEMAS_NORMSTRING) {
                     type->flags |= XML_SCHEMAS_TYPE_WHITESPACE_REPLACE;
 
                 } else if ((anc->builtInType == XML_SCHEMAS_STRING) ||
-                    (anc->builtInType == XML_SCHEMAS_ANYSIMPLETYPE)) {              
+                    (anc->builtInType == XML_SCHEMAS_ANYSIMPLETYPE)) {
                     type->flags |= XML_SCHEMAS_TYPE_WHITESPACE_PRESERVE;
 
                 } else
                     type->flags |= XML_SCHEMAS_TYPE_WHITESPACE_COLLAPSE;
                 break;
             }
         }
     }
     return (0);
 }
@@ skipping 16 matching lines @@
             /*
             * This one is really needed, so get out.
             */
             PERROR_INT("xmlSchemaFixupSimpleTypeStageOne",
                 "list type has no item-type assigned");
             return(-1);
         }
     } else if (WXS_IS_UNION(type)) {
         /*
         * Corresponds to <simpleType><union>...
-        */      
+        */
         if (type->memberTypes == NULL) {
             /*
             * This one is really needed, so get out.
             */
             PERROR_INT("xmlSchemaFixupSimpleTypeStageOne",
                 "union type has no member-types assigned");
             return(-1);
-        }           
-    } else {    
+        }
+    } else {
         /*
         * Corresponds to <simpleType><restriction>...
         */
         if (type->baseType == NULL) {
             PERROR_INT("xmlSchemaFixupSimpleTypeStageOne",
                 "type has no base-type assigned");
             return(-1);
         }
         if (WXS_IS_TYPE_NOT_FIXED_1(type->baseType))
             if (xmlSchemaFixupSimpleTypeStageOne(pctxt, type->baseType) == -1)
@@ skipping 94 matching lines @@
     type->flags |= XML_SCHEMAS_TYPE_INTERNAL_RESOLVED;
     type->contentType = XML_SCHEMA_CONTENT_SIMPLE;
 
     if (type->baseType == NULL) {
         PERROR_INT("xmlSchemaFixupSimpleTypeStageTwo",
             "missing baseType");
         goto exit_failure;
     }
     if (WXS_IS_TYPE_NOT_FIXED(type->baseType))
         xmlSchemaTypeFixup(type->baseType, ACTXT_CAST pctxt);
-    /* 
+    /*
     * If a member type of a union is a union itself, we need to substitute
     * that member type for its member types.
     * NOTE that this might change in WXS 1.1; i.e. we will keep the union
     * types in WXS 1.1.
     */
     if ((type->memberTypes != NULL) &&
         (xmlSchemaFinishMemberTypeDefinitionsProperty(pctxt, type) == -1))
-        return(-1);        
+        return(-1);
     /*
-    * SPEC src-simple-type 1 
+    * SPEC src-simple-type 1
     * "The corresponding simple type definition, if any, must satisfy
     * the conditions set out in Constraints on Simple Type Definition
-    * Schema Components (§3.14.6)."
+    * Schema Components (�3.14.6)."
     */
     /*
     * Schema Component Constraint: Simple Type Definition Properties Correct
     * (st-props-correct)
     */
     res = xmlSchemaCheckSTPropsCorrect(pctxt, type);
     HFAILURE HERROR
-    /* 
+    /*
     * Schema Component Constraint: Derivation Valid (Restriction, Simple)
     * (cos-st-restricts)
     */
     res = xmlSchemaCheckCOSSTRestricts(pctxt, type);
     HFAILURE HERROR
     /*
     * TODO: Removed the error report, since it got annoying to get an
     * extra error report, if anything failed until now.
     * Enable this if needed.
     *
@@ skipping 12 matching lines @@
     if ((type->facetSet != NULL) ||
         (type->baseType->facetSet != NULL)) {
         res = xmlSchemaDeriveAndValidateFacets(pctxt, type);
         HFAILURE HERROR
     }
     /*
     * Whitespace value.
     */
     res = xmlSchemaTypeFixupWhitespace(type);
     HFAILURE HERROR
-    xmlSchemaTypeFixupOptimFacets(type);    
+    xmlSchemaTypeFixupOptimFacets(type);
 
 exit_error:
 #ifdef DEBUG_TYPE
     xmlSchemaDebugFixedType(pctxt, type);
 #endif
     if (olderrs != pctxt->nberrors)
         return(pctxt->err);
     return(0);
 
 exit_failure:
@@ skipping 10 matching lines @@
     int res = 0, olderrs = pctxt->nberrors;
     xmlSchemaTypePtr baseType = type->baseType;
 
     if (! WXS_IS_TYPE_NOT_FIXED(type))
         return(0);
     type->flags |= XML_SCHEMAS_TYPE_INTERNAL_RESOLVED;
     if (baseType == NULL) {
         PERROR_INT("xmlSchemaFixupComplexType",
             "missing baseType");
         goto exit_failure;
-    }    
+    }
     /*
     * Fixup the base type.
     */
     if (WXS_IS_TYPE_NOT_FIXED(baseType))
         xmlSchemaTypeFixup(baseType, ACTXT_CAST pctxt);
     if (baseType->flags & XML_SCHEMAS_TYPE_INTERNAL_INVALID) {
         /*
         * Skip fixup if the base type is invalid.
         * TODO: Generate a warning!
         */
         return(0);
-    }   
+    }
     /*
     * This basically checks if the base type can be derived.
     */
     res = xmlSchemaCheckSRCCT(pctxt, type);
-    HFAILURE HERROR   
+    HFAILURE HERROR
     /*
     * Fixup the content type.
     */
     if (type->contentType == XML_SCHEMA_CONTENT_SIMPLE) {
         /*
         * Corresponds to <complexType><simpleContent>...
         */
         if ((WXS_IS_COMPLEX(baseType)) &&
             (baseType->contentTypeDef != NULL) &&
             (WXS_IS_RESTRICTION(type))) {
@@ skipping 53 matching lines @@
             content->type = XML_SCHEMA_TYPE_SIMPLE;
             content->baseType = contentBase;
             /*
             * Move the facets, previously anchored on the
             * complexType during parsing.
             */
             content->facets = type->facets;
             type->facets = NULL;
             content->facetSet = type->facetSet;
             type->facetSet = NULL;
-            
+
             type->contentTypeDef = content;
             if (WXS_IS_TYPE_NOT_FIXED(contentBase))
                 xmlSchemaTypeFixup(contentBase, ACTXT_CAST pctxt);
             /*
             * Fixup the newly created type. We don't need to check
             * for circularity here.
             */
             res = xmlSchemaFixupSimpleTypeStageOne(pctxt, content);
-            HFAILURE HERROR 
+            HFAILURE HERROR
             res = xmlSchemaFixupSimpleTypeStageTwo(pctxt, content);
-            HFAILURE HERROR 
-                
+            HFAILURE HERROR
+
         } else if ((WXS_IS_COMPLEX(baseType)) &&
             (baseType->contentType == XML_SCHEMA_CONTENT_MIXED) &&
             (WXS_IS_RESTRICTION(type))) {
             /*
             * SPEC (2) If <restriction> + base is a mixed <complexType> with
             * an emptiable particle, then a simple type definition which
             * restricts the <restriction>'s <simpleType> child.
             */
             if ((type->contentTypeDef == NULL) ||
                 (type->contentTypeDef->baseType == NULL)) {
@@ skipping 64 matching lines @@
         */
         if ((particle == NULL) ||
             ((particle->type == XML_SCHEMA_TYPE_PARTICLE) &&
             ((particle->children->type == XML_SCHEMA_TYPE_ALL) ||
             (particle->children->type == XML_SCHEMA_TYPE_SEQUENCE) ||
             ((particle->children->type == XML_SCHEMA_TYPE_CHOICE) &&
             (particle->minOccurs == 0))) &&
             ( ((xmlSchemaTreeItemPtr) particle->children)->children == NULL))) {
             if (type->flags & XML_SCHEMAS_TYPE_MIXED) {
                 /*
-                * SPEC (2.1.4) "If the ·effective mixed· is true, then
+                * SPEC (2.1.4) "If the �effective mixed� is true, then
                 * a particle whose properties are as follows:..."
                 *
                 * Empty sequence model group with
                 * minOccurs/maxOccurs = 1 (i.e. a "particle emptiable").
                 * NOTE that we sill assign it the <complexType> node to
                 * somehow anchor it in the doc.
                 */
                 if ((particle == NULL) ||
                     (particle->children->type != XML_SCHEMA_TYPE_SEQUENCE)) {
                     /*
                     * Create the particle.
                     */
                     particle = xmlSchemaAddParticle(pctxt,
                         type->node, 1, 1);
                     if (particle == NULL)
                         goto exit_failure;
                     /*
                     * Create the model group.
                     */ /* URGENT TODO: avoid adding to pending items. */
                     particle->children = (xmlSchemaTreeItemPtr)
                         xmlSchemaAddModelGroup(pctxt, pctxt->schema,
                         XML_SCHEMA_TYPE_SEQUENCE, type->node);
                     if (particle->children == NULL)
                         goto exit_failure;
-                    
+
                     type->subtypes = (xmlSchemaTypePtr) particle;
                 }
                 dummySequence = 1;
                 type->contentType = XML_SCHEMA_CONTENT_ELEMENTS;
             } else {
                 /*
                 * SPEC (2.1.5) "otherwise empty"
                 */
                 type->contentType = XML_SCHEMA_CONTENT_EMPTY;
             }
@@ skipping 16 matching lines @@
                 if (type->flags & XML_SCHEMAS_TYPE_MIXED)
                     type->contentType = XML_SCHEMA_CONTENT_MIXED;
             }
         } else {
             /*
             * SPEC (3.2) "If <extension>..."
             */
             if (type->contentType == XML_SCHEMA_CONTENT_EMPTY) {
                 /*
                 * SPEC (3.2.1)
-                * "If the ·effective content· is empty, then the
+                * "If the �effective content� is empty, then the
                 *  {content type} of the [...] base ..."
                 */
                 type->contentType = baseType->contentType;
                 type->subtypes = baseType->subtypes;
                 /*
                 * Fixes bug #347316:
                 * This is the case when the base type has a simple
                 * type definition as content.
                 */
                 type->contentTypeDef = baseType->contentTypeDef;
@@ skipping 86 matching lines @@
                         type->node,
                         ((xmlSchemaParticlePtr) type->subtypes)->minOccurs,
                         ((xmlSchemaParticlePtr) type->subtypes)->maxOccurs);
                     if (particle->children->children == NULL)
                         goto exit_failure;
                     particle = (xmlSchemaParticlePtr)
                         particle->children->children;
                     particle->children =
                         ((xmlSchemaParticlePtr) baseType->subtypes)->children;
                     /*
-                    * SPEC "followed by the ·effective content·."
+                    * SPEC "followed by the �effective content�."
                     */
                     particle->next = effectiveContent;
                     /*
                     * This all will result in:
                     * new-particle
                     *   --> new-sequence(
                     *         new-particle
                     *           --> base-model,
                     *         this-particle
                     *           --> this-model
@@ skipping 123 matching lines @@
         case XML_SCHEMA_FACET_MAXEXCLUSIVE:
         case XML_SCHEMA_FACET_ENUMERATION: {
                 /*
                  * Okay we need to validate the value
                  * at that point.
                  */
                 xmlSchemaTypePtr base;
 
                 /* 4.3.5.5 Constraints on enumeration Schema Components
                 * Schema Component Constraint: enumeration valid restriction
-                * It is an ·error· if any member of {value} is not in the
-                * ·value space· of {base type definition}.
+                * It is an �error� if any member of {value} is not in the
+                * �value space� of {base type definition}.
                 *
                 * minInclusive, maxInclusive, minExclusive, maxExclusive:
-                * The value ·must· be in the
-                * ·value space· of the ·base type·.
+                * The value �must� be in the
+                * �value space� of the �base type�.
                 */
                 /*
                 * This function is intended to deliver a compiled value
                 * on the facet. In this implementation of XML Schemata the
                 * type holding a facet, won't be a built-in type.
                 * Thus to ensure that other API
                 * calls (relaxng) do work, if the given type is a built-in
                 * type, we will assume that the given built-in type *is
                 * already* the base type.
                 */
                 if (typeDecl->type != XML_SCHEMA_TYPE_BASIC) {
                     base = typeDecl->baseType;
                     if (base == NULL) {
                         PERROR_INT("xmlSchemaCheckFacet",
                             "a type user derived type has no base type");
                         return (-1);
                     }
                 } else
                     base = typeDecl;
-                         
+
                 if (! ctxtGiven) {
                     /*
                     * A context is needed if called from RelaxNG.
-                    */              
+                    */
                     pctxt = xmlSchemaNewParserCtxt("*");
                     if (pctxt == NULL)
                         return (-1);
                 }
                 /*
                 * NOTE: This call does not check the content nodes,
                 * since they are not available:
                 * facet->node is just the node holding the facet
                 * definition, *not* the attribute holding the *value*
                 * of the facet.
-                */              
+                */
                 ret = xmlSchemaVCheckCVCSimpleType(
                     ACTXT_CAST pctxt, facet->node, base,
                     facet->value, &(facet->val), 1, 1, 0);
                 if (ret != 0) {
                     if (ret < 0) {
                         /* No error message for RelaxNG. */
-                        if (ctxtGiven) {                            
+                        if (ctxtGiven) {
                             xmlSchemaCustomErr(ACTXT_CAST pctxt,
                                 XML_SCHEMAP_INTERNAL, facet->node, NULL,
-                                "Internal error: xmlSchemaCheckFacet, " 
+                                "Internal error: xmlSchemaCheckFacet, "
                                 "failed to validate the value '%s' of the "
                                 "facet '%s' against the base type",
                                 facet->value, xmlSchemaFacetTypeToString(facet->type));
                         }
                         goto internal_error;
                     }
                     ret = XML_SCHEMAP_INVALID_FACET_VALUE;
                     /* No error message for RelaxNG. */
                     if (ctxtGiven) {
                         xmlChar *str = NULL;
@@ skipping 54 matching lines @@
                             "validating facet value");
                     }
                     goto internal_error;
                 }
                 ret = XML_SCHEMAP_INVALID_FACET_VALUE;
                 /* No error message for RelaxNG. */
                 if (ctxtGiven) {
                     /* error code */
                     xmlSchemaCustomErr4(ACTXT_CAST pctxt,
                         ret, facet->node, WXS_BASIC_CAST typeDecl,
-                        "The value '%s' of the facet '%s' is not a valid '%s'",                 
+                        "The value '%s' of the facet '%s' is not a valid '%s'",
                         facet->value,
                         xmlSchemaFacetTypeToString(facet->type),
-                        (facet->type != XML_SCHEMA_FACET_TOTALDIGITS) ? 
+                        (facet->type != XML_SCHEMA_FACET_TOTALDIGITS) ?
                             BAD_CAST "nonNegativeInteger" :
                             BAD_CAST "positiveInteger",
                         NULL);
                 }
             }
             break;
-            
+
         case XML_SCHEMA_FACET_WHITESPACE:{
                 if (xmlStrEqual(facet->value, BAD_CAST "preserve")) {
                     facet->whitespace = XML_SCHEMAS_FACET_PRESERVE;
                 } else if (xmlStrEqual(facet->value, BAD_CAST "replace")) {
                     facet->whitespace = XML_SCHEMAS_FACET_REPLACE;
                 } else if (xmlStrEqual(facet->value, BAD_CAST "collapse")) {
                     facet->whitespace = XML_SCHEMAS_FACET_COLLAPSE;
                 } else {
                     ret = XML_SCHEMAP_INVALID_FACET_VALUE;
                     /* No error message for RelaxNG. */
@@ skipping 192 matching lines @@
 {
     xmlSchemaParticlePtr particle = WXS_MODELGROUP_PARTICLE(mg);
 
     while (particle != NULL) {
         if ((WXS_PARTICLE_TERM(particle) == NULL) ||
             ((WXS_PARTICLE_TERM(particle))->type !=
                 XML_SCHEMA_TYPE_GROUP))
         {
             particle = WXS_PTC_CAST particle->next;
             continue;
-        } 
+        }
         if (WXS_MODELGROUPDEF_MODEL(WXS_PARTICLE_TERM(particle)) == NULL) {
             /*
             * TODO: Remove the particle.
             */
             WXS_PARTICLE_TERM(particle) = NULL;
             particle = WXS_PTC_CAST particle->next;
             continue;
         }
         /*
         * Assign the model group to the {term} of the particle.
@@ skipping 29 matching lines @@
     for (i = 0; i < list->nbItems; i++) {
         ref = list->items[i];
         if ((ref->type == XML_SCHEMA_EXTRA_QNAMEREF) &&
             (ref->itemType == XML_SCHEMA_TYPE_ATTRIBUTEGROUP) &&
             (ref->item != NULL))
         {
             gr = WXS_ATTR_GROUP_CAST ref->item;
             if (gr == ctxtGr)
                 return(ref);
             if (gr->flags & XML_SCHEMAS_ATTRGROUP_MARKED)
-                continue;           
+                continue;
             /*
             * Mark as visited to avoid infinite recursion on
             * circular references not yet examined.
             */
             if ((gr->attrUses) &&
                 (gr->flags & XML_SCHEMAS_ATTRGROUP_HAS_REFS))
             {
                 gr->flags |= XML_SCHEMAS_ATTRGROUP_MARKED;
                 circ = xmlSchemaCheckAttrGroupCircularRecur(ctxtGr,
-                    (xmlSchemaItemListPtr) gr->attrUses);               
+                    (xmlSchemaItemListPtr) gr->attrUses);
                 gr->flags ^= XML_SCHEMAS_ATTRGROUP_MARKED;
                 if (circ != NULL)
                     return (circ);
             }
-            
+
         }
     }
     return (NULL);
 }
 
 /**
  * xmlSchemaCheckAttrGroupCircular:
  * attrGr:  the attribute group definition
  * @ctxt:  the parser context
  * @name:  the name
  *
  * Checks for circular references of attribute groups.
  */
 static int
 xmlSchemaCheckAttrGroupCircular(xmlSchemaAttributeGroupPtr attrGr,
                                 xmlSchemaParserCtxtPtr ctxt)
 {
     /*
     * Schema Representation Constraint:
     * Attribute Group Definition Representation OK
     * 3 Circular group reference is disallowed outside <redefine>.
     * That is, unless this element information item's parent is
     * <redefine>, then among the [children], if any, there must
     * not be an <attributeGroup> with ref [attribute] which resolves
     * to the component corresponding to this <attributeGroup>. Indirect
     * circularity is also ruled out. That is, when QName resolution
-    * (Schema Document) (§3.15.3) is applied to a ·QName· arising from
+    * (Schema Document) (�3.15.3) is applied to a �QName� arising from
     * any <attributeGroup>s with a ref [attribute] among the [children],
-    * it must not be the case that a ·QName· is encountered at any depth
+    * it must not be the case that a �QName� is encountered at any depth
     * which resolves to the component corresponding to this <attributeGroup>.
     */
     if (attrGr->attrUses == NULL)
         return(0);
     else if ((attrGr->flags & XML_SCHEMAS_ATTRGROUP_HAS_REFS) == 0)
         return(0);
     else {
         xmlSchemaQNameRefPtr circ;
-        
+
         circ = xmlSchemaCheckAttrGroupCircularRecur(attrGr,
-            (xmlSchemaItemListPtr) attrGr->attrUses);   
+            (xmlSchemaItemListPtr) attrGr->attrUses);
         if (circ != NULL) {
             xmlChar *str = NULL;
             /*
             * TODO: Report the referenced attr group as QName.
             */
             xmlSchemaPCustomErr(ctxt,
                 XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_3,
                 NULL, WXS_ITEM_NODE(WXS_BASIC_CAST circ),
                 "Circular reference to the attribute group '%s' "
                 "defined", xmlSchemaGetComponentQName(&str, attrGr));
@@ skipping 11 matching lines @@
 }
 
 static int
 xmlSchemaAttributeGroupExpandRefs(xmlSchemaParserCtxtPtr pctxt,
                                   xmlSchemaAttributeGroupPtr attrGr);
 
 /**
  * xmlSchemaExpandAttributeGroupRefs:
  * @pctxt: the parser context
  * @node: the node of the component holding the attribute uses
- * @completeWild: the intersected wildcard to be returned 
+ * @completeWild: the intersected wildcard to be returned
  * @list: the attribute uses
  *
  * Substitutes contained attribute group references
  * for their attribute uses. Wilcards are intersected.
  * Attribute use prohibitions are removed from the list
  * and returned via the @prohibs list.
  * Pointlessness of attr. prohibs, if a matching attr. decl
  * is existent a well, are checked.
  */
 static int
 xmlSchemaExpandAttributeGroupRefs(xmlSchemaParserCtxtPtr pctxt,
                                   xmlSchemaBasicItemPtr item,
                                   xmlSchemaWildcardPtr *completeWild,
                                   xmlSchemaItemListPtr list,
                                   xmlSchemaItemListPtr prohibs)
 {
     xmlSchemaAttributeGroupPtr gr;
     xmlSchemaAttributeUsePtr use;
     xmlSchemaItemListPtr sublist;
     int i, j;
     int created = (*completeWild == NULL) ? 0 : 1;
 
     if (prohibs)
         prohibs->nbItems = 0;
 
     for (i = 0; i < list->nbItems; i++) {
         use = list->items[i];
 
-        if (use->type == XML_SCHEMA_EXTRA_ATTR_USE_PROHIB) {        
+        if (use->type == XML_SCHEMA_EXTRA_ATTR_USE_PROHIB) {
             if (prohibs == NULL) {
                 PERROR_INT("xmlSchemaExpandAttributeGroupRefs",
                     "unexpected attr prohibition found");
                 return(-1);
             }
             /*
             * Remove from attribute uses.
             */
             if (xmlSchemaItemListRemove(list, i) == -1)
                 return(-1);
             i--;
             /*
             * Note that duplicate prohibitions were already
             * handled at parsing time.
-            */      
+            */
             /*
             * Add to list of prohibitions.
             */
             xmlSchemaItemListAddSize(prohibs, 2, use);
             continue;
         }
         if ((use->type == XML_SCHEMA_EXTRA_QNAMEREF) &&
             ((WXS_QNAME_CAST use)->itemType == XML_SCHEMA_TYPE_ATTRIBUTEGROUP))
         {
             if ((WXS_QNAME_CAST use)->item == NULL)
@@ skipping 32 matching lines @@
                             WXS_ITEM_NODE(item));
                         if (tmpWild == NULL)
                             return(-1);
                         if (xmlSchemaCloneWildcardNsConstraints(pctxt,
                             tmpWild, *completeWild) == -1)
                             return (-1);
                         tmpWild->processContents = (*completeWild)->processContents;
                         *completeWild = tmpWild;
                         created = 1;
                     }
-                    
+
                     if (xmlSchemaIntersectWildcards(pctxt, *completeWild,
                         gr->attributeWildcard) == -1)
                         return(-1);
                 }
             }
             /*
             * Just remove the reference if the referenced group does not
             * contain any attribute uses.
             */
             sublist = ((xmlSchemaItemListPtr) gr->attrUses);
@@ skipping 53 matching lines @@
                 }
             }
         }
     }
     return(0);
 }
 
 /**
  * xmlSchemaAttributeGroupExpandRefs:
  * @pctxt:  the parser context
- * @attrGr:  the attribute group definition 
+ * @attrGr:  the attribute group definition
  *
  * Computation of:
  * {attribute uses} property
  * {attribute wildcard} property
  *
  * Substitutes contained attribute group references
  * for their attribute uses. Wilcards are intersected.
  */
 static int
 xmlSchemaAttributeGroupExpandRefs(xmlSchemaParserCtxtPtr pctxt,
                                   xmlSchemaAttributeGroupPtr attrGr)
-{  
+{
     if ((attrGr->attrUses == NULL) ||
         (attrGr->flags & XML_SCHEMAS_ATTRGROUP_WILDCARD_BUILDED))
         return(0);
 
     attrGr->flags |= XML_SCHEMAS_ATTRGROUP_WILDCARD_BUILDED;
     if (xmlSchemaExpandAttributeGroupRefs(pctxt, WXS_BASIC_CAST attrGr,
         &(attrGr->attributeWildcard), attrGr->attrUses, NULL) == -1)
-        return(-1);    
+        return(-1);
     return(0);
 }
 
 /**
  * xmlSchemaAttributeGroupExpandRefs:
  * @pctxt:  the parser context
- * @attrGr:  the attribute group definition 
+ * @attrGr:  the attribute group definition
  *
  * Substitutes contained attribute group references
  * for their attribute uses. Wilcards are intersected.
- * 
+ *
  * Schema Component Constraint:
- *    Attribute Group Definition Properties Correct (ag-props-correct) 
+ *    Attribute Group Definition Properties Correct (ag-props-correct)
  */
 static int
 xmlSchemaCheckAGPropsCorrect(xmlSchemaParserCtxtPtr pctxt,
                                   xmlSchemaAttributeGroupPtr attrGr)
-{  
+{
     /*
     * SPEC ag-props-correct
     * (1) "The values of the properties of an attribute group definition
     * must be as described in the property tableau in The Attribute
-    * Group Definition Schema Component (§3.6.1), modulo the impact of
-    * Missing Sub-components (§5.3);"
+    * Group Definition Schema Component (�3.6.1), modulo the impact of
+    * Missing Sub-components (�5.3);"
     */
-    
+
     if ((attrGr->attrUses != NULL) &&
         (WXS_LIST_CAST attrGr->attrUses)->nbItems > 1)
     {
         xmlSchemaItemListPtr uses = WXS_LIST_CAST attrGr->attrUses;
         xmlSchemaAttributeUsePtr use, tmp;
         int i, j, hasId = 0;
 
         for (i = uses->nbItems -1; i >= 0; i--) {
-            use = uses->items[i];           
+            use = uses->items[i];
             /*
             * SPEC ag-props-correct
             * (2) "Two distinct members of the {attribute uses} must not have
             * {attribute declaration}s both of whose {name}s match and whose
             * {target namespace}s are identical."
             */
             if (i > 0) {
                 for (j = i -1; j >= 0; j--) {
                     tmp = uses->items[j];
                     if ((WXS_ATTRUSE_DECL_NAME(use) ==
                         WXS_ATTRUSE_DECL_NAME(tmp)) &&
                         (WXS_ATTRUSE_DECL_TNS(use) ==
                         WXS_ATTRUSE_DECL_TNS(tmp)))
                     {
                         xmlChar *str = NULL;
-                        
+
                         xmlSchemaCustomErr(ACTXT_CAST pctxt,
                             XML_SCHEMAP_AG_PROPS_CORRECT,
                             attrGr->node, WXS_BASIC_CAST attrGr,
                             "Duplicate %s",
                             xmlSchemaGetComponentDesignation(&str, use),
                             NULL);
                         FREE_AND_NULL(str);
                         /*
                         * Remove the duplicate.
                         */
                         if (xmlSchemaItemListRemove(uses, i) == -1)
                             return(-1);
                         goto next_use;
                     }
                 }
             }
             /*
             * SPEC ag-props-correct
             * (3) "Two distinct members of the {attribute uses} must not have
             * {attribute declaration}s both of whose {type definition}s are or
             * are derived from ID."
             * TODO: Does 'derived' include member-types of unions?
             */
-            if (WXS_ATTRUSE_TYPEDEF(use) != NULL) {             
+            if (WXS_ATTRUSE_TYPEDEF(use) != NULL) {
                 if (xmlSchemaIsDerivedFromBuiltInType(
                     WXS_ATTRUSE_TYPEDEF(use), XML_SCHEMAS_ID))
-                {               
+                {
                     if (hasId) {
                         xmlChar *str = NULL;
-                        
+
                         xmlSchemaCustomErr(ACTXT_CAST pctxt,
                             XML_SCHEMAP_AG_PROPS_CORRECT,
                             attrGr->node, WXS_BASIC_CAST attrGr,
                             "There must not exist more than one attribute "
                             "declaration of type 'xs:ID' "
                             "(or derived from 'xs:ID'). The %s violates this "
                             "constraint",
                             xmlSchemaGetComponentDesignation(&str, use),
                             NULL);
                         FREE_AND_NULL(str);
                         if (xmlSchemaItemListRemove(uses, i) == -1)
                             return(-1);
-                    }               
+                    }
                     hasId = 1;
                 }
             }
 next_use: {}
         }
     }
     return(0);
 }
 
 /**
@@ skipping 43 matching lines @@
  */
 static int
 xmlSchemaCheckAttrPropsCorrect(xmlSchemaParserCtxtPtr pctxt,
                                xmlSchemaAttributePtr attr)
 {
 
     /*
     * SPEC a-props-correct (1)
     * "The values of the properties of an attribute declaration must
     * be as described in the property tableau in The Attribute
-    * Declaration Schema Component (§3.2.1), modulo the impact of
-    * Missing Sub-components (§5.3)."
+    * Declaration Schema Component (�3.2.1), modulo the impact of
+    * Missing Sub-components (�5.3)."
     */
-    
+
     if (WXS_ATTR_TYPEDEF(attr) == NULL)
         return(0);
 
     if (attr->defValue != NULL) {
         int ret;
 
         /*
         * SPEC a-props-correct (3)
         * "If the {type definition} is or is derived from ID then there
         * must not be a {value constraint}."
         */
         if (xmlSchemaIsDerivedFromBuiltInType(
             WXS_ATTR_TYPEDEF(attr), XML_SCHEMAS_ID))
         {
             xmlSchemaCustomErr(ACTXT_CAST pctxt,
                 XML_SCHEMAP_A_PROPS_CORRECT_3,
                 NULL, WXS_BASIC_CAST attr,
                 "Value constraints are not allowed if the type definition "
                 "is or is derived from xs:ID",
                 NULL, NULL);
             return(pctxt->err);
         }
         /*
         * SPEC a-props-correct (2)
         * "if there is a {value constraint}, the canonical lexical
-        * representation of its value must be ·valid· with respect
-        * to the {type definition} as defined in String Valid (§3.14.4)."
+        * representation of its value must be �valid� with respect
+        * to the {type definition} as defined in String Valid (�3.14.4)."
         * TODO: Don't care about the *cononical* stuff here, this requirement
         * will be removed in WXS 1.1 anyway.
         */
         ret = xmlSchemaVCheckCVCSimpleType(ACTXT_CAST pctxt,
             attr->node, WXS_ATTR_TYPEDEF(attr),
             attr->defValue, &(attr->defVal),
             1, 1, 0);
         if (ret != 0) {
             if (ret < 0) {
                 PERROR_INT("xmlSchemaCheckAttrPropsCorrect",
                     "calling xmlSchemaVCheckCVCSimpleType()");
                 return(-1);
             }
             xmlSchemaCustomErr(ACTXT_CAST pctxt,
                 XML_SCHEMAP_A_PROPS_CORRECT_2,
                 NULL, WXS_BASIC_CAST attr,
                 "The value of the value constraint is not valid",
                 NULL, NULL);
             return(pctxt->err);
         }
     }
-   
+
     return(0);
 }
 
 static xmlSchemaElementPtr
 xmlSchemaCheckSubstGroupCircular(xmlSchemaElementPtr elemDecl,
                                  xmlSchemaElementPtr ancestor)
 {
     xmlSchemaElementPtr ret;
 
     if (WXS_SUBST_HEAD(ancestor) == NULL)
@@ skipping 25 matching lines @@
  */
 static int
 xmlSchemaCheckElemPropsCorrect(xmlSchemaParserCtxtPtr pctxt,
                                xmlSchemaElementPtr elemDecl)
 {
     int ret = 0;
     xmlSchemaTypePtr typeDef = WXS_ELEM_TYPEDEF(elemDecl);
     /*
     * SPEC (1) "The values of the properties of an element declaration
     * must be as described in the property tableau in The Element
-    * Declaration Schema Component (§3.3.1), modulo the impact of Missing
-    * Sub-components (§5.3)."
+    * Declaration Schema Component (�3.3.1), modulo the impact of Missing
+    * Sub-components (�5.3)."
     */
     if (WXS_SUBST_HEAD(elemDecl) != NULL) {
         xmlSchemaElementPtr head = WXS_SUBST_HEAD(elemDecl), circ;
 
         xmlSchemaCheckElementDeclComponent(head, pctxt);
         /*
-        * SPEC (3) "If there is a non-·absent· {substitution group
+        * SPEC (3) "If there is a non-�absent� {substitution group
         * affiliation}, then {scope} must be global."
         */
         if ((elemDecl->flags & XML_SCHEMAS_ELEM_GLOBAL) == 0) {
             xmlSchemaPCustomErr(pctxt,
                 XML_SCHEMAP_E_PROPS_CORRECT_3,
                 WXS_BASIC_CAST elemDecl, NULL,
                 "Only global element declarations can have a "
                 "substitution group affiliation", NULL);
             ret = XML_SCHEMAP_E_PROPS_CORRECT_3;
         }
@@ skipping 23 matching lines @@
             FREE_AND_NULL(strA)
             FREE_AND_NULL(strB)
             ret = XML_SCHEMAP_E_PROPS_CORRECT_6;
         }
         /*
         * SPEC (4) "If there is a {substitution group affiliation},
         * the {type definition}
         * of the element declaration must be validly derived from the {type
         * definition} of the {substitution group affiliation}, given the value
         * of the {substitution group exclusions} of the {substitution group
-        * affiliation}, as defined in Type Derivation OK (Complex) (§3.4.6)
+        * affiliation}, as defined in Type Derivation OK (Complex) (�3.4.6)
         * (if the {type definition} is complex) or as defined in
-        * Type Derivation OK (Simple) (§3.14.6) (if the {type definition} is
+        * Type Derivation OK (Simple) (�3.14.6) (if the {type definition} is
         * simple)."
         *
         * NOTE: {substitution group exclusions} means the values of the
         * attribute "final".
         */
 
         if (typeDef != WXS_ELEM_TYPEDEF(WXS_SUBST_HEAD(elemDecl))) {
             int set = 0;
 
             if (head->flags & XML_SCHEMAS_ELEM_FINAL_EXTENSION)
@@ skipping 43 matching lines @@
             WXS_BASIC_CAST elemDecl, NULL,
             "The type definition (or type definition's content type) is or "
             "is derived from ID; value constraints are not allowed in "
             "conjunction with such a type definition", NULL);
     } else if (elemDecl->value != NULL) {
         int vcret;
         xmlNodePtr node = NULL;
 
         /*
         * SPEC (2) "If there is a {value constraint}, the canonical lexical
-        * representation of its value must be ·valid· with respect to the
+        * representation of its value must be �valid� with respect to the
         * {type definition} as defined in Element Default Valid (Immediate)
-        * (§3.3.6)."
+        * (�3.3.6)."
         */
         if (typeDef == NULL) {
             xmlSchemaPErr(pctxt, elemDecl->node,
                 XML_SCHEMAP_INTERNAL,
                 "Internal error: xmlSchemaCheckElemPropsCorrect, "
                 "type is missing... skipping validation of "
                 "the value constraint", NULL, NULL);
             return (-1);
         }
         if (elemDecl->node != NULL) {
@@ skipping 47 matching lines @@
         /* SPEC (1) "Its {abstract} is false." */
         (elemDecl->flags & XML_SCHEMAS_ELEM_ABSTRACT))
         return;
     {
         xmlSchemaElementPtr head;
         xmlSchemaTypePtr headType, type;
         int set, methSet;
         /*
         * SPEC (2) "It is validly substitutable for HEAD subject to HEAD's
         * {disallowed substitutions} as the blocking constraint, as defined in
-        * Substitution Group OK (Transitive) (§3.3.6)."
+        * Substitution Group OK (Transitive) (�3.3.6)."
         */
         for (head = WXS_SUBST_HEAD(elemDecl); head != NULL;
             head = WXS_SUBST_HEAD(head)) {
             set = 0;
             methSet = 0;
             /*
             * The blocking constraints.
             */
             if (head->flags & XML_SCHEMAS_ELEM_BLOCK_SUBSTITUTION)
                 continue;
@@ skipping 71 matching lines @@
 }
 
 #ifdef WXS_ELEM_DECL_CONS_ENABLED /* enable when finished */
 /**
  * xmlSchemaCheckElementDeclComponent
  * @pctxt: the schema parser context
  * @ctxtComponent: the context component (an element declaration)
  * @ctxtParticle: the first particle of the context component
  * @searchParticle: the element declaration particle to be analysed
  *
- * Schema Component Constraint: Element Declarations Consistent 
+ * Schema Component Constraint: Element Declarations Consistent
  */
 static int
 xmlSchemaCheckElementDeclConsistent(xmlSchemaParserCtxtPtr pctxt,
                                     xmlSchemaBasicItemPtr ctxtComponent,
-                                    xmlSchemaParticlePtr ctxtParticle,                              
+                                    xmlSchemaParticlePtr ctxtParticle,
                                     xmlSchemaParticlePtr searchParticle,
                                     xmlSchemaParticlePtr curParticle,
                                     int search)
 {
     return(0);
 
     int ret = 0;
     xmlSchemaParticlePtr cur = curParticle;
-    if (curParticle == NULL) {  
+    if (curParticle == NULL) {
         return(0);
     }
     if (WXS_PARTICLE_TERM(curParticle) == NULL) {
         /*
         * Just return in this case. A missing "term" of the particle
         * might arise due to an invalid "term" component.
         */
         return(0);
-    }    
+    }
     while (cur != NULL) {
         switch (WXS_PARTICLE_TERM(cur)->type) {
             case XML_SCHEMA_TYPE_ANY:
                 break;
             case XML_SCHEMA_TYPE_ELEMENT:
                 if (search == 0) {
                     ret = xmlSchemaCheckElementDeclConsistent(pctxt,
                         ctxtComponent, ctxtParticle, cur, ctxtParticle, 1);
                     if (ret != 0)
-                        return(ret);                
+                        return(ret);
                 } else {
                     xmlSchemaElementPtr elem =
                         WXS_ELEM_CAST(WXS_PARTICLE_TERM(cur));
                     /*
                     * SPEC Element Declarations Consistent:
                     * "If the {particles} contains, either directly,
                     * indirectly (that is, within the {particles} of a
-                    * contained model group, recursively) or ·implicitly·
+                    * contained model group, recursively) or �implicitly�
                     * two or more element declaration particles with
                     * the same {name} and {target namespace}, then
                     * all their type definitions must be the same
                     * top-level definition [...]"
                     */
                     if (xmlStrEqual(WXS_PARTICLE_TERM_AS_ELEM(cur)->name,
                             WXS_PARTICLE_TERM_AS_ELEM(searchParticle)->name) &&
                         xmlStrEqual(WXS_PARTICLE_TERM_AS_ELEM(cur)->targetNamespace,
                             WXS_PARTICLE_TERM_AS_ELEM(searchParticle)->targetNamespace))
                     {
                         xmlChar *strA = NULL, *strB = NULL;
-                        
+
                         xmlSchemaCustomErr(ACTXT_CAST pctxt,
                             /* TODO: error code */
                             XML_SCHEMAP_COS_NONAMBIG,
                             WXS_ITEM_NODE(cur), NULL,
                             "In the content model of %s, there are multiple "
                             "element declarations for '%s' with different "
                             "type definitions",
                             xmlSchemaGetComponentDesignation(&strA,
                                 ctxtComponent),
                             xmlSchemaFormatQName(&strB,
                                 WXS_PARTICLE_TERM_AS_ELEM(cur)->targetNamespace,
                                 WXS_PARTICLE_TERM_AS_ELEM(cur)->name));
                         FREE_AND_NULL(strA);
                         FREE_AND_NULL(strB);
                         return(XML_SCHEMAP_COS_NONAMBIG);
                     }
-                }           
+                }
                 break;
-            case XML_SCHEMA_TYPE_SEQUENCE: {            
+            case XML_SCHEMA_TYPE_SEQUENCE: {
                 break;
                 }
             case XML_SCHEMA_TYPE_CHOICE:{
                 /*
                 xmlSchemaTreeItemPtr sub;
-                
-                sub = WXS_PARTICLE_TERM(particle)->children;  (xmlSchemaParticlePtr) 
+
+                sub = WXS_PARTICLE_TERM(particle)->children;  (xmlSchemaParticlePtr)
                 while (sub != NULL) {
                     ret = xmlSchemaCheckElementDeclConsistent(pctxt, ctxtComponent,
                         ctxtParticle, ctxtElem);
                     if (ret != 0)
                         return(ret);
                     sub = sub->next;
                 }
                 */
                 break;
                 }
@@ skipping 16 matching lines @@
 }
 #endif
 
 /**
  * xmlSchemaCheckElementDeclComponent
  * @item:  an schema element declaration/particle
  * @ctxt:  a schema parser context
  * @name:  the name of the attribute
  *
  * Validates the value constraints of an element declaration.
- * Adds substitution group members. 
+ * Adds substitution group members.
  */
 static void
 xmlSchemaCheckElementDeclComponent(xmlSchemaElementPtr elemDecl,
                                    xmlSchemaParserCtxtPtr ctxt)
 {
     if (elemDecl == NULL)
         return;
     if (elemDecl->flags & XML_SCHEMAS_ELEM_INTERNAL_CHECKED)
         return;
     elemDecl->flags |= XML_SCHEMAS_ELEM_INTERNAL_CHECKED;
     if (xmlSchemaCheckElemPropsCorrect(ctxt, elemDecl) == 0) {
         /*
         * Adds substitution group members.
         */
-        xmlSchemaCheckElemSubstGroup(ctxt, elemDecl);   
+        xmlSchemaCheckElemSubstGroup(ctxt, elemDecl);
     }
 }
 
 /**
  * xmlSchemaResolveModelGroupParticleReferences:
  * @particle:  a particle component
  * @ctxt:  a parser context
  *
  * Resolves references of a model group's {particles} to
  * model group definitions and to element declarations.
  */
 static void
 xmlSchemaResolveModelGroupParticleReferences(
     xmlSchemaParserCtxtPtr ctxt,
     xmlSchemaModelGroupPtr mg)
 {
     xmlSchemaParticlePtr particle = WXS_MODELGROUP_PARTICLE(mg);
     xmlSchemaQNameRefPtr ref;
     xmlSchemaBasicItemPtr refItem;
 
     /*
     * URGENT TODO: Test this.
     */
     while (particle != NULL) {
         if ((WXS_PARTICLE_TERM(particle) == NULL) ||
             ((WXS_PARTICLE_TERM(particle))->type !=
                 XML_SCHEMA_EXTRA_QNAMEREF))
         {
             goto next_particle;
-        } 
+        }
         ref = WXS_QNAME_CAST WXS_PARTICLE_TERM(particle);
         /*
         * Resolve the reference.
         * NULL the {term} by default.
         */
         particle->children = NULL;
 
         refItem = xmlSchemaGetNamedComponent(ctxt->schema,
             ref->itemType, ref->name, ref->targetNamespace);
         if (refItem == NULL) {
             xmlSchemaPResCompAttrErr(ctxt, XML_SCHEMAP_SRC_RESOLVE,
                 NULL, WXS_ITEM_NODE(particle), "ref", ref->name,
                 ref->targetNamespace, ref->itemType, NULL);
             /* TODO: remove the particle. */
             goto next_particle;
-        } 
+        }
         if (refItem->type == XML_SCHEMA_TYPE_GROUP) {
             if (WXS_MODELGROUPDEF_MODEL(refItem) == NULL)
                 /* TODO: remove the particle. */
                 goto next_particle;
             /*
             * NOTE that we will assign the model group definition
             * itself to the "term" of the particle. This will ease
             * the check for circular model group definitions. After
             * that the "term" will be assigned the model group of the
             * model group definition.
@@ skipping 29 matching lines @@
             */
             particle->children = (xmlSchemaTreeItemPtr) refItem;
         }
 next_particle:
         particle = WXS_PTC_CAST particle->next;
     }
 }
 
 static int
 xmlSchemaAreValuesEqual(xmlSchemaValPtr x,
-                       xmlSchemaValPtr y) 
-{   
-    xmlSchemaTypePtr tx, ty, ptx, pty;    
+                       xmlSchemaValPtr y)
+{
+    xmlSchemaTypePtr tx, ty, ptx, pty;
     int ret;
 
     while (x != NULL) {
         /* Same types. */
         tx = xmlSchemaGetBuiltInType(xmlSchemaGetValType(x));
         ty = xmlSchemaGetBuiltInType(xmlSchemaGetValType(y));
         ptx = xmlSchemaGetPrimitiveType(tx);
         pty = xmlSchemaGetPrimitiveType(ty);
         /*
-        * (1) if a datatype T' is ·derived· by ·restriction· from an
-        * atomic datatype T then the ·value space· of T' is a subset of
-        * the ·value space· of T. */
+        * (1) if a datatype T' is �derived� by �restriction� from an
+        * atomic datatype T then the �value space� of T' is a subset of
+        * the �value space� of T. */
         /*
-        * (2) if datatypes T' and T'' are ·derived· by ·restriction·
-        * from a common atomic ancestor T then the ·value space·s of T'
+        * (2) if datatypes T' and T'' are �derived� by �restriction�
+        * from a common atomic ancestor T then the �value space�s of T'
         * and T'' may overlap.
         */
         if (ptx != pty)
             return(0);
         /*
         * We assume computed values to be normalized, so do a fast
         * string comparison for string based types.
         */
         if ((ptx->builtInType == XML_SCHEMAS_STRING) ||
             WXS_IS_ANY_SIMPLE_TYPE(ptx)) {
@@ skipping 10 matching lines @@
             if (ret != 0)
                 return(0);
         }
         /*
         * Lists.
         */
         x = xmlSchemaValueGetNext(x);
         if (x != NULL) {
             y = xmlSchemaValueGetNext(y);
             if (y == NULL)
-                return (0);         
+                return (0);
         } else if (xmlSchemaValueGetNext(y) != NULL)
             return (0);
         else
             return (1);
     }
     return (0);
 }
 
 /**
  * xmlSchemaResolveAttrUseReferences:
@@ skipping 29 matching lines @@
                 XML_SCHEMA_TYPE_ATTRIBUTE, NULL);
             return(ctxt->err);;
         }
     }
     return(0);
 }
 
 /**
  * xmlSchemaCheckAttrUsePropsCorrect:
  * @ctxt:  a parser context
- * @use:  an attribute use 
+ * @use:  an attribute use
  *
  * Schema Component Constraint:
  * Attribute Use Correct (au-props-correct)
- * 
+ *
  */
 static int
 xmlSchemaCheckAttrUsePropsCorrect(xmlSchemaParserCtxtPtr ctxt,
                              xmlSchemaAttributeUsePtr use)
 {
     if ((ctxt == NULL) || (use == NULL))
         return(-1);
     if ((use->defValue == NULL) || (WXS_ATTRUSE_DECL(use) == NULL) ||
         ((WXS_ATTRUSE_DECL(use))->type != XML_SCHEMA_TYPE_ATTRIBUTE))
-        return(0);      
+        return(0);
 
     /*
     * SPEC au-props-correct (1)
     * "The values of the properties of an attribute use must be as
     * described in the property tableau in The Attribute Use Schema
-    * Component (§3.5.1), modulo the impact of Missing
-    * Sub-components (§5.3)."
+    * Component (�3.5.1), modulo the impact of Missing
+    * Sub-components (�5.3)."
     */
-    
+
     if (((WXS_ATTRUSE_DECL(use))->defValue != NULL) &&
         ((WXS_ATTRUSE_DECL(use))->flags & XML_SCHEMAS_ATTR_FIXED) &&
         ((use->flags & XML_SCHEMA_ATTR_USE_FIXED) == 0))
     {
         xmlSchemaPCustomErr(ctxt,
             XML_SCHEMAP_AU_PROPS_CORRECT_2,
             WXS_BASIC_CAST use, NULL,
             "The attribute declaration has a 'fixed' value constraint "
             ", thus the attribute use must also have a 'fixed' value "
             "constraint",
             NULL);
         return(ctxt->err);
     }
     /*
     * Compute and check the value constraint's value.
     */
     if ((use->defVal != NULL) && (WXS_ATTRUSE_TYPEDEF(use) != NULL)) {
         int ret;
         /*
-        * TODO: The spec seems to be missing a check of the 
+        * TODO: The spec seems to be missing a check of the
         * value constraint of the attribute use. We will do it here.
         */
         /*
         * SPEC a-props-correct (3)
         */
         if (xmlSchemaIsDerivedFromBuiltInType(
             WXS_ATTRUSE_TYPEDEF(use), XML_SCHEMAS_ID))
         {
             xmlSchemaCustomErr(ACTXT_CAST ctxt,
                 XML_SCHEMAP_AU_PROPS_CORRECT,
                 NULL, WXS_BASIC_CAST use,
                 "Value constraints are not allowed if the type definition "
                 "is or is derived from xs:ID",
                 NULL, NULL);
             return(ctxt->err);
         }
-        
+
         ret = xmlSchemaVCheckCVCSimpleType(ACTXT_CAST ctxt,
             use->node, WXS_ATTRUSE_TYPEDEF(use),
             use->defValue, &(use->defVal),
             1, 1, 0);
         if (ret != 0) {
             if (ret < 0) {
                 PERROR_INT2("xmlSchemaCheckAttrUsePropsCorrect",
                     "calling xmlSchemaVCheckCVCSimpleType()");
                 return(-1);
             }
@@ skipping 30 matching lines @@
     }
     return(0);
 }
 
 
 
 
 /**
  * xmlSchemaResolveAttrTypeReferences:
  * @item:  an attribute declaration
- * @ctxt:  a parser context 
+ * @ctxt:  a parser context
  *
  * Resolves the referenced type definition component.
  */
 static int
 xmlSchemaResolveAttrTypeReferences(xmlSchemaAttributePtr item,
                                    xmlSchemaParserCtxtPtr ctxt)
 {
     /*
     * The simple type definition corresponding to the <simpleType> element
     * information item in the [children], if present, otherwise the simple
-    * type definition ·resolved· to by the ·actual value· of the type
-    * [attribute], if present, otherwise the ·simple ur-type definition·.
+    * type definition �resolved� to by the �actual value� of the type
+    * [attribute], if present, otherwise the �simple ur-type definition�.
     */
     if (item->flags & XML_SCHEMAS_ATTR_INTERNAL_RESOLVED)
         return(0);
     item->flags |= XML_SCHEMAS_ATTR_INTERNAL_RESOLVED;
     if (item->subtypes != NULL)
         return(0);
     if (item->typeName != NULL) {
         xmlSchemaTypePtr type;
 
         type = xmlSchemaGetType(ctxt->schema, item->typeName,
@@ skipping 58 matching lines @@
                 NULL, WXS_BASIC_CAST idc,
                 "The keyref references a keyref",
                 NULL, NULL);
             idc->ref->item = NULL;
             return(pctxt->err);
         } else {
             if (idc->nbFields !=
                 ((xmlSchemaIDCPtr) idc->ref->item)->nbFields) {
                 xmlChar *str = NULL;
                 xmlSchemaIDCPtr refer;
-                
+
                 refer = (xmlSchemaIDCPtr) idc->ref->item;
                 /*
                 * SPEC c-props-correct(2)
                 * "If the {identity-constraint category} is keyref,
                 * the cardinality of the {fields} must equal that of
                 * the {fields} of the {referenced key}.
                 */
                 xmlSchemaCustomErr(ACTXT_CAST pctxt,
                     XML_SCHEMAP_C_PROPS_CORRECT,
                     NULL, WXS_BASIC_CAST idc,
@@ skipping 38 matching lines @@
 
 static int
 xmlSchemaCheckSRCRedefineFirst(xmlSchemaParserCtxtPtr pctxt)
 {
     int err = 0;
     xmlSchemaRedefPtr redef = WXS_CONSTRUCTOR(pctxt)->redefs;
     xmlSchemaBasicItemPtr prev, item;
     int wasRedefined;
 
     if (redef == NULL)
-        return(0);      
+        return(0);
 
     do {
         item = redef->item;
         /*
         * First try to locate the redefined component in the
         * schema graph starting with the redefined schema.
         * NOTE: According to this schema bug entry:
         *   http://lists.w3.org/Archives/Public/www-xml-schema-comments/2005OctDec/0019.html
         *   it's not clear if the referenced component needs to originate
         *   from the <redefine>d schema _document_ or the schema; the latter
         *   would include all imported and included sub-schemas of the
         *   <redefine>d schema. Currenlty we latter approach is used.
         *   SUPPLEMENT: It seems that the WG moves towards the latter
         *   approach, so we are doing it right.
-        *   
+        *
         */
         prev = xmlSchemaFindRedefCompInGraph(
             redef->targetBucket, item->type,
             redef->refName, redef->refTargetNs);
         if (prev == NULL) {
             xmlChar *str = NULL;
             xmlNodePtr node;
 
             /*
             * SPEC src-redefine:
-            * (6.2.1) "The ·actual value· of its own name attribute plus
-            * target namespace must successfully ·resolve· to a model
+            * (6.2.1) "The �actual value� of its own name attribute plus
+            * target namespace must successfully �resolve� to a model
             * group definition in I."
-            * (7.2.1) "The ·actual value· of its own name attribute plus
-            * target namespace must successfully ·resolve· to an attribute
+            * (7.2.1) "The �actual value� of its own name attribute plus
+            * target namespace must successfully �resolve� to an attribute
             * group definition in I."
 
             *
             * Note that, if we are redefining with the use of references
             * to components, the spec assumes the src-resolve to be used;
             * but this won't assure that we search only *inside* the
             * redefined schema.
             */
             if (redef->reference)
                 node = WXS_ITEM_NODE(redef->reference);
             else
                 node = WXS_ITEM_NODE(item);
             xmlSchemaCustomErr(ACTXT_CAST pctxt,
                 /*
                 * TODO: error code.
                 * Probably XML_SCHEMAP_SRC_RESOLVE, if this is using the
-                * reference kind.               
+                * reference kind.
                 */
                 XML_SCHEMAP_SRC_REDEFINE, node, NULL,
                 "The %s '%s' to be redefined could not be found in "
                 "the redefined schema",
                 WXS_ITEM_TYPE_NAME(item),
                 xmlSchemaFormatQName(&str, redef->refTargetNs,
                     redef->refName));
-            FREE_AND_NULL(str);     
+            FREE_AND_NULL(str);
             err = pctxt->err;
             redef = redef->next;
             continue;
         }
         /*
         * TODO: Obtaining and setting the redefinition state is really
         * clumsy.
         */
         wasRedefined = 0;
         switch (item->type) {
             case XML_SCHEMA_TYPE_COMPLEX:
             case XML_SCHEMA_TYPE_SIMPLE:
                 if ((WXS_TYPE_CAST prev)->flags &
                     XML_SCHEMAS_TYPE_REDEFINED)
                 {
                     wasRedefined = 1;
                     break;
                 }
                 /* Mark it as redefined. */
                 (WXS_TYPE_CAST prev)->flags |= XML_SCHEMAS_TYPE_REDEFINED;
                 /*
                 * Assign the redefined type to the
                 * base type of the redefining type.
                 * TODO: How
                 */
-                ((xmlSchemaTypePtr) item)->baseType = 
+                ((xmlSchemaTypePtr) item)->baseType =
                     (xmlSchemaTypePtr) prev;
                 break;
             case XML_SCHEMA_TYPE_GROUP:
                 if ((WXS_MODEL_GROUPDEF_CAST prev)->flags &
                     XML_SCHEMA_MODEL_GROUP_DEF_REDEFINED)
                 {
                     wasRedefined = 1;
                     break;
                 }
                 /* Mark it as redefined. */
@@ skipping 34 matching lines @@
                     * stage, i.e. when attribute group references
                     * have beed expanded and simple types have
                     * beed fixed.
                     */
                     redef->target = prev;
                 }
                 break;
             default:
                 PERROR_INT("xmlSchemaResolveRedefReferences",
                     "Unexpected redefined component type");
-                return(-1);     
+                return(-1);
         }
         if (wasRedefined) {
             xmlChar *str = NULL;
             xmlNodePtr node;
 
             if (redef->reference)
                 node = WXS_ITEM_NODE(redef->reference);
             else
                 node = WXS_ITEM_NODE(redef->item);
-            
+
             xmlSchemaCustomErr(ACTXT_CAST pctxt,
                 /* TODO: error code. */
                 XML_SCHEMAP_SRC_REDEFINE,
                 node, NULL,
                 "The referenced %s was already redefined. Multiple "
                 "redefinition of the same component is not supported",
                 xmlSchemaGetComponentDesignation(&str, prev),
                 NULL);
-            FREE_AND_NULL(str)      
+            FREE_AND_NULL(str)
             err = pctxt->err;
             redef = redef->next;
             continue;
         }
-        redef = redef->next;    
+        redef = redef->next;
     } while (redef != NULL);
 
     return(err);
 }
 
 static int
 xmlSchemaCheckSRCRedefineSecond(xmlSchemaParserCtxtPtr pctxt)
 {
     int err = 0;
     xmlSchemaRedefPtr redef = WXS_CONSTRUCTOR(pctxt)->redefs;
     xmlSchemaBasicItemPtr item;
 
     if (redef == NULL)
-        return(0);      
+        return(0);
 
     do {
         if (redef->target == NULL) {
             redef = redef->next;
             continue;
         }
         item = redef->item;
-                
+
         switch (item->type) {
             case XML_SCHEMA_TYPE_SIMPLE:
             case XML_SCHEMA_TYPE_COMPLEX:
                 /*
                 * Since the spec wants the {name} of the redefined
                 * type to be 'absent', we'll NULL it.
                 */
                 (WXS_TYPE_CAST redef->target)->name = NULL;
-                
+
                 /*
                 * TODO: Seems like there's nothing more to do. The normal
                 * inheritance mechanism is used. But not 100% sure.
                 */
                 break;
             case XML_SCHEMA_TYPE_GROUP:
                 /*
                 * URGENT TODO:
                 * SPEC src-redefine:
                 * (6.2.2) "The {model group} of the model group definition
                 * which corresponds to it per XML Representation of Model
-                * Group Definition Schema Components (§3.7.2) must be a
-                * ·valid restriction· of the {model group} of that model
+                * Group Definition Schema Components (�3.7.2) must be a
+                * �valid restriction� of the {model group} of that model
                 * group definition in I, as defined in Particle Valid
-                * (Restriction) (§3.9.6)."
+                * (Restriction) (�3.9.6)."
                 */
                 break;
             case XML_SCHEMA_TYPE_ATTRIBUTEGROUP:
                 /*
                 * SPEC src-redefine:
                 * (7.2.2) "The {attribute uses} and {attribute wildcard} of
                 * the attribute group definition which corresponds to it
                 * per XML Representation of Attribute Group Definition Schema
-                * Components (§3.6.2) must be ·valid restrictions· of the
+                * Components (�3.6.2) must be �valid restrictions� of the
                 * {attribute uses} and {attribute wildcard} of that attribute
                 * group definition in I, as defined in clause 2, clause 3 and
                 * clause 4 of Derivation Valid (Restriction, Complex)
-                * (§3.4.6) (where references to the base type definition are
+                * (�3.4.6) (where references to the base type definition are
                 * understood as references to the attribute group definition
                 * in I)."
                 */
                 err = xmlSchemaCheckDerivationOKRestriction2to4(pctxt,
                     XML_SCHEMA_ACTION_REDEFINE,
                     item, redef->target,
                     (WXS_ATTR_GROUP_CAST item)->attrUses,
                     (WXS_ATTR_GROUP_CAST redef->target)->attrUses,
                     (WXS_ATTR_GROUP_CAST item)->attributeWildcard,
                     (WXS_ATTR_GROUP_CAST redef->target)->attributeWildcard);
                 if (err == -1)
                     return(-1);
                 break;
             default:
                 break;
         }
         redef = redef->next;
     } while (redef != NULL);
     return(0);
 }
-        
+
 
 static int
 xmlSchemaAddComponents(xmlSchemaParserCtxtPtr pctxt,
                        xmlSchemaBucketPtr bucket)
 {
     xmlSchemaBasicItemPtr item;
     int err;
     xmlHashTablePtr *table;
     const xmlChar *name;
     int i;
@@ skipping 13 matching lines @@
     *   but if we do then according to:
     *   http://www.w3.org/Bugs/Public/show_bug.cgi?id=2224
     *   we would need, if imported directly, to import redefined
     *   components as well to be able to catch clashing components.
     *   (I hope I'll still know what this means after some months :-()
     */
     if (bucket == NULL)
         return(-1);
     if (bucket->flags & XML_SCHEMA_BUCKET_COMPS_ADDED)
         return(0);
-    bucket->flags |= XML_SCHEMA_BUCKET_COMPS_ADDED; 
-    
+    bucket->flags |= XML_SCHEMA_BUCKET_COMPS_ADDED;
+
     for (i = 0; i < bucket->globals->nbItems; i++) {
         item = bucket->globals->items[i];
         table = NULL;
         switch (item->type) {
             case XML_SCHEMA_TYPE_COMPLEX:
             case XML_SCHEMA_TYPE_SIMPLE:
                 if (WXS_REDEFINED_TYPE(item))
                     continue;
                 name = (WXS_TYPE_CAST item)->name;
                 WXS_GET_GLOBAL_HASH(bucket, typeDecl)
@@ skipping 20 matching lines @@
                 break;
             case XML_SCHEMA_TYPE_IDC_KEY:
             case XML_SCHEMA_TYPE_IDC_UNIQUE:
             case XML_SCHEMA_TYPE_IDC_KEYREF:
                 name = (WXS_IDC_CAST item)->name;
                 WXS_GET_GLOBAL_HASH(bucket, idcDef)
                 break;
             case XML_SCHEMA_TYPE_NOTATION:
                 name = ((xmlSchemaNotationPtr) item)->name;
                 WXS_GET_GLOBAL_HASH(bucket, notaDecl)
-                break;      
+                break;
             default:
                 PERROR_INT("xmlSchemaAddComponents",
                     "Unexpected global component type");
-                continue;               
-        }       
+                continue;
+        }
         if (*table == NULL) {
             *table = xmlHashCreateDict(10, pctxt->dict);
             if (*table == NULL) {
                 PERROR_INT("xmlSchemaAddComponents",
                     "failed to create a component hash table");
                 return(-1);
             }
-        }       
+        }
         err = xmlHashAddEntry(*table, name, item);
-        if (err != 0) { 
+        if (err != 0) {
             xmlChar *str = NULL;
-            
+
             xmlSchemaCustomErr(ACTXT_CAST pctxt,
                 XML_SCHEMAP_REDEFINED_TYPE,
                 WXS_ITEM_NODE(item),
                 WXS_BASIC_CAST item,
                 "A global %s '%s' does already exist",
                 WXS_ITEM_TYPE_NAME(item),
                 xmlSchemaGetComponentQName(&str, item));
-            FREE_AND_NULL(str);  
+            FREE_AND_NULL(str);
         }
     }
     /*
     * Process imported/included schemas.
     */
     if (bucket->relations != NULL) {
         xmlSchemaSchemaRelationPtr rel = bucket->relations;
         do {
             if ((rel->bucket != NULL) &&
                 ((rel->bucket->flags & XML_SCHEMA_BUCKET_COMPS_ADDED) == 0)) {
@@ skipping 13 matching lines @@
     xmlSchemaConstructionCtxtPtr con = pctxt->constructor;
     xmlSchemaTreeItemPtr item, *items;
     int nbItems, i, ret = 0;
     xmlSchemaBucketPtr oldbucket = con->bucket;
     xmlSchemaElementPtr elemDecl;
 
 #define FIXHFAILURE if (pctxt->err == XML_SCHEMAP_INTERNAL) goto exit_failure;
 
     if ((con->pending == NULL) ||
         (con->pending->nbItems == 0))
-        return(0);    
+        return(0);
 
     /*
     * Since xmlSchemaFixupComplexType() will create new particles
     * (local components), and those particle components need a bucket
     * on the constructor, we'll assure here that the constructor has
     * a bucket.
-    * TODO: Think about storing locals _only_ on the main bucket.    
-    */    
+    * TODO: Think about storing locals _only_ on the main bucket.
+    */
     if (con->bucket == NULL)
-        con->bucket = rootBucket;    
+        con->bucket = rootBucket;
 
     /* TODO:
     * SPEC (src-redefine):
     * (6.2) "If it has no such self-reference, then all of the
     * following must be true:"
-    
+
     * (6.2.2) The {model group} of the model group definition which
     * corresponds to it per XML Representation of Model Group
-    * Definition Schema Components (§3.7.2) must be a ·valid
-    * restriction· of the {model group} of that model group definition
-    * in I, as defined in Particle Valid (Restriction) (§3.9.6)."
+    * Definition Schema Components (�3.7.2) must be a �valid
+    * restriction� of the {model group} of that model group definition
+    * in I, as defined in Particle Valid (Restriction) (�3.9.6)."
     */
     xmlSchemaCheckSRCRedefineFirst(pctxt);
 
     /*
     * Add global components to the schemata's hash tables.
-    */    
+    */
     xmlSchemaAddComponents(pctxt, rootBucket);
 
     pctxt->ctxtType = NULL;
     items = (xmlSchemaTreeItemPtr *) con->pending->items;
     nbItems = con->pending->nbItems;
     /*
     * Now that we have parsed *all* the schema document(s) and converted
     * them to schema components, we can resolve references, apply component
     * constraints, create the FSA from the content model, etc.
-    */    
+    */
     /*
     * Resolve references of..
     *
     * 1. element declarations:
     *   - the type definition
     *   - the substitution group affiliation
     * 2. simple/complex types:
     *   - the base type definition
     *   - the memberTypes of union types
     *   - the itemType of list types
     * 3. attributes declarations and attribute uses:
     *   - the type definition
     *   - if an attribute use, then the attribute declaration
     * 4. attribute group references:
     *   - the attribute group definition
     * 5. particles:
     *   - the term of the particle (e.g. a model group)
     * 6. IDC key-references:
     *   - the referenced IDC 'key' or 'unique' definition
     * 7. Attribute prohibitions which had a "ref" attribute.
-    */        
+    */
     for (i = 0; i < nbItems; i++) {
         item = items[i];
         switch (item->type) {
             case XML_SCHEMA_TYPE_ELEMENT:
                 xmlSchemaResolveElementReferences(
                     (xmlSchemaElementPtr) item, pctxt);
                 FIXHFAILURE;
                 break;
             case XML_SCHEMA_TYPE_COMPLEX:
             case XML_SCHEMA_TYPE_SIMPLE:
                 xmlSchemaResolveTypeReferences(
                     (xmlSchemaTypePtr) item, pctxt);
                 FIXHFAILURE;
                 break;
             case XML_SCHEMA_TYPE_ATTRIBUTE:
                 xmlSchemaResolveAttrTypeReferences(
                     (xmlSchemaAttributePtr) item, pctxt);
                 FIXHFAILURE;
                 break;
             case XML_SCHEMA_TYPE_ATTRIBUTE_USE:
                 xmlSchemaResolveAttrUseReferences(
                     (xmlSchemaAttributeUsePtr) item, pctxt);
                 FIXHFAILURE;
                 break;
             case XML_SCHEMA_EXTRA_QNAMEREF:
-                if ((WXS_QNAME_CAST item)->itemType == 
+                if ((WXS_QNAME_CAST item)->itemType ==
                     XML_SCHEMA_TYPE_ATTRIBUTEGROUP)
                 {
                     xmlSchemaResolveAttrGroupReferences(
                         WXS_QNAME_CAST item, pctxt);
                 }
                 FIXHFAILURE;
                 break;
             case XML_SCHEMA_TYPE_SEQUENCE:
             case XML_SCHEMA_TYPE_CHOICE:
             case XML_SCHEMA_TYPE_ALL:
@@ skipping 16 matching lines @@
                 xmlSchemaResolveAttrUseProhibReferences(
                     WXS_ATTR_PROHIB_CAST item, pctxt);
                 FIXHFAILURE;
                 break;
             default:
                 break;
         }
     }
     if (pctxt->nberrors != 0)
         goto exit_error;
-    
+
     /*
     * Now that all references are resolved we
     * can check for circularity of...
-    * 1. the base axis of type definitions 
+    * 1. the base axis of type definitions
     * 2. nested model group definitions
     * 3. nested attribute group definitions
     * TODO: check for circual substitution groups.
     */
     for (i = 0; i < nbItems; i++) {
         item = items[i];
         /*
         * Let's better stop on the first error here.
         */
         switch (item->type) {
@@ skipping 14 matching lines @@
                 break;
             case XML_SCHEMA_TYPE_ATTRIBUTEGROUP:
                 xmlSchemaCheckAttrGroupCircular(
                     (xmlSchemaAttributeGroupPtr) item, pctxt);
                 FIXHFAILURE;
                 if (pctxt->nberrors != 0)
                     goto exit_error;
                 break;
             default:
                 break;
-        }       
+        }
     }
     if (pctxt->nberrors != 0)
         goto exit_error;
     /*
     * Model group definition references:
     * Such a reference is reflected by a particle at the component
     * level. Until now the 'term' of such particles pointed
     * to the model group definition; this was done, in order to
     * ease circularity checks. Now we need to set the 'term' of
     * such particles to the model group of the model group definition.
     */
     for (i = 0; i < nbItems; i++) {
         item = items[i];
         switch (item->type) {
             case XML_SCHEMA_TYPE_SEQUENCE:
-            case XML_SCHEMA_TYPE_CHOICE:        
+            case XML_SCHEMA_TYPE_CHOICE:
                 xmlSchemaModelGroupToModelGroupDefFixup(pctxt,
                     WXS_MODEL_GROUP_CAST item);
                 break;
             default:
                 break;
         }
     }
     if (pctxt->nberrors != 0)
         goto exit_error;
     /*
@@ skipping 10 matching lines @@
                         WXS_ATTR_GROUP_CAST item);
                     FIXHFAILURE;
                 }
                 break;
             default:
                 break;
         }
     }
     if (pctxt->nberrors != 0)
         goto exit_error;
-    /* 
+    /*
     * First compute the variety of simple types. This is needed as
     * a seperate step, since otherwise we won't be able to detect
     * circular union types in all cases.
     */
     for (i = 0; i < nbItems; i++) {
         item = items[i];
         switch (item->type) {
             case XML_SCHEMA_TYPE_SIMPLE:
                 if (WXS_IS_TYPE_NOT_FIXED_1((xmlSchemaTypePtr) item)) {
                     xmlSchemaFixupSimpleTypeStageOne(pctxt,
                         (xmlSchemaTypePtr) item);
                     FIXHFAILURE;
                 }
                 break;
             default:
                 break;
         }
     }
     if (pctxt->nberrors != 0)
         goto exit_error;
     /*
     * Detect circular union types. Note that this needs the variety to
     * be already computed.
     */
     for (i = 0; i < nbItems; i++) {
         item = items[i];
         switch (item->type) {
             case XML_SCHEMA_TYPE_SIMPLE:
                 if (((xmlSchemaTypePtr) item)->memberTypes != NULL) {
-                    xmlSchemaCheckUnionTypeDefCircular(pctxt,   
+                    xmlSchemaCheckUnionTypeDefCircular(pctxt,
                         (xmlSchemaTypePtr) item);
                     FIXHFAILURE;
                 }
                 break;
             default:
                 break;
         }
     }
     if (pctxt->nberrors != 0)
         goto exit_error;
-    
+
     /*
     * Do the complete type fixup for simple types.
     */
     for (i = 0; i < nbItems; i++) {
         item = items[i];
         switch (item->type) {
             case XML_SCHEMA_TYPE_SIMPLE:
                 if (WXS_IS_TYPE_NOT_FIXED(WXS_TYPE_CAST item)) {
                     xmlSchemaFixupSimpleTypeStageTwo(pctxt, WXS_TYPE_CAST item);
                     FIXHFAILURE;
                 }
                 break;
             default:
                 break;
         }
     }
     if (pctxt->nberrors != 0)
         goto exit_error;
     /*
     * At this point we need build and check all simple types.
     */
     /*
     * Apply contraints for attribute declarations.
     */
     for (i = 0; i < nbItems; i++) {
         item = items[i];
         switch (item->type) {
-            case XML_SCHEMA_TYPE_ATTRIBUTE:             
+            case XML_SCHEMA_TYPE_ATTRIBUTE:
                 xmlSchemaCheckAttrPropsCorrect(pctxt, WXS_ATTR_CAST item);
                 FIXHFAILURE;
-                break;      
+                break;
             default:
                 break;
         }
     }
     if (pctxt->nberrors != 0)
         goto exit_error;
     /*
     * Apply constraints for attribute uses.
-    */    
+    */
     for (i = 0; i < nbItems; i++) {
         item = items[i];
         switch (item->type) {
             case XML_SCHEMA_TYPE_ATTRIBUTE_USE:
                 if (((xmlSchemaAttributeUsePtr)item)->defValue != NULL) {
                     xmlSchemaCheckAttrUsePropsCorrect(pctxt,
                         WXS_ATTR_USE_CAST item);
                     FIXHFAILURE;
                 }
                 break;
@@ skipping 26 matching lines @@
         goto exit_error;
 
     /*
     * Apply constraints for redefinitions.
     */
     if (WXS_CONSTRUCTOR(pctxt)->redefs != NULL)
         xmlSchemaCheckSRCRedefineSecond(pctxt);
     if (pctxt->nberrors != 0)
         goto exit_error;
 
-    /*    
+    /*
     * Complex types are builded and checked.
     */
     for (i = 0; i < nbItems; i++) {
         item = con->pending->items[i];
         switch (item->type) {
             case XML_SCHEMA_TYPE_COMPLEX:
                 if (WXS_IS_TYPE_NOT_FIXED(WXS_TYPE_CAST item)) {
                     xmlSchemaFixupComplexType(pctxt, WXS_TYPE_CAST item);
                     FIXHFAILURE;
                 }
                 break;
             default:
                 break;
         }
     }
     if (pctxt->nberrors != 0)
         goto exit_error;
 
     /*
     * The list could have changed, since xmlSchemaFixupComplexType()
     * will create particles and model groups in some cases.
     */
     items = (xmlSchemaTreeItemPtr *) con->pending->items;
-    nbItems = con->pending->nbItems;    
-    
+    nbItems = con->pending->nbItems;
+
     /*
     * Apply some constraints for element declarations.
     */
     for (i = 0; i < nbItems; i++) {
         item = items[i];
         switch (item->type) {
             case XML_SCHEMA_TYPE_ELEMENT:
                 elemDecl = (xmlSchemaElementPtr) item;
-                
+
                 if ((elemDecl->flags & XML_SCHEMAS_ELEM_INTERNAL_CHECKED) == 0)
                 {
                     xmlSchemaCheckElementDeclComponent(
                         (xmlSchemaElementPtr) elemDecl, pctxt);
                     FIXHFAILURE;
                 }
 
 #ifdef WXS_ELEM_DECL_CONS_ENABLED
                 /*
                 * Schema Component Constraint: Element Declarations Consistent
                 * Apply this constraint to local types of element declarations.
                 */
                 if ((WXS_ELEM_TYPEDEF(elemDecl) != NULL) &&
                     (WXS_IS_COMPLEX(WXS_ELEM_TYPEDEF(elemDecl))) &&
                     (WXS_TYPE_IS_LOCAL(WXS_ELEM_TYPEDEF(elemDecl))))
                 {
                     xmlSchemaCheckElementDeclConsistent(pctxt,
                         WXS_BASIC_CAST elemDecl,
                         WXS_TYPE_PARTICLE(WXS_ELEM_TYPEDEF(elemDecl)),
                         NULL, NULL, 0);
                 }
 #endif
                 break;
             default:
                 break;
         }
     }
     if (pctxt->nberrors != 0)
         goto exit_error;
- 
+
     /*
     * Finally we can build the automaton from the content model of
     * complex types.
     */
 
     for (i = 0; i < nbItems; i++) {
         item = items[i];
         switch (item->type) {
             case XML_SCHEMA_TYPE_COMPLEX:
                 xmlSchemaBuildContentModel((xmlSchemaTypePtr) item, pctxt);
                 /* FIXHFAILURE; */
                 break;
             default:
                 break;
         }
     }
     if (pctxt->nberrors != 0)
         goto exit_error;
     /*
     * URGENT TODO: cos-element-consistent
-    */        
-    goto exit;    
+    */
+    goto exit;
 
-exit_error:    
+exit_error:
     ret = pctxt->err;
     goto exit;
 
 exit_failure:
     ret = -1;
 
 exit:
     /*
     * Reset the constructor. This is needed for XSI acquisition, since
     * those items will be processed over and over again for every XSI
     * if not cleared here.
     */
     con->bucket = oldbucket;
-    con->pending->nbItems = 0;    
+    con->pending->nbItems = 0;
     if (con->substGroups != NULL) {
         xmlHashFree(con->substGroups,
             (xmlHashDeallocator) xmlSchemaSubstGroupFree);
         con->substGroups = NULL;
-    }    
+    }
     if (con->redefs != NULL) {
         xmlSchemaRedefListFree(con->redefs);
         con->redefs = NULL;
     }
     return(ret);
 }
 /**
  * xmlSchemaParse:
  * @ctxt:  a schema validation context
  *
@@ skipping 42 matching lines @@
     ctxt->constructor->mainSchema = mainSchema;
     /*
     * Locate and add the schema document.
     */
     res = xmlSchemaAddSchemaDoc(ctxt, XML_SCHEMA_SCHEMA_MAIN,
         ctxt->URL, ctxt->doc, ctxt->buffer, ctxt->size, NULL,
         NULL, NULL, &bucket);
     if (res == -1)
         goto exit_failure;
     if (res != 0)
-        goto exit;   
+        goto exit;
 
     if (bucket == NULL) {
         /* TODO: Error code, actually we failed to *locate* the schema. */
-        if (ctxt->URL) 
+        if (ctxt->URL)
             xmlSchemaCustomErr(ACTXT_CAST ctxt, XML_SCHEMAP_FAILED_LOAD,
                 NULL, NULL,
                 "Failed to locate the main schema resource at '%s'",
                 ctxt->URL, NULL);
         else
             xmlSchemaCustomErr(ACTXT_CAST ctxt, XML_SCHEMAP_FAILED_LOAD,
                 NULL, NULL,
                 "Failed to locate the main schema resource",
                     NULL, NULL);
         goto exit;
-    }        
+    }
     /* Then do the parsing for good. */
     if (xmlSchemaParseNewDocWithContext(ctxt, mainSchema, bucket) == -1)
         goto exit_failure;
     if (ctxt->nberrors != 0)
         goto exit;
-    
+
     mainSchema->doc = bucket->doc;
     mainSchema->preserve = ctxt->preserve;
-    
+
     ctxt->schema = mainSchema;
 
     if (xmlSchemaFixupComponents(ctxt, WXS_CONSTRUCTOR(ctxt)->mainBucket) == -1)
         goto exit_failure;
 
     /*
     * TODO: This is not nice, since we cannot distinguish from the
     * result if there was an internal error or not.
     */
-exit:       
-    if (ctxt->nberrors != 0) {  
+exit:
+    if (ctxt->nberrors != 0) {
         if (mainSchema) {
             xmlSchemaFree(mainSchema);
             mainSchema = NULL;
         }
         if (ctxt->constructor) {
             xmlSchemaConstructionCtxtFree(ctxt->constructor);
             ctxt->constructor = NULL;
             ctxt->ownsConstructor = 0;
         }
     }
     ctxt->schema = NULL;
     return(mainSchema);
 exit_failure:
-    /* 
+    /*
     * Quite verbose, but should catch internal errors, which were
     * not communitated.
     */
     if (mainSchema) {
         xmlSchemaFree(mainSchema);
         mainSchema = NULL;
     }
     if (ctxt->constructor) {
         xmlSchemaConstructionCtxtFree(ctxt->constructor);
         ctxt->constructor = NULL;
         ctxt->ownsConstructor = 0;
     }
     PERROR_INT2("xmlSchemaParse",
-        "An internal error occured");    
+        "An internal error occured");
     ctxt->schema = NULL;
     return(NULL);
 }
 
 /**
  * xmlSchemaSetParserErrors:
  * @ctxt:  a schema validation context
  * @err:  the error callback
  * @warn:  the warning callback
  * @ctx:  contextual data for the callbacks
@@ skipping 116 matching lines @@
         /*
         * Note that we assume a whitespace of preserve for anySimpleType.
         */
         if ((type->builtInType == XML_SCHEMAS_STRING) ||
             (type->builtInType == XML_SCHEMAS_ANYSIMPLETYPE))
             return(XML_SCHEMA_WHITESPACE_PRESERVE);
         else if (type->builtInType == XML_SCHEMAS_NORMSTRING)
             return(XML_SCHEMA_WHITESPACE_REPLACE);
         else {
             /*
-            * For all ·atomic· datatypes other than string (and types ·derived·
-            * by ·restriction· from it) the value of whiteSpace is fixed to
+            * For all �atomic� datatypes other than string (and types �derived�
+            * by �restriction� from it) the value of whiteSpace is fixed to
             * collapse
             * Note that this includes built-in list datatypes.
             */
             return(XML_SCHEMA_WHITESPACE_COLLAPSE);
         }
     } else if (WXS_IS_LIST(type)) {
         /*
         * For list types the facet "whiteSpace" is fixed to "collapse".
         */
         return (XML_SCHEMA_WHITESPACE_COLLAPSE);
@@ skipping 66 matching lines @@
     * Acquire the schema document.
     */
     location = xmlSchemaBuildAbsoluteURI(pctxt->dict,
         location, node);
     /*
     * Note that we pass XML_SCHEMA_SCHEMA_IMPORT here;
     * the process will automatically change this to
     * XML_SCHEMA_SCHEMA_MAIN if it is the first schema document.
     */
     ret = xmlSchemaAddSchemaDoc(pctxt, XML_SCHEMA_SCHEMA_IMPORT,
-        location, NULL, NULL, 0, node, NULL, nsName, 
+        location, NULL, NULL, 0, node, NULL, nsName,
         &bucket);
     if (ret != 0)
-        return(ret);    
-    if (bucket == NULL) {       
+        return(ret);
+    if (bucket == NULL) {
         /*
         * Generate a warning that the document could not be located.
         */
         xmlSchemaCustomWarning(ACTXT_CAST vctxt, XML_SCHEMAV_MISC,
             node, NULL,
             "The document at location '%s' could not be acquired",
             location, NULL, NULL);
         return(ret);
     }
     /*
     * The first located schema will be handled as if all other
     * schemas imported by XSI were imported by this first schema.
     */
     if ((bucket != NULL) &&
         (WXS_CONSTRUCTOR(pctxt)->bucket == NULL))
         WXS_CONSTRUCTOR(pctxt)->bucket = bucket;
     /*
     * TODO: Is this handled like an import? I.e. is it not an error
     * if the schema cannot be located?
     */
     if ((bucket == NULL) || (! CAN_PARSE_SCHEMA(bucket)))
         return(0);
     /*
     * We will reuse the parser context for every schema imported
     * directly via XSI. So reset the context.
     */
     pctxt->nberrors = 0;
     pctxt->err = 0;
     pctxt->doc = bucket->doc;
-    
-    ret = xmlSchemaParseNewDocWithContext(pctxt, schema, bucket);        
+
+    ret = xmlSchemaParseNewDocWithContext(pctxt, schema, bucket);
     if (ret == -1) {
         pctxt->doc = NULL;
         goto exit_failure;
     }
     /* Paranoid error channelling. */
     if ((ret == 0) && (pctxt->nberrors != 0))
-        ret = pctxt->err;    
-    if (pctxt->nberrors == 0) { 
-        /* 
+        ret = pctxt->err;
+    if (pctxt->nberrors == 0) {
+        /*
         * Only bother to fixup pending components, if there was
         * no error yet.
         * For every XSI acquired schema (and its sub-schemata) we will
         * fixup the components.
         */
         xmlSchemaFixupComponents(pctxt, bucket);
         ret = pctxt->err;
         /*
         * Not nice, but we need somehow to channel the schema parser
         * error to the validation context.
         */
         if ((ret != 0) && (vctxt->err == 0))
             vctxt->err = ret;
         vctxt->nberrors += pctxt->nberrors;
     } else {
-        /* Add to validation error sum. */ 
+        /* Add to validation error sum. */
         vctxt->nberrors += pctxt->nberrors;
     }
     pctxt->doc = NULL;
     return(ret);
 exit_failure:
     pctxt->doc = NULL;
     return (-1);
 }
 
 static xmlSchemaAttrInfoPtr
-xmlSchemaGetMetaAttrInfo(xmlSchemaValidCtxtPtr vctxt,                 
+xmlSchemaGetMetaAttrInfo(xmlSchemaValidCtxtPtr vctxt,
                          int metaType)
 {
     if (vctxt->nbAttrInfos == 0)
         return (NULL);
     {
         int i;
         xmlSchemaAttrInfoPtr iattr;
 
         for (i = 0; i < vctxt->nbAttrInfos; i++) {
             iattr = vctxt->attrInfos[i];
@@ skipping 69 matching lines @@
         end = cur;
         while ((*end != 0) && (!(IS_BLANK_CH(*end))))
             end++;
         if (end == cur) {
             if (iattr->metaType ==
                 XML_SCHEMA_ATTR_INFO_META_XSI_SCHEMA_LOC)
             {
                 /*
                 * If using @schemaLocation then tuples are expected.
                 * I.e. the namespace name *and* the document's URI.
-                */              
+                */
                 xmlSchemaCustomWarning(ACTXT_CAST vctxt, XML_SCHEMAV_MISC,
                     iattr->node, NULL,
                     "The value must consist of tuples: the target namespace "
                     "name and the document's URI", NULL, NULL, NULL);
             }
             break;
         }
         count++; /* TODO: Don't use the schema's dict. */
         location = xmlDictLookup(vctxt->schema->dict, cur, end - cur);
         cur = end;
         ret = xmlSchemaAssembleByLocation(vctxt, vctxt->schema,
             iattr->node, nsname, location);
         if (ret == -1) {
             VERROR_INT("xmlSchemaAssembleByXSI",
                 "assembling schemata");
             return (-1);
         }
     } while (*cur != 0);
     return (ret);
 }
 
 static const xmlChar *
 xmlSchemaLookupNamespace(xmlSchemaValidCtxtPtr vctxt,
                          const xmlChar *prefix)
 {
     if (vctxt->sax != NULL) {
         int i, j;
         xmlSchemaNodeInfoPtr inode;
-        
+
         for (i = vctxt->depth; i >= 0; i--) {
             if (vctxt->elemInfos[i]->nbNsBindings != 0) {
                 inode = vctxt->elemInfos[i];
                 for (j = 0; j < inode->nbNsBindings * 2; j += 2) {
                     if (((prefix == NULL) &&
                             (inode->nsBindings[j] == NULL)) ||
                         ((prefix != NULL) && xmlStrEqual(prefix,
                             inode->nsBindings[j]))) {
 
                         /*
                         * Note that the namespace bindings are already
                         * in a string dict.
                         */
-                        return (inode->nsBindings[j+1]);                        
+                        return (inode->nsBindings[j+1]);
                     }
                 }
             }
         }
         return (NULL);
-#ifdef LIBXML_WRITER_ENABLED
+#ifdef LIBXML_READER_ENABLED
     } else if (vctxt->reader != NULL) {
         xmlChar *nsName;
-        
+
         nsName = xmlTextReaderLookupNamespace(vctxt->reader, prefix);
         if (nsName != NULL) {
             const xmlChar *ret;
 
             ret = xmlDictLookup(vctxt->dict, nsName, -1);
             xmlFree(nsName);
             return (ret);
         } else
             return (NULL);
 #endif
@@ skipping 11 matching lines @@
         if (ns != NULL)
             return (ns->href);
         return (NULL);
     }
 }
 
 /*
 * This one works on the schema of the validation context.
 */
 static int
-xmlSchemaValidateNotation(xmlSchemaValidCtxtPtr vctxt,                    
+xmlSchemaValidateNotation(xmlSchemaValidCtxtPtr vctxt,
                           xmlSchemaPtr schema,
                           xmlNodePtr node,
                           const xmlChar *value,
                           xmlSchemaValPtr *val,
                           int valNeeded)
 {
     int ret;
 
     if (vctxt && (vctxt->schema == NULL)) {
         VERROR_INT("xmlSchemaValidateNotation",
             "a schema is needed on the validation context");
         return (-1);
     }
     ret = xmlValidateQName(value, 1);
     if (ret != 0)
         return (ret);
     {
         xmlChar *localName = NULL;
         xmlChar *prefix = NULL;
 
         localName = xmlSplitQName2(value, &prefix);
         if (prefix != NULL) {
             const xmlChar *nsName = NULL;
 
-            if (vctxt != NULL) 
+            if (vctxt != NULL)
                 nsName = xmlSchemaLookupNamespace(vctxt, BAD_CAST prefix);
             else if (node != NULL) {
                 xmlNsPtr ns = xmlSearchNs(node->doc, node, prefix);
                 if (ns != NULL)
                     nsName = ns->href;
             } else {
                 xmlFree(prefix);
                 xmlFree(localName);
                 return (1);
             }
@@ skipping 331 matching lines @@
  *
  * Frees an IDC binding. Note that the node table-items
  * are not freed.
  */
 static void
 xmlSchemaIDCFreeBinding(xmlSchemaPSVIIDCBindingPtr bind)
 {
     if (bind->nodeTable != NULL)
         xmlFree(bind->nodeTable);
     if (bind->dupls != NULL)
-        xmlSchemaItemListFree(bind->dupls);     
+        xmlSchemaItemListFree(bind->dupls);
     xmlFree(bind);
 }
 
 /**
  * xmlSchemaIDCFreeIDCTable:
  * @bind: the first IDC binding in the list
  *
  * Frees an IDC table, i.e. all the IDC bindings in the list.
  */
 static void
@@ skipping 14 matching lines @@
  *
  * Frees a list of IDC matchers.
  */
 static void
 xmlSchemaIDCFreeMatcherList(xmlSchemaIDCMatcherPtr matcher)
 {
     xmlSchemaIDCMatcherPtr next;
 
     while (matcher != NULL) {
         next = matcher->next;
-        if (matcher->keySeqs != NULL) {     
+        if (matcher->keySeqs != NULL) {
             int i;
             for (i = 0; i < matcher->sizeKeySeqs; i++)
                 if (matcher->keySeqs[i] != NULL)
                     xmlFree(matcher->keySeqs[i]);
-            xmlFree(matcher->keySeqs);      
+            xmlFree(matcher->keySeqs);
         }
         if (matcher->targets != NULL) {
             if (matcher->idcType == XML_SCHEMA_TYPE_IDC_KEYREF) {
                 int i;
                 xmlSchemaPSVIIDCNodePtr idcNode;
                 /*
                 * Node-table items for keyrefs are not stored globally
                 * to the validation context, since they are not bubbled.
                 * We need to free them here.
                 */
@@ skipping 19 matching lines @@
  * Caches a list of IDC matchers for reuse.
  */
 static void
 xmlSchemaIDCReleaseMatcherList(xmlSchemaValidCtxtPtr vctxt,
                                xmlSchemaIDCMatcherPtr matcher)
 {
     xmlSchemaIDCMatcherPtr next;
 
     while (matcher != NULL) {
         next = matcher->next;
-        if (matcher->keySeqs != NULL) {     
+        if (matcher->keySeqs != NULL) {
             int i;
             /*
             * Don't free the array, but only the content.
             */
             for (i = 0; i < matcher->sizeKeySeqs; i++)
                 if (matcher->keySeqs[i] != NULL) {
                     xmlFree(matcher->keySeqs[i]);
                     matcher->keySeqs[i] = NULL;
                 }
         }
         if (matcher->targets) {
             if (matcher->idcType == XML_SCHEMA_TYPE_IDC_KEYREF) {
                 int i;
                 xmlSchemaPSVIIDCNodePtr idcNode;
                 /*
                 * Node-table items for keyrefs are not stored globally
                 * to the validation context, since they are not bubbled.
                 * We need to free them here.
                 */
                 for (i = 0; i < matcher->targets->nbItems; i++) {
                     idcNode =
                         (xmlSchemaPSVIIDCNodePtr) matcher->targets->items[i];
                     xmlFree(idcNode->keys);
                     xmlFree(idcNode);
                 }
             }
             xmlSchemaItemListFree(matcher->targets);
             matcher->targets = NULL;
-        }       
+        }
         matcher->next = NULL;
         /*
         * Cache the matcher.
         */
         if (vctxt->idcMatcherCache != NULL)
             matcher->nextCached = vctxt->idcMatcherCache;
         vctxt->idcMatcherCache = matcher;
 
         matcher = next;
     }
@@ skipping 21 matching lines @@
 {
     xmlSchemaIDCStateObjPtr sto;
 
     /*
     * Reuse the state objects from the pool.
     */
     if (vctxt->xpathStatePool != NULL) {
         sto = vctxt->xpathStatePool;
         vctxt->xpathStatePool = sto->next;
         sto->next = NULL;
-    } else {    
+    } else {
         /*
         * Create a new state object.
         */
         sto = (xmlSchemaIDCStateObjPtr) xmlMalloc(sizeof(xmlSchemaIDCStateObj));
         if (sto == NULL) {
             xmlSchemaVErrMemory(NULL,
                 "allocating an IDC state object", NULL);
             return (-1);
         }
         memset(sto, 0, sizeof(xmlSchemaIDCStateObj));
-    }   
+    }
     /*
-    * Add to global list. 
-    */  
+    * Add to global list.
+    */
     if (vctxt->xpathStates != NULL)
         sto->next = vctxt->xpathStates;
     vctxt->xpathStates = sto;
 
     /*
     * Free the old xpath validation context.
     */
     if (sto->xpathCtxt != NULL)
         xmlFreeStreamCtxt((xmlStreamCtxtPtr) sto->xpathCtxt);
 
     /*
     * Create a new XPath (pattern) validation context.
     */
     sto->xpathCtxt = (void *) xmlPatternGetStreamCtxt(
         (xmlPatternPtr) sel->xpathComp);
     if (sto->xpathCtxt == NULL) {
         VERROR_INT("xmlSchemaIDCAddStateObject",
             "failed to create an XPath validation context");
         return (-1);
-    }    
+    }
     sto->type = type;
     sto->depth = vctxt->depth;
     sto->matcher = matcher;
     sto->sel = sel;
     sto->nbHistory = 0;
-    
+
 #ifdef DEBUG_IDC
     xmlGenericError(xmlGenericErrorContext, "IDC:   STO push '%s'\n",
         sto->sel->xpath);
 #endif
     return (0);
 }
 
 /**
  * xmlSchemaXPathEvaluate:
  * @vctxt: the WXS validation context
  * @nodeType: the nodeType of the current node
  *
  * Evaluates all active XPath state objects.
  *
  * Returns the number of IC "field" state objects which resolved to
  * this node, 0 if none resolved and -1 on internal errors.
  */
 static int
 xmlSchemaXPathEvaluate(xmlSchemaValidCtxtPtr vctxt,
                        xmlElementType nodeType)
 {
     xmlSchemaIDCStateObjPtr sto, head = NULL, first;
     int res, resolved = 0, depth = vctxt->depth;
-        
+
     if (vctxt->xpathStates == NULL)
         return (0);
 
     if (nodeType == XML_ATTRIBUTE_NODE)
         depth++;
 #ifdef DEBUG_IDC
     {
         xmlChar *str = NULL;
-        xmlGenericError(xmlGenericErrorContext, 
-            "IDC: EVAL on %s, depth %d, type %d\n",         
+        xmlGenericError(xmlGenericErrorContext,
+            "IDC: EVAL on %s, depth %d, type %d\n",
             xmlSchemaFormatQName(&str, vctxt->inode->nsName,
                 vctxt->inode->localName), depth, nodeType);
         FREE_AND_NULL(str)
     }
 #endif
     /*
     * Process all active XPath state objects.
     */
     first = vctxt->xpathStates;
     sto = first;
     while (sto != head) {
 #ifdef DEBUG_IDC
         if (sto->type == XPATH_STATE_OBJ_TYPE_IDC_SELECTOR)
-            xmlGenericError(xmlGenericErrorContext, "IDC:   ['%s'] selector '%s'\n", 
+            xmlGenericError(xmlGenericErrorContext, "IDC:   ['%s'] selector '%s'\n",
                 sto->matcher->aidc->def->name, sto->sel->xpath);
         else
-            xmlGenericError(xmlGenericErrorContext, "IDC:   ['%s'] field '%s'\n", 
+            xmlGenericError(xmlGenericErrorContext, "IDC:   ['%s'] field '%s'\n",
                 sto->matcher->aidc->def->name, sto->sel->xpath);
 #endif
         if (nodeType == XML_ELEMENT_NODE)
             res = xmlStreamPush((xmlStreamCtxtPtr) sto->xpathCtxt,
                 vctxt->inode->localName, vctxt->inode->nsName);
         else
             res = xmlStreamPushAttr((xmlStreamCtxtPtr) sto->xpathCtxt,
                 vctxt->inode->localName, vctxt->inode->nsName);
 
         if (res == -1) {
             VERROR_INT("xmlSchemaXPathEvaluate",
                 "calling xmlStreamPush()");
             return (-1);
         }
         if (res == 0)
             goto next_sto;
         /*
         * Full match.
         */
 #ifdef DEBUG_IDC
         xmlGenericError(xmlGenericErrorContext, "IDC:     "
             "MATCH\n");
 #endif
         /*
         * Register a match in the state object history.
         */
         if (sto->history == NULL) {
             sto->history = (int *) xmlMalloc(5 * sizeof(int));
             if (sto->history == NULL) {
-                xmlSchemaVErrMemory(NULL, 
+                xmlSchemaVErrMemory(NULL,
                     "allocating the state object history", NULL);
                 return(-1);
             }
             sto->sizeHistory = 5;
         } else if (sto->sizeHistory <= sto->nbHistory) {
             sto->sizeHistory *= 2;
             sto->history = (int *) xmlRealloc(sto->history,
                 sto->sizeHistory * sizeof(int));
             if (sto->history == NULL) {
-                xmlSchemaVErrMemory(NULL, 
+                xmlSchemaVErrMemory(NULL,
                     "re-allocating the state object history", NULL);
                 return(-1);
             }
-        }               
+        }
         sto->history[sto->nbHistory++] = depth;
 
 #ifdef DEBUG_IDC
         xmlGenericError(xmlGenericErrorContext, "IDC:       push match '%d'\n",
             vctxt->depth);
 #endif
 
         if (sto->type == XPATH_STATE_OBJ_TYPE_IDC_SELECTOR) {
             xmlSchemaIDCSelectPtr sel;
             /*
@@ skipping 48 matching lines @@
                               xmlChar **buf,
                               xmlSchemaPSVIIDCKeyPtr *seq,
                               int count)
 {
     int i, res;
     xmlChar *value = NULL;
 
     *buf = xmlStrdup(BAD_CAST "[");
     for (i = 0; i < count; i++) {
         *buf = xmlStrcat(*buf, BAD_CAST "'");
-        res = xmlSchemaGetCanonValueWhtspExt(seq[i]->val, 
+        res = xmlSchemaGetCanonValueWhtspExt(seq[i]->val,
             xmlSchemaGetWhiteSpaceFacetValue(seq[i]->type),
             &value);
         if (res == 0)
             *buf = xmlStrcat(*buf, BAD_CAST value);
         else {
             VERROR_INT("xmlSchemaFormatIDCKeySequence",
                 "failed to compute a canonical value");
             *buf = xmlStrcat(*buf, BAD_CAST "???");
         }
         if (i < count -1)
@@ skipping 37 matching lines @@
 }
 
 /**
  * xmlSchemaXPathProcessHistory:
  * @vctxt: the WXS validation context
  * @type: the simple/complex type of the current node if any at all
  * @val: the precompiled value
  *
  * Processes and pops the history items of the IDC state objects.
  * IDC key-sequences are validated/created on IDC bindings.
- * 
+ *
  * Returns 0 on success and -1 on internal errors.
  */
 static int
 xmlSchemaXPathProcessHistory(xmlSchemaValidCtxtPtr vctxt,
                              int depth)
 {
     xmlSchemaIDCStateObjPtr sto, nextsto;
     int res, matchDepth;
     xmlSchemaPSVIIDCKeyPtr key = NULL;
     xmlSchemaTypePtr type = vctxt->inode->typeDef, simpleType = NULL;
 
     if (vctxt->xpathStates == NULL)
         return (0);
     sto = vctxt->xpathStates;
 
 #ifdef DEBUG_IDC
     {
         xmlChar *str = NULL;
-        xmlGenericError(xmlGenericErrorContext, 
+        xmlGenericError(xmlGenericErrorContext,
             "IDC: BACK on %s, depth %d\n",
             xmlSchemaFormatQName(&str, vctxt->inode->nsName,
                 vctxt->inode->localName), vctxt->depth);
         FREE_AND_NULL(str)
     }
-#endif    
+#endif
     /*
     * Evaluate the state objects.
     */
     while (sto != NULL) {
         res = xmlStreamPop((xmlStreamCtxtPtr) sto->xpathCtxt);
         if (res == -1) {
             VERROR_INT("xmlSchemaXPathProcessHistory",
                 "calling xmlStreamPop()");
             return (-1);
         }
 #ifdef DEBUG_IDC
         xmlGenericError(xmlGenericErrorContext, "IDC:   stream pop '%s'\n",
             sto->sel->xpath);
 #endif
         if (sto->nbHistory == 0)
             goto deregister_check;
 
         matchDepth = sto->history[sto->nbHistory -1];
 
         /*
         * Only matches at the current depth are of interest.
         */
         if (matchDepth != depth) {
             sto = sto->next;
             continue;
-        }       
+        }
         if (sto->type == XPATH_STATE_OBJ_TYPE_IDC_FIELD) {
             /*
             * NOTE: According to
             *   http://www.w3.org/Bugs/Public/show_bug.cgi?id=2198
             *   ... the simple-content of complex types is also allowed.
             */
-            
+
             if (WXS_IS_COMPLEX(type)) {
                 if (WXS_HAS_SIMPLE_CONTENT(type)) {
                     /*
                     * Sanity check for complex types with simple content.
                     */
                     simpleType = type->contentTypeDef;
                     if (simpleType == NULL) {
                         VERROR_INT("xmlSchemaXPathProcessHistory",
                             "field resolves to a CT with simple content "
                             "but the CT is missing the ST definition");
                         return (-1);
                     }
                 } else
                     simpleType = NULL;
-            } else 
+            } else
                 simpleType = type;
             if (simpleType == NULL) {
                 xmlChar *str = NULL;
-        
+
                 /*
                 * Not qualified if the field resolves to a node of non
                 * simple type.
-                */      
+                */
                 xmlSchemaCustomErr(ACTXT_CAST vctxt,
-                    XML_SCHEMAV_CVC_IDC, NULL,              
+                    XML_SCHEMAV_CVC_IDC, NULL,
                     WXS_BASIC_CAST sto->matcher->aidc->def,
                     "The XPath '%s' of a field of %s does evaluate to a node of "
                     "non-simple type",
                     sto->sel->xpath,
                     xmlSchemaGetIDCDesignation(&str, sto->matcher->aidc->def));
                 FREE_AND_NULL(str);
                 sto->nbHistory--;
                 goto deregister_check;
             }
-            
+
             if ((key == NULL) && (vctxt->inode->val == NULL)) {
                 /*
                 * Failed to provide the normalized value; maybe
                 * the value was invalid.
                 */
                 VERROR(XML_SCHEMAV_CVC_IDC,
                     WXS_BASIC_CAST sto->matcher->aidc->def,
                     "Warning: No precomputed value available, the value "
                     "was either invalid or something strange happend");
                 sto->nbHistory--;
                 goto deregister_check;
             } else {
                 xmlSchemaIDCMatcherPtr matcher = sto->matcher;
                 xmlSchemaPSVIIDCKeyPtr *keySeq;
                 int pos, idx;
-                
+
                 /*
                 * The key will be anchored on the matcher's list of
                 * key-sequences. The position in this list is determined
                 * by the target node's depth relative to the matcher's
                 * depth of creation (i.e. the depth of the scope element).
-                * 
+                *
                 * Element        Depth    Pos   List-entries
                 * <scope>          0              NULL
                 *   <bar>          1              NULL
                 *     <target/>    2       2      target
                 *   <bar>
                 * </scope>
                 *
                 * The size of the list is only dependant on the depth of
                 * the tree.
                 * An entry will be NULLed in selector_leave, i.e. when
-                * we hit the target's 
-                */                  
+                * we hit the target's
+                */
                 pos = sto->depth - matcher->depth;
                 idx = sto->sel->index;
-                
+
                 /*
                 * Create/grow the array of key-sequences.
                 */
                 if (matcher->keySeqs == NULL) {
-                    if (pos > 9) 
+                    if (pos > 9)
                         matcher->sizeKeySeqs = pos * 2;
                     else
                         matcher->sizeKeySeqs = 10;
-                    matcher->keySeqs = (xmlSchemaPSVIIDCKeyPtr **) 
+                    matcher->keySeqs = (xmlSchemaPSVIIDCKeyPtr **)
                         xmlMalloc(matcher->sizeKeySeqs *
-                        sizeof(xmlSchemaPSVIIDCKeyPtr *));                      
-                    if (matcher->keySeqs == NULL) {             
+                        sizeof(xmlSchemaPSVIIDCKeyPtr *));
+                    if (matcher->keySeqs == NULL) {
                         xmlSchemaVErrMemory(NULL,
                             "allocating an array of key-sequences",
                             NULL);
                         return(-1);
                     }
                     memset(matcher->keySeqs, 0,
                         matcher->sizeKeySeqs *
                         sizeof(xmlSchemaPSVIIDCKeyPtr *));
-                } else if (pos >= matcher->sizeKeySeqs) {       
+                } else if (pos >= matcher->sizeKeySeqs) {
                     int i = matcher->sizeKeySeqs;
-                    
+
                     matcher->sizeKeySeqs *= 2;
                     matcher->keySeqs = (xmlSchemaPSVIIDCKeyPtr **)
                         xmlRealloc(matcher->keySeqs,
                         matcher->sizeKeySeqs *
                         sizeof(xmlSchemaPSVIIDCKeyPtr *));
                     if (matcher->keySeqs == NULL) {
                         xmlSchemaVErrMemory(NULL,
                             "reallocating an array of key-sequences",
                             NULL);
                         return (-1);
                     }
                     /*
                     * The array needs to be NULLed.
                     * TODO: Use memset?
                     */
-                    for (; i < matcher->sizeKeySeqs; i++) 
-                        matcher->keySeqs[i] = NULL;                     
+                    for (; i < matcher->sizeKeySeqs; i++)
+                        matcher->keySeqs[i] = NULL;
                 }
-                
+
                 /*
                 * Get/create the key-sequence.
                 */
-                keySeq = matcher->keySeqs[pos];             
-                if (keySeq == NULL) {   
+                keySeq = matcher->keySeqs[pos];
+                if (keySeq == NULL) {
                     goto create_sequence;
                 } else if (keySeq[idx] != NULL) {
                     xmlChar *str = NULL;
                     /*
                     * cvc-identity-constraint:
-                    * 3 For each node in the ·target node set· all
+                    * 3 For each node in the �target node set� all
                     * of the {fields}, with that node as the context
                     * node, evaluate to either an empty node-set or
                     * a node-set with exactly one member, which must
                     * have a simple type.
-                    * 
+                    *
                     * The key was already set; report an error.
                     */
-                    xmlSchemaCustomErr(ACTXT_CAST vctxt, 
+                    xmlSchemaCustomErr(ACTXT_CAST vctxt,
                         XML_SCHEMAV_CVC_IDC, NULL,
                         WXS_BASIC_CAST matcher->aidc->def,
                         "The XPath '%s' of a field of %s evaluates to a "
                         "node-set with more than one member",
                         sto->sel->xpath,
                         xmlSchemaGetIDCDesignation(&str, matcher->aidc->def));
                     FREE_AND_NULL(str);
                     sto->nbHistory--;
                     goto deregister_check;
                 } else
-                    goto create_key;            
-                
+                    goto create_key;
+
 create_sequence:
                 /*
                 * Create a key-sequence.
                 */
                 keySeq = (xmlSchemaPSVIIDCKeyPtr *) xmlMalloc(
-                    matcher->aidc->def->nbFields * 
+                    matcher->aidc->def->nbFields *
                     sizeof(xmlSchemaPSVIIDCKeyPtr));
                 if (keySeq == NULL) {
-                    xmlSchemaVErrMemory(NULL, 
+                    xmlSchemaVErrMemory(NULL,
                         "allocating an IDC key-sequence", NULL);
-                    return(-1);                 
-                }       
-                memset(keySeq, 0, matcher->aidc->def->nbFields * 
+                    return(-1);
+                }
+                memset(keySeq, 0, matcher->aidc->def->nbFields *
                     sizeof(xmlSchemaPSVIIDCKeyPtr));
                 matcher->keySeqs[pos] = keySeq;
 create_key:
                 /*
                 * Create a key once per node only.
-                */  
+                */
                 if (key == NULL) {
                     key = (xmlSchemaPSVIIDCKeyPtr) xmlMalloc(
                         sizeof(xmlSchemaPSVIIDCKey));
                     if (key == NULL) {
                         xmlSchemaVErrMemory(NULL,
                             "allocating a IDC key", NULL);
                         xmlFree(keySeq);
                         matcher->keySeqs[pos] = NULL;
-                        return(-1);                     
+                        return(-1);
                     }
                     /*
                     * Consume the compiled value.
                     */
                     key->type = simpleType;
                     key->val = vctxt->inode->val;
                     vctxt->inode->val = NULL;
                     /*
                     * Store the key in a global list.
                     */
                     if (xmlSchemaIDCStoreKey(vctxt, key) == -1) {
                         xmlSchemaIDCFreeKey(key);
                         return (-1);
                     }
                 }
-                keySeq[idx] = key;                  
+                keySeq[idx] = key;
             }
         } else if (sto->type == XPATH_STATE_OBJ_TYPE_IDC_SELECTOR) {
-                
+
             xmlSchemaPSVIIDCKeyPtr **keySeq = NULL;
             /* xmlSchemaPSVIIDCBindingPtr bind; */
             xmlSchemaPSVIIDCNodePtr ntItem;
             xmlSchemaIDCMatcherPtr matcher;
             xmlSchemaIDCPtr idc;
             xmlSchemaItemListPtr targets;
             int pos, i, j, nbKeys;
             /*
             * Here we have the following scenario:
             * An IDC 'selector' state object resolved to a target node,
-            * during the time this target node was in the 
-            * ancestor-or-self axis, the 'field' state object(s) looked 
-            * out for matching nodes to create a key-sequence for this 
+            * during the time this target node was in the
+            * ancestor-or-self axis, the 'field' state object(s) looked
+            * out for matching nodes to create a key-sequence for this
             * target node. Now we are back to this target node and need
-            * to put the key-sequence, together with the target node 
-            * itself, into the node-table of the corresponding IDC 
+            * to put the key-sequence, together with the target node
+            * itself, into the node-table of the corresponding IDC
             * binding.
             */
             matcher = sto->matcher;
             idc = matcher->aidc->def;
             nbKeys = idc->nbFields;
-            pos = depth - matcher->depth;               
+            pos = depth - matcher->depth;
             /*
             * Check if the matcher has any key-sequences at all, plus
             * if it has a key-sequence for the current target node.
-            */          
+            */
             if ((matcher->keySeqs == NULL) ||
                 (matcher->sizeKeySeqs <= pos)) {
                 if (idc->type == XML_SCHEMA_TYPE_IDC_KEY)
                     goto selector_key_error;
                 else
                     goto selector_leave;
             }
-            
-            keySeq = &(matcher->keySeqs[pos]);          
+
+            keySeq = &(matcher->keySeqs[pos]);
             if (*keySeq == NULL) {
                 if (idc->type == XML_SCHEMA_TYPE_IDC_KEY)
                     goto selector_key_error;
                 else
                     goto selector_leave;
             }
-            
+
             for (i = 0; i < nbKeys; i++) {
                 if ((*keySeq)[i] == NULL) {
                     /*
                     * Not qualified, if not all fields did resolve.
                     */
                     if (idc->type == XML_SCHEMA_TYPE_IDC_KEY) {
                         /*
                         * All fields of a "key" IDC must resolve.
                         */
                         goto selector_key_error;
-                    }               
+                    }
                     goto selector_leave;
                 }
             }
             /*
             * All fields did resolve.
             */
-            
+
             /*
             * 4.1 If the {identity-constraint category} is unique(/key),
-            * then no two members of the ·qualified node set· have
-            * ·key-sequences· whose members are pairwise equal, as
+            * then no two members of the �qualified node set� have
+            * �key-sequences� whose members are pairwise equal, as
             * defined by Equal in [XML Schemas: Datatypes].
             *
             * Get the IDC binding from the matcher and check for
             * duplicate key-sequences.
             */
 #if 0
             bind = xmlSchemaIDCAcquireBinding(vctxt, matcher);
 #endif
             targets = xmlSchemaIDCAcquireTargetList(vctxt, matcher);
-            if ((idc->type != XML_SCHEMA_TYPE_IDC_KEYREF) && 
+            if ((idc->type != XML_SCHEMA_TYPE_IDC_KEYREF) &&
                 (targets->nbItems != 0)) {
                 xmlSchemaPSVIIDCKeyPtr ckey, bkey, *bkeySeq;
-                
+
                 i = 0;
                 res = 0;
                 /*
                 * Compare the key-sequences, key by key.
                 */
                 do {
                     bkeySeq =
                         ((xmlSchemaPSVIIDCNodePtr) targets->items[i])->keys;
                     for (j = 0; j < nbKeys; j++) {
                         ckey = (*keySeq)[j];
-                        bkey = bkeySeq[j];                                                      
+                        bkey = bkeySeq[j];
                         res = xmlSchemaAreValuesEqual(ckey->val, bkey->val);
                         if (res == -1) {
                             return (-1);
                         } else if (res == 0) {
                             /*
                             * One of the keys differs, so the key-sequence
                             * won't be equal; get out.
                             */
                             break;
                         }
                     }
                     if (res == 1) {
                         /*
                         * Duplicate key-sequence found.
                         */
                         break;
                     }
                     i++;
                 } while (i < targets->nbItems);
                 if (i != targets->nbItems) {
                     xmlChar *str = NULL, *strB = NULL;
-                    /*   
+                    /*
                     * TODO: Try to report the key-sequence.
                     */
-                    xmlSchemaCustomErr(ACTXT_CAST vctxt, 
+                    xmlSchemaCustomErr(ACTXT_CAST vctxt,
                         XML_SCHEMAV_CVC_IDC, NULL,
                         WXS_BASIC_CAST idc,
                         "Duplicate key-sequence %s in %s",
                         xmlSchemaFormatIDCKeySequence(vctxt, &str,
                             (*keySeq), nbKeys),
                         xmlSchemaGetIDCDesignation(&strB, idc));
                     FREE_AND_NULL(str);
                     FREE_AND_NULL(strB);
                     goto selector_leave;
                 }
             }
             /*
             * Add a node-table item to the IDC binding.
             */
             ntItem = (xmlSchemaPSVIIDCNodePtr) xmlMalloc(
                 sizeof(xmlSchemaPSVIIDCNode));
             if (ntItem == NULL) {
-                xmlSchemaVErrMemory(NULL, 
+                xmlSchemaVErrMemory(NULL,
                     "allocating an IDC node-table item", NULL);
                 xmlFree(*keySeq);
                 *keySeq = NULL;
                 return(-1);
-            }   
+            }
             memset(ntItem, 0, sizeof(xmlSchemaPSVIIDCNode));
-            
-            /* 
+
+            /*
             * Store the node-table item in a global list.
             */
             if (idc->type != XML_SCHEMA_TYPE_IDC_KEYREF) {
                 if (xmlSchemaIDCStoreNodeTableItem(vctxt, ntItem) == -1) {
                     xmlFree(ntItem);
                     xmlFree(*keySeq);
                     *keySeq = NULL;
                     return (-1);
                 }
                 ntItem->nodeQNameID = -1;
             } else {
                 /*
                 * Save a cached QName for this node on the IDC node, to be
                 * able to report it, even if the node is not saved.
                 */
                 ntItem->nodeQNameID = xmlSchemaVAddNodeQName(vctxt,
                     vctxt->inode->localName, vctxt->inode->nsName);
                 if (ntItem->nodeQNameID == -1) {
                     xmlFree(ntItem);
                     xmlFree(*keySeq);
                     *keySeq = NULL;
-                    return (-1);                    
+                    return (-1);
                 }
             }
             /*
             * Init the node-table item: Save the node, position and
             * consume the key-sequence.
             */
             ntItem->node = vctxt->node;
             ntItem->nodeLine = vctxt->inode->nodeLine;
             ntItem->keys = *keySeq;
             *keySeq = NULL;
 #if 0
-            if (xmlSchemaIDCAppendNodeTableItem(bind, ntItem) == -1) {
+            if (xmlSchemaIDCAppendNodeTableItem(bind, ntItem) == -1)
 #endif
             if (xmlSchemaItemListAdd(targets, ntItem) == -1) {
                 if (idc->type == XML_SCHEMA_TYPE_IDC_KEYREF) {
-                    /* 
+                    /*
                     * Free the item, since keyref items won't be
                     * put on a global list.
                     */
                     xmlFree(ntItem->keys);
                     xmlFree(ntItem);
                 }
                 return (-1);
             }
-            
+
             goto selector_leave;
 selector_key_error:
             {
                 xmlChar *str = NULL;
                 /*
-                * 4.2.1 (KEY) The ·target node set· and the 
-                * ·qualified node set· are equal, that is, every 
-                * member of the ·target node set· is also a member
-                * of the ·qualified node set· and vice versa.
+                * 4.2.1 (KEY) The �target node set� and the
+                * �qualified node set� are equal, that is, every
+                * member of the �target node set� is also a member
+                * of the �qualified node set� and vice versa.
                 */
-                xmlSchemaCustomErr(ACTXT_CAST vctxt, 
+                xmlSchemaCustomErr(ACTXT_CAST vctxt,
                     XML_SCHEMAV_CVC_IDC, NULL,
                     WXS_BASIC_CAST idc,
                     "Not all fields of %s evaluate to a node",
                     xmlSchemaGetIDCDesignation(&str, idc), NULL);
                 FREE_AND_NULL(str);
             }
 selector_leave:
             /*
             * Free the key-sequence if not added to the IDC table.
             */
             if ((keySeq != NULL) && (*keySeq != NULL)) {
                 xmlFree(*keySeq);
                 *keySeq = NULL;
             }
         } /* if selector */
-        
+
         sto->nbHistory--;
 
 deregister_check:
         /*
         * Deregister state objects if they reach the depth of creation.
         */
         if ((sto->nbHistory == 0) && (sto->depth == depth)) {
 #ifdef DEBUG_IDC
             xmlGenericError(xmlGenericErrorContext, "IDC:   STO pop '%s'\n",
                 sto->sel->xpath);
@@ skipping 30 matching lines @@
  *
  * Returns 0 if OK and -1 on internal errors.
  */
 static int
 xmlSchemaIDCRegisterMatchers(xmlSchemaValidCtxtPtr vctxt,
                              xmlSchemaElementPtr elemDecl)
 {
     xmlSchemaIDCMatcherPtr matcher, last = NULL;
     xmlSchemaIDCPtr idc, refIdc;
     xmlSchemaIDCAugPtr aidc;
-        
+
     idc = (xmlSchemaIDCPtr) elemDecl->idcs;
     if (idc == NULL)
         return (0);
-    
+
 #ifdef DEBUG_IDC
     {
         xmlChar *str = NULL;
-        xmlGenericError(xmlGenericErrorContext, 
+        xmlGenericError(xmlGenericErrorContext,
             "IDC: REGISTER on %s, depth %d\n",
             (char *) xmlSchemaFormatQName(&str, vctxt->inode->nsName,
                 vctxt->inode->localName), vctxt->depth);
         FREE_AND_NULL(str)
     }
 #endif
     if (vctxt->inode->idcMatchers != NULL) {
         VERROR_INT("xmlSchemaIDCRegisterMatchers",
             "The chain of IDC matchers is expected to be empty");
         return (-1);
@@ skipping 20 matching lines @@
                 while (aidc != NULL) {
                     if (aidc->def == refIdc)
                         break;
                     aidc = aidc->next;
                 }
                 if (aidc == NULL) {
                     VERROR_INT("xmlSchemaIDCRegisterMatchers",
                         "Could not find an augmented IDC item for an IDC "
                         "definition");
                     return (-1);
-                }               
+                }
                 if ((aidc->keyrefDepth == -1) ||
                     (vctxt->depth < aidc->keyrefDepth))
                     aidc->keyrefDepth = vctxt->depth;
             }
         }
         /*
         * Lookup the augmented IDC item for the IDC definition.
         */
         aidc = vctxt->aidcs;
         while (aidc != NULL) {
@@ skipping 10 matching lines @@
         * Create an IDC matcher for every IDC definition.
         */
         if (vctxt->idcMatcherCache != NULL) {
             /*
             * Reuse a cached matcher.
             */
             matcher = vctxt->idcMatcherCache;
             vctxt->idcMatcherCache = matcher->nextCached;
             matcher->nextCached = NULL;
         } else {
-            matcher = (xmlSchemaIDCMatcherPtr) 
+            matcher = (xmlSchemaIDCMatcherPtr)
                 xmlMalloc(sizeof(xmlSchemaIDCMatcher));
             if (matcher == NULL) {
-                xmlSchemaVErrMemory(vctxt, 
+                xmlSchemaVErrMemory(vctxt,
                     "allocating an IDC matcher", NULL);
                 return (-1);
             }
             memset(matcher, 0, sizeof(xmlSchemaIDCMatcher));
         }
         if (last == NULL)
             vctxt->inode->idcMatchers = matcher;
         else
             last->next = matcher;
         last = matcher;
 
         matcher->type = IDC_MATCHER;
-        matcher->depth = vctxt->depth;  
+        matcher->depth = vctxt->depth;
         matcher->aidc = aidc;
         matcher->idcType = aidc->def->type;
-#ifdef DEBUG_IDC        
+#ifdef DEBUG_IDC
         xmlGenericError(xmlGenericErrorContext, "IDC:   register matcher\n");
-#endif 
+#endif
         /*
-        * Init the automaton state object. 
+        * Init the automaton state object.
         */
-        if (xmlSchemaIDCAddStateObject(vctxt, matcher, 
+        if (xmlSchemaIDCAddStateObject(vctxt, matcher,
             idc->selector, XPATH_STATE_OBJ_TYPE_IDC_SELECTOR) == -1)
             return (-1);
 
         idc = idc->next;
     } while (idc != NULL);
     return (0);
 }
 
 static int
 xmlSchemaIDCFillNodeTables(xmlSchemaValidCtxtPtr vctxt,
                            xmlSchemaNodeInfoPtr ielem)
 {
     xmlSchemaPSVIIDCBindingPtr bind;
     int res, i, j, k, nbTargets, nbFields, nbDupls, nbNodeTable;
     xmlSchemaPSVIIDCKeyPtr *keys, *ntkeys;
     xmlSchemaPSVIIDCNodePtr *targets, *dupls;
-    
+
     xmlSchemaIDCMatcherPtr matcher = ielem->idcMatchers;
     /* vctxt->createIDCNodeTables */
     while (matcher != NULL) {
         /*
         * Skip keyref IDCs and empty IDC target-lists.
         */
         if ((matcher->aidc->def->type == XML_SCHEMA_TYPE_IDC_KEYREF) ||
             WXS_ILIST_IS_EMPTY(matcher->targets))
         {
             matcher = matcher->next;
@@ skipping 13 matching lines @@
         /*
         * Get/create the IDC binding on this element for the IDC definition.
         */
         bind = xmlSchemaIDCAcquireBinding(vctxt, matcher);
 
         if (! WXS_ILIST_IS_EMPTY(bind->dupls)) {
             dupls = (xmlSchemaPSVIIDCNodePtr *) bind->dupls->items;
             nbDupls = bind->dupls->nbItems;
         } else {
             dupls = NULL;
-            nbDupls = 0;            
+            nbDupls = 0;
         }
         if (bind->nodeTable != NULL) {
             nbNodeTable = bind->nbNodes;
         } else {
             nbNodeTable = 0;
         }
 
         if ((nbNodeTable == 0) && (nbDupls == 0)) {
             /*
             * Transfer all IDC target-nodes to the IDC node-table.
             */
             bind->nodeTable =
-                (xmlSchemaPSVIIDCNodePtr *) matcher->targets->items;            
+                (xmlSchemaPSVIIDCNodePtr *) matcher->targets->items;
             bind->sizeNodes = matcher->targets->sizeItems;
             bind->nbNodes = matcher->targets->nbItems;
 
             matcher->targets->items = NULL;
             matcher->targets->sizeItems = 0;
-            matcher->targets->nbItems = 0;          
+            matcher->targets->nbItems = 0;
         } else {
             /*
             * Compare the key-sequences and add to the IDC node-table.
             */
             nbTargets = matcher->targets->nbItems;
-            targets = (xmlSchemaPSVIIDCNodePtr *) matcher->targets->items;      
+            targets = (xmlSchemaPSVIIDCNodePtr *) matcher->targets->items;
             nbFields = matcher->aidc->def->nbFields;
             i = 0;
             do {
                 keys = targets[i]->keys;
-                if (nbDupls) {                  
+                if (nbDupls) {
                     /*
                     * Search in already found duplicates first.
                     */
                     j = 0;
-                    do {                                                
+                    do {
                         if (nbFields == 1) {
                             res = xmlSchemaAreValuesEqual(keys[0]->val,
                                 dupls[j]->keys[0]->val);
                             if (res == -1)
                                 goto internal_error;
                             if (res == 1) {
                                 /*
                                 * Equal key-sequence.
                                 */
                                 goto next_target;
@@ skipping 14 matching lines @@
                                 }
                             }
                             if (res == 1) {
                                 /*
                                 * Equal key-sequence found.
                                 */
                                 goto next_target;
                             }
                         }
                         j++;
-                    } while (j < nbDupls);                  
+                    } while (j < nbDupls);
                 }
                 if (nbNodeTable) {
                     j = 0;
-                    do {                                                
+                    do {
                         if (nbFields == 1) {
                             res = xmlSchemaAreValuesEqual(keys[0]->val,
                                 bind->nodeTable[j]->keys[0]->val);
                             if (res == -1)
                                 goto internal_error;
                             if (res == 0) {
                                 /*
                                 * The key-sequence differs.
                                 */
                                 goto next_node_table_entry;
                             }
                         } else {
                             res = 0;
                             ntkeys = bind->nodeTable[j]->keys;
                             for (k = 0; k < nbFields; k++) {
                                 res = xmlSchemaAreValuesEqual(keys[k]->val,
                                     ntkeys[k]->val);
                                 if (res == -1)
                                     goto internal_error;
                                 if (res == 0) {
                                     /*
                                     * One of the keys differs.
                                     */
                                     goto next_node_table_entry;
                                 }
                             }
-                        }                       
+                        }
                         /*
                         * Add the duplicate to the list of duplicates.
                         */
                         if (bind->dupls == NULL) {
                             bind->dupls = xmlSchemaItemListCreate();
                             if (bind->dupls == NULL)
                                 goto internal_error;
-                        }                   
+                        }
                         if (xmlSchemaItemListAdd(bind->dupls, bind->nodeTable[j]) == -1)
                             goto internal_error;
                         /*
                         * Remove the duplicate entry from the IDC node-table.
                         */
                         bind->nodeTable[j] = bind->nodeTable[bind->nbNodes -1];
                         bind->nbNodes--;
 
                         goto next_target;
 
@@ skipping 14 matching lines @@
         }
         matcher = matcher->next;
     }
     return(0);
 
 internal_error:
     return(-1);
 }
 
 /**
- * xmlSchemaBubbleIDCNodeTables: 
+ * xmlSchemaBubbleIDCNodeTables:
  * @depth: the current tree depth
  *
- * Merges IDC bindings of an element at @depth into the corresponding IDC 
- * bindings of its parent element. If a duplicate note-table entry is found, 
- * both, the parent node-table entry and child entry are discarded from the 
+ * Merges IDC bindings of an element at @depth into the corresponding IDC
+ * bindings of its parent element. If a duplicate note-table entry is found,
+ * both, the parent node-table entry and child entry are discarded from the
  * node-table of the parent.
  *
  * Returns 0 if OK and -1 on internal errors.
  */
 static int
 xmlSchemaBubbleIDCNodeTables(xmlSchemaValidCtxtPtr vctxt)
 {
     xmlSchemaPSVIIDCBindingPtr bind; /* IDC bindings of the current node. */
     xmlSchemaPSVIIDCBindingPtr *parTable, parBind = NULL; /* parent IDC bindings. */
     xmlSchemaPSVIIDCNodePtr node, parNode = NULL, *dupls, *parNodes; /* node-table entries. */
     xmlSchemaIDCAugPtr aidc;
     int i, j, k, ret = 0, nbFields, oldNum, oldDupls;
 
-    bind = vctxt->inode->idcTable;        
+    bind = vctxt->inode->idcTable;
     if (bind == NULL) {
         /* Fine, no table, no bubbles. */
         return (0);
     }
-    
+
     parTable = &(vctxt->elemInfos[vctxt->depth -1]->idcTable);
     /*
     * Walk all bindings; create new or add to existing bindings.
     * Remove duplicate key-sequences.
     */
     while (bind != NULL) {
-        
+
         if ((bind->nbNodes == 0) && WXS_ILIST_IS_EMPTY(bind->dupls))
             goto next_binding;
         /*
         * Check if the key/unique IDC table needs to be bubbled.
         */
         if (! vctxt->createIDCNodeTables) {
             aidc = vctxt->aidcs;
             do {
                 if (aidc->def == bind->definition) {
-                    if ((aidc->keyrefDepth == -1) || 
+                    if ((aidc->keyrefDepth == -1) ||
                         (aidc->keyrefDepth >= vctxt->depth)) {
                         goto next_binding;
                     }
                     break;
                 }
                 aidc = aidc->next;
             } while (aidc != NULL);
         }
 
         if (parTable != NULL)
             parBind = *parTable;
         /*
         * Search a matching parent binding for the
         * IDC definition.
         */
-        while (parBind != NULL) {           
+        while (parBind != NULL) {
             if (parBind->definition == bind->definition)
                 break;
             parBind = parBind->next;
         }
 
         if (parBind != NULL) {
             /*
-            * Compare every node-table entry of the child node, 
+            * Compare every node-table entry of the child node,
             * i.e. the key-sequence within, ...
             */
             oldNum = parBind->nbNodes; /* Skip newly added items. */
 
             if (! WXS_ILIST_IS_EMPTY(parBind->dupls)) {
                 oldDupls = parBind->dupls->nbItems;
                 dupls = (xmlSchemaPSVIIDCNodePtr *) parBind->dupls->items;
             } else {
                 dupls = NULL;
-                oldDupls = 0;           
+                oldDupls = 0;
             }
-            
+
             parNodes = parBind->nodeTable;
             nbFields = bind->definition->nbFields;
-            
+
             for (i = 0; i < bind->nbNodes; i++) {
                 node = bind->nodeTable[i];
                 if (node == NULL)
                     continue;
                 /*
                 * ...with every key-sequence of the parent node, already
                 * evaluated to be a duplicate key-sequence.
                 */
                 if (oldDupls) {
-                    j = 0; 
+                    j = 0;
                     while (j < oldDupls) {
                         if (nbFields == 1) {
                             ret = xmlSchemaAreValuesEqual(
                                 node->keys[0]->val,
                                 dupls[j]->keys[0]->val);
                             if (ret == -1)
                                 goto internal_error;
                             if (ret == 0) {
                                 j++;
                                 continue;
@@ skipping 12 matching lines @@
                         }
                         if (ret == 1)
                             /* Duplicate found. */
                             break;
                         j++;
                     }
                     if (j != oldDupls) {
                         /* Duplicate found. Skip this entry. */
                         continue;
                     }
-                }                   
+                }
                 /*
                 * ... and with every key-sequence of the parent node.
                 */
                 if (oldNum) {
-                    j = 0; 
+                    j = 0;
                     while (j < oldNum) {
                         parNode = parNodes[j];
                         if (nbFields == 1) {
                             ret = xmlSchemaAreValuesEqual(
                                 node->keys[0]->val,
                                 parNode->keys[0]->val);
                             if (ret == -1)
                                 goto internal_error;
                             if (ret == 0) {
                                 j++;
                                 continue;
                             }
-                        } else {                            
+                        } else {
                             for (k = 0; k < nbFields; k++) {
                                 ret = xmlSchemaAreValuesEqual(
                                     node->keys[k]->val,
                                     parNode->keys[k]->val);
                                 if (ret == -1)
                                     goto internal_error;
                                 if (ret == 0)
                                     break;
                             }
                         }
                         if (ret == 1)
                             /* Duplicate found. */
                             break;
                         j++;
                     }
                     if (j != oldNum) {
                         /*
                         * Handle duplicates. Move the duplicate in
                         * the parent's node-table to the list of
                         * duplicates.
-                        */                      
+                        */
                         oldNum--;
                         parBind->nbNodes--;
                         /*
                         * Move last old item to pos of duplicate.
                         */
                         parNodes[j] = parNodes[oldNum];
-                        
+
                         if (parBind->nbNodes != oldNum) {
                             /*
-                            * If new items exist, move last new item to 
+                            * If new items exist, move last new item to
                             * last of old items.
                             */
-                            parNodes[oldNum] = 
+                            parNodes[oldNum] =
                                 parNodes[parBind->nbNodes];
                         }
                         if (parBind->dupls == NULL) {
                             parBind->dupls = xmlSchemaItemListCreate();
                             if (parBind->dupls == NULL)
                                 goto internal_error;
                         }
-                        xmlSchemaItemListAdd(parBind->dupls, parNode);                  
+                        xmlSchemaItemListAdd(parBind->dupls, parNode);
                     } else {
                         /*
-                        * Add the node-table entry (node and key-sequence) of 
+                        * Add the node-table entry (node and key-sequence) of
                         * the child node to the node table of the parent node.
                         */
-                        if (parBind->nodeTable == NULL) {                       
-                            parBind->nodeTable = (xmlSchemaPSVIIDCNodePtr *) 
+                        if (parBind->nodeTable == NULL) {
+                            parBind->nodeTable = (xmlSchemaPSVIIDCNodePtr *)
                                 xmlMalloc(10 * sizeof(xmlSchemaPSVIIDCNodePtr));
                             if (parBind->nodeTable == NULL) {
-                                xmlSchemaVErrMemory(NULL, 
+                                xmlSchemaVErrMemory(NULL,
                                     "allocating IDC list of node-table items", NULL);
                                 goto internal_error;
                             }
                             parBind->sizeNodes = 1;
                         } else if (parBind->nbNodes >= parBind->sizeNodes) {
                             parBind->sizeNodes *= 2;
-                            parBind->nodeTable = (xmlSchemaPSVIIDCNodePtr *) 
-                                xmlRealloc(parBind->nodeTable, parBind->sizeNodes * 
+                            parBind->nodeTable = (xmlSchemaPSVIIDCNodePtr *)
+                                xmlRealloc(parBind->nodeTable, parBind->sizeNodes *
                                 sizeof(xmlSchemaPSVIIDCNodePtr));
                             if (parBind->nodeTable == NULL) {
-                                xmlSchemaVErrMemory(NULL, 
+                                xmlSchemaVErrMemory(NULL,
                                     "re-allocating IDC list of node-table items", NULL);
                                 goto internal_error;
-                            }                       
+                            }
                         }
                         parNodes = parBind->nodeTable;
                         /*
                         * Append the new node-table entry to the 'new node-table
                         * entries' section.
                         */
                         parNodes[parBind->nbNodes++] = node;
                     }
 
-                }       
-                
-            }   
+                }
+
+            }
         } else {
             /*
             * No binding for the IDC was found: create a new one and
             * copy all node-tables.
             */
             parBind = xmlSchemaIDCNewBinding(bind->definition);
             if (parBind == NULL)
                 goto internal_error;
-            
+
             /*
             * TODO: Hmm, how to optimize the initial number of
             * allocated entries?
             */
             if (bind->nbNodes != 0) {
                 /*
                 * Add all IDC node-table entries.
                 */
                 if (! vctxt->psviExposeIDCNodeTables) {
                     /*
                     * Just move the entries.
                     * NOTE: this is quite save here, since
                     * all the keyref lookups have already been
                     * performed.
                     */
                     parBind->nodeTable = bind->nodeTable;
                     bind->nodeTable = NULL;
                     parBind->sizeNodes = bind->sizeNodes;
                     bind->sizeNodes = 0;
                     parBind->nbNodes = bind->nbNodes;
                     bind->nbNodes = 0;
                 } else {
                     /*
                     * Copy the entries.
                     */
-                    parBind->nodeTable = (xmlSchemaPSVIIDCNodePtr *) 
+                    parBind->nodeTable = (xmlSchemaPSVIIDCNodePtr *)
                         xmlMalloc(bind->nbNodes *
                         sizeof(xmlSchemaPSVIIDCNodePtr));
                     if (parBind->nodeTable == NULL) {
-                        xmlSchemaVErrMemory(NULL, 
+                        xmlSchemaVErrMemory(NULL,
                             "allocating an array of IDC node-table "
                             "items", NULL);
                         xmlSchemaIDCFreeBinding(parBind);
                         goto internal_error;
                     }
                     parBind->sizeNodes = bind->nbNodes;
                     parBind->nbNodes = bind->nbNodes;
                     memcpy(parBind->nodeTable, bind->nodeTable,
                         bind->nbNodes * sizeof(xmlSchemaPSVIIDCNodePtr));
                 }
             }
             if (bind->dupls) {
                 /*
                 * Move the duplicates.
                 */
                 if (parBind->dupls != NULL)
                     xmlSchemaItemListFree(parBind->dupls);
                 parBind->dupls = bind->dupls;
-                bind->dupls = NULL;             
+                bind->dupls = NULL;
             }
-            if (*parTable == NULL)
-                *parTable = parBind;
-            else {
-                parBind->next = *parTable;
-                *parTable = parBind;
-            }      
-        }       
+            if (parTable != NULL) {
+                if (*parTable == NULL)
+                    *parTable = parBind;
+                else {
+                    parBind->next = *parTable;
+                    *parTable = parBind;
+                }
+            }
+        }
 
 next_binding:
         bind = bind->next;
     }
     return (0);
 
 internal_error:
     return(-1);
 }
 
 /**
  * xmlSchemaCheckCVCIDCKeyRef:
  * @vctxt: the WXS validation context
  * @elemDecl: the element declaration
  *
  * Check the cvc-idc-keyref constraints.
  */
 static int
 xmlSchemaCheckCVCIDCKeyRef(xmlSchemaValidCtxtPtr vctxt)
 {
     xmlSchemaIDCMatcherPtr matcher;
     xmlSchemaPSVIIDCBindingPtr bind;
-    
+
     matcher = vctxt->inode->idcMatchers;
     /*
     * Find a keyref.
     */
     while (matcher != NULL) {
         if ((matcher->idcType == XML_SCHEMA_TYPE_IDC_KEYREF) &&
             matcher->targets &&
             matcher->targets->nbItems)
         {
             int i, j, k, res, nbFields, hasDupls;
             xmlSchemaPSVIIDCKeyPtr *refKeys, *keys;
             xmlSchemaPSVIIDCNodePtr refNode = NULL;
 
             nbFields = matcher->aidc->def->nbFields;
 
             /*
             * Find the IDC node-table for the referenced IDC key/unique.
             */
             bind = vctxt->inode->idcTable;
             while (bind != NULL) {
-                if ((xmlSchemaIDCPtr) matcher->aidc->def->ref->item == 
+                if ((xmlSchemaIDCPtr) matcher->aidc->def->ref->item ==
                     bind->definition)
                     break;
                 bind = bind->next;
             }
             hasDupls = (bind && bind->dupls && bind->dupls->nbItems) ? 1 : 0;
             /*
             * Search for a matching key-sequences.
             */
             for (i = 0; i < matcher->targets->nbItems; i++) {
                 res = 0;
@@ skipping 48 matching lines @@
                                         refNode->keys, nbFields),
                                     xmlSchemaGetComponentQName(&strB,
                                         matcher->aidc->def));
                                 FREE_AND_NULL(str);
                                 FREE_AND_NULL(strB);
                                 break;
                             }
                         }
                     }
                 }
-                
+
                 if (res == 0) {
                     xmlChar *str = NULL, *strB = NULL;
                     xmlSchemaKeyrefErr(vctxt,
                         XML_SCHEMAV_CVC_IDC, refNode,
                         (xmlSchemaTypePtr) matcher->aidc->def,
                         "No match found for key-sequence %s of keyref '%s'",
                         xmlSchemaFormatIDCKeySequence(vctxt, &str,
                             refNode->keys, nbFields),
                         xmlSchemaGetComponentQName(&strB, matcher->aidc->def));
                     FREE_AND_NULL(str);
@@ skipping 63 matching lines @@
     vctxt->attrInfos[vctxt->nbAttrInfos++] = iattr;
 
     return (iattr);
 }
 
 static int
 xmlSchemaValidatorPushAttribute(xmlSchemaValidCtxtPtr vctxt,
                         xmlNodePtr attrNode,
                         int nodeLine,
                         const xmlChar *localName,
-                        const xmlChar *nsName,                  
+                        const xmlChar *nsName,
                         int ownedNames,
                         xmlChar *value,
                         int ownedValue)
 {
     xmlSchemaAttrInfoPtr attr;
 
     attr = xmlSchemaGetFreshAttrInfo(vctxt);
     if (attr == NULL) {
         VERROR_INT("xmlSchemaPushAttribute",
             "calling xmlSchemaGetFreshAttrInfo()");
         return (-1);
     }
     attr->node = attrNode;
     attr->nodeLine = nodeLine;
     attr->state = XML_SCHEMAS_ATTR_UNKNOWN;
     attr->localName = localName;
     attr->nsName = nsName;
     if (ownedNames)
         attr->flags |= XML_SCHEMA_NODE_INFO_FLAG_OWNED_NAMES;
     /*
     * Evaluate if it's an XSI attribute.
     */
     if (nsName != NULL) {
         if (xmlStrEqual(localName, BAD_CAST "nil")) {
             if (xmlStrEqual(attr->nsName, xmlSchemaInstanceNs)) {
-                attr->metaType = XML_SCHEMA_ATTR_INFO_META_XSI_NIL;             
+                attr->metaType = XML_SCHEMA_ATTR_INFO_META_XSI_NIL;
             }
         } else if (xmlStrEqual(localName, BAD_CAST "type")) {
             if (xmlStrEqual(attr->nsName, xmlSchemaInstanceNs)) {
                 attr->metaType = XML_SCHEMA_ATTR_INFO_META_XSI_TYPE;
             }
         } else if (xmlStrEqual(localName, BAD_CAST "schemaLocation")) {
             if (xmlStrEqual(attr->nsName, xmlSchemaInstanceNs)) {
                 attr->metaType = XML_SCHEMA_ATTR_INFO_META_XSI_SCHEMA_LOC;
             }
         } else if (xmlStrEqual(localName, BAD_CAST "noNamespaceSchemaLocation")) {
@@ skipping 200 matching lines @@
         ws = XML_SCHEMA_WHITESPACE_COLLAPSE;
     /*
     * If the value was not computed (for string or
     * anySimpleType based types), then use the provided
     * type.
     */
     if (val == NULL)
         valType = valType;
     else
         valType = xmlSchemaGetValType(val);
-    
+
     ret = 0;
     for (facetLink = type->facetSet; facetLink != NULL;
         facetLink = facetLink->next) {
         /*
         * Skip the pattern "whiteSpace": it is used to
         * format the character content beforehand.
         */
         switch (facetLink->facet->type) {
             case XML_SCHEMA_FACET_WHITESPACE:
             case XML_SCHEMA_FACET_PATTERN:
@@ skipping 28 matching lines @@
 
 WXS_IS_LIST:
     if (! WXS_IS_LIST(type))
         goto pattern_and_enum;
     /*
     * "length", "minLength" and "maxLength" of list types.
     */
     ret = 0;
     for (facetLink = type->facetSet; facetLink != NULL;
         facetLink = facetLink->next) {
-        
+
         switch (facetLink->facet->type) {
             case XML_SCHEMA_FACET_LENGTH:
             case XML_SCHEMA_FACET_MINLENGTH:
-            case XML_SCHEMA_FACET_MAXLENGTH:                
+            case XML_SCHEMA_FACET_MAXLENGTH:
                 ret = xmlSchemaValidateListSimpleTypeFacet(facetLink->facet,
                     value, length, NULL);
                 break;
             default:
                 continue;
         }
         if (ret < 0) {
             AERROR_INT("xmlSchemaValidateFacets",
                 "validating against a list type facet");
             return (-1);
         } else if (ret > 0) {
-            if (fireErrors)             
+            if (fireErrors)
                 xmlSchemaFacetErr(actxt, ret, node,
                 value, length, type, facetLink->facet, NULL, NULL, NULL);
             else
                 return (ret);
             if (error == 0)
                 error = ret;
         }
         ret = 0;
     }
 
@@ skipping 56 matching lines @@
         */
         tmpType = type;
         facet = NULL;
         do {
             found = 0;
             for (facetLink = tmpType->facetSet; facetLink != NULL;
                 facetLink = facetLink->next) {
                 if (facetLink->facet->type != XML_SCHEMA_FACET_PATTERN)
                     continue;
                 found = 1;
-                /* 
+                /*
                 * NOTE that for patterns, @value needs to be the
                 * normalized vaule.
                 */
                 ret = xmlRegexpExec(facetLink->facet->regexp, value);
                 if (ret == 1)
                     break;
                 else if (ret < 0) {
                     AERROR_INT("xmlSchemaValidateFacets",
                         "validating against a pattern facet");
                     return (-1);
                 } else {
-                    /* 
+                    /*
                     * Save the last non-validating facet.
                     */
                     facet = facetLink->facet;
                 }
             }
             if (found && (ret != 1)) {
                 ret = XML_SCHEMAV_CVC_PATTERN_VALID;
                 if (fireErrors) {
                     xmlSchemaFacetErr(actxt, ret, node,
                         value, 0, type, facet, NULL, NULL, NULL);
                 } else
                     return (ret);
                 if (error == 0)
                     error = ret;
                 break;
             }
             tmpType = tmpType->baseType;
         } while ((tmpType != NULL) && (tmpType->type != XML_SCHEMA_TYPE_BASIC));
     }
 
     return (error);
 }
- 
+
 static xmlChar *
 xmlSchemaNormalizeValue(xmlSchemaTypePtr type,
                         const xmlChar *value)
 {
-    switch (xmlSchemaGetWhiteSpaceFacetValue(type)) {   
+    switch (xmlSchemaGetWhiteSpaceFacetValue(type)) {
         case XML_SCHEMA_WHITESPACE_COLLAPSE:
             return (xmlSchemaCollapseString(value));
         case XML_SCHEMA_WHITESPACE_REPLACE:
             return (xmlSchemaWhiteSpaceReplace(value));
         default:
             return (NULL);
     }
 }
 
 static int
 xmlSchemaValidateQName(xmlSchemaValidCtxtPtr vctxt,
                        const xmlChar *value,
                        xmlSchemaValPtr *val,
                        int valNeeded)
 {
     int ret;
     const xmlChar *nsName;
     xmlChar *local, *prefix = NULL;
-    
+
     ret = xmlValidateQName(value, 1);
     if (ret != 0) {
         if (ret == -1) {
             VERROR_INT("xmlSchemaValidateQName",
                 "calling xmlValidateQName()");
             return (-1);
         }
         return( XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1);
     }
     /*
     * NOTE: xmlSplitQName2 will always return a duplicated
     * strings.
     */
     local = xmlSplitQName2(value, &prefix);
     if (local == NULL)
         local = xmlStrdup(value);
     /*
     * OPTIMIZE TODO: Use flags for:
     *  - is there any namespace binding?
     *  - is there a default namespace?
     */
     nsName = xmlSchemaLookupNamespace(vctxt, prefix);
-    
+
     if (prefix != NULL) {
         xmlFree(prefix);
         /*
         * A namespace must be found if the prefix is
         * NOT NULL.
         */
         if (nsName == NULL) {
             ret = XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1;
             xmlSchemaCustomErr(ACTXT_CAST vctxt, ret, NULL,
                 WXS_BASIC_CAST xmlSchemaGetBuiltInType(XML_SCHEMAS_QNAME),
@@ skipping 36 matching lines @@
     xmlChar *normValue = NULL;
 
 #define NORMALIZE(atype) \
     if ((! isNormalized) && \
     (normalize || (type->flags & XML_SCHEMAS_TYPE_NORMVALUENEEDED))) { \
         normValue = xmlSchemaNormalizeValue(atype, value); \
         if (normValue != NULL) \
             value = normValue; \
         isNormalized = 1; \
     }
-    
+
     if ((retVal != NULL) && (*retVal != NULL)) {
         xmlSchemaFreeValue(*retVal);
         *retVal = NULL;
     }
     /*
     * 3.14.4 Simple Type Definition Validation Rules
     * Validation Rule: String Valid
     */
     /*
     * 1 It is schema-valid with respect to that definition as defined
     * by Datatype Valid in [XML Schemas: Datatypes].
     */
     /*
     * 2.1 If The definition is ENTITY or is validly derived from ENTITY given
-    * the empty set, as defined in Type Derivation OK (Simple) (§3.14.6), then
-    * the string must be a ·declared entity name·.
+    * the empty set, as defined in Type Derivation OK (Simple) (�3.14.6), then
+    * the string must be a �declared entity name�.
     */
     /*
     * 2.2 If The definition is ENTITIES or is validly derived from ENTITIES
-    * given the empty set, as defined in Type Derivation OK (Simple) (§3.14.6),
-    * then every whitespace-delimited substring of the string must be a ·declared
-    * entity name·.
+    * given the empty set, as defined in Type Derivation OK (Simple) (�3.14.6),
+    * then every whitespace-delimited substring of the string must be a �declared
+    * entity name�.
     */
     /*
     * 2.3 otherwise no further condition applies.
     */
     if ((! valNeeded) && (type->flags & XML_SCHEMAS_TYPE_FACETSNEEDVALUE))
         valNeeded = 1;
     if (value == NULL)
         value = BAD_CAST "";
     if (WXS_IS_ANY_SIMPLE_TYPE(type) || WXS_IS_ATOMIC(type)) {
         xmlSchemaTypePtr biType; /* The built-in type. */
         /*
-        * SPEC (1.2.1) "if {variety} is ·atomic· then the string must ·match·
-        * a literal in the ·lexical space· of {base type definition}"
+        * SPEC (1.2.1) "if {variety} is �atomic� then the string must �match�
+        * a literal in the �lexical space� of {base type definition}"
         */
         /*
         * Whitespace-normalize.
         */
         NORMALIZE(type);
         if (type->type != XML_SCHEMA_TYPE_BASIC) {
             /*
             * Get the built-in type.
             */
             biType = type->baseType;
             while ((biType != NULL) &&
                 (biType->type != XML_SCHEMA_TYPE_BASIC))
                 biType = biType->baseType;
 
             if (biType == NULL) {
                 AERROR_INT("xmlSchemaVCheckCVCSimpleType",
                     "could not get the built-in type");
                 goto internal_error;
             }
         } else
             biType = type;
         /*
         * NOTATIONs need to be processed here, since they need
         * to lookup in the hashtable of NOTATION declarations of the schema.
         */
-        if (actxt->type == XML_SCHEMA_CTXT_VALIDATOR) {     
-            switch (biType->builtInType) {              
-                case XML_SCHEMAS_NOTATION:                  
+        if (actxt->type == XML_SCHEMA_CTXT_VALIDATOR) {
+            switch (biType->builtInType) {
+                case XML_SCHEMAS_NOTATION:
                     ret = xmlSchemaValidateNotation(
                         (xmlSchemaValidCtxtPtr) actxt,
                         ((xmlSchemaValidCtxtPtr) actxt)->schema,
                         NULL, value, &val, valNeeded);
                     break;
                 case XML_SCHEMAS_QNAME:
                     ret = xmlSchemaValidateQName((xmlSchemaValidCtxtPtr) actxt,
                         value, &val, valNeeded);
                     break;
                 default:
                     /* ws = xmlSchemaGetWhiteSpaceFacetValue(type); */
                     if (valNeeded)
                         ret = xmlSchemaValPredefTypeNodeNoNorm(biType,
-                            value, &val, NULL);
+                            value, &val, node);
                     else
                         ret = xmlSchemaValPredefTypeNodeNoNorm(biType,
-                            value, NULL, NULL);
+                            value, NULL, node);
                     break;
             }
-        } else if (actxt->type == XML_SCHEMA_CTXT_PARSER) {         
-            switch (biType->builtInType) {                  
+        } else if (actxt->type == XML_SCHEMA_CTXT_PARSER) {
+            switch (biType->builtInType) {
                 case XML_SCHEMAS_NOTATION:
                     ret = xmlSchemaValidateNotation(NULL,
                         ((xmlSchemaParserCtxtPtr) actxt)->schema, node,
                         value, &val, valNeeded);
                     break;
                 default:
                     /* ws = xmlSchemaGetWhiteSpaceFacetValue(type); */
                     if (valNeeded)
                         ret = xmlSchemaValPredefTypeNodeNoNorm(biType,
                             value, &val, node);
                     else
                         ret = xmlSchemaValPredefTypeNodeNoNorm(biType,
                             value, NULL, node);
                     break;
-            }      
+            }
         } else {
             /*
             * Validation via a public API is not implemented yet.
             */
             TODO
             goto internal_error;
         }
         if (ret != 0) {
             if (ret < 0) {
                 AERROR_INT("xmlSchemaVCheckCVCSimpleType",
                     "validating against a built-in type");
                 goto internal_error;
             }
             if (WXS_IS_LIST(type))
                 ret = XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2;
             else
-                ret = XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1;         
+                ret = XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1;
         }
         if ((ret == 0) && (type->flags & XML_SCHEMAS_TYPE_HAS_FACETS)) {
             /*
             * Check facets.
             */
             ret = xmlSchemaValidateFacets(actxt, node, type,
                 (xmlSchemaValType) biType->builtInType, value, val,
                 0, fireErrors);
             if (ret != 0) {
                 if (ret < 0) {
                     AERROR_INT("xmlSchemaVCheckCVCSimpleType",
                         "validating facets of atomic simple type");
                     goto internal_error;
                 }
-                if (WXS_IS_LIST(type)) 
+                if (WXS_IS_LIST(type))
                     ret = XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2;
                 else
-                    ret = XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1;         
+                    ret = XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1;
             }
         }
         if (fireErrors && (ret > 0))
             xmlSchemaSimpleTypeErr(actxt, ret, node, value, type, 1);
     } else if (WXS_IS_LIST(type)) {
 
         xmlSchemaTypePtr itemType;
         const xmlChar *cur, *end;
         xmlChar *tmpValue = NULL;
         unsigned long len = 0;
         xmlSchemaValPtr prevVal = NULL, curVal = NULL;
-        /* 1.2.2 if {variety} is ·list· then the string must be a sequence
-        * of white space separated tokens, each of which ·match·es a literal
-        * in the ·lexical space· of {item type definition}
+        /* 1.2.2 if {variety} is �list� then the string must be a sequence
+        * of white space separated tokens, each of which �match�es a literal
+        * in the �lexical space� of {item type definition}
         */
         /*
         * Note that XML_SCHEMAS_TYPE_NORMVALUENEEDED will be set if
         * the list type has an enum or pattern facet.
         */
         NORMALIZE(type);
         /*
         * VAL TODO: Optimize validation of empty values.
         * VAL TODO: We do not have computed values for lists.
         */
-        itemType = WXS_LIST_ITEMTYPE(type);     
+        itemType = WXS_LIST_ITEMTYPE(type);
         cur = value;
         do {
             while (IS_BLANK_CH(*cur))
                 cur++;
             end = cur;
             while ((*end != 0) && (!(IS_BLANK_CH(*end))))
                 end++;
             if (end == cur)
                 break;
             tmpValue = xmlStrndup(cur, end - cur);
@@ skipping 18 matching lines @@
                 curVal = NULL;
             }
             if (ret != 0) {
                 if (ret < 0) {
                     AERROR_INT("xmlSchemaVCheckCVCSimpleType",
                         "validating an item of list simple type");
                     goto internal_error;
                 }
                 ret = XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2;
                 break;
-            }       
+            }
             cur = end;
         } while (*cur != 0);
         FREE_AND_NULL(tmpValue);
         if ((ret == 0) && (type->flags & XML_SCHEMAS_TYPE_HAS_FACETS)) {
             /*
             * Apply facets (pattern, enumeration).
             */
             ret = xmlSchemaValidateFacets(actxt, node, type,
                 XML_SCHEMAS_UNKNOWN, value, val,
                 len, fireErrors);
             if (ret != 0) {
                 if (ret < 0) {
                     AERROR_INT("xmlSchemaVCheckCVCSimpleType",
                         "validating facets of list simple type");
                     goto internal_error;
                 }
                 ret = XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2;
             }
         }
         if (fireErrors && (ret > 0)) {
-            /* 
+            /*
             * Report the normalized value.
             */
             normalize = 1;
             NORMALIZE(type);
             xmlSchemaSimpleTypeErr(actxt, ret, node, value, type, 1);
         }
     } else if (WXS_IS_UNION(type)) {
         xmlSchemaTypeLinkPtr memberLink;
         /*
-        * TODO: For all datatypes ·derived· by ·union·  whiteSpace does
-        * not apply directly; however, the normalization behavior of ·union·
+        * TODO: For all datatypes �derived� by �union�  whiteSpace does
+        * not apply directly; however, the normalization behavior of �union�
         * types is controlled by the value of whiteSpace on that one of the
-        * ·memberTypes· against which the ·union· is successfully validated.
+        * �memberTypes� against which the �union� is successfully validated.
         *
         * This means that the value is normalized by the first validating
         * member type, then the facets of the union type are applied. This
         * needs changing of the value!
         */
 
         /*
-        * 1.2.3 if {variety} is ·union· then the string must ·match· a
-        * literal in the ·lexical space· of at least one member of
+        * 1.2.3 if {variety} is �union� then the string must �match� a
+        * literal in the �lexical space� of at least one member of
         * {member type definitions}
         */
         memberLink = xmlSchemaGetUnionSimpleTypeMemberTypes(type);
         if (memberLink == NULL) {
             AERROR_INT("xmlSchemaVCheckCVCSimpleType",
                 "union simple type has no member types");
             goto internal_error;
-        }       
+        }
         /*
         * Always normalize union type values, since we currently
         * cannot store the whitespace information with the value
         * itself; otherwise a later value-comparison would be
         * not possible.
         */
         while (memberLink != NULL) {
-            if (valNeeded) 
+            if (valNeeded)
                 ret = xmlSchemaVCheckCVCSimpleType(actxt, node,
                     memberLink->type, value, &val, 0, 1, 0);
             else
                 ret = xmlSchemaVCheckCVCSimpleType(actxt, node,
                     memberLink->type, value, NULL, 0, 1, 0);
             if (ret <= 0)
                 break;
             memberLink = memberLink->next;
         }
         if (ret != 0) {
             if (ret < 0) {
                 AERROR_INT("xmlSchemaVCheckCVCSimpleType",
                     "validating members of union simple type");
                 goto internal_error;
             }
             ret = XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_3;
         }
         /*
         * Apply facets (pattern, enumeration).
         */
         if ((ret == 0) && (type->flags & XML_SCHEMAS_TYPE_HAS_FACETS)) {
             /*
-            * The normalization behavior of ·union· types is controlled by
-            * the value of whiteSpace on that one of the ·memberTypes·
-            * against which the ·union· is successfully validated.
+            * The normalization behavior of �union� types is controlled by
+            * the value of whiteSpace on that one of the �memberTypes�
+            * against which the �union� is successfully validated.
             */
             NORMALIZE(memberLink->type);
             ret = xmlSchemaValidateFacets(actxt, node, type,
                 XML_SCHEMAS_UNKNOWN, value, val,
                 0, fireErrors);
             if (ret != 0) {
                 if (ret < 0) {
                     AERROR_INT("xmlSchemaVCheckCVCSimpleType",
                         "validating facets of union simple type");
                     goto internal_error;
                 }
-                ret = XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_3;             
+                ret = XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_3;
             }
         }
         if (fireErrors && (ret > 0))
             xmlSchemaSimpleTypeErr(actxt, ret, node, value, type, 1);
     }
 
     if (normValue != NULL)
         xmlFree(normValue);
     if (ret == 0) {
         if (retVal != NULL)
@@ skipping 127 matching lines @@
                 xmlSchemaFormatQName(&str, nsName, local), NULL);
             FREE_AND_NULL(str);
             ret = vctxt->err;
             goto exit;
         }
         if (elemDecl != NULL) {
             int set = 0;
 
             /*
             * SPEC cvc-elt (3.3.4) : (4.3) (Type Derivation OK)
-            * "The ·local type definition· must be validly
+            * "The �local type definition� must be validly
             * derived from the {type definition} given the union of
             * the {disallowed substitutions} and the {type definition}'s
             * {prohibited substitutions}, as defined in
-            * Type Derivation OK (Complex) (§3.4.6)
+            * Type Derivation OK (Complex) (�3.4.6)
             * (if it is a complex type definition),
             * or given {disallowed substitutions} as defined in Type
-            * Derivation OK (Simple) (§3.14.6) (if it is a simple type
+            * Derivation OK (Simple) (�3.14.6) (if it is a simple type
             * definition)."
             *
             * {disallowed substitutions}: the "block" on the element decl.
             * {prohibited substitutions}: the "block" on the type def.
             */
             /*
             * OPTIMIZE TODO: We could map types already evaluated
             * to be validly derived from other types to avoid checking
             * this over and over for the same types.
             */
@@ skipping 239 matching lines @@
 * 3.2.4 Attribute Declaration Validation Rules
 *   Validation Rule: Attribute Locally Valid (cvc-attribute)
 *   Attribute Locally Valid (Use) (cvc-au)
 *
 * Only "assessed" attribute information items will be visible to
 * IDCs. I.e. not "lax" (without declaration) and "skip" wild attributes.
 */
 static int
 xmlSchemaVAttributesComplex(xmlSchemaValidCtxtPtr vctxt)
 {
-    xmlSchemaTypePtr type = vctxt->inode->typeDef;    
+    xmlSchemaTypePtr type = vctxt->inode->typeDef;
     xmlSchemaItemListPtr attrUseList;
     xmlSchemaAttributeUsePtr attrUse = NULL;
     xmlSchemaAttributePtr attrDecl = NULL;
-    xmlSchemaAttrInfoPtr iattr, tmpiattr;    
+    xmlSchemaAttrInfoPtr iattr, tmpiattr;
     int i, j, found, nbAttrs, nbUses;
     int xpathRes = 0, res, wildIDs = 0, fixed;
     xmlNodePtr defAttrOwnerElem = NULL;
 
     /*
     * SPEC (cvc-attribute)
-    * (1) "The declaration must not be ·absent· (see Missing
-    * Sub-components (§5.3) for how this can fail to be
+    * (1) "The declaration must not be �absent� (see Missing
+    * Sub-components (�5.3) for how this can fail to be
     * the case)."
     * (2) "Its {type definition} must not be absent."
     *
     * NOTE (1) + (2): This is not handled here, since we currently do not
     * allow validation against schemas which have missing sub-components.
     *
     * SPEC (cvc-complex-type)
     * (3) "For each attribute information item in the element information
     * item's [attributes] excepting those whose [namespace name] is
     * identical to http://www.w3.org/2001/XMLSchema-instance and whose
@@ skipping 29 matching lines @@
                 continue;
             if (!xmlStrEqual(iattr->nsName, attrDecl->targetNamespace))
                 continue;
             found = 1;
             /*
             * SPEC (cvc-complex-type)
             * (3.1) "If there is among the {attribute uses} an attribute
             * use with an {attribute declaration} whose {name} matches
             * the attribute information item's [local name] and whose
             * {target namespace} is identical to the attribute information
-            * item's [namespace name] (where an ·absent· {target namespace}
+            * item's [namespace name] (where an �absent� {target namespace}
             * is taken to be identical to a [namespace name] with no value),
-            * then the attribute information must be ·valid· with respect
+            * then the attribute information must be �valid� with respect
             * to that attribute use as per Attribute Locally Valid (Use)
-            * (§3.5.4). In this case the {attribute declaration} of that
-            * attribute use is the ·context-determined declaration· for the
+            * (�3.5.4). In this case the {attribute declaration} of that
+            * attribute use is the �context-determined declaration� for the
             * attribute information item with respect to Schema-Validity
-            * Assessment (Attribute) (§3.2.4) and
-            * Assessment Outcome (Attribute) (§3.2.5).
+            * Assessment (Attribute) (�3.2.4) and
+            * Assessment Outcome (Attribute) (�3.2.5).
             */
             iattr->state = XML_SCHEMAS_ATTR_ASSESSED;
             iattr->use = attrUse;
             /*
             * Context-determined declaration.
             */
             iattr->decl = attrDecl;
             iattr->typeDef = attrDecl->subtypes;
             break;
         }
@@ skipping 13 matching lines @@
             */
             tmpiattr = xmlSchemaGetFreshAttrInfo(vctxt);
             if (tmpiattr == NULL) {
                 VERROR_INT(
                     "xmlSchemaVAttributesComplex",
                     "calling xmlSchemaGetFreshAttrInfo()");
                 return (-1);
             }
             tmpiattr->state = XML_SCHEMAS_ATTR_ERR_MISSING;
             tmpiattr->use = attrUse;
-            tmpiattr->decl = attrDecl;      
+            tmpiattr->decl = attrDecl;
         } else if ((attrUse->occurs == XML_SCHEMAS_ATTR_USE_OPTIONAL) &&
             ((attrUse->defValue != NULL) ||
              (attrDecl->defValue != NULL))) {
             /*
             * Handle non-existent, optional, default/fixed attributes.
             */
             tmpiattr = xmlSchemaGetFreshAttrInfo(vctxt);
             if (tmpiattr == NULL) {
                 VERROR_INT(
                     "xmlSchemaVAttributesComplex",
                     "calling xmlSchemaGetFreshAttrInfo()");
                 return (-1);
             }
             tmpiattr->state = XML_SCHEMAS_ATTR_DEFAULT;
             tmpiattr->use = attrUse;
             tmpiattr->decl = attrDecl;
             tmpiattr->typeDef = attrDecl->subtypes;
             tmpiattr->localName = attrDecl->name;
             tmpiattr->nsName = attrDecl->targetNamespace;
         }
     }
 
     if (vctxt->nbAttrInfos == 0)
         return (0);
-    nbUses = vctxt->nbAttrInfos;
     /*
     * Validate against the wildcard.
     */
     if (type->attributeWildcard != NULL) {
         /*
         * SPEC (cvc-complex-type)
         * (3.2.1) "There must be an {attribute wildcard}."
         */
         for (i = 0; i < nbAttrs; i++) {
             iattr = vctxt->attrInfos[i];
             /*
             * SPEC (cvc-complex-type) (3)
             * Skip meta attributes.
             */
             if (iattr->state != XML_SCHEMAS_ATTR_UNKNOWN)
                 continue;
             /*
             * SPEC (cvc-complex-type)
-            * (3.2.2) "The attribute information item must be ·valid· with
-            * respect to it as defined in Item Valid (Wildcard) (§3.10.4)."
+            * (3.2.2) "The attribute information item must be �valid� with
+            * respect to it as defined in Item Valid (Wildcard) (�3.10.4)."
             *
             * SPEC Item Valid (Wildcard) (cvc-wildcard)
-            * "... its [namespace name] must be ·valid· with respect to
+            * "... its [namespace name] must be �valid� with respect to
             * the wildcard constraint, as defined in Wildcard allows
-            * Namespace Name (§3.10.4)."
+            * Namespace Name (�3.10.4)."
             */
             if (xmlSchemaCheckCVCWildcardNamespace(type->attributeWildcard,
                     iattr->nsName) == 0) {
                 /*
                 * Handle processContents.
                 *
                 * SPEC (cvc-wildcard):
                 * processContents | context-determined declaration:
                 * "strict"          "mustFind"
                 * "lax"             "none"
@@ skipping 15 matching lines @@
                 * Find an attribute declaration.
                 */
                 iattr->decl = xmlSchemaGetAttributeDecl(vctxt->schema,
                     iattr->localName, iattr->nsName);
                 if (iattr->decl != NULL) {
                     iattr->state = XML_SCHEMAS_ATTR_ASSESSED;
                     /*
                     * SPEC (cvc-complex-type)
                     * (5) "Let [Definition:]  the wild IDs be the set of
                     * all attribute information item to which clause 3.2
-                    * applied and whose ·validation· resulted in a
-                    * ·context-determined declaration· of mustFind or no
-                    * ·context-determined declaration· at all, and whose
+                    * applied and whose �validation� resulted in a
+                    * �context-determined declaration� of mustFind or no
+                    * �context-determined declaration� at all, and whose
                     * [local name] and [namespace name] resolve (as
-                    * defined by QName resolution (Instance) (§3.15.4)) to
+                    * defined by QName resolution (Instance) (�3.15.4)) to
                     * an attribute declaration whose {type definition} is
                     * or is derived from ID. Then all of the following
                     * must be true:"
                     */
                     iattr->typeDef = WXS_ATTR_TYPEDEF(iattr->decl);
                     if (xmlSchemaIsDerivedFromBuiltInType(
                         iattr->typeDef, XML_SCHEMAS_ID)) {
                         /*
                         * SPEC (5.1) "There must be no more than one
-                        * item in ·wild IDs·."
+                        * item in �wild IDs�."
                         */
                         if (wildIDs != 0) {
                             /* VAL TODO */
                             iattr->state = XML_SCHEMAS_ATTR_ERR_WILD_DUPLICATE_ID;
                             TODO
                             continue;
                         }
                         wildIDs++;
                         /*
                         * SPEC (cvc-complex-type)
-                        * (5.2) "If ·wild IDs· is non-empty, there must not
+                        * (5.2) "If �wild IDs� is non-empty, there must not
                         * be any attribute uses among the {attribute uses}
                         * whose {attribute declaration}'s {type definition}
                         * is or is derived from ID."
                         */
-                        for (j = 0; j < attrUseList->nbItems; j++) {
-                            if (xmlSchemaIsDerivedFromBuiltInType(
-                                WXS_ATTRUSE_TYPEDEF(attrUseList->items[j]),
-                                XML_SCHEMAS_ID)) {
-                                /* URGENT VAL TODO: implement */
-                                iattr->state = XML_SCHEMAS_ATTR_ERR_WILD_AND_USE_ID;
-                                TODO
-                                break;
-                            }
-                        }
+                        if (attrUseList != NULL) {
+                            for (j = 0; j < attrUseList->nbItems; j++) {
+                                if (xmlSchemaIsDerivedFromBuiltInType(
+                                    WXS_ATTRUSE_TYPEDEF(attrUseList->items[j]),
+                                    XML_SCHEMAS_ID)) {
+                                    /* URGENT VAL TODO: implement */
+                            iattr->state = XML_SCHEMAS_ATTR_ERR_WILD_AND_USE_ID;
+                                    TODO
+                                    break;
+                                }
+                            }
+                        }
                     }
                 } else if (type->attributeWildcard->processContents ==
                     XML_SCHEMAS_ANY_LAX) {
                     iattr->state = XML_SCHEMAS_ATTR_WILD_LAX_NO_DECL;
                     /*
                     * SPEC PSVI Assessment Outcome (Attribute)
                     * [validity] = "notKnown"
                     * [validation attempted] = "none"
                     */
                 } else {
@@ skipping 82 matching lines @@
                     VERROR_INT("xmlSchemaVAttributesComplex",
                         "calling xmlSchemaCopyValue()");
                     goto internal_error;
                 }
             }
             /*
             * PSVI: Add the default attribute to the current element.
             * VAL TODO: Should we use the *normalized* value? This currently
             *   uses the *initial* value.
             */
-            
+
             if (defAttrOwnerElem) {
                 xmlChar *normValue;
                 const xmlChar *value;
 
                 value = iattr->value;
                 /*
                 * Normalize the value.
                 */
                 normValue = xmlSchemaNormalizeValue(iattr->typeDef,
                     iattr->value);
@@ skipping 70 matching lines @@
         * the attribute was a wild attribute.
         */
         if ((iattr->decl->flags & XML_SCHEMAS_ATTR_FIXED) ||
             ((iattr->use != NULL) &&
              (iattr->use->flags & XML_SCHEMAS_ATTR_FIXED)))
             fixed = 1;
         else
             fixed = 0;
         /*
         * SPEC (cvc-attribute)
-        * (3) "The item's ·normalized value· must be locally ·valid·
-        * with respect to that {type definition} as per 
-        * String Valid (§3.14.4)."
+        * (3) "The item's �normalized value� must be locally �valid�
+        * with respect to that {type definition} as per
+        * String Valid (�3.14.4)."
         *
         * VAL TODO: Do we already have the
         * "normalized attribute value" here?
         */
         if (xpathRes || fixed) {
             iattr->flags |= XML_SCHEMA_NODE_INFO_VALUE_NEEDED;
             /*
             * Request a computed value.
             */
             res = xmlSchemaVCheckCVCSimpleType(
                 ACTXT_CAST vctxt,
                 iattr->node, iattr->typeDef, iattr->value, &(iattr->val),
                 1, 1, 0);
         } else {
             res = xmlSchemaVCheckCVCSimpleType(
                 ACTXT_CAST vctxt,
                 iattr->node, iattr->typeDef, iattr->value, NULL,
                 1, 0, 0);
         }
-            
+
         if (res != 0) {
             if (res == -1) {
                 VERROR_INT("xmlSchemaVAttributesComplex",
                     "calling xmlSchemaStreamValidateSimpleTypeValue()");
                 goto internal_error;
             }
             iattr->state = XML_SCHEMAS_ATTR_INVALID_VALUE;
             /*
             * SPEC PSVI Assessment Outcome (Attribute)
             * [validity] = "invalid"
             */
             goto eval_idcs;
         }
 
-        if (fixed) {        
+        if (fixed) {
             /*
             * SPEC Attribute Locally Valid (Use) (cvc-au)
-            * "For an attribute information item to be·valid·
+            * "For an attribute information item to be�valid�
             * with respect to an attribute use its *normalized*
-            * value· must match the *canonical* lexical
+            * value� must match the *canonical* lexical
             * representation of the attribute use's {value
             * constraint}value, if it is present and fixed."
             *
             * VAL TODO: The requirement for the *canonical* value
             * will be removed in XML Schema 1.1.
             */
             /*
             * SPEC Attribute Locally Valid (cvc-attribute)
-            * (4) "The item's *actual* value· must match the *value* of
+            * (4) "The item's *actual* value� must match the *value* of
             * the {value constraint}, if it is present and fixed."
             */
             if (iattr->val == NULL) {
                 /* VAL TODO: A value was not precomputed. */
                 TODO
                 goto eval_idcs;
             }
             if ((iattr->use != NULL) &&
                 (iattr->use->defValue != NULL)) {
                 if (iattr->use->defVal == NULL) {
@@ skipping 71 matching lines @@
                     break;
                 }
             case XML_SCHEMAS_ATTR_ERR_NO_TYPE:
                 VERROR(XML_SCHEMAV_CVC_ATTRIBUTE_2, NULL,
                     "The type definition is absent");
                 break;
             case XML_SCHEMAS_ATTR_ERR_FIXED_VALUE:
                 xmlSchemaCustomErr(ACTXT_CAST vctxt,
                     XML_SCHEMAV_CVC_AU, NULL, NULL,
                     "The value '%s' does not match the fixed "
-                    "value constraint '%s'", 
-                    iattr->value, iattr->vcValue);              
+                    "value constraint '%s'",
+                    iattr->value, iattr->vcValue);
                 break;
             case XML_SCHEMAS_ATTR_ERR_WILD_STRICT_NO_DECL:
                 VERROR(XML_SCHEMAV_CVC_WILDCARD, NULL,
                     "No matching global attribute declaration available, but "
                     "demanded by the strict wildcard");
                 break;
             case XML_SCHEMAS_ATTR_UNKNOWN:
                 if (iattr->metaType)
                     break;
                 /*
@@ skipping 41 matching lines @@
         * URGENT VAL TODO: Either we need to position the stream to the
         * next sibling, or walk the whole subtree.
         */
         *skip = 1;
         return (0);
     }
     {
         xmlSchemaElementPtr decl = NULL;
 
         decl = xmlSchemaGetElem(vctxt->schema,
-            vctxt->inode->localName, vctxt->inode->nsName);         
+            vctxt->inode->localName, vctxt->inode->nsName);
         if (decl != NULL) {
             vctxt->inode->decl = decl;
             return (0);
         }
     }
     if (wild->processContents == XML_SCHEMAS_ANY_STRICT) {
         /* VAL TODO: Change to proper error code. */
         VERROR(XML_SCHEMAV_CVC_ELT_1, NULL, /* WXS_BASIC_CAST wild */
             "No matching global element declaration available, but "
             "demanded by the strict wildcard");
@@ skipping 37 matching lines @@
 * xmlSchemaCheckCOSValidDefault:
 *
 * This will be called if: not nilled, no content and a default/fixed
 * value is provided.
 */
 
 static int
 xmlSchemaCheckCOSValidDefault(xmlSchemaValidCtxtPtr vctxt,
                               const xmlChar *value,
                               xmlSchemaValPtr *val)
-{   
+{
     int ret = 0;
     xmlSchemaNodeInfoPtr inode = vctxt->inode;
 
     /*
     * cos-valid-default:
     * Schema Component Constraint: Element Default Valid (Immediate)
-    * For a string to be a valid default with respect to a type 
+    * For a string to be a valid default with respect to a type
     * definition the appropriate case among the following must be true:
-    */    
+    */
     if WXS_IS_COMPLEX(inode->typeDef) {
         /*
         * Complex type.
         *
         * SPEC (2.1) "its {content type} must be a simple type definition
         * or mixed."
         * SPEC (2.2.2) "If the {content type} is mixed, then the {content
-        * type}'s particle must be ·emptiable· as defined by 
-        * Particle Emptiable (§3.9.6)."
+        * type}'s particle must be �emptiable� as defined by
+        * Particle Emptiable (�3.9.6)."
         */
         if ((! WXS_HAS_SIMPLE_CONTENT(inode->typeDef)) &&
             ((! WXS_HAS_MIXED_CONTENT(inode->typeDef)) ||
              (! WXS_EMPTIABLE(inode->typeDef)))) {
             ret = XML_SCHEMAP_COS_VALID_DEFAULT_2_1;
             /* NOTE that this covers (2.2.2) as well. */
             VERROR(ret, NULL,
                 "For a string to be a valid default, the type definition "
                 "must be a simple type or a complex type with simple content "
                 "or mixed content and a particle emptiable");
             return(ret);
         }
-    }   
+    }
     /*
-    * 1 If the type definition is a simple type definition, then the string 
-    * must be ·valid· with respect to that definition as defined by String 
-    * Valid (§3.14.4).
+    * 1 If the type definition is a simple type definition, then the string
+    * must be �valid� with respect to that definition as defined by String
+    * Valid (�3.14.4).
     *
     * AND
     *
-    * 2.2.1 If the {content type} is a simple type definition, then the 
-    * string must be ·valid· with respect to that simple type definition 
-    * as defined by String Valid (§3.14.4).
-    */  
+    * 2.2.1 If the {content type} is a simple type definition, then the
+    * string must be �valid� with respect to that simple type definition
+    * as defined by String Valid (�3.14.4).
+    */
     if (WXS_IS_SIMPLE(inode->typeDef)) {
 
         ret = xmlSchemaVCheckCVCSimpleType(ACTXT_CAST vctxt,
             NULL, inode->typeDef, value, val, 1, 1, 0);
 
     } else if (WXS_HAS_SIMPLE_CONTENT(inode->typeDef)) {
 
         ret = xmlSchemaVCheckCVCSimpleType(ACTXT_CAST vctxt,
             NULL, inode->typeDef->contentTypeDef, value, val, 1, 1, 0);
     }
     if (ret < 0) {
         VERROR_INT("xmlSchemaCheckCOSValidDefault",
             "calling xmlSchemaVCheckCVCSimpleType()");
-    }    
+    }
     return (ret);
 }
 
 static void
 xmlSchemaVContentModelCallback(xmlSchemaValidCtxtPtr vctxt ATTRIBUTE_UNUSED,
                                const xmlChar * name ATTRIBUTE_UNUSED,
                                xmlSchemaElementPtr item,
                                xmlSchemaNodeInfoPtr inode)
 {
     inode->decl = item;
@@ skipping 13 matching lines @@
                     inode->localName, inode->nsName));
 
         }
         FREE_AND_NULL(str)
     }
 #endif
 }
 
 static int
 xmlSchemaValidatorPushElem(xmlSchemaValidCtxtPtr vctxt)
-{    
+{
     vctxt->inode = xmlSchemaGetFreshElemInfo(vctxt);
     if (vctxt->inode == NULL) {
         VERROR_INT("xmlSchemaValidatorPushElem",
             "calling xmlSchemaGetFreshElemInfo()");
         return (-1);
-    }   
+    }
     vctxt->nbAttrInfos = 0;
     return (0);
 }
 
 static int
 xmlSchemaVCheckINodeDataType(xmlSchemaValidCtxtPtr vctxt,
                              xmlSchemaNodeInfoPtr inode,
                              xmlSchemaTypePtr type,
                              const xmlChar *value)
 {
     if (inode->flags & XML_SCHEMA_NODE_INFO_VALUE_NEEDED)
         return (xmlSchemaVCheckCVCSimpleType(
             ACTXT_CAST vctxt, NULL,
             type, value, &(inode->val), 1, 1, 0));
     else
         return (xmlSchemaVCheckCVCSimpleType(
             ACTXT_CAST vctxt, NULL,
             type, value, NULL, 1, 0, 0));
 }
 
 
 
-/* 
+/*
 * Process END of element.
 */
 static int
 xmlSchemaValidatorPopElem(xmlSchemaValidCtxtPtr vctxt)
 {
     int ret = 0;
     xmlSchemaNodeInfoPtr inode = vctxt->inode;
 
     if (vctxt->nbAttrInfos != 0)
         xmlSchemaClearAttrInfos(vctxt);
     if (inode->flags & XML_SCHEMA_NODE_INFO_ERR_NOT_EXPECTED) {
         /*
         * This element was not expected;
         * we will not validate child elements of broken parents.
         * Skip validation of all content of the parent.
         */
         vctxt->skipDepth = vctxt->depth -1;
         goto end_elem;
-    }    
+    }
     if ((inode->typeDef == NULL) ||
         (inode->flags & XML_SCHEMA_NODE_INFO_ERR_BAD_TYPE)) {
         /*
         * 1. the type definition might be missing if the element was
         *    error prone
         * 2. it might be abstract.
         */
         goto end_elem;
     }
     /*
     * Check the content model.
     */
     if ((inode->typeDef->contentType == XML_SCHEMA_CONTENT_MIXED) ||
         (inode->typeDef->contentType == XML_SCHEMA_CONTENT_ELEMENTS)) {
 
         /*
         * Workaround for "anyType".
         */
         if (inode->typeDef->builtInType == XML_SCHEMAS_ANYTYPE)
-            goto character_content;                     
-        
+            goto character_content;
+
         if ((inode->flags & XML_SCHEMA_ELEM_INFO_ERR_BAD_CONTENT) == 0) {
             xmlChar *values[10];
             int terminal, nbval = 10, nbneg;
 
             if (inode->regexCtxt == NULL) {
                 /*
                 * Create the regex context.
                 */
                 inode->regexCtxt =
                     xmlRegNewExecCtxt(inode->typeDef->contModel,
                     (xmlRegExecCallbacks) xmlSchemaVContentModelCallback,
                     vctxt);
                 if (inode->regexCtxt == NULL) {
                     VERROR_INT("xmlSchemaValidatorPopElem",
                         "failed to create a regex context");
                     goto internal_error;
                 }
 #ifdef DEBUG_AUTOMATA
                 xmlGenericError(xmlGenericErrorContext,
                     "AUTOMATON create on '%s'\n", inode->localName);
-#endif      
+#endif
             }
             /*
             * Get hold of the still expected content, since a further
             * call to xmlRegExecPushString() will loose this information.
-            */ 
+            */
             xmlRegExecNextValues(inode->regexCtxt,
                 &nbval, &nbneg, &values[0], &terminal);
             ret = xmlRegExecPushString(inode->regexCtxt, NULL, NULL);
             if ((ret<0) || ((ret==0) && (!INODE_NILLED(inode)))) {
                 /*
                 * Still missing something.
                 */
                 ret = 1;
                 inode->flags |=
                     XML_SCHEMA_ELEM_INFO_ERR_BAD_CONTENT;
@@ skipping 29 matching lines @@
         xmlSchemaFreeValue(vctxt->value);
         vctxt->value = NULL;
     }
     /*
     * Check character content.
     */
     if (inode->decl == NULL) {
         /*
         * Speedup if no declaration exists.
         */
-        if (WXS_IS_SIMPLE(inode->typeDef)) {        
+        if (WXS_IS_SIMPLE(inode->typeDef)) {
             ret = xmlSchemaVCheckINodeDataType(vctxt,
                 inode, inode->typeDef, inode->value);
         } else if (WXS_HAS_SIMPLE_CONTENT(inode->typeDef)) {
             ret = xmlSchemaVCheckINodeDataType(vctxt,
                 inode, inode->typeDef->contentTypeDef,
                 inode->value);
-        }               
+        }
         if (ret < 0) {
             VERROR_INT("xmlSchemaValidatorPopElem",
                 "calling xmlSchemaVCheckCVCSimpleType()");
             goto internal_error;
         }
         goto end_elem;
     }
     /*
-    * cvc-elt (3.3.4) : 5 
+    * cvc-elt (3.3.4) : 5
     * The appropriate case among the following must be true:
     */
     /*
-    * cvc-elt (3.3.4) : 5.1 
-    * If the declaration has a {value constraint}, 
-    * the item has neither element nor character [children] and 
+    * cvc-elt (3.3.4) : 5.1
+    * If the declaration has a {value constraint},
+    * the item has neither element nor character [children] and
     * clause 3.2 has not applied, then all of the following must be true:
     */
     if ((inode->decl->value != NULL) &&
-        (inode->flags & XML_SCHEMA_ELEM_INFO_EMPTY) && 
+        (inode->flags & XML_SCHEMA_ELEM_INFO_EMPTY) &&
         (! INODE_NILLED(inode))) {
         /*
-        * cvc-elt (3.3.4) : 5.1.1 
-        * If the ·actual type definition· is a ·local type definition·
+        * cvc-elt (3.3.4) : 5.1.1
+        * If the �actual type definition� is a �local type definition�
         * then the canonical lexical representation of the {value constraint}
-        * value must be a valid default for the ·actual type definition· as 
-        * defined in Element Default Valid (Immediate) (§3.3.6). 
+        * value must be a valid default for the �actual type definition� as
+        * defined in Element Default Valid (Immediate) (�3.3.6).
         */
-        /* 
+        /*
         * NOTE: 'local' above means types acquired by xsi:type.
         * NOTE: Although the *canonical* value is stated, it is not
         * relevant if canonical or not. Additionally XML Schema 1.1
         * will removed this requirement as well.
         */
         if (inode->flags & XML_SCHEMA_ELEM_INFO_LOCAL_TYPE) {
 
             ret = xmlSchemaCheckCOSValidDefault(vctxt,
                 inode->decl->value, &(inode->val));
             if (ret != 0) {
                 if (ret < 0) {
                     VERROR_INT("xmlSchemaValidatorPopElem",
                         "calling xmlSchemaCheckCOSValidDefault()");
                     goto internal_error;
                 }
                 goto end_elem;
             }
             /*
             * Stop here, to avoid redundant validation of the value
             * (see following).
             */
             goto default_psvi;
-        }       
+        }
         /*
-        * cvc-elt (3.3.4) : 5.1.2 
-        * The element information item with the canonical lexical 
-        * representation of the {value constraint} value used as its 
-        * ·normalized value· must be ·valid· with respect to the 
-        * ·actual type definition· as defined by Element Locally Valid (Type)
-        * (§3.3.4).
-        */          
+        * cvc-elt (3.3.4) : 5.1.2
+        * The element information item with the canonical lexical
+        * representation of the {value constraint} value used as its
+        * �normalized value� must be �valid� with respect to the
+        * �actual type definition� as defined by Element Locally Valid (Type)
+        * (�3.3.4).
+        */
         if (WXS_IS_SIMPLE(inode->typeDef)) {
             ret = xmlSchemaVCheckINodeDataType(vctxt,
                 inode, inode->typeDef, inode->decl->value);
         } else if (WXS_HAS_SIMPLE_CONTENT(inode->typeDef)) {
             ret = xmlSchemaVCheckINodeDataType(vctxt,
                 inode, inode->typeDef->contentTypeDef,
-                inode->decl->value);        
+                inode->decl->value);
         }
         if (ret != 0) {
             if (ret < 0) {
                 VERROR_INT("xmlSchemaValidatorPopElem",
                     "calling xmlSchemaVCheckCVCSimpleType()");
                 goto internal_error;
             }
             goto end_elem;
         }
 
 default_psvi:
         /*
         * PSVI: Create a text node on the instance element.
         */
         if ((vctxt->options & XML_SCHEMA_VAL_VC_I_CREATE) &&
             (inode->node != NULL)) {
             xmlNodePtr textChild;
             xmlChar *normValue;
             /*
             * VAL TODO: Normalize the value.
-            */      
+            */
             normValue = xmlSchemaNormalizeValue(inode->typeDef,
                 inode->decl->value);
             if (normValue != NULL) {
                 textChild = xmlNewText(BAD_CAST normValue);
                 xmlFree(normValue);
             } else
                 textChild = xmlNewText(inode->decl->value);
             if (textChild == NULL) {
                 VERROR_INT("xmlSchemaValidatorPopElem",
                     "calling xmlNewText()");
                 goto internal_error;
             } else
-                xmlAddChild(inode->node, textChild);        
+                xmlAddChild(inode->node, textChild);
         }
-        
-    } else if (! INODE_NILLED(inode)) { 
+
+    } else if (! INODE_NILLED(inode)) {
         /*
-        * 5.2.1 The element information item must be ·valid· with respect 
-        * to the ·actual type definition· as defined by Element Locally 
-        * Valid (Type) (§3.3.4).
-        */      
+        * 5.2.1 The element information item must be �valid� with respect
+        * to the �actual type definition� as defined by Element Locally
+        * Valid (Type) (�3.3.4).
+        */
         if (WXS_IS_SIMPLE(inode->typeDef)) {
              /*
             * SPEC (cvc-type) (3.1)
             * "If the type definition is a simple type definition, ..."
             * (3.1.3) "If clause 3.2 of Element Locally Valid
-            * (Element) (§3.3.4) did not apply, then the ·normalized value·
-            * must be ·valid· with respect to the type definition as defined
-            * by String Valid (§3.14.4).
-            */      
+            * (Element) (�3.3.4) did not apply, then the �normalized value�
+            * must be �valid� with respect to the type definition as defined
+            * by String Valid (�3.14.4).
+            */
             ret = xmlSchemaVCheckINodeDataType(vctxt,
                     inode, inode->typeDef, inode->value);
         } else if (WXS_HAS_SIMPLE_CONTENT(inode->typeDef)) {
             /*
             * SPEC (cvc-type) (3.2) "If the type definition is a complex type
             * definition, then the element information item must be
-            * ·valid· with respect to the type definition as per
-            * Element Locally Valid (Complex Type) (§3.4.4);"
+            * �valid� with respect to the type definition as per
+            * Element Locally Valid (Complex Type) (�3.4.4);"
             *
             * SPEC (cvc-complex-type) (2.2)
-            * "If the {content type} is a simple type definition, ... 
-            * the ·normalized value· of the element information item is
-            * ·valid· with respect to that simple type definition as
-            * defined by String Valid (§3.14.4)."
+            * "If the {content type} is a simple type definition, ...
+            * the �normalized value� of the element information item is
+            * �valid� with respect to that simple type definition as
+            * defined by String Valid (�3.14.4)."
             */
             ret = xmlSchemaVCheckINodeDataType(vctxt,
                 inode, inode->typeDef->contentTypeDef, inode->value);
-        }       
+        }
         if (ret != 0) {
             if (ret < 0) {
                 VERROR_INT("xmlSchemaValidatorPopElem",
                     "calling xmlSchemaVCheckCVCSimpleType()");
                 goto internal_error;
             }
             goto end_elem;
         }
         /*
-        * 5.2.2 If there is a fixed {value constraint} and clause 3.2 has 
+        * 5.2.2 If there is a fixed {value constraint} and clause 3.2 has
         * not applied, all of the following must be true:
         */
         if ((inode->decl->value != NULL) &&
             (inode->decl->flags & XML_SCHEMAS_ELEM_FIXED)) {
 
             /*
             * TODO: We will need a computed value, when comparison is
             * done on computed values.
             */
             /*
-            * 5.2.2.1 The element information item must have no element 
+            * 5.2.2.1 The element information item must have no element
             * information item [children].
             */
             if (inode->flags &
                     XML_SCHEMA_ELEM_INFO_HAS_ELEM_CONTENT) {
                 ret = XML_SCHEMAV_CVC_ELT_5_2_2_1;
                 VERROR(ret, NULL,
                     "The content must not containt element nodes since "
                     "there is a fixed value constraint");
                 goto end_elem;
             } else {
                 /*
-                * 5.2.2.2 The appropriate case among the following must 
+                * 5.2.2.2 The appropriate case among the following must
                 * be true:
-                */              
+                */
                 if (WXS_HAS_MIXED_CONTENT(inode->typeDef)) {
                     /*
-                    * 5.2.2.2.1 If the {content type} of the ·actual type 
-                    * definition· is mixed, then the *initial value* of the 
-                    * item must match the canonical lexical representation 
+                    * 5.2.2.2.1 If the {content type} of the �actual type
+                    * definition� is mixed, then the *initial value* of the
+                    * item must match the canonical lexical representation
                     * of the {value constraint} value.
                     *
-                    * ... the *initial value* of an element information 
-                    * item is the string composed of, in order, the 
-                    * [character code] of each character information item in 
+                    * ... the *initial value* of an element information
+                    * item is the string composed of, in order, the
+                    * [character code] of each character information item in
                     * the [children] of that element information item.
-                    */             
+                    */
                     if (! xmlStrEqual(inode->value, inode->decl->value)){
-                        /* 
+                        /*
                         * VAL TODO: Report invalid & expected values as well.
                         * VAL TODO: Implement the canonical stuff.
                         */
                         ret = XML_SCHEMAV_CVC_ELT_5_2_2_2_1;
-                        xmlSchemaCustomErr(ACTXT_CAST vctxt, 
+                        xmlSchemaCustomErr(ACTXT_CAST vctxt,
                             ret, NULL, NULL,
                             "The initial value '%s' does not match the fixed "
                             "value constraint '%s'",
                             inode->value, inode->decl->value);
                         goto end_elem;
                     }
                 } else if (WXS_HAS_SIMPLE_CONTENT(inode->typeDef)) {
                     /*
-                    * 5.2.2.2.2 If the {content type} of the ·actual type 
-                    * definition· is a simple type definition, then the 
-                    * *actual value* of the item must match the canonical 
+                    * 5.2.2.2.2 If the {content type} of the �actual type
+                    * definition� is a simple type definition, then the
+                    * *actual value* of the item must match the canonical
                     * lexical representation of the {value constraint} value.
                     */
                     /*
                     * VAL TODO: *actual value* is the normalized value, impl.
                     *           this.
                     * VAL TODO: Report invalid & expected values as well.
                     * VAL TODO: Implement a comparison with the computed values.
                     */
                     if (! xmlStrEqual(inode->value,
                             inode->decl->value)) {
                         ret = XML_SCHEMAV_CVC_ELT_5_2_2_2_2;
                         xmlSchemaCustomErr(ACTXT_CAST vctxt,
                             ret, NULL, NULL,
                             "The actual value '%s' does not match the fixed "
-                            "value constraint '%s'", 
+                            "value constraint '%s'",
                             inode->value,
                             inode->decl->value);
                         goto end_elem;
-                    }               
+                    }
                 }
-            }       
+            }
         }
     }
-    
+
 end_elem:
     if (vctxt->depth < 0) {
         /* TODO: raise error? */
         return (0);
     }
     if (vctxt->depth == vctxt->skipDepth)
         vctxt->skipDepth = -1;
     /*
     * Evaluate the history of XPath state objects.
-    */    
+    */
     if (inode->appliedXPath &&
         (xmlSchemaXPathProcessHistory(vctxt, vctxt->depth) == -1))
         goto internal_error;
     /*
     * MAYBE TODO:
-    * SPEC (6) "The element information item must be ·valid· with
+    * SPEC (6) "The element information item must be �valid� with
     * respect to each of the {identity-constraint definitions} as per
-    * Identity-constraint Satisfied (§3.11.4)."
+    * Identity-constraint Satisfied (�3.11.4)."
     */
     /*
     * PSVI TODO: If we expose IDC node-tables via PSVI then the tables
     *   need to be built in any case.
     *   We will currently build IDC node-tables and bubble them only if
     *   keyrefs do exist.
     */
-    
+
     /*
     * Add the current IDC target-nodes to the IDC node-tables.
     */
     if ((inode->idcMatchers != NULL) &&
         (vctxt->hasKeyrefs || vctxt->createIDCNodeTables))
     {
         if (xmlSchemaIDCFillNodeTables(vctxt, inode) == -1)
             goto internal_error;
     }
     /*
@@ skipping 13 matching lines @@
             inode->idcTable);
 #endif
         if ((vctxt->depth > 0) &&
             (vctxt->hasKeyrefs || vctxt->createIDCNodeTables))
         {
             /*
             * Merge the IDC node table with the table of the parent node.
             */
             if (xmlSchemaBubbleIDCNodeTables(vctxt) == -1)
                 goto internal_error;
-        }       
+        }
     }
     /*
     * Clear the current ielem.
     * VAL TODO: Don't free the PSVI IDC tables if they are
     * requested for the PSVI.
     */
     xmlSchemaClearElemInfo(vctxt, inode);
     /*
     * Skip further processing if we are on the validation root.
     */
@@ skipping 12 matching lines @@
                 /*
                 * A 'keyrefDepth' of a key/unique IDC matches the current
                 * depth, this means that we are leaving the scope of the
                 * top-most keyref IDC which refers to this IDC.
                 */
                 aidc->keyrefDepth = -1;
             }
             aidc = aidc->next;
         } while (aidc != NULL);
     }
-    vctxt->depth--;        
+    vctxt->depth--;
     vctxt->inode = vctxt->elemInfos[vctxt->depth];
     /*
-    * VAL TODO: 7 If the element information item is the ·validation root·, it must be 
-    * ·valid· per Validation Root Valid (ID/IDREF) (§3.3.4).
+    * VAL TODO: 7 If the element information item is the �validation root�, it must be
+    * �valid� per Validation Root Valid (ID/IDREF) (�3.3.4).
     */
     return (ret);
 
 internal_error:
     vctxt->err = -1;
     return (-1);
 }
 
 /*
 * 3.4.4 Complex Type Definition Validation Rules
@@ skipping 60 matching lines @@
                             "process the attribute 'xsi:nil'");
                         return (-1);
                     }
                     return (ret);
                 }
             } else {
                  /*
                  * Fallback to "anyType".
                  *
                  * SPEC (cvc-assess-elt)
-                 * "If the item cannot be ·strictly assessed·, [...]
+                 * "If the item cannot be �strictly assessed�, [...]
                  * an element information item's schema validity may be laxly
-                 * assessed if its ·context-determined declaration· is not
-                 * skip by ·validating· with respect to the ·ur-type
-                 * definition· as per Element Locally Valid (Type) (§3.3.4)."
+                 * assessed if its �context-determined declaration� is not
+                 * skip by �validating� with respect to the �ur-type
+                 * definition� as per Element Locally Valid (Type) (�3.3.4)."
                 */
                 vctxt->inode->typeDef =
                     xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYTYPE);
             }
         }
         return (0);
     }
 
     switch (ptype->contentType) {
         case XML_SCHEMA_CONTENT_EMPTY:
@@ skipping 51 matching lines @@
 #ifdef DEBUG_AUTOMATA
                 xmlGenericError(xmlGenericErrorContext, "AUTOMATA create on '%s'\n",
                     pielem->localName);
 #endif
             }
 
             /*
             * SPEC (2.4) "If the {content type} is element-only or mixed,
             * then the sequence of the element information item's
             * element information item [children], if any, taken in
-            * order, is ·valid· with respect to the {content type}'s
+            * order, is �valid� with respect to the {content type}'s
             * particle, as defined in Element Sequence Locally Valid
-            * (Particle) (§3.9.4)."
+            * (Particle) (�3.9.4)."
             */
             ret = xmlRegExecPushString2(regexCtxt,
                 vctxt->inode->localName,
                 vctxt->inode->nsName,
                 vctxt->inode);
 #ifdef DEBUG_AUTOMATA
             if (ret < 0)
                 xmlGenericError(xmlGenericErrorContext,
                 "AUTOMATON push ERROR for '%s' on '%s'\n",
                 vctxt->inode->localName, pielem->localName);
@@ skipping 76 matching lines @@
     * OPTIMIZE: Maybe we could skip it, if:
     *   1. content type is simple
     *   2. whitespace is "collapse"
     *   3. it consists of whitespace only
     *
     * Process character content.
     */
     if (consumed != NULL)
         *consumed = 0;
     if (INODE_NILLED(vctxt->inode)) {
-        /* 
+        /*
         * SPEC cvc-elt (3.3.4 - 3.2.1)
         * "The element information item must have no character or
         * element information item [children]."
         */
         VERROR(XML_SCHEMAV_CVC_ELT_3_2_1, NULL,
             "Neither character nor element content is allowed "
             "because the element is 'nilled'");
         return (vctxt->err);
     }
     /*
     * SPEC (2.1) "If the {content type} is empty, then the
     * element information item has no character or element
     * information item [children]."
     */
     if (vctxt->inode->typeDef->contentType ==
-            XML_SCHEMA_CONTENT_EMPTY) {    
+            XML_SCHEMA_CONTENT_EMPTY) {
         VERROR(XML_SCHEMAV_CVC_COMPLEX_TYPE_2_1, NULL,
             "Character content is not allowed, "
             "because the content type is empty");
         return (vctxt->err);
     }
 
     if (vctxt->inode->typeDef->contentType ==
             XML_SCHEMA_CONTENT_ELEMENTS) {
         if ((nodeType != XML_TEXT_NODE) ||
             (! xmlSchemaIsBlank((xmlChar *) value, len))) {
-            /* 
-            * SPEC cvc-complex-type (2.3) 
-            * "If the {content type} is element-only, then the 
-            * element information item has no character information 
-            * item [children] other than those whose [character 
-            * code] is defined as a white space in [XML 1.0 (Second 
+            /*
+            * SPEC cvc-complex-type (2.3)
+            * "If the {content type} is element-only, then the
+            * element information item has no character information
+            * item [children] other than those whose [character
+            * code] is defined as a white space in [XML 1.0 (Second
             * Edition)]."
             */
             VERROR(XML_SCHEMAV_CVC_COMPLEX_TYPE_2_3, NULL,
                 "Character content other than whitespace is not allowed "
                 "because the content type is 'element-only'");
             return (vctxt->err);
         }
         return (0);
     }
-    
+
     if ((value == NULL) || (value[0] == 0))
         return (0);
     /*
     * Save the value.
     * NOTE that even if the content type is *mixed*, we need the
     * *initial value* for default/fixed value constraints.
     */
     if ((vctxt->inode->typeDef->contentType == XML_SCHEMA_CONTENT_MIXED) &&
         ((vctxt->inode->decl == NULL) ||
         (vctxt->inode->decl->value == NULL)))
         return (0);
-    
+
     if (vctxt->inode->value == NULL) {
         /*
         * Set the value.
         */
         switch (mode) {
             case XML_SCHEMA_PUSH_TEXT_PERSIST:
                 /*
                 * When working on a tree.
                 */
                 vctxt->inode->value = value;
@@ skipping 22 matching lines @@
                     XML_SCHEMA_NODE_INFO_FLAG_OWNED_VALUES;
                 break;
             default:
                 break;
         }
     } else {
         if (len < 0)
             len = xmlStrlen(value);
         /*
         * Concat the value.
-        */      
+        */
         if (vctxt->inode->flags & XML_SCHEMA_NODE_INFO_FLAG_OWNED_VALUES) {
             vctxt->inode->value = BAD_CAST xmlStrncat(
                 (xmlChar *) vctxt->inode->value, value, len);
         } else {
             vctxt->inode->value =
                 BAD_CAST xmlStrncatNew(vctxt->inode->value, value, len);
             vctxt->inode->flags |= XML_SCHEMA_NODE_INFO_FLAG_OWNED_VALUES;
         }
-    }   
+    }
 
     return (0);
 }
 
 static int
 xmlSchemaValidateElem(xmlSchemaValidCtxtPtr vctxt)
 {
     int ret = 0;
 
     if ((vctxt->skipDepth != -1) &&
         (vctxt->depth >= vctxt->skipDepth)) {
         VERROR_INT("xmlSchemaValidateElem",
             "in skip-state");
         goto internal_error;
     }
     if (vctxt->xsiAssemble) {
-        /* 
+        /*
         * We will stop validation if there was an error during
         * dynamic schema construction.
         * Note that we simply set @skipDepth to 0, this could
         * mean that a streaming document via SAX would be
         * still read to the end but it won't be validated any more.
         * TODO: If we are sure how to stop the validation at once
         *   for all input scenarios, then this should be changed to
         *   instantly stop the validation.
         */
         ret = xmlSchemaAssembleByXSI(vctxt);
@@ skipping 92 matching lines @@
     * Validate against the type definition.
     */
 type_validation:
 
     if (vctxt->inode->typeDef == NULL) {
         vctxt->inode->flags |= XML_SCHEMA_NODE_INFO_ERR_BAD_TYPE;
         ret = XML_SCHEMAV_CVC_TYPE_1;
         VERROR(ret, NULL,
             "The type definition is absent");
         goto exit;
-    }    
+    }
     if (vctxt->inode->typeDef->flags & XML_SCHEMAS_TYPE_ABSTRACT) {
         vctxt->inode->flags |= XML_SCHEMA_NODE_INFO_ERR_BAD_TYPE;
         ret = XML_SCHEMAV_CVC_TYPE_2;
             VERROR(ret, NULL,
-            "The type definition is abstract"); 
+            "The type definition is abstract");
         goto exit;
     }
     /*
     * Evaluate IDCs. Do it here, since new IDC matchers are registered
     * during validation against the declaration. This must be done
     * _before_ attribute validation.
     */
     if (vctxt->xpathStates != NULL) {
         ret = xmlSchemaXPathEvaluate(vctxt, XML_ELEMENT_NODE);
         vctxt->inode->appliedXPath = 1;
@@ skipping 60 matching lines @@
     }
     goto exit;
 
 root_found:
 
     do {
         depth = xmlTextReaderDepth(vctxt->reader);
         nodeType = xmlTextReaderNodeType(vctxt->reader);
 
         if (nodeType == XML_ELEMENT_NODE) {
-            
+
             vctxt->depth++;
             if (xmlSchemaValidatorPushElem(vctxt) == -1) {
                 VERROR_INT("xmlSchemaVReaderWalk",
                     "calling xmlSchemaValidatorPushElem()");
                 goto internal_error;
             }
             ielem = vctxt->inode;
             ielem->localName = xmlTextReaderLocalName(vctxt->reader);
             ielem->nsName = xmlTextReaderNamespaceUri(vctxt->reader);
             ielem->flags |= XML_SCHEMA_NODE_INFO_FLAG_OWNED_NAMES;
@@ skipping 154 matching lines @@
 /************************************************************************
  *                                                                      *
  *                      SAX validation handlers                         *
  *                                                                      *
  ************************************************************************/
 
 /*
 * Process text content.
 */
 static void
-xmlSchemaSAXHandleText(void *ctx, 
-                       const xmlChar * ch, 
+xmlSchemaSAXHandleText(void *ctx,
+                       const xmlChar * ch,
                        int len)
 {
     xmlSchemaValidCtxtPtr vctxt = (xmlSchemaValidCtxtPtr) ctx;
 
     if (vctxt->depth < 0)
         return;
     if ((vctxt->skipDepth != -1) && (vctxt->depth >= vctxt->skipDepth))
         return;
     if (vctxt->inode->flags & XML_SCHEMA_ELEM_INFO_EMPTY)
         vctxt->inode->flags ^= XML_SCHEMA_ELEM_INFO_EMPTY;
     if (xmlSchemaVPushText(vctxt, XML_TEXT_NODE, ch, len,
         XML_SCHEMA_PUSH_TEXT_VOLATILE, NULL) == -1) {
         VERROR_INT("xmlSchemaSAXHandleCDataSection",
             "calling xmlSchemaVPushText()");
         vctxt->err = -1;
         xmlStopParser(vctxt->parserCtxt);
     }
 }
 
 /*
 * Process CDATA content.
 */
 static void
-xmlSchemaSAXHandleCDataSection(void *ctx, 
-                             const xmlChar * ch, 
+xmlSchemaSAXHandleCDataSection(void *ctx,
+                             const xmlChar * ch,
                              int len)
-{   
+{
     xmlSchemaValidCtxtPtr vctxt = (xmlSchemaValidCtxtPtr) ctx;
 
     if (vctxt->depth < 0)
         return;
     if ((vctxt->skipDepth != -1) && (vctxt->depth >= vctxt->skipDepth))
         return;
     if (vctxt->inode->flags & XML_SCHEMA_ELEM_INFO_EMPTY)
         vctxt->inode->flags ^= XML_SCHEMA_ELEM_INFO_EMPTY;
     if (xmlSchemaVPushText(vctxt, XML_CDATA_SECTION_NODE, ch, len,
         XML_SCHEMA_PUSH_TEXT_VOLATILE, NULL) == -1) {
@@ skipping 13 matching lines @@
     if (vctxt->depth < 0)
         return;
     if ((vctxt->skipDepth != -1) && (vctxt->depth >= vctxt->skipDepth))
         return;
     /* SAX VAL TODO: What to do here? */
     TODO
 }
 
 static void
 xmlSchemaSAXHandleStartElementNs(void *ctx,
-                                 const xmlChar * localname, 
-                                 const xmlChar * prefix ATTRIBUTE_UNUSED, 
-                                 const xmlChar * URI, 
-                                 int nb_namespaces, 
-                                 const xmlChar ** namespaces, 
-                                 int nb_attributes, 
-                                 int nb_defaulted ATTRIBUTE_UNUSED, 
+                                 const xmlChar * localname,
+                                 const xmlChar * prefix ATTRIBUTE_UNUSED,
+                                 const xmlChar * URI,
+                                 int nb_namespaces,
+                                 const xmlChar ** namespaces,
+                                 int nb_attributes,
+                                 int nb_defaulted ATTRIBUTE_UNUSED,
                                  const xmlChar ** attributes)
-{  
+{
     xmlSchemaValidCtxtPtr vctxt = (xmlSchemaValidCtxtPtr) ctx;
     int ret;
     xmlSchemaNodeInfoPtr ielem;
     int i, j;
-    
+
     /*
     * SAX VAL TODO: What to do with nb_defaulted?
     */
     /*
     * Skip elements if inside a "skip" wildcard or invalid.
     */
     vctxt->depth++;
     if ((vctxt->skipDepth != -1) && (vctxt->depth >= vctxt->skipDepth))
         return;
     /*
     * Push the element.
     */
     if (xmlSchemaValidatorPushElem(vctxt) == -1) {
         VERROR_INT("xmlSchemaSAXHandleStartElementNs",
             "calling xmlSchemaValidatorPushElem()");
         goto internal_error;
     }
     ielem = vctxt->inode;
     /*
     * TODO: Is this OK?
     */
     ielem->nodeLine = xmlSAX2GetLineNumber(vctxt->parserCtxt);
     ielem->localName = localname;
     ielem->nsName = URI;
     ielem->flags |= XML_SCHEMA_ELEM_INFO_EMPTY;
     /*
     * Register namespaces on the elem info.
-    */    
+    */
     if (nb_namespaces != 0) {
         /*
         * Although the parser builds its own namespace list,
         * we have no access to it, so we'll use an own one.
         */
-        for (i = 0, j = 0; i < nb_namespaces; i++, j += 2) {        
+        for (i = 0, j = 0; i < nb_namespaces; i++, j += 2) {
             /*
             * Store prefix and namespace name.
-            */     
+            */
             if (ielem->nsBindings == NULL) {
                 ielem->nsBindings =
                     (const xmlChar **) xmlMalloc(10 *
                         sizeof(const xmlChar *));
                 if (ielem->nsBindings == NULL) {
                     xmlSchemaVErrMemory(vctxt,
                         "allocating namespace bindings for SAX validation",
                         NULL);
                     goto internal_error;
                 }
@@ skipping 15 matching lines @@
 
             ielem->nsBindings[ielem->nbNsBindings * 2] = namespaces[j];
             if (namespaces[j+1][0] == 0) {
                 /*
                 * Handle xmlns="".
                 */
                 ielem->nsBindings[ielem->nbNsBindings * 2 + 1] = NULL;
             } else
                 ielem->nsBindings[ielem->nbNsBindings * 2 + 1] =
                     namespaces[j+1];
-            ielem->nbNsBindings++;                  
+            ielem->nbNsBindings++;
         }
     }
     /*
     * Register attributes.
     * SAX VAL TODO: We are not adding namespace declaration
     * attributes yet.
     */
     if (nb_attributes != 0) {
         xmlChar *value;
 
         for (j = 0, i = 0; i < nb_attributes; i++, j += 5) {
             /*
             * Duplicate the value.
-            */   
+            */
             value = xmlStrndup(attributes[j+3],
                 attributes[j+4] - attributes[j+3]);
             /*
             * TODO: Set the node line.
             */
             ret = xmlSchemaValidatorPushAttribute(vctxt,
                 NULL, ielem->nodeLine, attributes[j], attributes[j+2], 0,
                 value, 1);
             if (ret == -1) {
                 VERROR_INT("xmlSchemaSAXHandleStartElementNs",
                     "calling xmlSchemaValidatorPushAttribute()");
                 goto internal_error;
             }
         }
     }
     /*
     * Validate the element.
     */
     ret = xmlSchemaValidateElem(vctxt);
     if (ret != 0) {
         if (ret == -1) {
             VERROR_INT("xmlSchemaSAXHandleStartElementNs",
                 "calling xmlSchemaValidateElem()");
             goto internal_error;
         }
         goto exit;
-    }    
+    }
 
 exit:
     return;
 internal_error:
     vctxt->err = -1;
     xmlStopParser(vctxt->parserCtxt);
     return;
 }
 
 static void
@@ skipping 89 matching lines @@
     * TODO: Should we clear the flags?
     *   Might be problematic if one reuses the context
     *   and assumes that the options remain the same.
     */
     vctxt->flags = 0;
     vctxt->validationRoot = NULL;
     vctxt->doc = NULL;
 #ifdef LIBXML_READER_ENABLED
     vctxt->reader = NULL;
 #endif
-    vctxt->hasKeyrefs = 0;    
+    vctxt->hasKeyrefs = 0;
 
     if (vctxt->value != NULL) {
         xmlSchemaFreeValue(vctxt->value);
         vctxt->value = NULL;
     }
     /*
     * Augmented IDC information.
     */
     if (vctxt->aidcs != NULL) {
         xmlSchemaIDCAugPtr cur = vctxt->aidcs, next;
@@ skipping 49 matching lines @@
     if (vctxt->elemInfos != NULL) {
         int i;
         xmlSchemaNodeInfoPtr ei;
 
         for (i = 0; i < vctxt->sizeElemInfos; i++) {
             ei = vctxt->elemInfos[i];
             if (ei == NULL)
                 break;
             xmlSchemaClearElemInfo(vctxt, ei);
         }
-    }    
+    }
     xmlSchemaItemListClear(vctxt->nodeQNames);
     /* Recreate the dict. */
     xmlDictFree(vctxt->dict);
     /*
     * TODO: Is is save to recreate it? Do we have a scenario
     * where the user provides the dict?
     */
     vctxt->dict = xmlDictCreate();
 }
 
@@ skipping 81 matching lines @@
     if (ctxt->dict != NULL)
         xmlDictFree(ctxt->dict);
     xmlFree(ctxt);
 }
 
 /**
  * xmlSchemaIsValid:
  * @ctxt: the schema validation context
  *
  * Check if any error was detected during validation.
- * 
+ *
  * Returns 1 if valid so far, 0 if errors were detected, and -1 in case
  *         of internal error.
  */
 int
 xmlSchemaIsValid(xmlSchemaValidCtxtPtr ctxt)
 {
     if (ctxt == NULL)
         return(-1);
     return(ctxt->err == 0);
 }
@@ skipping 38 matching lines @@
         ctxt->serror = serror;
     ctxt->error = NULL;
     ctxt->warning = NULL;
     ctxt->errCtxt = ctx;
     if (ctxt->pctxt != NULL)
         xmlSchemaSetParserStructuredErrors(ctxt->pctxt, serror, ctx);
 }
 
 /**
  * xmlSchemaGetValidErrors:
- * @ctxt:       a XML-Schema validation context
+ * @ctxt: a XML-Schema validation context
  * @err: the error function result
  * @warn: the warning function result
  * @ctx: the functions context result
  *
  * Get the error and warning callback informations
  *
  * Returns -1 in case of error and 0 otherwise
  */
 int
 xmlSchemaGetValidErrors(xmlSchemaValidCtxtPtr ctxt,
@@ skipping 40 matching lines @@
     for (i = 1; i < (int) sizeof(int) * 8; i++) {
         if (options & 1<<i)
             return (-1);
     }
     ctxt->options = options;
     return (0);
 }
 
 /**
  * xmlSchemaValidCtxtGetOptions:
- * @ctxt:       a schema validation context
+ * @ctxt: a schema validation context
  *
  * Get the validation context options.
  *
  * Returns the option combination or -1 on error.
  */
 int
 xmlSchemaValidCtxtGetOptions(xmlSchemaValidCtxtPtr ctxt)
 
 {
     if (ctxt == NULL)
@@ skipping 47 matching lines @@
             vctxt->nbAttrInfos = 0;
             if (node->properties != NULL) {
                 attr = node->properties;
                 do {
                     if (attr->ns != NULL)
                         nsName = attr->ns->href;
                     else
                         nsName = NULL;
                     ret = xmlSchemaValidatorPushAttribute(vctxt,
                         (xmlNodePtr) attr,
-                        /* 
+                        /*
                         * Note that we give it the line number of the
                         * parent element.
                         */
                         ielem->nodeLine,
                         attr->name, nsName, 0,
                         xmlNodeListGetString(attr->doc, attr->children, 1), 1);
                     if (ret == -1) {
                         VERROR_INT("xmlSchemaDocWalk",
                             "calling xmlSchemaValidatorPushAttribute()");
                         goto internal_error;
@@ skipping 35 matching lines @@
                 goto internal_error;
             }
             /*
             * DOC VAL TODO: Should we skip further validation of the
             * element content here?
             */
         } else if ((node->type == XML_ENTITY_NODE) ||
             (node->type == XML_ENTITY_REF_NODE)) {
             /*
             * DOC VAL TODO: What to do with entities?
-            */      
+            */
             VERROR_INT("xmlSchemaVDocWalk",
                 "there is at least one entity reference in the node-tree "
                 "currently being validated. Processing of entities with "
                 "this XML Schema processor is not supported (yet). Please "
                 "substitute entities before validation.");
             goto internal_error;
         } else {
             goto leave_node;
             /*
             * DOC VAL TODO: XInclude nodes, etc.
@@ skipping 39 matching lines @@
 exit:
     return (ret);
 internal_error:
     return (-1);
 }
 
 static int
 xmlSchemaPreRun(xmlSchemaValidCtxtPtr vctxt) {
     /*
     * Some initialization.
-    */    
+    */
     vctxt->err = 0;
     vctxt->nberrors = 0;
     vctxt->depth = -1;
     vctxt->skipDepth = -1;
     vctxt->xsiAssemble = 0;
     vctxt->hasKeyrefs = 0;
 #ifdef ENABLE_IDC_NODE_TABLES_TEST
     vctxt->createIDCNodeTables = 1;
 #else
     vctxt->createIDCNodeTables = 0;
 #endif
     /*
     * Create a schema + parser if necessary.
     */
     if (vctxt->schema == NULL) {
         xmlSchemaParserCtxtPtr pctxt;
-        
+
         vctxt->xsiAssemble = 1;
-        /* 
+        /*
         * If not schema was given then we will create a schema
         * dynamically using XSI schema locations.
         *
         * Create the schema parser context.
         */
         if ((vctxt->pctxt == NULL) &&
            (xmlSchemaCreatePCtxtOnVCtxt(vctxt) == -1))
            return (-1);
         pctxt = vctxt->pctxt;
         pctxt->xsiAssemble = 1;
         /*
         * Create the schema.
         */
         vctxt->schema = xmlSchemaNewSchema(pctxt);
         if (vctxt->schema == NULL)
-            return (-1);                
-        /* 
+            return (-1);
+        /*
         * Create the schema construction context.
         */
         pctxt->constructor = xmlSchemaConstructionCtxtCreate(pctxt->dict);
         if (pctxt->constructor == NULL)
             return(-1);
         pctxt->constructor->mainSchema = vctxt->schema;
         /*
         * Take ownership of the constructor to be able to free it.
         */
         pctxt->ownsConstructor = 1;
-    }   
-    /* 
-    * Augment the IDC definitions for the main schema and all imported ones 
+    }
+    /*
+    * Augment the IDC definitions for the main schema and all imported ones
     * NOTE: main schema if the first in the imported list
     */
     xmlHashScan(vctxt->schema->schemasImports,(xmlHashScanner)xmlSchemaAugmentImportedIDC, vctxt);
-    
+
     return(0);
 }
 
 static void
 xmlSchemaPostRun(xmlSchemaValidCtxtPtr vctxt) {
     if (vctxt->xsiAssemble) {
         if (vctxt->schema != NULL) {
             xmlSchemaFree(vctxt->schema);
             vctxt->schema = NULL;
         }
@@ skipping 394 matching lines @@
     if (ctxt == NULL)
         return;
     if ((ctxt != NULL) && (ctxt->user_sax != NULL) &&
         (ctxt->user_sax->reference != NULL))
         ctxt->user_sax->reference(ctxt->user_data, name);
     if (ctxt->ctxt != NULL)
         xmlSchemaSAXHandleReference(ctxt->user_data, name);
 }
 
 static void
-startElementNsSplit(void *ctx, const xmlChar * localname, 
-                    const xmlChar * prefix, const xmlChar * URI, 
-                    int nb_namespaces, const xmlChar ** namespaces, 
-                    int nb_attributes, int nb_defaulted, 
+startElementNsSplit(void *ctx, const xmlChar * localname,
+                    const xmlChar * prefix, const xmlChar * URI,
+                    int nb_namespaces, const xmlChar ** namespaces,
+                    int nb_attributes, int nb_defaulted,
                     const xmlChar ** attributes) {
     xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
     if (ctxt == NULL)
         return;
     if ((ctxt->user_sax != NULL) &&
         (ctxt->user_sax->startElementNs != NULL))
         ctxt->user_sax->startElementNs(ctxt->user_data, localname, prefix,
                                        URI, nb_namespaces, namespaces,
                                        nb_attributes, nb_defaulted,
                                        attributes);
     if (ctxt->ctxt != NULL)
         xmlSchemaSAXHandleStartElementNs(ctxt->ctxt, localname, prefix,
                                          URI, nb_namespaces, namespaces,
                                          nb_attributes, nb_defaulted,
                                          attributes);
 }
 
 static void
-endElementNsSplit(void *ctx, const xmlChar * localname, 
+endElementNsSplit(void *ctx, const xmlChar * localname,
                     const xmlChar * prefix, const xmlChar * URI) {
     xmlSchemaSAXPlugPtr ctxt = (xmlSchemaSAXPlugPtr) ctx;
     if (ctxt == NULL)
         return;
     if ((ctxt->user_sax != NULL) &&
         (ctxt->user_sax->endElementNs != NULL))
         ctxt->user_sax->endElementNs(ctxt->user_data, localname, prefix, URI);
     if (ctxt->ctxt != NULL)
         xmlSchemaSAXHandleEndElementNs(ctxt->ctxt, localname, prefix, URI);
 }
@@ skipping 20 matching lines @@
 
     if ((ctxt == NULL) || (sax == NULL) || (user_data == NULL))
         return(NULL);
 
     /*
      * We only allow to plug into SAX2 event streams
      */
     old_sax = *sax;
     if ((old_sax != NULL) && (old_sax->initialized != XML_SAX2_MAGIC))
         return(NULL);
-    if ((old_sax != NULL) && 
+    if ((old_sax != NULL) &&
         (old_sax->startElementNs == NULL) && (old_sax->endElementNs == NULL) &&
         ((old_sax->startElement != NULL) || (old_sax->endElement != NULL)))
         return(NULL);
 
     /*
      * everything seems right allocate the local data needed for that layer
      */
     ret = (xmlSchemaSAXPlugPtr) xmlMalloc(sizeof(xmlSchemaSAXPlugStruct));
     if (ret == NULL) {
         return(NULL);
     }
     memset(ret, 0, sizeof(xmlSchemaSAXPlugStruct));
     ret->magic = XML_SAX_PLUG_MAGIC;
     ret->schemas_sax.initialized = XML_SAX2_MAGIC;
     ret->ctxt = ctxt;
     ret->user_sax_ptr = sax;
     ret->user_sax = old_sax;
-    if (old_sax == NULL) {      
+    if (old_sax == NULL) {
         /*
          * go direct, no need for the split block and functions.
          */
         ret->schemas_sax.startElementNs = xmlSchemaSAXHandleStartElementNs;
         ret->schemas_sax.endElementNs = xmlSchemaSAXHandleEndElementNs;
         /*
          * Note that we use the same text-function for both, to prevent
          * the parser from testing for ignorable whitespace.
          */
         ret->schemas_sax.ignorableWhitespace = xmlSchemaSAXHandleText;
         ret->schemas_sax.characters = xmlSchemaSAXHandleText;
 
         ret->schemas_sax.cdataBlock = xmlSchemaSAXHandleCDataSection;
         ret->schemas_sax.reference = xmlSchemaSAXHandleReference;
 
         ret->user_data = ctxt;
         *user_data = ctxt;
     } else {
        /*
         * for each callback unused by Schemas initialize it to the Split
-        * routine only if non NULL in the user block, this can speed up 
+        * routine only if non NULL in the user block, this can speed up
         * things at the SAX level.
         */
         if (old_sax->internalSubset != NULL)
             ret->schemas_sax.internalSubset = internalSubsetSplit;
         if (old_sax->isStandalone != NULL)
             ret->schemas_sax.isStandalone = isStandaloneSplit;
         if (old_sax->hasInternalSubset != NULL)
             ret->schemas_sax.hasInternalSubset = hasInternalSubsetSplit;
         if (old_sax->hasExternalSubset != NULL)
             ret->schemas_sax.hasExternalSubset = hasExternalSubsetSplit;
@@ skipping 132 matching lines @@
     pctxt = xmlNewParserCtxt();
     if (pctxt == NULL)
         return (-1);
     old_sax = pctxt->sax;
     pctxt->sax = sax;
     pctxt->userData = user_data;
 #if 0
     if (options)
         xmlCtxtUseOptions(pctxt, options);
 #endif
-    pctxt->linenumbers = 1;    
+    pctxt->linenumbers = 1;
 
     inputStream = xmlNewIOInputStream(pctxt, input, enc);;
     if (inputStream == NULL) {
         ret = -1;
         goto done;
     }
     inputPush(pctxt, inputStream);
     ctxt->parserCtxt = pctxt;
     ctxt->input = input;
 
     /*
      * Plug the validation and launch the parsing
      */
     plug = xmlSchemaSAXPlug(ctxt, &(pctxt->sax), &(pctxt->userData));
     if (plug == NULL) {
         ret = -1;
         goto done;
     }
     ctxt->input = input;
     ctxt->enc = enc;
     ctxt->sax = pctxt->sax;
     ctxt->flags |= XML_SCHEMA_VALID_CTXT_FLAG_STREAM;
     ret = xmlSchemaVStart(ctxt);
 
     if ((ret == 0) && (! ctxt->parserCtxt->wellFormed)) {
         ret = ctxt->parserCtxt->errNo;
         if (ret == 0)
             ret = 1;
-    }    
+    }
 
 done:
     ctxt->parserCtxt = NULL;
     ctxt->sax = NULL;
     ctxt->input = NULL;
     if (plug != NULL) {
         xmlSchemaSAXUnplug(plug);
     }
     /* cleanup */
     if (pctxt != NULL) {
@@ skipping 18 matching lines @@
 int
 xmlSchemaValidateFile(xmlSchemaValidCtxtPtr ctxt,
                       const char * filename,
                       int options ATTRIBUTE_UNUSED)
 {
     int ret;
     xmlParserInputBufferPtr input;
 
     if ((ctxt == NULL) || (filename == NULL))
         return (-1);
-    
+
     input = xmlParserInputBufferCreateFilename(filename,
         XML_CHAR_ENCODING_NONE);
     if (input == NULL)
         return (-1);
     ret = xmlSchemaValidateStream(ctxt, input, XML_CHAR_ENCODING_NONE,
-        NULL, NULL);    
+        NULL, NULL);
     return (ret);
 }
 
+/**
+ * xmlSchemaValidCtxtGetParserCtxt:
+ * @ctxt: a schema validation context
+ *
+ * allow access to the parser context of the schema validation context
+ *
+ * Returns the parser context of the schema validation context or NULL
+ *         in case of error.
+ */
+xmlParserCtxtPtr
+xmlSchemaValidCtxtGetParserCtxt(xmlSchemaValidCtxtPtr ctxt)
+{
+    if (ctxt == NULL)
+        return(NULL);
+    return (ctxt->parserCtxt);
+}
+
 #define bottom_xmlschemas
 #include "elfgcchack.h"
 #endif /* LIBXML_SCHEMAS_ENABLED */