Upgrade to libxml 2.9.2 and libxslt 1.1.28

third_party/libxml/src/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 89 matching lines @@
 
 /* #define ENABLE_IDC_NODE_TABLES_TEST */
 
 #define DUMP_CONTENT_MODEL
 
 #ifdef LIBXML_READER_ENABLED
 /* #define XML_SCHEMA_READER_ENABLED */
 #endif
 
 #define UNBOUNDED (1 << 30)
-#define TODO                                                            \
+#define TODO                                                            \
     xmlGenericError(xmlGenericErrorContext,                             \
             "Unimplemented block at %s:%d\n",                           \
             __FILE__, __LINE__);
 
 #define XML_SCHEMAS_NO_NAMESPACE (const xmlChar *) "##"
 
 /*
  * The XML Schemas namespaces
  */
 static const xmlChar *xmlSchemaNs = (const xmlChar *)
@@ skipping 847 matching lines @@
     xmlSchemaValidityWarningFunc warning; /* the callback in case of warning */
     xmlStructuredErrorFunc serror;
 
     xmlSchemaPtr schema;        /* The schema in use */
     xmlDocPtr doc;
     xmlParserInputBufferPtr input;
     xmlCharEncoding enc;
     xmlSAXHandlerPtr sax;
     xmlParserCtxtPtr parserCtxt;
     void *user_data; /* TODO: What is this for? */
+    char *filename;
 
     int err;
     int nberrors;
 
     xmlNodePtr node;
     xmlNodePtr cur;
     /* xmlSchemaTypePtr type; */
 
     xmlRegExecCtxtPtr regexp;
     xmlSchemaValPtr value;
@@ skipping 33 matching lines @@
 
     xmlSchemaAttrInfoPtr *attrInfos;
     int nbAttrInfos;
     int sizeAttrInfos;
 
     int skipDepth;
     xmlSchemaItemListPtr nodeQNames;
     int hasKeyrefs;
     int createIDCNodeTables;
     int psviExposeIDCNodeTables;
+
+    /* Locator for error reporting in streaming mode */
+    xmlSchemaValidityLocatorFunc locFunc;
+    void *locCtxt;
 };
 
 /**
  * xmlSchemaSubstGroup:
  *
  *
  */
 typedef struct _xmlSchemaSubstGroup xmlSchemaSubstGroup;
 typedef xmlSchemaSubstGroup *xmlSchemaSubstGroupPtr;
 struct _xmlSchemaSubstGroup {
     xmlSchemaElementPtr head;
     xmlSchemaItemListPtr members;
 };
 
 /************************************************************************
- *                                                                      *
- *                      Some predeclarations                            *
- *                                                                      *
+ *                                                                      *
+ *                      Some predeclarations                            *
+ *                                                                      *
  ************************************************************************/
 
 static int xmlSchemaParseInclude(xmlSchemaParserCtxtPtr ctxt,
                                  xmlSchemaPtr schema,
                                  xmlNodePtr node);
 static int xmlSchemaParseRedefine(xmlSchemaParserCtxtPtr ctxt,
                                  xmlSchemaPtr schema,
                                  xmlNodePtr node);
 static int
 xmlSchemaTypeFixup(xmlSchemaTypePtr type,
@@ skipping 32 matching lines @@
                                    xmlSchemaParserCtxtPtr ctxt);
 static void
 xmlSchemaComponentListFree(xmlSchemaItemListPtr list);
 static xmlSchemaQNameRefPtr
 xmlSchemaParseAttributeGroupRef(xmlSchemaParserCtxtPtr pctxt,
                                 xmlSchemaPtr schema,
                                 xmlNodePtr node);
 
 /************************************************************************
  *                                                                      *
- *                      Helper functions                                *
+ *                      Helper functions                                *
  *                                                                      *
  ************************************************************************/
 
 /**
  * xmlSchemaItemTypeToStr:
  * @type: the type of the schema item
  *
  * Returns the component name of a schema item.
  */
 static const xmlChar *
@@ skipping 347 matching lines @@
             return (BAD_CAST "invalid process contents");
     }
 }
 
 /**
  * xmlSchemaGetCanonValueWhtspExt:
  * @val: the precomputed value
  * @retValue: the returned value
  * @ws: the whitespace type of the value
  *
- * Get a the cononical representation of the value.
+ * Get a the canonical representation of the value.
  * The caller has to free the returned retValue.
  *
  * Returns 0 if the value could be built and -1 in case of
  *         API errors or if the value type is not supported yet.
  */
 static int
 xmlSchemaGetCanonValueWhtspExt(xmlSchemaValPtr val,
                                xmlSchemaWhitespaceValueType ws,
                                xmlChar **retValue)
 {
@@ skipping 349 matching lines @@
         if (found)
             break;
         type = type->baseType;
     } while ((type != NULL) && (type->type != XML_SCHEMA_TYPE_BASIC));
 
     return ((const xmlChar *) *buf);
 }
 
 /************************************************************************
  *                                                                      *
- *                      Error functions                                 *
+ *                      Error functions                                 *
  *                                                                      *
  ************************************************************************/
 
 #if 0
 static void
 xmlSchemaErrMemory(const char *msg)
 {
     __xmlSimpleError(XML_FROM_SCHEMASP, XML_ERR_NO_MEMORY, NULL, NULL,
                      msg);
 }
@@ skipping 117 matching lines @@
     }
     __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,
                     str3, str4, str5);
 }
 
 /************************************************************************
  *                                                                      *
- *                      Allround error functions                        *
+ *                      Allround error functions                        *
  *                                                                      *
  ************************************************************************/
 
 /**
  * xmlSchemaVTypeErrMemory:
  * @node: a context node
  * @extra:  extra informations
  *
  * Handle an out of memory condition
  */
@@ skipping 39 matching lines @@
                   const xmlChar *str3, const xmlChar *str4)
 {
     xmlStructuredErrorFunc schannel = NULL;
     xmlGenericErrorFunc channel = NULL;
     void *data = NULL;
 
     if (ctxt != NULL) {
         if (ctxt->type == XML_SCHEMA_CTXT_VALIDATOR) {
             xmlSchemaValidCtxtPtr vctxt = (xmlSchemaValidCtxtPtr) ctxt;
             const char *file = NULL;
+            int col = 0;
             if (errorLevel != XML_ERR_WARNING) {
                 vctxt->nberrors++;
                 vctxt->err = 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.
             */
             if (line == 0) {
                 if ((node == NULL) &&
                     (vctxt->depth >= 0) &&
                     (vctxt->inode != NULL)) {
                     node = vctxt->inode->node;
                 }
                 /*
                 * Get filename and line if no node-tree.
                 */
                 if ((node == NULL) &&
                     (vctxt->parserCtxt != NULL) &&
                     (vctxt->parserCtxt->input != NULL)) {
                     file = vctxt->parserCtxt->input->filename;
                     line = vctxt->parserCtxt->input->line;
+                    col = vctxt->parserCtxt->input->col;
                 }
             } else {
                 /*
                 * Override the given node's (if any) position
                 * and channel only the given line number.
                 */
                 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;
             }
+            if (vctxt->locFunc != NULL) {
+                if ((file == NULL) || (line == 0)) {
+                    unsigned long l;
+                    const char *f;
+                    vctxt->locFunc(vctxt->locCtxt, &f, &l);
+                    if (file == NULL)
+                        file = f;
+                    if (line == 0)
+                        line = (int) l;
+                }
+            }
+            if ((file == NULL) && (vctxt->filename != NULL))
+                file = vctxt->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);
+                (const char *) str3, 0, col, 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;
             } else {
                 channel = pctxt->warning;
             }
@@ skipping 1096 matching lines @@
         } else {
             xmlSchemaPErr2(ctxt, ownerElem, child, error,
                 "%s: The content is not valid.\n",
                 BAD_CAST des, NULL);
         }
     }
     FREE_AND_NULL(des)
 }
 
 /************************************************************************
- *                                                                      *
- *                      Streamable error functions                      *
- *                                                                      *
+ *                                                                      *
+ *                      Streamable error functions                      *
+ *                                                                      *
  ************************************************************************/
 
 
 
 
 /************************************************************************
- *                                                                      *
- *                      Validation helper functions                     *
- *                                                                      *
+ *                                                                      *
+ *                      Validation helper functions                     *
+ *                                                                      *
  ************************************************************************/
 
 
 /************************************************************************
- *                                                                      *
- *                      Allocation functions                            *
- *                                                                      *
+ *                                                                      *
+ *                      Allocation functions                            *
+ *                                                                      *
  ************************************************************************/
 
 /**
  * xmlSchemaNewSchemaForParserCtxt:
  * @ctxt:  a schema validation context
  *
  * Allocate a new Schema structure.
  *
  * Returns the newly allocated structure or NULL in case or error
  */
@@ skipping 897 matching lines @@
     }
     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);
 }
 
 /************************************************************************
- *                                                                      *
- *                      Debug functions                                 *
- *                                                                      *
+ *                                                                      *
+ *                      Debug functions                                 *
+ *                                                                      *
  ************************************************************************/
 
 #ifdef LIBXML_OUTPUT_ENABLED
 
 static void
 xmlSchemaTypeDump(xmlSchemaTypePtr type, FILE * output); /* forward */
 
 /**
  * xmlSchemaElementDump:
  * @elem:  an element
@@ skipping 429 matching lines @@
             }
         }
         bind = bind->next;
     } while (bind != NULL);
 }
 #endif /* DEBUG_IDC */
 #endif /* LIBXML_OUTPUT_ENABLED */
 
 /************************************************************************
  *                                                                      *
- *                      Utilities                                       *
+ *                      Utilities                                       *
  *                                                                      *
  ************************************************************************/
 
 /**
  * xmlSchemaGetPropNode:
  * @node: the element node
  * @name: the name of the attribute
  *
  * Seeks an attribute with a name of @name in
  * no namespace.
@@ skipping 84 matching lines @@
 
     val = xmlGetNoNsProp(node, BAD_CAST name);
     if (val == NULL)
         return(NULL);
     ret = xmlDictLookup(ctxt->dict, val, -1);
     xmlFree(val);
     return(ret);
 }
 
 /************************************************************************
- *                                                                      *
- *                      Parsing functions                               *
- *                                                                      *
+ *                                                                      *
+ *                      Parsing functions                               *
+ *                                                                      *
  ************************************************************************/
 
 #define WXS_FIND_GLOBAL_ITEM(slot)                      \
     if (xmlStrEqual(nsName, schema->targetNamespace)) { \
         ret = xmlHashLookup(schema->slot, name); \
         if (ret != NULL) goto exit; \
     } \
     if (xmlHashSize(schema->schemasImports) > 1) { \
         xmlSchemaImportPtr import; \
         if (nsName == NULL) \
@@ skipping 251 matching lines @@
         case XML_SCHEMA_TYPE_ELEMENT:
             return ((xmlSchemaBasicItemPtr) xmlSchemaGetElem(schema,
                 name, targetNs));
         default:
             TODO
             return (NULL);
     }
 }
 
 /************************************************************************
- *                                                                      *
- *                      Parsing functions                               *
- *                                                                      *
+ *                                                                      *
+ *                      Parsing functions                               *
+ *                                                                      *
  ************************************************************************/
 
 #define IS_BLANK_NODE(n)                                                \
     (((n)->type == XML_TEXT_NODE) && (xmlSchemaIsBlank((n)->content, -1)))
 
 /**
  * xmlSchemaIsBlank:
  * @str:  a string
  * @len: the length of the string or -1
  *
@@ skipping 754 matching lines @@
     if (substGroup == NULL)
         substGroup = xmlSchemaSubstGroupAdd(pctxt, head);
     if (substGroup == NULL)
         return(-1);
     if (xmlSchemaItemListAdd(substGroup->members, member) == -1)
         return(-1);
     return(0);
 }
 
 /************************************************************************
- *                                                                      *
+ *                                                                      *
  *              Utilities for parsing                                   *
- *                                                                      *
+ *                                                                      *
  ************************************************************************/
 
 /**
  * xmlSchemaPValAttrNodeQNameValue:
  * @ctxt:  a schema parser context
  * @schema: the schema context
  * @ownerDes: the designation of the parent element
  * @ownerItem: the parent as a schema object
  * @value:  the QName value
  * @local: the resulting local part if found, the attribute value otherwise
@@ skipping 173 matching lines @@
 
             /*
             * TODO: Use xmlSchemaStrip here; it's not exported at this
             * moment.
             */
             strip = xmlSchemaCollapseString(value);
             if (strip != NULL) {
                 xmlFree((xmlChar *) value);
                 value = strip;
             }
-            res = xmlAddID(NULL, attr->doc, value, attr);
+            res = xmlAddID(NULL, attr->doc, value, attr);
             if (res == NULL) {
                 ret = XML_SCHEMAP_S4S_ATTR_INVALID_VALUE;
                 xmlSchemaPSimpleTypeErr(ctxt,
                     XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
                     NULL, (xmlNodePtr) attr,
                     xmlSchemaGetBuiltInType(XML_SCHEMAS_ID),
                     NULL, NULL, "Duplicate value '%s' of simple "
                     "type 'xs:ID'", value, NULL);
             } else
                 attr->atype = XML_ATTRIBUTE_ID;
@@ skipping 160 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;
     else {
         xmlSchemaPSimpleTypeErr(ctxt,
             XML_SCHEMAP_INVALID_BOOLEAN,
             NULL,
             (xmlNodePtr) xmlSchemaGetPropNode(node, name),
             xmlSchemaGetBuiltInType(XML_SCHEMAS_BOOLEAN),
             NULL, val, NULL, NULL, NULL);
     }
     return (def);
 }
 
 /************************************************************************
- *                                                                      *
+ *                                                                      *
  *              Shema extraction from an Infoset                        *
- *                                                                      *
+ *                                                                      *
  ************************************************************************/
 static xmlSchemaTypePtr xmlSchemaParseSimpleType(xmlSchemaParserCtxtPtr
                                                  ctxt, xmlSchemaPtr schema,
                                                  xmlNodePtr node,
                                                  int topLevel);
 static xmlSchemaTypePtr xmlSchemaParseComplexType(xmlSchemaParserCtxtPtr
                                                   ctxt,
                                                   xmlSchemaPtr schema,
                                                   xmlNodePtr node,
                                                   int topLevel);
@@ skipping 1484 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",
@@ skipping 507 matching lines @@
             "allocating a 'selector' of an identity-constraint definition",
             NULL);
         return (NULL);
     }
     memset(item, 0, sizeof(xmlSchemaIDCSelect));
     /*
     * Attribute "xpath" (mandatory).
     */
     attr = xmlSchemaGetPropNode(node, "xpath");
     if (attr == NULL) {
-        xmlSchemaPMissingAttrErr(ctxt,
+        xmlSchemaPMissingAttrErr(ctxt,
             XML_SCHEMAP_S4S_ATTR_MISSING,
             NULL, node,
             "name", NULL);
     } else {
         item->xpath = xmlSchemaGetNodeContent(ctxt, (xmlNodePtr) attr);
         /*
         * URGENT TODO: "field"s have an other syntax than "selector"s.
         */
 
         if (xmlSchemaCheckCSelectorXPath(ctxt, idc, item, attr,
@@ skipping 600 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 114 matching lines @@
         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);
@@ skipping 1063 matching lines @@
                     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,
@@ skipping 332 matching lines @@
         return (pctxt->err);
     }
 
     if (xmlSchemaPValAttr(pctxt, NULL, node,
         "schemaLocation", xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYURI),
         &schemaLocation) != 0) {
         xmlSchemaPSimpleTypeErr(pctxt,
             XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
             NULL, node,
             xmlSchemaGetBuiltInType(XML_SCHEMAS_ANYURI),
-            NULL, namespaceName, NULL, NULL, NULL);
+            NULL, schemaLocation, NULL, NULL, NULL);
         return (pctxt->err);
     }
     /*
     * And now for the children...
     */
     child = node->children;
     if (IS_SCHEMA(child, "annotation")) {
         /*
          * the annotation here is simply discarded ...
          * TODO: really?
@@ skipping 10 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 180 matching lines @@
     * 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) {
             /*
             * 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;
@@ skipping 327 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),
@@ skipping 93 matching lines @@
     xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
     /*
     * 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);
@@ skipping 740 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 48 matching lines @@
         xmlSchemaPCustomErr(ctxt, XML_SCHEMAP_SRC_REDEFINE,
             NULL, node, "This is a redefinition, thus the "
             "<complexType> must have a <restriction> or <extension> "
             "grand-child", NULL);
     }
     ctxt->ctxtType = ctxtType;
     return (type);
 }
 
 /************************************************************************
- *                                                                      *
- *                      Validating using Schemas                        *
- *                                                                      *
+ *                                                                      *
+ *                      Validating using Schemas                        *
+ *                                                                      *
  ************************************************************************/
 
 /************************************************************************
- *                                                                      *
- *                      Reading/Writing Schemas                         *
- *                                                                      *
+ *                                                                      *
+ *                      Reading/Writing Schemas                         *
+ *                                                                      *
  ************************************************************************/
 
 #if 0 /* Will be enabled if it is clear what options are needed. */
 /**
  * xmlSchemaParserCtxtSetOptions:
  * @ctxt:       a schema parser context
  * @options: a combination of xmlSchemaParserOption
  *
  * Sets the options to be used during the parse.
  *
@@ skipping 556 matching lines @@
                         ret = 1;
                     }
                 } else {
                     sub = particle->children->children;
                     while (sub != NULL) {
                         tmp2 = xmlSchemaBuildAContentModel(pctxt,
                                         (xmlSchemaParticlePtr) sub);
                         if (tmp2 != 1) ret = 0;
                         sub = sub->next;
                     }
+
+                    /*
+                     * 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);
                         ret = 1;
                     }
                 }
             }
             break;
         }
         case XML_SCHEMA_TYPE_CHOICE:{
@@ skipping 225 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 274 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 == super->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);
         }
     }
@@ skipping 141 matching lines @@
                     } 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;
 
@@ skipping 13 matching lines @@
                         }
                     }
                     break;
                 }
             }
 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,
@@ skipping 77 matching lines @@
             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 165 matching lines @@
         * 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 (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;
             } 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);
 }
 
@@ skipping 228 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 291 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))) {
+    if ((WXS_IS_LIST(type) || WXS_IS_UNION(type)) &&
+        (WXS_IS_RESTRICTION(type) == 0) &&
+        ((! WXS_IS_ANY_SIMPLE_TYPE(baseType)) &&
+         (baseType->type != XML_SCHEMA_TYPE_SIMPLE))) {
         xmlSchemaPCustomErr(ctxt,
             XML_SCHEMAP_ST_PROPS_CORRECT_1,
             WXS_BASIC_CAST type, NULL,
             "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);
     }
     /*
@@ skipping 18 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 86 matching lines @@
  * 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>.
         */
         /*
         *
@@ skipping 77 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,
             "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
-    * definition by repeatedly following the {base type definition}."
+    * 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 &&
@@ skipping 131 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 119 matching lines @@
                         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;
 
@@ skipping 76 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 96 matching lines @@
         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;
 
@@ skipping 10 matching lines @@
                         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);
@@ skipping 12 matching lines @@
             */
             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 85 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 57 matching lines @@
 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
 
@@ skipping 19 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 603 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 113 matching lines @@
                     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 &&
                 anc->builtInType != XML_SCHEMAS_ANYTYPE;
                 anc = anc->baseType) {
 
             if (anc->type == XML_SCHEMA_TYPE_BASIC) {
@@ skipping 168 matching lines @@
     * 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);
     /*
     * 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)
@@ skipping 239 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)) {
                     /*
@@ skipping 41 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 77 matching lines @@
                     WXS_TYPE_CONTENTTYPE(type) = (xmlSchemaTypePtr) particle;
                     /*
                     * SPEC "the particle of the {content type} of
                     * the ... base ..."
                     * Create a duplicate of the base type's particle
                     * and assign its "term" to it.
                     */
                     particle->children->children =
                         (xmlSchemaTreeItemPtr) xmlSchemaAddParticle(pctxt,
                         type->node,
-                        ((xmlSchemaParticlePtr) type->subtypes)->minOccurs,
-                        ((xmlSchemaParticlePtr) type->subtypes)->maxOccurs);
+                        ((xmlSchemaParticlePtr) baseType->subtypes)->minOccurs,
+                        ((xmlSchemaParticlePtr) baseType->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.
                 */
@@ skipping 414 matching lines @@
 {
     /*
     * 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,
@@ skipping 236 matching lines @@
  *    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--) {
@@ skipping 113 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)."
-        * TODO: Don't care about the *cononical* stuff here, this requirement
+        * 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 *canonical* 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()");
@@ skipping 46 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 112 matching lines @@
                         ctxtComponent, ctxtParticle, cur, ctxtParticle, 1);
                     if (ret != 0)
                         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))
                     {
@@ skipping 177 matching lines @@
     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 47 matching lines @@
         xmlSchemaQNameRefPtr ref = WXS_QNAME_CAST ause->attrDecl;
 
         /*
         * TODO: Evaluate, what errors could occur if the declaration is not
         * found.
         */
         ause->attrDecl = xmlSchemaGetAttributeDecl(ctxt->schema,
             ref->name, ref->targetNamespace);
         if (ause->attrDecl == NULL) {
             xmlSchemaPResCompAttrErr(ctxt,
-                XML_SCHEMAP_SRC_RESOLVE,
+                XML_SCHEMAP_SRC_RESOLVE,
                 WXS_BASIC_CAST ause, ause->node,
                 "ref", ref->name, ref->targetNamespace,
                 XML_SCHEMA_TYPE_ATTRIBUTE, NULL);
             return(ctxt->err);;
         }
     }
     return(0);
 }
 
 /**
@@ skipping 12 matching lines @@
     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);
 
     /*
     * 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 "
@@ skipping 80 matching lines @@
  *
  * 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 143 matching lines @@
         */
         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);
@@ skipping 152 matching lines @@
                 * 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);
@@ skipping 154 matching lines @@
     if (con->bucket == NULL)
         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;
@@ skipping 663 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);
     } else if (WXS_IS_UNION(type)) {
         return (XML_SCHEMA_WHITESPACE_UNKNOWN);
     } else if (WXS_IS_ATOMIC(type)) {
         if (type->flags & XML_SCHEMAS_TYPE_WHITESPACE_PRESERVE)
             return (XML_SCHEMA_WHITESPACE_PRESERVE);
         else if (type->flags & XML_SCHEMAS_TYPE_WHITESPACE_REPLACE)
             return (XML_SCHEMA_WHITESPACE_REPLACE);
         else
             return (XML_SCHEMA_WHITESPACE_COLLAPSE);
     }
     return (-1);
 }
 
 /************************************************************************
- *                                                                      *
- *                      Simple type validation                          *
- *                                                                      *
+ *                                                                      *
+ *                      Simple type validation                          *
+ *                                                                      *
  ************************************************************************/
 
 
 /************************************************************************
- *                                                                      *
- *                      DOM Validation code                             *
- *                                                                      *
+ *                                                                      *
+ *                      DOM Validation code                             *
+ *                                                                      *
  ************************************************************************/
 
 /**
  * xmlSchemaAssembleByLocation:
  * @pctxt:  a schema parser context
  * @vctxt:  a schema validation context
  * @schema: the existing schema
  * @node: the node that fired the assembling
  * @nsName: the namespace name of the new schema
  * @location: the location of the schema
@@ skipping 373 matching lines @@
             return(i);
     }
     /* Add new entry. */
     i = vctxt->nodeQNames->nbItems;
     xmlSchemaItemListAdd(vctxt->nodeQNames, (void *) lname);
     xmlSchemaItemListAdd(vctxt->nodeQNames, (void *) nsname);
     return(i);
 }
 
 /************************************************************************
- *                                                                      *
+ *                                                                      *
  *  Validation of identity-constraints (IDC)                            *
- *                                                                      *
+ *                                                                      *
  ************************************************************************/
 
 /**
  * xmlSchemaAugmentIDC:
  * @idcDef: the IDC definition
  *
  * Creates an augmented IDC definition item.
  *
  * Returns the item, or NULL on internal errors.
  */
@@ skipping 854 matching lines @@
                 /*
                 * Get/create the key-sequence.
                 */
                 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,
                         XML_SCHEMAV_CVC_IDC, NULL,
                         WXS_BASIC_CAST matcher->aidc->def,
@@ skipping 109 matching lines @@
                     }
                     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) &&
@@ skipping 107 matching lines @@
                     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,
                     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:
             /*
@@ skipping 770 matching lines @@
                 }
             }
         }
         matcher = matcher->next;
     }
     /* TODO: Return an error if any error encountered. */
     return (0);
 }
 
 /************************************************************************
- *                                                                      *
- *                      XML Reader validation code                      *
- *                                                                      *
+ *                                                                      *
+ *                      XML Reader validation code                      *
+ *                                                                      *
  ************************************************************************/
 
 static xmlSchemaAttrInfoPtr
 xmlSchemaGetFreshAttrInfo(xmlSchemaValidCtxtPtr vctxt)
 {
     xmlSchemaAttrInfoPtr iattr;
     /*
     * Grow/create list of attribute infos.
     */
     if (vctxt->attrInfos == NULL) {
@@ skipping 582 matching lines @@
     /*
     * 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;
@@ skipping 90 matching lines @@
         }
         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.
         */
@@ skipping 60 matching lines @@
             /*
             * 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
@@ skipping 18 matching lines @@
                     "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;
@@ skipping 139 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 62 matching lines @@
     actualType = WXS_ELEM_TYPEDEF(elemDecl);
     /*
     * cvc-elt (3.3.4) : 2
     */
     if (elemDecl->flags & XML_SCHEMAS_ELEM_ABSTRACT) {
         VERROR(XML_SCHEMAV_CVC_ELT_2, NULL,
             "The element declaration is abstract");
         return (vctxt->err);
     }
     if (actualType == NULL) {
-        VERROR(XML_SCHEMAV_CVC_TYPE_1, NULL,
-            "The type definition is absent");
-        return (XML_SCHEMAV_CVC_TYPE_1);
+        VERROR(XML_SCHEMAV_CVC_TYPE_1, NULL,
+            "The type definition is absent");
+        return (XML_SCHEMAV_CVC_TYPE_1);
     }
     if (vctxt->nbAttrInfos != 0) {
         int ret;
         xmlSchemaAttrInfoPtr iattr;
         /*
         * cvc-elt (3.3.4) : 3
         * Handle 'xsi:nil'.
         */
         iattr = xmlSchemaGetMetaAttrInfo(vctxt,
             XML_SCHEMA_ATTR_INFO_META_XSI_NIL);
@@ skipping 69 matching lines @@
     /*
     * IDC: Register identity-constraint XPath matchers.
     */
     if ((elemDecl->idcs != NULL) &&
         (xmlSchemaIDCRegisterMatchers(vctxt, elemDecl) == -1))
             return (-1);
     /*
     * No actual type definition.
     */
     if (actualType == NULL) {
-        VERROR(XML_SCHEMAV_CVC_TYPE_1, NULL,
-            "The type definition is absent");
-        return (XML_SCHEMAV_CVC_TYPE_1);
+        VERROR(XML_SCHEMAV_CVC_TYPE_1, NULL,
+            "The type definition is absent");
+        return (XML_SCHEMAV_CVC_TYPE_1);
     }
     /*
     * Remember the actual type definition.
     */
     vctxt->inode->typeDef = actualType;
 
     return (0);
 }
 
 static int
@@ skipping 73 matching lines @@
     xmlSchemaItemListPtr attrUseList;
     xmlSchemaAttributeUsePtr attrUse = NULL;
     xmlSchemaAttributePtr attrDecl = NULL;
     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 56 matching lines @@
         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."
                         */
                         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 */
@@ skipping 189 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�
+        * (3) "The item's `normalized value` must be locally `valid`
         * with respect to that {type definition} as per
-        * String Valid (�3.14.4)."
+        * 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(
@@ skipping 17 matching lines @@
             /*
             * SPEC PSVI Assessment Outcome (Attribute)
             * [validity] = "invalid"
             */
             goto eval_idcs;
         }
 
         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 209 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(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).
+    * 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(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);
@@ skipping 120 matching lines @@
                 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
             }
+
+            /*
+             * Do not check further content if the node has been nilled
+             */
+            if (INODE_NILLED(inode)) {
+                ret = 0;
+#ifdef DEBUG_AUTOMATA
+                xmlGenericError(xmlGenericErrorContext,
+                    "AUTOMATON succeeded on nilled '%s'\n",
+                    inode->localName);
+#endif
+                goto skip_nilled;
+            }
+
             /*
             * 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.
@@ skipping 17 matching lines @@
                 ret = 0;
 #ifdef DEBUG_AUTOMATA
                 xmlGenericError(xmlGenericErrorContext,
                     "AUTOMATON succeeded on '%s'\n",
                     inode->localName);
 #endif
             }
 
         }
     }
+
+skip_nilled:
+
     if (inode->typeDef->contentType == XML_SCHEMA_CONTENT_ELEMENTS)
         goto end_elem;
 
 character_content:
 
     if (vctxt->value != NULL) {
         xmlSchemaFreeValue(vctxt->value);
         vctxt->value = NULL;
     }
     /*
@@ skipping 26 matching lines @@
     * 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_NILLED(inode))) {
         /*
         * cvc-elt (3.3.4) : 5.1.1
-        * If the �actual type definition� is a �local type definition�
+        * 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).
+        * `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);
         }
         if (ret != 0) {
@@ skipping 26 matching lines @@
             if (textChild == NULL) {
                 VERROR_INT("xmlSchemaValidatorPopElem",
                     "calling xmlNewText()");
                 goto internal_error;
             } else
                 xmlAddChild(inode->node, textChild);
         }
 
     } 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)."
+            * 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;
             }
@@ skipping 21 matching lines @@
                     "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
                 * 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
+                    * 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 [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,
                             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
+                    * 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,
@@ skipping 20 matching lines @@
     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.
@@ skipping 57 matching lines @@
                 * top-most keyref IDC which refers to this IDC.
                 */
                 aidc->keyrefDepth = -1;
             }
             aidc = aidc->next;
         } while (aidc != NULL);
     }
     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 216 matching lines @@
         *   for all input scenarios, then this should be changed to
         *   instantly stop the validation.
         */
         ret = xmlSchemaAssembleByXSI(vctxt);
         if (ret != 0) {
             if (ret == -1)
                 goto internal_error;
             vctxt->skipDepth = 0;
             return(ret);
         }
+        /*
+         * Augment the IDC definitions for the main schema and all imported ones
+         * NOTE: main schema is the first in the imported list
+         */
+        xmlHashScan(vctxt->schema->schemasImports,(xmlHashScanner)xmlSchemaAugmentImportedIDC, vctxt);
     }
     if (vctxt->depth > 0) {
         /*
         * Validate this element against the content model
         * of the parent.
         */
         ret = xmlSchemaValidateChildElem(vctxt);
         if (ret != 0) {
             if (ret < 0) {
                 VERROR_INT("xmlSchemaValidateElem",
@@ skipping 73 matching lines @@
         goto exit;
     }
     /*
     * 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");
+        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");
+            VERROR(ret, NULL,
+            "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 226 matching lines @@
     } while (ret == 1);
 
 exit:
     return (ret);
 internal_error:
     return (-1);
 }
 #endif
 
 /************************************************************************
- *                                                                      *
- *                      SAX validation handlers                         *
- *                                                                      *
+ *                                                                      *
+ *                      SAX validation handlers                         *
+ *                                                                      *
  ************************************************************************/
 
 /*
 * Process text content.
 */
 static void
 xmlSchemaSAXHandleText(void *ctx,
                        const xmlChar * ch,
                        int len)
 {
@@ skipping 230 matching lines @@
     }
 exit:
     return;
 internal_error:
     vctxt->err = -1;
     xmlStopParser(vctxt->parserCtxt);
     return;
 }
 
 /************************************************************************
- *                                                                      *
- *                      Validation interfaces                           *
- *                                                                      *
+ *                                                                      *
+ *                      Validation interfaces                           *
+ *                                                                      *
  ************************************************************************/
 
 /**
  * xmlSchemaNewValidCtxt:
  * @schema:  a precompiled XML Schemas
  *
  * Create an XML Schemas validation context based on the given schema.
  *
  * Returns the validation context or NULL in case of error
  */
 xmlSchemaValidCtxtPtr
 xmlSchemaNewValidCtxt(xmlSchemaPtr schema)
 {
     xmlSchemaValidCtxtPtr ret;
 
     ret = (xmlSchemaValidCtxtPtr) xmlMalloc(sizeof(xmlSchemaValidCtxt));
     if (ret == NULL) {
         xmlSchemaVErrMemory(NULL, "allocating validation context", NULL);
         return (NULL);
     }
     memset(ret, 0, sizeof(xmlSchemaValidCtxt));
     ret->type = XML_SCHEMA_CTXT_VALIDATOR;
     ret->dict = xmlDictCreate();
     ret->nodeQNames = xmlSchemaItemListCreate();
     ret->schema = schema;
     return (ret);
 }
 
 /**
+ * xmlSchemaValidateSetFilename:
+ * @vctxt: the schema validation context
+ * @filename: the file name
+ *
+ * Workaround to provide file error reporting information when this is
+ * not provided by current APIs
+ */
+void
+xmlSchemaValidateSetFilename(xmlSchemaValidCtxtPtr vctxt, const char *filename) {
+    if (vctxt == NULL)
+        return;
+    if (vctxt->filename != NULL)
+        xmlFree(vctxt->filename);
+    if (filename != NULL)
+        vctxt->filename = (char *) xmlStrdup((const xmlChar *) filename);
+    else
+        vctxt->filename = NULL;
+}
+
+/**
  * xmlSchemaClearValidCtxt:
- * @ctxt: the schema validation context
+ * @vctxt: the schema validation context
  *
  * Free the resources associated to the schema validation context;
  * leaves some fields alive intended for reuse of the context.
  */
 static void
 xmlSchemaClearValidCtxt(xmlSchemaValidCtxtPtr vctxt)
 {
     if (vctxt == NULL)
         return;
 
@@ skipping 80 matching lines @@
         }
     }
     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();
+
+    if (vctxt->filename != NULL) {
+        xmlFree(vctxt->filename);
+        vctxt->filename = NULL;
+    }
 }
 
 /**
  * xmlSchemaFreeValidCtxt:
  * @ctxt:  the schema validation context
  *
  * Free the resources associated to the schema validation context
  */
 void
 xmlSchemaFreeValidCtxt(xmlSchemaValidCtxtPtr ctxt)
@@ skipping 65 matching lines @@
                 break;
             xmlSchemaClearElemInfo(ctxt, ei);
             xmlFree(ei);
         }
         xmlFree(ctxt->elemInfos);
     }
     if (ctxt->nodeQNames != NULL)
         xmlSchemaItemListFree(ctxt->nodeQNames);
     if (ctxt->dict != NULL)
         xmlDictFree(ctxt->dict);
+    if (ctxt->filename != NULL)
+        xmlFree(ctxt->filename);
     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
@@ skipping 134 matching lines @@
 static int
 xmlSchemaVDocWalk(xmlSchemaValidCtxtPtr vctxt)
 {
     xmlAttrPtr attr;
     int ret = 0;
     xmlSchemaNodeInfoPtr ielem = NULL;
     xmlNodePtr node, valRoot;
     const xmlChar *nsName;
 
     /* DOC VAL TODO: Move this to the start function. */
-    valRoot = xmlDocGetRootElement(vctxt->doc);
+    if (vctxt->validationRoot != NULL)
+        valRoot = vctxt->validationRoot;
+    else
+        valRoot = xmlDocGetRootElement(vctxt->doc);
     if (valRoot == NULL) {
         /* VAL TODO: Error code? */
         VERROR(1, NULL, "The document has no document element");
         return (1);
     }
     vctxt->depth = -1;
     vctxt->validationRoot = valRoot;
     node = valRoot;
     while (node != NULL) {
         if ((vctxt->skipDepth != -1) && (vctxt->depth >= vctxt->skipDepth))
@@ skipping 300 matching lines @@
             (xmlNodePtr) doc, NULL,
             "The document has no document element", NULL, NULL);
         return (ctxt->err);
     }
     ctxt->validationRoot = ctxt->node;
     return (xmlSchemaVStart(ctxt));
 }
 
 
 /************************************************************************
- *                                                                      *
- *              Function and data for SAX streaming API                 *
- *                                                                      *
+ *                                                                      *
+ *              Function and data for SAX streaming API                 *
+ *                                                                      *
  ************************************************************************/
 typedef struct _xmlSchemaSplitSAXData xmlSchemaSplitSAXData;
 typedef xmlSchemaSplitSAXData *xmlSchemaSplitSAXDataPtr;
 
 struct _xmlSchemaSplitSAXData {
     xmlSAXHandlerPtr      user_sax;
     void                 *user_data;
     xmlSchemaValidCtxtPtr ctxt;
     xmlSAXHandlerPtr      schemas_sax;
 };
@@ skipping 496 matching lines @@
         user_data = plug->user_data_ptr;
         *user_data = plug->user_data;
     }
 
     /* free and return */
     xmlFree(plug);
     return(0);
 }
 
 /**
+ * xmlSchemaValidateSetLocator:
+ * @vctxt: a schema validation context
+ * @f: the locator function pointer
+ * @ctxt: the locator context
+ *
+ * Allows to set a locator function to the validation context,
+ * which will be used to provide file and line information since
+ * those are not provided as part of the SAX validation flow
+ * Setting @f to NULL disable the locator.
+ */
+
+void
+xmlSchemaValidateSetLocator(xmlSchemaValidCtxtPtr vctxt,
+                            xmlSchemaValidityLocatorFunc f,
+                            void *ctxt)
+{
+    if (vctxt == NULL) return;
+    vctxt->locFunc = f;
+    vctxt->locCtxt = ctxt;
+}
+
+/**
+ * xmlSchemaValidateStreamLocator:
+ * @ctx: the xmlTextReaderPtr used
+ * @file: returned file information
+ * @line: returned line information
+ *
+ * Internal locator function for the readers
+ *
+ * Returns 0 in case the Schema validation could be (des)activated and
+ *         -1 in case of error.
+ */
+static int
+xmlSchemaValidateStreamLocator(void *ctx, const char **file,
+                               unsigned long *line) {
+    xmlParserCtxtPtr ctxt;
+
+    if ((ctx == NULL) || ((file == NULL) && (line == NULL)))
+        return(-1);
+
+    if (file != NULL)
+        *file = NULL;
+    if (line != NULL)
+        *line = 0;
+
+    ctxt = (xmlParserCtxtPtr) ctx;
+    if (ctxt->input != NULL) {
+       if (file != NULL)
+           *file = ctxt->input->filename;
+       if (line != NULL)
+           *line = ctxt->input->line;
+       return(0);
+    }
+    return(-1);
+}
+
+/**
  * xmlSchemaValidateStream:
  * @ctxt:  a schema validation context
  * @input:  the input to use for reading the data
  * @enc:  an optional encoding information
  * @sax:  a SAX handler for the resulting events
  * @user_data:  the context to provide to the SAX handler.
  *
  * Validate an input based on a flow of SAX event from the parser
  * and forward the events to the @sax handler with the provided @user_data
  * the user provided @sax handler must be a SAX2 one.
@@ skipping 22 matching lines @@
     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;
+    xmlSchemaValidateSetLocator(ctxt, xmlSchemaValidateStreamLocator, pctxt);
 
     inputStream = xmlNewIOInputStream(pctxt, input, enc);;
     if (inputStream == NULL) {
         ret = -1;
         goto done;
     }
     inputPush(pctxt, inputStream);
     ctxt->parserCtxt = pctxt;
     ctxt->input = input;
 
@@ skipping 77 matching lines @@
 xmlSchemaValidCtxtGetParserCtxt(xmlSchemaValidCtxtPtr ctxt)
 {
     if (ctxt == NULL)
         return(NULL);
     return (ctxt->parserCtxt);
 }
 
 #define bottom_xmlschemas
 #include "elfgcchack.h"
 #endif /* LIBXML_SCHEMAS_ENABLED */