Initial merge of nxml

132 files changed, 31314 insertions, 0 deletions

diff --git a/lisp/nxml/Makefile b/lisp/nxml/Makefile
new file mode 100644
index 00000000000..13eee93a0e8
--- /dev/null
+++ b/lisp/nxml/Makefile
@@ -0,0 +1,80 @@
+EXTRA=README NEWS VERSION TODO COPYING Makefile rng-auto.el \
+  nxml-mode.xml nxml-mode.rnc nxml-mode.texi nxml-mode.info dir \
+  test.valid.xml test.invalid.xml 
+
+SRC=nxml-rap.el nxml-outln.el nxml-mode.el nxml-parse.el nxml-enc.el \
+  nxml-uchnm.el nxml-glyph.el nxml-maint.el nxml-util.el nxml-ns.el \
+  rng-dt.el rng-valid.el rng-pttrn.el rng-xsd.el rng-cmpct.el \
+  rng-match.el rng-nxml.el rng-util.el rng-loc.el rng-uri.el \
+  rng-parse.el rng-maint.el xsd-regexp.el xmltok.el
+
+ELC=nxml-rap.elc nxml-outln.elc nxml-mode.elc nxml-parse.elc nxml-enc.elc \
+  nxml-uchnm.elc nxml-glyph.elc nxml-maint.elc nxml-util.elc nxml-ns.elc \
+  rng-dt.elc rng-valid.elc rng-pttrn.elc rng-xsd.elc rng-cmpct.elc \
+  rng-match.elc rng-nxml.elc rng-util.elc rng-loc.elc rng-uri.elc \
+  rng-parse.elc rng-maint.elc xsd-regexp.elc xmltok.elc
+
+FILESTOCLEAN=stamp-byte-compile $(ELC) VERSION TAGS \
+  nxml-mode.texi nxml-mode.info dir
+
+EMACS=emacs
+ETAGS=etags
+MAKEINFO=makeinfo
+INSTALL-INFO=install-info
+PACKAGE=nxml-mode
+
+stamp-byte-compile: $(SRC)
+        -rm -f $(ELC)
+        $(EMACS) -batch -l rng-auto.el -f rng-byte-compile-load
+        touch $(@)
+
+all: stamp-byte-compile nxml-mode.info
+
+dir: nxml-mode.info
+        rm -f $@
+        $(INSTALL-INFO) $< $@
+
+info: nxml-mode.info
+
+nxml-mode.info: nxml-mode.texi
+        $(MAKEINFO) $<
+
+nxml-mode.texi: nxml-mode.xml
+        $(EMACS) -batch -l rng-auto.el -f rng-format-manual
+
+VERSION: stamp-byte-compile rng-auto.el
+        $(EMACS) -batch -l rng-auto.el -f rng-write-version
+
+TAGS: $(SRC)
+        $(ETAGS) $(SRC)
+
+dist: stamp-byte-compile $(EXTRA)
+        @version=`cat VERSION`; \
+        set -e; \
+        echo Making $(PACKAGE)-$$version.tar.gz; \
+        rm -fr $(PACKAGE)-$$version; \
+        mkdir $(PACKAGE)-$$version; \
+        cd $(PACKAGE)-$$version; \
+        for f in $(EXTRA) $(SRC) $(ELC); do \
+          ln -s ../$$f .; \
+        done; \
+        mkdir schema; \
+        cd schema; \
+        for f in ../../schema/*.rnc ../../schema/*.xml; do \
+          ln -s $$f .; \
+        done; \
+        cd ..; \
+        mkdir char-name; \
+        mkdir char-name/unicode; \
+        cd char-name/unicode; \
+        for f in ../../../char-name/unicode/*-*.el; do \
+          ln -s $$f .; \
+        done; \
+        cd ../../..; \
+        tar cfhz $(PACKAGE)-$$version.tar.gz $(PACKAGE)-$$version; \
+        rm -fr $(PACKAGE)-$$version
+
+clean:
+        -rm -f $(FILESTOCLEAN)
+
+.PHONY: all clean info
diff --git a/lisp/nxml/NEWS b/lisp/nxml/NEWS
new file mode 100644
index 00000000000..cebbab82fda
--- /dev/null
+++ b/lisp/nxml/NEWS
@@ -0,0 +1,199 @@
+20041004
+--------
+
+Support for outlining has been added. See the manual for more details.
+
+C-u C-c C-n goes to the first error.
+
+20040910
+--------
+
+C-c RET splits the current element as in PSGML.
+
+20040908
+--------
+
+Indentation has been rewritten.  Indentation of attribute names and
+values should work better.  The default value of
+`nxml-attribute-indent' has been changed to 4.
+
+Syntax highlighting with a dark background should now work.
+
+20040726
+--------
+
+The attribute pathSuffix on the uri element in schema locating files
+has been replaced by a more general pattern attribute. The
+transformURI element now has required fromPattern and toPattern
+attributes.
+
+The schema related bindings have been changed to use C-c C-s as a prefix
+as follows:
+
+  C-c C-s => C-c C-s C-f (f for file)
+  C-c C-a => C-c C-s C-a
+  C-c C-t => C-c C-s C-t
+  C-c C-l => C-c C-s C-l
+  C-c C-w => C-c C-s C-w
+
+There's now an XML menu on the menu-bar.
+
+20031031
+--------
+
+C-c C-d "dynamically" chooses a tag to put around the word before
+point, rather like M-/.
+
+The mechanism for locating the schema has changed completely.  The new
+mechanism is described in the manual.  Any existing customizations of
+`rng-auto-element-alist' or `rng-auto-file-name-alist' will no longer
+be effective.
+
+C-c C-a is now bound to rng-auto-set-schema.
+
+20031018
+--------
+
+Unicode names can be used to insert characters with the new command
+C-c C-u.  Normally, this inserts a character reference.  With a prefix
+arg (i.e. C-u C-c C-u), it inserts the character directly.  You can
+customize `nxml-enabled-unicode-blocks' to control what Unicode blocks
+are used for completing names.
+
+Extra information is displayed for character references.  The Unicode
+name is displayed in a tooltip. A glyph for the referenced character
+is displayed in a distinguished face following the character
+reference; this can be disabled by customizing
+`nxml-char-ref-display-glyph-flag'.  The command
+`nxml-toggle-char-ref-extra-display' dynamically toggles the display
+of extra information for character references for a particular buffer.
+This can be used if the display of extra information is causing
+performance problems. nXML mode tries to figure out which glyphs can
+be displayed. Unfortunately Emacs doesn't provide the primitives
+necessary to do this properly, so nXML mode has to guess and will
+sometimes guess wrong.  The hook `nxml-glyph-set-hook' can be used to
+change nXML mode's guess.
+
+New command C-c C-w says what schema is being used.
+
+C-c C-s now turns on validation if it is not already on.
+
+20030928
+--------
+
+M-q has been implemented so that it works reasonably with XML.  Other
+paragraph-related commands (M-{, M-}, M-h) have also been implemented.
+
+New command M-x rng-auto-set-schema to set the schema based on the
+buffer's current contents and file-name. This is called automatically
+when rng-validate-mode is first enabled.
+
+There's now a C-M-d to go with C-M-u.  C-M-d moves forward down into
+the content of an element.  C-M-n and C-M-p move to the next or
+previous element.
+
+By default, the sexp commands (C-M-f, C-M-b, C-M-k, C-M-SPC) operate
+on tags rather than elements.  To restore the old behaviour,
+customize nxml-sexp-element-flag.
+
+The file TUTORIAL has been replaced by nxml-mode.info; this is in info
+format and can be read using Emacs.  The source is maintained in a
+simple, ad-hoc XML format.
+
+20030915
+--------
+
+XML encodings should now work properly.  When saving a buffer,
+nxml-mode arranges to use the encoding declared in the XML
+declaration.  If there is no encoding declared, then nxml-mode will
+use utf-8 or utf-16 according to the user options
+`nxml-prefer-utf-16-to-utf-8-flag' and
+`nxml-prefer-utf-16-little-to-big-endian-flag'. If the chosen encoding
+cannot encode all the characters in the buffer, nxml-mode will
+complain and give the user an opportunity to use an encoding that can.
+
+A new command C-c C-x inserts an XML declaration.
+
+The option `nxml-auto-insert-xml-declaration-flag' automatically
+inserts an XML declaration in new files.
+
+The `nxml-default-buffer-file-coding-system' option allows a different
+default buffer-file-coding-system for nXML mode buffers.  This affects
+what XML declaration is inserted.
+
+Encoding names in XML declarations are now validated by
+rng-validate-mode.
+
+RDF/XML schema was updated to version in 05 September 2003 WD.
+
+20030912
+--------
+
+The tutorial has a new section on inserting end-tags.
+
+By default </ no longer automatically inserts the rest of the end-tag.
+You can do
+
+  M-x customize-variable RET nxml-slash-auto-complete-flag RET
+
+and then follow the instructions displayed in the buffer to get the
+old behaviour.
+
+Completion after </ will complete the rest of the end-tag. Completion
+after < will include the end-tag in the possibilities if allowed by
+the schema.
+
+You can use C-c C-i instead of > to close the start-tag of an
+inline-level element.  After inserting the >, it will insert the
+end-tag and leave point before the end-tag. The `i' is supposed to be
+mnemonic for `inline'. C-c C-b is similar, but for block elements: the
+start-tag, point and the end-tag will all be on separate lines.
+
+The binding for inserting an end-tag has changed from C-c / to C-c C-f
+to comply with Emacs guidelines about what keys major modes should
+bind.  The `f' is supposed to be mnemonic for `finish'.
+
+Completion always puts point after all the characters it inserts. It
+doesn't insert a `>' after completing a start-tag name.
+
+Completion no longer completes CDATA section and comment delimiters.
+
+The nxml-start-auto-coding command enables auto-detection of a file's
+encoding as specified in the XML Recommendation for files that use
+nxml-mode; rng-auto.el calls this.
+
+20030906
+--------
+
+Validation messages applicable to point are displayed automatically.
+
+Completion can deal with prefixes that haven't yet been declared.
+
+rng-preferred-prefix-alist variable added.
+
+Namespace URIs can be completed.
+
+xmlns and xmlns:* attributes can be completed.
+
+CDATA section and comment delimiters can be completed.
+
+Each kind of completion has its own history.
+
+Completion function moved to nxml-mode; uses a hook to allow
+schema-sensitive completion.  Completion function bound to C-return.
+Also bound to M-TAB as before, unless
+nxml-bind-meta-tab-to-complete-flag is nil.  When there is a window
+system, nxml-bind-meta-tab-to-complete-flag is nil by default, This
+avoid problems with M-TAB, which is not passed through by several
+window systems/managers.
+
+TUTORIAL file added.
+
+NEWS file added.
+
+Bug fixes.
+
+20030901
+--------
+
+Initial release.
diff --git a/lisp/nxml/README b/lisp/nxml/README
new file mode 100644
index 00000000000..4f3fc96c0f4
--- /dev/null
+++ b/lisp/nxml/README
@@ -0,0 +1,106 @@
+This is a new major mode for GNU Emacs for editing XML documents. It
+supports editing well-formed XML documents and also provides
+schema-sensitive editing of XML documents using RELAX NG Compact
+Syntax.
+
+To use this, you need GNU Emacs version 21.x, preferably 21.3. GNU
+Emacs version 20 will not work properly, nor will XEmacs.
+
+To get started, do
+
+  M-x load-file <RET> rng-auto.el <RET>
+
+This defines the necessary autoloads.  Now, visit a file containing
+an XML document, and do
+
+  M-x nxml-mode
+
+Now do
+
+  C-h m
+
+for information on how to use nxml-mode.
+
+The beginnings of a manual are in nxml-mode.info.  You can read this
+using
+
+  C-u M-x info RET nxml-mode.info RET
+
+It's also installed as an entry at the end of the top-level info
+directory.  So you can read it with C-h i as usual.
+
+You can use test.valid.xml and test.invalid.xml as examples of valid
+and invalid XML documents.
+
+To get things automatically loaded each time you start Emacs, add
+
+  (load "~/nxml-mode-200YMMDD/rng-auto.el")
+
+to your .emacs, where ~/nxml-mode-200YMMDD is the directory containing
+the .elc files.  Note that rng-auto.el does not load all of the
+nxml-mode code; it merely sets things up so that all the features of
+nxml-mode will be autoloaded properly.  You should not try to autoload
+rng-auto.el itself.
+
+To use nxml-mode automatically for files with an extension of xml,
+xsl, rng or xhtml, add
+
+  (setq auto-mode-alist
+        (cons '("\\.\\(xml\\|xsl\\|rng\\|xhtml\\)\\'" . nxml-mode)
+              auto-mode-alist))
+
+to your .emacs.
+
+If you edit XML using iso-8859-N encodings other than iso-8859-1 and
+you are running Emacs 21.3 or later, then I recommend enabling
+unify-8859-on-decoding-mode, by adding
+
+  (unify-8859-on-decoding-mode)
+
+to you .emacs.
+
+To get validation and schema-sensitive editing, you need a RELAX NG
+Compact Syntax (RNC) schema for you document. The schema directory
+includes some schemas for popular document types.
+
+For more on RELAX NG, see
+
+  http://relaxng.org
+
+For a tutorial on RELAX NG Compact Syntax, see
+
+  http://relaxng.org/compact-tutorial.html
+
+For automatically creating RNC schemas, I recommend my Trang program:
+
+  http://www.thaiopensource.com/relaxng/trang.html
+
+You can use this to
+
+- infer an RNC schema from an instance document;
+
+- convert a DTD to an RNC schema;
+
+- convert a RELAX NG XML syntax schema to an RNC schema.
+
+To convert a RELAX NG XML syntax (.rng) schema to a RNC schema, you
+can also use the XSLT stylesheet from
+
+  http://www.pantor.com/download.html
+
+To convert a W3C XML Schema to an RNC schema, you need first to
+convert it to RELAX NG XML syntax using Sun's RELAX NG converter tool
+rngconv (built on top of MSV). See
+
+  https://msv.dev.java.net/
+
+The file NEWS describes recent changes.
+
+Please use the list
+
+  http://groups.yahoo.com/group/emacs-nxml-mode/
+
+for bug reports, discussion. I will announce all new versions there.
+
+James Clark
+http://www.jclark.com/contact.html
diff --git a/lisp/nxml/TODO b/lisp/nxml/TODO
new file mode 100644
index 00000000000..3e7d5012b66
--- /dev/null
+++ b/lisp/nxml/TODO
@@ -0,0 +1,468 @@
+* High priority
+
+** Command to insert an element template, including all required
+attributes and child elements.  When there's a choice of elements
+possible, we could insert a comment, and put an overlay on that
+comment that makes it behave like a button with a pop-up menu to
+select the appropriate choice.
+
+** Command to tag a region.  With a schema should complete using legal
+tags, but should work without a schema as well.
+
+** Provide a way to conveniently rename an element. With a schema should
+complete using legal tags, but should work without a schema as well.
+
+* Outlining
+
+** Implement C-c C-o C-q.
+
+** Install pre/post command hook for moving out of invisible section.
+
+** Put a modify hook on invisible sections that expands them.
+
+** Integrate dumb folding somehow.
+
+** An element should be able to be its own heading.
+
+** Optimize to avoid complete buffer scan on each command.
+
+** Make it work with HTML-style headings (i.e. level indicated by
+name of heading element rather than depth of section nesting).
+
+** Recognize root element as a section provided it has a title, even
+if it doesn't match section-element-name-regex.
+
+** Support for incremental search automatically making hidden text
+visible.
+
+** Allow title to be an attribute.
+
+** Command that says to recognize the tag at point as a section/heading.
+
+** Explore better ways to determine when an element is a section
+or a heading.
+
+** rng-next-error needs to either ignore invisible portion or reveal it
+(maybe use isearch oriented text properties).
+
+** Errors within hidden section should be highlighted by underlining the
+ellipsis.
+
+** Make indirect buffers work.
+
+** How should nxml-refresh outline recover from non well-formed tags?
+
+** Hide tags in title elements?
+
+** Use overlays instead of text properties for holding outline state?
+Necessary for indirect buffers to work?
+
+** Allow an outline to go in the speedbar.
+
+** Split up outlining manual section into subsections.
+
+** More detail in the manual about each outlining command.
+
+** More menu entries for hiding/showing?
+
+** Indication of many lines have been hidden?
+
+* Locating schemas
+
+** Should rng-validate-mode give the user an opportunity to specify a
+schema if there is currently none? Or should it at least give a hint
+to the user how to specify a non-vacuous schema?
+
+** Support for adding new schemas to schema-locating files. Add
+documentElement and namespace elements.
+
+** C-c C-w should be able to report current type id.
+
+** Implement doctypePublicId.
+
+** Implement typeIdBase.
+
+** Implement typeIdProcessingInstruction.
+
+** Support xml:base.
+
+** Implement group.
+
+** Find preferred prefix from schema-locating files.  Get rid of
+rng-preferred-prefix-alist.
+
+** Inserting document element with vacuous schema should complete using
+document elements declared in schema locating files, and set schema
+appropriately.
+
+** Add a ruleType attribute to the <include> element?
+
+** Allow processing instruction in prolog to contain the compact syntax
+schema directly.
+
+** Use RDDL to locate a schema based on the namespace URI.
+
+** Should not prompt to add redundant association to schema locating
+file.
+
+** Command to reload current schema.
+
+* Schema-sensitive features
+
+** Should filter dynamic markup possibilities using schema validity, by
+adding hook to nxml-mode.
+
+** Dynamic markup word should (at least optionally) be able to look in
+other buffers that are using nxml-mode.
+
+** Should clicking on Invalid move to next error if already on an error?
+
+** Take advantage of a:documentation. Needs change to schema format.
+
+** Provide feasible validation (as in Jing) toggle.
+
+** Save the validation state as a property on the error overlay to enable
+more detailed diagnosis.
+
+** Provide an Error Summary buffer showing all the validation errors.
+
+** Pop-up menu.  What is useful?  Tag a region (should be greyed out if
+the region is not balanced).  Suggestions based on error messages.
+
+** Have configurable list of namespace URIs so that we can provide
+namespace URI completion on extension elements or with schema-less
+documents.
+
+** Allow validation to handle XInclude.
+
+** ID/IDREF support.
+
+* Completion
+
+** Make it work with icomplete.  Only use a function to complete when
+some of the possible names have undeclared namespaces.
+
+** How should C-return in mixed text work?
+
+** When there's a vacuous schema, C-return after < will insert the
+end-tag.  Is this a bug or a feature?
+
+** After completing start-tag, ensure we don't get unhelpful message
+from validation
+
+** Syntax table for completion.
+
+** Should complete start-tag name with a space if namespace attributes
+are required.
+
+** When completing start-tag name with no prefix and it doesn't match
+should try to infer namespace from local name.
+
+** Should completion pay attention to characters after point?  If so,
+how?
+
+** When completing start-tag name, add required atts if only one required
+attribute.
+
+** When completing attribute name, add attribute value if only one value
+is possible.
+
+** After attribute-value completion, insert space after close delimiter
+if more attributes are required.
+
+** Complete on enumerated data values in elements.
+
+** When in context that allows only elements, should get tag
+completion without having to type < first.
+
+** When immediately after start-tag name, and name is valid and not
+prefix of any other name, should C-return complete on attribute names?
+
+** When completing attributes, more consistent to ignore all attributes
+after point.
+
+** Inserting attribute value completions needs to be sensitive to what
+delimiter is used so that it quotes the correct character.
+
+** Complete on encoding-names in XML decl.
+
+** Complete namespace declarations by searching for all namespaces
+mentioned in the schema.
+
+* Well-formed XML support
+
+** Deal better with Mule-UCS
+
+** Deal with UTF-8 BOM when reading.
+
+** Complete entity names.
+
+** Provide some support for entity names for MathML.
+
+** Command to repeat the last tag.
+
+** Support for changing between character references and characters.
+Need to check that context is one in which character references are
+allowed.  xmltok prolog parsing will need to distinguish parameter
+literals from other kinds of literal.
+
+** Provide a comment command to bind to M-; that works better than the
+normal one.
+
+** Make indenting in a multi-line comment work.
+
+** Structure view.  Separate buffer displaying element tree. Be able to
+navigate from structure view to document and vice-versa.
+
+** Flash matching >.
+
+** Smart selection command that selects increasingly large syntactically
+coherent chunks of XML.  If point is in an attribute value, first
+select complete value; then if command is repeated, select value plus
+delimiters, then select attribute name as well, then complete
+start-tag, then complete element, then enclosing element, etc.
+
+** ispell integration.
+
+** Block-level items in mixed content should be indented, e.g:
+  <para>This is list:
+    <ul>
+      <li>item</li>
+
+** Provide option to indent like this:
+
+**   <para>This is a paragraph
+    occupying multiple lines.</para>
+
+** Option to add make a / that closes a start-tag electrically insert a
+space for the XHTML guys.
+
+** C-M-q should work.
+
+* Datatypes
+
+** Figure out workaround for CJK characters with regexps.
+
+** Does category C contain Cn?
+
+** Do ENTITY datatype properly.
+
+* XML Parsing Library
+
+** Parameter entity parsing option, nil (never), t (always),
+unless-standalone (unless standalone="yes" in XML declaration).
+
+** When a file is currently being edited, there should be an option to
+use its buffer instead of the on-disk copy.
+
+* Handling all XML features
+
+** Provide better support for editing external general parsed entities.
+Perhaps provide a way to force ignoring undefined entities; maybe turn
+this on automatically with <?xml encoding=""?> (with no version
+pseudo-att).
+
+** Handle internal general entity declarations containing elements.
+
+** Handle external general entity declarations.
+
+** Handle default attribute declarations in internal subset.
+
+** Handle parameter entities (including DTD).
+
+* RELAX NG
+
+** Do complete schema checking, at least optionally.
+
+** Detect include/external loops during schema parse.
+
+** Coding system detection for schemas.  Should use utf-8/utf-16 per the
+spec. But also need to allow encodings other than UTF-8/16 to support
+CJK charsets that Emacs cannot represent in Unicode.
+
+* Catching XML errors
+
+** Check public identifiers.
+
+** Check default attribute values.
+
+* Performance
+
+** Explore whether overlay-recenter can cure overlays performance
+problems.
+
+** Cache schemas. Need to have list of files and mtimes.
+
+** Make it possible to reduce rng-validate-chunk-size significantly,
+perhaps to 500 bytes, without bad performance impact: don't do
+redisplay on every chunk; pass continue functions on other uses of
+rng-do-some-validation.
+
+** Cache after first tag.
+
+** Introduce a new name class that is a choice between names (so that
+we can use member)
+
+** intern-choice should simplify after patterns with same 1st/2nd args
+
+** Large numbers of overlays slow things down dramatically.  Represent
+errors using text properties.  This implies we cannot incrementally
+keep track of the number of errors, in order to determine validity.
+Instead, when validation completes, scan for any characters with an
+error text property; this seems to be fast enough even with large
+buffers. Problem with error at end of buffer, where there's no
+character; need special variable for this.  Need to merge face from
+font-lock with the error face: use :inherit attribute with list of two
+faces.  How do we avoid making rng-valid depend on nxml-mode?
+
+* Error recovery
+
+** Don't stop at newline in looking for close of start-tag.
+
+** Use indentation to guide recovery from mismatched end-tags
+
+** Don't keep parsing when currently not well-formed but previously
+well-formed
+
+** Try to recover from a bad start-tag by popping an open element if
+there was a mismatched end-tag unaccounted for.
+
+** Try to recover from a bad start-tag open on the hypothesis that there
+was an error in the namespace URI.
+
+** Better recovery from ill-formed XML declarations.
+
+* Useability improvements
+
+** Should print a "Parsing..." message during long movements.
+
+** Provide better position for reference to undefined pattern error.
+
+** Put Well-formed in the mode-line when validating against any-content.
+
+** Trim marking of illegal data for leading and trailing whitespace.
+
+** Show Invalid status as soon as we are sure it's invalid, rather than
+waiting for everything to be completely up to date.
+
+** When narrowed, Valid or Invalid status should probably consider only
+validity of narrowed region.
+
+* Bug fixes
+
+** Need to give an error for a document like: <foo/><![CDATA[  ]]>
+
+** Make nxml-forward-balanced-item work better for the prolog.
+
+** Make filling and indenting comments work in the prolog.
+
+** Should delete RNC Input buffers.
+
+** Figure out what regex use for NCName and use it consistently,
+
+** Should have not-well-formed tokens in ref.
+
+** Require version in XML declaration? Probably not because prevents
+use for external parsed entities. At least forbid standalone
+without version.
+
+** Reject schema that compiles to rng-not-allowed-ipattern.
+
+** Move point backwards on schema parse error so that it's on the right token.
+
+* Internal
+
+** Use rng-quote-string consistently.
+
+** Use parsing library for XML to texinfo conversion.
+
+** Rename xmltok.el to nxml-token.el.  Use nxml-t- prefix instead of
+xmltok-. Change nxml-t-type to nxml-t-token-type, nxml-t-start to
+nxml-t-token-start.
+
+** Can we set fill-prefix to nil and rely on indenting?
+
+** xmltok should make available replacement text of entities containing
+elements
+
+** In rng-valid, instead of using modification-hooks and
+insert-behind-hooks on dependent overlays, use same technique as
+nxml-mode.
+
+** Port to XEmacs.  Issues include: Unicode (XEmacs seems to be based on
+Mule-UCS); overlays/text properties vs extents; absence of
+fontification-functions hook.
+
+* Fontification
+
+** Allow face to depend on element qname, attribute qname, attribute
+value.  Use list with pairs of (R . F), where R specifies regexps and
+F specifies faces.  How can this list be made to depend on the
+document type?
+
+* Other
+
+** Support RELAX NG XML syntax (use XML parsing library).
+
+** Support W3C XML Schema (use XML parsing library).
+
+** Command to infer schema from current document (like trang).
+
+* Schemas
+
+** XSLT schema should take advantage of RELAX NG to express cooccurrence
+constraints on attributes (e.g. xsl:template).
+
+* Documentation
+
+** Move material from README to manual.
+
+** Document encodings.
+
+* Notes
+
+** How can we allow an error to be displayed on a different token from
+where it is detected?  In particular, for a missing closing ">" we
+will need to display it at the beginning of the following token.  At
+the moment, when we parse the following token the error overlay will
+get cleared.
+
+** How should rng-goto-next-error deal with narrowing?
+
+** Perhaps should merge errors having same start position even if they
+have different ends.
+
+** How to handle surrogates? One possibility is to be compatible with
+utf8.e: represent as sequence of 4 chars.  But utf-16 is incompatible
+with this.
+
+** Should we distinguish well-formedness errors from invalidity errors?
+(I think not: we may want to recover from a bad start-tag by implying
+an end-tag.)
+
+** Seems to be a bug with Emacs, where a mouse movement that causes
+help-echo text to appear counts as pending input but does not cause
+idle timer to be restarted.
+
+** Use XML to represent this file.
+
+** I had a TODO which said simply "split-string". What did I mean?
+
+** Investigate performance on large files all on one line.
+
+* CVS emacs issues
+
+** Take advantage of UTF-8 CJK support.
+
+** Supply a next-error-function.
+
+** Investigate this NEWS item "Emacs now tries to set up buffer coding
+systems for HTML/XML files automatically."
+
+** Take advantage of the pointer text property.
+
+** Leverage char-displayable-p.
+
+Local variables:
+mode: outline
+end:
diff --git a/lisp/nxml/char-name/subdirs.el b/lisp/nxml/char-name/subdirs.el
new file mode 100644
index 00000000000..28d8936d890
--- /dev/null
+++ b/lisp/nxml/char-name/subdirs.el
@@ -0,0 +1,8 @@
+;; -*- no-byte-compile: t -*-
+;; In load-path, after this directory should come
+;; certain of its subdirectories.  Here we specify them.
+(normal-top-level-add-to-load-path '("unicode" ))
+;; Local Variables:
+;; version-control: never
+;; no-byte-compile: t
+;; End:
diff --git a/lisp/nxml/char-name/unicode/00000-0007F.el b/lisp/nxml/char-name/unicode/00000-0007F.el
new file mode 100644
index 00000000000..122804fc47a
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/00000-0007F.el
@@ -0,0 +1,97 @@
+(nxml-define-char-name-set 'basic-latin
+  '(("SPACE" #x0020)
+    ("EXCLAMATION MARK" #x0021)
+    ("QUOTATION MARK" #x0022)
+    ("NUMBER SIGN" #x0023)
+    ("DOLLAR SIGN" #x0024)
+    ("PERCENT SIGN" #x0025)
+    ("AMPERSAND" #x0026)
+    ("APOSTROPHE" #x0027)
+    ("LEFT PARENTHESIS" #x0028)
+    ("RIGHT PARENTHESIS" #x0029)
+    ("ASTERISK" #x002A)
+    ("PLUS SIGN" #x002B)
+    ("COMMA" #x002C)
+    ("HYPHEN-MINUS" #x002D)
+    ("FULL STOP" #x002E)
+    ("SOLIDUS" #x002F)
+    ("DIGIT ZERO" #x0030)
+    ("DIGIT ONE" #x0031)
+    ("DIGIT TWO" #x0032)
+    ("DIGIT THREE" #x0033)
+    ("DIGIT FOUR" #x0034)
+    ("DIGIT FIVE" #x0035)
+    ("DIGIT SIX" #x0036)
+    ("DIGIT SEVEN" #x0037)
+    ("DIGIT EIGHT" #x0038)
+    ("DIGIT NINE" #x0039)
+    ("COLON" #x003A)
+    ("SEMICOLON" #x003B)
+    ("LESS-THAN SIGN" #x003C)
+    ("EQUALS SIGN" #x003D)
+    ("GREATER-THAN SIGN" #x003E)
+    ("QUESTION MARK" #x003F)
+    ("COMMERCIAL AT" #x0040)
+    ("LATIN CAPITAL LETTER A" #x0041)
+    ("LATIN CAPITAL LETTER B" #x0042)
+    ("LATIN CAPITAL LETTER C" #x0043)
+    ("LATIN CAPITAL LETTER D" #x0044)
+    ("LATIN CAPITAL LETTER E" #x0045)
+    ("LATIN CAPITAL LETTER F" #x0046)
+    ("LATIN CAPITAL LETTER G" #x0047)
+    ("LATIN CAPITAL LETTER H" #x0048)
+    ("LATIN CAPITAL LETTER I" #x0049)
+    ("LATIN CAPITAL LETTER J" #x004A)
+    ("LATIN CAPITAL LETTER K" #x004B)
+    ("LATIN CAPITAL LETTER L" #x004C)
+    ("LATIN CAPITAL LETTER M" #x004D)
+    ("LATIN CAPITAL LETTER N" #x004E)
+    ("LATIN CAPITAL LETTER O" #x004F)
+    ("LATIN CAPITAL LETTER P" #x0050)
+    ("LATIN CAPITAL LETTER Q" #x0051)
+    ("LATIN CAPITAL LETTER R" #x0052)
+    ("LATIN CAPITAL LETTER S" #x0053)
+    ("LATIN CAPITAL LETTER T" #x0054)
+    ("LATIN CAPITAL LETTER U" #x0055)
+    ("LATIN CAPITAL LETTER V" #x0056)
+    ("LATIN CAPITAL LETTER W" #x0057)
+    ("LATIN CAPITAL LETTER X" #x0058)
+    ("LATIN CAPITAL LETTER Y" #x0059)
+    ("LATIN CAPITAL LETTER Z" #x005A)
+    ("LEFT SQUARE BRACKET" #x005B)
+    ("REVERSE SOLIDUS" #x005C)
+    ("RIGHT SQUARE BRACKET" #x005D)
+    ("CIRCUMFLEX ACCENT" #x005E)
+    ("LOW LINE" #x005F)
+    ("GRAVE ACCENT" #x0060)
+    ("LATIN SMALL LETTER A" #x0061)
+    ("LATIN SMALL LETTER B" #x0062)
+    ("LATIN SMALL LETTER C" #x0063)
+    ("LATIN SMALL LETTER D" #x0064)
+    ("LATIN SMALL LETTER E" #x0065)
+    ("LATIN SMALL LETTER F" #x0066)
+    ("LATIN SMALL LETTER G" #x0067)
+    ("LATIN SMALL LETTER H" #x0068)
+    ("LATIN SMALL LETTER I" #x0069)
+    ("LATIN SMALL LETTER J" #x006A)
+    ("LATIN SMALL LETTER K" #x006B)
+    ("LATIN SMALL LETTER L" #x006C)
+    ("LATIN SMALL LETTER M" #x006D)
+    ("LATIN SMALL LETTER N" #x006E)
+    ("LATIN SMALL LETTER O" #x006F)
+    ("LATIN SMALL LETTER P" #x0070)
+    ("LATIN SMALL LETTER Q" #x0071)
+    ("LATIN SMALL LETTER R" #x0072)
+    ("LATIN SMALL LETTER S" #x0073)
+    ("LATIN SMALL LETTER T" #x0074)
+    ("LATIN SMALL LETTER U" #x0075)
+    ("LATIN SMALL LETTER V" #x0076)
+    ("LATIN SMALL LETTER W" #x0077)
+    ("LATIN SMALL LETTER X" #x0078)
+    ("LATIN SMALL LETTER Y" #x0079)
+    ("LATIN SMALL LETTER Z" #x007A)
+    ("LEFT CURLY BRACKET" #x007B)
+    ("VERTICAL LINE" #x007C)
+    ("RIGHT CURLY BRACKET" #x007D)
+    ("TILDE" #x007E)
+    ))
diff --git a/lisp/nxml/char-name/unicode/00080-000FF.el b/lisp/nxml/char-name/unicode/00080-000FF.el
new file mode 100644
index 00000000000..1d7f463d56f
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/00080-000FF.el
@@ -0,0 +1,98 @@
+(nxml-define-char-name-set 'latin-1-supplement
+  '(("NO-BREAK SPACE" #x00A0)
+    ("INVERTED EXCLAMATION MARK" #x00A1)
+    ("CENT SIGN" #x00A2)
+    ("POUND SIGN" #x00A3)
+    ("CURRENCY SIGN" #x00A4)
+    ("YEN SIGN" #x00A5)
+    ("BROKEN BAR" #x00A6)
+    ("SECTION SIGN" #x00A7)
+    ("DIAERESIS" #x00A8)
+    ("COPYRIGHT SIGN" #x00A9)
+    ("FEMININE ORDINAL INDICATOR" #x00AA)
+    ("LEFT-POINTING DOUBLE ANGLE QUOTATION MARK" #x00AB)
+    ("NOT SIGN" #x00AC)
+    ("SOFT HYPHEN" #x00AD)
+    ("REGISTERED SIGN" #x00AE)
+    ("MACRON" #x00AF)
+    ("DEGREE SIGN" #x00B0)
+    ("PLUS-MINUS SIGN" #x00B1)
+    ("SUPERSCRIPT TWO" #x00B2)
+    ("SUPERSCRIPT THREE" #x00B3)
+    ("ACUTE ACCENT" #x00B4)
+    ("MICRO SIGN" #x00B5)
+    ("PILCROW SIGN" #x00B6)
+    ("MIDDLE DOT" #x00B7)
+    ("CEDILLA" #x00B8)
+    ("SUPERSCRIPT ONE" #x00B9)
+    ("MASCULINE ORDINAL INDICATOR" #x00BA)
+    ("RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK" #x00BB)
+    ("VULGAR FRACTION ONE QUARTER" #x00BC)
+    ("VULGAR FRACTION ONE HALF" #x00BD)
+    ("VULGAR FRACTION THREE QUARTERS" #x00BE)
+    ("INVERTED QUESTION MARK" #x00BF)
+    ("LATIN CAPITAL LETTER A WITH GRAVE" #x00C0)
+    ("LATIN CAPITAL LETTER A WITH ACUTE" #x00C1)
+    ("LATIN CAPITAL LETTER A WITH CIRCUMFLEX" #x00C2)
+    ("LATIN CAPITAL LETTER A WITH TILDE" #x00C3)
+    ("LATIN CAPITAL LETTER A WITH DIAERESIS" #x00C4)
+    ("LATIN CAPITAL LETTER A WITH RING ABOVE" #x00C5)
+    ("LATIN CAPITAL LETTER AE" #x00C6)
+    ("LATIN CAPITAL LETTER C WITH CEDILLA" #x00C7)
+    ("LATIN CAPITAL LETTER E WITH GRAVE" #x00C8)
+    ("LATIN CAPITAL LETTER E WITH ACUTE" #x00C9)
+    ("LATIN CAPITAL LETTER E WITH CIRCUMFLEX" #x00CA)
+    ("LATIN CAPITAL LETTER E WITH DIAERESIS" #x00CB)
+    ("LATIN CAPITAL LETTER I WITH GRAVE" #x00CC)
+    ("LATIN CAPITAL LETTER I WITH ACUTE" #x00CD)
+    ("LATIN CAPITAL LETTER I WITH CIRCUMFLEX" #x00CE)
+    ("LATIN CAPITAL LETTER I WITH DIAERESIS" #x00CF)
+    ("LATIN CAPITAL LETTER ETH" #x00D0)
+    ("LATIN CAPITAL LETTER N WITH TILDE" #x00D1)
+    ("LATIN CAPITAL LETTER O WITH GRAVE" #x00D2)
+    ("LATIN CAPITAL LETTER O WITH ACUTE" #x00D3)
+    ("LATIN CAPITAL LETTER O WITH CIRCUMFLEX" #x00D4)
+    ("LATIN CAPITAL LETTER O WITH TILDE" #x00D5)
+    ("LATIN CAPITAL LETTER O WITH DIAERESIS" #x00D6)
+    ("MULTIPLICATION SIGN" #x00D7)
+    ("LATIN CAPITAL LETTER O WITH STROKE" #x00D8)
+    ("LATIN CAPITAL LETTER U WITH GRAVE" #x00D9)
+    ("LATIN CAPITAL LETTER U WITH ACUTE" #x00DA)
+    ("LATIN CAPITAL LETTER U WITH CIRCUMFLEX" #x00DB)
+    ("LATIN CAPITAL LETTER U WITH DIAERESIS" #x00DC)
+    ("LATIN CAPITAL LETTER Y WITH ACUTE" #x00DD)
+    ("LATIN CAPITAL LETTER THORN" #x00DE)
+    ("LATIN SMALL LETTER SHARP S" #x00DF)
+    ("LATIN SMALL LETTER A WITH GRAVE" #x00E0)
+    ("LATIN SMALL LETTER A WITH ACUTE" #x00E1)
+    ("LATIN SMALL LETTER A WITH CIRCUMFLEX" #x00E2)
+    ("LATIN SMALL LETTER A WITH TILDE" #x00E3)
+    ("LATIN SMALL LETTER A WITH DIAERESIS" #x00E4)
+    ("LATIN SMALL LETTER A WITH RING ABOVE" #x00E5)
+    ("LATIN SMALL LETTER AE" #x00E6)
+    ("LATIN SMALL LETTER C WITH CEDILLA" #x00E7)
+    ("LATIN SMALL LETTER E WITH GRAVE" #x00E8)
+    ("LATIN SMALL LETTER E WITH ACUTE" #x00E9)
+    ("LATIN SMALL LETTER E WITH CIRCUMFLEX" #x00EA)
+    ("LATIN SMALL LETTER E WITH DIAERESIS" #x00EB)
+    ("LATIN SMALL LETTER I WITH GRAVE" #x00EC)
+    ("LATIN SMALL LETTER I WITH ACUTE" #x00ED)
+    ("LATIN SMALL LETTER I WITH CIRCUMFLEX" #x00EE)
+    ("LATIN SMALL LETTER I WITH DIAERESIS" #x00EF)
+    ("LATIN SMALL LETTER ETH" #x00F0)
+    ("LATIN SMALL LETTER N WITH TILDE" #x00F1)
+    ("LATIN SMALL LETTER O WITH GRAVE" #x00F2)
+    ("LATIN SMALL LETTER O WITH ACUTE" #x00F3)
+    ("LATIN SMALL LETTER O WITH CIRCUMFLEX" #x00F4)
+    ("LATIN SMALL LETTER O WITH TILDE" #x00F5)
+    ("LATIN SMALL LETTER O WITH DIAERESIS" #x00F6)
+    ("DIVISION SIGN" #x00F7)
+    ("LATIN SMALL LETTER O WITH STROKE" #x00F8)
+    ("LATIN SMALL LETTER U WITH GRAVE" #x00F9)
+    ("LATIN SMALL LETTER U WITH ACUTE" #x00FA)
+    ("LATIN SMALL LETTER U WITH CIRCUMFLEX" #x00FB)
+    ("LATIN SMALL LETTER U WITH DIAERESIS" #x00FC)
+    ("LATIN SMALL LETTER Y WITH ACUTE" #x00FD)
+    ("LATIN SMALL LETTER THORN" #x00FE)
+    ("LATIN SMALL LETTER Y WITH DIAERESIS" #x00FF)
+    ))
diff --git a/lisp/nxml/char-name/unicode/00100-0017F.el b/lisp/nxml/char-name/unicode/00100-0017F.el
new file mode 100644
index 00000000000..7a97964a161
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/00100-0017F.el
@@ -0,0 +1,130 @@
+(nxml-define-char-name-set 'latin-extended-a
+  '(("LATIN CAPITAL LETTER A WITH MACRON" #x0100)
+    ("LATIN SMALL LETTER A WITH MACRON" #x0101)
+    ("LATIN CAPITAL LETTER A WITH BREVE" #x0102)
+    ("LATIN SMALL LETTER A WITH BREVE" #x0103)
+    ("LATIN CAPITAL LETTER A WITH OGONEK" #x0104)
+    ("LATIN SMALL LETTER A WITH OGONEK" #x0105)
+    ("LATIN CAPITAL LETTER C WITH ACUTE" #x0106)
+    ("LATIN SMALL LETTER C WITH ACUTE" #x0107)
+    ("LATIN CAPITAL LETTER C WITH CIRCUMFLEX" #x0108)
+    ("LATIN SMALL LETTER C WITH CIRCUMFLEX" #x0109)
+    ("LATIN CAPITAL LETTER C WITH DOT ABOVE" #x010A)
+    ("LATIN SMALL LETTER C WITH DOT ABOVE" #x010B)
+    ("LATIN CAPITAL LETTER C WITH CARON" #x010C)
+    ("LATIN SMALL LETTER C WITH CARON" #x010D)
+    ("LATIN CAPITAL LETTER D WITH CARON" #x010E)
+    ("LATIN SMALL LETTER D WITH CARON" #x010F)
+    ("LATIN CAPITAL LETTER D WITH STROKE" #x0110)
+    ("LATIN SMALL LETTER D WITH STROKE" #x0111)
+    ("LATIN CAPITAL LETTER E WITH MACRON" #x0112)
+    ("LATIN SMALL LETTER E WITH MACRON" #x0113)
+    ("LATIN CAPITAL LETTER E WITH BREVE" #x0114)
+    ("LATIN SMALL LETTER E WITH BREVE" #x0115)
+    ("LATIN CAPITAL LETTER E WITH DOT ABOVE" #x0116)
+    ("LATIN SMALL LETTER E WITH DOT ABOVE" #x0117)
+    ("LATIN CAPITAL LETTER E WITH OGONEK" #x0118)
+    ("LATIN SMALL LETTER E WITH OGONEK" #x0119)
+    ("LATIN CAPITAL LETTER E WITH CARON" #x011A)
+    ("LATIN SMALL LETTER E WITH CARON" #x011B)
+    ("LATIN CAPITAL LETTER G WITH CIRCUMFLEX" #x011C)
+    ("LATIN SMALL LETTER G WITH CIRCUMFLEX" #x011D)
+    ("LATIN CAPITAL LETTER G WITH BREVE" #x011E)
+    ("LATIN SMALL LETTER G WITH BREVE" #x011F)
+    ("LATIN CAPITAL LETTER G WITH DOT ABOVE" #x0120)
+    ("LATIN SMALL LETTER G WITH DOT ABOVE" #x0121)
+    ("LATIN CAPITAL LETTER G WITH CEDILLA" #x0122)
+    ("LATIN SMALL LETTER G WITH CEDILLA" #x0123)
+    ("LATIN CAPITAL LETTER H WITH CIRCUMFLEX" #x0124)
+    ("LATIN SMALL LETTER H WITH CIRCUMFLEX" #x0125)
+    ("LATIN CAPITAL LETTER H WITH STROKE" #x0126)
+    ("LATIN SMALL LETTER H WITH STROKE" #x0127)
+    ("LATIN CAPITAL LETTER I WITH TILDE" #x0128)
+    ("LATIN SMALL LETTER I WITH TILDE" #x0129)
+    ("LATIN CAPITAL LETTER I WITH MACRON" #x012A)
+    ("LATIN SMALL LETTER I WITH MACRON" #x012B)
+    ("LATIN CAPITAL LETTER I WITH BREVE" #x012C)
+    ("LATIN SMALL LETTER I WITH BREVE" #x012D)
+    ("LATIN CAPITAL LETTER I WITH OGONEK" #x012E)
+    ("LATIN SMALL LETTER I WITH OGONEK" #x012F)
+    ("LATIN CAPITAL LETTER I WITH DOT ABOVE" #x0130)
+    ("LATIN SMALL LETTER DOTLESS I" #x0131)
+    ("LATIN CAPITAL LIGATURE IJ" #x0132)
+    ("LATIN SMALL LIGATURE IJ" #x0133)
+    ("LATIN CAPITAL LETTER J WITH CIRCUMFLEX" #x0134)
+    ("LATIN SMALL LETTER J WITH CIRCUMFLEX" #x0135)
+    ("LATIN CAPITAL LETTER K WITH CEDILLA" #x0136)
+    ("LATIN SMALL LETTER K WITH CEDILLA" #x0137)
+    ("LATIN SMALL LETTER KRA" #x0138)
+    ("LATIN CAPITAL LETTER L WITH ACUTE" #x0139)
+    ("LATIN SMALL LETTER L WITH ACUTE" #x013A)
+    ("LATIN CAPITAL LETTER L WITH CEDILLA" #x013B)
+    ("LATIN SMALL LETTER L WITH CEDILLA" #x013C)
+    ("LATIN CAPITAL LETTER L WITH CARON" #x013D)
+    ("LATIN SMALL LETTER L WITH CARON" #x013E)
+    ("LATIN CAPITAL LETTER L WITH MIDDLE DOT" #x013F)
+    ("LATIN SMALL LETTER L WITH MIDDLE DOT" #x0140)
+    ("LATIN CAPITAL LETTER L WITH STROKE" #x0141)
+    ("LATIN SMALL LETTER L WITH STROKE" #x0142)
+    ("LATIN CAPITAL LETTER N WITH ACUTE" #x0143)
+    ("LATIN SMALL LETTER N WITH ACUTE" #x0144)
+    ("LATIN CAPITAL LETTER N WITH CEDILLA" #x0145)
+    ("LATIN SMALL LETTER N WITH CEDILLA" #x0146)
+    ("LATIN CAPITAL LETTER N WITH CARON" #x0147)
+    ("LATIN SMALL LETTER N WITH CARON" #x0148)
+    ("LATIN SMALL LETTER N PRECEDED BY APOSTROPHE" #x0149)
+    ("LATIN CAPITAL LETTER ENG" #x014A)
+    ("LATIN SMALL LETTER ENG" #x014B)
+    ("LATIN CAPITAL LETTER O WITH MACRON" #x014C)
+    ("LATIN SMALL LETTER O WITH MACRON" #x014D)
+    ("LATIN CAPITAL LETTER O WITH BREVE" #x014E)
+    ("LATIN SMALL LETTER O WITH BREVE" #x014F)
+    ("LATIN CAPITAL LETTER O WITH DOUBLE ACUTE" #x0150)
+    ("LATIN SMALL LETTER O WITH DOUBLE ACUTE" #x0151)
+    ("LATIN CAPITAL LIGATURE OE" #x0152)
+    ("LATIN SMALL LIGATURE OE" #x0153)
+    ("LATIN CAPITAL LETTER R WITH ACUTE" #x0154)
+    ("LATIN SMALL LETTER R WITH ACUTE" #x0155)
+    ("LATIN CAPITAL LETTER R WITH CEDILLA" #x0156)
+    ("LATIN SMALL LETTER R WITH CEDILLA" #x0157)
+    ("LATIN CAPITAL LETTER R WITH CARON" #x0158)
+    ("LATIN SMALL LETTER R WITH CARON" #x0159)
+    ("LATIN CAPITAL LETTER S WITH ACUTE" #x015A)
+    ("LATIN SMALL LETTER S WITH ACUTE" #x015B)
+    ("LATIN CAPITAL LETTER S WITH CIRCUMFLEX" #x015C)
+    ("LATIN SMALL LETTER S WITH CIRCUMFLEX" #x015D)
+    ("LATIN CAPITAL LETTER S WITH CEDILLA" #x015E)
+    ("LATIN SMALL LETTER S WITH CEDILLA" #x015F)
+    ("LATIN CAPITAL LETTER S WITH CARON" #x0160)
+    ("LATIN SMALL LETTER S WITH CARON" #x0161)
+    ("LATIN CAPITAL LETTER T WITH CEDILLA" #x0162)
+    ("LATIN SMALL LETTER T WITH CEDILLA" #x0163)
+    ("LATIN CAPITAL LETTER T WITH CARON" #x0164)
+    ("LATIN SMALL LETTER T WITH CARON" #x0165)
+    ("LATIN CAPITAL LETTER T WITH STROKE" #x0166)
+    ("LATIN SMALL LETTER T WITH STROKE" #x0167)
+    ("LATIN CAPITAL LETTER U WITH TILDE" #x0168)
+    ("LATIN SMALL LETTER U WITH TILDE" #x0169)
+    ("LATIN CAPITAL LETTER U WITH MACRON" #x016A)
+    ("LATIN SMALL LETTER U WITH MACRON" #x016B)
+    ("LATIN CAPITAL LETTER U WITH BREVE" #x016C)
+    ("LATIN SMALL LETTER U WITH BREVE" #x016D)
+    ("LATIN CAPITAL LETTER U WITH RING ABOVE" #x016E)
+    ("LATIN SMALL LETTER U WITH RING ABOVE" #x016F)
+    ("LATIN CAPITAL LETTER U WITH DOUBLE ACUTE" #x0170)
+    ("LATIN SMALL LETTER U WITH DOUBLE ACUTE" #x0171)
+    ("LATIN CAPITAL LETTER U WITH OGONEK" #x0172)
+    ("LATIN SMALL LETTER U WITH OGONEK" #x0173)
+    ("LATIN CAPITAL LETTER W WITH CIRCUMFLEX" #x0174)
+    ("LATIN SMALL LETTER W WITH CIRCUMFLEX" #x0175)
+    ("LATIN CAPITAL LETTER Y WITH CIRCUMFLEX" #x0176)
+    ("LATIN SMALL LETTER Y WITH CIRCUMFLEX" #x0177)
+    ("LATIN CAPITAL LETTER Y WITH DIAERESIS" #x0178)
+    ("LATIN CAPITAL LETTER Z WITH ACUTE" #x0179)
+    ("LATIN SMALL LETTER Z WITH ACUTE" #x017A)
+    ("LATIN CAPITAL LETTER Z WITH DOT ABOVE" #x017B)
+    ("LATIN SMALL LETTER Z WITH DOT ABOVE" #x017C)
+    ("LATIN CAPITAL LETTER Z WITH CARON" #x017D)
+    ("LATIN SMALL LETTER Z WITH CARON" #x017E)
+    ("LATIN SMALL LETTER LONG S" #x017F)
+    ))
diff --git a/lisp/nxml/char-name/unicode/00180-0024F.el b/lisp/nxml/char-name/unicode/00180-0024F.el
new file mode 100644
index 00000000000..6a6a7ff3c18
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/00180-0024F.el
@@ -0,0 +1,181 @@
+(nxml-define-char-name-set 'latin-extended-b
+  '(("LATIN SMALL LETTER B WITH STROKE" #x0180)
+    ("LATIN CAPITAL LETTER B WITH HOOK" #x0181)
+    ("LATIN CAPITAL LETTER B WITH TOPBAR" #x0182)
+    ("LATIN SMALL LETTER B WITH TOPBAR" #x0183)
+    ("LATIN CAPITAL LETTER TONE SIX" #x0184)
+    ("LATIN SMALL LETTER TONE SIX" #x0185)
+    ("LATIN CAPITAL LETTER OPEN O" #x0186)
+    ("LATIN CAPITAL LETTER C WITH HOOK" #x0187)
+    ("LATIN SMALL LETTER C WITH HOOK" #x0188)
+    ("LATIN CAPITAL LETTER AFRICAN D" #x0189)
+    ("LATIN CAPITAL LETTER D WITH HOOK" #x018A)
+    ("LATIN CAPITAL LETTER D WITH TOPBAR" #x018B)
+    ("LATIN SMALL LETTER D WITH TOPBAR" #x018C)
+    ("LATIN SMALL LETTER TURNED DELTA" #x018D)
+    ("LATIN CAPITAL LETTER REVERSED E" #x018E)
+    ("LATIN CAPITAL LETTER SCHWA" #x018F)
+    ("LATIN CAPITAL LETTER OPEN E" #x0190)
+    ("LATIN CAPITAL LETTER F WITH HOOK" #x0191)
+    ("LATIN SMALL LETTER F WITH HOOK" #x0192)
+    ("LATIN CAPITAL LETTER G WITH HOOK" #x0193)
+    ("LATIN CAPITAL LETTER GAMMA" #x0194)
+    ("LATIN SMALL LETTER HV" #x0195)
+    ("LATIN CAPITAL LETTER IOTA" #x0196)
+    ("LATIN CAPITAL LETTER I WITH STROKE" #x0197)
+    ("LATIN CAPITAL LETTER K WITH HOOK" #x0198)
+    ("LATIN SMALL LETTER K WITH HOOK" #x0199)
+    ("LATIN SMALL LETTER L WITH BAR" #x019A)
+    ("LATIN SMALL LETTER LAMBDA WITH STROKE" #x019B)
+    ("LATIN CAPITAL LETTER TURNED M" #x019C)
+    ("LATIN CAPITAL LETTER N WITH LEFT HOOK" #x019D)
+    ("LATIN SMALL LETTER N WITH LONG RIGHT LEG" #x019E)
+    ("LATIN CAPITAL LETTER O WITH MIDDLE TILDE" #x019F)
+    ("LATIN CAPITAL LETTER O WITH HORN" #x01A0)
+    ("LATIN SMALL LETTER O WITH HORN" #x01A1)
+    ("LATIN CAPITAL LETTER OI" #x01A2)
+    ("LATIN SMALL LETTER OI" #x01A3)
+    ("LATIN CAPITAL LETTER P WITH HOOK" #x01A4)
+    ("LATIN SMALL LETTER P WITH HOOK" #x01A5)
+    ("LATIN LETTER YR" #x01A6)
+    ("LATIN CAPITAL LETTER TONE TWO" #x01A7)
+    ("LATIN SMALL LETTER TONE TWO" #x01A8)
+    ("LATIN CAPITAL LETTER ESH" #x01A9)
+    ("LATIN LETTER REVERSED ESH LOOP" #x01AA)
+    ("LATIN SMALL LETTER T WITH PALATAL HOOK" #x01AB)
+    ("LATIN CAPITAL LETTER T WITH HOOK" #x01AC)
+    ("LATIN SMALL LETTER T WITH HOOK" #x01AD)
+    ("LATIN CAPITAL LETTER T WITH RETROFLEX HOOK" #x01AE)
+    ("LATIN CAPITAL LETTER U WITH HORN" #x01AF)
+    ("LATIN SMALL LETTER U WITH HORN" #x01B0)
+    ("LATIN CAPITAL LETTER UPSILON" #x01B1)
+    ("LATIN CAPITAL LETTER V WITH HOOK" #x01B2)
+    ("LATIN CAPITAL LETTER Y WITH HOOK" #x01B3)
+    ("LATIN SMALL LETTER Y WITH HOOK" #x01B4)
+    ("LATIN CAPITAL LETTER Z WITH STROKE" #x01B5)
+    ("LATIN SMALL LETTER Z WITH STROKE" #x01B6)
+    ("LATIN CAPITAL LETTER EZH" #x01B7)
+    ("LATIN CAPITAL LETTER EZH REVERSED" #x01B8)
+    ("LATIN SMALL LETTER EZH REVERSED" #x01B9)
+    ("LATIN SMALL LETTER EZH WITH TAIL" #x01BA)
+    ("LATIN LETTER TWO WITH STROKE" #x01BB)
+    ("LATIN CAPITAL LETTER TONE FIVE" #x01BC)
+    ("LATIN SMALL LETTER TONE FIVE" #x01BD)
+    ("LATIN LETTER INVERTED GLOTTAL STOP WITH STROKE" #x01BE)
+    ("LATIN LETTER WYNN" #x01BF)
+    ("LATIN LETTER DENTAL CLICK" #x01C0)
+    ("LATIN LETTER LATERAL CLICK" #x01C1)
+    ("LATIN LETTER ALVEOLAR CLICK" #x01C2)
+    ("LATIN LETTER RETROFLEX CLICK" #x01C3)
+    ("LATIN CAPITAL LETTER DZ WITH CARON" #x01C4)
+    ("LATIN CAPITAL LETTER D WITH SMALL LETTER Z WITH CARON" #x01C5)
+    ("LATIN SMALL LETTER DZ WITH CARON" #x01C6)
+    ("LATIN CAPITAL LETTER LJ" #x01C7)
+    ("LATIN CAPITAL LETTER L WITH SMALL LETTER J" #x01C8)
+    ("LATIN SMALL LETTER LJ" #x01C9)
+    ("LATIN CAPITAL LETTER NJ" #x01CA)
+    ("LATIN CAPITAL LETTER N WITH SMALL LETTER J" #x01CB)
+    ("LATIN SMALL LETTER NJ" #x01CC)
+    ("LATIN CAPITAL LETTER A WITH CARON" #x01CD)
+    ("LATIN SMALL LETTER A WITH CARON" #x01CE)
+    ("LATIN CAPITAL LETTER I WITH CARON" #x01CF)
+    ("LATIN SMALL LETTER I WITH CARON" #x01D0)
+    ("LATIN CAPITAL LETTER O WITH CARON" #x01D1)
+    ("LATIN SMALL LETTER O WITH CARON" #x01D2)
+    ("LATIN CAPITAL LETTER U WITH CARON" #x01D3)
+    ("LATIN SMALL LETTER U WITH CARON" #x01D4)
+    ("LATIN CAPITAL LETTER U WITH DIAERESIS AND MACRON" #x01D5)
+    ("LATIN SMALL LETTER U WITH DIAERESIS AND MACRON" #x01D6)
+    ("LATIN CAPITAL LETTER U WITH DIAERESIS AND ACUTE" #x01D7)
+    ("LATIN SMALL LETTER U WITH DIAERESIS AND ACUTE" #x01D8)
+    ("LATIN CAPITAL LETTER U WITH DIAERESIS AND CARON" #x01D9)
+    ("LATIN SMALL LETTER U WITH DIAERESIS AND CARON" #x01DA)
+    ("LATIN CAPITAL LETTER U WITH DIAERESIS AND GRAVE" #x01DB)
+    ("LATIN SMALL LETTER U WITH DIAERESIS AND GRAVE" #x01DC)
+    ("LATIN SMALL LETTER TURNED E" #x01DD)
+    ("LATIN CAPITAL LETTER A WITH DIAERESIS AND MACRON" #x01DE)
+    ("LATIN SMALL LETTER A WITH DIAERESIS AND MACRON" #x01DF)
+    ("LATIN CAPITAL LETTER A WITH DOT ABOVE AND MACRON" #x01E0)
+    ("LATIN SMALL LETTER A WITH DOT ABOVE AND MACRON" #x01E1)
+    ("LATIN CAPITAL LETTER AE WITH MACRON" #x01E2)
+    ("LATIN SMALL LETTER AE WITH MACRON" #x01E3)
+    ("LATIN CAPITAL LETTER G WITH STROKE" #x01E4)
+    ("LATIN SMALL LETTER G WITH STROKE" #x01E5)
+    ("LATIN CAPITAL LETTER G WITH CARON" #x01E6)
+    ("LATIN SMALL LETTER G WITH CARON" #x01E7)
+    ("LATIN CAPITAL LETTER K WITH CARON" #x01E8)
+    ("LATIN SMALL LETTER K WITH CARON" #x01E9)
+    ("LATIN CAPITAL LETTER O WITH OGONEK" #x01EA)
+    ("LATIN SMALL LETTER O WITH OGONEK" #x01EB)
+    ("LATIN CAPITAL LETTER O WITH OGONEK AND MACRON" #x01EC)
+    ("LATIN SMALL LETTER O WITH OGONEK AND MACRON" #x01ED)
+    ("LATIN CAPITAL LETTER EZH WITH CARON" #x01EE)
+    ("LATIN SMALL LETTER EZH WITH CARON" #x01EF)
+    ("LATIN SMALL LETTER J WITH CARON" #x01F0)
+    ("LATIN CAPITAL LETTER DZ" #x01F1)
+    ("LATIN CAPITAL LETTER D WITH SMALL LETTER Z" #x01F2)
+    ("LATIN SMALL LETTER DZ" #x01F3)
+    ("LATIN CAPITAL LETTER G WITH ACUTE" #x01F4)
+    ("LATIN SMALL LETTER G WITH ACUTE" #x01F5)
+    ("LATIN CAPITAL LETTER HWAIR" #x01F6)
+    ("LATIN CAPITAL LETTER WYNN" #x01F7)
+    ("LATIN CAPITAL LETTER N WITH GRAVE" #x01F8)
+    ("LATIN SMALL LETTER N WITH GRAVE" #x01F9)
+    ("LATIN CAPITAL LETTER A WITH RING ABOVE AND ACUTE" #x01FA)
+    ("LATIN SMALL LETTER A WITH RING ABOVE AND ACUTE" #x01FB)
+    ("LATIN CAPITAL LETTER AE WITH ACUTE" #x01FC)
+    ("LATIN SMALL LETTER AE WITH ACUTE" #x01FD)
+    ("LATIN CAPITAL LETTER O WITH STROKE AND ACUTE" #x01FE)
+    ("LATIN SMALL LETTER O WITH STROKE AND ACUTE" #x01FF)
+    ("LATIN CAPITAL LETTER A WITH DOUBLE GRAVE" #x0200)
+    ("LATIN SMALL LETTER A WITH DOUBLE GRAVE" #x0201)
+    ("LATIN CAPITAL LETTER A WITH INVERTED BREVE" #x0202)
+    ("LATIN SMALL LETTER A WITH INVERTED BREVE" #x0203)
+    ("LATIN CAPITAL LETTER E WITH DOUBLE GRAVE" #x0204)
+    ("LATIN SMALL LETTER E WITH DOUBLE GRAVE" #x0205)
+    ("LATIN CAPITAL LETTER E WITH INVERTED BREVE" #x0206)
+    ("LATIN SMALL LETTER E WITH INVERTED BREVE" #x0207)
+    ("LATIN CAPITAL LETTER I WITH DOUBLE GRAVE" #x0208)
+    ("LATIN SMALL LETTER I WITH DOUBLE GRAVE" #x0209)
+    ("LATIN CAPITAL LETTER I WITH INVERTED BREVE" #x020A)
+    ("LATIN SMALL LETTER I WITH INVERTED BREVE" #x020B)
+    ("LATIN CAPITAL LETTER O WITH DOUBLE GRAVE" #x020C)
+    ("LATIN SMALL LETTER O WITH DOUBLE GRAVE" #x020D)
+    ("LATIN CAPITAL LETTER O WITH INVERTED BREVE" #x020E)
+    ("LATIN SMALL LETTER O WITH INVERTED BREVE" #x020F)
+    ("LATIN CAPITAL LETTER R WITH DOUBLE GRAVE" #x0210)
+    ("LATIN SMALL LETTER R WITH DOUBLE GRAVE" #x0211)
+    ("LATIN CAPITAL LETTER R WITH INVERTED BREVE" #x0212)
+    ("LATIN SMALL LETTER R WITH INVERTED BREVE" #x0213)
+    ("LATIN CAPITAL LETTER U WITH DOUBLE GRAVE" #x0214)
+    ("LATIN SMALL LETTER U WITH DOUBLE GRAVE" #x0215)
+    ("LATIN CAPITAL LETTER U WITH INVERTED BREVE" #x0216)
+    ("LATIN SMALL LETTER U WITH INVERTED BREVE" #x0217)
+    ("LATIN CAPITAL LETTER S WITH COMMA BELOW" #x0218)
+    ("LATIN SMALL LETTER S WITH COMMA BELOW" #x0219)
+    ("LATIN CAPITAL LETTER T WITH COMMA BELOW" #x021A)
+    ("LATIN SMALL LETTER T WITH COMMA BELOW" #x021B)
+    ("LATIN CAPITAL LETTER YOGH" #x021C)
+    ("LATIN SMALL LETTER YOGH" #x021D)
+    ("LATIN CAPITAL LETTER H WITH CARON" #x021E)
+    ("LATIN SMALL LETTER H WITH CARON" #x021F)
+    ("LATIN CAPITAL LETTER N WITH LONG RIGHT LEG" #x0220)
+    ("LATIN CAPITAL LETTER OU" #x0222)
+    ("LATIN SMALL LETTER OU" #x0223)
+    ("LATIN CAPITAL LETTER Z WITH HOOK" #x0224)
+    ("LATIN SMALL LETTER Z WITH HOOK" #x0225)
+    ("LATIN CAPITAL LETTER A WITH DOT ABOVE" #x0226)
+    ("LATIN SMALL LETTER A WITH DOT ABOVE" #x0227)
+    ("LATIN CAPITAL LETTER E WITH CEDILLA" #x0228)
+    ("LATIN SMALL LETTER E WITH CEDILLA" #x0229)
+    ("LATIN CAPITAL LETTER O WITH DIAERESIS AND MACRON" #x022A)
+    ("LATIN SMALL LETTER O WITH DIAERESIS AND MACRON" #x022B)
+    ("LATIN CAPITAL LETTER O WITH TILDE AND MACRON" #x022C)
+    ("LATIN SMALL LETTER O WITH TILDE AND MACRON" #x022D)
+    ("LATIN CAPITAL LETTER O WITH DOT ABOVE" #x022E)
+    ("LATIN SMALL LETTER O WITH DOT ABOVE" #x022F)
+    ("LATIN CAPITAL LETTER O WITH DOT ABOVE AND MACRON" #x0230)
+    ("LATIN SMALL LETTER O WITH DOT ABOVE AND MACRON" #x0231)
+    ("LATIN CAPITAL LETTER Y WITH MACRON" #x0232)
+    ("LATIN SMALL LETTER Y WITH MACRON" #x0233)
+    ))
diff --git a/lisp/nxml/char-name/unicode/00250-002AF.el b/lisp/nxml/char-name/unicode/00250-002AF.el
new file mode 100644
index 00000000000..84814214f50
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/00250-002AF.el
@@ -0,0 +1,96 @@
+(nxml-define-char-name-set 'ipa-extensions
+  '(("LATIN SMALL LETTER TURNED A" #x0250)
+    ("LATIN SMALL LETTER ALPHA" #x0251)
+    ("LATIN SMALL LETTER TURNED ALPHA" #x0252)
+    ("LATIN SMALL LETTER B WITH HOOK" #x0253)
+    ("LATIN SMALL LETTER OPEN O" #x0254)
+    ("LATIN SMALL LETTER C WITH CURL" #x0255)
+    ("LATIN SMALL LETTER D WITH TAIL" #x0256)
+    ("LATIN SMALL LETTER D WITH HOOK" #x0257)
+    ("LATIN SMALL LETTER REVERSED E" #x0258)
+    ("LATIN SMALL LETTER SCHWA" #x0259)
+    ("LATIN SMALL LETTER SCHWA WITH HOOK" #x025A)
+    ("LATIN SMALL LETTER OPEN E" #x025B)
+    ("LATIN SMALL LETTER REVERSED OPEN E" #x025C)
+    ("LATIN SMALL LETTER REVERSED OPEN E WITH HOOK" #x025D)
+    ("LATIN SMALL LETTER CLOSED REVERSED OPEN E" #x025E)
+    ("LATIN SMALL LETTER DOTLESS J WITH STROKE" #x025F)
+    ("LATIN SMALL LETTER G WITH HOOK" #x0260)
+    ("LATIN SMALL LETTER SCRIPT G" #x0261)
+    ("LATIN LETTER SMALL CAPITAL G" #x0262)
+    ("LATIN SMALL LETTER GAMMA" #x0263)
+    ("LATIN SMALL LETTER RAMS HORN" #x0264)
+    ("LATIN SMALL LETTER TURNED H" #x0265)
+    ("LATIN SMALL LETTER H WITH HOOK" #x0266)
+    ("LATIN SMALL LETTER HENG WITH HOOK" #x0267)
+    ("LATIN SMALL LETTER I WITH STROKE" #x0268)
+    ("LATIN SMALL LETTER IOTA" #x0269)
+    ("LATIN LETTER SMALL CAPITAL I" #x026A)
+    ("LATIN SMALL LETTER L WITH MIDDLE TILDE" #x026B)
+    ("LATIN SMALL LETTER L WITH BELT" #x026C)
+    ("LATIN SMALL LETTER L WITH RETROFLEX HOOK" #x026D)
+    ("LATIN SMALL LETTER LEZH" #x026E)
+    ("LATIN SMALL LETTER TURNED M" #x026F)
+    ("LATIN SMALL LETTER TURNED M WITH LONG LEG" #x0270)
+    ("LATIN SMALL LETTER M WITH HOOK" #x0271)
+    ("LATIN SMALL LETTER N WITH LEFT HOOK" #x0272)
+    ("LATIN SMALL LETTER N WITH RETROFLEX HOOK" #x0273)
+    ("LATIN LETTER SMALL CAPITAL N" #x0274)
+    ("LATIN SMALL LETTER BARRED O" #x0275)
+    ("LATIN LETTER SMALL CAPITAL OE" #x0276)
+    ("LATIN SMALL LETTER CLOSED OMEGA" #x0277)
+    ("LATIN SMALL LETTER PHI" #x0278)
+    ("LATIN SMALL LETTER TURNED R" #x0279)
+    ("LATIN SMALL LETTER TURNED R WITH LONG LEG" #x027A)
+    ("LATIN SMALL LETTER TURNED R WITH HOOK" #x027B)
+    ("LATIN SMALL LETTER R WITH LONG LEG" #x027C)
+    ("LATIN SMALL LETTER R WITH TAIL" #x027D)
+    ("LATIN SMALL LETTER R WITH FISHHOOK" #x027E)
+    ("LATIN SMALL LETTER REVERSED R WITH FISHHOOK" #x027F)
+    ("LATIN LETTER SMALL CAPITAL R" #x0280)
+    ("LATIN LETTER SMALL CAPITAL INVERTED R" #x0281)
+    ("LATIN SMALL LETTER S WITH HOOK" #x0282)
+    ("LATIN SMALL LETTER ESH" #x0283)
+    ("LATIN SMALL LETTER DOTLESS J WITH STROKE AND HOOK" #x0284)
+    ("LATIN SMALL LETTER SQUAT REVERSED ESH" #x0285)
+    ("LATIN SMALL LETTER ESH WITH CURL" #x0286)
+    ("LATIN SMALL LETTER TURNED T" #x0287)
+    ("LATIN SMALL LETTER T WITH RETROFLEX HOOK" #x0288)
+    ("LATIN SMALL LETTER U BAR" #x0289)
+    ("LATIN SMALL LETTER UPSILON" #x028A)
+    ("LATIN SMALL LETTER V WITH HOOK" #x028B)
+    ("LATIN SMALL LETTER TURNED V" #x028C)
+    ("LATIN SMALL LETTER TURNED W" #x028D)
+    ("LATIN SMALL LETTER TURNED Y" #x028E)
+    ("LATIN LETTER SMALL CAPITAL Y" #x028F)
+    ("LATIN SMALL LETTER Z WITH RETROFLEX HOOK" #x0290)
+    ("LATIN SMALL LETTER Z WITH CURL" #x0291)
+    ("LATIN SMALL LETTER EZH" #x0292)
+    ("LATIN SMALL LETTER EZH WITH CURL" #x0293)
+    ("LATIN LETTER GLOTTAL STOP" #x0294)
+    ("LATIN LETTER PHARYNGEAL VOICED FRICATIVE" #x0295)
+    ("LATIN LETTER INVERTED GLOTTAL STOP" #x0296)
+    ("LATIN LETTER STRETCHED C" #x0297)
+    ("LATIN LETTER BILABIAL CLICK" #x0298)
+    ("LATIN LETTER SMALL CAPITAL B" #x0299)
+    ("LATIN SMALL LETTER CLOSED OPEN E" #x029A)
+    ("LATIN LETTER SMALL CAPITAL G WITH HOOK" #x029B)
+    ("LATIN LETTER SMALL CAPITAL H" #x029C)
+    ("LATIN SMALL LETTER J WITH CROSSED-TAIL" #x029D)
+    ("LATIN SMALL LETTER TURNED K" #x029E)
+    ("LATIN LETTER SMALL CAPITAL L" #x029F)
+    ("LATIN SMALL LETTER Q WITH HOOK" #x02A0)
+    ("LATIN LETTER GLOTTAL STOP WITH STROKE" #x02A1)
+    ("LATIN LETTER REVERSED GLOTTAL STOP WITH STROKE" #x02A2)
+    ("LATIN SMALL LETTER DZ DIGRAPH" #x02A3)
+    ("LATIN SMALL LETTER DEZH DIGRAPH" #x02A4)
+    ("LATIN SMALL LETTER DZ DIGRAPH WITH CURL" #x02A5)
+    ("LATIN SMALL LETTER TS DIGRAPH" #x02A6)
+    ("LATIN SMALL LETTER TESH DIGRAPH" #x02A7)
+    ("LATIN SMALL LETTER TC DIGRAPH WITH CURL" #x02A8)
+    ("LATIN SMALL LETTER FENG DIGRAPH" #x02A9)
+    ("LATIN SMALL LETTER LS DIGRAPH" #x02AA)
+    ("LATIN SMALL LETTER LZ DIGRAPH" #x02AB)
+    ("LATIN LETTER BILABIAL PERCUSSIVE" #x02AC)
+    ("LATIN LETTER BIDENTAL PERCUSSIVE" #x02AD)
+    ))
diff --git a/lisp/nxml/char-name/unicode/002B0-002FF.el b/lisp/nxml/char-name/unicode/002B0-002FF.el
new file mode 100644
index 00000000000..4f74699d76e
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/002B0-002FF.el
@@ -0,0 +1,65 @@
+(nxml-define-char-name-set 'spacing-modifier-letters
+  '(("MODIFIER LETTER SMALL H" #x02B0)
+    ("MODIFIER LETTER SMALL H WITH HOOK" #x02B1)
+    ("MODIFIER LETTER SMALL J" #x02B2)
+    ("MODIFIER LETTER SMALL R" #x02B3)
+    ("MODIFIER LETTER SMALL TURNED R" #x02B4)
+    ("MODIFIER LETTER SMALL TURNED R WITH HOOK" #x02B5)
+    ("MODIFIER LETTER SMALL CAPITAL INVERTED R" #x02B6)
+    ("MODIFIER LETTER SMALL W" #x02B7)
+    ("MODIFIER LETTER SMALL Y" #x02B8)
+    ("MODIFIER LETTER PRIME" #x02B9)
+    ("MODIFIER LETTER DOUBLE PRIME" #x02BA)
+    ("MODIFIER LETTER TURNED COMMA" #x02BB)
+    ("MODIFIER LETTER APOSTROPHE" #x02BC)
+    ("MODIFIER LETTER REVERSED COMMA" #x02BD)
+    ("MODIFIER LETTER RIGHT HALF RING" #x02BE)
+    ("MODIFIER LETTER LEFT HALF RING" #x02BF)
+    ("MODIFIER LETTER GLOTTAL STOP" #x02C0)
+    ("MODIFIER LETTER REVERSED GLOTTAL STOP" #x02C1)
+    ("MODIFIER LETTER LEFT ARROWHEAD" #x02C2)
+    ("MODIFIER LETTER RIGHT ARROWHEAD" #x02C3)
+    ("MODIFIER LETTER UP ARROWHEAD" #x02C4)
+    ("MODIFIER LETTER DOWN ARROWHEAD" #x02C5)
+    ("MODIFIER LETTER CIRCUMFLEX ACCENT" #x02C6)
+    ("CARON" #x02C7)
+    ("MODIFIER LETTER VERTICAL LINE" #x02C8)
+    ("MODIFIER LETTER MACRON" #x02C9)
+    ("MODIFIER LETTER ACUTE ACCENT" #x02CA)
+    ("MODIFIER LETTER GRAVE ACCENT" #x02CB)
+    ("MODIFIER LETTER LOW VERTICAL LINE" #x02CC)
+    ("MODIFIER LETTER LOW MACRON" #x02CD)
+    ("MODIFIER LETTER LOW GRAVE ACCENT" #x02CE)
+    ("MODIFIER LETTER LOW ACUTE ACCENT" #x02CF)
+    ("MODIFIER LETTER TRIANGULAR COLON" #x02D0)
+    ("MODIFIER LETTER HALF TRIANGULAR COLON" #x02D1)
+    ("MODIFIER LETTER CENTRED RIGHT HALF RING" #x02D2)
+    ("MODIFIER LETTER CENTRED LEFT HALF RING" #x02D3)
+    ("MODIFIER LETTER UP TACK" #x02D4)
+    ("MODIFIER LETTER DOWN TACK" #x02D5)
+    ("MODIFIER LETTER PLUS SIGN" #x02D6)
+    ("MODIFIER LETTER MINUS SIGN" #x02D7)
+    ("BREVE" #x02D8)
+    ("DOT ABOVE" #x02D9)
+    ("RING ABOVE" #x02DA)
+    ("OGONEK" #x02DB)
+    ("SMALL TILDE" #x02DC)
+    ("DOUBLE ACUTE ACCENT" #x02DD)
+    ("MODIFIER LETTER RHOTIC HOOK" #x02DE)
+    ("MODIFIER LETTER CROSS ACCENT" #x02DF)
+    ("MODIFIER LETTER SMALL GAMMA" #x02E0)
+    ("MODIFIER LETTER SMALL L" #x02E1)
+    ("MODIFIER LETTER SMALL S" #x02E2)
+    ("MODIFIER LETTER SMALL X" #x02E3)
+    ("MODIFIER LETTER SMALL REVERSED GLOTTAL STOP" #x02E4)
+    ("MODIFIER LETTER EXTRA-HIGH TONE BAR" #x02E5)
+    ("MODIFIER LETTER HIGH TONE BAR" #x02E6)
+    ("MODIFIER LETTER MID TONE BAR" #x02E7)
+    ("MODIFIER LETTER LOW TONE BAR" #x02E8)
+    ("MODIFIER LETTER EXTRA-LOW TONE BAR" #x02E9)
+    ("MODIFIER LETTER YIN DEPARTING TONE MARK" #x02EA)
+    ("MODIFIER LETTER YANG DEPARTING TONE MARK" #x02EB)
+    ("MODIFIER LETTER VOICING" #x02EC)
+    ("MODIFIER LETTER UNASPIRATED" #x02ED)
+    ("MODIFIER LETTER DOUBLE APOSTROPHE" #x02EE)
+    ))
diff --git a/lisp/nxml/char-name/unicode/00300-0036F.el b/lisp/nxml/char-name/unicode/00300-0036F.el
new file mode 100644
index 00000000000..33e9627d92e
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/00300-0036F.el
@@ -0,0 +1,98 @@
+(nxml-define-char-name-set 'combining-diacritical-marks
+  '(("COMBINING GRAVE ACCENT" #x0300)
+    ("COMBINING ACUTE ACCENT" #x0301)
+    ("COMBINING CIRCUMFLEX ACCENT" #x0302)
+    ("COMBINING TILDE" #x0303)
+    ("COMBINING MACRON" #x0304)
+    ("COMBINING OVERLINE" #x0305)
+    ("COMBINING BREVE" #x0306)
+    ("COMBINING DOT ABOVE" #x0307)
+    ("COMBINING DIAERESIS" #x0308)
+    ("COMBINING HOOK ABOVE" #x0309)
+    ("COMBINING RING ABOVE" #x030A)
+    ("COMBINING DOUBLE ACUTE ACCENT" #x030B)
+    ("COMBINING CARON" #x030C)
+    ("COMBINING VERTICAL LINE ABOVE" #x030D)
+    ("COMBINING DOUBLE VERTICAL LINE ABOVE" #x030E)
+    ("COMBINING DOUBLE GRAVE ACCENT" #x030F)
+    ("COMBINING CANDRABINDU" #x0310)
+    ("COMBINING INVERTED BREVE" #x0311)
+    ("COMBINING TURNED COMMA ABOVE" #x0312)
+    ("COMBINING COMMA ABOVE" #x0313)
+    ("COMBINING REVERSED COMMA ABOVE" #x0314)
+    ("COMBINING COMMA ABOVE RIGHT" #x0315)
+    ("COMBINING GRAVE ACCENT BELOW" #x0316)
+    ("COMBINING ACUTE ACCENT BELOW" #x0317)
+    ("COMBINING LEFT TACK BELOW" #x0318)
+    ("COMBINING RIGHT TACK BELOW" #x0319)
+    ("COMBINING LEFT ANGLE ABOVE" #x031A)
+    ("COMBINING HORN" #x031B)
+    ("COMBINING LEFT HALF RING BELOW" #x031C)
+    ("COMBINING UP TACK BELOW" #x031D)
+    ("COMBINING DOWN TACK BELOW" #x031E)
+    ("COMBINING PLUS SIGN BELOW" #x031F)
+    ("COMBINING MINUS SIGN BELOW" #x0320)
+    ("COMBINING PALATALIZED HOOK BELOW" #x0321)
+    ("COMBINING RETROFLEX HOOK BELOW" #x0322)
+    ("COMBINING DOT BELOW" #x0323)
+    ("COMBINING DIAERESIS BELOW" #x0324)
+    ("COMBINING RING BELOW" #x0325)
+    ("COMBINING COMMA BELOW" #x0326)
+    ("COMBINING CEDILLA" #x0327)
+    ("COMBINING OGONEK" #x0328)
+    ("COMBINING VERTICAL LINE BELOW" #x0329)
+    ("COMBINING BRIDGE BELOW" #x032A)
+    ("COMBINING INVERTED DOUBLE ARCH BELOW" #x032B)
+    ("COMBINING CARON BELOW" #x032C)
+    ("COMBINING CIRCUMFLEX ACCENT BELOW" #x032D)
+    ("COMBINING BREVE BELOW" #x032E)
+    ("COMBINING INVERTED BREVE BELOW" #x032F)
+    ("COMBINING TILDE BELOW" #x0330)
+    ("COMBINING MACRON BELOW" #x0331)
+    ("COMBINING LOW LINE" #x0332)
+    ("COMBINING DOUBLE LOW LINE" #x0333)
+    ("COMBINING TILDE OVERLAY" #x0334)
+    ("COMBINING SHORT STROKE OVERLAY" #x0335)
+    ("COMBINING LONG STROKE OVERLAY" #x0336)
+    ("COMBINING SHORT SOLIDUS OVERLAY" #x0337)
+    ("COMBINING LONG SOLIDUS OVERLAY" #x0338)
+    ("COMBINING RIGHT HALF RING BELOW" #x0339)
+    ("COMBINING INVERTED BRIDGE BELOW" #x033A)
+    ("COMBINING SQUARE BELOW" #x033B)
+    ("COMBINING SEAGULL BELOW" #x033C)
+    ("COMBINING X ABOVE" #x033D)
+    ("COMBINING VERTICAL TILDE" #x033E)
+    ("COMBINING DOUBLE OVERLINE" #x033F)
+    ("COMBINING GRAVE TONE MARK" #x0340)
+    ("COMBINING ACUTE TONE MARK" #x0341)
+    ("COMBINING GREEK PERISPOMENI" #x0342)
+    ("COMBINING GREEK KORONIS" #x0343)
+    ("COMBINING GREEK DIALYTIKA TONOS" #x0344)
+    ("COMBINING GREEK YPOGEGRAMMENI" #x0345)
+    ("COMBINING BRIDGE ABOVE" #x0346)
+    ("COMBINING EQUALS SIGN BELOW" #x0347)
+    ("COMBINING DOUBLE VERTICAL LINE BELOW" #x0348)
+    ("COMBINING LEFT ANGLE BELOW" #x0349)
+    ("COMBINING NOT TILDE ABOVE" #x034A)
+    ("COMBINING HOMOTHETIC ABOVE" #x034B)
+    ("COMBINING ALMOST EQUAL TO ABOVE" #x034C)
+    ("COMBINING LEFT RIGHT ARROW BELOW" #x034D)
+    ("COMBINING UPWARDS ARROW BELOW" #x034E)
+    ("COMBINING GRAPHEME JOINER" #x034F)
+    ("COMBINING DOUBLE TILDE" #x0360)
+    ("COMBINING DOUBLE INVERTED BREVE" #x0361)
+    ("COMBINING DOUBLE RIGHTWARDS ARROW BELOW" #x0362)
+    ("COMBINING LATIN SMALL LETTER A" #x0363)
+    ("COMBINING LATIN SMALL LETTER E" #x0364)
+    ("COMBINING LATIN SMALL LETTER I" #x0365)
+    ("COMBINING LATIN SMALL LETTER O" #x0366)
+    ("COMBINING LATIN SMALL LETTER U" #x0367)
+    ("COMBINING LATIN SMALL LETTER C" #x0368)
+    ("COMBINING LATIN SMALL LETTER D" #x0369)
+    ("COMBINING LATIN SMALL LETTER H" #x036A)
+    ("COMBINING LATIN SMALL LETTER M" #x036B)
+    ("COMBINING LATIN SMALL LETTER R" #x036C)
+    ("COMBINING LATIN SMALL LETTER T" #x036D)
+    ("COMBINING LATIN SMALL LETTER V" #x036E)
+    ("COMBINING LATIN SMALL LETTER X" #x036F)
+    ))
diff --git a/lisp/nxml/char-name/unicode/00370-003FF.el b/lisp/nxml/char-name/unicode/00370-003FF.el
new file mode 100644
index 00000000000..031b58d877d
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/00370-003FF.el
@@ -0,0 +1,117 @@
+(nxml-define-char-name-set 'greek-and-coptic
+  '(("GREEK NUMERAL SIGN" #x0374)
+    ("GREEK LOWER NUMERAL SIGN" #x0375)
+    ("GREEK YPOGEGRAMMENI" #x037A)
+    ("GREEK QUESTION MARK" #x037E)
+    ("GREEK TONOS" #x0384)
+    ("GREEK DIALYTIKA TONOS" #x0385)
+    ("GREEK CAPITAL LETTER ALPHA WITH TONOS" #x0386)
+    ("GREEK ANO TELEIA" #x0387)
+    ("GREEK CAPITAL LETTER EPSILON WITH TONOS" #x0388)
+    ("GREEK CAPITAL LETTER ETA WITH TONOS" #x0389)
+    ("GREEK CAPITAL LETTER IOTA WITH TONOS" #x038A)
+    ("GREEK CAPITAL LETTER OMICRON WITH TONOS" #x038C)
+    ("GREEK CAPITAL LETTER UPSILON WITH TONOS" #x038E)
+    ("GREEK CAPITAL LETTER OMEGA WITH TONOS" #x038F)
+    ("GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS" #x0390)
+    ("GREEK CAPITAL LETTER ALPHA" #x0391)
+    ("GREEK CAPITAL LETTER BETA" #x0392)
+    ("GREEK CAPITAL LETTER GAMMA" #x0393)
+    ("GREEK CAPITAL LETTER DELTA" #x0394)
+    ("GREEK CAPITAL LETTER EPSILON" #x0395)
+    ("GREEK CAPITAL LETTER ZETA" #x0396)
+    ("GREEK CAPITAL LETTER ETA" #x0397)
+    ("GREEK CAPITAL LETTER THETA" #x0398)
+    ("GREEK CAPITAL LETTER IOTA" #x0399)
+    ("GREEK CAPITAL LETTER KAPPA" #x039A)
+    ("GREEK CAPITAL LETTER LAMDA" #x039B)
+    ("GREEK CAPITAL LETTER MU" #x039C)
+    ("GREEK CAPITAL LETTER NU" #x039D)
+    ("GREEK CAPITAL LETTER XI" #x039E)
+    ("GREEK CAPITAL LETTER OMICRON" #x039F)
+    ("GREEK CAPITAL LETTER PI" #x03A0)
+    ("GREEK CAPITAL LETTER RHO" #x03A1)
+    ("GREEK CAPITAL LETTER SIGMA" #x03A3)
+    ("GREEK CAPITAL LETTER TAU" #x03A4)
+    ("GREEK CAPITAL LETTER UPSILON" #x03A5)
+    ("GREEK CAPITAL LETTER PHI" #x03A6)
+    ("GREEK CAPITAL LETTER CHI" #x03A7)
+    ("GREEK CAPITAL LETTER PSI" #x03A8)
+    ("GREEK CAPITAL LETTER OMEGA" #x03A9)
+    ("GREEK CAPITAL LETTER IOTA WITH DIALYTIKA" #x03AA)
+    ("GREEK CAPITAL LETTER UPSILON WITH DIALYTIKA" #x03AB)
+    ("GREEK SMALL LETTER ALPHA WITH TONOS" #x03AC)
+    ("GREEK SMALL LETTER EPSILON WITH TONOS" #x03AD)
+    ("GREEK SMALL LETTER ETA WITH TONOS" #x03AE)
+    ("GREEK SMALL LETTER IOTA WITH TONOS" #x03AF)
+    ("GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS" #x03B0)
+    ("GREEK SMALL LETTER ALPHA" #x03B1)
+    ("GREEK SMALL LETTER BETA" #x03B2)
+    ("GREEK SMALL LETTER GAMMA" #x03B3)
+    ("GREEK SMALL LETTER DELTA" #x03B4)
+    ("GREEK SMALL LETTER EPSILON" #x03B5)
+    ("GREEK SMALL LETTER ZETA" #x03B6)
+    ("GREEK SMALL LETTER ETA" #x03B7)
+    ("GREEK SMALL LETTER THETA" #x03B8)
+    ("GREEK SMALL LETTER IOTA" #x03B9)
+    ("GREEK SMALL LETTER KAPPA" #x03BA)
+    ("GREEK SMALL LETTER LAMDA" #x03BB)
+    ("GREEK SMALL LETTER MU" #x03BC)
+    ("GREEK SMALL LETTER NU" #x03BD)
+    ("GREEK SMALL LETTER XI" #x03BE)
+    ("GREEK SMALL LETTER OMICRON" #x03BF)
+    ("GREEK SMALL LETTER PI" #x03C0)
+    ("GREEK SMALL LETTER RHO" #x03C1)
+    ("GREEK SMALL LETTER FINAL SIGMA" #x03C2)
+    ("GREEK SMALL LETTER SIGMA" #x03C3)
+    ("GREEK SMALL LETTER TAU" #x03C4)
+    ("GREEK SMALL LETTER UPSILON" #x03C5)
+    ("GREEK SMALL LETTER PHI" #x03C6)
+    ("GREEK SMALL LETTER CHI" #x03C7)
+    ("GREEK SMALL LETTER PSI" #x03C8)
+    ("GREEK SMALL LETTER OMEGA" #x03C9)
+    ("GREEK SMALL LETTER IOTA WITH DIALYTIKA" #x03CA)
+    ("GREEK SMALL LETTER UPSILON WITH DIALYTIKA" #x03CB)
+    ("GREEK SMALL LETTER OMICRON WITH TONOS" #x03CC)
+    ("GREEK SMALL LETTER UPSILON WITH TONOS" #x03CD)
+    ("GREEK SMALL LETTER OMEGA WITH TONOS" #x03CE)
+    ("GREEK BETA SYMBOL" #x03D0)
+    ("GREEK THETA SYMBOL" #x03D1)
+    ("GREEK UPSILON WITH HOOK SYMBOL" #x03D2)
+    ("GREEK UPSILON WITH ACUTE AND HOOK SYMBOL" #x03D3)
+    ("GREEK UPSILON WITH DIAERESIS AND HOOK SYMBOL" #x03D4)
+    ("GREEK PHI SYMBOL" #x03D5)
+    ("GREEK PI SYMBOL" #x03D6)
+    ("GREEK KAI SYMBOL" #x03D7)
+    ("GREEK LETTER ARCHAIC KOPPA" #x03D8)
+    ("GREEK SMALL LETTER ARCHAIC KOPPA" #x03D9)
+    ("GREEK LETTER STIGMA" #x03DA)
+    ("GREEK SMALL LETTER STIGMA" #x03DB)
+    ("GREEK LETTER DIGAMMA" #x03DC)
+    ("GREEK SMALL LETTER DIGAMMA" #x03DD)
+    ("GREEK LETTER KOPPA" #x03DE)
+    ("GREEK SMALL LETTER KOPPA" #x03DF)
+    ("GREEK LETTER SAMPI" #x03E0)
+    ("GREEK SMALL LETTER SAMPI" #x03E1)
+    ("COPTIC CAPITAL LETTER SHEI" #x03E2)
+    ("COPTIC SMALL LETTER SHEI" #x03E3)
+    ("COPTIC CAPITAL LETTER FEI" #x03E4)
+    ("COPTIC SMALL LETTER FEI" #x03E5)
+    ("COPTIC CAPITAL LETTER KHEI" #x03E6)
+    ("COPTIC SMALL LETTER KHEI" #x03E7)
+    ("COPTIC CAPITAL LETTER HORI" #x03E8)
+    ("COPTIC SMALL LETTER HORI" #x03E9)
+    ("COPTIC CAPITAL LETTER GANGIA" #x03EA)
+    ("COPTIC SMALL LETTER GANGIA" #x03EB)
+    ("COPTIC CAPITAL LETTER SHIMA" #x03EC)
+    ("COPTIC SMALL LETTER SHIMA" #x03ED)
+    ("COPTIC CAPITAL LETTER DEI" #x03EE)
+    ("COPTIC SMALL LETTER DEI" #x03EF)
+    ("GREEK KAPPA SYMBOL" #x03F0)
+    ("GREEK RHO SYMBOL" #x03F1)
+    ("GREEK LUNATE SIGMA SYMBOL" #x03F2)
+    ("GREEK LETTER YOT" #x03F3)
+    ("GREEK CAPITAL THETA SYMBOL" #x03F4)
+    ("GREEK LUNATE EPSILON SYMBOL" #x03F5)
+    ("GREEK REVERSED LUNATE EPSILON SYMBOL" #x03F6)
+    ))
diff --git a/lisp/nxml/char-name/unicode/00400-004FF.el b/lisp/nxml/char-name/unicode/00400-004FF.el
new file mode 100644
index 00000000000..9de27e0dc57
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/00400-004FF.el
@@ -0,0 +1,248 @@
+(nxml-define-char-name-set 'cyrillic
+  '(("CYRILLIC CAPITAL LETTER IE WITH GRAVE" #x0400)
+    ("CYRILLIC CAPITAL LETTER IO" #x0401)
+    ("CYRILLIC CAPITAL LETTER DJE" #x0402)
+    ("CYRILLIC CAPITAL LETTER GJE" #x0403)
+    ("CYRILLIC CAPITAL LETTER UKRAINIAN IE" #x0404)
+    ("CYRILLIC CAPITAL LETTER DZE" #x0405)
+    ("CYRILLIC CAPITAL LETTER BYELORUSSIAN-UKRAINIAN I" #x0406)
+    ("CYRILLIC CAPITAL LETTER YI" #x0407)
+    ("CYRILLIC CAPITAL LETTER JE" #x0408)
+    ("CYRILLIC CAPITAL LETTER LJE" #x0409)
+    ("CYRILLIC CAPITAL LETTER NJE" #x040A)
+    ("CYRILLIC CAPITAL LETTER TSHE" #x040B)
+    ("CYRILLIC CAPITAL LETTER KJE" #x040C)
+    ("CYRILLIC CAPITAL LETTER I WITH GRAVE" #x040D)
+    ("CYRILLIC CAPITAL LETTER SHORT U" #x040E)
+    ("CYRILLIC CAPITAL LETTER DZHE" #x040F)
+    ("CYRILLIC CAPITAL LETTER A" #x0410)
+    ("CYRILLIC CAPITAL LETTER BE" #x0411)
+    ("CYRILLIC CAPITAL LETTER VE" #x0412)
+    ("CYRILLIC CAPITAL LETTER GHE" #x0413)
+    ("CYRILLIC CAPITAL LETTER DE" #x0414)
+    ("CYRILLIC CAPITAL LETTER IE" #x0415)
+    ("CYRILLIC CAPITAL LETTER ZHE" #x0416)
+    ("CYRILLIC CAPITAL LETTER ZE" #x0417)
+    ("CYRILLIC CAPITAL LETTER I" #x0418)
+    ("CYRILLIC CAPITAL LETTER SHORT I" #x0419)
+    ("CYRILLIC CAPITAL LETTER KA" #x041A)
+    ("CYRILLIC CAPITAL LETTER EL" #x041B)
+    ("CYRILLIC CAPITAL LETTER EM" #x041C)
+    ("CYRILLIC CAPITAL LETTER EN" #x041D)
+    ("CYRILLIC CAPITAL LETTER O" #x041E)
+    ("CYRILLIC CAPITAL LETTER PE" #x041F)
+    ("CYRILLIC CAPITAL LETTER ER" #x0420)
+    ("CYRILLIC CAPITAL LETTER ES" #x0421)
+    ("CYRILLIC CAPITAL LETTER TE" #x0422)
+    ("CYRILLIC CAPITAL LETTER U" #x0423)
+    ("CYRILLIC CAPITAL LETTER EF" #x0424)
+    ("CYRILLIC CAPITAL LETTER HA" #x0425)
+    ("CYRILLIC CAPITAL LETTER TSE" #x0426)
+    ("CYRILLIC CAPITAL LETTER CHE" #x0427)
+    ("CYRILLIC CAPITAL LETTER SHA" #x0428)
+    ("CYRILLIC CAPITAL LETTER SHCHA" #x0429)
+    ("CYRILLIC CAPITAL LETTER HARD SIGN" #x042A)
+    ("CYRILLIC CAPITAL LETTER YERU" #x042B)
+    ("CYRILLIC CAPITAL LETTER SOFT SIGN" #x042C)
+    ("CYRILLIC CAPITAL LETTER E" #x042D)
+    ("CYRILLIC CAPITAL LETTER YU" #x042E)
+    ("CYRILLIC CAPITAL LETTER YA" #x042F)
+    ("CYRILLIC SMALL LETTER A" #x0430)
+    ("CYRILLIC SMALL LETTER BE" #x0431)
+    ("CYRILLIC SMALL LETTER VE" #x0432)
+    ("CYRILLIC SMALL LETTER GHE" #x0433)
+    ("CYRILLIC SMALL LETTER DE" #x0434)
+    ("CYRILLIC SMALL LETTER IE" #x0435)
+    ("CYRILLIC SMALL LETTER ZHE" #x0436)
+    ("CYRILLIC SMALL LETTER ZE" #x0437)
+    ("CYRILLIC SMALL LETTER I" #x0438)
+    ("CYRILLIC SMALL LETTER SHORT I" #x0439)
+    ("CYRILLIC SMALL LETTER KA" #x043A)
+    ("CYRILLIC SMALL LETTER EL" #x043B)
+    ("CYRILLIC SMALL LETTER EM" #x043C)
+    ("CYRILLIC SMALL LETTER EN" #x043D)
+    ("CYRILLIC SMALL LETTER O" #x043E)
+    ("CYRILLIC SMALL LETTER PE" #x043F)
+    ("CYRILLIC SMALL LETTER ER" #x0440)
+    ("CYRILLIC SMALL LETTER ES" #x0441)
+    ("CYRILLIC SMALL LETTER TE" #x0442)
+    ("CYRILLIC SMALL LETTER U" #x0443)
+    ("CYRILLIC SMALL LETTER EF" #x0444)
+    ("CYRILLIC SMALL LETTER HA" #x0445)
+    ("CYRILLIC SMALL LETTER TSE" #x0446)
+    ("CYRILLIC SMALL LETTER CHE" #x0447)
+    ("CYRILLIC SMALL LETTER SHA" #x0448)
+    ("CYRILLIC SMALL LETTER SHCHA" #x0449)
+    ("CYRILLIC SMALL LETTER HARD SIGN" #x044A)
+    ("CYRILLIC SMALL LETTER YERU" #x044B)
+    ("CYRILLIC SMALL LETTER SOFT SIGN" #x044C)
+    ("CYRILLIC SMALL LETTER E" #x044D)
+    ("CYRILLIC SMALL LETTER YU" #x044E)
+    ("CYRILLIC SMALL LETTER YA" #x044F)
+    ("CYRILLIC SMALL LETTER IE WITH GRAVE" #x0450)
+    ("CYRILLIC SMALL LETTER IO" #x0451)
+    ("CYRILLIC SMALL LETTER DJE" #x0452)
+    ("CYRILLIC SMALL LETTER GJE" #x0453)
+    ("CYRILLIC SMALL LETTER UKRAINIAN IE" #x0454)
+    ("CYRILLIC SMALL LETTER DZE" #x0455)
+    ("CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I" #x0456)
+    ("CYRILLIC SMALL LETTER YI" #x0457)
+    ("CYRILLIC SMALL LETTER JE" #x0458)
+    ("CYRILLIC SMALL LETTER LJE" #x0459)
+    ("CYRILLIC SMALL LETTER NJE" #x045A)
+    ("CYRILLIC SMALL LETTER TSHE" #x045B)
+    ("CYRILLIC SMALL LETTER KJE" #x045C)
+    ("CYRILLIC SMALL LETTER I WITH GRAVE" #x045D)
+    ("CYRILLIC SMALL LETTER SHORT U" #x045E)
+    ("CYRILLIC SMALL LETTER DZHE" #x045F)
+    ("CYRILLIC CAPITAL LETTER OMEGA" #x0460)
+    ("CYRILLIC SMALL LETTER OMEGA" #x0461)
+    ("CYRILLIC CAPITAL LETTER YAT" #x0462)
+    ("CYRILLIC SMALL LETTER YAT" #x0463)
+    ("CYRILLIC CAPITAL LETTER IOTIFIED E" #x0464)
+    ("CYRILLIC SMALL LETTER IOTIFIED E" #x0465)
+    ("CYRILLIC CAPITAL LETTER LITTLE YUS" #x0466)
+    ("CYRILLIC SMALL LETTER LITTLE YUS" #x0467)
+    ("CYRILLIC CAPITAL LETTER IOTIFIED LITTLE YUS" #x0468)
+    ("CYRILLIC SMALL LETTER IOTIFIED LITTLE YUS" #x0469)
+    ("CYRILLIC CAPITAL LETTER BIG YUS" #x046A)
+    ("CYRILLIC SMALL LETTER BIG YUS" #x046B)
+    ("CYRILLIC CAPITAL LETTER IOTIFIED BIG YUS" #x046C)
+    ("CYRILLIC SMALL LETTER IOTIFIED BIG YUS" #x046D)
+    ("CYRILLIC CAPITAL LETTER KSI" #x046E)
+    ("CYRILLIC SMALL LETTER KSI" #x046F)
+    ("CYRILLIC CAPITAL LETTER PSI" #x0470)
+    ("CYRILLIC SMALL LETTER PSI" #x0471)
+    ("CYRILLIC CAPITAL LETTER FITA" #x0472)
+    ("CYRILLIC SMALL LETTER FITA" #x0473)
+    ("CYRILLIC CAPITAL LETTER IZHITSA" #x0474)
+    ("CYRILLIC SMALL LETTER IZHITSA" #x0475)
+    ("CYRILLIC CAPITAL LETTER IZHITSA WITH DOUBLE GRAVE ACCENT" #x0476)
+    ("CYRILLIC SMALL LETTER IZHITSA WITH DOUBLE GRAVE ACCENT" #x0477)
+    ("CYRILLIC CAPITAL LETTER UK" #x0478)
+    ("CYRILLIC SMALL LETTER UK" #x0479)
+    ("CYRILLIC CAPITAL LETTER ROUND OMEGA" #x047A)
+    ("CYRILLIC SMALL LETTER ROUND OMEGA" #x047B)
+    ("CYRILLIC CAPITAL LETTER OMEGA WITH TITLO" #x047C)
+    ("CYRILLIC SMALL LETTER OMEGA WITH TITLO" #x047D)
+    ("CYRILLIC CAPITAL LETTER OT" #x047E)
+    ("CYRILLIC SMALL LETTER OT" #x047F)
+    ("CYRILLIC CAPITAL LETTER KOPPA" #x0480)
+    ("CYRILLIC SMALL LETTER KOPPA" #x0481)
+    ("CYRILLIC THOUSANDS SIGN" #x0482)
+    ("COMBINING CYRILLIC TITLO" #x0483)
+    ("COMBINING CYRILLIC PALATALIZATION" #x0484)
+    ("COMBINING CYRILLIC DASIA PNEUMATA" #x0485)
+    ("COMBINING CYRILLIC PSILI PNEUMATA" #x0486)
+    ("COMBINING CYRILLIC HUNDRED THOUSANDS SIGN" #x0488)
+    ("COMBINING CYRILLIC MILLIONS SIGN" #x0489)
+    ("CYRILLIC CAPITAL LETTER SHORT I WITH TAIL" #x048A)
+    ("CYRILLIC SMALL LETTER SHORT I WITH TAIL" #x048B)
+    ("CYRILLIC CAPITAL LETTER SEMISOFT SIGN" #x048C)
+    ("CYRILLIC SMALL LETTER SEMISOFT SIGN" #x048D)
+    ("CYRILLIC CAPITAL LETTER ER WITH TICK" #x048E)
+    ("CYRILLIC SMALL LETTER ER WITH TICK" #x048F)
+    ("CYRILLIC CAPITAL LETTER GHE WITH UPTURN" #x0490)
+    ("CYRILLIC SMALL LETTER GHE WITH UPTURN" #x0491)
+    ("CYRILLIC CAPITAL LETTER GHE WITH STROKE" #x0492)
+    ("CYRILLIC SMALL LETTER GHE WITH STROKE" #x0493)
+    ("CYRILLIC CAPITAL LETTER GHE WITH MIDDLE HOOK" #x0494)
+    ("CYRILLIC SMALL LETTER GHE WITH MIDDLE HOOK" #x0495)
+    ("CYRILLIC CAPITAL LETTER ZHE WITH DESCENDER" #x0496)
+    ("CYRILLIC SMALL LETTER ZHE WITH DESCENDER" #x0497)
+    ("CYRILLIC CAPITAL LETTER ZE WITH DESCENDER" #x0498)
+    ("CYRILLIC SMALL LETTER ZE WITH DESCENDER" #x0499)
+    ("CYRILLIC CAPITAL LETTER KA WITH DESCENDER" #x049A)
+    ("CYRILLIC SMALL LETTER KA WITH DESCENDER" #x049B)
+    ("CYRILLIC CAPITAL LETTER KA WITH VERTICAL STROKE" #x049C)
+    ("CYRILLIC SMALL LETTER KA WITH VERTICAL STROKE" #x049D)
+    ("CYRILLIC CAPITAL LETTER KA WITH STROKE" #x049E)
+    ("CYRILLIC SMALL LETTER KA WITH STROKE" #x049F)
+    ("CYRILLIC CAPITAL LETTER BASHKIR KA" #x04A0)
+    ("CYRILLIC SMALL LETTER BASHKIR KA" #x04A1)
+    ("CYRILLIC CAPITAL LETTER EN WITH DESCENDER" #x04A2)
+    ("CYRILLIC SMALL LETTER EN WITH DESCENDER" #x04A3)
+    ("CYRILLIC CAPITAL LIGATURE EN GHE" #x04A4)
+    ("CYRILLIC SMALL LIGATURE EN GHE" #x04A5)
+    ("CYRILLIC CAPITAL LETTER PE WITH MIDDLE HOOK" #x04A6)
+    ("CYRILLIC SMALL LETTER PE WITH MIDDLE HOOK" #x04A7)
+    ("CYRILLIC CAPITAL LETTER ABKHASIAN HA" #x04A8)
+    ("CYRILLIC SMALL LETTER ABKHASIAN HA" #x04A9)
+    ("CYRILLIC CAPITAL LETTER ES WITH DESCENDER" #x04AA)
+    ("CYRILLIC SMALL LETTER ES WITH DESCENDER" #x04AB)
+    ("CYRILLIC CAPITAL LETTER TE WITH DESCENDER" #x04AC)
+    ("CYRILLIC SMALL LETTER TE WITH DESCENDER" #x04AD)
+    ("CYRILLIC CAPITAL LETTER STRAIGHT U" #x04AE)
+    ("CYRILLIC SMALL LETTER STRAIGHT U" #x04AF)
+    ("CYRILLIC CAPITAL LETTER STRAIGHT U WITH STROKE" #x04B0)
+    ("CYRILLIC SMALL LETTER STRAIGHT U WITH STROKE" #x04B1)
+    ("CYRILLIC CAPITAL LETTER HA WITH DESCENDER" #x04B2)
+    ("CYRILLIC SMALL LETTER HA WITH DESCENDER" #x04B3)
+    ("CYRILLIC CAPITAL LIGATURE TE TSE" #x04B4)
+    ("CYRILLIC SMALL LIGATURE TE TSE" #x04B5)
+    ("CYRILLIC CAPITAL LETTER CHE WITH DESCENDER" #x04B6)
+    ("CYRILLIC SMALL LETTER CHE WITH DESCENDER" #x04B7)
+    ("CYRILLIC CAPITAL LETTER CHE WITH VERTICAL STROKE" #x04B8)
+    ("CYRILLIC SMALL LETTER CHE WITH VERTICAL STROKE" #x04B9)
+    ("CYRILLIC CAPITAL LETTER SHHA" #x04BA)
+    ("CYRILLIC SMALL LETTER SHHA" #x04BB)
+    ("CYRILLIC CAPITAL LETTER ABKHASIAN CHE" #x04BC)
+    ("CYRILLIC SMALL LETTER ABKHASIAN CHE" #x04BD)
+    ("CYRILLIC CAPITAL LETTER ABKHASIAN CHE WITH DESCENDER" #x04BE)
+    ("CYRILLIC SMALL LETTER ABKHASIAN CHE WITH DESCENDER" #x04BF)
+    ("CYRILLIC LETTER PALOCHKA" #x04C0)
+    ("CYRILLIC CAPITAL LETTER ZHE WITH BREVE" #x04C1)
+    ("CYRILLIC SMALL LETTER ZHE WITH BREVE" #x04C2)
+    ("CYRILLIC CAPITAL LETTER KA WITH HOOK" #x04C3)
+    ("CYRILLIC SMALL LETTER KA WITH HOOK" #x04C4)
+    ("CYRILLIC CAPITAL LETTER EL WITH TAIL" #x04C5)
+    ("CYRILLIC SMALL LETTER EL WITH TAIL" #x04C6)
+    ("CYRILLIC CAPITAL LETTER EN WITH HOOK" #x04C7)
+    ("CYRILLIC SMALL LETTER EN WITH HOOK" #x04C8)
+    ("CYRILLIC CAPITAL LETTER EN WITH TAIL" #x04C9)
+    ("CYRILLIC SMALL LETTER EN WITH TAIL" #x04CA)
+    ("CYRILLIC CAPITAL LETTER KHAKASSIAN CHE" #x04CB)
+    ("CYRILLIC SMALL LETTER KHAKASSIAN CHE" #x04CC)
+    ("CYRILLIC CAPITAL LETTER EM WITH TAIL" #x04CD)
+    ("CYRILLIC SMALL LETTER EM WITH TAIL" #x04CE)
+    ("CYRILLIC CAPITAL LETTER A WITH BREVE" #x04D0)
+    ("CYRILLIC SMALL LETTER A WITH BREVE" #x04D1)
+    ("CYRILLIC CAPITAL LETTER A WITH DIAERESIS" #x04D2)
+    ("CYRILLIC SMALL LETTER A WITH DIAERESIS" #x04D3)
+    ("CYRILLIC CAPITAL LIGATURE A IE" #x04D4)
+    ("CYRILLIC SMALL LIGATURE A IE" #x04D5)
+    ("CYRILLIC CAPITAL LETTER IE WITH BREVE" #x04D6)
+    ("CYRILLIC SMALL LETTER IE WITH BREVE" #x04D7)
+    ("CYRILLIC CAPITAL LETTER SCHWA" #x04D8)
+    ("CYRILLIC SMALL LETTER SCHWA" #x04D9)
+    ("CYRILLIC CAPITAL LETTER SCHWA WITH DIAERESIS" #x04DA)
+    ("CYRILLIC SMALL LETTER SCHWA WITH DIAERESIS" #x04DB)
+    ("CYRILLIC CAPITAL LETTER ZHE WITH DIAERESIS" #x04DC)
+    ("CYRILLIC SMALL LETTER ZHE WITH DIAERESIS" #x04DD)
+    ("CYRILLIC CAPITAL LETTER ZE WITH DIAERESIS" #x04DE)
+    ("CYRILLIC SMALL LETTER ZE WITH DIAERESIS" #x04DF)
+    ("CYRILLIC CAPITAL LETTER ABKHASIAN DZE" #x04E0)
+    ("CYRILLIC SMALL LETTER ABKHASIAN DZE" #x04E1)
+    ("CYRILLIC CAPITAL LETTER I WITH MACRON" #x04E2)
+    ("CYRILLIC SMALL LETTER I WITH MACRON" #x04E3)
+    ("CYRILLIC CAPITAL LETTER I WITH DIAERESIS" #x04E4)
+    ("CYRILLIC SMALL LETTER I WITH DIAERESIS" #x04E5)
+    ("CYRILLIC CAPITAL LETTER O WITH DIAERESIS" #x04E6)
+    ("CYRILLIC SMALL LETTER O WITH DIAERESIS" #x04E7)
+    ("CYRILLIC CAPITAL LETTER BARRED O" #x04E8)
+    ("CYRILLIC SMALL LETTER BARRED O" #x04E9)
+    ("CYRILLIC CAPITAL LETTER BARRED O WITH DIAERESIS" #x04EA)
+    ("CYRILLIC SMALL LETTER BARRED O WITH DIAERESIS" #x04EB)
+    ("CYRILLIC CAPITAL LETTER E WITH DIAERESIS" #x04EC)
+    ("CYRILLIC SMALL LETTER E WITH DIAERESIS" #x04ED)
+    ("CYRILLIC CAPITAL LETTER U WITH MACRON" #x04EE)
+    ("CYRILLIC SMALL LETTER U WITH MACRON" #x04EF)
+    ("CYRILLIC CAPITAL LETTER U WITH DIAERESIS" #x04F0)
+    ("CYRILLIC SMALL LETTER U WITH DIAERESIS" #x04F1)
+    ("CYRILLIC CAPITAL LETTER U WITH DOUBLE ACUTE" #x04F2)
+    ("CYRILLIC SMALL LETTER U WITH DOUBLE ACUTE" #x04F3)
+    ("CYRILLIC CAPITAL LETTER CHE WITH DIAERESIS" #x04F4)
+    ("CYRILLIC SMALL LETTER CHE WITH DIAERESIS" #x04F5)
+    ("CYRILLIC CAPITAL LETTER YERU WITH DIAERESIS" #x04F8)
+    ("CYRILLIC SMALL LETTER YERU WITH DIAERESIS" #x04F9)
+    ))
diff --git a/lisp/nxml/char-name/unicode/00500-0052F.el b/lisp/nxml/char-name/unicode/00500-0052F.el
new file mode 100644
index 00000000000..a59541150ef
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/00500-0052F.el
@@ -0,0 +1,18 @@
+(nxml-define-char-name-set 'cyrillic-supplementary
+  '(("CYRILLIC CAPITAL LETTER KOMI DE" #x0500)
+    ("CYRILLIC SMALL LETTER KOMI DE" #x0501)
+    ("CYRILLIC CAPITAL LETTER KOMI DJE" #x0502)
+    ("CYRILLIC SMALL LETTER KOMI DJE" #x0503)
+    ("CYRILLIC CAPITAL LETTER KOMI ZJE" #x0504)
+    ("CYRILLIC SMALL LETTER KOMI ZJE" #x0505)
+    ("CYRILLIC CAPITAL LETTER KOMI DZJE" #x0506)
+    ("CYRILLIC SMALL LETTER KOMI DZJE" #x0507)
+    ("CYRILLIC CAPITAL LETTER KOMI LJE" #x0508)
+    ("CYRILLIC SMALL LETTER KOMI LJE" #x0509)
+    ("CYRILLIC CAPITAL LETTER KOMI NJE" #x050A)
+    ("CYRILLIC SMALL LETTER KOMI NJE" #x050B)
+    ("CYRILLIC CAPITAL LETTER KOMI SJE" #x050C)
+    ("CYRILLIC SMALL LETTER KOMI SJE" #x050D)
+    ("CYRILLIC CAPITAL LETTER KOMI TJE" #x050E)
+    ("CYRILLIC SMALL LETTER KOMI TJE" #x050F)
+    ))
diff --git a/lisp/nxml/char-name/unicode/00530-0058F.el b/lisp/nxml/char-name/unicode/00530-0058F.el
new file mode 100644
index 00000000000..0f5d0ed1e5f
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/00530-0058F.el
@@ -0,0 +1,88 @@
+(nxml-define-char-name-set 'armenian
+  '(("ARMENIAN CAPITAL LETTER AYB" #x0531)
+    ("ARMENIAN CAPITAL LETTER BEN" #x0532)
+    ("ARMENIAN CAPITAL LETTER GIM" #x0533)
+    ("ARMENIAN CAPITAL LETTER DA" #x0534)
+    ("ARMENIAN CAPITAL LETTER ECH" #x0535)
+    ("ARMENIAN CAPITAL LETTER ZA" #x0536)
+    ("ARMENIAN CAPITAL LETTER EH" #x0537)
+    ("ARMENIAN CAPITAL LETTER ET" #x0538)
+    ("ARMENIAN CAPITAL LETTER TO" #x0539)
+    ("ARMENIAN CAPITAL LETTER ZHE" #x053A)
+    ("ARMENIAN CAPITAL LETTER INI" #x053B)
+    ("ARMENIAN CAPITAL LETTER LIWN" #x053C)
+    ("ARMENIAN CAPITAL LETTER XEH" #x053D)
+    ("ARMENIAN CAPITAL LETTER CA" #x053E)
+    ("ARMENIAN CAPITAL LETTER KEN" #x053F)
+    ("ARMENIAN CAPITAL LETTER HO" #x0540)
+    ("ARMENIAN CAPITAL LETTER JA" #x0541)
+    ("ARMENIAN CAPITAL LETTER GHAD" #x0542)
+    ("ARMENIAN CAPITAL LETTER CHEH" #x0543)
+    ("ARMENIAN CAPITAL LETTER MEN" #x0544)
+    ("ARMENIAN CAPITAL LETTER YI" #x0545)
+    ("ARMENIAN CAPITAL LETTER NOW" #x0546)
+    ("ARMENIAN CAPITAL LETTER SHA" #x0547)
+    ("ARMENIAN CAPITAL LETTER VO" #x0548)
+    ("ARMENIAN CAPITAL LETTER CHA" #x0549)
+    ("ARMENIAN CAPITAL LETTER PEH" #x054A)
+    ("ARMENIAN CAPITAL LETTER JHEH" #x054B)
+    ("ARMENIAN CAPITAL LETTER RA" #x054C)
+    ("ARMENIAN CAPITAL LETTER SEH" #x054D)
+    ("ARMENIAN CAPITAL LETTER VEW" #x054E)
+    ("ARMENIAN CAPITAL LETTER TIWN" #x054F)
+    ("ARMENIAN CAPITAL LETTER REH" #x0550)
+    ("ARMENIAN CAPITAL LETTER CO" #x0551)
+    ("ARMENIAN CAPITAL LETTER YIWN" #x0552)
+    ("ARMENIAN CAPITAL LETTER PIWR" #x0553)
+    ("ARMENIAN CAPITAL LETTER KEH" #x0554)
+    ("ARMENIAN CAPITAL LETTER OH" #x0555)
+    ("ARMENIAN CAPITAL LETTER FEH" #x0556)
+    ("ARMENIAN MODIFIER LETTER LEFT HALF RING" #x0559)
+    ("ARMENIAN APOSTROPHE" #x055A)
+    ("ARMENIAN EMPHASIS MARK" #x055B)
+    ("ARMENIAN EXCLAMATION MARK" #x055C)
+    ("ARMENIAN COMMA" #x055D)
+    ("ARMENIAN QUESTION MARK" #x055E)
+    ("ARMENIAN ABBREVIATION MARK" #x055F)
+    ("ARMENIAN SMALL LETTER AYB" #x0561)
+    ("ARMENIAN SMALL LETTER BEN" #x0562)
+    ("ARMENIAN SMALL LETTER GIM" #x0563)
+    ("ARMENIAN SMALL LETTER DA" #x0564)
+    ("ARMENIAN SMALL LETTER ECH" #x0565)
+    ("ARMENIAN SMALL LETTER ZA" #x0566)
+    ("ARMENIAN SMALL LETTER EH" #x0567)
+    ("ARMENIAN SMALL LETTER ET" #x0568)
+    ("ARMENIAN SMALL LETTER TO" #x0569)
+    ("ARMENIAN SMALL LETTER ZHE" #x056A)
+    ("ARMENIAN SMALL LETTER INI" #x056B)
+    ("ARMENIAN SMALL LETTER LIWN" #x056C)
+    ("ARMENIAN SMALL LETTER XEH" #x056D)
+    ("ARMENIAN SMALL LETTER CA" #x056E)
+    ("ARMENIAN SMALL LETTER KEN" #x056F)
+    ("ARMENIAN SMALL LETTER HO" #x0570)
+    ("ARMENIAN SMALL LETTER JA" #x0571)
+    ("ARMENIAN SMALL LETTER GHAD" #x0572)
+    ("ARMENIAN SMALL LETTER CHEH" #x0573)
+    ("ARMENIAN SMALL LETTER MEN" #x0574)
+    ("ARMENIAN SMALL LETTER YI" #x0575)
+    ("ARMENIAN SMALL LETTER NOW" #x0576)
+    ("ARMENIAN SMALL LETTER SHA" #x0577)
+    ("ARMENIAN SMALL LETTER VO" #x0578)
+    ("ARMENIAN SMALL LETTER CHA" #x0579)
+    ("ARMENIAN SMALL LETTER PEH" #x057A)
+    ("ARMENIAN SMALL LETTER JHEH" #x057B)
+    ("ARMENIAN SMALL LETTER RA" #x057C)
+    ("ARMENIAN SMALL LETTER SEH" #x057D)
+    ("ARMENIAN SMALL LETTER VEW" #x057E)
+    ("ARMENIAN SMALL LETTER TIWN" #x057F)
+    ("ARMENIAN SMALL LETTER REH" #x0580)
+    ("ARMENIAN SMALL LETTER CO" #x0581)
+    ("ARMENIAN SMALL LETTER YIWN" #x0582)
+    ("ARMENIAN SMALL LETTER PIWR" #x0583)
+    ("ARMENIAN SMALL LETTER KEH" #x0584)
+    ("ARMENIAN SMALL LETTER OH" #x0585)
+    ("ARMENIAN SMALL LETTER FEH" #x0586)
+    ("ARMENIAN SMALL LIGATURE ECH YIWN" #x0587)
+    ("ARMENIAN FULL STOP" #x0589)
+    ("ARMENIAN HYPHEN" #x058A)
+    ))
diff --git a/lisp/nxml/char-name/unicode/00590-005FF.el b/lisp/nxml/char-name/unicode/00590-005FF.el
new file mode 100644
index 00000000000..b33d5ea0650
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/00590-005FF.el
@@ -0,0 +1,84 @@
+(nxml-define-char-name-set 'hebrew
+  '(("HEBREW ACCENT ETNAHTA" #x0591)
+    ("HEBREW ACCENT SEGOL" #x0592)
+    ("HEBREW ACCENT SHALSHELET" #x0593)
+    ("HEBREW ACCENT ZAQEF QATAN" #x0594)
+    ("HEBREW ACCENT ZAQEF GADOL" #x0595)
+    ("HEBREW ACCENT TIPEHA" #x0596)
+    ("HEBREW ACCENT REVIA" #x0597)
+    ("HEBREW ACCENT ZARQA" #x0598)
+    ("HEBREW ACCENT PASHTA" #x0599)
+    ("HEBREW ACCENT YETIV" #x059A)
+    ("HEBREW ACCENT TEVIR" #x059B)
+    ("HEBREW ACCENT GERESH" #x059C)
+    ("HEBREW ACCENT GERESH MUQDAM" #x059D)
+    ("HEBREW ACCENT GERSHAYIM" #x059E)
+    ("HEBREW ACCENT QARNEY PARA" #x059F)
+    ("HEBREW ACCENT TELISHA GEDOLA" #x05A0)
+    ("HEBREW ACCENT PAZER" #x05A1)
+    ("HEBREW ACCENT MUNAH" #x05A3)
+    ("HEBREW ACCENT MAHAPAKH" #x05A4)
+    ("HEBREW ACCENT MERKHA" #x05A5)
+    ("HEBREW ACCENT MERKHA KEFULA" #x05A6)
+    ("HEBREW ACCENT DARGA" #x05A7)
+    ("HEBREW ACCENT QADMA" #x05A8)
+    ("HEBREW ACCENT TELISHA QETANA" #x05A9)
+    ("HEBREW ACCENT YERAH BEN YOMO" #x05AA)
+    ("HEBREW ACCENT OLE" #x05AB)
+    ("HEBREW ACCENT ILUY" #x05AC)
+    ("HEBREW ACCENT DEHI" #x05AD)
+    ("HEBREW ACCENT ZINOR" #x05AE)
+    ("HEBREW MARK MASORA CIRCLE" #x05AF)
+    ("HEBREW POINT SHEVA" #x05B0)
+    ("HEBREW POINT HATAF SEGOL" #x05B1)
+    ("HEBREW POINT HATAF PATAH" #x05B2)
+    ("HEBREW POINT HATAF QAMATS" #x05B3)
+    ("HEBREW POINT HIRIQ" #x05B4)
+    ("HEBREW POINT TSERE" #x05B5)
+    ("HEBREW POINT SEGOL" #x05B6)
+    ("HEBREW POINT PATAH" #x05B7)
+    ("HEBREW POINT QAMATS" #x05B8)
+    ("HEBREW POINT HOLAM" #x05B9)
+    ("HEBREW POINT QUBUTS" #x05BB)
+    ("HEBREW POINT DAGESH OR MAPIQ" #x05BC)
+    ("HEBREW POINT METEG" #x05BD)
+    ("HEBREW PUNCTUATION MAQAF" #x05BE)
+    ("HEBREW POINT RAFE" #x05BF)
+    ("HEBREW PUNCTUATION PASEQ" #x05C0)
+    ("HEBREW POINT SHIN DOT" #x05C1)
+    ("HEBREW POINT SIN DOT" #x05C2)
+    ("HEBREW PUNCTUATION SOF PASUQ" #x05C3)
+    ("HEBREW MARK UPPER DOT" #x05C4)
+    ("HEBREW LETTER ALEF" #x05D0)
+    ("HEBREW LETTER BET" #x05D1)
+    ("HEBREW LETTER GIMEL" #x05D2)
+    ("HEBREW LETTER DALET" #x05D3)
+    ("HEBREW LETTER HE" #x05D4)
+    ("HEBREW LETTER VAV" #x05D5)
+    ("HEBREW LETTER ZAYIN" #x05D6)
+    ("HEBREW LETTER HET" #x05D7)
+    ("HEBREW LETTER TET" #x05D8)
+    ("HEBREW LETTER YOD" #x05D9)
+    ("HEBREW LETTER FINAL KAF" #x05DA)
+    ("HEBREW LETTER KAF" #x05DB)
+    ("HEBREW LETTER LAMED" #x05DC)
+    ("HEBREW LETTER FINAL MEM" #x05DD)
+    ("HEBREW LETTER MEM" #x05DE)
+    ("HEBREW LETTER FINAL NUN" #x05DF)
+    ("HEBREW LETTER NUN" #x05E0)
+    ("HEBREW LETTER SAMEKH" #x05E1)
+    ("HEBREW LETTER AYIN" #x05E2)
+    ("HEBREW LETTER FINAL PE" #x05E3)
+    ("HEBREW LETTER PE" #x05E4)
+    ("HEBREW LETTER FINAL TSADI" #x05E5)
+    ("HEBREW LETTER TSADI" #x05E6)
+    ("HEBREW LETTER QOF" #x05E7)
+    ("HEBREW LETTER RESH" #x05E8)
+    ("HEBREW LETTER SHIN" #x05E9)
+    ("HEBREW LETTER TAV" #x05EA)
+    ("HEBREW LIGATURE YIDDISH DOUBLE VAV" #x05F0)
+    ("HEBREW LIGATURE YIDDISH VAV YOD" #x05F1)
+    ("HEBREW LIGATURE YIDDISH DOUBLE YOD" #x05F2)
+    ("HEBREW PUNCTUATION GERESH" #x05F3)
+    ("HEBREW PUNCTUATION GERSHAYIM" #x05F4)
+    ))
diff --git a/lisp/nxml/char-name/unicode/00600-006FF.el b/lisp/nxml/char-name/unicode/00600-006FF.el
new file mode 100644
index 00000000000..9009737528a
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/00600-006FF.el
@@ -0,0 +1,210 @@
+(nxml-define-char-name-set 'arabic
+  '(("ARABIC COMMA" #x060C)
+    ("ARABIC SEMICOLON" #x061B)
+    ("ARABIC QUESTION MARK" #x061F)
+    ("ARABIC LETTER HAMZA" #x0621)
+    ("ARABIC LETTER ALEF WITH MADDA ABOVE" #x0622)
+    ("ARABIC LETTER ALEF WITH HAMZA ABOVE" #x0623)
+    ("ARABIC LETTER WAW WITH HAMZA ABOVE" #x0624)
+    ("ARABIC LETTER ALEF WITH HAMZA BELOW" #x0625)
+    ("ARABIC LETTER YEH WITH HAMZA ABOVE" #x0626)
+    ("ARABIC LETTER ALEF" #x0627)
+    ("ARABIC LETTER BEH" #x0628)
+    ("ARABIC LETTER TEH MARBUTA" #x0629)
+    ("ARABIC LETTER TEH" #x062A)
+    ("ARABIC LETTER THEH" #x062B)
+    ("ARABIC LETTER JEEM" #x062C)
+    ("ARABIC LETTER HAH" #x062D)
+    ("ARABIC LETTER KHAH" #x062E)
+    ("ARABIC LETTER DAL" #x062F)
+    ("ARABIC LETTER THAL" #x0630)
+    ("ARABIC LETTER REH" #x0631)
+    ("ARABIC LETTER ZAIN" #x0632)
+    ("ARABIC LETTER SEEN" #x0633)
+    ("ARABIC LETTER SHEEN" #x0634)
+    ("ARABIC LETTER SAD" #x0635)
+    ("ARABIC LETTER DAD" #x0636)
+    ("ARABIC LETTER TAH" #x0637)
+    ("ARABIC LETTER ZAH" #x0638)
+    ("ARABIC LETTER AIN" #x0639)
+    ("ARABIC LETTER GHAIN" #x063A)
+    ("ARABIC TATWEEL" #x0640)
+    ("ARABIC LETTER FEH" #x0641)
+    ("ARABIC LETTER QAF" #x0642)
+    ("ARABIC LETTER KAF" #x0643)
+    ("ARABIC LETTER LAM" #x0644)
+    ("ARABIC LETTER MEEM" #x0645)
+    ("ARABIC LETTER NOON" #x0646)
+    ("ARABIC LETTER HEH" #x0647)
+    ("ARABIC LETTER WAW" #x0648)
+    ("ARABIC LETTER ALEF MAKSURA" #x0649)
+    ("ARABIC LETTER YEH" #x064A)
+    ("ARABIC FATHATAN" #x064B)
+    ("ARABIC DAMMATAN" #x064C)
+    ("ARABIC KASRATAN" #x064D)
+    ("ARABIC FATHA" #x064E)
+    ("ARABIC DAMMA" #x064F)
+    ("ARABIC KASRA" #x0650)
+    ("ARABIC SHADDA" #x0651)
+    ("ARABIC SUKUN" #x0652)
+    ("ARABIC MADDAH ABOVE" #x0653)
+    ("ARABIC HAMZA ABOVE" #x0654)
+    ("ARABIC HAMZA BELOW" #x0655)
+    ("ARABIC-INDIC DIGIT ZERO" #x0660)
+    ("ARABIC-INDIC DIGIT ONE" #x0661)
+    ("ARABIC-INDIC DIGIT TWO" #x0662)
+    ("ARABIC-INDIC DIGIT THREE" #x0663)
+    ("ARABIC-INDIC DIGIT FOUR" #x0664)
+    ("ARABIC-INDIC DIGIT FIVE" #x0665)
+    ("ARABIC-INDIC DIGIT SIX" #x0666)
+    ("ARABIC-INDIC DIGIT SEVEN" #x0667)
+    ("ARABIC-INDIC DIGIT EIGHT" #x0668)
+    ("ARABIC-INDIC DIGIT NINE" #x0669)
+    ("ARABIC PERCENT SIGN" #x066A)
+    ("ARABIC DECIMAL SEPARATOR" #x066B)
+    ("ARABIC THOUSANDS SEPARATOR" #x066C)
+    ("ARABIC FIVE POINTED STAR" #x066D)
+    ("ARABIC LETTER DOTLESS BEH" #x066E)
+    ("ARABIC LETTER DOTLESS QAF" #x066F)
+    ("ARABIC LETTER SUPERSCRIPT ALEF" #x0670)
+    ("ARABIC LETTER ALEF WASLA" #x0671)
+    ("ARABIC LETTER ALEF WITH WAVY HAMZA ABOVE" #x0672)
+    ("ARABIC LETTER ALEF WITH WAVY HAMZA BELOW" #x0673)
+    ("ARABIC LETTER HIGH HAMZA" #x0674)
+    ("ARABIC LETTER HIGH HAMZA ALEF" #x0675)
+    ("ARABIC LETTER HIGH HAMZA WAW" #x0676)
+    ("ARABIC LETTER U WITH HAMZA ABOVE" #x0677)
+    ("ARABIC LETTER HIGH HAMZA YEH" #x0678)
+    ("ARABIC LETTER TTEH" #x0679)
+    ("ARABIC LETTER TTEHEH" #x067A)
+    ("ARABIC LETTER BEEH" #x067B)
+    ("ARABIC LETTER TEH WITH RING" #x067C)
+    ("ARABIC LETTER TEH WITH THREE DOTS ABOVE DOWNWARDS" #x067D)
+    ("ARABIC LETTER PEH" #x067E)
+    ("ARABIC LETTER TEHEH" #x067F)
+    ("ARABIC LETTER BEHEH" #x0680)
+    ("ARABIC LETTER HAH WITH HAMZA ABOVE" #x0681)
+    ("ARABIC LETTER HAH WITH TWO DOTS VERTICAL ABOVE" #x0682)
+    ("ARABIC LETTER NYEH" #x0683)
+    ("ARABIC LETTER DYEH" #x0684)
+    ("ARABIC LETTER HAH WITH THREE DOTS ABOVE" #x0685)
+    ("ARABIC LETTER TCHEH" #x0686)
+    ("ARABIC LETTER TCHEHEH" #x0687)
+    ("ARABIC LETTER DDAL" #x0688)
+    ("ARABIC LETTER DAL WITH RING" #x0689)
+    ("ARABIC LETTER DAL WITH DOT BELOW" #x068A)
+    ("ARABIC LETTER DAL WITH DOT BELOW AND SMALL TAH" #x068B)
+    ("ARABIC LETTER DAHAL" #x068C)
+    ("ARABIC LETTER DDAHAL" #x068D)
+    ("ARABIC LETTER DUL" #x068E)
+    ("ARABIC LETTER DAL WITH THREE DOTS ABOVE DOWNWARDS" #x068F)
+    ("ARABIC LETTER DAL WITH FOUR DOTS ABOVE" #x0690)
+    ("ARABIC LETTER RREH" #x0691)
+    ("ARABIC LETTER REH WITH SMALL V" #x0692)
+    ("ARABIC LETTER REH WITH RING" #x0693)
+    ("ARABIC LETTER REH WITH DOT BELOW" #x0694)
+    ("ARABIC LETTER REH WITH SMALL V BELOW" #x0695)
+    ("ARABIC LETTER REH WITH DOT BELOW AND DOT ABOVE" #x0696)
+    ("ARABIC LETTER REH WITH TWO DOTS ABOVE" #x0697)
+    ("ARABIC LETTER JEH" #x0698)
+    ("ARABIC LETTER REH WITH FOUR DOTS ABOVE" #x0699)
+    ("ARABIC LETTER SEEN WITH DOT BELOW AND DOT ABOVE" #x069A)
+    ("ARABIC LETTER SEEN WITH THREE DOTS BELOW" #x069B)
+    ("ARABIC LETTER SEEN WITH THREE DOTS BELOW AND THREE DOTS ABOVE" #x069C)
+    ("ARABIC LETTER SAD WITH TWO DOTS BELOW" #x069D)
+    ("ARABIC LETTER SAD WITH THREE DOTS ABOVE" #x069E)
+    ("ARABIC LETTER TAH WITH THREE DOTS ABOVE" #x069F)
+    ("ARABIC LETTER AIN WITH THREE DOTS ABOVE" #x06A0)
+    ("ARABIC LETTER DOTLESS FEH" #x06A1)
+    ("ARABIC LETTER FEH WITH DOT MOVED BELOW" #x06A2)
+    ("ARABIC LETTER FEH WITH DOT BELOW" #x06A3)
+    ("ARABIC LETTER VEH" #x06A4)
+    ("ARABIC LETTER FEH WITH THREE DOTS BELOW" #x06A5)
+    ("ARABIC LETTER PEHEH" #x06A6)
+    ("ARABIC LETTER QAF WITH DOT ABOVE" #x06A7)
+    ("ARABIC LETTER QAF WITH THREE DOTS ABOVE" #x06A8)
+    ("ARABIC LETTER KEHEH" #x06A9)
+    ("ARABIC LETTER SWASH KAF" #x06AA)
+    ("ARABIC LETTER KAF WITH RING" #x06AB)
+    ("ARABIC LETTER KAF WITH DOT ABOVE" #x06AC)
+    ("ARABIC LETTER NG" #x06AD)
+    ("ARABIC LETTER KAF WITH THREE DOTS BELOW" #x06AE)
+    ("ARABIC LETTER GAF" #x06AF)
+    ("ARABIC LETTER GAF WITH RING" #x06B0)
+    ("ARABIC LETTER NGOEH" #x06B1)
+    ("ARABIC LETTER GAF WITH TWO DOTS BELOW" #x06B2)
+    ("ARABIC LETTER GUEH" #x06B3)
+    ("ARABIC LETTER GAF WITH THREE DOTS ABOVE" #x06B4)
+    ("ARABIC LETTER LAM WITH SMALL V" #x06B5)
+    ("ARABIC LETTER LAM WITH DOT ABOVE" #x06B6)
+    ("ARABIC LETTER LAM WITH THREE DOTS ABOVE" #x06B7)
+    ("ARABIC LETTER LAM WITH THREE DOTS BELOW" #x06B8)
+    ("ARABIC LETTER NOON WITH DOT BELOW" #x06B9)
+    ("ARABIC LETTER NOON GHUNNA" #x06BA)
+    ("ARABIC LETTER RNOON" #x06BB)
+    ("ARABIC LETTER NOON WITH RING" #x06BC)
+    ("ARABIC LETTER NOON WITH THREE DOTS ABOVE" #x06BD)
+    ("ARABIC LETTER HEH DOACHASHMEE" #x06BE)
+    ("ARABIC LETTER TCHEH WITH DOT ABOVE" #x06BF)
+    ("ARABIC LETTER HEH WITH YEH ABOVE" #x06C0)
+    ("ARABIC LETTER HEH GOAL" #x06C1)
+    ("ARABIC LETTER HEH GOAL WITH HAMZA ABOVE" #x06C2)
+    ("ARABIC LETTER TEH MARBUTA GOAL" #x06C3)
+    ("ARABIC LETTER WAW WITH RING" #x06C4)
+    ("ARABIC LETTER KIRGHIZ OE" #x06C5)
+    ("ARABIC LETTER OE" #x06C6)
+    ("ARABIC LETTER U" #x06C7)
+    ("ARABIC LETTER YU" #x06C8)
+    ("ARABIC LETTER KIRGHIZ YU" #x06C9)
+    ("ARABIC LETTER WAW WITH TWO DOTS ABOVE" #x06CA)
+    ("ARABIC LETTER VE" #x06CB)
+    ("ARABIC LETTER FARSI YEH" #x06CC)
+    ("ARABIC LETTER YEH WITH TAIL" #x06CD)
+    ("ARABIC LETTER YEH WITH SMALL V" #x06CE)
+    ("ARABIC LETTER WAW WITH DOT ABOVE" #x06CF)
+    ("ARABIC LETTER E" #x06D0)
+    ("ARABIC LETTER YEH WITH THREE DOTS BELOW" #x06D1)
+    ("ARABIC LETTER YEH BARREE" #x06D2)
+    ("ARABIC LETTER YEH BARREE WITH HAMZA ABOVE" #x06D3)
+    ("ARABIC FULL STOP" #x06D4)
+    ("ARABIC LETTER AE" #x06D5)
+    ("ARABIC SMALL HIGH LIGATURE SAD WITH LAM WITH ALEF MAKSURA" #x06D6)
+    ("ARABIC SMALL HIGH LIGATURE QAF WITH LAM WITH ALEF MAKSURA" #x06D7)
+    ("ARABIC SMALL HIGH MEEM INITIAL FORM" #x06D8)
+    ("ARABIC SMALL HIGH LAM ALEF" #x06D9)
+    ("ARABIC SMALL HIGH JEEM" #x06DA)
+    ("ARABIC SMALL HIGH THREE DOTS" #x06DB)
+    ("ARABIC SMALL HIGH SEEN" #x06DC)
+    ("ARABIC END OF AYAH" #x06DD)
+    ("ARABIC START OF RUB EL HIZB" #x06DE)
+    ("ARABIC SMALL HIGH ROUNDED ZERO" #x06DF)
+    ("ARABIC SMALL HIGH UPRIGHT RECTANGULAR ZERO" #x06E0)
+    ("ARABIC SMALL HIGH DOTLESS HEAD OF KHAH" #x06E1)
+    ("ARABIC SMALL HIGH MEEM ISOLATED FORM" #x06E2)
+    ("ARABIC SMALL LOW SEEN" #x06E3)
+    ("ARABIC SMALL HIGH MADDA" #x06E4)
+    ("ARABIC SMALL WAW" #x06E5)
+    ("ARABIC SMALL YEH" #x06E6)
+    ("ARABIC SMALL HIGH YEH" #x06E7)
+    ("ARABIC SMALL HIGH NOON" #x06E8)
+    ("ARABIC PLACE OF SAJDAH" #x06E9)
+    ("ARABIC EMPTY CENTRE LOW STOP" #x06EA)
+    ("ARABIC EMPTY CENTRE HIGH STOP" #x06EB)
+    ("ARABIC ROUNDED HIGH STOP WITH FILLED CENTRE" #x06EC)
+    ("ARABIC SMALL LOW MEEM" #x06ED)
+    ("EXTENDED ARABIC-INDIC DIGIT ZERO" #x06F0)
+    ("EXTENDED ARABIC-INDIC DIGIT ONE" #x06F1)
+    ("EXTENDED ARABIC-INDIC DIGIT TWO" #x06F2)
+    ("EXTENDED ARABIC-INDIC DIGIT THREE" #x06F3)
+    ("EXTENDED ARABIC-INDIC DIGIT FOUR" #x06F4)
+    ("EXTENDED ARABIC-INDIC DIGIT FIVE" #x06F5)
+    ("EXTENDED ARABIC-INDIC DIGIT SIX" #x06F6)
+    ("EXTENDED ARABIC-INDIC DIGIT SEVEN" #x06F7)
+    ("EXTENDED ARABIC-INDIC DIGIT EIGHT" #x06F8)
+    ("EXTENDED ARABIC-INDIC DIGIT NINE" #x06F9)
+    ("ARABIC LETTER SHEEN WITH DOT BELOW" #x06FA)
+    ("ARABIC LETTER DAD WITH DOT BELOW" #x06FB)
+    ("ARABIC LETTER GHAIN WITH DOT BELOW" #x06FC)
+    ("ARABIC SIGN SINDHI AMPERSAND" #x06FD)
+    ("ARABIC SIGN SINDHI POSTPOSITION MEN" #x06FE)
+    ))
diff --git a/lisp/nxml/char-name/unicode/00700-0074F.el b/lisp/nxml/char-name/unicode/00700-0074F.el
new file mode 100644
index 00000000000..434861cf2b5
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/00700-0074F.el
@@ -0,0 +1,73 @@
+(nxml-define-char-name-set 'syriac
+  '(("SYRIAC END OF PARAGRAPH" #x0700)
+    ("SYRIAC SUPRALINEAR FULL STOP" #x0701)
+    ("SYRIAC SUBLINEAR FULL STOP" #x0702)
+    ("SYRIAC SUPRALINEAR COLON" #x0703)
+    ("SYRIAC SUBLINEAR COLON" #x0704)
+    ("SYRIAC HORIZONTAL COLON" #x0705)
+    ("SYRIAC COLON SKEWED LEFT" #x0706)
+    ("SYRIAC COLON SKEWED RIGHT" #x0707)
+    ("SYRIAC SUPRALINEAR COLON SKEWED LEFT" #x0708)
+    ("SYRIAC SUBLINEAR COLON SKEWED RIGHT" #x0709)
+    ("SYRIAC CONTRACTION" #x070A)
+    ("SYRIAC HARKLEAN OBELUS" #x070B)
+    ("SYRIAC HARKLEAN METOBELUS" #x070C)
+    ("SYRIAC HARKLEAN ASTERISCUS" #x070D)
+    ("SYRIAC ABBREVIATION MARK" #x070F)
+    ("SYRIAC LETTER ALAPH" #x0710)
+    ("SYRIAC LETTER SUPERSCRIPT ALAPH" #x0711)
+    ("SYRIAC LETTER BETH" #x0712)
+    ("SYRIAC LETTER GAMAL" #x0713)
+    ("SYRIAC LETTER GAMAL GARSHUNI" #x0714)
+    ("SYRIAC LETTER DALATH" #x0715)
+    ("SYRIAC LETTER DOTLESS DALATH RISH" #x0716)
+    ("SYRIAC LETTER HE" #x0717)
+    ("SYRIAC LETTER WAW" #x0718)
+    ("SYRIAC LETTER ZAIN" #x0719)
+    ("SYRIAC LETTER HETH" #x071A)
+    ("SYRIAC LETTER TETH" #x071B)
+    ("SYRIAC LETTER TETH GARSHUNI" #x071C)
+    ("SYRIAC LETTER YUDH" #x071D)
+    ("SYRIAC LETTER YUDH HE" #x071E)
+    ("SYRIAC LETTER KAPH" #x071F)
+    ("SYRIAC LETTER LAMADH" #x0720)
+    ("SYRIAC LETTER MIM" #x0721)
+    ("SYRIAC LETTER NUN" #x0722)
+    ("SYRIAC LETTER SEMKATH" #x0723)
+    ("SYRIAC LETTER FINAL SEMKATH" #x0724)
+    ("SYRIAC LETTER E" #x0725)
+    ("SYRIAC LETTER PE" #x0726)
+    ("SYRIAC LETTER REVERSED PE" #x0727)
+    ("SYRIAC LETTER SADHE" #x0728)
+    ("SYRIAC LETTER QAPH" #x0729)
+    ("SYRIAC LETTER RISH" #x072A)
+    ("SYRIAC LETTER SHIN" #x072B)
+    ("SYRIAC LETTER TAW" #x072C)
+    ("SYRIAC PTHAHA ABOVE" #x0730)
+    ("SYRIAC PTHAHA BELOW" #x0731)
+    ("SYRIAC PTHAHA DOTTED" #x0732)
+    ("SYRIAC ZQAPHA ABOVE" #x0733)
+    ("SYRIAC ZQAPHA BELOW" #x0734)
+    ("SYRIAC ZQAPHA DOTTED" #x0735)
+    ("SYRIAC RBASA ABOVE" #x0736)
+    ("SYRIAC RBASA BELOW" #x0737)
+    ("SYRIAC DOTTED ZLAMA HORIZONTAL" #x0738)
+    ("SYRIAC DOTTED ZLAMA ANGULAR" #x0739)
+    ("SYRIAC HBASA ABOVE" #x073A)
+    ("SYRIAC HBASA BELOW" #x073B)
+    ("SYRIAC HBASA-ESASA DOTTED" #x073C)
+    ("SYRIAC ESASA ABOVE" #x073D)
+    ("SYRIAC ESASA BELOW" #x073E)
+    ("SYRIAC RWAHA" #x073F)
+    ("SYRIAC FEMININE DOT" #x0740)
+    ("SYRIAC QUSHSHAYA" #x0741)
+    ("SYRIAC RUKKAKHA" #x0742)
+    ("SYRIAC TWO VERTICAL DOTS ABOVE" #x0743)
+    ("SYRIAC TWO VERTICAL DOTS BELOW" #x0744)
+    ("SYRIAC THREE DOTS ABOVE" #x0745)
+    ("SYRIAC THREE DOTS BELOW" #x0746)
+    ("SYRIAC OBLIQUE LINE ABOVE" #x0747)
+    ("SYRIAC OBLIQUE LINE BELOW" #x0748)
+    ("SYRIAC MUSIC" #x0749)
+    ("SYRIAC BARREKH" #x074A)
+    ))
diff --git a/lisp/nxml/char-name/unicode/00780-007BF.el b/lisp/nxml/char-name/unicode/00780-007BF.el
new file mode 100644
index 00000000000..bb572921ddc
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/00780-007BF.el
@@ -0,0 +1,52 @@
+(nxml-define-char-name-set 'thaana
+  '(("THAANA LETTER HAA" #x0780)
+    ("THAANA LETTER SHAVIYANI" #x0781)
+    ("THAANA LETTER NOONU" #x0782)
+    ("THAANA LETTER RAA" #x0783)
+    ("THAANA LETTER BAA" #x0784)
+    ("THAANA LETTER LHAVIYANI" #x0785)
+    ("THAANA LETTER KAAFU" #x0786)
+    ("THAANA LETTER ALIFU" #x0787)
+    ("THAANA LETTER VAAVU" #x0788)
+    ("THAANA LETTER MEEMU" #x0789)
+    ("THAANA LETTER FAAFU" #x078A)
+    ("THAANA LETTER DHAALU" #x078B)
+    ("THAANA LETTER THAA" #x078C)
+    ("THAANA LETTER LAAMU" #x078D)
+    ("THAANA LETTER GAAFU" #x078E)
+    ("THAANA LETTER GNAVIYANI" #x078F)
+    ("THAANA LETTER SEENU" #x0790)
+    ("THAANA LETTER DAVIYANI" #x0791)
+    ("THAANA LETTER ZAVIYANI" #x0792)
+    ("THAANA LETTER TAVIYANI" #x0793)
+    ("THAANA LETTER YAA" #x0794)
+    ("THAANA LETTER PAVIYANI" #x0795)
+    ("THAANA LETTER JAVIYANI" #x0796)
+    ("THAANA LETTER CHAVIYANI" #x0797)
+    ("THAANA LETTER TTAA" #x0798)
+    ("THAANA LETTER HHAA" #x0799)
+    ("THAANA LETTER KHAA" #x079A)
+    ("THAANA LETTER THAALU" #x079B)
+    ("THAANA LETTER ZAA" #x079C)
+    ("THAANA LETTER SHEENU" #x079D)
+    ("THAANA LETTER SAADHU" #x079E)
+    ("THAANA LETTER DAADHU" #x079F)
+    ("THAANA LETTER TO" #x07A0)
+    ("THAANA LETTER ZO" #x07A1)
+    ("THAANA LETTER AINU" #x07A2)
+    ("THAANA LETTER GHAINU" #x07A3)
+    ("THAANA LETTER QAAFU" #x07A4)
+    ("THAANA LETTER WAAVU" #x07A5)
+    ("THAANA ABAFILI" #x07A6)
+    ("THAANA AABAAFILI" #x07A7)
+    ("THAANA IBIFILI" #x07A8)
+    ("THAANA EEBEEFILI" #x07A9)
+    ("THAANA UBUFILI" #x07AA)
+    ("THAANA OOBOOFILI" #x07AB)
+    ("THAANA EBEFILI" #x07AC)
+    ("THAANA EYBEYFILI" #x07AD)
+    ("THAANA OBOFILI" #x07AE)
+    ("THAANA OABOAFILI" #x07AF)
+    ("THAANA SUKUN" #x07B0)
+    ("THAANA LETTER NAA" #x07B1)
+    ))
diff --git a/lisp/nxml/char-name/unicode/00900-0097F.el b/lisp/nxml/char-name/unicode/00900-0097F.el
new file mode 100644
index 00000000000..c93dd4654b2
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/00900-0097F.el
@@ -0,0 +1,106 @@
+(nxml-define-char-name-set 'devanagari
+  '(("DEVANAGARI SIGN CANDRABINDU" #x0901)
+    ("DEVANAGARI SIGN ANUSVARA" #x0902)
+    ("DEVANAGARI SIGN VISARGA" #x0903)
+    ("DEVANAGARI LETTER A" #x0905)
+    ("DEVANAGARI LETTER AA" #x0906)
+    ("DEVANAGARI LETTER I" #x0907)
+    ("DEVANAGARI LETTER II" #x0908)
+    ("DEVANAGARI LETTER U" #x0909)
+    ("DEVANAGARI LETTER UU" #x090A)
+    ("DEVANAGARI LETTER VOCALIC R" #x090B)
+    ("DEVANAGARI LETTER VOCALIC L" #x090C)
+    ("DEVANAGARI LETTER CANDRA E" #x090D)
+    ("DEVANAGARI LETTER SHORT E" #x090E)
+    ("DEVANAGARI LETTER E" #x090F)
+    ("DEVANAGARI LETTER AI" #x0910)
+    ("DEVANAGARI LETTER CANDRA O" #x0911)
+    ("DEVANAGARI LETTER SHORT O" #x0912)
+    ("DEVANAGARI LETTER O" #x0913)
+    ("DEVANAGARI LETTER AU" #x0914)
+    ("DEVANAGARI LETTER KA" #x0915)
+    ("DEVANAGARI LETTER KHA" #x0916)
+    ("DEVANAGARI LETTER GA" #x0917)
+    ("DEVANAGARI LETTER GHA" #x0918)
+    ("DEVANAGARI LETTER NGA" #x0919)
+    ("DEVANAGARI LETTER CA" #x091A)
+    ("DEVANAGARI LETTER CHA" #x091B)
+    ("DEVANAGARI LETTER JA" #x091C)
+    ("DEVANAGARI LETTER JHA" #x091D)
+    ("DEVANAGARI LETTER NYA" #x091E)
+    ("DEVANAGARI LETTER TTA" #x091F)
+    ("DEVANAGARI LETTER TTHA" #x0920)
+    ("DEVANAGARI LETTER DDA" #x0921)
+    ("DEVANAGARI LETTER DDHA" #x0922)
+    ("DEVANAGARI LETTER NNA" #x0923)
+    ("DEVANAGARI LETTER TA" #x0924)
+    ("DEVANAGARI LETTER THA" #x0925)
+    ("DEVANAGARI LETTER DA" #x0926)
+    ("DEVANAGARI LETTER DHA" #x0927)
+    ("DEVANAGARI LETTER NA" #x0928)
+    ("DEVANAGARI LETTER NNNA" #x0929)
+    ("DEVANAGARI LETTER PA" #x092A)
+    ("DEVANAGARI LETTER PHA" #x092B)
+    ("DEVANAGARI LETTER BA" #x092C)
+    ("DEVANAGARI LETTER BHA" #x092D)
+    ("DEVANAGARI LETTER MA" #x092E)
+    ("DEVANAGARI LETTER YA" #x092F)
+    ("DEVANAGARI LETTER RA" #x0930)
+    ("DEVANAGARI LETTER RRA" #x0931)
+    ("DEVANAGARI LETTER LA" #x0932)
+    ("DEVANAGARI LETTER LLA" #x0933)
+    ("DEVANAGARI LETTER LLLA" #x0934)
+    ("DEVANAGARI LETTER VA" #x0935)
+    ("DEVANAGARI LETTER SHA" #x0936)
+    ("DEVANAGARI LETTER SSA" #x0937)
+    ("DEVANAGARI LETTER SA" #x0938)
+    ("DEVANAGARI LETTER HA" #x0939)
+    ("DEVANAGARI SIGN NUKTA" #x093C)
+    ("DEVANAGARI SIGN AVAGRAHA" #x093D)
+    ("DEVANAGARI VOWEL SIGN AA" #x093E)
+    ("DEVANAGARI VOWEL SIGN I" #x093F)
+    ("DEVANAGARI VOWEL SIGN II" #x0940)
+    ("DEVANAGARI VOWEL SIGN U" #x0941)
+    ("DEVANAGARI VOWEL SIGN UU" #x0942)
+    ("DEVANAGARI VOWEL SIGN VOCALIC R" #x0943)
+    ("DEVANAGARI VOWEL SIGN VOCALIC RR" #x0944)
+    ("DEVANAGARI VOWEL SIGN CANDRA E" #x0945)
+    ("DEVANAGARI VOWEL SIGN SHORT E" #x0946)
+    ("DEVANAGARI VOWEL SIGN E" #x0947)
+    ("DEVANAGARI VOWEL SIGN AI" #x0948)
+    ("DEVANAGARI VOWEL SIGN CANDRA O" #x0949)
+    ("DEVANAGARI VOWEL SIGN SHORT O" #x094A)
+    ("DEVANAGARI VOWEL SIGN O" #x094B)
+    ("DEVANAGARI VOWEL SIGN AU" #x094C)
+    ("DEVANAGARI SIGN VIRAMA" #x094D)
+    ("DEVANAGARI OM" #x0950)
+    ("DEVANAGARI STRESS SIGN UDATTA" #x0951)
+    ("DEVANAGARI STRESS SIGN ANUDATTA" #x0952)
+    ("DEVANAGARI GRAVE ACCENT" #x0953)
+    ("DEVANAGARI ACUTE ACCENT" #x0954)
+    ("DEVANAGARI LETTER QA" #x0958)
+    ("DEVANAGARI LETTER KHHA" #x0959)
+    ("DEVANAGARI LETTER GHHA" #x095A)
+    ("DEVANAGARI LETTER ZA" #x095B)
+    ("DEVANAGARI LETTER DDDHA" #x095C)
+    ("DEVANAGARI LETTER RHA" #x095D)
+    ("DEVANAGARI LETTER FA" #x095E)
+    ("DEVANAGARI LETTER YYA" #x095F)
+    ("DEVANAGARI LETTER VOCALIC RR" #x0960)
+    ("DEVANAGARI LETTER VOCALIC LL" #x0961)
+    ("DEVANAGARI VOWEL SIGN VOCALIC L" #x0962)
+    ("DEVANAGARI VOWEL SIGN VOCALIC LL" #x0963)
+    ("DEVANAGARI DANDA" #x0964)
+    ("DEVANAGARI DOUBLE DANDA" #x0965)
+    ("DEVANAGARI DIGIT ZERO" #x0966)
+    ("DEVANAGARI DIGIT ONE" #x0967)
+    ("DEVANAGARI DIGIT TWO" #x0968)
+    ("DEVANAGARI DIGIT THREE" #x0969)
+    ("DEVANAGARI DIGIT FOUR" #x096A)
+    ("DEVANAGARI DIGIT FIVE" #x096B)
+    ("DEVANAGARI DIGIT SIX" #x096C)
+    ("DEVANAGARI DIGIT SEVEN" #x096D)
+    ("DEVANAGARI DIGIT EIGHT" #x096E)
+    ("DEVANAGARI DIGIT NINE" #x096F)
+    ("DEVANAGARI ABBREVIATION SIGN" #x0970)
+    ))
diff --git a/lisp/nxml/char-name/unicode/00980-009FF.el b/lisp/nxml/char-name/unicode/00980-009FF.el
new file mode 100644
index 00000000000..cfae10e0950
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/00980-009FF.el
@@ -0,0 +1,91 @@
+(nxml-define-char-name-set 'bengali
+  '(("BENGALI SIGN CANDRABINDU" #x0981)
+    ("BENGALI SIGN ANUSVARA" #x0982)
+    ("BENGALI SIGN VISARGA" #x0983)
+    ("BENGALI LETTER A" #x0985)
+    ("BENGALI LETTER AA" #x0986)
+    ("BENGALI LETTER I" #x0987)
+    ("BENGALI LETTER II" #x0988)
+    ("BENGALI LETTER U" #x0989)
+    ("BENGALI LETTER UU" #x098A)
+    ("BENGALI LETTER VOCALIC R" #x098B)
+    ("BENGALI LETTER VOCALIC L" #x098C)
+    ("BENGALI LETTER E" #x098F)
+    ("BENGALI LETTER AI" #x0990)
+    ("BENGALI LETTER O" #x0993)
+    ("BENGALI LETTER AU" #x0994)
+    ("BENGALI LETTER KA" #x0995)
+    ("BENGALI LETTER KHA" #x0996)
+    ("BENGALI LETTER GA" #x0997)
+    ("BENGALI LETTER GHA" #x0998)
+    ("BENGALI LETTER NGA" #x0999)
+    ("BENGALI LETTER CA" #x099A)
+    ("BENGALI LETTER CHA" #x099B)
+    ("BENGALI LETTER JA" #x099C)
+    ("BENGALI LETTER JHA" #x099D)
+    ("BENGALI LETTER NYA" #x099E)
+    ("BENGALI LETTER TTA" #x099F)
+    ("BENGALI LETTER TTHA" #x09A0)
+    ("BENGALI LETTER DDA" #x09A1)
+    ("BENGALI LETTER DDHA" #x09A2)
+    ("BENGALI LETTER NNA" #x09A3)
+    ("BENGALI LETTER TA" #x09A4)
+    ("BENGALI LETTER THA" #x09A5)
+    ("BENGALI LETTER DA" #x09A6)
+    ("BENGALI LETTER DHA" #x09A7)
+    ("BENGALI LETTER NA" #x09A8)
+    ("BENGALI LETTER PA" #x09AA)
+    ("BENGALI LETTER PHA" #x09AB)
+    ("BENGALI LETTER BA" #x09AC)
+    ("BENGALI LETTER BHA" #x09AD)
+    ("BENGALI LETTER MA" #x09AE)
+    ("BENGALI LETTER YA" #x09AF)
+    ("BENGALI LETTER RA" #x09B0)
+    ("BENGALI LETTER LA" #x09B2)
+    ("BENGALI LETTER SHA" #x09B6)
+    ("BENGALI LETTER SSA" #x09B7)
+    ("BENGALI LETTER SA" #x09B8)
+    ("BENGALI LETTER HA" #x09B9)
+    ("BENGALI SIGN NUKTA" #x09BC)
+    ("BENGALI VOWEL SIGN AA" #x09BE)
+    ("BENGALI VOWEL SIGN I" #x09BF)
+    ("BENGALI VOWEL SIGN II" #x09C0)
+    ("BENGALI VOWEL SIGN U" #x09C1)
+    ("BENGALI VOWEL SIGN UU" #x09C2)
+    ("BENGALI VOWEL SIGN VOCALIC R" #x09C3)
+    ("BENGALI VOWEL SIGN VOCALIC RR" #x09C4)
+    ("BENGALI VOWEL SIGN E" #x09C7)
+    ("BENGALI VOWEL SIGN AI" #x09C8)
+    ("BENGALI VOWEL SIGN O" #x09CB)
+    ("BENGALI VOWEL SIGN AU" #x09CC)
+    ("BENGALI SIGN VIRAMA" #x09CD)
+    ("BENGALI AU LENGTH MARK" #x09D7)
+    ("BENGALI LETTER RRA" #x09DC)
+    ("BENGALI LETTER RHA" #x09DD)
+    ("BENGALI LETTER YYA" #x09DF)
+    ("BENGALI LETTER VOCALIC RR" #x09E0)
+    ("BENGALI LETTER VOCALIC LL" #x09E1)
+    ("BENGALI VOWEL SIGN VOCALIC L" #x09E2)
+    ("BENGALI VOWEL SIGN VOCALIC LL" #x09E3)
+    ("BENGALI DIGIT ZERO" #x09E6)
+    ("BENGALI DIGIT ONE" #x09E7)
+    ("BENGALI DIGIT TWO" #x09E8)
+    ("BENGALI DIGIT THREE" #x09E9)
+    ("BENGALI DIGIT FOUR" #x09EA)
+    ("BENGALI DIGIT FIVE" #x09EB)
+    ("BENGALI DIGIT SIX" #x09EC)
+    ("BENGALI DIGIT SEVEN" #x09ED)
+    ("BENGALI DIGIT EIGHT" #x09EE)
+    ("BENGALI DIGIT NINE" #x09EF)
+    ("BENGALI LETTER RA WITH MIDDLE DIAGONAL" #x09F0)
+    ("BENGALI LETTER RA WITH LOWER DIAGONAL" #x09F1)
+    ("BENGALI RUPEE MARK" #x09F2)
+    ("BENGALI RUPEE SIGN" #x09F3)
+    ("BENGALI CURRENCY NUMERATOR ONE" #x09F4)
+    ("BENGALI CURRENCY NUMERATOR TWO" #x09F5)
+    ("BENGALI CURRENCY NUMERATOR THREE" #x09F6)
+    ("BENGALI CURRENCY NUMERATOR FOUR" #x09F7)
+    ("BENGALI CURRENCY NUMERATOR ONE LESS THAN THE DENOMINATOR" #x09F8)
+    ("BENGALI CURRENCY DENOMINATOR SIXTEEN" #x09F9)
+    ("BENGALI ISSHAR" #x09FA)
+    ))
diff --git a/lisp/nxml/char-name/unicode/00A00-00A7F.el b/lisp/nxml/char-name/unicode/00A00-00A7F.el
new file mode 100644
index 00000000000..5adfaed0ef1
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/00A00-00A7F.el
@@ -0,0 +1,77 @@
+(nxml-define-char-name-set 'gurmukhi
+  '(("GURMUKHI SIGN BINDI" #x0A02)
+    ("GURMUKHI LETTER A" #x0A05)
+    ("GURMUKHI LETTER AA" #x0A06)
+    ("GURMUKHI LETTER I" #x0A07)
+    ("GURMUKHI LETTER II" #x0A08)
+    ("GURMUKHI LETTER U" #x0A09)
+    ("GURMUKHI LETTER UU" #x0A0A)
+    ("GURMUKHI LETTER EE" #x0A0F)
+    ("GURMUKHI LETTER AI" #x0A10)
+    ("GURMUKHI LETTER OO" #x0A13)
+    ("GURMUKHI LETTER AU" #x0A14)
+    ("GURMUKHI LETTER KA" #x0A15)
+    ("GURMUKHI LETTER KHA" #x0A16)
+    ("GURMUKHI LETTER GA" #x0A17)
+    ("GURMUKHI LETTER GHA" #x0A18)
+    ("GURMUKHI LETTER NGA" #x0A19)
+    ("GURMUKHI LETTER CA" #x0A1A)
+    ("GURMUKHI LETTER CHA" #x0A1B)
+    ("GURMUKHI LETTER JA" #x0A1C)
+    ("GURMUKHI LETTER JHA" #x0A1D)
+    ("GURMUKHI LETTER NYA" #x0A1E)
+    ("GURMUKHI LETTER TTA" #x0A1F)
+    ("GURMUKHI LETTER TTHA" #x0A20)
+    ("GURMUKHI LETTER DDA" #x0A21)
+    ("GURMUKHI LETTER DDHA" #x0A22)
+    ("GURMUKHI LETTER NNA" #x0A23)
+    ("GURMUKHI LETTER TA" #x0A24)
+    ("GURMUKHI LETTER THA" #x0A25)
+    ("GURMUKHI LETTER DA" #x0A26)
+    ("GURMUKHI LETTER DHA" #x0A27)
+    ("GURMUKHI LETTER NA" #x0A28)
+    ("GURMUKHI LETTER PA" #x0A2A)
+    ("GURMUKHI LETTER PHA" #x0A2B)
+    ("GURMUKHI LETTER BA" #x0A2C)
+    ("GURMUKHI LETTER BHA" #x0A2D)
+    ("GURMUKHI LETTER MA" #x0A2E)
+    ("GURMUKHI LETTER YA" #x0A2F)
+    ("GURMUKHI LETTER RA" #x0A30)
+    ("GURMUKHI LETTER LA" #x0A32)
+    ("GURMUKHI LETTER LLA" #x0A33)
+    ("GURMUKHI LETTER VA" #x0A35)
+    ("GURMUKHI LETTER SHA" #x0A36)
+    ("GURMUKHI LETTER SA" #x0A38)
+    ("GURMUKHI LETTER HA" #x0A39)
+    ("GURMUKHI SIGN NUKTA" #x0A3C)
+    ("GURMUKHI VOWEL SIGN AA" #x0A3E)
+    ("GURMUKHI VOWEL SIGN I" #x0A3F)
+    ("GURMUKHI VOWEL SIGN II" #x0A40)
+    ("GURMUKHI VOWEL SIGN U" #x0A41)
+    ("GURMUKHI VOWEL SIGN UU" #x0A42)
+    ("GURMUKHI VOWEL SIGN EE" #x0A47)
+    ("GURMUKHI VOWEL SIGN AI" #x0A48)
+    ("GURMUKHI VOWEL SIGN OO" #x0A4B)
+    ("GURMUKHI VOWEL SIGN AU" #x0A4C)
+    ("GURMUKHI SIGN VIRAMA" #x0A4D)
+    ("GURMUKHI LETTER KHHA" #x0A59)
+    ("GURMUKHI LETTER GHHA" #x0A5A)
+    ("GURMUKHI LETTER ZA" #x0A5B)
+    ("GURMUKHI LETTER RRA" #x0A5C)
+    ("GURMUKHI LETTER FA" #x0A5E)
+    ("GURMUKHI DIGIT ZERO" #x0A66)
+    ("GURMUKHI DIGIT ONE" #x0A67)
+    ("GURMUKHI DIGIT TWO" #x0A68)
+    ("GURMUKHI DIGIT THREE" #x0A69)
+    ("GURMUKHI DIGIT FOUR" #x0A6A)
+    ("GURMUKHI DIGIT FIVE" #x0A6B)
+    ("GURMUKHI DIGIT SIX" #x0A6C)
+    ("GURMUKHI DIGIT SEVEN" #x0A6D)
+    ("GURMUKHI DIGIT EIGHT" #x0A6E)
+    ("GURMUKHI DIGIT NINE" #x0A6F)
+    ("GURMUKHI TIPPI" #x0A70)
+    ("GURMUKHI ADDAK" #x0A71)
+    ("GURMUKHI IRI" #x0A72)
+    ("GURMUKHI URA" #x0A73)
+    ("GURMUKHI EK ONKAR" #x0A74)
+    ))
diff --git a/lisp/nxml/char-name/unicode/00A80-00AFF.el b/lisp/nxml/char-name/unicode/00A80-00AFF.el
new file mode 100644
index 00000000000..35be7fa7a55
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/00A80-00AFF.el
@@ -0,0 +1,80 @@
+(nxml-define-char-name-set 'gujarati
+  '(("GUJARATI SIGN CANDRABINDU" #x0A81)
+    ("GUJARATI SIGN ANUSVARA" #x0A82)
+    ("GUJARATI SIGN VISARGA" #x0A83)
+    ("GUJARATI LETTER A" #x0A85)
+    ("GUJARATI LETTER AA" #x0A86)
+    ("GUJARATI LETTER I" #x0A87)
+    ("GUJARATI LETTER II" #x0A88)
+    ("GUJARATI LETTER U" #x0A89)
+    ("GUJARATI LETTER UU" #x0A8A)
+    ("GUJARATI LETTER VOCALIC R" #x0A8B)
+    ("GUJARATI VOWEL CANDRA E" #x0A8D)
+    ("GUJARATI LETTER E" #x0A8F)
+    ("GUJARATI LETTER AI" #x0A90)
+    ("GUJARATI VOWEL CANDRA O" #x0A91)
+    ("GUJARATI LETTER O" #x0A93)
+    ("GUJARATI LETTER AU" #x0A94)
+    ("GUJARATI LETTER KA" #x0A95)
+    ("GUJARATI LETTER KHA" #x0A96)
+    ("GUJARATI LETTER GA" #x0A97)
+    ("GUJARATI LETTER GHA" #x0A98)
+    ("GUJARATI LETTER NGA" #x0A99)
+    ("GUJARATI LETTER CA" #x0A9A)
+    ("GUJARATI LETTER CHA" #x0A9B)
+    ("GUJARATI LETTER JA" #x0A9C)
+    ("GUJARATI LETTER JHA" #x0A9D)
+    ("GUJARATI LETTER NYA" #x0A9E)
+    ("GUJARATI LETTER TTA" #x0A9F)
+    ("GUJARATI LETTER TTHA" #x0AA0)
+    ("GUJARATI LETTER DDA" #x0AA1)
+    ("GUJARATI LETTER DDHA" #x0AA2)
+    ("GUJARATI LETTER NNA" #x0AA3)
+    ("GUJARATI LETTER TA" #x0AA4)
+    ("GUJARATI LETTER THA" #x0AA5)
+    ("GUJARATI LETTER DA" #x0AA6)
+    ("GUJARATI LETTER DHA" #x0AA7)
+    ("GUJARATI LETTER NA" #x0AA8)
+    ("GUJARATI LETTER PA" #x0AAA)
+    ("GUJARATI LETTER PHA" #x0AAB)
+    ("GUJARATI LETTER BA" #x0AAC)
+    ("GUJARATI LETTER BHA" #x0AAD)
+    ("GUJARATI LETTER MA" #x0AAE)
+    ("GUJARATI LETTER YA" #x0AAF)
+    ("GUJARATI LETTER RA" #x0AB0)
+    ("GUJARATI LETTER LA" #x0AB2)
+    ("GUJARATI LETTER LLA" #x0AB3)
+    ("GUJARATI LETTER VA" #x0AB5)
+    ("GUJARATI LETTER SHA" #x0AB6)
+    ("GUJARATI LETTER SSA" #x0AB7)
+    ("GUJARATI LETTER SA" #x0AB8)
+    ("GUJARATI LETTER HA" #x0AB9)
+    ("GUJARATI SIGN NUKTA" #x0ABC)
+    ("GUJARATI SIGN AVAGRAHA" #x0ABD)
+    ("GUJARATI VOWEL SIGN AA" #x0ABE)
+    ("GUJARATI VOWEL SIGN I" #x0ABF)
+    ("GUJARATI VOWEL SIGN II" #x0AC0)
+    ("GUJARATI VOWEL SIGN U" #x0AC1)
+    ("GUJARATI VOWEL SIGN UU" #x0AC2)
+    ("GUJARATI VOWEL SIGN VOCALIC R" #x0AC3)
+    ("GUJARATI VOWEL SIGN VOCALIC RR" #x0AC4)
+    ("GUJARATI VOWEL SIGN CANDRA E" #x0AC5)
+    ("GUJARATI VOWEL SIGN E" #x0AC7)
+    ("GUJARATI VOWEL SIGN AI" #x0AC8)
+    ("GUJARATI VOWEL SIGN CANDRA O" #x0AC9)
+    ("GUJARATI VOWEL SIGN O" #x0ACB)
+    ("GUJARATI VOWEL SIGN AU" #x0ACC)
+    ("GUJARATI SIGN VIRAMA" #x0ACD)
+    ("GUJARATI OM" #x0AD0)
+    ("GUJARATI LETTER VOCALIC RR" #x0AE0)
+    ("GUJARATI DIGIT ZERO" #x0AE6)
+    ("GUJARATI DIGIT ONE" #x0AE7)
+    ("GUJARATI DIGIT TWO" #x0AE8)
+    ("GUJARATI DIGIT THREE" #x0AE9)
+    ("GUJARATI DIGIT FOUR" #x0AEA)
+    ("GUJARATI DIGIT FIVE" #x0AEB)
+    ("GUJARATI DIGIT SIX" #x0AEC)
+    ("GUJARATI DIGIT SEVEN" #x0AED)
+    ("GUJARATI DIGIT EIGHT" #x0AEE)
+    ("GUJARATI DIGIT NINE" #x0AEF)
+    ))
diff --git a/lisp/nxml/char-name/unicode/00B00-00B7F.el b/lisp/nxml/char-name/unicode/00B00-00B7F.el
new file mode 100644
index 00000000000..e0d08648c99
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/00B00-00B7F.el
@@ -0,0 +1,81 @@
+(nxml-define-char-name-set 'oriya
+  '(("ORIYA SIGN CANDRABINDU" #x0B01)
+    ("ORIYA SIGN ANUSVARA" #x0B02)
+    ("ORIYA SIGN VISARGA" #x0B03)
+    ("ORIYA LETTER A" #x0B05)
+    ("ORIYA LETTER AA" #x0B06)
+    ("ORIYA LETTER I" #x0B07)
+    ("ORIYA LETTER II" #x0B08)
+    ("ORIYA LETTER U" #x0B09)
+    ("ORIYA LETTER UU" #x0B0A)
+    ("ORIYA LETTER VOCALIC R" #x0B0B)
+    ("ORIYA LETTER VOCALIC L" #x0B0C)
+    ("ORIYA LETTER E" #x0B0F)
+    ("ORIYA LETTER AI" #x0B10)
+    ("ORIYA LETTER O" #x0B13)
+    ("ORIYA LETTER AU" #x0B14)
+    ("ORIYA LETTER KA" #x0B15)
+    ("ORIYA LETTER KHA" #x0B16)
+    ("ORIYA LETTER GA" #x0B17)
+    ("ORIYA LETTER GHA" #x0B18)
+    ("ORIYA LETTER NGA" #x0B19)
+    ("ORIYA LETTER CA" #x0B1A)
+    ("ORIYA LETTER CHA" #x0B1B)
+    ("ORIYA LETTER JA" #x0B1C)
+    ("ORIYA LETTER JHA" #x0B1D)
+    ("ORIYA LETTER NYA" #x0B1E)
+    ("ORIYA LETTER TTA" #x0B1F)
+    ("ORIYA LETTER TTHA" #x0B20)
+    ("ORIYA LETTER DDA" #x0B21)
+    ("ORIYA LETTER DDHA" #x0B22)
+    ("ORIYA LETTER NNA" #x0B23)
+    ("ORIYA LETTER TA" #x0B24)
+    ("ORIYA LETTER THA" #x0B25)
+    ("ORIYA LETTER DA" #x0B26)
+    ("ORIYA LETTER DHA" #x0B27)
+    ("ORIYA LETTER NA" #x0B28)
+    ("ORIYA LETTER PA" #x0B2A)
+    ("ORIYA LETTER PHA" #x0B2B)
+    ("ORIYA LETTER BA" #x0B2C)
+    ("ORIYA LETTER BHA" #x0B2D)
+    ("ORIYA LETTER MA" #x0B2E)
+    ("ORIYA LETTER YA" #x0B2F)
+    ("ORIYA LETTER RA" #x0B30)
+    ("ORIYA LETTER LA" #x0B32)
+    ("ORIYA LETTER LLA" #x0B33)
+    ("ORIYA LETTER SHA" #x0B36)
+    ("ORIYA LETTER SSA" #x0B37)
+    ("ORIYA LETTER SA" #x0B38)
+    ("ORIYA LETTER HA" #x0B39)
+    ("ORIYA SIGN NUKTA" #x0B3C)
+    ("ORIYA SIGN AVAGRAHA" #x0B3D)
+    ("ORIYA VOWEL SIGN AA" #x0B3E)
+    ("ORIYA VOWEL SIGN I" #x0B3F)
+    ("ORIYA VOWEL SIGN II" #x0B40)
+    ("ORIYA VOWEL SIGN U" #x0B41)
+    ("ORIYA VOWEL SIGN UU" #x0B42)
+    ("ORIYA VOWEL SIGN VOCALIC R" #x0B43)
+    ("ORIYA VOWEL SIGN E" #x0B47)
+    ("ORIYA VOWEL SIGN AI" #x0B48)
+    ("ORIYA VOWEL SIGN O" #x0B4B)
+    ("ORIYA VOWEL SIGN AU" #x0B4C)
+    ("ORIYA SIGN VIRAMA" #x0B4D)
+    ("ORIYA AI LENGTH MARK" #x0B56)
+    ("ORIYA AU LENGTH MARK" #x0B57)
+    ("ORIYA LETTER RRA" #x0B5C)
+    ("ORIYA LETTER RHA" #x0B5D)
+    ("ORIYA LETTER YYA" #x0B5F)
+    ("ORIYA LETTER VOCALIC RR" #x0B60)
+    ("ORIYA LETTER VOCALIC LL" #x0B61)
+    ("ORIYA DIGIT ZERO" #x0B66)
+    ("ORIYA DIGIT ONE" #x0B67)
+    ("ORIYA DIGIT TWO" #x0B68)
+    ("ORIYA DIGIT THREE" #x0B69)
+    ("ORIYA DIGIT FOUR" #x0B6A)
+    ("ORIYA DIGIT FIVE" #x0B6B)
+    ("ORIYA DIGIT SIX" #x0B6C)
+    ("ORIYA DIGIT SEVEN" #x0B6D)
+    ("ORIYA DIGIT EIGHT" #x0B6E)
+    ("ORIYA DIGIT NINE" #x0B6F)
+    ("ORIYA ISSHAR" #x0B70)
+    ))
diff --git a/lisp/nxml/char-name/unicode/00B80-00BFF.el b/lisp/nxml/char-name/unicode/00B80-00BFF.el
new file mode 100644
index 00000000000..8e23e1341c7
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/00B80-00BFF.el
@@ -0,0 +1,63 @@
+(nxml-define-char-name-set 'tamil
+  '(("TAMIL SIGN ANUSVARA" #x0B82)
+    ("TAMIL SIGN VISARGA" #x0B83)
+    ("TAMIL LETTER A" #x0B85)
+    ("TAMIL LETTER AA" #x0B86)
+    ("TAMIL LETTER I" #x0B87)
+    ("TAMIL LETTER II" #x0B88)
+    ("TAMIL LETTER U" #x0B89)
+    ("TAMIL LETTER UU" #x0B8A)
+    ("TAMIL LETTER E" #x0B8E)
+    ("TAMIL LETTER EE" #x0B8F)
+    ("TAMIL LETTER AI" #x0B90)
+    ("TAMIL LETTER O" #x0B92)
+    ("TAMIL LETTER OO" #x0B93)
+    ("TAMIL LETTER AU" #x0B94)
+    ("TAMIL LETTER KA" #x0B95)
+    ("TAMIL LETTER NGA" #x0B99)
+    ("TAMIL LETTER CA" #x0B9A)
+    ("TAMIL LETTER JA" #x0B9C)
+    ("TAMIL LETTER NYA" #x0B9E)
+    ("TAMIL LETTER TTA" #x0B9F)
+    ("TAMIL LETTER NNA" #x0BA3)
+    ("TAMIL LETTER TA" #x0BA4)
+    ("TAMIL LETTER NA" #x0BA8)
+    ("TAMIL LETTER NNNA" #x0BA9)
+    ("TAMIL LETTER PA" #x0BAA)
+    ("TAMIL LETTER MA" #x0BAE)
+    ("TAMIL LETTER YA" #x0BAF)
+    ("TAMIL LETTER RA" #x0BB0)
+    ("TAMIL LETTER RRA" #x0BB1)
+    ("TAMIL LETTER LA" #x0BB2)
+    ("TAMIL LETTER LLA" #x0BB3)
+    ("TAMIL LETTER LLLA" #x0BB4)
+    ("TAMIL LETTER VA" #x0BB5)
+    ("TAMIL LETTER SSA" #x0BB7)
+    ("TAMIL LETTER SA" #x0BB8)
+    ("TAMIL LETTER HA" #x0BB9)
+    ("TAMIL VOWEL SIGN AA" #x0BBE)
+    ("TAMIL VOWEL SIGN I" #x0BBF)
+    ("TAMIL VOWEL SIGN II" #x0BC0)
+    ("TAMIL VOWEL SIGN U" #x0BC1)
+    ("TAMIL VOWEL SIGN UU" #x0BC2)
+    ("TAMIL VOWEL SIGN E" #x0BC6)
+    ("TAMIL VOWEL SIGN EE" #x0BC7)
+    ("TAMIL VOWEL SIGN AI" #x0BC8)
+    ("TAMIL VOWEL SIGN O" #x0BCA)
+    ("TAMIL VOWEL SIGN OO" #x0BCB)
+    ("TAMIL VOWEL SIGN AU" #x0BCC)
+    ("TAMIL SIGN VIRAMA" #x0BCD)
+    ("TAMIL AU LENGTH MARK" #x0BD7)
+    ("TAMIL DIGIT ONE" #x0BE7)
+    ("TAMIL DIGIT TWO" #x0BE8)
+    ("TAMIL DIGIT THREE" #x0BE9)
+    ("TAMIL DIGIT FOUR" #x0BEA)
+    ("TAMIL DIGIT FIVE" #x0BEB)
+    ("TAMIL DIGIT SIX" #x0BEC)
+    ("TAMIL DIGIT SEVEN" #x0BED)
+    ("TAMIL DIGIT EIGHT" #x0BEE)
+    ("TAMIL DIGIT NINE" #x0BEF)
+    ("TAMIL NUMBER TEN" #x0BF0)
+    ("TAMIL NUMBER ONE HUNDRED" #x0BF1)
+    ("TAMIL NUMBER ONE THOUSAND" #x0BF2)
+    ))
diff --git a/lisp/nxml/char-name/unicode/00C00-00C7F.el b/lisp/nxml/char-name/unicode/00C00-00C7F.el
new file mode 100644
index 00000000000..ef70b35ee10
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/00C00-00C7F.el
@@ -0,0 +1,82 @@
+(nxml-define-char-name-set 'telugu
+  '(("TELUGU SIGN CANDRABINDU" #x0C01)
+    ("TELUGU SIGN ANUSVARA" #x0C02)
+    ("TELUGU SIGN VISARGA" #x0C03)
+    ("TELUGU LETTER A" #x0C05)
+    ("TELUGU LETTER AA" #x0C06)
+    ("TELUGU LETTER I" #x0C07)
+    ("TELUGU LETTER II" #x0C08)
+    ("TELUGU LETTER U" #x0C09)
+    ("TELUGU LETTER UU" #x0C0A)
+    ("TELUGU LETTER VOCALIC R" #x0C0B)
+    ("TELUGU LETTER VOCALIC L" #x0C0C)
+    ("TELUGU LETTER E" #x0C0E)
+    ("TELUGU LETTER EE" #x0C0F)
+    ("TELUGU LETTER AI" #x0C10)
+    ("TELUGU LETTER O" #x0C12)
+    ("TELUGU LETTER OO" #x0C13)
+    ("TELUGU LETTER AU" #x0C14)
+    ("TELUGU LETTER KA" #x0C15)
+    ("TELUGU LETTER KHA" #x0C16)
+    ("TELUGU LETTER GA" #x0C17)
+    ("TELUGU LETTER GHA" #x0C18)
+    ("TELUGU LETTER NGA" #x0C19)
+    ("TELUGU LETTER CA" #x0C1A)
+    ("TELUGU LETTER CHA" #x0C1B)
+    ("TELUGU LETTER JA" #x0C1C)
+    ("TELUGU LETTER JHA" #x0C1D)
+    ("TELUGU LETTER NYA" #x0C1E)
+    ("TELUGU LETTER TTA" #x0C1F)
+    ("TELUGU LETTER TTHA" #x0C20)
+    ("TELUGU LETTER DDA" #x0C21)
+    ("TELUGU LETTER DDHA" #x0C22)
+    ("TELUGU LETTER NNA" #x0C23)
+    ("TELUGU LETTER TA" #x0C24)
+    ("TELUGU LETTER THA" #x0C25)
+    ("TELUGU LETTER DA" #x0C26)
+    ("TELUGU LETTER DHA" #x0C27)
+    ("TELUGU LETTER NA" #x0C28)
+    ("TELUGU LETTER PA" #x0C2A)
+    ("TELUGU LETTER PHA" #x0C2B)
+    ("TELUGU LETTER BA" #x0C2C)
+    ("TELUGU LETTER BHA" #x0C2D)
+    ("TELUGU LETTER MA" #x0C2E)
+    ("TELUGU LETTER YA" #x0C2F)
+    ("TELUGU LETTER RA" #x0C30)
+    ("TELUGU LETTER RRA" #x0C31)
+    ("TELUGU LETTER LA" #x0C32)
+    ("TELUGU LETTER LLA" #x0C33)
+    ("TELUGU LETTER VA" #x0C35)
+    ("TELUGU LETTER SHA" #x0C36)
+    ("TELUGU LETTER SSA" #x0C37)
+    ("TELUGU LETTER SA" #x0C38)
+    ("TELUGU LETTER HA" #x0C39)
+    ("TELUGU VOWEL SIGN AA" #x0C3E)
+    ("TELUGU VOWEL SIGN I" #x0C3F)
+    ("TELUGU VOWEL SIGN II" #x0C40)
+    ("TELUGU VOWEL SIGN U" #x0C41)
+    ("TELUGU VOWEL SIGN UU" #x0C42)
+    ("TELUGU VOWEL SIGN VOCALIC R" #x0C43)
+    ("TELUGU VOWEL SIGN VOCALIC RR" #x0C44)
+    ("TELUGU VOWEL SIGN E" #x0C46)
+    ("TELUGU VOWEL SIGN EE" #x0C47)
+    ("TELUGU VOWEL SIGN AI" #x0C48)
+    ("TELUGU VOWEL SIGN O" #x0C4A)
+    ("TELUGU VOWEL SIGN OO" #x0C4B)
+    ("TELUGU VOWEL SIGN AU" #x0C4C)
+    ("TELUGU SIGN VIRAMA" #x0C4D)
+    ("TELUGU LENGTH MARK" #x0C55)
+    ("TELUGU AI LENGTH MARK" #x0C56)
+    ("TELUGU LETTER VOCALIC RR" #x0C60)
+    ("TELUGU LETTER VOCALIC LL" #x0C61)
+    ("TELUGU DIGIT ZERO" #x0C66)
+    ("TELUGU DIGIT ONE" #x0C67)
+    ("TELUGU DIGIT TWO" #x0C68)
+    ("TELUGU DIGIT THREE" #x0C69)
+    ("TELUGU DIGIT FOUR" #x0C6A)
+    ("TELUGU DIGIT FIVE" #x0C6B)
+    ("TELUGU DIGIT SIX" #x0C6C)
+    ("TELUGU DIGIT SEVEN" #x0C6D)
+    ("TELUGU DIGIT EIGHT" #x0C6E)
+    ("TELUGU DIGIT NINE" #x0C6F)
+    ))
diff --git a/lisp/nxml/char-name/unicode/00C80-00CFF.el b/lisp/nxml/char-name/unicode/00C80-00CFF.el
new file mode 100644
index 00000000000..b94e1944563
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/00C80-00CFF.el
@@ -0,0 +1,82 @@
+(nxml-define-char-name-set 'kannada
+  '(("KANNADA SIGN ANUSVARA" #x0C82)
+    ("KANNADA SIGN VISARGA" #x0C83)
+    ("KANNADA LETTER A" #x0C85)
+    ("KANNADA LETTER AA" #x0C86)
+    ("KANNADA LETTER I" #x0C87)
+    ("KANNADA LETTER II" #x0C88)
+    ("KANNADA LETTER U" #x0C89)
+    ("KANNADA LETTER UU" #x0C8A)
+    ("KANNADA LETTER VOCALIC R" #x0C8B)
+    ("KANNADA LETTER VOCALIC L" #x0C8C)
+    ("KANNADA LETTER E" #x0C8E)
+    ("KANNADA LETTER EE" #x0C8F)
+    ("KANNADA LETTER AI" #x0C90)
+    ("KANNADA LETTER O" #x0C92)
+    ("KANNADA LETTER OO" #x0C93)
+    ("KANNADA LETTER AU" #x0C94)
+    ("KANNADA LETTER KA" #x0C95)
+    ("KANNADA LETTER KHA" #x0C96)
+    ("KANNADA LETTER GA" #x0C97)
+    ("KANNADA LETTER GHA" #x0C98)
+    ("KANNADA LETTER NGA" #x0C99)
+    ("KANNADA LETTER CA" #x0C9A)
+    ("KANNADA LETTER CHA" #x0C9B)
+    ("KANNADA LETTER JA" #x0C9C)
+    ("KANNADA LETTER JHA" #x0C9D)
+    ("KANNADA LETTER NYA" #x0C9E)
+    ("KANNADA LETTER TTA" #x0C9F)
+    ("KANNADA LETTER TTHA" #x0CA0)
+    ("KANNADA LETTER DDA" #x0CA1)
+    ("KANNADA LETTER DDHA" #x0CA2)
+    ("KANNADA LETTER NNA" #x0CA3)
+    ("KANNADA LETTER TA" #x0CA4)
+    ("KANNADA LETTER THA" #x0CA5)
+    ("KANNADA LETTER DA" #x0CA6)
+    ("KANNADA LETTER DHA" #x0CA7)
+    ("KANNADA LETTER NA" #x0CA8)
+    ("KANNADA LETTER PA" #x0CAA)
+    ("KANNADA LETTER PHA" #x0CAB)
+    ("KANNADA LETTER BA" #x0CAC)
+    ("KANNADA LETTER BHA" #x0CAD)
+    ("KANNADA LETTER MA" #x0CAE)
+    ("KANNADA LETTER YA" #x0CAF)
+    ("KANNADA LETTER RA" #x0CB0)
+    ("KANNADA LETTER RRA" #x0CB1)
+    ("KANNADA LETTER LA" #x0CB2)
+    ("KANNADA LETTER LLA" #x0CB3)
+    ("KANNADA LETTER VA" #x0CB5)
+    ("KANNADA LETTER SHA" #x0CB6)
+    ("KANNADA LETTER SSA" #x0CB7)
+    ("KANNADA LETTER SA" #x0CB8)
+    ("KANNADA LETTER HA" #x0CB9)
+    ("KANNADA VOWEL SIGN AA" #x0CBE)
+    ("KANNADA VOWEL SIGN I" #x0CBF)
+    ("KANNADA VOWEL SIGN II" #x0CC0)
+    ("KANNADA VOWEL SIGN U" #x0CC1)
+    ("KANNADA VOWEL SIGN UU" #x0CC2)
+    ("KANNADA VOWEL SIGN VOCALIC R" #x0CC3)
+    ("KANNADA VOWEL SIGN VOCALIC RR" #x0CC4)
+    ("KANNADA VOWEL SIGN E" #x0CC6)
+    ("KANNADA VOWEL SIGN EE" #x0CC7)
+    ("KANNADA VOWEL SIGN AI" #x0CC8)
+    ("KANNADA VOWEL SIGN O" #x0CCA)
+    ("KANNADA VOWEL SIGN OO" #x0CCB)
+    ("KANNADA VOWEL SIGN AU" #x0CCC)
+    ("KANNADA SIGN VIRAMA" #x0CCD)
+    ("KANNADA LENGTH MARK" #x0CD5)
+    ("KANNADA AI LENGTH MARK" #x0CD6)
+    ("KANNADA LETTER FA" #x0CDE)
+    ("KANNADA LETTER VOCALIC RR" #x0CE0)
+    ("KANNADA LETTER VOCALIC LL" #x0CE1)
+    ("KANNADA DIGIT ZERO" #x0CE6)
+    ("KANNADA DIGIT ONE" #x0CE7)
+    ("KANNADA DIGIT TWO" #x0CE8)
+    ("KANNADA DIGIT THREE" #x0CE9)
+    ("KANNADA DIGIT FOUR" #x0CEA)
+    ("KANNADA DIGIT FIVE" #x0CEB)
+    ("KANNADA DIGIT SIX" #x0CEC)
+    ("KANNADA DIGIT SEVEN" #x0CED)
+    ("KANNADA DIGIT EIGHT" #x0CEE)
+    ("KANNADA DIGIT NINE" #x0CEF)
+    ))
diff --git a/lisp/nxml/char-name/unicode/00D00-00D7F.el b/lisp/nxml/char-name/unicode/00D00-00D7F.el
new file mode 100644
index 00000000000..e9ea7e2aeaa
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/00D00-00D7F.el
@@ -0,0 +1,80 @@
+(nxml-define-char-name-set 'malayalam
+  '(("MALAYALAM SIGN ANUSVARA" #x0D02)
+    ("MALAYALAM SIGN VISARGA" #x0D03)
+    ("MALAYALAM LETTER A" #x0D05)
+    ("MALAYALAM LETTER AA" #x0D06)
+    ("MALAYALAM LETTER I" #x0D07)
+    ("MALAYALAM LETTER II" #x0D08)
+    ("MALAYALAM LETTER U" #x0D09)
+    ("MALAYALAM LETTER UU" #x0D0A)
+    ("MALAYALAM LETTER VOCALIC R" #x0D0B)
+    ("MALAYALAM LETTER VOCALIC L" #x0D0C)
+    ("MALAYALAM LETTER E" #x0D0E)
+    ("MALAYALAM LETTER EE" #x0D0F)
+    ("MALAYALAM LETTER AI" #x0D10)
+    ("MALAYALAM LETTER O" #x0D12)
+    ("MALAYALAM LETTER OO" #x0D13)
+    ("MALAYALAM LETTER AU" #x0D14)
+    ("MALAYALAM LETTER KA" #x0D15)
+    ("MALAYALAM LETTER KHA" #x0D16)
+    ("MALAYALAM LETTER GA" #x0D17)
+    ("MALAYALAM LETTER GHA" #x0D18)
+    ("MALAYALAM LETTER NGA" #x0D19)
+    ("MALAYALAM LETTER CA" #x0D1A)
+    ("MALAYALAM LETTER CHA" #x0D1B)
+    ("MALAYALAM LETTER JA" #x0D1C)
+    ("MALAYALAM LETTER JHA" #x0D1D)
+    ("MALAYALAM LETTER NYA" #x0D1E)
+    ("MALAYALAM LETTER TTA" #x0D1F)
+    ("MALAYALAM LETTER TTHA" #x0D20)
+    ("MALAYALAM LETTER DDA" #x0D21)
+    ("MALAYALAM LETTER DDHA" #x0D22)
+    ("MALAYALAM LETTER NNA" #x0D23)
+    ("MALAYALAM LETTER TA" #x0D24)
+    ("MALAYALAM LETTER THA" #x0D25)
+    ("MALAYALAM LETTER DA" #x0D26)
+    ("MALAYALAM LETTER DHA" #x0D27)
+    ("MALAYALAM LETTER NA" #x0D28)
+    ("MALAYALAM LETTER PA" #x0D2A)
+    ("MALAYALAM LETTER PHA" #x0D2B)
+    ("MALAYALAM LETTER BA" #x0D2C)
+    ("MALAYALAM LETTER BHA" #x0D2D)
+    ("MALAYALAM LETTER MA" #x0D2E)
+    ("MALAYALAM LETTER YA" #x0D2F)
+    ("MALAYALAM LETTER RA" #x0D30)
+    ("MALAYALAM LETTER RRA" #x0D31)
+    ("MALAYALAM LETTER LA" #x0D32)
+    ("MALAYALAM LETTER LLA" #x0D33)
+    ("MALAYALAM LETTER LLLA" #x0D34)
+    ("MALAYALAM LETTER VA" #x0D35)
+    ("MALAYALAM LETTER SHA" #x0D36)
+    ("MALAYALAM LETTER SSA" #x0D37)
+    ("MALAYALAM LETTER SA" #x0D38)
+    ("MALAYALAM LETTER HA" #x0D39)
+    ("MALAYALAM VOWEL SIGN AA" #x0D3E)
+    ("MALAYALAM VOWEL SIGN I" #x0D3F)
+    ("MALAYALAM VOWEL SIGN II" #x0D40)
+    ("MALAYALAM VOWEL SIGN U" #x0D41)
+    ("MALAYALAM VOWEL SIGN UU" #x0D42)
+    ("MALAYALAM VOWEL SIGN VOCALIC R" #x0D43)
+    ("MALAYALAM VOWEL SIGN E" #x0D46)
+    ("MALAYALAM VOWEL SIGN EE" #x0D47)
+    ("MALAYALAM VOWEL SIGN AI" #x0D48)
+    ("MALAYALAM VOWEL SIGN O" #x0D4A)
+    ("MALAYALAM VOWEL SIGN OO" #x0D4B)
+    ("MALAYALAM VOWEL SIGN AU" #x0D4C)
+    ("MALAYALAM SIGN VIRAMA" #x0D4D)
+    ("MALAYALAM AU LENGTH MARK" #x0D57)
+    ("MALAYALAM LETTER VOCALIC RR" #x0D60)
+    ("MALAYALAM LETTER VOCALIC LL" #x0D61)
+    ("MALAYALAM DIGIT ZERO" #x0D66)
+    ("MALAYALAM DIGIT ONE" #x0D67)
+    ("MALAYALAM DIGIT TWO" #x0D68)
+    ("MALAYALAM DIGIT THREE" #x0D69)
+    ("MALAYALAM DIGIT FOUR" #x0D6A)
+    ("MALAYALAM DIGIT FIVE" #x0D6B)
+    ("MALAYALAM DIGIT SIX" #x0D6C)
+    ("MALAYALAM DIGIT SEVEN" #x0D6D)
+    ("MALAYALAM DIGIT EIGHT" #x0D6E)
+    ("MALAYALAM DIGIT NINE" #x0D6F)
+    ))
diff --git a/lisp/nxml/char-name/unicode/00D80-00DFF.el b/lisp/nxml/char-name/unicode/00D80-00DFF.el
new file mode 100644
index 00000000000..d0278dd0884
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/00D80-00DFF.el
@@ -0,0 +1,82 @@
+(nxml-define-char-name-set 'sinhala
+  '(("SINHALA SIGN ANUSVARAYA" #x0D82)
+    ("SINHALA SIGN VISARGAYA" #x0D83)
+    ("SINHALA LETTER AYANNA" #x0D85)
+    ("SINHALA LETTER AAYANNA" #x0D86)
+    ("SINHALA LETTER AEYANNA" #x0D87)
+    ("SINHALA LETTER AEEYANNA" #x0D88)
+    ("SINHALA LETTER IYANNA" #x0D89)
+    ("SINHALA LETTER IIYANNA" #x0D8A)
+    ("SINHALA LETTER UYANNA" #x0D8B)
+    ("SINHALA LETTER UUYANNA" #x0D8C)
+    ("SINHALA LETTER IRUYANNA" #x0D8D)
+    ("SINHALA LETTER IRUUYANNA" #x0D8E)
+    ("SINHALA LETTER ILUYANNA" #x0D8F)
+    ("SINHALA LETTER ILUUYANNA" #x0D90)
+    ("SINHALA LETTER EYANNA" #x0D91)
+    ("SINHALA LETTER EEYANNA" #x0D92)
+    ("SINHALA LETTER AIYANNA" #x0D93)
+    ("SINHALA LETTER OYANNA" #x0D94)
+    ("SINHALA LETTER OOYANNA" #x0D95)
+    ("SINHALA LETTER AUYANNA" #x0D96)
+    ("SINHALA LETTER ALPAPRAANA KAYANNA" #x0D9A)
+    ("SINHALA LETTER MAHAAPRAANA KAYANNA" #x0D9B)
+    ("SINHALA LETTER ALPAPRAANA GAYANNA" #x0D9C)
+    ("SINHALA LETTER MAHAAPRAANA GAYANNA" #x0D9D)
+    ("SINHALA LETTER KANTAJA NAASIKYAYA" #x0D9E)
+    ("SINHALA LETTER SANYAKA GAYANNA" #x0D9F)
+    ("SINHALA LETTER ALPAPRAANA CAYANNA" #x0DA0)
+    ("SINHALA LETTER MAHAAPRAANA CAYANNA" #x0DA1)
+    ("SINHALA LETTER ALPAPRAANA JAYANNA" #x0DA2)
+    ("SINHALA LETTER MAHAAPRAANA JAYANNA" #x0DA3)
+    ("SINHALA LETTER TAALUJA NAASIKYAYA" #x0DA4)
+    ("SINHALA LETTER TAALUJA SANYOOGA NAAKSIKYAYA" #x0DA5)
+    ("SINHALA LETTER SANYAKA JAYANNA" #x0DA6)
+    ("SINHALA LETTER ALPAPRAANA TTAYANNA" #x0DA7)
+    ("SINHALA LETTER MAHAAPRAANA TTAYANNA" #x0DA8)
+    ("SINHALA LETTER ALPAPRAANA DDAYANNA" #x0DA9)
+    ("SINHALA LETTER MAHAAPRAANA DDAYANNA" #x0DAA)
+    ("SINHALA LETTER MUURDHAJA NAYANNA" #x0DAB)
+    ("SINHALA LETTER SANYAKA DDAYANNA" #x0DAC)
+    ("SINHALA LETTER ALPAPRAANA TAYANNA" #x0DAD)
+    ("SINHALA LETTER MAHAAPRAANA TAYANNA" #x0DAE)
+    ("SINHALA LETTER ALPAPRAANA DAYANNA" #x0DAF)
+    ("SINHALA LETTER MAHAAPRAANA DAYANNA" #x0DB0)
+    ("SINHALA LETTER DANTAJA NAYANNA" #x0DB1)
+    ("SINHALA LETTER SANYAKA DAYANNA" #x0DB3)
+    ("SINHALA LETTER ALPAPRAANA PAYANNA" #x0DB4)
+    ("SINHALA LETTER MAHAAPRAANA PAYANNA" #x0DB5)
+    ("SINHALA LETTER ALPAPRAANA BAYANNA" #x0DB6)
+    ("SINHALA LETTER MAHAAPRAANA BAYANNA" #x0DB7)
+    ("SINHALA LETTER MAYANNA" #x0DB8)
+    ("SINHALA LETTER AMBA BAYANNA" #x0DB9)
+    ("SINHALA LETTER YAYANNA" #x0DBA)
+    ("SINHALA LETTER RAYANNA" #x0DBB)
+    ("SINHALA LETTER DANTAJA LAYANNA" #x0DBD)
+    ("SINHALA LETTER VAYANNA" #x0DC0)
+    ("SINHALA LETTER TAALUJA SAYANNA" #x0DC1)
+    ("SINHALA LETTER MUURDHAJA SAYANNA" #x0DC2)
+    ("SINHALA LETTER DANTAJA SAYANNA" #x0DC3)
+    ("SINHALA LETTER HAYANNA" #x0DC4)
+    ("SINHALA LETTER MUURDHAJA LAYANNA" #x0DC5)
+    ("SINHALA LETTER FAYANNA" #x0DC6)
+    ("SINHALA SIGN AL-LAKUNA" #x0DCA)
+    ("SINHALA VOWEL SIGN AELA-PILLA" #x0DCF)
+    ("SINHALA VOWEL SIGN KETTI AEDA-PILLA" #x0DD0)
+    ("SINHALA VOWEL SIGN DIGA AEDA-PILLA" #x0DD1)
+    ("SINHALA VOWEL SIGN KETTI IS-PILLA" #x0DD2)
+    ("SINHALA VOWEL SIGN DIGA IS-PILLA" #x0DD3)
+    ("SINHALA VOWEL SIGN KETTI PAA-PILLA" #x0DD4)
+    ("SINHALA VOWEL SIGN DIGA PAA-PILLA" #x0DD6)
+    ("SINHALA VOWEL SIGN GAETTA-PILLA" #x0DD8)
+    ("SINHALA VOWEL SIGN KOMBUVA" #x0DD9)
+    ("SINHALA VOWEL SIGN DIGA KOMBUVA" #x0DDA)
+    ("SINHALA VOWEL SIGN KOMBU DEKA" #x0DDB)
+    ("SINHALA VOWEL SIGN KOMBUVA HAA AELA-PILLA" #x0DDC)
+    ("SINHALA VOWEL SIGN KOMBUVA HAA DIGA AELA-PILLA" #x0DDD)
+    ("SINHALA VOWEL SIGN KOMBUVA HAA GAYANUKITTA" #x0DDE)
+    ("SINHALA VOWEL SIGN GAYANUKITTA" #x0DDF)
+    ("SINHALA VOWEL SIGN DIGA GAETTA-PILLA" #x0DF2)
+    ("SINHALA VOWEL SIGN DIGA GAYANUKITTA" #x0DF3)
+    ("SINHALA PUNCTUATION KUNDDALIYA" #x0DF4)
+    ))
diff --git a/lisp/nxml/char-name/unicode/00E00-00E7F.el b/lisp/nxml/char-name/unicode/00E00-00E7F.el
new file mode 100644
index 00000000000..ef5a9bb949c
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/00E00-00E7F.el
@@ -0,0 +1,89 @@
+(nxml-define-char-name-set 'thai
+  '(("THAI CHARACTER KO KAI" #x0E01)
+    ("THAI CHARACTER KHO KHAI" #x0E02)
+    ("THAI CHARACTER KHO KHUAT" #x0E03)
+    ("THAI CHARACTER KHO KHWAI" #x0E04)
+    ("THAI CHARACTER KHO KHON" #x0E05)
+    ("THAI CHARACTER KHO RAKHANG" #x0E06)
+    ("THAI CHARACTER NGO NGU" #x0E07)
+    ("THAI CHARACTER CHO CHAN" #x0E08)
+    ("THAI CHARACTER CHO CHING" #x0E09)
+    ("THAI CHARACTER CHO CHANG" #x0E0A)
+    ("THAI CHARACTER SO SO" #x0E0B)
+    ("THAI CHARACTER CHO CHOE" #x0E0C)
+    ("THAI CHARACTER YO YING" #x0E0D)
+    ("THAI CHARACTER DO CHADA" #x0E0E)
+    ("THAI CHARACTER TO PATAK" #x0E0F)
+    ("THAI CHARACTER THO THAN" #x0E10)
+    ("THAI CHARACTER THO NANGMONTHO" #x0E11)
+    ("THAI CHARACTER THO PHUTHAO" #x0E12)
+    ("THAI CHARACTER NO NEN" #x0E13)
+    ("THAI CHARACTER DO DEK" #x0E14)
+    ("THAI CHARACTER TO TAO" #x0E15)
+    ("THAI CHARACTER THO THUNG" #x0E16)
+    ("THAI CHARACTER THO THAHAN" #x0E17)
+    ("THAI CHARACTER THO THONG" #x0E18)
+    ("THAI CHARACTER NO NU" #x0E19)
+    ("THAI CHARACTER BO BAIMAI" #x0E1A)
+    ("THAI CHARACTER PO PLA" #x0E1B)
+    ("THAI CHARACTER PHO PHUNG" #x0E1C)
+    ("THAI CHARACTER FO FA" #x0E1D)
+    ("THAI CHARACTER PHO PHAN" #x0E1E)
+    ("THAI CHARACTER FO FAN" #x0E1F)
+    ("THAI CHARACTER PHO SAMPHAO" #x0E20)
+    ("THAI CHARACTER MO MA" #x0E21)
+    ("THAI CHARACTER YO YAK" #x0E22)
+    ("THAI CHARACTER RO RUA" #x0E23)
+    ("THAI CHARACTER RU" #x0E24)
+    ("THAI CHARACTER LO LING" #x0E25)
+    ("THAI CHARACTER LU" #x0E26)
+    ("THAI CHARACTER WO WAEN" #x0E27)
+    ("THAI CHARACTER SO SALA" #x0E28)
+    ("THAI CHARACTER SO RUSI" #x0E29)
+    ("THAI CHARACTER SO SUA" #x0E2A)
+    ("THAI CHARACTER HO HIP" #x0E2B)
+    ("THAI CHARACTER LO CHULA" #x0E2C)
+    ("THAI CHARACTER O ANG" #x0E2D)
+    ("THAI CHARACTER HO NOKHUK" #x0E2E)
+    ("THAI CHARACTER PAIYANNOI" #x0E2F)
+    ("THAI CHARACTER SARA A" #x0E30)
+    ("THAI CHARACTER MAI HAN-AKAT" #x0E31)
+    ("THAI CHARACTER SARA AA" #x0E32)
+    ("THAI CHARACTER SARA AM" #x0E33)
+    ("THAI CHARACTER SARA I" #x0E34)
+    ("THAI CHARACTER SARA II" #x0E35)
+    ("THAI CHARACTER SARA UE" #x0E36)
+    ("THAI CHARACTER SARA UEE" #x0E37)
+    ("THAI CHARACTER SARA U" #x0E38)
+    ("THAI CHARACTER SARA UU" #x0E39)
+    ("THAI CHARACTER PHINTHU" #x0E3A)
+    ("THAI CURRENCY SYMBOL BAHT" #x0E3F)
+    ("THAI CHARACTER SARA E" #x0E40)
+    ("THAI CHARACTER SARA AE" #x0E41)
+    ("THAI CHARACTER SARA O" #x0E42)
+    ("THAI CHARACTER SARA AI MAIMUAN" #x0E43)
+    ("THAI CHARACTER SARA AI MAIMALAI" #x0E44)
+    ("THAI CHARACTER LAKKHANGYAO" #x0E45)
+    ("THAI CHARACTER MAIYAMOK" #x0E46)
+    ("THAI CHARACTER MAITAIKHU" #x0E47)
+    ("THAI CHARACTER MAI EK" #x0E48)
+    ("THAI CHARACTER MAI THO" #x0E49)
+    ("THAI CHARACTER MAI TRI" #x0E4A)
+    ("THAI CHARACTER MAI CHATTAWA" #x0E4B)
+    ("THAI CHARACTER THANTHAKHAT" #x0E4C)
+    ("THAI CHARACTER NIKHAHIT" #x0E4D)
+    ("THAI CHARACTER YAMAKKAN" #x0E4E)
+    ("THAI CHARACTER FONGMAN" #x0E4F)
+    ("THAI DIGIT ZERO" #x0E50)
+    ("THAI DIGIT ONE" #x0E51)
+    ("THAI DIGIT TWO" #x0E52)
+    ("THAI DIGIT THREE" #x0E53)
+    ("THAI DIGIT FOUR" #x0E54)
+    ("THAI DIGIT FIVE" #x0E55)
+    ("THAI DIGIT SIX" #x0E56)
+    ("THAI DIGIT SEVEN" #x0E57)
+    ("THAI DIGIT EIGHT" #x0E58)
+    ("THAI DIGIT NINE" #x0E59)
+    ("THAI CHARACTER ANGKHANKHU" #x0E5A)
+    ("THAI CHARACTER KHOMUT" #x0E5B)
+    ))
diff --git a/lisp/nxml/char-name/unicode/00E80-00EFF.el b/lisp/nxml/char-name/unicode/00E80-00EFF.el
new file mode 100644
index 00000000000..f9842bc8cbc
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/00E80-00EFF.el
@@ -0,0 +1,67 @@
+(nxml-define-char-name-set 'lao
+  '(("LAO LETTER KO" #x0E81)
+    ("LAO LETTER KHO SUNG" #x0E82)
+    ("LAO LETTER KHO TAM" #x0E84)
+    ("LAO LETTER NGO" #x0E87)
+    ("LAO LETTER CO" #x0E88)
+    ("LAO LETTER SO TAM" #x0E8A)
+    ("LAO LETTER NYO" #x0E8D)
+    ("LAO LETTER DO" #x0E94)
+    ("LAO LETTER TO" #x0E95)
+    ("LAO LETTER THO SUNG" #x0E96)
+    ("LAO LETTER THO TAM" #x0E97)
+    ("LAO LETTER NO" #x0E99)
+    ("LAO LETTER BO" #x0E9A)
+    ("LAO LETTER PO" #x0E9B)
+    ("LAO LETTER PHO SUNG" #x0E9C)
+    ("LAO LETTER FO TAM" #x0E9D)
+    ("LAO LETTER PHO TAM" #x0E9E)
+    ("LAO LETTER FO SUNG" #x0E9F)
+    ("LAO LETTER MO" #x0EA1)
+    ("LAO LETTER YO" #x0EA2)
+    ("LAO LETTER LO LING" #x0EA3)
+    ("LAO LETTER LO LOOT" #x0EA5)
+    ("LAO LETTER WO" #x0EA7)
+    ("LAO LETTER SO SUNG" #x0EAA)
+    ("LAO LETTER HO SUNG" #x0EAB)
+    ("LAO LETTER O" #x0EAD)
+    ("LAO LETTER HO TAM" #x0EAE)
+    ("LAO ELLIPSIS" #x0EAF)
+    ("LAO VOWEL SIGN A" #x0EB0)
+    ("LAO VOWEL SIGN MAI KAN" #x0EB1)
+    ("LAO VOWEL SIGN AA" #x0EB2)
+    ("LAO VOWEL SIGN AM" #x0EB3)
+    ("LAO VOWEL SIGN I" #x0EB4)
+    ("LAO VOWEL SIGN II" #x0EB5)
+    ("LAO VOWEL SIGN Y" #x0EB6)
+    ("LAO VOWEL SIGN YY" #x0EB7)
+    ("LAO VOWEL SIGN U" #x0EB8)
+    ("LAO VOWEL SIGN UU" #x0EB9)
+    ("LAO VOWEL SIGN MAI KON" #x0EBB)
+    ("LAO SEMIVOWEL SIGN LO" #x0EBC)
+    ("LAO SEMIVOWEL SIGN NYO" #x0EBD)
+    ("LAO VOWEL SIGN E" #x0EC0)
+    ("LAO VOWEL SIGN EI" #x0EC1)
+    ("LAO VOWEL SIGN O" #x0EC2)
+    ("LAO VOWEL SIGN AY" #x0EC3)
+    ("LAO VOWEL SIGN AI" #x0EC4)
+    ("LAO KO LA" #x0EC6)
+    ("LAO TONE MAI EK" #x0EC8)
+    ("LAO TONE MAI THO" #x0EC9)
+    ("LAO TONE MAI TI" #x0ECA)
+    ("LAO TONE MAI CATAWA" #x0ECB)
+    ("LAO CANCELLATION MARK" #x0ECC)
+    ("LAO NIGGAHITA" #x0ECD)
+    ("LAO DIGIT ZERO" #x0ED0)
+    ("LAO DIGIT ONE" #x0ED1)
+    ("LAO DIGIT TWO" #x0ED2)
+    ("LAO DIGIT THREE" #x0ED3)
+    ("LAO DIGIT FOUR" #x0ED4)
+    ("LAO DIGIT FIVE" #x0ED5)
+    ("LAO DIGIT SIX" #x0ED6)
+    ("LAO DIGIT SEVEN" #x0ED7)
+    ("LAO DIGIT EIGHT" #x0ED8)
+    ("LAO DIGIT NINE" #x0ED9)
+    ("LAO HO NO" #x0EDC)
+    ("LAO HO MO" #x0EDD)
+    ))
diff --git a/lisp/nxml/char-name/unicode/00F00-00FFF.el b/lisp/nxml/char-name/unicode/00F00-00FFF.el
new file mode 100644
index 00000000000..7440269e0e3
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/00F00-00FFF.el
@@ -0,0 +1,195 @@
+(nxml-define-char-name-set 'tibetan
+  '(("TIBETAN SYLLABLE OM" #x0F00)
+    ("TIBETAN MARK GTER YIG MGO TRUNCATED A" #x0F01)
+    ("TIBETAN MARK GTER YIG MGO -UM RNAM BCAD MA" #x0F02)
+    ("TIBETAN MARK GTER YIG MGO -UM GTER TSHEG MA" #x0F03)
+    ("TIBETAN MARK INITIAL YIG MGO MDUN MA" #x0F04)
+    ("TIBETAN MARK CLOSING YIG MGO SGAB MA" #x0F05)
+    ("TIBETAN MARK CARET YIG MGO PHUR SHAD MA" #x0F06)
+    ("TIBETAN MARK YIG MGO TSHEG SHAD MA" #x0F07)
+    ("TIBETAN MARK SBRUL SHAD" #x0F08)
+    ("TIBETAN MARK BSKUR YIG MGO" #x0F09)
+    ("TIBETAN MARK BKA- SHOG YIG MGO" #x0F0A)
+    ("TIBETAN MARK INTERSYLLABIC TSHEG" #x0F0B)
+    ("TIBETAN MARK DELIMITER TSHEG BSTAR" #x0F0C)
+    ("TIBETAN MARK SHAD" #x0F0D)
+    ("TIBETAN MARK NYIS SHAD" #x0F0E)
+    ("TIBETAN MARK TSHEG SHAD" #x0F0F)
+    ("TIBETAN MARK NYIS TSHEG SHAD" #x0F10)
+    ("TIBETAN MARK RIN CHEN SPUNGS SHAD" #x0F11)
+    ("TIBETAN MARK RGYA GRAM SHAD" #x0F12)
+    ("TIBETAN MARK CARET -DZUD RTAGS ME LONG CAN" #x0F13)
+    ("TIBETAN MARK GTER TSHEG" #x0F14)
+    ("TIBETAN LOGOTYPE SIGN CHAD RTAGS" #x0F15)
+    ("TIBETAN LOGOTYPE SIGN LHAG RTAGS" #x0F16)
+    ("TIBETAN ASTROLOGICAL SIGN SGRA GCAN -CHAR RTAGS" #x0F17)
+    ("TIBETAN ASTROLOGICAL SIGN -KHYUD PA" #x0F18)
+    ("TIBETAN ASTROLOGICAL SIGN SDONG TSHUGS" #x0F19)
+    ("TIBETAN SIGN RDEL DKAR GCIG" #x0F1A)
+    ("TIBETAN SIGN RDEL DKAR GNYIS" #x0F1B)
+    ("TIBETAN SIGN RDEL DKAR GSUM" #x0F1C)
+    ("TIBETAN SIGN RDEL NAG GCIG" #x0F1D)
+    ("TIBETAN SIGN RDEL NAG GNYIS" #x0F1E)
+    ("TIBETAN SIGN RDEL DKAR RDEL NAG" #x0F1F)
+    ("TIBETAN DIGIT ZERO" #x0F20)
+    ("TIBETAN DIGIT ONE" #x0F21)
+    ("TIBETAN DIGIT TWO" #x0F22)
+    ("TIBETAN DIGIT THREE" #x0F23)
+    ("TIBETAN DIGIT FOUR" #x0F24)
+    ("TIBETAN DIGIT FIVE" #x0F25)
+    ("TIBETAN DIGIT SIX" #x0F26)
+    ("TIBETAN DIGIT SEVEN" #x0F27)
+    ("TIBETAN DIGIT EIGHT" #x0F28)
+    ("TIBETAN DIGIT NINE" #x0F29)
+    ("TIBETAN DIGIT HALF ONE" #x0F2A)
+    ("TIBETAN DIGIT HALF TWO" #x0F2B)
+    ("TIBETAN DIGIT HALF THREE" #x0F2C)
+    ("TIBETAN DIGIT HALF FOUR" #x0F2D)
+    ("TIBETAN DIGIT HALF FIVE" #x0F2E)
+    ("TIBETAN DIGIT HALF SIX" #x0F2F)
+    ("TIBETAN DIGIT HALF SEVEN" #x0F30)
+    ("TIBETAN DIGIT HALF EIGHT" #x0F31)
+    ("TIBETAN DIGIT HALF NINE" #x0F32)
+    ("TIBETAN DIGIT HALF ZERO" #x0F33)
+    ("TIBETAN MARK BSDUS RTAGS" #x0F34)
+    ("TIBETAN MARK NGAS BZUNG NYI ZLA" #x0F35)
+    ("TIBETAN MARK CARET -DZUD RTAGS BZHI MIG CAN" #x0F36)
+    ("TIBETAN MARK NGAS BZUNG SGOR RTAGS" #x0F37)
+    ("TIBETAN MARK CHE MGO" #x0F38)
+    ("TIBETAN MARK TSA -PHRU" #x0F39)
+    ("TIBETAN MARK GUG RTAGS GYON" #x0F3A)
+    ("TIBETAN MARK GUG RTAGS GYAS" #x0F3B)
+    ("TIBETAN MARK ANG KHANG GYON" #x0F3C)
+    ("TIBETAN MARK ANG KHANG GYAS" #x0F3D)
+    ("TIBETAN SIGN YAR TSHES" #x0F3E)
+    ("TIBETAN SIGN MAR TSHES" #x0F3F)
+    ("TIBETAN LETTER KA" #x0F40)
+    ("TIBETAN LETTER KHA" #x0F41)
+    ("TIBETAN LETTER GA" #x0F42)
+    ("TIBETAN LETTER GHA" #x0F43)
+    ("TIBETAN LETTER NGA" #x0F44)
+    ("TIBETAN LETTER CA" #x0F45)
+    ("TIBETAN LETTER CHA" #x0F46)
+    ("TIBETAN LETTER JA" #x0F47)
+    ("TIBETAN LETTER NYA" #x0F49)
+    ("TIBETAN LETTER TTA" #x0F4A)
+    ("TIBETAN LETTER TTHA" #x0F4B)
+    ("TIBETAN LETTER DDA" #x0F4C)
+    ("TIBETAN LETTER DDHA" #x0F4D)
+    ("TIBETAN LETTER NNA" #x0F4E)
+    ("TIBETAN LETTER TA" #x0F4F)
+    ("TIBETAN LETTER THA" #x0F50)
+    ("TIBETAN LETTER DA" #x0F51)
+    ("TIBETAN LETTER DHA" #x0F52)
+    ("TIBETAN LETTER NA" #x0F53)
+    ("TIBETAN LETTER PA" #x0F54)
+    ("TIBETAN LETTER PHA" #x0F55)
+    ("TIBETAN LETTER BA" #x0F56)
+    ("TIBETAN LETTER BHA" #x0F57)
+    ("TIBETAN LETTER MA" #x0F58)
+    ("TIBETAN LETTER TSA" #x0F59)
+    ("TIBETAN LETTER TSHA" #x0F5A)
+    ("TIBETAN LETTER DZA" #x0F5B)
+    ("TIBETAN LETTER DZHA" #x0F5C)
+    ("TIBETAN LETTER WA" #x0F5D)
+    ("TIBETAN LETTER ZHA" #x0F5E)
+    ("TIBETAN LETTER ZA" #x0F5F)
+    ("TIBETAN LETTER -A" #x0F60)
+    ("TIBETAN LETTER YA" #x0F61)
+    ("TIBETAN LETTER RA" #x0F62)
+    ("TIBETAN LETTER LA" #x0F63)
+    ("TIBETAN LETTER SHA" #x0F64)
+    ("TIBETAN LETTER SSA" #x0F65)
+    ("TIBETAN LETTER SA" #x0F66)
+    ("TIBETAN LETTER HA" #x0F67)
+    ("TIBETAN LETTER A" #x0F68)
+    ("TIBETAN LETTER KSSA" #x0F69)
+    ("TIBETAN LETTER FIXED-FORM RA" #x0F6A)
+    ("TIBETAN VOWEL SIGN AA" #x0F71)
+    ("TIBETAN VOWEL SIGN I" #x0F72)
+    ("TIBETAN VOWEL SIGN II" #x0F73)
+    ("TIBETAN VOWEL SIGN U" #x0F74)
+    ("TIBETAN VOWEL SIGN UU" #x0F75)
+    ("TIBETAN VOWEL SIGN VOCALIC R" #x0F76)
+    ("TIBETAN VOWEL SIGN VOCALIC RR" #x0F77)
+    ("TIBETAN VOWEL SIGN VOCALIC L" #x0F78)
+    ("TIBETAN VOWEL SIGN VOCALIC LL" #x0F79)
+    ("TIBETAN VOWEL SIGN E" #x0F7A)
+    ("TIBETAN VOWEL SIGN EE" #x0F7B)
+    ("TIBETAN VOWEL SIGN O" #x0F7C)
+    ("TIBETAN VOWEL SIGN OO" #x0F7D)
+    ("TIBETAN SIGN RJES SU NGA RO" #x0F7E)
+    ("TIBETAN SIGN RNAM BCAD" #x0F7F)
+    ("TIBETAN VOWEL SIGN REVERSED I" #x0F80)
+    ("TIBETAN VOWEL SIGN REVERSED II" #x0F81)
+    ("TIBETAN SIGN NYI ZLA NAA DA" #x0F82)
+    ("TIBETAN SIGN SNA LDAN" #x0F83)
+    ("TIBETAN MARK HALANTA" #x0F84)
+    ("TIBETAN MARK PALUTA" #x0F85)
+    ("TIBETAN SIGN LCI RTAGS" #x0F86)
+    ("TIBETAN SIGN YANG RTAGS" #x0F87)
+    ("TIBETAN SIGN LCE TSA CAN" #x0F88)
+    ("TIBETAN SIGN MCHU CAN" #x0F89)
+    ("TIBETAN SIGN GRU CAN RGYINGS" #x0F8A)
+    ("TIBETAN SIGN GRU MED RGYINGS" #x0F8B)
+    ("TIBETAN SUBJOINED LETTER KA" #x0F90)
+    ("TIBETAN SUBJOINED LETTER KHA" #x0F91)
+    ("TIBETAN SUBJOINED LETTER GA" #x0F92)
+    ("TIBETAN SUBJOINED LETTER GHA" #x0F93)
+    ("TIBETAN SUBJOINED LETTER NGA" #x0F94)
+    ("TIBETAN SUBJOINED LETTER CA" #x0F95)
+    ("TIBETAN SUBJOINED LETTER CHA" #x0F96)
+    ("TIBETAN SUBJOINED LETTER JA" #x0F97)
+    ("TIBETAN SUBJOINED LETTER NYA" #x0F99)
+    ("TIBETAN SUBJOINED LETTER TTA" #x0F9A)
+    ("TIBETAN SUBJOINED LETTER TTHA" #x0F9B)
+    ("TIBETAN SUBJOINED LETTER DDA" #x0F9C)
+    ("TIBETAN SUBJOINED LETTER DDHA" #x0F9D)
+    ("TIBETAN SUBJOINED LETTER NNA" #x0F9E)
+    ("TIBETAN SUBJOINED LETTER TA" #x0F9F)
+    ("TIBETAN SUBJOINED LETTER THA" #x0FA0)
+    ("TIBETAN SUBJOINED LETTER DA" #x0FA1)
+    ("TIBETAN SUBJOINED LETTER DHA" #x0FA2)
+    ("TIBETAN SUBJOINED LETTER NA" #x0FA3)
+    ("TIBETAN SUBJOINED LETTER PA" #x0FA4)
+    ("TIBETAN SUBJOINED LETTER PHA" #x0FA5)
+    ("TIBETAN SUBJOINED LETTER BA" #x0FA6)
+    ("TIBETAN SUBJOINED LETTER BHA" #x0FA7)
+    ("TIBETAN SUBJOINED LETTER MA" #x0FA8)
+    ("TIBETAN SUBJOINED LETTER TSA" #x0FA9)
+    ("TIBETAN SUBJOINED LETTER TSHA" #x0FAA)
+    ("TIBETAN SUBJOINED LETTER DZA" #x0FAB)
+    ("TIBETAN SUBJOINED LETTER DZHA" #x0FAC)
+    ("TIBETAN SUBJOINED LETTER WA" #x0FAD)
+    ("TIBETAN SUBJOINED LETTER ZHA" #x0FAE)
+    ("TIBETAN SUBJOINED LETTER ZA" #x0FAF)
+    ("TIBETAN SUBJOINED LETTER -A" #x0FB0)
+    ("TIBETAN SUBJOINED LETTER YA" #x0FB1)
+    ("TIBETAN SUBJOINED LETTER RA" #x0FB2)
+    ("TIBETAN SUBJOINED LETTER LA" #x0FB3)
+    ("TIBETAN SUBJOINED LETTER SHA" #x0FB4)
+    ("TIBETAN SUBJOINED LETTER SSA" #x0FB5)
+    ("TIBETAN SUBJOINED LETTER SA" #x0FB6)
+    ("TIBETAN SUBJOINED LETTER HA" #x0FB7)
+    ("TIBETAN SUBJOINED LETTER A" #x0FB8)
+    ("TIBETAN SUBJOINED LETTER KSSA" #x0FB9)
+    ("TIBETAN SUBJOINED LETTER FIXED-FORM WA" #x0FBA)
+    ("TIBETAN SUBJOINED LETTER FIXED-FORM YA" #x0FBB)
+    ("TIBETAN SUBJOINED LETTER FIXED-FORM RA" #x0FBC)
+    ("TIBETAN KU RU KHA" #x0FBE)
+    ("TIBETAN KU RU KHA BZHI MIG CAN" #x0FBF)
+    ("TIBETAN CANTILLATION SIGN HEAVY BEAT" #x0FC0)
+    ("TIBETAN CANTILLATION SIGN LIGHT BEAT" #x0FC1)
+    ("TIBETAN CANTILLATION SIGN CANG TE-U" #x0FC2)
+    ("TIBETAN CANTILLATION SIGN SBUB -CHAL" #x0FC3)
+    ("TIBETAN SYMBOL DRIL BU" #x0FC4)
+    ("TIBETAN SYMBOL RDO RJE" #x0FC5)
+    ("TIBETAN SYMBOL PADMA GDAN" #x0FC6)
+    ("TIBETAN SYMBOL RDO RJE RGYA GRAM" #x0FC7)
+    ("TIBETAN SYMBOL PHUR PA" #x0FC8)
+    ("TIBETAN SYMBOL NOR BU" #x0FC9)
+    ("TIBETAN SYMBOL NOR BU NYIS -KHYIL" #x0FCA)
+    ("TIBETAN SYMBOL NOR BU GSUM -KHYIL" #x0FCB)
+    ("TIBETAN SYMBOL NOR BU BZHI -KHYIL" #x0FCC)
+    ("TIBETAN SIGN RDEL NAG GSUM" #x0FCF)
+    ))
diff --git a/lisp/nxml/char-name/unicode/01000-0109F.el b/lisp/nxml/char-name/unicode/01000-0109F.el
new file mode 100644
index 00000000000..4465de42dda
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/01000-0109F.el
@@ -0,0 +1,80 @@
+(nxml-define-char-name-set 'myanmar
+  '(("MYANMAR LETTER KA" #x1000)
+    ("MYANMAR LETTER KHA" #x1001)
+    ("MYANMAR LETTER GA" #x1002)
+    ("MYANMAR LETTER GHA" #x1003)
+    ("MYANMAR LETTER NGA" #x1004)
+    ("MYANMAR LETTER CA" #x1005)
+    ("MYANMAR LETTER CHA" #x1006)
+    ("MYANMAR LETTER JA" #x1007)
+    ("MYANMAR LETTER JHA" #x1008)
+    ("MYANMAR LETTER NYA" #x1009)
+    ("MYANMAR LETTER NNYA" #x100A)
+    ("MYANMAR LETTER TTA" #x100B)
+    ("MYANMAR LETTER TTHA" #x100C)
+    ("MYANMAR LETTER DDA" #x100D)
+    ("MYANMAR LETTER DDHA" #x100E)
+    ("MYANMAR LETTER NNA" #x100F)
+    ("MYANMAR LETTER TA" #x1010)
+    ("MYANMAR LETTER THA" #x1011)
+    ("MYANMAR LETTER DA" #x1012)
+    ("MYANMAR LETTER DHA" #x1013)
+    ("MYANMAR LETTER NA" #x1014)
+    ("MYANMAR LETTER PA" #x1015)
+    ("MYANMAR LETTER PHA" #x1016)
+    ("MYANMAR LETTER BA" #x1017)
+    ("MYANMAR LETTER BHA" #x1018)
+    ("MYANMAR LETTER MA" #x1019)
+    ("MYANMAR LETTER YA" #x101A)
+    ("MYANMAR LETTER RA" #x101B)
+    ("MYANMAR LETTER LA" #x101C)
+    ("MYANMAR LETTER WA" #x101D)
+    ("MYANMAR LETTER SA" #x101E)
+    ("MYANMAR LETTER HA" #x101F)
+    ("MYANMAR LETTER LLA" #x1020)
+    ("MYANMAR LETTER A" #x1021)
+    ("MYANMAR LETTER I" #x1023)
+    ("MYANMAR LETTER II" #x1024)
+    ("MYANMAR LETTER U" #x1025)
+    ("MYANMAR LETTER UU" #x1026)
+    ("MYANMAR LETTER E" #x1027)
+    ("MYANMAR LETTER O" #x1029)
+    ("MYANMAR LETTER AU" #x102A)
+    ("MYANMAR VOWEL SIGN AA" #x102C)
+    ("MYANMAR VOWEL SIGN I" #x102D)
+    ("MYANMAR VOWEL SIGN II" #x102E)
+    ("MYANMAR VOWEL SIGN U" #x102F)
+    ("MYANMAR VOWEL SIGN UU" #x1030)
+    ("MYANMAR VOWEL SIGN E" #x1031)
+    ("MYANMAR VOWEL SIGN AI" #x1032)
+    ("MYANMAR SIGN ANUSVARA" #x1036)
+    ("MYANMAR SIGN DOT BELOW" #x1037)
+    ("MYANMAR SIGN VISARGA" #x1038)
+    ("MYANMAR SIGN VIRAMA" #x1039)
+    ("MYANMAR DIGIT ZERO" #x1040)
+    ("MYANMAR DIGIT ONE" #x1041)
+    ("MYANMAR DIGIT TWO" #x1042)
+    ("MYANMAR DIGIT THREE" #x1043)
+    ("MYANMAR DIGIT FOUR" #x1044)
+    ("MYANMAR DIGIT FIVE" #x1045)
+    ("MYANMAR DIGIT SIX" #x1046)
+    ("MYANMAR DIGIT SEVEN" #x1047)
+    ("MYANMAR DIGIT EIGHT" #x1048)
+    ("MYANMAR DIGIT NINE" #x1049)
+    ("MYANMAR SIGN LITTLE SECTION" #x104A)
+    ("MYANMAR SIGN SECTION" #x104B)
+    ("MYANMAR SYMBOL LOCATIVE" #x104C)
+    ("MYANMAR SYMBOL COMPLETED" #x104D)
+    ("MYANMAR SYMBOL AFOREMENTIONED" #x104E)
+    ("MYANMAR SYMBOL GENITIVE" #x104F)
+    ("MYANMAR LETTER SHA" #x1050)
+    ("MYANMAR LETTER SSA" #x1051)
+    ("MYANMAR LETTER VOCALIC R" #x1052)
+    ("MYANMAR LETTER VOCALIC RR" #x1053)
+    ("MYANMAR LETTER VOCALIC L" #x1054)
+    ("MYANMAR LETTER VOCALIC LL" #x1055)
+    ("MYANMAR VOWEL SIGN VOCALIC R" #x1056)
+    ("MYANMAR VOWEL SIGN VOCALIC RR" #x1057)
+    ("MYANMAR VOWEL SIGN VOCALIC L" #x1058)
+    ("MYANMAR VOWEL SIGN VOCALIC LL" #x1059)
+    ))
diff --git a/lisp/nxml/char-name/unicode/010A0-010FF.el b/lisp/nxml/char-name/unicode/010A0-010FF.el
new file mode 100644
index 00000000000..26abf69d527
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/010A0-010FF.el
@@ -0,0 +1,82 @@
+(nxml-define-char-name-set 'georgian
+  '(("GEORGIAN CAPITAL LETTER AN" #x10A0)
+    ("GEORGIAN CAPITAL LETTER BAN" #x10A1)
+    ("GEORGIAN CAPITAL LETTER GAN" #x10A2)
+    ("GEORGIAN CAPITAL LETTER DON" #x10A3)
+    ("GEORGIAN CAPITAL LETTER EN" #x10A4)
+    ("GEORGIAN CAPITAL LETTER VIN" #x10A5)
+    ("GEORGIAN CAPITAL LETTER ZEN" #x10A6)
+    ("GEORGIAN CAPITAL LETTER TAN" #x10A7)
+    ("GEORGIAN CAPITAL LETTER IN" #x10A8)
+    ("GEORGIAN CAPITAL LETTER KAN" #x10A9)
+    ("GEORGIAN CAPITAL LETTER LAS" #x10AA)
+    ("GEORGIAN CAPITAL LETTER MAN" #x10AB)
+    ("GEORGIAN CAPITAL LETTER NAR" #x10AC)
+    ("GEORGIAN CAPITAL LETTER ON" #x10AD)
+    ("GEORGIAN CAPITAL LETTER PAR" #x10AE)
+    ("GEORGIAN CAPITAL LETTER ZHAR" #x10AF)
+    ("GEORGIAN CAPITAL LETTER RAE" #x10B0)
+    ("GEORGIAN CAPITAL LETTER SAN" #x10B1)
+    ("GEORGIAN CAPITAL LETTER TAR" #x10B2)
+    ("GEORGIAN CAPITAL LETTER UN" #x10B3)
+    ("GEORGIAN CAPITAL LETTER PHAR" #x10B4)
+    ("GEORGIAN CAPITAL LETTER KHAR" #x10B5)
+    ("GEORGIAN CAPITAL LETTER GHAN" #x10B6)
+    ("GEORGIAN CAPITAL LETTER QAR" #x10B7)
+    ("GEORGIAN CAPITAL LETTER SHIN" #x10B8)
+    ("GEORGIAN CAPITAL LETTER CHIN" #x10B9)
+    ("GEORGIAN CAPITAL LETTER CAN" #x10BA)
+    ("GEORGIAN CAPITAL LETTER JIL" #x10BB)
+    ("GEORGIAN CAPITAL LETTER CIL" #x10BC)
+    ("GEORGIAN CAPITAL LETTER CHAR" #x10BD)
+    ("GEORGIAN CAPITAL LETTER XAN" #x10BE)
+    ("GEORGIAN CAPITAL LETTER JHAN" #x10BF)
+    ("GEORGIAN CAPITAL LETTER HAE" #x10C0)
+    ("GEORGIAN CAPITAL LETTER HE" #x10C1)
+    ("GEORGIAN CAPITAL LETTER HIE" #x10C2)
+    ("GEORGIAN CAPITAL LETTER WE" #x10C3)
+    ("GEORGIAN CAPITAL LETTER HAR" #x10C4)
+    ("GEORGIAN CAPITAL LETTER HOE" #x10C5)
+    ("GEORGIAN LETTER AN" #x10D0)
+    ("GEORGIAN LETTER BAN" #x10D1)
+    ("GEORGIAN LETTER GAN" #x10D2)
+    ("GEORGIAN LETTER DON" #x10D3)
+    ("GEORGIAN LETTER EN" #x10D4)
+    ("GEORGIAN LETTER VIN" #x10D5)
+    ("GEORGIAN LETTER ZEN" #x10D6)
+    ("GEORGIAN LETTER TAN" #x10D7)
+    ("GEORGIAN LETTER IN" #x10D8)
+    ("GEORGIAN LETTER KAN" #x10D9)
+    ("GEORGIAN LETTER LAS" #x10DA)
+    ("GEORGIAN LETTER MAN" #x10DB)
+    ("GEORGIAN LETTER NAR" #x10DC)
+    ("GEORGIAN LETTER ON" #x10DD)
+    ("GEORGIAN LETTER PAR" #x10DE)
+    ("GEORGIAN LETTER ZHAR" #x10DF)
+    ("GEORGIAN LETTER RAE" #x10E0)
+    ("GEORGIAN LETTER SAN" #x10E1)
+    ("GEORGIAN LETTER TAR" #x10E2)
+    ("GEORGIAN LETTER UN" #x10E3)
+    ("GEORGIAN LETTER PHAR" #x10E4)
+    ("GEORGIAN LETTER KHAR" #x10E5)
+    ("GEORGIAN LETTER GHAN" #x10E6)
+    ("GEORGIAN LETTER QAR" #x10E7)
+    ("GEORGIAN LETTER SHIN" #x10E8)
+    ("GEORGIAN LETTER CHIN" #x10E9)
+    ("GEORGIAN LETTER CAN" #x10EA)
+    ("GEORGIAN LETTER JIL" #x10EB)
+    ("GEORGIAN LETTER CIL" #x10EC)
+    ("GEORGIAN LETTER CHAR" #x10ED)
+    ("GEORGIAN LETTER XAN" #x10EE)
+    ("GEORGIAN LETTER JHAN" #x10EF)
+    ("GEORGIAN LETTER HAE" #x10F0)
+    ("GEORGIAN LETTER HE" #x10F1)
+    ("GEORGIAN LETTER HIE" #x10F2)
+    ("GEORGIAN LETTER WE" #x10F3)
+    ("GEORGIAN LETTER HAR" #x10F4)
+    ("GEORGIAN LETTER HOE" #x10F5)
+    ("GEORGIAN LETTER FI" #x10F6)
+    ("GEORGIAN LETTER YN" #x10F7)
+    ("GEORGIAN LETTER ELIFI" #x10F8)
+    ("GEORGIAN PARAGRAPH SEPARATOR" #x10FB)
+    ))
diff --git a/lisp/nxml/char-name/unicode/01100-011FF.el b/lisp/nxml/char-name/unicode/01100-011FF.el
new file mode 100644
index 00000000000..b89d01536f8
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/01100-011FF.el
@@ -0,0 +1,242 @@
+(nxml-define-char-name-set 'hangul-jamo
+  '(("HANGUL CHOSEONG KIYEOK" #x1100)
+    ("HANGUL CHOSEONG SSANGKIYEOK" #x1101)
+    ("HANGUL CHOSEONG NIEUN" #x1102)
+    ("HANGUL CHOSEONG TIKEUT" #x1103)
+    ("HANGUL CHOSEONG SSANGTIKEUT" #x1104)
+    ("HANGUL CHOSEONG RIEUL" #x1105)
+    ("HANGUL CHOSEONG MIEUM" #x1106)
+    ("HANGUL CHOSEONG PIEUP" #x1107)
+    ("HANGUL CHOSEONG SSANGPIEUP" #x1108)
+    ("HANGUL CHOSEONG SIOS" #x1109)
+    ("HANGUL CHOSEONG SSANGSIOS" #x110A)
+    ("HANGUL CHOSEONG IEUNG" #x110B)
+    ("HANGUL CHOSEONG CIEUC" #x110C)
+    ("HANGUL CHOSEONG SSANGCIEUC" #x110D)
+    ("HANGUL CHOSEONG CHIEUCH" #x110E)
+    ("HANGUL CHOSEONG KHIEUKH" #x110F)
+    ("HANGUL CHOSEONG THIEUTH" #x1110)
+    ("HANGUL CHOSEONG PHIEUPH" #x1111)
+    ("HANGUL CHOSEONG HIEUH" #x1112)
+    ("HANGUL CHOSEONG NIEUN-KIYEOK" #x1113)
+    ("HANGUL CHOSEONG SSANGNIEUN" #x1114)
+    ("HANGUL CHOSEONG NIEUN-TIKEUT" #x1115)
+    ("HANGUL CHOSEONG NIEUN-PIEUP" #x1116)
+    ("HANGUL CHOSEONG TIKEUT-KIYEOK" #x1117)
+    ("HANGUL CHOSEONG RIEUL-NIEUN" #x1118)
+    ("HANGUL CHOSEONG SSANGRIEUL" #x1119)
+    ("HANGUL CHOSEONG RIEUL-HIEUH" #x111A)
+    ("HANGUL CHOSEONG KAPYEOUNRIEUL" #x111B)
+    ("HANGUL CHOSEONG MIEUM-PIEUP" #x111C)
+    ("HANGUL CHOSEONG KAPYEOUNMIEUM" #x111D)
+    ("HANGUL CHOSEONG PIEUP-KIYEOK" #x111E)
+    ("HANGUL CHOSEONG PIEUP-NIEUN" #x111F)
+    ("HANGUL CHOSEONG PIEUP-TIKEUT" #x1120)
+    ("HANGUL CHOSEONG PIEUP-SIOS" #x1121)
+    ("HANGUL CHOSEONG PIEUP-SIOS-KIYEOK" #x1122)
+    ("HANGUL CHOSEONG PIEUP-SIOS-TIKEUT" #x1123)
+    ("HANGUL CHOSEONG PIEUP-SIOS-PIEUP" #x1124)
+    ("HANGUL CHOSEONG PIEUP-SSANGSIOS" #x1125)
+    ("HANGUL CHOSEONG PIEUP-SIOS-CIEUC" #x1126)
+    ("HANGUL CHOSEONG PIEUP-CIEUC" #x1127)
+    ("HANGUL CHOSEONG PIEUP-CHIEUCH" #x1128)
+    ("HANGUL CHOSEONG PIEUP-THIEUTH" #x1129)
+    ("HANGUL CHOSEONG PIEUP-PHIEUPH" #x112A)
+    ("HANGUL CHOSEONG KAPYEOUNPIEUP" #x112B)
+    ("HANGUL CHOSEONG KAPYEOUNSSANGPIEUP" #x112C)
+    ("HANGUL CHOSEONG SIOS-KIYEOK" #x112D)
+    ("HANGUL CHOSEONG SIOS-NIEUN" #x112E)
+    ("HANGUL CHOSEONG SIOS-TIKEUT" #x112F)
+    ("HANGUL CHOSEONG SIOS-RIEUL" #x1130)
+    ("HANGUL CHOSEONG SIOS-MIEUM" #x1131)
+    ("HANGUL CHOSEONG SIOS-PIEUP" #x1132)
+    ("HANGUL CHOSEONG SIOS-PIEUP-KIYEOK" #x1133)
+    ("HANGUL CHOSEONG SIOS-SSANGSIOS" #x1134)
+    ("HANGUL CHOSEONG SIOS-IEUNG" #x1135)
+    ("HANGUL CHOSEONG SIOS-CIEUC" #x1136)
+    ("HANGUL CHOSEONG SIOS-CHIEUCH" #x1137)
+    ("HANGUL CHOSEONG SIOS-KHIEUKH" #x1138)
+    ("HANGUL CHOSEONG SIOS-THIEUTH" #x1139)
+    ("HANGUL CHOSEONG SIOS-PHIEUPH" #x113A)
+    ("HANGUL CHOSEONG SIOS-HIEUH" #x113B)
+    ("HANGUL CHOSEONG CHITUEUMSIOS" #x113C)
+    ("HANGUL CHOSEONG CHITUEUMSSANGSIOS" #x113D)
+    ("HANGUL CHOSEONG CEONGCHIEUMSIOS" #x113E)
+    ("HANGUL CHOSEONG CEONGCHIEUMSSANGSIOS" #x113F)
+    ("HANGUL CHOSEONG PANSIOS" #x1140)
+    ("HANGUL CHOSEONG IEUNG-KIYEOK" #x1141)
+    ("HANGUL CHOSEONG IEUNG-TIKEUT" #x1142)
+    ("HANGUL CHOSEONG IEUNG-MIEUM" #x1143)
+    ("HANGUL CHOSEONG IEUNG-PIEUP" #x1144)
+    ("HANGUL CHOSEONG IEUNG-SIOS" #x1145)
+    ("HANGUL CHOSEONG IEUNG-PANSIOS" #x1146)
+    ("HANGUL CHOSEONG SSANGIEUNG" #x1147)
+    ("HANGUL CHOSEONG IEUNG-CIEUC" #x1148)
+    ("HANGUL CHOSEONG IEUNG-CHIEUCH" #x1149)
+    ("HANGUL CHOSEONG IEUNG-THIEUTH" #x114A)
+    ("HANGUL CHOSEONG IEUNG-PHIEUPH" #x114B)
+    ("HANGUL CHOSEONG YESIEUNG" #x114C)
+    ("HANGUL CHOSEONG CIEUC-IEUNG" #x114D)
+    ("HANGUL CHOSEONG CHITUEUMCIEUC" #x114E)
+    ("HANGUL CHOSEONG CHITUEUMSSANGCIEUC" #x114F)
+    ("HANGUL CHOSEONG CEONGCHIEUMCIEUC" #x1150)
+    ("HANGUL CHOSEONG CEONGCHIEUMSSANGCIEUC" #x1151)
+    ("HANGUL CHOSEONG CHIEUCH-KHIEUKH" #x1152)
+    ("HANGUL CHOSEONG CHIEUCH-HIEUH" #x1153)
+    ("HANGUL CHOSEONG CHITUEUMCHIEUCH" #x1154)
+    ("HANGUL CHOSEONG CEONGCHIEUMCHIEUCH" #x1155)
+    ("HANGUL CHOSEONG PHIEUPH-PIEUP" #x1156)
+    ("HANGUL CHOSEONG KAPYEOUNPHIEUPH" #x1157)
+    ("HANGUL CHOSEONG SSANGHIEUH" #x1158)
+    ("HANGUL CHOSEONG YEORINHIEUH" #x1159)
+    ("HANGUL CHOSEONG FILLER" #x115F)
+    ("HANGUL JUNGSEONG FILLER" #x1160)
+    ("HANGUL JUNGSEONG A" #x1161)
+    ("HANGUL JUNGSEONG AE" #x1162)
+    ("HANGUL JUNGSEONG YA" #x1163)
+    ("HANGUL JUNGSEONG YAE" #x1164)
+    ("HANGUL JUNGSEONG EO" #x1165)
+    ("HANGUL JUNGSEONG E" #x1166)
+    ("HANGUL JUNGSEONG YEO" #x1167)
+    ("HANGUL JUNGSEONG YE" #x1168)
+    ("HANGUL JUNGSEONG O" #x1169)
+    ("HANGUL JUNGSEONG WA" #x116A)
+    ("HANGUL JUNGSEONG WAE" #x116B)
+    ("HANGUL JUNGSEONG OE" #x116C)
+    ("HANGUL JUNGSEONG YO" #x116D)
+    ("HANGUL JUNGSEONG U" #x116E)
+    ("HANGUL JUNGSEONG WEO" #x116F)
+    ("HANGUL JUNGSEONG WE" #x1170)
+    ("HANGUL JUNGSEONG WI" #x1171)
+    ("HANGUL JUNGSEONG YU" #x1172)
+    ("HANGUL JUNGSEONG EU" #x1173)
+    ("HANGUL JUNGSEONG YI" #x1174)
+    ("HANGUL JUNGSEONG I" #x1175)
+    ("HANGUL JUNGSEONG A-O" #x1176)
+    ("HANGUL JUNGSEONG A-U" #x1177)
+    ("HANGUL JUNGSEONG YA-O" #x1178)
+    ("HANGUL JUNGSEONG YA-YO" #x1179)
+    ("HANGUL JUNGSEONG EO-O" #x117A)
+    ("HANGUL JUNGSEONG EO-U" #x117B)
+    ("HANGUL JUNGSEONG EO-EU" #x117C)
+    ("HANGUL JUNGSEONG YEO-O" #x117D)
+    ("HANGUL JUNGSEONG YEO-U" #x117E)
+    ("HANGUL JUNGSEONG O-EO" #x117F)
+    ("HANGUL JUNGSEONG O-E" #x1180)
+    ("HANGUL JUNGSEONG O-YE" #x1181)
+    ("HANGUL JUNGSEONG O-O" #x1182)
+    ("HANGUL JUNGSEONG O-U" #x1183)
+    ("HANGUL JUNGSEONG YO-YA" #x1184)
+    ("HANGUL JUNGSEONG YO-YAE" #x1185)
+    ("HANGUL JUNGSEONG YO-YEO" #x1186)
+    ("HANGUL JUNGSEONG YO-O" #x1187)
+    ("HANGUL JUNGSEONG YO-I" #x1188)
+    ("HANGUL JUNGSEONG U-A" #x1189)
+    ("HANGUL JUNGSEONG U-AE" #x118A)
+    ("HANGUL JUNGSEONG U-EO-EU" #x118B)
+    ("HANGUL JUNGSEONG U-YE" #x118C)
+    ("HANGUL JUNGSEONG U-U" #x118D)
+    ("HANGUL JUNGSEONG YU-A" #x118E)
+    ("HANGUL JUNGSEONG YU-EO" #x118F)
+    ("HANGUL JUNGSEONG YU-E" #x1190)
+    ("HANGUL JUNGSEONG YU-YEO" #x1191)
+    ("HANGUL JUNGSEONG YU-YE" #x1192)
+    ("HANGUL JUNGSEONG YU-U" #x1193)
+    ("HANGUL JUNGSEONG YU-I" #x1194)
+    ("HANGUL JUNGSEONG EU-U" #x1195)
+    ("HANGUL JUNGSEONG EU-EU" #x1196)
+    ("HANGUL JUNGSEONG YI-U" #x1197)
+    ("HANGUL JUNGSEONG I-A" #x1198)
+    ("HANGUL JUNGSEONG I-YA" #x1199)
+    ("HANGUL JUNGSEONG I-O" #x119A)
+    ("HANGUL JUNGSEONG I-U" #x119B)
+    ("HANGUL JUNGSEONG I-EU" #x119C)
+    ("HANGUL JUNGSEONG I-ARAEA" #x119D)
+    ("HANGUL JUNGSEONG ARAEA" #x119E)
+    ("HANGUL JUNGSEONG ARAEA-EO" #x119F)
+    ("HANGUL JUNGSEONG ARAEA-U" #x11A0)
+    ("HANGUL JUNGSEONG ARAEA-I" #x11A1)
+    ("HANGUL JUNGSEONG SSANGARAEA" #x11A2)
+    ("HANGUL JONGSEONG KIYEOK" #x11A8)
+    ("HANGUL JONGSEONG SSANGKIYEOK" #x11A9)
+    ("HANGUL JONGSEONG KIYEOK-SIOS" #x11AA)
+    ("HANGUL JONGSEONG NIEUN" #x11AB)
+    ("HANGUL JONGSEONG NIEUN-CIEUC" #x11AC)
+    ("HANGUL JONGSEONG NIEUN-HIEUH" #x11AD)
+    ("HANGUL JONGSEONG TIKEUT" #x11AE)
+    ("HANGUL JONGSEONG RIEUL" #x11AF)
+    ("HANGUL JONGSEONG RIEUL-KIYEOK" #x11B0)
+    ("HANGUL JONGSEONG RIEUL-MIEUM" #x11B1)
+    ("HANGUL JONGSEONG RIEUL-PIEUP" #x11B2)
+    ("HANGUL JONGSEONG RIEUL-SIOS" #x11B3)
+    ("HANGUL JONGSEONG RIEUL-THIEUTH" #x11B4)
+    ("HANGUL JONGSEONG RIEUL-PHIEUPH" #x11B5)
+    ("HANGUL JONGSEONG RIEUL-HIEUH" #x11B6)
+    ("HANGUL JONGSEONG MIEUM" #x11B7)
+    ("HANGUL JONGSEONG PIEUP" #x11B8)
+    ("HANGUL JONGSEONG PIEUP-SIOS" #x11B9)
+    ("HANGUL JONGSEONG SIOS" #x11BA)
+    ("HANGUL JONGSEONG SSANGSIOS" #x11BB)
+    ("HANGUL JONGSEONG IEUNG" #x11BC)
+    ("HANGUL JONGSEONG CIEUC" #x11BD)
+    ("HANGUL JONGSEONG CHIEUCH" #x11BE)
+    ("HANGUL JONGSEONG KHIEUKH" #x11BF)
+    ("HANGUL JONGSEONG THIEUTH" #x11C0)
+    ("HANGUL JONGSEONG PHIEUPH" #x11C1)
+    ("HANGUL JONGSEONG HIEUH" #x11C2)
+    ("HANGUL JONGSEONG KIYEOK-RIEUL" #x11C3)
+    ("HANGUL JONGSEONG KIYEOK-SIOS-KIYEOK" #x11C4)
+    ("HANGUL JONGSEONG NIEUN-KIYEOK" #x11C5)
+    ("HANGUL JONGSEONG NIEUN-TIKEUT" #x11C6)
+    ("HANGUL JONGSEONG NIEUN-SIOS" #x11C7)
+    ("HANGUL JONGSEONG NIEUN-PANSIOS" #x11C8)
+    ("HANGUL JONGSEONG NIEUN-THIEUTH" #x11C9)
+    ("HANGUL JONGSEONG TIKEUT-KIYEOK" #x11CA)
+    ("HANGUL JONGSEONG TIKEUT-RIEUL" #x11CB)
+    ("HANGUL JONGSEONG RIEUL-KIYEOK-SIOS" #x11CC)
+    ("HANGUL JONGSEONG RIEUL-NIEUN" #x11CD)
+    ("HANGUL JONGSEONG RIEUL-TIKEUT" #x11CE)
+    ("HANGUL JONGSEONG RIEUL-TIKEUT-HIEUH" #x11CF)
+    ("HANGUL JONGSEONG SSANGRIEUL" #x11D0)
+    ("HANGUL JONGSEONG RIEUL-MIEUM-KIYEOK" #x11D1)
+    ("HANGUL JONGSEONG RIEUL-MIEUM-SIOS" #x11D2)
+    ("HANGUL JONGSEONG RIEUL-PIEUP-SIOS" #x11D3)
+    ("HANGUL JONGSEONG RIEUL-PIEUP-HIEUH" #x11D4)
+    ("HANGUL JONGSEONG RIEUL-KAPYEOUNPIEUP" #x11D5)
+    ("HANGUL JONGSEONG RIEUL-SSANGSIOS" #x11D6)
+    ("HANGUL JONGSEONG RIEUL-PANSIOS" #x11D7)
+    ("HANGUL JONGSEONG RIEUL-KHIEUKH" #x11D8)
+    ("HANGUL JONGSEONG RIEUL-YEORINHIEUH" #x11D9)
+    ("HANGUL JONGSEONG MIEUM-KIYEOK" #x11DA)
+    ("HANGUL JONGSEONG MIEUM-RIEUL" #x11DB)
+    ("HANGUL JONGSEONG MIEUM-PIEUP" #x11DC)
+    ("HANGUL JONGSEONG MIEUM-SIOS" #x11DD)
+    ("HANGUL JONGSEONG MIEUM-SSANGSIOS" #x11DE)
+    ("HANGUL JONGSEONG MIEUM-PANSIOS" #x11DF)
+    ("HANGUL JONGSEONG MIEUM-CHIEUCH" #x11E0)
+    ("HANGUL JONGSEONG MIEUM-HIEUH" #x11E1)
+    ("HANGUL JONGSEONG KAPYEOUNMIEUM" #x11E2)
+    ("HANGUL JONGSEONG PIEUP-RIEUL" #x11E3)
+    ("HANGUL JONGSEONG PIEUP-PHIEUPH" #x11E4)
+    ("HANGUL JONGSEONG PIEUP-HIEUH" #x11E5)
+    ("HANGUL JONGSEONG KAPYEOUNPIEUP" #x11E6)
+    ("HANGUL JONGSEONG SIOS-KIYEOK" #x11E7)
+    ("HANGUL JONGSEONG SIOS-TIKEUT" #x11E8)
+    ("HANGUL JONGSEONG SIOS-RIEUL" #x11E9)
+    ("HANGUL JONGSEONG SIOS-PIEUP" #x11EA)
+    ("HANGUL JONGSEONG PANSIOS" #x11EB)
+    ("HANGUL JONGSEONG IEUNG-KIYEOK" #x11EC)
+    ("HANGUL JONGSEONG IEUNG-SSANGKIYEOK" #x11ED)
+    ("HANGUL JONGSEONG SSANGIEUNG" #x11EE)
+    ("HANGUL JONGSEONG IEUNG-KHIEUKH" #x11EF)
+    ("HANGUL JONGSEONG YESIEUNG" #x11F0)
+    ("HANGUL JONGSEONG YESIEUNG-SIOS" #x11F1)
+    ("HANGUL JONGSEONG YESIEUNG-PANSIOS" #x11F2)
+    ("HANGUL JONGSEONG PHIEUPH-PIEUP" #x11F3)
+    ("HANGUL JONGSEONG KAPYEOUNPHIEUPH" #x11F4)
+    ("HANGUL JONGSEONG HIEUH-NIEUN" #x11F5)
+    ("HANGUL JONGSEONG HIEUH-RIEUL" #x11F6)
+    ("HANGUL JONGSEONG HIEUH-MIEUM" #x11F7)
+    ("HANGUL JONGSEONG HIEUH-PIEUP" #x11F8)
+    ("HANGUL JONGSEONG YEORINHIEUH" #x11F9)
+    ))
diff --git a/lisp/nxml/char-name/unicode/01200-0137F.el b/lisp/nxml/char-name/unicode/01200-0137F.el
new file mode 100644
index 00000000000..06f59a3d841
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/01200-0137F.el
@@ -0,0 +1,347 @@
+(nxml-define-char-name-set 'ethiopic
+  '(("ETHIOPIC SYLLABLE HA" #x1200)
+    ("ETHIOPIC SYLLABLE HU" #x1201)
+    ("ETHIOPIC SYLLABLE HI" #x1202)
+    ("ETHIOPIC SYLLABLE HAA" #x1203)
+    ("ETHIOPIC SYLLABLE HEE" #x1204)
+    ("ETHIOPIC SYLLABLE HE" #x1205)
+    ("ETHIOPIC SYLLABLE HO" #x1206)
+    ("ETHIOPIC SYLLABLE LA" #x1208)
+    ("ETHIOPIC SYLLABLE LU" #x1209)
+    ("ETHIOPIC SYLLABLE LI" #x120A)
+    ("ETHIOPIC SYLLABLE LAA" #x120B)
+    ("ETHIOPIC SYLLABLE LEE" #x120C)
+    ("ETHIOPIC SYLLABLE LE" #x120D)
+    ("ETHIOPIC SYLLABLE LO" #x120E)
+    ("ETHIOPIC SYLLABLE LWA" #x120F)
+    ("ETHIOPIC SYLLABLE HHA" #x1210)
+    ("ETHIOPIC SYLLABLE HHU" #x1211)
+    ("ETHIOPIC SYLLABLE HHI" #x1212)
+    ("ETHIOPIC SYLLABLE HHAA" #x1213)
+    ("ETHIOPIC SYLLABLE HHEE" #x1214)
+    ("ETHIOPIC SYLLABLE HHE" #x1215)
+    ("ETHIOPIC SYLLABLE HHO" #x1216)
+    ("ETHIOPIC SYLLABLE HHWA" #x1217)
+    ("ETHIOPIC SYLLABLE MA" #x1218)
+    ("ETHIOPIC SYLLABLE MU" #x1219)
+    ("ETHIOPIC SYLLABLE MI" #x121A)
+    ("ETHIOPIC SYLLABLE MAA" #x121B)
+    ("ETHIOPIC SYLLABLE MEE" #x121C)
+    ("ETHIOPIC SYLLABLE ME" #x121D)
+    ("ETHIOPIC SYLLABLE MO" #x121E)
+    ("ETHIOPIC SYLLABLE MWA" #x121F)
+    ("ETHIOPIC SYLLABLE SZA" #x1220)
+    ("ETHIOPIC SYLLABLE SZU" #x1221)
+    ("ETHIOPIC SYLLABLE SZI" #x1222)
+    ("ETHIOPIC SYLLABLE SZAA" #x1223)
+    ("ETHIOPIC SYLLABLE SZEE" #x1224)
+    ("ETHIOPIC SYLLABLE SZE" #x1225)
+    ("ETHIOPIC SYLLABLE SZO" #x1226)
+    ("ETHIOPIC SYLLABLE SZWA" #x1227)
+    ("ETHIOPIC SYLLABLE RA" #x1228)
+    ("ETHIOPIC SYLLABLE RU" #x1229)
+    ("ETHIOPIC SYLLABLE RI" #x122A)
+    ("ETHIOPIC SYLLABLE RAA" #x122B)
+    ("ETHIOPIC SYLLABLE REE" #x122C)
+    ("ETHIOPIC SYLLABLE RE" #x122D)
+    ("ETHIOPIC SYLLABLE RO" #x122E)
+    ("ETHIOPIC SYLLABLE RWA" #x122F)
+    ("ETHIOPIC SYLLABLE SA" #x1230)
+    ("ETHIOPIC SYLLABLE SU" #x1231)
+    ("ETHIOPIC SYLLABLE SI" #x1232)
+    ("ETHIOPIC SYLLABLE SAA" #x1233)
+    ("ETHIOPIC SYLLABLE SEE" #x1234)
+    ("ETHIOPIC SYLLABLE SE" #x1235)
+    ("ETHIOPIC SYLLABLE SO" #x1236)
+    ("ETHIOPIC SYLLABLE SWA" #x1237)
+    ("ETHIOPIC SYLLABLE SHA" #x1238)
+    ("ETHIOPIC SYLLABLE SHU" #x1239)
+    ("ETHIOPIC SYLLABLE SHI" #x123A)
+    ("ETHIOPIC SYLLABLE SHAA" #x123B)
+    ("ETHIOPIC SYLLABLE SHEE" #x123C)
+    ("ETHIOPIC SYLLABLE SHE" #x123D)
+    ("ETHIOPIC SYLLABLE SHO" #x123E)
+    ("ETHIOPIC SYLLABLE SHWA" #x123F)
+    ("ETHIOPIC SYLLABLE QA" #x1240)
+    ("ETHIOPIC SYLLABLE QU" #x1241)
+    ("ETHIOPIC SYLLABLE QI" #x1242)
+    ("ETHIOPIC SYLLABLE QAA" #x1243)
+    ("ETHIOPIC SYLLABLE QEE" #x1244)
+    ("ETHIOPIC SYLLABLE QE" #x1245)
+    ("ETHIOPIC SYLLABLE QO" #x1246)
+    ("ETHIOPIC SYLLABLE QWA" #x1248)
+    ("ETHIOPIC SYLLABLE QWI" #x124A)
+    ("ETHIOPIC SYLLABLE QWAA" #x124B)
+    ("ETHIOPIC SYLLABLE QWEE" #x124C)
+    ("ETHIOPIC SYLLABLE QWE" #x124D)
+    ("ETHIOPIC SYLLABLE QHA" #x1250)
+    ("ETHIOPIC SYLLABLE QHU" #x1251)
+    ("ETHIOPIC SYLLABLE QHI" #x1252)
+    ("ETHIOPIC SYLLABLE QHAA" #x1253)
+    ("ETHIOPIC SYLLABLE QHEE" #x1254)
+    ("ETHIOPIC SYLLABLE QHE" #x1255)
+    ("ETHIOPIC SYLLABLE QHO" #x1256)
+    ("ETHIOPIC SYLLABLE QHWA" #x1258)
+    ("ETHIOPIC SYLLABLE QHWI" #x125A)
+    ("ETHIOPIC SYLLABLE QHWAA" #x125B)
+    ("ETHIOPIC SYLLABLE QHWEE" #x125C)
+    ("ETHIOPIC SYLLABLE QHWE" #x125D)
+    ("ETHIOPIC SYLLABLE BA" #x1260)
+    ("ETHIOPIC SYLLABLE BU" #x1261)
+    ("ETHIOPIC SYLLABLE BI" #x1262)
+    ("ETHIOPIC SYLLABLE BAA" #x1263)
+    ("ETHIOPIC SYLLABLE BEE" #x1264)
+    ("ETHIOPIC SYLLABLE BE" #x1265)
+    ("ETHIOPIC SYLLABLE BO" #x1266)
+    ("ETHIOPIC SYLLABLE BWA" #x1267)
+    ("ETHIOPIC SYLLABLE VA" #x1268)
+    ("ETHIOPIC SYLLABLE VU" #x1269)
+    ("ETHIOPIC SYLLABLE VI" #x126A)
+    ("ETHIOPIC SYLLABLE VAA" #x126B)
+    ("ETHIOPIC SYLLABLE VEE" #x126C)
+    ("ETHIOPIC SYLLABLE VE" #x126D)
+    ("ETHIOPIC SYLLABLE VO" #x126E)
+    ("ETHIOPIC SYLLABLE VWA" #x126F)
+    ("ETHIOPIC SYLLABLE TA" #x1270)
+    ("ETHIOPIC SYLLABLE TU" #x1271)
+    ("ETHIOPIC SYLLABLE TI" #x1272)
+    ("ETHIOPIC SYLLABLE TAA" #x1273)
+    ("ETHIOPIC SYLLABLE TEE" #x1274)
+    ("ETHIOPIC SYLLABLE TE" #x1275)
+    ("ETHIOPIC SYLLABLE TO" #x1276)
+    ("ETHIOPIC SYLLABLE TWA" #x1277)
+    ("ETHIOPIC SYLLABLE CA" #x1278)
+    ("ETHIOPIC SYLLABLE CU" #x1279)
+    ("ETHIOPIC SYLLABLE CI" #x127A)
+    ("ETHIOPIC SYLLABLE CAA" #x127B)
+    ("ETHIOPIC SYLLABLE CEE" #x127C)
+    ("ETHIOPIC SYLLABLE CE" #x127D)
+    ("ETHIOPIC SYLLABLE CO" #x127E)
+    ("ETHIOPIC SYLLABLE CWA" #x127F)
+    ("ETHIOPIC SYLLABLE XA" #x1280)
+    ("ETHIOPIC SYLLABLE XU" #x1281)
+    ("ETHIOPIC SYLLABLE XI" #x1282)
+    ("ETHIOPIC SYLLABLE XAA" #x1283)
+    ("ETHIOPIC SYLLABLE XEE" #x1284)
+    ("ETHIOPIC SYLLABLE XE" #x1285)
+    ("ETHIOPIC SYLLABLE XO" #x1286)
+    ("ETHIOPIC SYLLABLE XWA" #x1288)
+    ("ETHIOPIC SYLLABLE XWI" #x128A)
+    ("ETHIOPIC SYLLABLE XWAA" #x128B)
+    ("ETHIOPIC SYLLABLE XWEE" #x128C)
+    ("ETHIOPIC SYLLABLE XWE" #x128D)
+    ("ETHIOPIC SYLLABLE NA" #x1290)
+    ("ETHIOPIC SYLLABLE NU" #x1291)
+    ("ETHIOPIC SYLLABLE NI" #x1292)
+    ("ETHIOPIC SYLLABLE NAA" #x1293)
+    ("ETHIOPIC SYLLABLE NEE" #x1294)
+    ("ETHIOPIC SYLLABLE NE" #x1295)
+    ("ETHIOPIC SYLLABLE NO" #x1296)
+    ("ETHIOPIC SYLLABLE NWA" #x1297)
+    ("ETHIOPIC SYLLABLE NYA" #x1298)
+    ("ETHIOPIC SYLLABLE NYU" #x1299)
+    ("ETHIOPIC SYLLABLE NYI" #x129A)
+    ("ETHIOPIC SYLLABLE NYAA" #x129B)
+    ("ETHIOPIC SYLLABLE NYEE" #x129C)
+    ("ETHIOPIC SYLLABLE NYE" #x129D)
+    ("ETHIOPIC SYLLABLE NYO" #x129E)
+    ("ETHIOPIC SYLLABLE NYWA" #x129F)
+    ("ETHIOPIC SYLLABLE GLOTTAL A" #x12A0)
+    ("ETHIOPIC SYLLABLE GLOTTAL U" #x12A1)
+    ("ETHIOPIC SYLLABLE GLOTTAL I" #x12A2)
+    ("ETHIOPIC SYLLABLE GLOTTAL AA" #x12A3)
+    ("ETHIOPIC SYLLABLE GLOTTAL EE" #x12A4)
+    ("ETHIOPIC SYLLABLE GLOTTAL E" #x12A5)
+    ("ETHIOPIC SYLLABLE GLOTTAL O" #x12A6)
+    ("ETHIOPIC SYLLABLE GLOTTAL WA" #x12A7)
+    ("ETHIOPIC SYLLABLE KA" #x12A8)
+    ("ETHIOPIC SYLLABLE KU" #x12A9)
+    ("ETHIOPIC SYLLABLE KI" #x12AA)
+    ("ETHIOPIC SYLLABLE KAA" #x12AB)
+    ("ETHIOPIC SYLLABLE KEE" #x12AC)
+    ("ETHIOPIC SYLLABLE KE" #x12AD)
+    ("ETHIOPIC SYLLABLE KO" #x12AE)
+    ("ETHIOPIC SYLLABLE KWA" #x12B0)
+    ("ETHIOPIC SYLLABLE KWI" #x12B2)
+    ("ETHIOPIC SYLLABLE KWAA" #x12B3)
+    ("ETHIOPIC SYLLABLE KWEE" #x12B4)
+    ("ETHIOPIC SYLLABLE KWE" #x12B5)
+    ("ETHIOPIC SYLLABLE KXA" #x12B8)
+    ("ETHIOPIC SYLLABLE KXU" #x12B9)
+    ("ETHIOPIC SYLLABLE KXI" #x12BA)
+    ("ETHIOPIC SYLLABLE KXAA" #x12BB)
+    ("ETHIOPIC SYLLABLE KXEE" #x12BC)
+    ("ETHIOPIC SYLLABLE KXE" #x12BD)
+    ("ETHIOPIC SYLLABLE KXO" #x12BE)
+    ("ETHIOPIC SYLLABLE KXWA" #x12C0)
+    ("ETHIOPIC SYLLABLE KXWI" #x12C2)
+    ("ETHIOPIC SYLLABLE KXWAA" #x12C3)
+    ("ETHIOPIC SYLLABLE KXWEE" #x12C4)
+    ("ETHIOPIC SYLLABLE KXWE" #x12C5)
+    ("ETHIOPIC SYLLABLE WA" #x12C8)
+    ("ETHIOPIC SYLLABLE WU" #x12C9)
+    ("ETHIOPIC SYLLABLE WI" #x12CA)
+    ("ETHIOPIC SYLLABLE WAA" #x12CB)
+    ("ETHIOPIC SYLLABLE WEE" #x12CC)
+    ("ETHIOPIC SYLLABLE WE" #x12CD)
+    ("ETHIOPIC SYLLABLE WO" #x12CE)
+    ("ETHIOPIC SYLLABLE PHARYNGEAL A" #x12D0)
+    ("ETHIOPIC SYLLABLE PHARYNGEAL U" #x12D1)
+    ("ETHIOPIC SYLLABLE PHARYNGEAL I" #x12D2)
+    ("ETHIOPIC SYLLABLE PHARYNGEAL AA" #x12D3)
+    ("ETHIOPIC SYLLABLE PHARYNGEAL EE" #x12D4)
+    ("ETHIOPIC SYLLABLE PHARYNGEAL E" #x12D5)
+    ("ETHIOPIC SYLLABLE PHARYNGEAL O" #x12D6)
+    ("ETHIOPIC SYLLABLE ZA" #x12D8)
+    ("ETHIOPIC SYLLABLE ZU" #x12D9)
+    ("ETHIOPIC SYLLABLE ZI" #x12DA)
+    ("ETHIOPIC SYLLABLE ZAA" #x12DB)
+    ("ETHIOPIC SYLLABLE ZEE" #x12DC)
+    ("ETHIOPIC SYLLABLE ZE" #x12DD)
+    ("ETHIOPIC SYLLABLE ZO" #x12DE)
+    ("ETHIOPIC SYLLABLE ZWA" #x12DF)
+    ("ETHIOPIC SYLLABLE ZHA" #x12E0)
+    ("ETHIOPIC SYLLABLE ZHU" #x12E1)
+    ("ETHIOPIC SYLLABLE ZHI" #x12E2)
+    ("ETHIOPIC SYLLABLE ZHAA" #x12E3)
+    ("ETHIOPIC SYLLABLE ZHEE" #x12E4)
+    ("ETHIOPIC SYLLABLE ZHE" #x12E5)
+    ("ETHIOPIC SYLLABLE ZHO" #x12E6)
+    ("ETHIOPIC SYLLABLE ZHWA" #x12E7)
+    ("ETHIOPIC SYLLABLE YA" #x12E8)
+    ("ETHIOPIC SYLLABLE YU" #x12E9)
+    ("ETHIOPIC SYLLABLE YI" #x12EA)
+    ("ETHIOPIC SYLLABLE YAA" #x12EB)
+    ("ETHIOPIC SYLLABLE YEE" #x12EC)
+    ("ETHIOPIC SYLLABLE YE" #x12ED)
+    ("ETHIOPIC SYLLABLE YO" #x12EE)
+    ("ETHIOPIC SYLLABLE DA" #x12F0)
+    ("ETHIOPIC SYLLABLE DU" #x12F1)
+    ("ETHIOPIC SYLLABLE DI" #x12F2)
+    ("ETHIOPIC SYLLABLE DAA" #x12F3)
+    ("ETHIOPIC SYLLABLE DEE" #x12F4)
+    ("ETHIOPIC SYLLABLE DE" #x12F5)
+    ("ETHIOPIC SYLLABLE DO" #x12F6)
+    ("ETHIOPIC SYLLABLE DWA" #x12F7)
+    ("ETHIOPIC SYLLABLE DDA" #x12F8)
+    ("ETHIOPIC SYLLABLE DDU" #x12F9)
+    ("ETHIOPIC SYLLABLE DDI" #x12FA)
+    ("ETHIOPIC SYLLABLE DDAA" #x12FB)
+    ("ETHIOPIC SYLLABLE DDEE" #x12FC)
+    ("ETHIOPIC SYLLABLE DDE" #x12FD)
+    ("ETHIOPIC SYLLABLE DDO" #x12FE)
+    ("ETHIOPIC SYLLABLE DDWA" #x12FF)
+    ("ETHIOPIC SYLLABLE JA" #x1300)
+    ("ETHIOPIC SYLLABLE JU" #x1301)
+    ("ETHIOPIC SYLLABLE JI" #x1302)
+    ("ETHIOPIC SYLLABLE JAA" #x1303)
+    ("ETHIOPIC SYLLABLE JEE" #x1304)
+    ("ETHIOPIC SYLLABLE JE" #x1305)
+    ("ETHIOPIC SYLLABLE JO" #x1306)
+    ("ETHIOPIC SYLLABLE JWA" #x1307)
+    ("ETHIOPIC SYLLABLE GA" #x1308)
+    ("ETHIOPIC SYLLABLE GU" #x1309)
+    ("ETHIOPIC SYLLABLE GI" #x130A)
+    ("ETHIOPIC SYLLABLE GAA" #x130B)
+    ("ETHIOPIC SYLLABLE GEE" #x130C)
+    ("ETHIOPIC SYLLABLE GE" #x130D)
+    ("ETHIOPIC SYLLABLE GO" #x130E)
+    ("ETHIOPIC SYLLABLE GWA" #x1310)
+    ("ETHIOPIC SYLLABLE GWI" #x1312)
+    ("ETHIOPIC SYLLABLE GWAA" #x1313)
+    ("ETHIOPIC SYLLABLE GWEE" #x1314)
+    ("ETHIOPIC SYLLABLE GWE" #x1315)
+    ("ETHIOPIC SYLLABLE GGA" #x1318)
+    ("ETHIOPIC SYLLABLE GGU" #x1319)
+    ("ETHIOPIC SYLLABLE GGI" #x131A)
+    ("ETHIOPIC SYLLABLE GGAA" #x131B)
+    ("ETHIOPIC SYLLABLE GGEE" #x131C)
+    ("ETHIOPIC SYLLABLE GGE" #x131D)
+    ("ETHIOPIC SYLLABLE GGO" #x131E)
+    ("ETHIOPIC SYLLABLE THA" #x1320)
+    ("ETHIOPIC SYLLABLE THU" #x1321)
+    ("ETHIOPIC SYLLABLE THI" #x1322)
+    ("ETHIOPIC SYLLABLE THAA" #x1323)
+    ("ETHIOPIC SYLLABLE THEE" #x1324)
+    ("ETHIOPIC SYLLABLE THE" #x1325)
+    ("ETHIOPIC SYLLABLE THO" #x1326)
+    ("ETHIOPIC SYLLABLE THWA" #x1327)
+    ("ETHIOPIC SYLLABLE CHA" #x1328)
+    ("ETHIOPIC SYLLABLE CHU" #x1329)
+    ("ETHIOPIC SYLLABLE CHI" #x132A)
+    ("ETHIOPIC SYLLABLE CHAA" #x132B)
+    ("ETHIOPIC SYLLABLE CHEE" #x132C)
+    ("ETHIOPIC SYLLABLE CHE" #x132D)
+    ("ETHIOPIC SYLLABLE CHO" #x132E)
+    ("ETHIOPIC SYLLABLE CHWA" #x132F)
+    ("ETHIOPIC SYLLABLE PHA" #x1330)
+    ("ETHIOPIC SYLLABLE PHU" #x1331)
+    ("ETHIOPIC SYLLABLE PHI" #x1332)
+    ("ETHIOPIC SYLLABLE PHAA" #x1333)
+    ("ETHIOPIC SYLLABLE PHEE" #x1334)
+    ("ETHIOPIC SYLLABLE PHE" #x1335)
+    ("ETHIOPIC SYLLABLE PHO" #x1336)
+    ("ETHIOPIC SYLLABLE PHWA" #x1337)
+    ("ETHIOPIC SYLLABLE TSA" #x1338)
+    ("ETHIOPIC SYLLABLE TSU" #x1339)
+    ("ETHIOPIC SYLLABLE TSI" #x133A)
+    ("ETHIOPIC SYLLABLE TSAA" #x133B)
+    ("ETHIOPIC SYLLABLE TSEE" #x133C)
+    ("ETHIOPIC SYLLABLE TSE" #x133D)
+    ("ETHIOPIC SYLLABLE TSO" #x133E)
+    ("ETHIOPIC SYLLABLE TSWA" #x133F)
+    ("ETHIOPIC SYLLABLE TZA" #x1340)
+    ("ETHIOPIC SYLLABLE TZU" #x1341)
+    ("ETHIOPIC SYLLABLE TZI" #x1342)
+    ("ETHIOPIC SYLLABLE TZAA" #x1343)
+    ("ETHIOPIC SYLLABLE TZEE" #x1344)
+    ("ETHIOPIC SYLLABLE TZE" #x1345)
+    ("ETHIOPIC SYLLABLE TZO" #x1346)
+    ("ETHIOPIC SYLLABLE FA" #x1348)
+    ("ETHIOPIC SYLLABLE FU" #x1349)
+    ("ETHIOPIC SYLLABLE FI" #x134A)
+    ("ETHIOPIC SYLLABLE FAA" #x134B)
+    ("ETHIOPIC SYLLABLE FEE" #x134C)
+    ("ETHIOPIC SYLLABLE FE" #x134D)
+    ("ETHIOPIC SYLLABLE FO" #x134E)
+    ("ETHIOPIC SYLLABLE FWA" #x134F)
+    ("ETHIOPIC SYLLABLE PA" #x1350)
+    ("ETHIOPIC SYLLABLE PU" #x1351)
+    ("ETHIOPIC SYLLABLE PI" #x1352)
+    ("ETHIOPIC SYLLABLE PAA" #x1353)
+    ("ETHIOPIC SYLLABLE PEE" #x1354)
+    ("ETHIOPIC SYLLABLE PE" #x1355)
+    ("ETHIOPIC SYLLABLE PO" #x1356)
+    ("ETHIOPIC SYLLABLE PWA" #x1357)
+    ("ETHIOPIC SYLLABLE RYA" #x1358)
+    ("ETHIOPIC SYLLABLE MYA" #x1359)
+    ("ETHIOPIC SYLLABLE FYA" #x135A)
+    ("ETHIOPIC WORDSPACE" #x1361)
+    ("ETHIOPIC FULL STOP" #x1362)
+    ("ETHIOPIC COMMA" #x1363)
+    ("ETHIOPIC SEMICOLON" #x1364)
+    ("ETHIOPIC COLON" #x1365)
+    ("ETHIOPIC PREFACE COLON" #x1366)
+    ("ETHIOPIC QUESTION MARK" #x1367)
+    ("ETHIOPIC PARAGRAPH SEPARATOR" #x1368)
+    ("ETHIOPIC DIGIT ONE" #x1369)
+    ("ETHIOPIC DIGIT TWO" #x136A)
+    ("ETHIOPIC DIGIT THREE" #x136B)
+    ("ETHIOPIC DIGIT FOUR" #x136C)
+    ("ETHIOPIC DIGIT FIVE" #x136D)
+    ("ETHIOPIC DIGIT SIX" #x136E)
+    ("ETHIOPIC DIGIT SEVEN" #x136F)
+    ("ETHIOPIC DIGIT EIGHT" #x1370)
+    ("ETHIOPIC DIGIT NINE" #x1371)
+    ("ETHIOPIC NUMBER TEN" #x1372)
+    ("ETHIOPIC NUMBER TWENTY" #x1373)
+    ("ETHIOPIC NUMBER THIRTY" #x1374)
+    ("ETHIOPIC NUMBER FORTY" #x1375)
+    ("ETHIOPIC NUMBER FIFTY" #x1376)
+    ("ETHIOPIC NUMBER SIXTY" #x1377)
+    ("ETHIOPIC NUMBER SEVENTY" #x1378)
+    ("ETHIOPIC NUMBER EIGHTY" #x1379)
+    ("ETHIOPIC NUMBER NINETY" #x137A)
+    ("ETHIOPIC NUMBER HUNDRED" #x137B)
+    ("ETHIOPIC NUMBER TEN THOUSAND" #x137C)
+    ))
diff --git a/lisp/nxml/char-name/unicode/013A0-013FF.el b/lisp/nxml/char-name/unicode/013A0-013FF.el
new file mode 100644
index 00000000000..74111fb8b09
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/013A0-013FF.el
@@ -0,0 +1,87 @@
+(nxml-define-char-name-set 'cherokee
+  '(("CHEROKEE LETTER A" #x13A0)
+    ("CHEROKEE LETTER E" #x13A1)
+    ("CHEROKEE LETTER I" #x13A2)
+    ("CHEROKEE LETTER O" #x13A3)
+    ("CHEROKEE LETTER U" #x13A4)
+    ("CHEROKEE LETTER V" #x13A5)
+    ("CHEROKEE LETTER GA" #x13A6)
+    ("CHEROKEE LETTER KA" #x13A7)
+    ("CHEROKEE LETTER GE" #x13A8)
+    ("CHEROKEE LETTER GI" #x13A9)
+    ("CHEROKEE LETTER GO" #x13AA)
+    ("CHEROKEE LETTER GU" #x13AB)
+    ("CHEROKEE LETTER GV" #x13AC)
+    ("CHEROKEE LETTER HA" #x13AD)
+    ("CHEROKEE LETTER HE" #x13AE)
+    ("CHEROKEE LETTER HI" #x13AF)
+    ("CHEROKEE LETTER HO" #x13B0)
+    ("CHEROKEE LETTER HU" #x13B1)
+    ("CHEROKEE LETTER HV" #x13B2)
+    ("CHEROKEE LETTER LA" #x13B3)
+    ("CHEROKEE LETTER LE" #x13B4)
+    ("CHEROKEE LETTER LI" #x13B5)
+    ("CHEROKEE LETTER LO" #x13B6)
+    ("CHEROKEE LETTER LU" #x13B7)
+    ("CHEROKEE LETTER LV" #x13B8)
+    ("CHEROKEE LETTER MA" #x13B9)
+    ("CHEROKEE LETTER ME" #x13BA)
+    ("CHEROKEE LETTER MI" #x13BB)
+    ("CHEROKEE LETTER MO" #x13BC)
+    ("CHEROKEE LETTER MU" #x13BD)
+    ("CHEROKEE LETTER NA" #x13BE)
+    ("CHEROKEE LETTER HNA" #x13BF)
+    ("CHEROKEE LETTER NAH" #x13C0)
+    ("CHEROKEE LETTER NE" #x13C1)
+    ("CHEROKEE LETTER NI" #x13C2)
+    ("CHEROKEE LETTER NO" #x13C3)
+    ("CHEROKEE LETTER NU" #x13C4)
+    ("CHEROKEE LETTER NV" #x13C5)
+    ("CHEROKEE LETTER QUA" #x13C6)
+    ("CHEROKEE LETTER QUE" #x13C7)
+    ("CHEROKEE LETTER QUI" #x13C8)
+    ("CHEROKEE LETTER QUO" #x13C9)
+    ("CHEROKEE LETTER QUU" #x13CA)
+    ("CHEROKEE LETTER QUV" #x13CB)
+    ("CHEROKEE LETTER SA" #x13CC)
+    ("CHEROKEE LETTER S" #x13CD)
+    ("CHEROKEE LETTER SE" #x13CE)
+    ("CHEROKEE LETTER SI" #x13CF)
+    ("CHEROKEE LETTER SO" #x13D0)
+    ("CHEROKEE LETTER SU" #x13D1)
+    ("CHEROKEE LETTER SV" #x13D2)
+    ("CHEROKEE LETTER DA" #x13D3)
+    ("CHEROKEE LETTER TA" #x13D4)
+    ("CHEROKEE LETTER DE" #x13D5)
+    ("CHEROKEE LETTER TE" #x13D6)
+    ("CHEROKEE LETTER DI" #x13D7)
+    ("CHEROKEE LETTER TI" #x13D8)
+    ("CHEROKEE LETTER DO" #x13D9)
+    ("CHEROKEE LETTER DU" #x13DA)
+    ("CHEROKEE LETTER DV" #x13DB)
+    ("CHEROKEE LETTER DLA" #x13DC)
+    ("CHEROKEE LETTER TLA" #x13DD)
+    ("CHEROKEE LETTER TLE" #x13DE)
+    ("CHEROKEE LETTER TLI" #x13DF)
+    ("CHEROKEE LETTER TLO" #x13E0)
+    ("CHEROKEE LETTER TLU" #x13E1)
+    ("CHEROKEE LETTER TLV" #x13E2)
+    ("CHEROKEE LETTER TSA" #x13E3)
+    ("CHEROKEE LETTER TSE" #x13E4)
+    ("CHEROKEE LETTER TSI" #x13E5)
+    ("CHEROKEE LETTER TSO" #x13E6)
+    ("CHEROKEE LETTER TSU" #x13E7)
+    ("CHEROKEE LETTER TSV" #x13E8)
+    ("CHEROKEE LETTER WA" #x13E9)
+    ("CHEROKEE LETTER WE" #x13EA)
+    ("CHEROKEE LETTER WI" #x13EB)
+    ("CHEROKEE LETTER WO" #x13EC)
+    ("CHEROKEE LETTER WU" #x13ED)
+    ("CHEROKEE LETTER WV" #x13EE)
+    ("CHEROKEE LETTER YA" #x13EF)
+    ("CHEROKEE LETTER YE" #x13F0)
+    ("CHEROKEE LETTER YI" #x13F1)
+    ("CHEROKEE LETTER YO" #x13F2)
+    ("CHEROKEE LETTER YU" #x13F3)
+    ("CHEROKEE LETTER YV" #x13F4)
+    ))
diff --git a/lisp/nxml/char-name/unicode/01400-0167F.el b/lisp/nxml/char-name/unicode/01400-0167F.el
new file mode 100644
index 00000000000..644b2552d00
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/01400-0167F.el
@@ -0,0 +1,632 @@
+(nxml-define-char-name-set 'unified-canadian-aboriginal-syllabics
+  '(("CANADIAN SYLLABICS E" #x1401)
+    ("CANADIAN SYLLABICS AAI" #x1402)
+    ("CANADIAN SYLLABICS I" #x1403)
+    ("CANADIAN SYLLABICS II" #x1404)
+    ("CANADIAN SYLLABICS O" #x1405)
+    ("CANADIAN SYLLABICS OO" #x1406)
+    ("CANADIAN SYLLABICS Y-CREE OO" #x1407)
+    ("CANADIAN SYLLABICS CARRIER EE" #x1408)
+    ("CANADIAN SYLLABICS CARRIER I" #x1409)
+    ("CANADIAN SYLLABICS A" #x140A)
+    ("CANADIAN SYLLABICS AA" #x140B)
+    ("CANADIAN SYLLABICS WE" #x140C)
+    ("CANADIAN SYLLABICS WEST-CREE WE" #x140D)
+    ("CANADIAN SYLLABICS WI" #x140E)
+    ("CANADIAN SYLLABICS WEST-CREE WI" #x140F)
+    ("CANADIAN SYLLABICS WII" #x1410)
+    ("CANADIAN SYLLABICS WEST-CREE WII" #x1411)
+    ("CANADIAN SYLLABICS WO" #x1412)
+    ("CANADIAN SYLLABICS WEST-CREE WO" #x1413)
+    ("CANADIAN SYLLABICS WOO" #x1414)
+    ("CANADIAN SYLLABICS WEST-CREE WOO" #x1415)
+    ("CANADIAN SYLLABICS NASKAPI WOO" #x1416)
+    ("CANADIAN SYLLABICS WA" #x1417)
+    ("CANADIAN SYLLABICS WEST-CREE WA" #x1418)
+    ("CANADIAN SYLLABICS WAA" #x1419)
+    ("CANADIAN SYLLABICS WEST-CREE WAA" #x141A)
+    ("CANADIAN SYLLABICS NASKAPI WAA" #x141B)
+    ("CANADIAN SYLLABICS AI" #x141C)
+    ("CANADIAN SYLLABICS Y-CREE W" #x141D)
+    ("CANADIAN SYLLABICS GLOTTAL STOP" #x141E)
+    ("CANADIAN SYLLABICS FINAL ACUTE" #x141F)
+    ("CANADIAN SYLLABICS FINAL GRAVE" #x1420)
+    ("CANADIAN SYLLABICS FINAL BOTTOM HALF RING" #x1421)
+    ("CANADIAN SYLLABICS FINAL TOP HALF RING" #x1422)
+    ("CANADIAN SYLLABICS FINAL RIGHT HALF RING" #x1423)
+    ("CANADIAN SYLLABICS FINAL RING" #x1424)
+    ("CANADIAN SYLLABICS FINAL DOUBLE ACUTE" #x1425)
+    ("CANADIAN SYLLABICS FINAL DOUBLE SHORT VERTICAL STROKES" #x1426)
+    ("CANADIAN SYLLABICS FINAL MIDDLE DOT" #x1427)
+    ("CANADIAN SYLLABICS FINAL SHORT HORIZONTAL STROKE" #x1428)
+    ("CANADIAN SYLLABICS FINAL PLUS" #x1429)
+    ("CANADIAN SYLLABICS FINAL DOWN TACK" #x142A)
+    ("CANADIAN SYLLABICS EN" #x142B)
+    ("CANADIAN SYLLABICS IN" #x142C)
+    ("CANADIAN SYLLABICS ON" #x142D)
+    ("CANADIAN SYLLABICS AN" #x142E)
+    ("CANADIAN SYLLABICS PE" #x142F)
+    ("CANADIAN SYLLABICS PAAI" #x1430)
+    ("CANADIAN SYLLABICS PI" #x1431)
+    ("CANADIAN SYLLABICS PII" #x1432)
+    ("CANADIAN SYLLABICS PO" #x1433)
+    ("CANADIAN SYLLABICS POO" #x1434)
+    ("CANADIAN SYLLABICS Y-CREE POO" #x1435)
+    ("CANADIAN SYLLABICS CARRIER HEE" #x1436)
+    ("CANADIAN SYLLABICS CARRIER HI" #x1437)
+    ("CANADIAN SYLLABICS PA" #x1438)
+    ("CANADIAN SYLLABICS PAA" #x1439)
+    ("CANADIAN SYLLABICS PWE" #x143A)
+    ("CANADIAN SYLLABICS WEST-CREE PWE" #x143B)
+    ("CANADIAN SYLLABICS PWI" #x143C)
+    ("CANADIAN SYLLABICS WEST-CREE PWI" #x143D)
+    ("CANADIAN SYLLABICS PWII" #x143E)
+    ("CANADIAN SYLLABICS WEST-CREE PWII" #x143F)
+    ("CANADIAN SYLLABICS PWO" #x1440)
+    ("CANADIAN SYLLABICS WEST-CREE PWO" #x1441)
+    ("CANADIAN SYLLABICS PWOO" #x1442)
+    ("CANADIAN SYLLABICS WEST-CREE PWOO" #x1443)
+    ("CANADIAN SYLLABICS PWA" #x1444)
+    ("CANADIAN SYLLABICS WEST-CREE PWA" #x1445)
+    ("CANADIAN SYLLABICS PWAA" #x1446)
+    ("CANADIAN SYLLABICS WEST-CREE PWAA" #x1447)
+    ("CANADIAN SYLLABICS Y-CREE PWAA" #x1448)
+    ("CANADIAN SYLLABICS P" #x1449)
+    ("CANADIAN SYLLABICS WEST-CREE P" #x144A)
+    ("CANADIAN SYLLABICS CARRIER H" #x144B)
+    ("CANADIAN SYLLABICS TE" #x144C)
+    ("CANADIAN SYLLABICS TAAI" #x144D)
+    ("CANADIAN SYLLABICS TI" #x144E)
+    ("CANADIAN SYLLABICS TII" #x144F)
+    ("CANADIAN SYLLABICS TO" #x1450)
+    ("CANADIAN SYLLABICS TOO" #x1451)
+    ("CANADIAN SYLLABICS Y-CREE TOO" #x1452)
+    ("CANADIAN SYLLABICS CARRIER DEE" #x1453)
+    ("CANADIAN SYLLABICS CARRIER DI" #x1454)
+    ("CANADIAN SYLLABICS TA" #x1455)
+    ("CANADIAN SYLLABICS TAA" #x1456)
+    ("CANADIAN SYLLABICS TWE" #x1457)
+    ("CANADIAN SYLLABICS WEST-CREE TWE" #x1458)
+    ("CANADIAN SYLLABICS TWI" #x1459)
+    ("CANADIAN SYLLABICS WEST-CREE TWI" #x145A)
+    ("CANADIAN SYLLABICS TWII" #x145B)
+    ("CANADIAN SYLLABICS WEST-CREE TWII" #x145C)
+    ("CANADIAN SYLLABICS TWO" #x145D)
+    ("CANADIAN SYLLABICS WEST-CREE TWO" #x145E)
+    ("CANADIAN SYLLABICS TWOO" #x145F)
+    ("CANADIAN SYLLABICS WEST-CREE TWOO" #x1460)
+    ("CANADIAN SYLLABICS TWA" #x1461)
+    ("CANADIAN SYLLABICS WEST-CREE TWA" #x1462)
+    ("CANADIAN SYLLABICS TWAA" #x1463)
+    ("CANADIAN SYLLABICS WEST-CREE TWAA" #x1464)
+    ("CANADIAN SYLLABICS NASKAPI TWAA" #x1465)
+    ("CANADIAN SYLLABICS T" #x1466)
+    ("CANADIAN SYLLABICS TTE" #x1467)
+    ("CANADIAN SYLLABICS TTI" #x1468)
+    ("CANADIAN SYLLABICS TTO" #x1469)
+    ("CANADIAN SYLLABICS TTA" #x146A)
+    ("CANADIAN SYLLABICS KE" #x146B)
+    ("CANADIAN SYLLABICS KAAI" #x146C)
+    ("CANADIAN SYLLABICS KI" #x146D)
+    ("CANADIAN SYLLABICS KII" #x146E)
+    ("CANADIAN SYLLABICS KO" #x146F)
+    ("CANADIAN SYLLABICS KOO" #x1470)
+    ("CANADIAN SYLLABICS Y-CREE KOO" #x1471)
+    ("CANADIAN SYLLABICS KA" #x1472)
+    ("CANADIAN SYLLABICS KAA" #x1473)
+    ("CANADIAN SYLLABICS KWE" #x1474)
+    ("CANADIAN SYLLABICS WEST-CREE KWE" #x1475)
+    ("CANADIAN SYLLABICS KWI" #x1476)
+    ("CANADIAN SYLLABICS WEST-CREE KWI" #x1477)
+    ("CANADIAN SYLLABICS KWII" #x1478)
+    ("CANADIAN SYLLABICS WEST-CREE KWII" #x1479)
+    ("CANADIAN SYLLABICS KWO" #x147A)
+    ("CANADIAN SYLLABICS WEST-CREE KWO" #x147B)
+    ("CANADIAN SYLLABICS KWOO" #x147C)
+    ("CANADIAN SYLLABICS WEST-CREE KWOO" #x147D)
+    ("CANADIAN SYLLABICS KWA" #x147E)
+    ("CANADIAN SYLLABICS WEST-CREE KWA" #x147F)
+    ("CANADIAN SYLLABICS KWAA" #x1480)
+    ("CANADIAN SYLLABICS WEST-CREE KWAA" #x1481)
+    ("CANADIAN SYLLABICS NASKAPI KWAA" #x1482)
+    ("CANADIAN SYLLABICS K" #x1483)
+    ("CANADIAN SYLLABICS KW" #x1484)
+    ("CANADIAN SYLLABICS SOUTH-SLAVEY KEH" #x1485)
+    ("CANADIAN SYLLABICS SOUTH-SLAVEY KIH" #x1486)
+    ("CANADIAN SYLLABICS SOUTH-SLAVEY KOH" #x1487)
+    ("CANADIAN SYLLABICS SOUTH-SLAVEY KAH" #x1488)
+    ("CANADIAN SYLLABICS CE" #x1489)
+    ("CANADIAN SYLLABICS CAAI" #x148A)
+    ("CANADIAN SYLLABICS CI" #x148B)
+    ("CANADIAN SYLLABICS CII" #x148C)
+    ("CANADIAN SYLLABICS CO" #x148D)
+    ("CANADIAN SYLLABICS COO" #x148E)
+    ("CANADIAN SYLLABICS Y-CREE COO" #x148F)
+    ("CANADIAN SYLLABICS CA" #x1490)
+    ("CANADIAN SYLLABICS CAA" #x1491)
+    ("CANADIAN SYLLABICS CWE" #x1492)
+    ("CANADIAN SYLLABICS WEST-CREE CWE" #x1493)
+    ("CANADIAN SYLLABICS CWI" #x1494)
+    ("CANADIAN SYLLABICS WEST-CREE CWI" #x1495)
+    ("CANADIAN SYLLABICS CWII" #x1496)
+    ("CANADIAN SYLLABICS WEST-CREE CWII" #x1497)
+    ("CANADIAN SYLLABICS CWO" #x1498)
+    ("CANADIAN SYLLABICS WEST-CREE CWO" #x1499)
+    ("CANADIAN SYLLABICS CWOO" #x149A)
+    ("CANADIAN SYLLABICS WEST-CREE CWOO" #x149B)
+    ("CANADIAN SYLLABICS CWA" #x149C)
+    ("CANADIAN SYLLABICS WEST-CREE CWA" #x149D)
+    ("CANADIAN SYLLABICS CWAA" #x149E)
+    ("CANADIAN SYLLABICS WEST-CREE CWAA" #x149F)
+    ("CANADIAN SYLLABICS NASKAPI CWAA" #x14A0)
+    ("CANADIAN SYLLABICS C" #x14A1)
+    ("CANADIAN SYLLABICS SAYISI TH" #x14A2)
+    ("CANADIAN SYLLABICS ME" #x14A3)
+    ("CANADIAN SYLLABICS MAAI" #x14A4)
+    ("CANADIAN SYLLABICS MI" #x14A5)
+    ("CANADIAN SYLLABICS MII" #x14A6)
+    ("CANADIAN SYLLABICS MO" #x14A7)
+    ("CANADIAN SYLLABICS MOO" #x14A8)
+    ("CANADIAN SYLLABICS Y-CREE MOO" #x14A9)
+    ("CANADIAN SYLLABICS MA" #x14AA)
+    ("CANADIAN SYLLABICS MAA" #x14AB)
+    ("CANADIAN SYLLABICS MWE" #x14AC)
+    ("CANADIAN SYLLABICS WEST-CREE MWE" #x14AD)
+    ("CANADIAN SYLLABICS MWI" #x14AE)
+    ("CANADIAN SYLLABICS WEST-CREE MWI" #x14AF)
+    ("CANADIAN SYLLABICS MWII" #x14B0)
+    ("CANADIAN SYLLABICS WEST-CREE MWII" #x14B1)
+    ("CANADIAN SYLLABICS MWO" #x14B2)
+    ("CANADIAN SYLLABICS WEST-CREE MWO" #x14B3)
+    ("CANADIAN SYLLABICS MWOO" #x14B4)
+    ("CANADIAN SYLLABICS WEST-CREE MWOO" #x14B5)
+    ("CANADIAN SYLLABICS MWA" #x14B6)
+    ("CANADIAN SYLLABICS WEST-CREE MWA" #x14B7)
+    ("CANADIAN SYLLABICS MWAA" #x14B8)
+    ("CANADIAN SYLLABICS WEST-CREE MWAA" #x14B9)
+    ("CANADIAN SYLLABICS NASKAPI MWAA" #x14BA)
+    ("CANADIAN SYLLABICS M" #x14BB)
+    ("CANADIAN SYLLABICS WEST-CREE M" #x14BC)
+    ("CANADIAN SYLLABICS MH" #x14BD)
+    ("CANADIAN SYLLABICS ATHAPASCAN M" #x14BE)
+    ("CANADIAN SYLLABICS SAYISI M" #x14BF)
+    ("CANADIAN SYLLABICS NE" #x14C0)
+    ("CANADIAN SYLLABICS NAAI" #x14C1)
+    ("CANADIAN SYLLABICS NI" #x14C2)
+    ("CANADIAN SYLLABICS NII" #x14C3)
+    ("CANADIAN SYLLABICS NO" #x14C4)
+    ("CANADIAN SYLLABICS NOO" #x14C5)
+    ("CANADIAN SYLLABICS Y-CREE NOO" #x14C6)
+    ("CANADIAN SYLLABICS NA" #x14C7)
+    ("CANADIAN SYLLABICS NAA" #x14C8)
+    ("CANADIAN SYLLABICS NWE" #x14C9)
+    ("CANADIAN SYLLABICS WEST-CREE NWE" #x14CA)
+    ("CANADIAN SYLLABICS NWA" #x14CB)
+    ("CANADIAN SYLLABICS WEST-CREE NWA" #x14CC)
+    ("CANADIAN SYLLABICS NWAA" #x14CD)
+    ("CANADIAN SYLLABICS WEST-CREE NWAA" #x14CE)
+    ("CANADIAN SYLLABICS NASKAPI NWAA" #x14CF)
+    ("CANADIAN SYLLABICS N" #x14D0)
+    ("CANADIAN SYLLABICS CARRIER NG" #x14D1)
+    ("CANADIAN SYLLABICS NH" #x14D2)
+    ("CANADIAN SYLLABICS LE" #x14D3)
+    ("CANADIAN SYLLABICS LAAI" #x14D4)
+    ("CANADIAN SYLLABICS LI" #x14D5)
+    ("CANADIAN SYLLABICS LII" #x14D6)
+    ("CANADIAN SYLLABICS LO" #x14D7)
+    ("CANADIAN SYLLABICS LOO" #x14D8)
+    ("CANADIAN SYLLABICS Y-CREE LOO" #x14D9)
+    ("CANADIAN SYLLABICS LA" #x14DA)
+    ("CANADIAN SYLLABICS LAA" #x14DB)
+    ("CANADIAN SYLLABICS LWE" #x14DC)
+    ("CANADIAN SYLLABICS WEST-CREE LWE" #x14DD)
+    ("CANADIAN SYLLABICS LWI" #x14DE)
+    ("CANADIAN SYLLABICS WEST-CREE LWI" #x14DF)
+    ("CANADIAN SYLLABICS LWII" #x14E0)
+    ("CANADIAN SYLLABICS WEST-CREE LWII" #x14E1)
+    ("CANADIAN SYLLABICS LWO" #x14E2)
+    ("CANADIAN SYLLABICS WEST-CREE LWO" #x14E3)
+    ("CANADIAN SYLLABICS LWOO" #x14E4)
+    ("CANADIAN SYLLABICS WEST-CREE LWOO" #x14E5)
+    ("CANADIAN SYLLABICS LWA" #x14E6)
+    ("CANADIAN SYLLABICS WEST-CREE LWA" #x14E7)
+    ("CANADIAN SYLLABICS LWAA" #x14E8)
+    ("CANADIAN SYLLABICS WEST-CREE LWAA" #x14E9)
+    ("CANADIAN SYLLABICS L" #x14EA)
+    ("CANADIAN SYLLABICS WEST-CREE L" #x14EB)
+    ("CANADIAN SYLLABICS MEDIAL L" #x14EC)
+    ("CANADIAN SYLLABICS SE" #x14ED)
+    ("CANADIAN SYLLABICS SAAI" #x14EE)
+    ("CANADIAN SYLLABICS SI" #x14EF)
+    ("CANADIAN SYLLABICS SII" #x14F0)
+    ("CANADIAN SYLLABICS SO" #x14F1)
+    ("CANADIAN SYLLABICS SOO" #x14F2)
+    ("CANADIAN SYLLABICS Y-CREE SOO" #x14F3)
+    ("CANADIAN SYLLABICS SA" #x14F4)
+    ("CANADIAN SYLLABICS SAA" #x14F5)
+    ("CANADIAN SYLLABICS SWE" #x14F6)
+    ("CANADIAN SYLLABICS WEST-CREE SWE" #x14F7)
+    ("CANADIAN SYLLABICS SWI" #x14F8)
+    ("CANADIAN SYLLABICS WEST-CREE SWI" #x14F9)
+    ("CANADIAN SYLLABICS SWII" #x14FA)
+    ("CANADIAN SYLLABICS WEST-CREE SWII" #x14FB)
+    ("CANADIAN SYLLABICS SWO" #x14FC)
+    ("CANADIAN SYLLABICS WEST-CREE SWO" #x14FD)
+    ("CANADIAN SYLLABICS SWOO" #x14FE)
+    ("CANADIAN SYLLABICS WEST-CREE SWOO" #x14FF)
+    ("CANADIAN SYLLABICS SWA" #x1500)
+    ("CANADIAN SYLLABICS WEST-CREE SWA" #x1501)
+    ("CANADIAN SYLLABICS SWAA" #x1502)
+    ("CANADIAN SYLLABICS WEST-CREE SWAA" #x1503)
+    ("CANADIAN SYLLABICS NASKAPI SWAA" #x1504)
+    ("CANADIAN SYLLABICS S" #x1505)
+    ("CANADIAN SYLLABICS ATHAPASCAN S" #x1506)
+    ("CANADIAN SYLLABICS SW" #x1507)
+    ("CANADIAN SYLLABICS BLACKFOOT S" #x1508)
+    ("CANADIAN SYLLABICS MOOSE-CREE SK" #x1509)
+    ("CANADIAN SYLLABICS NASKAPI SKW" #x150A)
+    ("CANADIAN SYLLABICS NASKAPI S-W" #x150B)
+    ("CANADIAN SYLLABICS NASKAPI SPWA" #x150C)
+    ("CANADIAN SYLLABICS NASKAPI STWA" #x150D)
+    ("CANADIAN SYLLABICS NASKAPI SKWA" #x150E)
+    ("CANADIAN SYLLABICS NASKAPI SCWA" #x150F)
+    ("CANADIAN SYLLABICS SHE" #x1510)
+    ("CANADIAN SYLLABICS SHI" #x1511)
+    ("CANADIAN SYLLABICS SHII" #x1512)
+    ("CANADIAN SYLLABICS SHO" #x1513)
+    ("CANADIAN SYLLABICS SHOO" #x1514)
+    ("CANADIAN SYLLABICS SHA" #x1515)
+    ("CANADIAN SYLLABICS SHAA" #x1516)
+    ("CANADIAN SYLLABICS SHWE" #x1517)
+    ("CANADIAN SYLLABICS WEST-CREE SHWE" #x1518)
+    ("CANADIAN SYLLABICS SHWI" #x1519)
+    ("CANADIAN SYLLABICS WEST-CREE SHWI" #x151A)
+    ("CANADIAN SYLLABICS SHWII" #x151B)
+    ("CANADIAN SYLLABICS WEST-CREE SHWII" #x151C)
+    ("CANADIAN SYLLABICS SHWO" #x151D)
+    ("CANADIAN SYLLABICS WEST-CREE SHWO" #x151E)
+    ("CANADIAN SYLLABICS SHWOO" #x151F)
+    ("CANADIAN SYLLABICS WEST-CREE SHWOO" #x1520)
+    ("CANADIAN SYLLABICS SHWA" #x1521)
+    ("CANADIAN SYLLABICS WEST-CREE SHWA" #x1522)
+    ("CANADIAN SYLLABICS SHWAA" #x1523)
+    ("CANADIAN SYLLABICS WEST-CREE SHWAA" #x1524)
+    ("CANADIAN SYLLABICS SH" #x1525)
+    ("CANADIAN SYLLABICS YE" #x1526)
+    ("CANADIAN SYLLABICS YAAI" #x1527)
+    ("CANADIAN SYLLABICS YI" #x1528)
+    ("CANADIAN SYLLABICS YII" #x1529)
+    ("CANADIAN SYLLABICS YO" #x152A)
+    ("CANADIAN SYLLABICS YOO" #x152B)
+    ("CANADIAN SYLLABICS Y-CREE YOO" #x152C)
+    ("CANADIAN SYLLABICS YA" #x152D)
+    ("CANADIAN SYLLABICS YAA" #x152E)
+    ("CANADIAN SYLLABICS YWE" #x152F)
+    ("CANADIAN SYLLABICS WEST-CREE YWE" #x1530)
+    ("CANADIAN SYLLABICS YWI" #x1531)
+    ("CANADIAN SYLLABICS WEST-CREE YWI" #x1532)
+    ("CANADIAN SYLLABICS YWII" #x1533)
+    ("CANADIAN SYLLABICS WEST-CREE YWII" #x1534)
+    ("CANADIAN SYLLABICS YWO" #x1535)
+    ("CANADIAN SYLLABICS WEST-CREE YWO" #x1536)
+    ("CANADIAN SYLLABICS YWOO" #x1537)
+    ("CANADIAN SYLLABICS WEST-CREE YWOO" #x1538)
+    ("CANADIAN SYLLABICS YWA" #x1539)
+    ("CANADIAN SYLLABICS WEST-CREE YWA" #x153A)
+    ("CANADIAN SYLLABICS YWAA" #x153B)
+    ("CANADIAN SYLLABICS WEST-CREE YWAA" #x153C)
+    ("CANADIAN SYLLABICS NASKAPI YWAA" #x153D)
+    ("CANADIAN SYLLABICS Y" #x153E)
+    ("CANADIAN SYLLABICS BIBLE-CREE Y" #x153F)
+    ("CANADIAN SYLLABICS WEST-CREE Y" #x1540)
+    ("CANADIAN SYLLABICS SAYISI YI" #x1541)
+    ("CANADIAN SYLLABICS RE" #x1542)
+    ("CANADIAN SYLLABICS R-CREE RE" #x1543)
+    ("CANADIAN SYLLABICS WEST-CREE LE" #x1544)
+    ("CANADIAN SYLLABICS RAAI" #x1545)
+    ("CANADIAN SYLLABICS RI" #x1546)
+    ("CANADIAN SYLLABICS RII" #x1547)
+    ("CANADIAN SYLLABICS RO" #x1548)
+    ("CANADIAN SYLLABICS ROO" #x1549)
+    ("CANADIAN SYLLABICS WEST-CREE LO" #x154A)
+    ("CANADIAN SYLLABICS RA" #x154B)
+    ("CANADIAN SYLLABICS RAA" #x154C)
+    ("CANADIAN SYLLABICS WEST-CREE LA" #x154D)
+    ("CANADIAN SYLLABICS RWAA" #x154E)
+    ("CANADIAN SYLLABICS WEST-CREE RWAA" #x154F)
+    ("CANADIAN SYLLABICS R" #x1550)
+    ("CANADIAN SYLLABICS WEST-CREE R" #x1551)
+    ("CANADIAN SYLLABICS MEDIAL R" #x1552)
+    ("CANADIAN SYLLABICS FE" #x1553)
+    ("CANADIAN SYLLABICS FAAI" #x1554)
+    ("CANADIAN SYLLABICS FI" #x1555)
+    ("CANADIAN SYLLABICS FII" #x1556)
+    ("CANADIAN SYLLABICS FO" #x1557)
+    ("CANADIAN SYLLABICS FOO" #x1558)
+    ("CANADIAN SYLLABICS FA" #x1559)
+    ("CANADIAN SYLLABICS FAA" #x155A)
+    ("CANADIAN SYLLABICS FWAA" #x155B)
+    ("CANADIAN SYLLABICS WEST-CREE FWAA" #x155C)
+    ("CANADIAN SYLLABICS F" #x155D)
+    ("CANADIAN SYLLABICS THE" #x155E)
+    ("CANADIAN SYLLABICS N-CREE THE" #x155F)
+    ("CANADIAN SYLLABICS THI" #x1560)
+    ("CANADIAN SYLLABICS N-CREE THI" #x1561)
+    ("CANADIAN SYLLABICS THII" #x1562)
+    ("CANADIAN SYLLABICS N-CREE THII" #x1563)
+    ("CANADIAN SYLLABICS THO" #x1564)
+    ("CANADIAN SYLLABICS THOO" #x1565)
+    ("CANADIAN SYLLABICS THA" #x1566)
+    ("CANADIAN SYLLABICS THAA" #x1567)
+    ("CANADIAN SYLLABICS THWAA" #x1568)
+    ("CANADIAN SYLLABICS WEST-CREE THWAA" #x1569)
+    ("CANADIAN SYLLABICS TH" #x156A)
+    ("CANADIAN SYLLABICS TTHE" #x156B)
+    ("CANADIAN SYLLABICS TTHI" #x156C)
+    ("CANADIAN SYLLABICS TTHO" #x156D)
+    ("CANADIAN SYLLABICS TTHA" #x156E)
+    ("CANADIAN SYLLABICS TTH" #x156F)
+    ("CANADIAN SYLLABICS TYE" #x1570)
+    ("CANADIAN SYLLABICS TYI" #x1571)
+    ("CANADIAN SYLLABICS TYO" #x1572)
+    ("CANADIAN SYLLABICS TYA" #x1573)
+    ("CANADIAN SYLLABICS NUNAVIK HE" #x1574)
+    ("CANADIAN SYLLABICS NUNAVIK HI" #x1575)
+    ("CANADIAN SYLLABICS NUNAVIK HII" #x1576)
+    ("CANADIAN SYLLABICS NUNAVIK HO" #x1577)
+    ("CANADIAN SYLLABICS NUNAVIK HOO" #x1578)
+    ("CANADIAN SYLLABICS NUNAVIK HA" #x1579)
+    ("CANADIAN SYLLABICS NUNAVIK HAA" #x157A)
+    ("CANADIAN SYLLABICS NUNAVIK H" #x157B)
+    ("CANADIAN SYLLABICS NUNAVUT H" #x157C)
+    ("CANADIAN SYLLABICS HK" #x157D)
+    ("CANADIAN SYLLABICS QAAI" #x157E)
+    ("CANADIAN SYLLABICS QI" #x157F)
+    ("CANADIAN SYLLABICS QII" #x1580)
+    ("CANADIAN SYLLABICS QO" #x1581)
+    ("CANADIAN SYLLABICS QOO" #x1582)
+    ("CANADIAN SYLLABICS QA" #x1583)
+    ("CANADIAN SYLLABICS QAA" #x1584)
+    ("CANADIAN SYLLABICS Q" #x1585)
+    ("CANADIAN SYLLABICS TLHE" #x1586)
+    ("CANADIAN SYLLABICS TLHI" #x1587)
+    ("CANADIAN SYLLABICS TLHO" #x1588)
+    ("CANADIAN SYLLABICS TLHA" #x1589)
+    ("CANADIAN SYLLABICS WEST-CREE RE" #x158A)
+    ("CANADIAN SYLLABICS WEST-CREE RI" #x158B)
+    ("CANADIAN SYLLABICS WEST-CREE RO" #x158C)
+    ("CANADIAN SYLLABICS WEST-CREE RA" #x158D)
+    ("CANADIAN SYLLABICS NGAAI" #x158E)
+    ("CANADIAN SYLLABICS NGI" #x158F)
+    ("CANADIAN SYLLABICS NGII" #x1590)
+    ("CANADIAN SYLLABICS NGO" #x1591)
+    ("CANADIAN SYLLABICS NGOO" #x1592)
+    ("CANADIAN SYLLABICS NGA" #x1593)
+    ("CANADIAN SYLLABICS NGAA" #x1594)
+    ("CANADIAN SYLLABICS NG" #x1595)
+    ("CANADIAN SYLLABICS NNG" #x1596)
+    ("CANADIAN SYLLABICS SAYISI SHE" #x1597)
+    ("CANADIAN SYLLABICS SAYISI SHI" #x1598)
+    ("CANADIAN SYLLABICS SAYISI SHO" #x1599)
+    ("CANADIAN SYLLABICS SAYISI SHA" #x159A)
+    ("CANADIAN SYLLABICS WOODS-CREE THE" #x159B)
+    ("CANADIAN SYLLABICS WOODS-CREE THI" #x159C)
+    ("CANADIAN SYLLABICS WOODS-CREE THO" #x159D)
+    ("CANADIAN SYLLABICS WOODS-CREE THA" #x159E)
+    ("CANADIAN SYLLABICS WOODS-CREE TH" #x159F)
+    ("CANADIAN SYLLABICS LHI" #x15A0)
+    ("CANADIAN SYLLABICS LHII" #x15A1)
+    ("CANADIAN SYLLABICS LHO" #x15A2)
+    ("CANADIAN SYLLABICS LHOO" #x15A3)
+    ("CANADIAN SYLLABICS LHA" #x15A4)
+    ("CANADIAN SYLLABICS LHAA" #x15A5)
+    ("CANADIAN SYLLABICS LH" #x15A6)
+    ("CANADIAN SYLLABICS TH-CREE THE" #x15A7)
+    ("CANADIAN SYLLABICS TH-CREE THI" #x15A8)
+    ("CANADIAN SYLLABICS TH-CREE THII" #x15A9)
+    ("CANADIAN SYLLABICS TH-CREE THO" #x15AA)
+    ("CANADIAN SYLLABICS TH-CREE THOO" #x15AB)
+    ("CANADIAN SYLLABICS TH-CREE THA" #x15AC)
+    ("CANADIAN SYLLABICS TH-CREE THAA" #x15AD)
+    ("CANADIAN SYLLABICS TH-CREE TH" #x15AE)
+    ("CANADIAN SYLLABICS AIVILIK B" #x15AF)
+    ("CANADIAN SYLLABICS BLACKFOOT E" #x15B0)
+    ("CANADIAN SYLLABICS BLACKFOOT I" #x15B1)
+    ("CANADIAN SYLLABICS BLACKFOOT O" #x15B2)
+    ("CANADIAN SYLLABICS BLACKFOOT A" #x15B3)
+    ("CANADIAN SYLLABICS BLACKFOOT WE" #x15B4)
+    ("CANADIAN SYLLABICS BLACKFOOT WI" #x15B5)
+    ("CANADIAN SYLLABICS BLACKFOOT WO" #x15B6)
+    ("CANADIAN SYLLABICS BLACKFOOT WA" #x15B7)
+    ("CANADIAN SYLLABICS BLACKFOOT NE" #x15B8)
+    ("CANADIAN SYLLABICS BLACKFOOT NI" #x15B9)
+    ("CANADIAN SYLLABICS BLACKFOOT NO" #x15BA)
+    ("CANADIAN SYLLABICS BLACKFOOT NA" #x15BB)
+    ("CANADIAN SYLLABICS BLACKFOOT KE" #x15BC)
+    ("CANADIAN SYLLABICS BLACKFOOT KI" #x15BD)
+    ("CANADIAN SYLLABICS BLACKFOOT KO" #x15BE)
+    ("CANADIAN SYLLABICS BLACKFOOT KA" #x15BF)
+    ("CANADIAN SYLLABICS SAYISI HE" #x15C0)
+    ("CANADIAN SYLLABICS SAYISI HI" #x15C1)
+    ("CANADIAN SYLLABICS SAYISI HO" #x15C2)
+    ("CANADIAN SYLLABICS SAYISI HA" #x15C3)
+    ("CANADIAN SYLLABICS CARRIER GHU" #x15C4)
+    ("CANADIAN SYLLABICS CARRIER GHO" #x15C5)
+    ("CANADIAN SYLLABICS CARRIER GHE" #x15C6)
+    ("CANADIAN SYLLABICS CARRIER GHEE" #x15C7)
+    ("CANADIAN SYLLABICS CARRIER GHI" #x15C8)
+    ("CANADIAN SYLLABICS CARRIER GHA" #x15C9)
+    ("CANADIAN SYLLABICS CARRIER RU" #x15CA)
+    ("CANADIAN SYLLABICS CARRIER RO" #x15CB)
+    ("CANADIAN SYLLABICS CARRIER RE" #x15CC)
+    ("CANADIAN SYLLABICS CARRIER REE" #x15CD)
+    ("CANADIAN SYLLABICS CARRIER RI" #x15CE)
+    ("CANADIAN SYLLABICS CARRIER RA" #x15CF)
+    ("CANADIAN SYLLABICS CARRIER WU" #x15D0)
+    ("CANADIAN SYLLABICS CARRIER WO" #x15D1)
+    ("CANADIAN SYLLABICS CARRIER WE" #x15D2)
+    ("CANADIAN SYLLABICS CARRIER WEE" #x15D3)
+    ("CANADIAN SYLLABICS CARRIER WI" #x15D4)
+    ("CANADIAN SYLLABICS CARRIER WA" #x15D5)
+    ("CANADIAN SYLLABICS CARRIER HWU" #x15D6)
+    ("CANADIAN SYLLABICS CARRIER HWO" #x15D7)
+    ("CANADIAN SYLLABICS CARRIER HWE" #x15D8)
+    ("CANADIAN SYLLABICS CARRIER HWEE" #x15D9)
+    ("CANADIAN SYLLABICS CARRIER HWI" #x15DA)
+    ("CANADIAN SYLLABICS CARRIER HWA" #x15DB)
+    ("CANADIAN SYLLABICS CARRIER THU" #x15DC)
+    ("CANADIAN SYLLABICS CARRIER THO" #x15DD)
+    ("CANADIAN SYLLABICS CARRIER THE" #x15DE)
+    ("CANADIAN SYLLABICS CARRIER THEE" #x15DF)
+    ("CANADIAN SYLLABICS CARRIER THI" #x15E0)
+    ("CANADIAN SYLLABICS CARRIER THA" #x15E1)
+    ("CANADIAN SYLLABICS CARRIER TTU" #x15E2)
+    ("CANADIAN SYLLABICS CARRIER TTO" #x15E3)
+    ("CANADIAN SYLLABICS CARRIER TTE" #x15E4)
+    ("CANADIAN SYLLABICS CARRIER TTEE" #x15E5)
+    ("CANADIAN SYLLABICS CARRIER TTI" #x15E6)
+    ("CANADIAN SYLLABICS CARRIER TTA" #x15E7)
+    ("CANADIAN SYLLABICS CARRIER PU" #x15E8)
+    ("CANADIAN SYLLABICS CARRIER PO" #x15E9)
+    ("CANADIAN SYLLABICS CARRIER PE" #x15EA)
+    ("CANADIAN SYLLABICS CARRIER PEE" #x15EB)
+    ("CANADIAN SYLLABICS CARRIER PI" #x15EC)
+    ("CANADIAN SYLLABICS CARRIER PA" #x15ED)
+    ("CANADIAN SYLLABICS CARRIER P" #x15EE)
+    ("CANADIAN SYLLABICS CARRIER GU" #x15EF)
+    ("CANADIAN SYLLABICS CARRIER GO" #x15F0)
+    ("CANADIAN SYLLABICS CARRIER GE" #x15F1)
+    ("CANADIAN SYLLABICS CARRIER GEE" #x15F2)
+    ("CANADIAN SYLLABICS CARRIER GI" #x15F3)
+    ("CANADIAN SYLLABICS CARRIER GA" #x15F4)
+    ("CANADIAN SYLLABICS CARRIER KHU" #x15F5)
+    ("CANADIAN SYLLABICS CARRIER KHO" #x15F6)
+    ("CANADIAN SYLLABICS CARRIER KHE" #x15F7)
+    ("CANADIAN SYLLABICS CARRIER KHEE" #x15F8)
+    ("CANADIAN SYLLABICS CARRIER KHI" #x15F9)
+    ("CANADIAN SYLLABICS CARRIER KHA" #x15FA)
+    ("CANADIAN SYLLABICS CARRIER KKU" #x15FB)
+    ("CANADIAN SYLLABICS CARRIER KKO" #x15FC)
+    ("CANADIAN SYLLABICS CARRIER KKE" #x15FD)
+    ("CANADIAN SYLLABICS CARRIER KKEE" #x15FE)
+    ("CANADIAN SYLLABICS CARRIER KKI" #x15FF)
+    ("CANADIAN SYLLABICS CARRIER KKA" #x1600)
+    ("CANADIAN SYLLABICS CARRIER KK" #x1601)
+    ("CANADIAN SYLLABICS CARRIER NU" #x1602)
+    ("CANADIAN SYLLABICS CARRIER NO" #x1603)
+    ("CANADIAN SYLLABICS CARRIER NE" #x1604)
+    ("CANADIAN SYLLABICS CARRIER NEE" #x1605)
+    ("CANADIAN SYLLABICS CARRIER NI" #x1606)
+    ("CANADIAN SYLLABICS CARRIER NA" #x1607)
+    ("CANADIAN SYLLABICS CARRIER MU" #x1608)
+    ("CANADIAN SYLLABICS CARRIER MO" #x1609)
+    ("CANADIAN SYLLABICS CARRIER ME" #x160A)
+    ("CANADIAN SYLLABICS CARRIER MEE" #x160B)
+    ("CANADIAN SYLLABICS CARRIER MI" #x160C)
+    ("CANADIAN SYLLABICS CARRIER MA" #x160D)
+    ("CANADIAN SYLLABICS CARRIER YU" #x160E)
+    ("CANADIAN SYLLABICS CARRIER YO" #x160F)
+    ("CANADIAN SYLLABICS CARRIER YE" #x1610)
+    ("CANADIAN SYLLABICS CARRIER YEE" #x1611)
+    ("CANADIAN SYLLABICS CARRIER YI" #x1612)
+    ("CANADIAN SYLLABICS CARRIER YA" #x1613)
+    ("CANADIAN SYLLABICS CARRIER JU" #x1614)
+    ("CANADIAN SYLLABICS SAYISI JU" #x1615)
+    ("CANADIAN SYLLABICS CARRIER JO" #x1616)
+    ("CANADIAN SYLLABICS CARRIER JE" #x1617)
+    ("CANADIAN SYLLABICS CARRIER JEE" #x1618)
+    ("CANADIAN SYLLABICS CARRIER JI" #x1619)
+    ("CANADIAN SYLLABICS SAYISI JI" #x161A)
+    ("CANADIAN SYLLABICS CARRIER JA" #x161B)
+    ("CANADIAN SYLLABICS CARRIER JJU" #x161C)
+    ("CANADIAN SYLLABICS CARRIER JJO" #x161D)
+    ("CANADIAN SYLLABICS CARRIER JJE" #x161E)
+    ("CANADIAN SYLLABICS CARRIER JJEE" #x161F)
+    ("CANADIAN SYLLABICS CARRIER JJI" #x1620)
+    ("CANADIAN SYLLABICS CARRIER JJA" #x1621)
+    ("CANADIAN SYLLABICS CARRIER LU" #x1622)
+    ("CANADIAN SYLLABICS CARRIER LO" #x1623)
+    ("CANADIAN SYLLABICS CARRIER LE" #x1624)
+    ("CANADIAN SYLLABICS CARRIER LEE" #x1625)
+    ("CANADIAN SYLLABICS CARRIER LI" #x1626)
+    ("CANADIAN SYLLABICS CARRIER LA" #x1627)
+    ("CANADIAN SYLLABICS CARRIER DLU" #x1628)
+    ("CANADIAN SYLLABICS CARRIER DLO" #x1629)
+    ("CANADIAN SYLLABICS CARRIER DLE" #x162A)
+    ("CANADIAN SYLLABICS CARRIER DLEE" #x162B)
+    ("CANADIAN SYLLABICS CARRIER DLI" #x162C)
+    ("CANADIAN SYLLABICS CARRIER DLA" #x162D)
+    ("CANADIAN SYLLABICS CARRIER LHU" #x162E)
+    ("CANADIAN SYLLABICS CARRIER LHO" #x162F)
+    ("CANADIAN SYLLABICS CARRIER LHE" #x1630)
+    ("CANADIAN SYLLABICS CARRIER LHEE" #x1631)
+    ("CANADIAN SYLLABICS CARRIER LHI" #x1632)
+    ("CANADIAN SYLLABICS CARRIER LHA" #x1633)
+    ("CANADIAN SYLLABICS CARRIER TLHU" #x1634)
+    ("CANADIAN SYLLABICS CARRIER TLHO" #x1635)
+    ("CANADIAN SYLLABICS CARRIER TLHE" #x1636)
+    ("CANADIAN SYLLABICS CARRIER TLHEE" #x1637)
+    ("CANADIAN SYLLABICS CARRIER TLHI" #x1638)
+    ("CANADIAN SYLLABICS CARRIER TLHA" #x1639)
+    ("CANADIAN SYLLABICS CARRIER TLU" #x163A)
+    ("CANADIAN SYLLABICS CARRIER TLO" #x163B)
+    ("CANADIAN SYLLABICS CARRIER TLE" #x163C)
+    ("CANADIAN SYLLABICS CARRIER TLEE" #x163D)
+    ("CANADIAN SYLLABICS CARRIER TLI" #x163E)
+    ("CANADIAN SYLLABICS CARRIER TLA" #x163F)
+    ("CANADIAN SYLLABICS CARRIER ZU" #x1640)
+    ("CANADIAN SYLLABICS CARRIER ZO" #x1641)
+    ("CANADIAN SYLLABICS CARRIER ZE" #x1642)
+    ("CANADIAN SYLLABICS CARRIER ZEE" #x1643)
+    ("CANADIAN SYLLABICS CARRIER ZI" #x1644)
+    ("CANADIAN SYLLABICS CARRIER ZA" #x1645)
+    ("CANADIAN SYLLABICS CARRIER Z" #x1646)
+    ("CANADIAN SYLLABICS CARRIER INITIAL Z" #x1647)
+    ("CANADIAN SYLLABICS CARRIER DZU" #x1648)
+    ("CANADIAN SYLLABICS CARRIER DZO" #x1649)
+    ("CANADIAN SYLLABICS CARRIER DZE" #x164A)
+    ("CANADIAN SYLLABICS CARRIER DZEE" #x164B)
+    ("CANADIAN SYLLABICS CARRIER DZI" #x164C)
+    ("CANADIAN SYLLABICS CARRIER DZA" #x164D)
+    ("CANADIAN SYLLABICS CARRIER SU" #x164E)
+    ("CANADIAN SYLLABICS CARRIER SO" #x164F)
+    ("CANADIAN SYLLABICS CARRIER SE" #x1650)
+    ("CANADIAN SYLLABICS CARRIER SEE" #x1651)
+    ("CANADIAN SYLLABICS CARRIER SI" #x1652)
+    ("CANADIAN SYLLABICS CARRIER SA" #x1653)
+    ("CANADIAN SYLLABICS CARRIER SHU" #x1654)
+    ("CANADIAN SYLLABICS CARRIER SHO" #x1655)
+    ("CANADIAN SYLLABICS CARRIER SHE" #x1656)
+    ("CANADIAN SYLLABICS CARRIER SHEE" #x1657)
+    ("CANADIAN SYLLABICS CARRIER SHI" #x1658)
+    ("CANADIAN SYLLABICS CARRIER SHA" #x1659)
+    ("CANADIAN SYLLABICS CARRIER SH" #x165A)
+    ("CANADIAN SYLLABICS CARRIER TSU" #x165B)
+    ("CANADIAN SYLLABICS CARRIER TSO" #x165C)
+    ("CANADIAN SYLLABICS CARRIER TSE" #x165D)
+    ("CANADIAN SYLLABICS CARRIER TSEE" #x165E)
+    ("CANADIAN SYLLABICS CARRIER TSI" #x165F)
+    ("CANADIAN SYLLABICS CARRIER TSA" #x1660)
+    ("CANADIAN SYLLABICS CARRIER CHU" #x1661)
+    ("CANADIAN SYLLABICS CARRIER CHO" #x1662)
+    ("CANADIAN SYLLABICS CARRIER CHE" #x1663)
+    ("CANADIAN SYLLABICS CARRIER CHEE" #x1664)
+    ("CANADIAN SYLLABICS CARRIER CHI" #x1665)
+    ("CANADIAN SYLLABICS CARRIER CHA" #x1666)
+    ("CANADIAN SYLLABICS CARRIER TTSU" #x1667)
+    ("CANADIAN SYLLABICS CARRIER TTSO" #x1668)
+    ("CANADIAN SYLLABICS CARRIER TTSE" #x1669)
+    ("CANADIAN SYLLABICS CARRIER TTSEE" #x166A)
+    ("CANADIAN SYLLABICS CARRIER TTSI" #x166B)
+    ("CANADIAN SYLLABICS CARRIER TTSA" #x166C)
+    ("CANADIAN SYLLABICS CHI SIGN" #x166D)
+    ("CANADIAN SYLLABICS FULL STOP" #x166E)
+    ("CANADIAN SYLLABICS QAI" #x166F)
+    ("CANADIAN SYLLABICS NGAI" #x1670)
+    ("CANADIAN SYLLABICS NNGI" #x1671)
+    ("CANADIAN SYLLABICS NNGII" #x1672)
+    ("CANADIAN SYLLABICS NNGO" #x1673)
+    ("CANADIAN SYLLABICS NNGOO" #x1674)
+    ("CANADIAN SYLLABICS NNGA" #x1675)
+    ("CANADIAN SYLLABICS NNGAA" #x1676)
+    ))
diff --git a/lisp/nxml/char-name/unicode/01680-0169F.el b/lisp/nxml/char-name/unicode/01680-0169F.el
new file mode 100644
index 00000000000..827b70e6b00
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/01680-0169F.el
@@ -0,0 +1,31 @@
+(nxml-define-char-name-set 'ogham
+  '(("OGHAM SPACE MARK" #x1680)
+    ("OGHAM LETTER BEITH" #x1681)
+    ("OGHAM LETTER LUIS" #x1682)
+    ("OGHAM LETTER FEARN" #x1683)
+    ("OGHAM LETTER SAIL" #x1684)
+    ("OGHAM LETTER NION" #x1685)
+    ("OGHAM LETTER UATH" #x1686)
+    ("OGHAM LETTER DAIR" #x1687)
+    ("OGHAM LETTER TINNE" #x1688)
+    ("OGHAM LETTER COLL" #x1689)
+    ("OGHAM LETTER CEIRT" #x168A)
+    ("OGHAM LETTER MUIN" #x168B)
+    ("OGHAM LETTER GORT" #x168C)
+    ("OGHAM LETTER NGEADAL" #x168D)
+    ("OGHAM LETTER STRAIF" #x168E)
+    ("OGHAM LETTER RUIS" #x168F)
+    ("OGHAM LETTER AILM" #x1690)
+    ("OGHAM LETTER ONN" #x1691)
+    ("OGHAM LETTER UR" #x1692)
+    ("OGHAM LETTER EADHADH" #x1693)
+    ("OGHAM LETTER IODHADH" #x1694)
+    ("OGHAM LETTER EABHADH" #x1695)
+    ("OGHAM LETTER OR" #x1696)
+    ("OGHAM LETTER UILLEANN" #x1697)
+    ("OGHAM LETTER IFIN" #x1698)
+    ("OGHAM LETTER EAMHANCHOLL" #x1699)
+    ("OGHAM LETTER PEITH" #x169A)
+    ("OGHAM FEATHER MARK" #x169B)
+    ("OGHAM REVERSED FEATHER MARK" #x169C)
+    ))
diff --git a/lisp/nxml/char-name/unicode/016A0-016FF.el b/lisp/nxml/char-name/unicode/016A0-016FF.el
new file mode 100644
index 00000000000..ce67a4069e5
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/016A0-016FF.el
@@ -0,0 +1,83 @@
+(nxml-define-char-name-set 'runic
+  '(("RUNIC LETTER FEHU FEOH FE F" #x16A0)
+    ("RUNIC LETTER V" #x16A1)
+    ("RUNIC LETTER URUZ UR U" #x16A2)
+    ("RUNIC LETTER YR" #x16A3)
+    ("RUNIC LETTER Y" #x16A4)
+    ("RUNIC LETTER W" #x16A5)
+    ("RUNIC LETTER THURISAZ THURS THORN" #x16A6)
+    ("RUNIC LETTER ETH" #x16A7)
+    ("RUNIC LETTER ANSUZ A" #x16A8)
+    ("RUNIC LETTER OS O" #x16A9)
+    ("RUNIC LETTER AC A" #x16AA)
+    ("RUNIC LETTER AESC" #x16AB)
+    ("RUNIC LETTER LONG-BRANCH-OSS O" #x16AC)
+    ("RUNIC LETTER SHORT-TWIG-OSS O" #x16AD)
+    ("RUNIC LETTER O" #x16AE)
+    ("RUNIC LETTER OE" #x16AF)
+    ("RUNIC LETTER ON" #x16B0)
+    ("RUNIC LETTER RAIDO RAD REID R" #x16B1)
+    ("RUNIC LETTER KAUNA" #x16B2)
+    ("RUNIC LETTER CEN" #x16B3)
+    ("RUNIC LETTER KAUN K" #x16B4)
+    ("RUNIC LETTER G" #x16B5)
+    ("RUNIC LETTER ENG" #x16B6)
+    ("RUNIC LETTER GEBO GYFU G" #x16B7)
+    ("RUNIC LETTER GAR" #x16B8)
+    ("RUNIC LETTER WUNJO WYNN W" #x16B9)
+    ("RUNIC LETTER HAGLAZ H" #x16BA)
+    ("RUNIC LETTER HAEGL H" #x16BB)
+    ("RUNIC LETTER LONG-BRANCH-HAGALL H" #x16BC)
+    ("RUNIC LETTER SHORT-TWIG-HAGALL H" #x16BD)
+    ("RUNIC LETTER NAUDIZ NYD NAUD N" #x16BE)
+    ("RUNIC LETTER SHORT-TWIG-NAUD N" #x16BF)
+    ("RUNIC LETTER DOTTED-N" #x16C0)
+    ("RUNIC LETTER ISAZ IS ISS I" #x16C1)
+    ("RUNIC LETTER E" #x16C2)
+    ("RUNIC LETTER JERAN J" #x16C3)
+    ("RUNIC LETTER GER" #x16C4)
+    ("RUNIC LETTER LONG-BRANCH-AR AE" #x16C5)
+    ("RUNIC LETTER SHORT-TWIG-AR A" #x16C6)
+    ("RUNIC LETTER IWAZ EOH" #x16C7)
+    ("RUNIC LETTER PERTHO PEORTH P" #x16C8)
+    ("RUNIC LETTER ALGIZ EOLHX" #x16C9)
+    ("RUNIC LETTER SOWILO S" #x16CA)
+    ("RUNIC LETTER SIGEL LONG-BRANCH-SOL S" #x16CB)
+    ("RUNIC LETTER SHORT-TWIG-SOL S" #x16CC)
+    ("RUNIC LETTER C" #x16CD)
+    ("RUNIC LETTER Z" #x16CE)
+    ("RUNIC LETTER TIWAZ TIR TYR T" #x16CF)
+    ("RUNIC LETTER SHORT-TWIG-TYR T" #x16D0)
+    ("RUNIC LETTER D" #x16D1)
+    ("RUNIC LETTER BERKANAN BEORC BJARKAN B" #x16D2)
+    ("RUNIC LETTER SHORT-TWIG-BJARKAN B" #x16D3)
+    ("RUNIC LETTER DOTTED-P" #x16D4)
+    ("RUNIC LETTER OPEN-P" #x16D5)
+    ("RUNIC LETTER EHWAZ EH E" #x16D6)
+    ("RUNIC LETTER MANNAZ MAN M" #x16D7)
+    ("RUNIC LETTER LONG-BRANCH-MADR M" #x16D8)
+    ("RUNIC LETTER SHORT-TWIG-MADR M" #x16D9)
+    ("RUNIC LETTER LAUKAZ LAGU LOGR L" #x16DA)
+    ("RUNIC LETTER DOTTED-L" #x16DB)
+    ("RUNIC LETTER INGWAZ" #x16DC)
+    ("RUNIC LETTER ING" #x16DD)
+    ("RUNIC LETTER DAGAZ DAEG D" #x16DE)
+    ("RUNIC LETTER OTHALAN ETHEL O" #x16DF)
+    ("RUNIC LETTER EAR" #x16E0)
+    ("RUNIC LETTER IOR" #x16E1)
+    ("RUNIC LETTER CWEORTH" #x16E2)
+    ("RUNIC LETTER CALC" #x16E3)
+    ("RUNIC LETTER CEALC" #x16E4)
+    ("RUNIC LETTER STAN" #x16E5)
+    ("RUNIC LETTER LONG-BRANCH-YR" #x16E6)
+    ("RUNIC LETTER SHORT-TWIG-YR" #x16E7)
+    ("RUNIC LETTER ICELANDIC-YR" #x16E8)
+    ("RUNIC LETTER Q" #x16E9)
+    ("RUNIC LETTER X" #x16EA)
+    ("RUNIC SINGLE PUNCTUATION" #x16EB)
+    ("RUNIC MULTIPLE PUNCTUATION" #x16EC)
+    ("RUNIC CROSS PUNCTUATION" #x16ED)
+    ("RUNIC ARLAUG SYMBOL" #x16EE)
+    ("RUNIC TVIMADUR SYMBOL" #x16EF)
+    ("RUNIC BELGTHOR SYMBOL" #x16F0)
+    ))
diff --git a/lisp/nxml/char-name/unicode/01700-0171F.el b/lisp/nxml/char-name/unicode/01700-0171F.el
new file mode 100644
index 00000000000..b30500639b6
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/01700-0171F.el
@@ -0,0 +1,22 @@
+(nxml-define-char-name-set 'tagalog
+  '(("TAGALOG LETTER A" #x1700)
+    ("TAGALOG LETTER I" #x1701)
+    ("TAGALOG LETTER U" #x1702)
+    ("TAGALOG LETTER KA" #x1703)
+    ("TAGALOG LETTER GA" #x1704)
+    ("TAGALOG LETTER NGA" #x1705)
+    ("TAGALOG LETTER TA" #x1706)
+    ("TAGALOG LETTER DA" #x1707)
+    ("TAGALOG LETTER NA" #x1708)
+    ("TAGALOG LETTER PA" #x1709)
+    ("TAGALOG LETTER BA" #x170A)
+    ("TAGALOG LETTER MA" #x170B)
+    ("TAGALOG LETTER YA" #x170C)
+    ("TAGALOG LETTER LA" #x170E)
+    ("TAGALOG LETTER WA" #x170F)
+    ("TAGALOG LETTER SA" #x1710)
+    ("TAGALOG LETTER HA" #x1711)
+    ("TAGALOG VOWEL SIGN I" #x1712)
+    ("TAGALOG VOWEL SIGN U" #x1713)
+    ("TAGALOG SIGN VIRAMA" #x1714)
+    ))
diff --git a/lisp/nxml/char-name/unicode/01720-0173F.el b/lisp/nxml/char-name/unicode/01720-0173F.el
new file mode 100644
index 00000000000..09f61ea1b55
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/01720-0173F.el
@@ -0,0 +1,25 @@
+(nxml-define-char-name-set 'hanunoo
+  '(("HANUNOO LETTER A" #x1720)
+    ("HANUNOO LETTER I" #x1721)
+    ("HANUNOO LETTER U" #x1722)
+    ("HANUNOO LETTER KA" #x1723)
+    ("HANUNOO LETTER GA" #x1724)
+    ("HANUNOO LETTER NGA" #x1725)
+    ("HANUNOO LETTER TA" #x1726)
+    ("HANUNOO LETTER DA" #x1727)
+    ("HANUNOO LETTER NA" #x1728)
+    ("HANUNOO LETTER PA" #x1729)
+    ("HANUNOO LETTER BA" #x172A)
+    ("HANUNOO LETTER MA" #x172B)
+    ("HANUNOO LETTER YA" #x172C)
+    ("HANUNOO LETTER RA" #x172D)
+    ("HANUNOO LETTER LA" #x172E)
+    ("HANUNOO LETTER WA" #x172F)
+    ("HANUNOO LETTER SA" #x1730)
+    ("HANUNOO LETTER HA" #x1731)
+    ("HANUNOO VOWEL SIGN I" #x1732)
+    ("HANUNOO VOWEL SIGN U" #x1733)
+    ("HANUNOO SIGN PAMUDPOD" #x1734)
+    ("PHILIPPINE SINGLE PUNCTUATION" #x1735)
+    ("PHILIPPINE DOUBLE PUNCTUATION" #x1736)
+    ))
diff --git a/lisp/nxml/char-name/unicode/01740-0175F.el b/lisp/nxml/char-name/unicode/01740-0175F.el
new file mode 100644
index 00000000000..b507c90c268
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/01740-0175F.el
@@ -0,0 +1,22 @@
+(nxml-define-char-name-set 'buhid
+  '(("BUHID LETTER A" #x1740)
+    ("BUHID LETTER I" #x1741)
+    ("BUHID LETTER U" #x1742)
+    ("BUHID LETTER KA" #x1743)
+    ("BUHID LETTER GA" #x1744)
+    ("BUHID LETTER NGA" #x1745)
+    ("BUHID LETTER TA" #x1746)
+    ("BUHID LETTER DA" #x1747)
+    ("BUHID LETTER NA" #x1748)
+    ("BUHID LETTER PA" #x1749)
+    ("BUHID LETTER BA" #x174A)
+    ("BUHID LETTER MA" #x174B)
+    ("BUHID LETTER YA" #x174C)
+    ("BUHID LETTER RA" #x174D)
+    ("BUHID LETTER LA" #x174E)
+    ("BUHID LETTER WA" #x174F)
+    ("BUHID LETTER SA" #x1750)
+    ("BUHID LETTER HA" #x1751)
+    ("BUHID VOWEL SIGN I" #x1752)
+    ("BUHID VOWEL SIGN U" #x1753)
+    ))
diff --git a/lisp/nxml/char-name/unicode/01760-0177F.el b/lisp/nxml/char-name/unicode/01760-0177F.el
new file mode 100644
index 00000000000..e824c2bd434
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/01760-0177F.el
@@ -0,0 +1,20 @@
+(nxml-define-char-name-set 'tagbanwa
+  '(("TAGBANWA LETTER A" #x1760)
+    ("TAGBANWA LETTER I" #x1761)
+    ("TAGBANWA LETTER U" #x1762)
+    ("TAGBANWA LETTER KA" #x1763)
+    ("TAGBANWA LETTER GA" #x1764)
+    ("TAGBANWA LETTER NGA" #x1765)
+    ("TAGBANWA LETTER TA" #x1766)
+    ("TAGBANWA LETTER DA" #x1767)
+    ("TAGBANWA LETTER NA" #x1768)
+    ("TAGBANWA LETTER PA" #x1769)
+    ("TAGBANWA LETTER BA" #x176A)
+    ("TAGBANWA LETTER MA" #x176B)
+    ("TAGBANWA LETTER YA" #x176C)
+    ("TAGBANWA LETTER LA" #x176E)
+    ("TAGBANWA LETTER WA" #x176F)
+    ("TAGBANWA LETTER SA" #x1770)
+    ("TAGBANWA VOWEL SIGN I" #x1772)
+    ("TAGBANWA VOWEL SIGN U" #x1773)
+    ))
diff --git a/lisp/nxml/char-name/unicode/01780-017FF.el b/lisp/nxml/char-name/unicode/01780-017FF.el
new file mode 100644
index 00000000000..e9671c943ca
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/01780-017FF.el
@@ -0,0 +1,105 @@
+(nxml-define-char-name-set 'khmer
+  '(("KHMER LETTER KA" #x1780)
+    ("KHMER LETTER KHA" #x1781)
+    ("KHMER LETTER KO" #x1782)
+    ("KHMER LETTER KHO" #x1783)
+    ("KHMER LETTER NGO" #x1784)
+    ("KHMER LETTER CA" #x1785)
+    ("KHMER LETTER CHA" #x1786)
+    ("KHMER LETTER CO" #x1787)
+    ("KHMER LETTER CHO" #x1788)
+    ("KHMER LETTER NYO" #x1789)
+    ("KHMER LETTER DA" #x178A)
+    ("KHMER LETTER TTHA" #x178B)
+    ("KHMER LETTER DO" #x178C)
+    ("KHMER LETTER TTHO" #x178D)
+    ("KHMER LETTER NNO" #x178E)
+    ("KHMER LETTER TA" #x178F)
+    ("KHMER LETTER THA" #x1790)
+    ("KHMER LETTER TO" #x1791)
+    ("KHMER LETTER THO" #x1792)
+    ("KHMER LETTER NO" #x1793)
+    ("KHMER LETTER BA" #x1794)
+    ("KHMER LETTER PHA" #x1795)
+    ("KHMER LETTER PO" #x1796)
+    ("KHMER LETTER PHO" #x1797)
+    ("KHMER LETTER MO" #x1798)
+    ("KHMER LETTER YO" #x1799)
+    ("KHMER LETTER RO" #x179A)
+    ("KHMER LETTER LO" #x179B)
+    ("KHMER LETTER VO" #x179C)
+    ("KHMER LETTER SHA" #x179D)
+    ("KHMER LETTER SSO" #x179E)
+    ("KHMER LETTER SA" #x179F)
+    ("KHMER LETTER HA" #x17A0)
+    ("KHMER LETTER LA" #x17A1)
+    ("KHMER LETTER QA" #x17A2)
+    ("KHMER INDEPENDENT VOWEL QAQ" #x17A3)
+    ("KHMER INDEPENDENT VOWEL QAA" #x17A4)
+    ("KHMER INDEPENDENT VOWEL QI" #x17A5)
+    ("KHMER INDEPENDENT VOWEL QII" #x17A6)
+    ("KHMER INDEPENDENT VOWEL QU" #x17A7)
+    ("KHMER INDEPENDENT VOWEL QUK" #x17A8)
+    ("KHMER INDEPENDENT VOWEL QUU" #x17A9)
+    ("KHMER INDEPENDENT VOWEL QUUV" #x17AA)
+    ("KHMER INDEPENDENT VOWEL RY" #x17AB)
+    ("KHMER INDEPENDENT VOWEL RYY" #x17AC)
+    ("KHMER INDEPENDENT VOWEL LY" #x17AD)
+    ("KHMER INDEPENDENT VOWEL LYY" #x17AE)
+    ("KHMER INDEPENDENT VOWEL QE" #x17AF)
+    ("KHMER INDEPENDENT VOWEL QAI" #x17B0)
+    ("KHMER INDEPENDENT VOWEL QOO TYPE ONE" #x17B1)
+    ("KHMER INDEPENDENT VOWEL QOO TYPE TWO" #x17B2)
+    ("KHMER INDEPENDENT VOWEL QAU" #x17B3)
+    ("KHMER VOWEL INHERENT AQ" #x17B4)
+    ("KHMER VOWEL INHERENT AA" #x17B5)
+    ("KHMER VOWEL SIGN AA" #x17B6)
+    ("KHMER VOWEL SIGN I" #x17B7)
+    ("KHMER VOWEL SIGN II" #x17B8)
+    ("KHMER VOWEL SIGN Y" #x17B9)
+    ("KHMER VOWEL SIGN YY" #x17BA)
+    ("KHMER VOWEL SIGN U" #x17BB)
+    ("KHMER VOWEL SIGN UU" #x17BC)
+    ("KHMER VOWEL SIGN UA" #x17BD)
+    ("KHMER VOWEL SIGN OE" #x17BE)
+    ("KHMER VOWEL SIGN YA" #x17BF)
+    ("KHMER VOWEL SIGN IE" #x17C0)
+    ("KHMER VOWEL SIGN E" #x17C1)
+    ("KHMER VOWEL SIGN AE" #x17C2)
+    ("KHMER VOWEL SIGN AI" #x17C3)
+    ("KHMER VOWEL SIGN OO" #x17C4)
+    ("KHMER VOWEL SIGN AU" #x17C5)
+    ("KHMER SIGN NIKAHIT" #x17C6)
+    ("KHMER SIGN REAHMUK" #x17C7)
+    ("KHMER SIGN YUUKALEAPINTU" #x17C8)
+    ("KHMER SIGN MUUSIKATOAN" #x17C9)
+    ("KHMER SIGN TRIISAP" #x17CA)
+    ("KHMER SIGN BANTOC" #x17CB)
+    ("KHMER SIGN ROBAT" #x17CC)
+    ("KHMER SIGN TOANDAKHIAT" #x17CD)
+    ("KHMER SIGN KAKABAT" #x17CE)
+    ("KHMER SIGN AHSDA" #x17CF)
+    ("KHMER SIGN SAMYOK SANNYA" #x17D0)
+    ("KHMER SIGN VIRIAM" #x17D1)
+    ("KHMER SIGN COENG" #x17D2)
+    ("KHMER SIGN BATHAMASAT" #x17D3)
+    ("KHMER SIGN KHAN" #x17D4)
+    ("KHMER SIGN BARIYOOSAN" #x17D5)
+    ("KHMER SIGN CAMNUC PII KUUH" #x17D6)
+    ("KHMER SIGN LEK TOO" #x17D7)
+    ("KHMER SIGN BEYYAL" #x17D8)
+    ("KHMER SIGN PHNAEK MUAN" #x17D9)
+    ("KHMER SIGN KOOMUUT" #x17DA)
+    ("KHMER CURRENCY SYMBOL RIEL" #x17DB)
+    ("KHMER SIGN AVAKRAHASANYA" #x17DC)
+    ("KHMER DIGIT ZERO" #x17E0)
+    ("KHMER DIGIT ONE" #x17E1)
+    ("KHMER DIGIT TWO" #x17E2)
+    ("KHMER DIGIT THREE" #x17E3)
+    ("KHMER DIGIT FOUR" #x17E4)
+    ("KHMER DIGIT FIVE" #x17E5)
+    ("KHMER DIGIT SIX" #x17E6)
+    ("KHMER DIGIT SEVEN" #x17E7)
+    ("KHMER DIGIT EIGHT" #x17E8)
+    ("KHMER DIGIT NINE" #x17E9)
+    ))
diff --git a/lisp/nxml/char-name/unicode/01800-018AF.el b/lisp/nxml/char-name/unicode/01800-018AF.el
new file mode 100644
index 00000000000..fd3e2455a29
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/01800-018AF.el
@@ -0,0 +1,157 @@
+(nxml-define-char-name-set 'mongolian
+  '(("MONGOLIAN BIRGA" #x1800)
+    ("MONGOLIAN ELLIPSIS" #x1801)
+    ("MONGOLIAN COMMA" #x1802)
+    ("MONGOLIAN FULL STOP" #x1803)
+    ("MONGOLIAN COLON" #x1804)
+    ("MONGOLIAN FOUR DOTS" #x1805)
+    ("MONGOLIAN TODO SOFT HYPHEN" #x1806)
+    ("MONGOLIAN SIBE SYLLABLE BOUNDARY MARKER" #x1807)
+    ("MONGOLIAN MANCHU COMMA" #x1808)
+    ("MONGOLIAN MANCHU FULL STOP" #x1809)
+    ("MONGOLIAN NIRUGU" #x180A)
+    ("MONGOLIAN FREE VARIATION SELECTOR ONE" #x180B)
+    ("MONGOLIAN FREE VARIATION SELECTOR TWO" #x180C)
+    ("MONGOLIAN FREE VARIATION SELECTOR THREE" #x180D)
+    ("MONGOLIAN VOWEL SEPARATOR" #x180E)
+    ("MONGOLIAN DIGIT ZERO" #x1810)
+    ("MONGOLIAN DIGIT ONE" #x1811)
+    ("MONGOLIAN DIGIT TWO" #x1812)
+    ("MONGOLIAN DIGIT THREE" #x1813)
+    ("MONGOLIAN DIGIT FOUR" #x1814)
+    ("MONGOLIAN DIGIT FIVE" #x1815)
+    ("MONGOLIAN DIGIT SIX" #x1816)
+    ("MONGOLIAN DIGIT SEVEN" #x1817)
+    ("MONGOLIAN DIGIT EIGHT" #x1818)
+    ("MONGOLIAN DIGIT NINE" #x1819)
+    ("MONGOLIAN LETTER A" #x1820)
+    ("MONGOLIAN LETTER E" #x1821)
+    ("MONGOLIAN LETTER I" #x1822)
+    ("MONGOLIAN LETTER O" #x1823)
+    ("MONGOLIAN LETTER U" #x1824)
+    ("MONGOLIAN LETTER OE" #x1825)
+    ("MONGOLIAN LETTER UE" #x1826)
+    ("MONGOLIAN LETTER EE" #x1827)
+    ("MONGOLIAN LETTER NA" #x1828)
+    ("MONGOLIAN LETTER ANG" #x1829)
+    ("MONGOLIAN LETTER BA" #x182A)
+    ("MONGOLIAN LETTER PA" #x182B)
+    ("MONGOLIAN LETTER QA" #x182C)
+    ("MONGOLIAN LETTER GA" #x182D)
+    ("MONGOLIAN LETTER MA" #x182E)
+    ("MONGOLIAN LETTER LA" #x182F)
+    ("MONGOLIAN LETTER SA" #x1830)
+    ("MONGOLIAN LETTER SHA" #x1831)
+    ("MONGOLIAN LETTER TA" #x1832)
+    ("MONGOLIAN LETTER DA" #x1833)
+    ("MONGOLIAN LETTER CHA" #x1834)
+    ("MONGOLIAN LETTER JA" #x1835)
+    ("MONGOLIAN LETTER YA" #x1836)
+    ("MONGOLIAN LETTER RA" #x1837)
+    ("MONGOLIAN LETTER WA" #x1838)
+    ("MONGOLIAN LETTER FA" #x1839)
+    ("MONGOLIAN LETTER KA" #x183A)
+    ("MONGOLIAN LETTER KHA" #x183B)
+    ("MONGOLIAN LETTER TSA" #x183C)
+    ("MONGOLIAN LETTER ZA" #x183D)
+    ("MONGOLIAN LETTER HAA" #x183E)
+    ("MONGOLIAN LETTER ZRA" #x183F)
+    ("MONGOLIAN LETTER LHA" #x1840)
+    ("MONGOLIAN LETTER ZHI" #x1841)
+    ("MONGOLIAN LETTER CHI" #x1842)
+    ("MONGOLIAN LETTER TODO LONG VOWEL SIGN" #x1843)
+    ("MONGOLIAN LETTER TODO E" #x1844)
+    ("MONGOLIAN LETTER TODO I" #x1845)
+    ("MONGOLIAN LETTER TODO O" #x1846)
+    ("MONGOLIAN LETTER TODO U" #x1847)
+    ("MONGOLIAN LETTER TODO OE" #x1848)
+    ("MONGOLIAN LETTER TODO UE" #x1849)
+    ("MONGOLIAN LETTER TODO ANG" #x184A)
+    ("MONGOLIAN LETTER TODO BA" #x184B)
+    ("MONGOLIAN LETTER TODO PA" #x184C)
+    ("MONGOLIAN LETTER TODO QA" #x184D)
+    ("MONGOLIAN LETTER TODO GA" #x184E)
+    ("MONGOLIAN LETTER TODO MA" #x184F)
+    ("MONGOLIAN LETTER TODO TA" #x1850)
+    ("MONGOLIAN LETTER TODO DA" #x1851)
+    ("MONGOLIAN LETTER TODO CHA" #x1852)
+    ("MONGOLIAN LETTER TODO JA" #x1853)
+    ("MONGOLIAN LETTER TODO TSA" #x1854)
+    ("MONGOLIAN LETTER TODO YA" #x1855)
+    ("MONGOLIAN LETTER TODO WA" #x1856)
+    ("MONGOLIAN LETTER TODO KA" #x1857)
+    ("MONGOLIAN LETTER TODO GAA" #x1858)
+    ("MONGOLIAN LETTER TODO HAA" #x1859)
+    ("MONGOLIAN LETTER TODO JIA" #x185A)
+    ("MONGOLIAN LETTER TODO NIA" #x185B)
+    ("MONGOLIAN LETTER TODO DZA" #x185C)
+    ("MONGOLIAN LETTER SIBE E" #x185D)
+    ("MONGOLIAN LETTER SIBE I" #x185E)
+    ("MONGOLIAN LETTER SIBE IY" #x185F)
+    ("MONGOLIAN LETTER SIBE UE" #x1860)
+    ("MONGOLIAN LETTER SIBE U" #x1861)
+    ("MONGOLIAN LETTER SIBE ANG" #x1862)
+    ("MONGOLIAN LETTER SIBE KA" #x1863)
+    ("MONGOLIAN LETTER SIBE GA" #x1864)
+    ("MONGOLIAN LETTER SIBE HA" #x1865)
+    ("MONGOLIAN LETTER SIBE PA" #x1866)
+    ("MONGOLIAN LETTER SIBE SHA" #x1867)
+    ("MONGOLIAN LETTER SIBE TA" #x1868)
+    ("MONGOLIAN LETTER SIBE DA" #x1869)
+    ("MONGOLIAN LETTER SIBE JA" #x186A)
+    ("MONGOLIAN LETTER SIBE FA" #x186B)
+    ("MONGOLIAN LETTER SIBE GAA" #x186C)
+    ("MONGOLIAN LETTER SIBE HAA" #x186D)
+    ("MONGOLIAN LETTER SIBE TSA" #x186E)
+    ("MONGOLIAN LETTER SIBE ZA" #x186F)
+    ("MONGOLIAN LETTER SIBE RAA" #x1870)
+    ("MONGOLIAN LETTER SIBE CHA" #x1871)
+    ("MONGOLIAN LETTER SIBE ZHA" #x1872)
+    ("MONGOLIAN LETTER MANCHU I" #x1873)
+    ("MONGOLIAN LETTER MANCHU KA" #x1874)
+    ("MONGOLIAN LETTER MANCHU RA" #x1875)
+    ("MONGOLIAN LETTER MANCHU FA" #x1876)
+    ("MONGOLIAN LETTER MANCHU ZHA" #x1877)
+    ("MONGOLIAN LETTER ALI GALI ANUSVARA ONE" #x1880)
+    ("MONGOLIAN LETTER ALI GALI VISARGA ONE" #x1881)
+    ("MONGOLIAN LETTER ALI GALI DAMARU" #x1882)
+    ("MONGOLIAN LETTER ALI GALI UBADAMA" #x1883)
+    ("MONGOLIAN LETTER ALI GALI INVERTED UBADAMA" #x1884)
+    ("MONGOLIAN LETTER ALI GALI BALUDA" #x1885)
+    ("MONGOLIAN LETTER ALI GALI THREE BALUDA" #x1886)
+    ("MONGOLIAN LETTER ALI GALI A" #x1887)
+    ("MONGOLIAN LETTER ALI GALI I" #x1888)
+    ("MONGOLIAN LETTER ALI GALI KA" #x1889)
+    ("MONGOLIAN LETTER ALI GALI NGA" #x188A)
+    ("MONGOLIAN LETTER ALI GALI CA" #x188B)
+    ("MONGOLIAN LETTER ALI GALI TTA" #x188C)
+    ("MONGOLIAN LETTER ALI GALI TTHA" #x188D)
+    ("MONGOLIAN LETTER ALI GALI DDA" #x188E)
+    ("MONGOLIAN LETTER ALI GALI NNA" #x188F)
+    ("MONGOLIAN LETTER ALI GALI TA" #x1890)
+    ("MONGOLIAN LETTER ALI GALI DA" #x1891)
+    ("MONGOLIAN LETTER ALI GALI PA" #x1892)
+    ("MONGOLIAN LETTER ALI GALI PHA" #x1893)
+    ("MONGOLIAN LETTER ALI GALI SSA" #x1894)
+    ("MONGOLIAN LETTER ALI GALI ZHA" #x1895)
+    ("MONGOLIAN LETTER ALI GALI ZA" #x1896)
+    ("MONGOLIAN LETTER ALI GALI AH" #x1897)
+    ("MONGOLIAN LETTER TODO ALI GALI TA" #x1898)
+    ("MONGOLIAN LETTER TODO ALI GALI ZHA" #x1899)
+    ("MONGOLIAN LETTER MANCHU ALI GALI GHA" #x189A)
+    ("MONGOLIAN LETTER MANCHU ALI GALI NGA" #x189B)
+    ("MONGOLIAN LETTER MANCHU ALI GALI CA" #x189C)
+    ("MONGOLIAN LETTER MANCHU ALI GALI JHA" #x189D)
+    ("MONGOLIAN LETTER MANCHU ALI GALI TTA" #x189E)
+    ("MONGOLIAN LETTER MANCHU ALI GALI DDHA" #x189F)
+    ("MONGOLIAN LETTER MANCHU ALI GALI TA" #x18A0)
+    ("MONGOLIAN LETTER MANCHU ALI GALI DHA" #x18A1)
+    ("MONGOLIAN LETTER MANCHU ALI GALI SSA" #x18A2)
+    ("MONGOLIAN LETTER MANCHU ALI GALI CYA" #x18A3)
+    ("MONGOLIAN LETTER MANCHU ALI GALI ZHA" #x18A4)
+    ("MONGOLIAN LETTER MANCHU ALI GALI ZA" #x18A5)
+    ("MONGOLIAN LETTER ALI GALI HALF U" #x18A6)
+    ("MONGOLIAN LETTER ALI GALI HALF YA" #x18A7)
+    ("MONGOLIAN LETTER MANCHU ALI GALI BHA" #x18A8)
+    ("MONGOLIAN LETTER ALI GALI DAGALGA" #x18A9)
+    ))
diff --git a/lisp/nxml/char-name/unicode/01E00-01EFF.el b/lisp/nxml/char-name/unicode/01E00-01EFF.el
new file mode 100644
index 00000000000..618b74cd3da
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/01E00-01EFF.el
@@ -0,0 +1,248 @@
+(nxml-define-char-name-set 'latin-extended-additional
+  '(("LATIN CAPITAL LETTER A WITH RING BELOW" #x1E00)
+    ("LATIN SMALL LETTER A WITH RING BELOW" #x1E01)
+    ("LATIN CAPITAL LETTER B WITH DOT ABOVE" #x1E02)
+    ("LATIN SMALL LETTER B WITH DOT ABOVE" #x1E03)
+    ("LATIN CAPITAL LETTER B WITH DOT BELOW" #x1E04)
+    ("LATIN SMALL LETTER B WITH DOT BELOW" #x1E05)
+    ("LATIN CAPITAL LETTER B WITH LINE BELOW" #x1E06)
+    ("LATIN SMALL LETTER B WITH LINE BELOW" #x1E07)
+    ("LATIN CAPITAL LETTER C WITH CEDILLA AND ACUTE" #x1E08)
+    ("LATIN SMALL LETTER C WITH CEDILLA AND ACUTE" #x1E09)
+    ("LATIN CAPITAL LETTER D WITH DOT ABOVE" #x1E0A)
+    ("LATIN SMALL LETTER D WITH DOT ABOVE" #x1E0B)
+    ("LATIN CAPITAL LETTER D WITH DOT BELOW" #x1E0C)
+    ("LATIN SMALL LETTER D WITH DOT BELOW" #x1E0D)
+    ("LATIN CAPITAL LETTER D WITH LINE BELOW" #x1E0E)
+    ("LATIN SMALL LETTER D WITH LINE BELOW" #x1E0F)
+    ("LATIN CAPITAL LETTER D WITH CEDILLA" #x1E10)
+    ("LATIN SMALL LETTER D WITH CEDILLA" #x1E11)
+    ("LATIN CAPITAL LETTER D WITH CIRCUMFLEX BELOW" #x1E12)
+    ("LATIN SMALL LETTER D WITH CIRCUMFLEX BELOW" #x1E13)
+    ("LATIN CAPITAL LETTER E WITH MACRON AND GRAVE" #x1E14)
+    ("LATIN SMALL LETTER E WITH MACRON AND GRAVE" #x1E15)
+    ("LATIN CAPITAL LETTER E WITH MACRON AND ACUTE" #x1E16)
+    ("LATIN SMALL LETTER E WITH MACRON AND ACUTE" #x1E17)
+    ("LATIN CAPITAL LETTER E WITH CIRCUMFLEX BELOW" #x1E18)
+    ("LATIN SMALL LETTER E WITH CIRCUMFLEX BELOW" #x1E19)
+    ("LATIN CAPITAL LETTER E WITH TILDE BELOW" #x1E1A)
+    ("LATIN SMALL LETTER E WITH TILDE BELOW" #x1E1B)
+    ("LATIN CAPITAL LETTER E WITH CEDILLA AND BREVE" #x1E1C)
+    ("LATIN SMALL LETTER E WITH CEDILLA AND BREVE" #x1E1D)
+    ("LATIN CAPITAL LETTER F WITH DOT ABOVE" #x1E1E)
+    ("LATIN SMALL LETTER F WITH DOT ABOVE" #x1E1F)
+    ("LATIN CAPITAL LETTER G WITH MACRON" #x1E20)
+    ("LATIN SMALL LETTER G WITH MACRON" #x1E21)
+    ("LATIN CAPITAL LETTER H WITH DOT ABOVE" #x1E22)
+    ("LATIN SMALL LETTER H WITH DOT ABOVE" #x1E23)
+    ("LATIN CAPITAL LETTER H WITH DOT BELOW" #x1E24)
+    ("LATIN SMALL LETTER H WITH DOT BELOW" #x1E25)
+    ("LATIN CAPITAL LETTER H WITH DIAERESIS" #x1E26)
+    ("LATIN SMALL LETTER H WITH DIAERESIS" #x1E27)
+    ("LATIN CAPITAL LETTER H WITH CEDILLA" #x1E28)
+    ("LATIN SMALL LETTER H WITH CEDILLA" #x1E29)
+    ("LATIN CAPITAL LETTER H WITH BREVE BELOW" #x1E2A)
+    ("LATIN SMALL LETTER H WITH BREVE BELOW" #x1E2B)
+    ("LATIN CAPITAL LETTER I WITH TILDE BELOW" #x1E2C)
+    ("LATIN SMALL LETTER I WITH TILDE BELOW" #x1E2D)
+    ("LATIN CAPITAL LETTER I WITH DIAERESIS AND ACUTE" #x1E2E)
+    ("LATIN SMALL LETTER I WITH DIAERESIS AND ACUTE" #x1E2F)
+    ("LATIN CAPITAL LETTER K WITH ACUTE" #x1E30)
+    ("LATIN SMALL LETTER K WITH ACUTE" #x1E31)
+    ("LATIN CAPITAL LETTER K WITH DOT BELOW" #x1E32)
+    ("LATIN SMALL LETTER K WITH DOT BELOW" #x1E33)
+    ("LATIN CAPITAL LETTER K WITH LINE BELOW" #x1E34)
+    ("LATIN SMALL LETTER K WITH LINE BELOW" #x1E35)
+    ("LATIN CAPITAL LETTER L WITH DOT BELOW" #x1E36)
+    ("LATIN SMALL LETTER L WITH DOT BELOW" #x1E37)
+    ("LATIN CAPITAL LETTER L WITH DOT BELOW AND MACRON" #x1E38)
+    ("LATIN SMALL LETTER L WITH DOT BELOW AND MACRON" #x1E39)
+    ("LATIN CAPITAL LETTER L WITH LINE BELOW" #x1E3A)
+    ("LATIN SMALL LETTER L WITH LINE BELOW" #x1E3B)
+    ("LATIN CAPITAL LETTER L WITH CIRCUMFLEX BELOW" #x1E3C)
+    ("LATIN SMALL LETTER L WITH CIRCUMFLEX BELOW" #x1E3D)
+    ("LATIN CAPITAL LETTER M WITH ACUTE" #x1E3E)
+    ("LATIN SMALL LETTER M WITH ACUTE" #x1E3F)
+    ("LATIN CAPITAL LETTER M WITH DOT ABOVE" #x1E40)
+    ("LATIN SMALL LETTER M WITH DOT ABOVE" #x1E41)
+    ("LATIN CAPITAL LETTER M WITH DOT BELOW" #x1E42)
+    ("LATIN SMALL LETTER M WITH DOT BELOW" #x1E43)
+    ("LATIN CAPITAL LETTER N WITH DOT ABOVE" #x1E44)
+    ("LATIN SMALL LETTER N WITH DOT ABOVE" #x1E45)
+    ("LATIN CAPITAL LETTER N WITH DOT BELOW" #x1E46)
+    ("LATIN SMALL LETTER N WITH DOT BELOW" #x1E47)
+    ("LATIN CAPITAL LETTER N WITH LINE BELOW" #x1E48)
+    ("LATIN SMALL LETTER N WITH LINE BELOW" #x1E49)
+    ("LATIN CAPITAL LETTER N WITH CIRCUMFLEX BELOW" #x1E4A)
+    ("LATIN SMALL LETTER N WITH CIRCUMFLEX BELOW" #x1E4B)
+    ("LATIN CAPITAL LETTER O WITH TILDE AND ACUTE" #x1E4C)
+    ("LATIN SMALL LETTER O WITH TILDE AND ACUTE" #x1E4D)
+    ("LATIN CAPITAL LETTER O WITH TILDE AND DIAERESIS" #x1E4E)
+    ("LATIN SMALL LETTER O WITH TILDE AND DIAERESIS" #x1E4F)
+    ("LATIN CAPITAL LETTER O WITH MACRON AND GRAVE" #x1E50)
+    ("LATIN SMALL LETTER O WITH MACRON AND GRAVE" #x1E51)
+    ("LATIN CAPITAL LETTER O WITH MACRON AND ACUTE" #x1E52)
+    ("LATIN SMALL LETTER O WITH MACRON AND ACUTE" #x1E53)
+    ("LATIN CAPITAL LETTER P WITH ACUTE" #x1E54)
+    ("LATIN SMALL LETTER P WITH ACUTE" #x1E55)
+    ("LATIN CAPITAL LETTER P WITH DOT ABOVE" #x1E56)
+    ("LATIN SMALL LETTER P WITH DOT ABOVE" #x1E57)
+    ("LATIN CAPITAL LETTER R WITH DOT ABOVE" #x1E58)
+    ("LATIN SMALL LETTER R WITH DOT ABOVE" #x1E59)
+    ("LATIN CAPITAL LETTER R WITH DOT BELOW" #x1E5A)
+    ("LATIN SMALL LETTER R WITH DOT BELOW" #x1E5B)
+    ("LATIN CAPITAL LETTER R WITH DOT BELOW AND MACRON" #x1E5C)
+    ("LATIN SMALL LETTER R WITH DOT BELOW AND MACRON" #x1E5D)
+    ("LATIN CAPITAL LETTER R WITH LINE BELOW" #x1E5E)
+    ("LATIN SMALL LETTER R WITH LINE BELOW" #x1E5F)
+    ("LATIN CAPITAL LETTER S WITH DOT ABOVE" #x1E60)
+    ("LATIN SMALL LETTER S WITH DOT ABOVE" #x1E61)
+    ("LATIN CAPITAL LETTER S WITH DOT BELOW" #x1E62)
+    ("LATIN SMALL LETTER S WITH DOT BELOW" #x1E63)
+    ("LATIN CAPITAL LETTER S WITH ACUTE AND DOT ABOVE" #x1E64)
+    ("LATIN SMALL LETTER S WITH ACUTE AND DOT ABOVE" #x1E65)
+    ("LATIN CAPITAL LETTER S WITH CARON AND DOT ABOVE" #x1E66)
+    ("LATIN SMALL LETTER S WITH CARON AND DOT ABOVE" #x1E67)
+    ("LATIN CAPITAL LETTER S WITH DOT BELOW AND DOT ABOVE" #x1E68)
+    ("LATIN SMALL LETTER S WITH DOT BELOW AND DOT ABOVE" #x1E69)
+    ("LATIN CAPITAL LETTER T WITH DOT ABOVE" #x1E6A)
+    ("LATIN SMALL LETTER T WITH DOT ABOVE" #x1E6B)
+    ("LATIN CAPITAL LETTER T WITH DOT BELOW" #x1E6C)
+    ("LATIN SMALL LETTER T WITH DOT BELOW" #x1E6D)
+    ("LATIN CAPITAL LETTER T WITH LINE BELOW" #x1E6E)
+    ("LATIN SMALL LETTER T WITH LINE BELOW" #x1E6F)
+    ("LATIN CAPITAL LETTER T WITH CIRCUMFLEX BELOW" #x1E70)
+    ("LATIN SMALL LETTER T WITH CIRCUMFLEX BELOW" #x1E71)
+    ("LATIN CAPITAL LETTER U WITH DIAERESIS BELOW" #x1E72)
+    ("LATIN SMALL LETTER U WITH DIAERESIS BELOW" #x1E73)
+    ("LATIN CAPITAL LETTER U WITH TILDE BELOW" #x1E74)
+    ("LATIN SMALL LETTER U WITH TILDE BELOW" #x1E75)
+    ("LATIN CAPITAL LETTER U WITH CIRCUMFLEX BELOW" #x1E76)
+    ("LATIN SMALL LETTER U WITH CIRCUMFLEX BELOW" #x1E77)
+    ("LATIN CAPITAL LETTER U WITH TILDE AND ACUTE" #x1E78)
+    ("LATIN SMALL LETTER U WITH TILDE AND ACUTE" #x1E79)
+    ("LATIN CAPITAL LETTER U WITH MACRON AND DIAERESIS" #x1E7A)
+    ("LATIN SMALL LETTER U WITH MACRON AND DIAERESIS" #x1E7B)
+    ("LATIN CAPITAL LETTER V WITH TILDE" #x1E7C)
+    ("LATIN SMALL LETTER V WITH TILDE" #x1E7D)
+    ("LATIN CAPITAL LETTER V WITH DOT BELOW" #x1E7E)
+    ("LATIN SMALL LETTER V WITH DOT BELOW" #x1E7F)
+    ("LATIN CAPITAL LETTER W WITH GRAVE" #x1E80)
+    ("LATIN SMALL LETTER W WITH GRAVE" #x1E81)
+    ("LATIN CAPITAL LETTER W WITH ACUTE" #x1E82)
+    ("LATIN SMALL LETTER W WITH ACUTE" #x1E83)
+    ("LATIN CAPITAL LETTER W WITH DIAERESIS" #x1E84)
+    ("LATIN SMALL LETTER W WITH DIAERESIS" #x1E85)
+    ("LATIN CAPITAL LETTER W WITH DOT ABOVE" #x1E86)
+    ("LATIN SMALL LETTER W WITH DOT ABOVE" #x1E87)
+    ("LATIN CAPITAL LETTER W WITH DOT BELOW" #x1E88)
+    ("LATIN SMALL LETTER W WITH DOT BELOW" #x1E89)
+    ("LATIN CAPITAL LETTER X WITH DOT ABOVE" #x1E8A)
+    ("LATIN SMALL LETTER X WITH DOT ABOVE" #x1E8B)
+    ("LATIN CAPITAL LETTER X WITH DIAERESIS" #x1E8C)
+    ("LATIN SMALL LETTER X WITH DIAERESIS" #x1E8D)
+    ("LATIN CAPITAL LETTER Y WITH DOT ABOVE" #x1E8E)
+    ("LATIN SMALL LETTER Y WITH DOT ABOVE" #x1E8F)
+    ("LATIN CAPITAL LETTER Z WITH CIRCUMFLEX" #x1E90)
+    ("LATIN SMALL LETTER Z WITH CIRCUMFLEX" #x1E91)
+    ("LATIN CAPITAL LETTER Z WITH DOT BELOW" #x1E92)
+    ("LATIN SMALL LETTER Z WITH DOT BELOW" #x1E93)
+    ("LATIN CAPITAL LETTER Z WITH LINE BELOW" #x1E94)
+    ("LATIN SMALL LETTER Z WITH LINE BELOW" #x1E95)
+    ("LATIN SMALL LETTER H WITH LINE BELOW" #x1E96)
+    ("LATIN SMALL LETTER T WITH DIAERESIS" #x1E97)
+    ("LATIN SMALL LETTER W WITH RING ABOVE" #x1E98)
+    ("LATIN SMALL LETTER Y WITH RING ABOVE" #x1E99)
+    ("LATIN SMALL LETTER A WITH RIGHT HALF RING" #x1E9A)
+    ("LATIN SMALL LETTER LONG S WITH DOT ABOVE" #x1E9B)
+    ("LATIN CAPITAL LETTER A WITH DOT BELOW" #x1EA0)
+    ("LATIN SMALL LETTER A WITH DOT BELOW" #x1EA1)
+    ("LATIN CAPITAL LETTER A WITH HOOK ABOVE" #x1EA2)
+    ("LATIN SMALL LETTER A WITH HOOK ABOVE" #x1EA3)
+    ("LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND ACUTE" #x1EA4)
+    ("LATIN SMALL LETTER A WITH CIRCUMFLEX AND ACUTE" #x1EA5)
+    ("LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND GRAVE" #x1EA6)
+    ("LATIN SMALL LETTER A WITH CIRCUMFLEX AND GRAVE" #x1EA7)
+    ("LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND HOOK ABOVE" #x1EA8)
+    ("LATIN SMALL LETTER A WITH CIRCUMFLEX AND HOOK ABOVE" #x1EA9)
+    ("LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND TILDE" #x1EAA)
+    ("LATIN SMALL LETTER A WITH CIRCUMFLEX AND TILDE" #x1EAB)
+    ("LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND DOT BELOW" #x1EAC)
+    ("LATIN SMALL LETTER A WITH CIRCUMFLEX AND DOT BELOW" #x1EAD)
+    ("LATIN CAPITAL LETTER A WITH BREVE AND ACUTE" #x1EAE)
+    ("LATIN SMALL LETTER A WITH BREVE AND ACUTE" #x1EAF)
+    ("LATIN CAPITAL LETTER A WITH BREVE AND GRAVE" #x1EB0)
+    ("LATIN SMALL LETTER A WITH BREVE AND GRAVE" #x1EB1)
+    ("LATIN CAPITAL LETTER A WITH BREVE AND HOOK ABOVE" #x1EB2)
+    ("LATIN SMALL LETTER A WITH BREVE AND HOOK ABOVE" #x1EB3)
+    ("LATIN CAPITAL LETTER A WITH BREVE AND TILDE" #x1EB4)
+    ("LATIN SMALL LETTER A WITH BREVE AND TILDE" #x1EB5)
+    ("LATIN CAPITAL LETTER A WITH BREVE AND DOT BELOW" #x1EB6)
+    ("LATIN SMALL LETTER A WITH BREVE AND DOT BELOW" #x1EB7)
+    ("LATIN CAPITAL LETTER E WITH DOT BELOW" #x1EB8)
+    ("LATIN SMALL LETTER E WITH DOT BELOW" #x1EB9)
+    ("LATIN CAPITAL LETTER E WITH HOOK ABOVE" #x1EBA)
+    ("LATIN SMALL LETTER E WITH HOOK ABOVE" #x1EBB)
+    ("LATIN CAPITAL LETTER E WITH TILDE" #x1EBC)
+    ("LATIN SMALL LETTER E WITH TILDE" #x1EBD)
+    ("LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND ACUTE" #x1EBE)
+    ("LATIN SMALL LETTER E WITH CIRCUMFLEX AND ACUTE" #x1EBF)
+    ("LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND GRAVE" #x1EC0)
+    ("LATIN SMALL LETTER E WITH CIRCUMFLEX AND GRAVE" #x1EC1)
+    ("LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND HOOK ABOVE" #x1EC2)
+    ("LATIN SMALL LETTER E WITH CIRCUMFLEX AND HOOK ABOVE" #x1EC3)
+    ("LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND TILDE" #x1EC4)
+    ("LATIN SMALL LETTER E WITH CIRCUMFLEX AND TILDE" #x1EC5)
+    ("LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND DOT BELOW" #x1EC6)
+    ("LATIN SMALL LETTER E WITH CIRCUMFLEX AND DOT BELOW" #x1EC7)
+    ("LATIN CAPITAL LETTER I WITH HOOK ABOVE" #x1EC8)
+    ("LATIN SMALL LETTER I WITH HOOK ABOVE" #x1EC9)
+    ("LATIN CAPITAL LETTER I WITH DOT BELOW" #x1ECA)
+    ("LATIN SMALL LETTER I WITH DOT BELOW" #x1ECB)
+    ("LATIN CAPITAL LETTER O WITH DOT BELOW" #x1ECC)
+    ("LATIN SMALL LETTER O WITH DOT BELOW" #x1ECD)
+    ("LATIN CAPITAL LETTER O WITH HOOK ABOVE" #x1ECE)
+    ("LATIN SMALL LETTER O WITH HOOK ABOVE" #x1ECF)
+    ("LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND ACUTE" #x1ED0)
+    ("LATIN SMALL LETTER O WITH CIRCUMFLEX AND ACUTE" #x1ED1)
+    ("LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND GRAVE" #x1ED2)
+    ("LATIN SMALL LETTER O WITH CIRCUMFLEX AND GRAVE" #x1ED3)
+    ("LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND HOOK ABOVE" #x1ED4)
+    ("LATIN SMALL LETTER O WITH CIRCUMFLEX AND HOOK ABOVE" #x1ED5)
+    ("LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND TILDE" #x1ED6)
+    ("LATIN SMALL LETTER O WITH CIRCUMFLEX AND TILDE" #x1ED7)
+    ("LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND DOT BELOW" #x1ED8)
+    ("LATIN SMALL LETTER O WITH CIRCUMFLEX AND DOT BELOW" #x1ED9)
+    ("LATIN CAPITAL LETTER O WITH HORN AND ACUTE" #x1EDA)
+    ("LATIN SMALL LETTER O WITH HORN AND ACUTE" #x1EDB)
+    ("LATIN CAPITAL LETTER O WITH HORN AND GRAVE" #x1EDC)
+    ("LATIN SMALL LETTER O WITH HORN AND GRAVE" #x1EDD)
+    ("LATIN CAPITAL LETTER O WITH HORN AND HOOK ABOVE" #x1EDE)
+    ("LATIN SMALL LETTER O WITH HORN AND HOOK ABOVE" #x1EDF)
+    ("LATIN CAPITAL LETTER O WITH HORN AND TILDE" #x1EE0)
+    ("LATIN SMALL LETTER O WITH HORN AND TILDE" #x1EE1)
+    ("LATIN CAPITAL LETTER O WITH HORN AND DOT BELOW" #x1EE2)
+    ("LATIN SMALL LETTER O WITH HORN AND DOT BELOW" #x1EE3)
+    ("LATIN CAPITAL LETTER U WITH DOT BELOW" #x1EE4)
+    ("LATIN SMALL LETTER U WITH DOT BELOW" #x1EE5)
+    ("LATIN CAPITAL LETTER U WITH HOOK ABOVE" #x1EE6)
+    ("LATIN SMALL LETTER U WITH HOOK ABOVE" #x1EE7)
+    ("LATIN CAPITAL LETTER U WITH HORN AND ACUTE" #x1EE8)
+    ("LATIN SMALL LETTER U WITH HORN AND ACUTE" #x1EE9)
+    ("LATIN CAPITAL LETTER U WITH HORN AND GRAVE" #x1EEA)
+    ("LATIN SMALL LETTER U WITH HORN AND GRAVE" #x1EEB)
+    ("LATIN CAPITAL LETTER U WITH HORN AND HOOK ABOVE" #x1EEC)
+    ("LATIN SMALL LETTER U WITH HORN AND HOOK ABOVE" #x1EED)
+    ("LATIN CAPITAL LETTER U WITH HORN AND TILDE" #x1EEE)
+    ("LATIN SMALL LETTER U WITH HORN AND TILDE" #x1EEF)
+    ("LATIN CAPITAL LETTER U WITH HORN AND DOT BELOW" #x1EF0)
+    ("LATIN SMALL LETTER U WITH HORN AND DOT BELOW" #x1EF1)
+    ("LATIN CAPITAL LETTER Y WITH GRAVE" #x1EF2)
+    ("LATIN SMALL LETTER Y WITH GRAVE" #x1EF3)
+    ("LATIN CAPITAL LETTER Y WITH DOT BELOW" #x1EF4)
+    ("LATIN SMALL LETTER Y WITH DOT BELOW" #x1EF5)
+    ("LATIN CAPITAL LETTER Y WITH HOOK ABOVE" #x1EF6)
+    ("LATIN SMALL LETTER Y WITH HOOK ABOVE" #x1EF7)
+    ("LATIN CAPITAL LETTER Y WITH TILDE" #x1EF8)
+    ("LATIN SMALL LETTER Y WITH TILDE" #x1EF9)
+    ))
diff --git a/lisp/nxml/char-name/unicode/01F00-01FFF.el b/lisp/nxml/char-name/unicode/01F00-01FFF.el
new file mode 100644
index 00000000000..56ce30a017a
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/01F00-01FFF.el
@@ -0,0 +1,235 @@
+(nxml-define-char-name-set 'greek-extended
+  '(("GREEK SMALL LETTER ALPHA WITH PSILI" #x1F00)
+    ("GREEK SMALL LETTER ALPHA WITH DASIA" #x1F01)
+    ("GREEK SMALL LETTER ALPHA WITH PSILI AND VARIA" #x1F02)
+    ("GREEK SMALL LETTER ALPHA WITH DASIA AND VARIA" #x1F03)
+    ("GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA" #x1F04)
+    ("GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA" #x1F05)
+    ("GREEK SMALL LETTER ALPHA WITH PSILI AND PERISPOMENI" #x1F06)
+    ("GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI" #x1F07)
+    ("GREEK CAPITAL LETTER ALPHA WITH PSILI" #x1F08)
+    ("GREEK CAPITAL LETTER ALPHA WITH DASIA" #x1F09)
+    ("GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA" #x1F0A)
+    ("GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA" #x1F0B)
+    ("GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA" #x1F0C)
+    ("GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA" #x1F0D)
+    ("GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI" #x1F0E)
+    ("GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI" #x1F0F)
+    ("GREEK SMALL LETTER EPSILON WITH PSILI" #x1F10)
+    ("GREEK SMALL LETTER EPSILON WITH DASIA" #x1F11)
+    ("GREEK SMALL LETTER EPSILON WITH PSILI AND VARIA" #x1F12)
+    ("GREEK SMALL LETTER EPSILON WITH DASIA AND VARIA" #x1F13)
+    ("GREEK SMALL LETTER EPSILON WITH PSILI AND OXIA" #x1F14)
+    ("GREEK SMALL LETTER EPSILON WITH DASIA AND OXIA" #x1F15)
+    ("GREEK CAPITAL LETTER EPSILON WITH PSILI" #x1F18)
+    ("GREEK CAPITAL LETTER EPSILON WITH DASIA" #x1F19)
+    ("GREEK CAPITAL LETTER EPSILON WITH PSILI AND VARIA" #x1F1A)
+    ("GREEK CAPITAL LETTER EPSILON WITH DASIA AND VARIA" #x1F1B)
+    ("GREEK CAPITAL LETTER EPSILON WITH PSILI AND OXIA" #x1F1C)
+    ("GREEK CAPITAL LETTER EPSILON WITH DASIA AND OXIA" #x1F1D)
+    ("GREEK SMALL LETTER ETA WITH PSILI" #x1F20)
+    ("GREEK SMALL LETTER ETA WITH DASIA" #x1F21)
+    ("GREEK SMALL LETTER ETA WITH PSILI AND VARIA" #x1F22)
+    ("GREEK SMALL LETTER ETA WITH DASIA AND VARIA" #x1F23)
+    ("GREEK SMALL LETTER ETA WITH PSILI AND OXIA" #x1F24)
+    ("GREEK SMALL LETTER ETA WITH DASIA AND OXIA" #x1F25)
+    ("GREEK SMALL LETTER ETA WITH PSILI AND PERISPOMENI" #x1F26)
+    ("GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI" #x1F27)
+    ("GREEK CAPITAL LETTER ETA WITH PSILI" #x1F28)
+    ("GREEK CAPITAL LETTER ETA WITH DASIA" #x1F29)
+    ("GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA" #x1F2A)
+    ("GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA" #x1F2B)
+    ("GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA" #x1F2C)
+    ("GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA" #x1F2D)
+    ("GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI" #x1F2E)
+    ("GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI" #x1F2F)
+    ("GREEK SMALL LETTER IOTA WITH PSILI" #x1F30)
+    ("GREEK SMALL LETTER IOTA WITH DASIA" #x1F31)
+    ("GREEK SMALL LETTER IOTA WITH PSILI AND VARIA" #x1F32)
+    ("GREEK SMALL LETTER IOTA WITH DASIA AND VARIA" #x1F33)
+    ("GREEK SMALL LETTER IOTA WITH PSILI AND OXIA" #x1F34)
+    ("GREEK SMALL LETTER IOTA WITH DASIA AND OXIA" #x1F35)
+    ("GREEK SMALL LETTER IOTA WITH PSILI AND PERISPOMENI" #x1F36)
+    ("GREEK SMALL LETTER IOTA WITH DASIA AND PERISPOMENI" #x1F37)
+    ("GREEK CAPITAL LETTER IOTA WITH PSILI" #x1F38)
+    ("GREEK CAPITAL LETTER IOTA WITH DASIA" #x1F39)
+    ("GREEK CAPITAL LETTER IOTA WITH PSILI AND VARIA" #x1F3A)
+    ("GREEK CAPITAL LETTER IOTA WITH DASIA AND VARIA" #x1F3B)
+    ("GREEK CAPITAL LETTER IOTA WITH PSILI AND OXIA" #x1F3C)
+    ("GREEK CAPITAL LETTER IOTA WITH DASIA AND OXIA" #x1F3D)
+    ("GREEK CAPITAL LETTER IOTA WITH PSILI AND PERISPOMENI" #x1F3E)
+    ("GREEK CAPITAL LETTER IOTA WITH DASIA AND PERISPOMENI" #x1F3F)
+    ("GREEK SMALL LETTER OMICRON WITH PSILI" #x1F40)
+    ("GREEK SMALL LETTER OMICRON WITH DASIA" #x1F41)
+    ("GREEK SMALL LETTER OMICRON WITH PSILI AND VARIA" #x1F42)
+    ("GREEK SMALL LETTER OMICRON WITH DASIA AND VARIA" #x1F43)
+    ("GREEK SMALL LETTER OMICRON WITH PSILI AND OXIA" #x1F44)
+    ("GREEK SMALL LETTER OMICRON WITH DASIA AND OXIA" #x1F45)
+    ("GREEK CAPITAL LETTER OMICRON WITH PSILI" #x1F48)
+    ("GREEK CAPITAL LETTER OMICRON WITH DASIA" #x1F49)
+    ("GREEK CAPITAL LETTER OMICRON WITH PSILI AND VARIA" #x1F4A)
+    ("GREEK CAPITAL LETTER OMICRON WITH DASIA AND VARIA" #x1F4B)
+    ("GREEK CAPITAL LETTER OMICRON WITH PSILI AND OXIA" #x1F4C)
+    ("GREEK CAPITAL LETTER OMICRON WITH DASIA AND OXIA" #x1F4D)
+    ("GREEK SMALL LETTER UPSILON WITH PSILI" #x1F50)
+    ("GREEK SMALL LETTER UPSILON WITH DASIA" #x1F51)
+    ("GREEK SMALL LETTER UPSILON WITH PSILI AND VARIA" #x1F52)
+    ("GREEK SMALL LETTER UPSILON WITH DASIA AND VARIA" #x1F53)
+    ("GREEK SMALL LETTER UPSILON WITH PSILI AND OXIA" #x1F54)
+    ("GREEK SMALL LETTER UPSILON WITH DASIA AND OXIA" #x1F55)
+    ("GREEK SMALL LETTER UPSILON WITH PSILI AND PERISPOMENI" #x1F56)
+    ("GREEK SMALL LETTER UPSILON WITH DASIA AND PERISPOMENI" #x1F57)
+    ("GREEK CAPITAL LETTER UPSILON WITH DASIA" #x1F59)
+    ("GREEK CAPITAL LETTER UPSILON WITH DASIA AND VARIA" #x1F5B)
+    ("GREEK CAPITAL LETTER UPSILON WITH DASIA AND OXIA" #x1F5D)
+    ("GREEK CAPITAL LETTER UPSILON WITH DASIA AND PERISPOMENI" #x1F5F)
+    ("GREEK SMALL LETTER OMEGA WITH PSILI" #x1F60)
+    ("GREEK SMALL LETTER OMEGA WITH DASIA" #x1F61)
+    ("GREEK SMALL LETTER OMEGA WITH PSILI AND VARIA" #x1F62)
+    ("GREEK SMALL LETTER OMEGA WITH DASIA AND VARIA" #x1F63)
+    ("GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA" #x1F64)
+    ("GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA" #x1F65)
+    ("GREEK SMALL LETTER OMEGA WITH PSILI AND PERISPOMENI" #x1F66)
+    ("GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI" #x1F67)
+    ("GREEK CAPITAL LETTER OMEGA WITH PSILI" #x1F68)
+    ("GREEK CAPITAL LETTER OMEGA WITH DASIA" #x1F69)
+    ("GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA" #x1F6A)
+    ("GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA" #x1F6B)
+    ("GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA" #x1F6C)
+    ("GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA" #x1F6D)
+    ("GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI" #x1F6E)
+    ("GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI" #x1F6F)
+    ("GREEK SMALL LETTER ALPHA WITH VARIA" #x1F70)
+    ("GREEK SMALL LETTER ALPHA WITH OXIA" #x1F71)
+    ("GREEK SMALL LETTER EPSILON WITH VARIA" #x1F72)
+    ("GREEK SMALL LETTER EPSILON WITH OXIA" #x1F73)
+    ("GREEK SMALL LETTER ETA WITH VARIA" #x1F74)
+    ("GREEK SMALL LETTER ETA WITH OXIA" #x1F75)
+    ("GREEK SMALL LETTER IOTA WITH VARIA" #x1F76)
+    ("GREEK SMALL LETTER IOTA WITH OXIA" #x1F77)
+    ("GREEK SMALL LETTER OMICRON WITH VARIA" #x1F78)
+    ("GREEK SMALL LETTER OMICRON WITH OXIA" #x1F79)
+    ("GREEK SMALL LETTER UPSILON WITH VARIA" #x1F7A)
+    ("GREEK SMALL LETTER UPSILON WITH OXIA" #x1F7B)
+    ("GREEK SMALL LETTER OMEGA WITH VARIA" #x1F7C)
+    ("GREEK SMALL LETTER OMEGA WITH OXIA" #x1F7D)
+    ("GREEK SMALL LETTER ALPHA WITH PSILI AND YPOGEGRAMMENI" #x1F80)
+    ("GREEK SMALL LETTER ALPHA WITH DASIA AND YPOGEGRAMMENI" #x1F81)
+    ("GREEK SMALL LETTER ALPHA WITH PSILI AND VARIA AND YPOGEGRAMMENI" #x1F82)
+    ("GREEK SMALL LETTER ALPHA WITH DASIA AND VARIA AND YPOGEGRAMMENI" #x1F83)
+    ("GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA AND YPOGEGRAMMENI" #x1F84)
+    ("GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA AND YPOGEGRAMMENI" #x1F85)
+    ("GREEK SMALL LETTER ALPHA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI" #x1F86)
+    ("GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI" #x1F87)
+    ("GREEK CAPITAL LETTER ALPHA WITH PSILI AND PROSGEGRAMMENI" #x1F88)
+    ("GREEK CAPITAL LETTER ALPHA WITH DASIA AND PROSGEGRAMMENI" #x1F89)
+    ("GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA AND PROSGEGRAMMENI" #x1F8A)
+    ("GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA AND PROSGEGRAMMENI" #x1F8B)
+    ("GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA AND PROSGEGRAMMENI" #x1F8C)
+    ("GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA AND PROSGEGRAMMENI" #x1F8D)
+    ("GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI" #x1F8E)
+    ("GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI" #x1F8F)
+    ("GREEK SMALL LETTER ETA WITH PSILI AND YPOGEGRAMMENI" #x1F90)
+    ("GREEK SMALL LETTER ETA WITH DASIA AND YPOGEGRAMMENI" #x1F91)
+    ("GREEK SMALL LETTER ETA WITH PSILI AND VARIA AND YPOGEGRAMMENI" #x1F92)
+    ("GREEK SMALL LETTER ETA WITH DASIA AND VARIA AND YPOGEGRAMMENI" #x1F93)
+    ("GREEK SMALL LETTER ETA WITH PSILI AND OXIA AND YPOGEGRAMMENI" #x1F94)
+    ("GREEK SMALL LETTER ETA WITH DASIA AND OXIA AND YPOGEGRAMMENI" #x1F95)
+    ("GREEK SMALL LETTER ETA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI" #x1F96)
+    ("GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI" #x1F97)
+    ("GREEK CAPITAL LETTER ETA WITH PSILI AND PROSGEGRAMMENI" #x1F98)
+    ("GREEK CAPITAL LETTER ETA WITH DASIA AND PROSGEGRAMMENI" #x1F99)
+    ("GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA AND PROSGEGRAMMENI" #x1F9A)
+    ("GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA AND PROSGEGRAMMENI" #x1F9B)
+    ("GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA AND PROSGEGRAMMENI" #x1F9C)
+    ("GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA AND PROSGEGRAMMENI" #x1F9D)
+    ("GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI" #x1F9E)
+    ("GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI" #x1F9F)
+    ("GREEK SMALL LETTER OMEGA WITH PSILI AND YPOGEGRAMMENI" #x1FA0)
+    ("GREEK SMALL LETTER OMEGA WITH DASIA AND YPOGEGRAMMENI" #x1FA1)
+    ("GREEK SMALL LETTER OMEGA WITH PSILI AND VARIA AND YPOGEGRAMMENI" #x1FA2)
+    ("GREEK SMALL LETTER OMEGA WITH DASIA AND VARIA AND YPOGEGRAMMENI" #x1FA3)
+    ("GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA AND YPOGEGRAMMENI" #x1FA4)
+    ("GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA AND YPOGEGRAMMENI" #x1FA5)
+    ("GREEK SMALL LETTER OMEGA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI" #x1FA6)
+    ("GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI" #x1FA7)
+    ("GREEK CAPITAL LETTER OMEGA WITH PSILI AND PROSGEGRAMMENI" #x1FA8)
+    ("GREEK CAPITAL LETTER OMEGA WITH DASIA AND PROSGEGRAMMENI" #x1FA9)
+    ("GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA AND PROSGEGRAMMENI" #x1FAA)
+    ("GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA AND PROSGEGRAMMENI" #x1FAB)
+    ("GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA AND PROSGEGRAMMENI" #x1FAC)
+    ("GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA AND PROSGEGRAMMENI" #x1FAD)
+    ("GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI" #x1FAE)
+    ("GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI" #x1FAF)
+    ("GREEK SMALL LETTER ALPHA WITH VRACHY" #x1FB0)
+    ("GREEK SMALL LETTER ALPHA WITH MACRON" #x1FB1)
+    ("GREEK SMALL LETTER ALPHA WITH VARIA AND YPOGEGRAMMENI" #x1FB2)
+    ("GREEK SMALL LETTER ALPHA WITH YPOGEGRAMMENI" #x1FB3)
+    ("GREEK SMALL LETTER ALPHA WITH OXIA AND YPOGEGRAMMENI" #x1FB4)
+    ("GREEK SMALL LETTER ALPHA WITH PERISPOMENI" #x1FB6)
+    ("GREEK SMALL LETTER ALPHA WITH PERISPOMENI AND YPOGEGRAMMENI" #x1FB7)
+    ("GREEK CAPITAL LETTER ALPHA WITH VRACHY" #x1FB8)
+    ("GREEK CAPITAL LETTER ALPHA WITH MACRON" #x1FB9)
+    ("GREEK CAPITAL LETTER ALPHA WITH VARIA" #x1FBA)
+    ("GREEK CAPITAL LETTER ALPHA WITH OXIA" #x1FBB)
+    ("GREEK CAPITAL LETTER ALPHA WITH PROSGEGRAMMENI" #x1FBC)
+    ("GREEK KORONIS" #x1FBD)
+    ("GREEK PROSGEGRAMMENI" #x1FBE)
+    ("GREEK PSILI" #x1FBF)
+    ("GREEK PERISPOMENI" #x1FC0)
+    ("GREEK DIALYTIKA AND PERISPOMENI" #x1FC1)
+    ("GREEK SMALL LETTER ETA WITH VARIA AND YPOGEGRAMMENI" #x1FC2)
+    ("GREEK SMALL LETTER ETA WITH YPOGEGRAMMENI" #x1FC3)
+    ("GREEK SMALL LETTER ETA WITH OXIA AND YPOGEGRAMMENI" #x1FC4)
+    ("GREEK SMALL LETTER ETA WITH PERISPOMENI" #x1FC6)
+    ("GREEK SMALL LETTER ETA WITH PERISPOMENI AND YPOGEGRAMMENI" #x1FC7)
+    ("GREEK CAPITAL LETTER EPSILON WITH VARIA" #x1FC8)
+    ("GREEK CAPITAL LETTER EPSILON WITH OXIA" #x1FC9)
+    ("GREEK CAPITAL LETTER ETA WITH VARIA" #x1FCA)
+    ("GREEK CAPITAL LETTER ETA WITH OXIA" #x1FCB)
+    ("GREEK CAPITAL LETTER ETA WITH PROSGEGRAMMENI" #x1FCC)
+    ("GREEK PSILI AND VARIA" #x1FCD)
+    ("GREEK PSILI AND OXIA" #x1FCE)
+    ("GREEK PSILI AND PERISPOMENI" #x1FCF)
+    ("GREEK SMALL LETTER IOTA WITH VRACHY" #x1FD0)
+    ("GREEK SMALL LETTER IOTA WITH MACRON" #x1FD1)
+    ("GREEK SMALL LETTER IOTA WITH DIALYTIKA AND VARIA" #x1FD2)
+    ("GREEK SMALL LETTER IOTA WITH DIALYTIKA AND OXIA" #x1FD3)
+    ("GREEK SMALL LETTER IOTA WITH PERISPOMENI" #x1FD6)
+    ("GREEK SMALL LETTER IOTA WITH DIALYTIKA AND PERISPOMENI" #x1FD7)
+    ("GREEK CAPITAL LETTER IOTA WITH VRACHY" #x1FD8)
+    ("GREEK CAPITAL LETTER IOTA WITH MACRON" #x1FD9)
+    ("GREEK CAPITAL LETTER IOTA WITH VARIA" #x1FDA)
+    ("GREEK CAPITAL LETTER IOTA WITH OXIA" #x1FDB)
+    ("GREEK DASIA AND VARIA" #x1FDD)
+    ("GREEK DASIA AND OXIA" #x1FDE)
+    ("GREEK DASIA AND PERISPOMENI" #x1FDF)
+    ("GREEK SMALL LETTER UPSILON WITH VRACHY" #x1FE0)
+    ("GREEK SMALL LETTER UPSILON WITH MACRON" #x1FE1)
+    ("GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND VARIA" #x1FE2)
+    ("GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND OXIA" #x1FE3)
+    ("GREEK SMALL LETTER RHO WITH PSILI" #x1FE4)
+    ("GREEK SMALL LETTER RHO WITH DASIA" #x1FE5)
+    ("GREEK SMALL LETTER UPSILON WITH PERISPOMENI" #x1FE6)
+    ("GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND PERISPOMENI" #x1FE7)
+    ("GREEK CAPITAL LETTER UPSILON WITH VRACHY" #x1FE8)
+    ("GREEK CAPITAL LETTER UPSILON WITH MACRON" #x1FE9)
+    ("GREEK CAPITAL LETTER UPSILON WITH VARIA" #x1FEA)
+    ("GREEK CAPITAL LETTER UPSILON WITH OXIA" #x1FEB)
+    ("GREEK CAPITAL LETTER RHO WITH DASIA" #x1FEC)
+    ("GREEK DIALYTIKA AND VARIA" #x1FED)
+    ("GREEK DIALYTIKA AND OXIA" #x1FEE)
+    ("GREEK VARIA" #x1FEF)
+    ("GREEK SMALL LETTER OMEGA WITH VARIA AND YPOGEGRAMMENI" #x1FF2)
+    ("GREEK SMALL LETTER OMEGA WITH YPOGEGRAMMENI" #x1FF3)
+    ("GREEK SMALL LETTER OMEGA WITH OXIA AND YPOGEGRAMMENI" #x1FF4)
+    ("GREEK SMALL LETTER OMEGA WITH PERISPOMENI" #x1FF6)
+    ("GREEK SMALL LETTER OMEGA WITH PERISPOMENI AND YPOGEGRAMMENI" #x1FF7)
+    ("GREEK CAPITAL LETTER OMICRON WITH VARIA" #x1FF8)
+    ("GREEK CAPITAL LETTER OMICRON WITH OXIA" #x1FF9)
+    ("GREEK CAPITAL LETTER OMEGA WITH VARIA" #x1FFA)
+    ("GREEK CAPITAL LETTER OMEGA WITH OXIA" #x1FFB)
+    ("GREEK CAPITAL LETTER OMEGA WITH PROSGEGRAMMENI" #x1FFC)
+    ("GREEK OXIA" #x1FFD)
+    ("GREEK DASIA" #x1FFE)
+    ))
diff --git a/lisp/nxml/char-name/unicode/02000-0206F.el b/lisp/nxml/char-name/unicode/02000-0206F.el
new file mode 100644
index 00000000000..54f6207cd42
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/02000-0206F.el
@@ -0,0 +1,97 @@
+(nxml-define-char-name-set 'general-punctuation
+  '(("EN QUAD" #x2000)
+    ("EM QUAD" #x2001)
+    ("EN SPACE" #x2002)
+    ("EM SPACE" #x2003)
+    ("THREE-PER-EM SPACE" #x2004)
+    ("FOUR-PER-EM SPACE" #x2005)
+    ("SIX-PER-EM SPACE" #x2006)
+    ("FIGURE SPACE" #x2007)
+    ("PUNCTUATION SPACE" #x2008)
+    ("THIN SPACE" #x2009)
+    ("HAIR SPACE" #x200A)
+    ("ZERO WIDTH SPACE" #x200B)
+    ("ZERO WIDTH NON-JOINER" #x200C)
+    ("ZERO WIDTH JOINER" #x200D)
+    ("LEFT-TO-RIGHT MARK" #x200E)
+    ("RIGHT-TO-LEFT MARK" #x200F)
+    ("HYPHEN" #x2010)
+    ("NON-BREAKING HYPHEN" #x2011)
+    ("FIGURE DASH" #x2012)
+    ("EN DASH" #x2013)
+    ("EM DASH" #x2014)
+    ("HORIZONTAL BAR" #x2015)
+    ("DOUBLE VERTICAL LINE" #x2016)
+    ("DOUBLE LOW LINE" #x2017)
+    ("LEFT SINGLE QUOTATION MARK" #x2018)
+    ("RIGHT SINGLE QUOTATION MARK" #x2019)
+    ("SINGLE LOW-9 QUOTATION MARK" #x201A)
+    ("SINGLE HIGH-REVERSED-9 QUOTATION MARK" #x201B)
+    ("LEFT DOUBLE QUOTATION MARK" #x201C)
+    ("RIGHT DOUBLE QUOTATION MARK" #x201D)
+    ("DOUBLE LOW-9 QUOTATION MARK" #x201E)
+    ("DOUBLE HIGH-REVERSED-9 QUOTATION MARK" #x201F)
+    ("DAGGER" #x2020)
+    ("DOUBLE DAGGER" #x2021)
+    ("BULLET" #x2022)
+    ("TRIANGULAR BULLET" #x2023)
+    ("ONE DOT LEADER" #x2024)
+    ("TWO DOT LEADER" #x2025)
+    ("HORIZONTAL ELLIPSIS" #x2026)
+    ("HYPHENATION POINT" #x2027)
+    ("LINE SEPARATOR" #x2028)
+    ("PARAGRAPH SEPARATOR" #x2029)
+    ("LEFT-TO-RIGHT EMBEDDING" #x202A)
+    ("RIGHT-TO-LEFT EMBEDDING" #x202B)
+    ("POP DIRECTIONAL FORMATTING" #x202C)
+    ("LEFT-TO-RIGHT OVERRIDE" #x202D)
+    ("RIGHT-TO-LEFT OVERRIDE" #x202E)
+    ("NARROW NO-BREAK SPACE" #x202F)
+    ("PER MILLE SIGN" #x2030)
+    ("PER TEN THOUSAND SIGN" #x2031)
+    ("PRIME" #x2032)
+    ("DOUBLE PRIME" #x2033)
+    ("TRIPLE PRIME" #x2034)
+    ("REVERSED PRIME" #x2035)
+    ("REVERSED DOUBLE PRIME" #x2036)
+    ("REVERSED TRIPLE PRIME" #x2037)
+    ("CARET" #x2038)
+    ("SINGLE LEFT-POINTING ANGLE QUOTATION MARK" #x2039)
+    ("SINGLE RIGHT-POINTING ANGLE QUOTATION MARK" #x203A)
+    ("REFERENCE MARK" #x203B)
+    ("DOUBLE EXCLAMATION MARK" #x203C)
+    ("INTERROBANG" #x203D)
+    ("OVERLINE" #x203E)
+    ("UNDERTIE" #x203F)
+    ("CHARACTER TIE" #x2040)
+    ("CARET INSERTION POINT" #x2041)
+    ("ASTERISM" #x2042)
+    ("HYPHEN BULLET" #x2043)
+    ("FRACTION SLASH" #x2044)
+    ("LEFT SQUARE BRACKET WITH QUILL" #x2045)
+    ("RIGHT SQUARE BRACKET WITH QUILL" #x2046)
+    ("DOUBLE QUESTION MARK" #x2047)
+    ("QUESTION EXCLAMATION MARK" #x2048)
+    ("EXCLAMATION QUESTION MARK" #x2049)
+    ("TIRONIAN SIGN ET" #x204A)
+    ("REVERSED PILCROW SIGN" #x204B)
+    ("BLACK LEFTWARDS BULLET" #x204C)
+    ("BLACK RIGHTWARDS BULLET" #x204D)
+    ("LOW ASTERISK" #x204E)
+    ("REVERSED SEMICOLON" #x204F)
+    ("CLOSE UP" #x2050)
+    ("TWO ASTERISKS ALIGNED VERTICALLY" #x2051)
+    ("COMMERCIAL MINUS SIGN" #x2052)
+    ("QUADRUPLE PRIME" #x2057)
+    ("MEDIUM MATHEMATICAL SPACE" #x205F)
+    ("WORD JOINER" #x2060)
+    ("FUNCTION APPLICATION" #x2061)
+    ("INVISIBLE TIMES" #x2062)
+    ("INVISIBLE SEPARATOR" #x2063)
+    ("INHIBIT SYMMETRIC SWAPPING" #x206A)
+    ("ACTIVATE SYMMETRIC SWAPPING" #x206B)
+    ("INHIBIT ARABIC FORM SHAPING" #x206C)
+    ("ACTIVATE ARABIC FORM SHAPING" #x206D)
+    ("NATIONAL DIGIT SHAPES" #x206E)
+    ("NOMINAL DIGIT SHAPES" #x206F)
+    ))
diff --git a/lisp/nxml/char-name/unicode/02070-0209F.el b/lisp/nxml/char-name/unicode/02070-0209F.el
new file mode 100644
index 00000000000..5d37880fd62
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/02070-0209F.el
@@ -0,0 +1,31 @@
+(nxml-define-char-name-set 'superscripts-and-subscripts
+  '(("SUPERSCRIPT ZERO" #x2070)
+    ("SUPERSCRIPT LATIN SMALL LETTER I" #x2071)
+    ("SUPERSCRIPT FOUR" #x2074)
+    ("SUPERSCRIPT FIVE" #x2075)
+    ("SUPERSCRIPT SIX" #x2076)
+    ("SUPERSCRIPT SEVEN" #x2077)
+    ("SUPERSCRIPT EIGHT" #x2078)
+    ("SUPERSCRIPT NINE" #x2079)
+    ("SUPERSCRIPT PLUS SIGN" #x207A)
+    ("SUPERSCRIPT MINUS" #x207B)
+    ("SUPERSCRIPT EQUALS SIGN" #x207C)
+    ("SUPERSCRIPT LEFT PARENTHESIS" #x207D)
+    ("SUPERSCRIPT RIGHT PARENTHESIS" #x207E)
+    ("SUPERSCRIPT LATIN SMALL LETTER N" #x207F)
+    ("SUBSCRIPT ZERO" #x2080)
+    ("SUBSCRIPT ONE" #x2081)
+    ("SUBSCRIPT TWO" #x2082)
+    ("SUBSCRIPT THREE" #x2083)
+    ("SUBSCRIPT FOUR" #x2084)
+    ("SUBSCRIPT FIVE" #x2085)
+    ("SUBSCRIPT SIX" #x2086)
+    ("SUBSCRIPT SEVEN" #x2087)
+    ("SUBSCRIPT EIGHT" #x2088)
+    ("SUBSCRIPT NINE" #x2089)
+    ("SUBSCRIPT PLUS SIGN" #x208A)
+    ("SUBSCRIPT MINUS" #x208B)
+    ("SUBSCRIPT EQUALS SIGN" #x208C)
+    ("SUBSCRIPT LEFT PARENTHESIS" #x208D)
+    ("SUBSCRIPT RIGHT PARENTHESIS" #x208E)
+    ))
diff --git a/lisp/nxml/char-name/unicode/020A0-020CF.el b/lisp/nxml/char-name/unicode/020A0-020CF.el
new file mode 100644
index 00000000000..1cab37edcbc
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/020A0-020CF.el
@@ -0,0 +1,20 @@
+(nxml-define-char-name-set 'currency-symbols
+  '(("EURO-CURRENCY SIGN" #x20A0)
+    ("COLON SIGN" #x20A1)
+    ("CRUZEIRO SIGN" #x20A2)
+    ("FRENCH FRANC SIGN" #x20A3)
+    ("LIRA SIGN" #x20A4)
+    ("MILL SIGN" #x20A5)
+    ("NAIRA SIGN" #x20A6)
+    ("PESETA SIGN" #x20A7)
+    ("RUPEE SIGN" #x20A8)
+    ("WON SIGN" #x20A9)
+    ("NEW SHEQEL SIGN" #x20AA)
+    ("DONG SIGN" #x20AB)
+    ("EURO SIGN" #x20AC)
+    ("KIP SIGN" #x20AD)
+    ("TUGRIK SIGN" #x20AE)
+    ("DRACHMA SIGN" #x20AF)
+    ("GERMAN PENNY SIGN" #x20B0)
+    ("PESO SIGN" #x20B1)
+    ))
diff --git a/lisp/nxml/char-name/unicode/020D0-020FF.el b/lisp/nxml/char-name/unicode/020D0-020FF.el
new file mode 100644
index 00000000000..e610d399d49
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/020D0-020FF.el
@@ -0,0 +1,29 @@
+(nxml-define-char-name-set 'combining-diacritical-marks-for-symbols
+  '(("COMBINING LEFT HARPOON ABOVE" #x20D0)
+    ("COMBINING RIGHT HARPOON ABOVE" #x20D1)
+    ("COMBINING LONG VERTICAL LINE OVERLAY" #x20D2)
+    ("COMBINING SHORT VERTICAL LINE OVERLAY" #x20D3)
+    ("COMBINING ANTICLOCKWISE ARROW ABOVE" #x20D4)
+    ("COMBINING CLOCKWISE ARROW ABOVE" #x20D5)
+    ("COMBINING LEFT ARROW ABOVE" #x20D6)
+    ("COMBINING RIGHT ARROW ABOVE" #x20D7)
+    ("COMBINING RING OVERLAY" #x20D8)
+    ("COMBINING CLOCKWISE RING OVERLAY" #x20D9)
+    ("COMBINING ANTICLOCKWISE RING OVERLAY" #x20DA)
+    ("COMBINING THREE DOTS ABOVE" #x20DB)
+    ("COMBINING FOUR DOTS ABOVE" #x20DC)
+    ("COMBINING ENCLOSING CIRCLE" #x20DD)
+    ("COMBINING ENCLOSING SQUARE" #x20DE)
+    ("COMBINING ENCLOSING DIAMOND" #x20DF)
+    ("COMBINING ENCLOSING CIRCLE BACKSLASH" #x20E0)
+    ("COMBINING LEFT RIGHT ARROW ABOVE" #x20E1)
+    ("COMBINING ENCLOSING SCREEN" #x20E2)
+    ("COMBINING ENCLOSING KEYCAP" #x20E3)
+    ("COMBINING ENCLOSING UPWARD POINTING TRIANGLE" #x20E4)
+    ("COMBINING REVERSE SOLIDUS OVERLAY" #x20E5)
+    ("COMBINING DOUBLE VERTICAL STROKE OVERLAY" #x20E6)
+    ("COMBINING ANNUITY SYMBOL" #x20E7)
+    ("COMBINING TRIPLE UNDERDOT" #x20E8)
+    ("COMBINING WIDE BRIDGE ABOVE" #x20E9)
+    ("COMBINING LEFTWARDS ARROW OVERLAY" #x20EA)
+    ))
diff --git a/lisp/nxml/char-name/unicode/02100-0214F.el b/lisp/nxml/char-name/unicode/02100-0214F.el
new file mode 100644
index 00000000000..bdf929f6544
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/02100-0214F.el
@@ -0,0 +1,76 @@
+(nxml-define-char-name-set 'letterlike-symbols
+  '(("ACCOUNT OF" #x2100)
+    ("ADDRESSED TO THE SUBJECT" #x2101)
+    ("DOUBLE-STRUCK CAPITAL C" #x2102)
+    ("DEGREE CELSIUS" #x2103)
+    ("CENTRE LINE SYMBOL" #x2104)
+    ("CARE OF" #x2105)
+    ("CADA UNA" #x2106)
+    ("EULER CONSTANT" #x2107)
+    ("SCRUPLE" #x2108)
+    ("DEGREE FAHRENHEIT" #x2109)
+    ("SCRIPT SMALL G" #x210A)
+    ("SCRIPT CAPITAL H" #x210B)
+    ("BLACK-LETTER CAPITAL H" #x210C)
+    ("DOUBLE-STRUCK CAPITAL H" #x210D)
+    ("PLANCK CONSTANT" #x210E)
+    ("PLANCK CONSTANT OVER TWO PI" #x210F)
+    ("SCRIPT CAPITAL I" #x2110)
+    ("BLACK-LETTER CAPITAL I" #x2111)
+    ("SCRIPT CAPITAL L" #x2112)
+    ("SCRIPT SMALL L" #x2113)
+    ("L B BAR SYMBOL" #x2114)
+    ("DOUBLE-STRUCK CAPITAL N" #x2115)
+    ("NUMERO SIGN" #x2116)
+    ("SOUND RECORDING COPYRIGHT" #x2117)
+    ("SCRIPT CAPITAL P" #x2118)
+    ("DOUBLE-STRUCK CAPITAL P" #x2119)
+    ("DOUBLE-STRUCK CAPITAL Q" #x211A)
+    ("SCRIPT CAPITAL R" #x211B)
+    ("BLACK-LETTER CAPITAL R" #x211C)
+    ("DOUBLE-STRUCK CAPITAL R" #x211D)
+    ("PRESCRIPTION TAKE" #x211E)
+    ("RESPONSE" #x211F)
+    ("SERVICE MARK" #x2120)
+    ("TELEPHONE SIGN" #x2121)
+    ("TRADE MARK SIGN" #x2122)
+    ("VERSICLE" #x2123)
+    ("DOUBLE-STRUCK CAPITAL Z" #x2124)
+    ("OUNCE SIGN" #x2125)
+    ("OHM SIGN" #x2126)
+    ("INVERTED OHM SIGN" #x2127)
+    ("BLACK-LETTER CAPITAL Z" #x2128)
+    ("TURNED GREEK SMALL LETTER IOTA" #x2129)
+    ("KELVIN SIGN" #x212A)
+    ("ANGSTROM SIGN" #x212B)
+    ("SCRIPT CAPITAL B" #x212C)
+    ("BLACK-LETTER CAPITAL C" #x212D)
+    ("ESTIMATED SYMBOL" #x212E)
+    ("SCRIPT SMALL E" #x212F)
+    ("SCRIPT CAPITAL E" #x2130)
+    ("SCRIPT CAPITAL F" #x2131)
+    ("TURNED CAPITAL F" #x2132)
+    ("SCRIPT CAPITAL M" #x2133)
+    ("SCRIPT SMALL O" #x2134)
+    ("ALEF SYMBOL" #x2135)
+    ("BET SYMBOL" #x2136)
+    ("GIMEL SYMBOL" #x2137)
+    ("DALET SYMBOL" #x2138)
+    ("INFORMATION SOURCE" #x2139)
+    ("ROTATED CAPITAL Q" #x213A)
+    ("DOUBLE-STRUCK SMALL GAMMA" #x213D)
+    ("DOUBLE-STRUCK CAPITAL GAMMA" #x213E)
+    ("DOUBLE-STRUCK CAPITAL PI" #x213F)
+    ("DOUBLE-STRUCK N-ARY SUMMATION" #x2140)
+    ("TURNED SANS-SERIF CAPITAL G" #x2141)
+    ("TURNED SANS-SERIF CAPITAL L" #x2142)
+    ("REVERSED SANS-SERIF CAPITAL L" #x2143)
+    ("TURNED SANS-SERIF CAPITAL Y" #x2144)
+    ("DOUBLE-STRUCK ITALIC CAPITAL D" #x2145)
+    ("DOUBLE-STRUCK ITALIC SMALL D" #x2146)
+    ("DOUBLE-STRUCK ITALIC SMALL E" #x2147)
+    ("DOUBLE-STRUCK ITALIC SMALL I" #x2148)
+    ("DOUBLE-STRUCK ITALIC SMALL J" #x2149)
+    ("PROPERTY LINE" #x214A)
+    ("TURNED AMPERSAND" #x214B)
+    ))
diff --git a/lisp/nxml/char-name/unicode/02150-0218F.el b/lisp/nxml/char-name/unicode/02150-0218F.el
new file mode 100644
index 00000000000..4300c497803
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/02150-0218F.el
@@ -0,0 +1,51 @@
+(nxml-define-char-name-set 'number-forms
+  '(("VULGAR FRACTION ONE THIRD" #x2153)
+    ("VULGAR FRACTION TWO THIRDS" #x2154)
+    ("VULGAR FRACTION ONE FIFTH" #x2155)
+    ("VULGAR FRACTION TWO FIFTHS" #x2156)
+    ("VULGAR FRACTION THREE FIFTHS" #x2157)
+    ("VULGAR FRACTION FOUR FIFTHS" #x2158)
+    ("VULGAR FRACTION ONE SIXTH" #x2159)
+    ("VULGAR FRACTION FIVE SIXTHS" #x215A)
+    ("VULGAR FRACTION ONE EIGHTH" #x215B)
+    ("VULGAR FRACTION THREE EIGHTHS" #x215C)
+    ("VULGAR FRACTION FIVE EIGHTHS" #x215D)
+    ("VULGAR FRACTION SEVEN EIGHTHS" #x215E)
+    ("FRACTION NUMERATOR ONE" #x215F)
+    ("ROMAN NUMERAL ONE" #x2160)
+    ("ROMAN NUMERAL TWO" #x2161)
+    ("ROMAN NUMERAL THREE" #x2162)
+    ("ROMAN NUMERAL FOUR" #x2163)
+    ("ROMAN NUMERAL FIVE" #x2164)
+    ("ROMAN NUMERAL SIX" #x2165)
+    ("ROMAN NUMERAL SEVEN" #x2166)
+    ("ROMAN NUMERAL EIGHT" #x2167)
+    ("ROMAN NUMERAL NINE" #x2168)
+    ("ROMAN NUMERAL TEN" #x2169)
+    ("ROMAN NUMERAL ELEVEN" #x216A)
+    ("ROMAN NUMERAL TWELVE" #x216B)
+    ("ROMAN NUMERAL FIFTY" #x216C)
+    ("ROMAN NUMERAL ONE HUNDRED" #x216D)
+    ("ROMAN NUMERAL FIVE HUNDRED" #x216E)
+    ("ROMAN NUMERAL ONE THOUSAND" #x216F)
+    ("SMALL ROMAN NUMERAL ONE" #x2170)
+    ("SMALL ROMAN NUMERAL TWO" #x2171)
+    ("SMALL ROMAN NUMERAL THREE" #x2172)
+    ("SMALL ROMAN NUMERAL FOUR" #x2173)
+    ("SMALL ROMAN NUMERAL FIVE" #x2174)
+    ("SMALL ROMAN NUMERAL SIX" #x2175)
+    ("SMALL ROMAN NUMERAL SEVEN" #x2176)
+    ("SMALL ROMAN NUMERAL EIGHT" #x2177)
+    ("SMALL ROMAN NUMERAL NINE" #x2178)
+    ("SMALL ROMAN NUMERAL TEN" #x2179)
+    ("SMALL ROMAN NUMERAL ELEVEN" #x217A)
+    ("SMALL ROMAN NUMERAL TWELVE" #x217B)
+    ("SMALL ROMAN NUMERAL FIFTY" #x217C)
+    ("SMALL ROMAN NUMERAL ONE HUNDRED" #x217D)
+    ("SMALL ROMAN NUMERAL FIVE HUNDRED" #x217E)
+    ("SMALL ROMAN NUMERAL ONE THOUSAND" #x217F)
+    ("ROMAN NUMERAL ONE THOUSAND C D" #x2180)
+    ("ROMAN NUMERAL FIVE THOUSAND" #x2181)
+    ("ROMAN NUMERAL TEN THOUSAND" #x2182)
+    ("ROMAN NUMERAL REVERSED ONE HUNDRED" #x2183)
+    ))
diff --git a/lisp/nxml/char-name/unicode/02190-021FF.el b/lisp/nxml/char-name/unicode/02190-021FF.el
new file mode 100644
index 00000000000..88989ed7b63
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/02190-021FF.el
@@ -0,0 +1,114 @@
+(nxml-define-char-name-set 'arrows
+  '(("LEFTWARDS ARROW" #x2190)
+    ("UPWARDS ARROW" #x2191)
+    ("RIGHTWARDS ARROW" #x2192)
+    ("DOWNWARDS ARROW" #x2193)
+    ("LEFT RIGHT ARROW" #x2194)
+    ("UP DOWN ARROW" #x2195)
+    ("NORTH WEST ARROW" #x2196)
+    ("NORTH EAST ARROW" #x2197)
+    ("SOUTH EAST ARROW" #x2198)
+    ("SOUTH WEST ARROW" #x2199)
+    ("LEFTWARDS ARROW WITH STROKE" #x219A)
+    ("RIGHTWARDS ARROW WITH STROKE" #x219B)
+    ("LEFTWARDS WAVE ARROW" #x219C)
+    ("RIGHTWARDS WAVE ARROW" #x219D)
+    ("LEFTWARDS TWO HEADED ARROW" #x219E)
+    ("UPWARDS TWO HEADED ARROW" #x219F)
+    ("RIGHTWARDS TWO HEADED ARROW" #x21A0)
+    ("DOWNWARDS TWO HEADED ARROW" #x21A1)
+    ("LEFTWARDS ARROW WITH TAIL" #x21A2)
+    ("RIGHTWARDS ARROW WITH TAIL" #x21A3)
+    ("LEFTWARDS ARROW FROM BAR" #x21A4)
+    ("UPWARDS ARROW FROM BAR" #x21A5)
+    ("RIGHTWARDS ARROW FROM BAR" #x21A6)
+    ("DOWNWARDS ARROW FROM BAR" #x21A7)
+    ("UP DOWN ARROW WITH BASE" #x21A8)
+    ("LEFTWARDS ARROW WITH HOOK" #x21A9)
+    ("RIGHTWARDS ARROW WITH HOOK" #x21AA)
+    ("LEFTWARDS ARROW WITH LOOP" #x21AB)
+    ("RIGHTWARDS ARROW WITH LOOP" #x21AC)
+    ("LEFT RIGHT WAVE ARROW" #x21AD)
+    ("LEFT RIGHT ARROW WITH STROKE" #x21AE)
+    ("DOWNWARDS ZIGZAG ARROW" #x21AF)
+    ("UPWARDS ARROW WITH TIP LEFTWARDS" #x21B0)
+    ("UPWARDS ARROW WITH TIP RIGHTWARDS" #x21B1)
+    ("DOWNWARDS ARROW WITH TIP LEFTWARDS" #x21B2)
+    ("DOWNWARDS ARROW WITH TIP RIGHTWARDS" #x21B3)
+    ("RIGHTWARDS ARROW WITH CORNER DOWNWARDS" #x21B4)
+    ("DOWNWARDS ARROW WITH CORNER LEFTWARDS" #x21B5)
+    ("ANTICLOCKWISE TOP SEMICIRCLE ARROW" #x21B6)
+    ("CLOCKWISE TOP SEMICIRCLE ARROW" #x21B7)
+    ("NORTH WEST ARROW TO LONG BAR" #x21B8)
+    ("LEFTWARDS ARROW TO BAR OVER RIGHTWARDS ARROW TO BAR" #x21B9)
+    ("ANTICLOCKWISE OPEN CIRCLE ARROW" #x21BA)
+    ("CLOCKWISE OPEN CIRCLE ARROW" #x21BB)
+    ("LEFTWARDS HARPOON WITH BARB UPWARDS" #x21BC)
+    ("LEFTWARDS HARPOON WITH BARB DOWNWARDS" #x21BD)
+    ("UPWARDS HARPOON WITH BARB RIGHTWARDS" #x21BE)
+    ("UPWARDS HARPOON WITH BARB LEFTWARDS" #x21BF)
+    ("RIGHTWARDS HARPOON WITH BARB UPWARDS" #x21C0)
+    ("RIGHTWARDS HARPOON WITH BARB DOWNWARDS" #x21C1)
+    ("DOWNWARDS HARPOON WITH BARB RIGHTWARDS" #x21C2)
+    ("DOWNWARDS HARPOON WITH BARB LEFTWARDS" #x21C3)
+    ("RIGHTWARDS ARROW OVER LEFTWARDS ARROW" #x21C4)
+    ("UPWARDS ARROW LEFTWARDS OF DOWNWARDS ARROW" #x21C5)
+    ("LEFTWARDS ARROW OVER RIGHTWARDS ARROW" #x21C6)
+    ("LEFTWARDS PAIRED ARROWS" #x21C7)
+    ("UPWARDS PAIRED ARROWS" #x21C8)
+    ("RIGHTWARDS PAIRED ARROWS" #x21C9)
+    ("DOWNWARDS PAIRED ARROWS" #x21CA)
+    ("LEFTWARDS HARPOON OVER RIGHTWARDS HARPOON" #x21CB)
+    ("RIGHTWARDS HARPOON OVER LEFTWARDS HARPOON" #x21CC)
+    ("LEFTWARDS DOUBLE ARROW WITH STROKE" #x21CD)
+    ("LEFT RIGHT DOUBLE ARROW WITH STROKE" #x21CE)
+    ("RIGHTWARDS DOUBLE ARROW WITH STROKE" #x21CF)
+    ("LEFTWARDS DOUBLE ARROW" #x21D0)
+    ("UPWARDS DOUBLE ARROW" #x21D1)
+    ("RIGHTWARDS DOUBLE ARROW" #x21D2)
+    ("DOWNWARDS DOUBLE ARROW" #x21D3)
+    ("LEFT RIGHT DOUBLE ARROW" #x21D4)
+    ("UP DOWN DOUBLE ARROW" #x21D5)
+    ("NORTH WEST DOUBLE ARROW" #x21D6)
+    ("NORTH EAST DOUBLE ARROW" #x21D7)
+    ("SOUTH EAST DOUBLE ARROW" #x21D8)
+    ("SOUTH WEST DOUBLE ARROW" #x21D9)
+    ("LEFTWARDS TRIPLE ARROW" #x21DA)
+    ("RIGHTWARDS TRIPLE ARROW" #x21DB)
+    ("LEFTWARDS SQUIGGLE ARROW" #x21DC)
+    ("RIGHTWARDS SQUIGGLE ARROW" #x21DD)
+    ("UPWARDS ARROW WITH DOUBLE STROKE" #x21DE)
+    ("DOWNWARDS ARROW WITH DOUBLE STROKE" #x21DF)
+    ("LEFTWARDS DASHED ARROW" #x21E0)
+    ("UPWARDS DASHED ARROW" #x21E1)
+    ("RIGHTWARDS DASHED ARROW" #x21E2)
+    ("DOWNWARDS DASHED ARROW" #x21E3)
+    ("LEFTWARDS ARROW TO BAR" #x21E4)
+    ("RIGHTWARDS ARROW TO BAR" #x21E5)
+    ("LEFTWARDS WHITE ARROW" #x21E6)
+    ("UPWARDS WHITE ARROW" #x21E7)
+    ("RIGHTWARDS WHITE ARROW" #x21E8)
+    ("DOWNWARDS WHITE ARROW" #x21E9)
+    ("UPWARDS WHITE ARROW FROM BAR" #x21EA)
+    ("UPWARDS WHITE ARROW ON PEDESTAL" #x21EB)
+    ("UPWARDS WHITE ARROW ON PEDESTAL WITH HORIZONTAL BAR" #x21EC)
+    ("UPWARDS WHITE ARROW ON PEDESTAL WITH VERTICAL BAR" #x21ED)
+    ("UPWARDS WHITE DOUBLE ARROW" #x21EE)
+    ("UPWARDS WHITE DOUBLE ARROW ON PEDESTAL" #x21EF)
+    ("RIGHTWARDS WHITE ARROW FROM WALL" #x21F0)
+    ("NORTH WEST ARROW TO CORNER" #x21F1)
+    ("SOUTH EAST ARROW TO CORNER" #x21F2)
+    ("UP DOWN WHITE ARROW" #x21F3)
+    ("RIGHT ARROW WITH SMALL CIRCLE" #x21F4)
+    ("DOWNWARDS ARROW LEFTWARDS OF UPWARDS ARROW" #x21F5)
+    ("THREE RIGHTWARDS ARROWS" #x21F6)
+    ("LEFTWARDS ARROW WITH VERTICAL STROKE" #x21F7)
+    ("RIGHTWARDS ARROW WITH VERTICAL STROKE" #x21F8)
+    ("LEFT RIGHT ARROW WITH VERTICAL STROKE" #x21F9)
+    ("LEFTWARDS ARROW WITH DOUBLE VERTICAL STROKE" #x21FA)
+    ("RIGHTWARDS ARROW WITH DOUBLE VERTICAL STROKE" #x21FB)
+    ("LEFT RIGHT ARROW WITH DOUBLE VERTICAL STROKE" #x21FC)
+    ("LEFTWARDS OPEN-HEADED ARROW" #x21FD)
+    ("RIGHTWARDS OPEN-HEADED ARROW" #x21FE)
+    ("LEFT RIGHT OPEN-HEADED ARROW" #x21FF)
+    ))
diff --git a/lisp/nxml/char-name/unicode/02200-022FF.el b/lisp/nxml/char-name/unicode/02200-022FF.el
new file mode 100644
index 00000000000..a28f77853db
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/02200-022FF.el
@@ -0,0 +1,258 @@
+(nxml-define-char-name-set 'mathematical-operators
+  '(("FOR ALL" #x2200)
+    ("COMPLEMENT" #x2201)
+    ("PARTIAL DIFFERENTIAL" #x2202)
+    ("THERE EXISTS" #x2203)
+    ("THERE DOES NOT EXIST" #x2204)
+    ("EMPTY SET" #x2205)
+    ("INCREMENT" #x2206)
+    ("NABLA" #x2207)
+    ("ELEMENT OF" #x2208)
+    ("NOT AN ELEMENT OF" #x2209)
+    ("SMALL ELEMENT OF" #x220A)
+    ("CONTAINS AS MEMBER" #x220B)
+    ("DOES NOT CONTAIN AS MEMBER" #x220C)
+    ("SMALL CONTAINS AS MEMBER" #x220D)
+    ("END OF PROOF" #x220E)
+    ("N-ARY PRODUCT" #x220F)
+    ("N-ARY COPRODUCT" #x2210)
+    ("N-ARY SUMMATION" #x2211)
+    ("MINUS SIGN" #x2212)
+    ("MINUS-OR-PLUS SIGN" #x2213)
+    ("DOT PLUS" #x2214)
+    ("DIVISION SLASH" #x2215)
+    ("SET MINUS" #x2216)
+    ("ASTERISK OPERATOR" #x2217)
+    ("RING OPERATOR" #x2218)
+    ("BULLET OPERATOR" #x2219)
+    ("SQUARE ROOT" #x221A)
+    ("CUBE ROOT" #x221B)
+    ("FOURTH ROOT" #x221C)
+    ("PROPORTIONAL TO" #x221D)
+    ("INFINITY" #x221E)
+    ("RIGHT ANGLE" #x221F)
+    ("ANGLE" #x2220)
+    ("MEASURED ANGLE" #x2221)
+    ("SPHERICAL ANGLE" #x2222)
+    ("DIVIDES" #x2223)
+    ("DOES NOT DIVIDE" #x2224)
+    ("PARALLEL TO" #x2225)
+    ("NOT PARALLEL TO" #x2226)
+    ("LOGICAL AND" #x2227)
+    ("LOGICAL OR" #x2228)
+    ("INTERSECTION" #x2229)
+    ("UNION" #x222A)
+    ("INTEGRAL" #x222B)
+    ("DOUBLE INTEGRAL" #x222C)
+    ("TRIPLE INTEGRAL" #x222D)
+    ("CONTOUR INTEGRAL" #x222E)
+    ("SURFACE INTEGRAL" #x222F)
+    ("VOLUME INTEGRAL" #x2230)
+    ("CLOCKWISE INTEGRAL" #x2231)
+    ("CLOCKWISE CONTOUR INTEGRAL" #x2232)
+    ("ANTICLOCKWISE CONTOUR INTEGRAL" #x2233)
+    ("THEREFORE" #x2234)
+    ("BECAUSE" #x2235)
+    ("RATIO" #x2236)
+    ("PROPORTION" #x2237)
+    ("DOT MINUS" #x2238)
+    ("EXCESS" #x2239)
+    ("GEOMETRIC PROPORTION" #x223A)
+    ("HOMOTHETIC" #x223B)
+    ("TILDE OPERATOR" #x223C)
+    ("REVERSED TILDE" #x223D)
+    ("INVERTED LAZY S" #x223E)
+    ("SINE WAVE" #x223F)
+    ("WREATH PRODUCT" #x2240)
+    ("NOT TILDE" #x2241)
+    ("MINUS TILDE" #x2242)
+    ("ASYMPTOTICALLY EQUAL TO" #x2243)
+    ("NOT ASYMPTOTICALLY EQUAL TO" #x2244)
+    ("APPROXIMATELY EQUAL TO" #x2245)
+    ("APPROXIMATELY BUT NOT ACTUALLY EQUAL TO" #x2246)
+    ("NEITHER APPROXIMATELY NOR ACTUALLY EQUAL TO" #x2247)
+    ("ALMOST EQUAL TO" #x2248)
+    ("NOT ALMOST EQUAL TO" #x2249)
+    ("ALMOST EQUAL OR EQUAL TO" #x224A)
+    ("TRIPLE TILDE" #x224B)
+    ("ALL EQUAL TO" #x224C)
+    ("EQUIVALENT TO" #x224D)
+    ("GEOMETRICALLY EQUIVALENT TO" #x224E)
+    ("DIFFERENCE BETWEEN" #x224F)
+    ("APPROACHES THE LIMIT" #x2250)
+    ("GEOMETRICALLY EQUAL TO" #x2251)
+    ("APPROXIMATELY EQUAL TO OR THE IMAGE OF" #x2252)
+    ("IMAGE OF OR APPROXIMATELY EQUAL TO" #x2253)
+    ("COLON EQUALS" #x2254)
+    ("EQUALS COLON" #x2255)
+    ("RING IN EQUAL TO" #x2256)
+    ("RING EQUAL TO" #x2257)
+    ("CORRESPONDS TO" #x2258)
+    ("ESTIMATES" #x2259)
+    ("EQUIANGULAR TO" #x225A)
+    ("STAR EQUALS" #x225B)
+    ("DELTA EQUAL TO" #x225C)
+    ("EQUAL TO BY DEFINITION" #x225D)
+    ("MEASURED BY" #x225E)
+    ("QUESTIONED EQUAL TO" #x225F)
+    ("NOT EQUAL TO" #x2260)
+    ("IDENTICAL TO" #x2261)
+    ("NOT IDENTICAL TO" #x2262)
+    ("STRICTLY EQUIVALENT TO" #x2263)
+    ("LESS-THAN OR EQUAL TO" #x2264)
+    ("GREATER-THAN OR EQUAL TO" #x2265)
+    ("LESS-THAN OVER EQUAL TO" #x2266)
+    ("GREATER-THAN OVER EQUAL TO" #x2267)
+    ("LESS-THAN BUT NOT EQUAL TO" #x2268)
+    ("GREATER-THAN BUT NOT EQUAL TO" #x2269)
+    ("MUCH LESS-THAN" #x226A)
+    ("MUCH GREATER-THAN" #x226B)
+    ("BETWEEN" #x226C)
+    ("NOT EQUIVALENT TO" #x226D)
+    ("NOT LESS-THAN" #x226E)
+    ("NOT GREATER-THAN" #x226F)
+    ("NEITHER LESS-THAN NOR EQUAL TO" #x2270)
+    ("NEITHER GREATER-THAN NOR EQUAL TO" #x2271)
+    ("LESS-THAN OR EQUIVALENT TO" #x2272)
+    ("GREATER-THAN OR EQUIVALENT TO" #x2273)
+    ("NEITHER LESS-THAN NOR EQUIVALENT TO" #x2274)
+    ("NEITHER GREATER-THAN NOR EQUIVALENT TO" #x2275)
+    ("LESS-THAN OR GREATER-THAN" #x2276)
+    ("GREATER-THAN OR LESS-THAN" #x2277)
+    ("NEITHER LESS-THAN NOR GREATER-THAN" #x2278)
+    ("NEITHER GREATER-THAN NOR LESS-THAN" #x2279)
+    ("PRECEDES" #x227A)
+    ("SUCCEEDS" #x227B)
+    ("PRECEDES OR EQUAL TO" #x227C)
+    ("SUCCEEDS OR EQUAL TO" #x227D)
+    ("PRECEDES OR EQUIVALENT TO" #x227E)
+    ("SUCCEEDS OR EQUIVALENT TO" #x227F)
+    ("DOES NOT PRECEDE" #x2280)
+    ("DOES NOT SUCCEED" #x2281)
+    ("SUBSET OF" #x2282)
+    ("SUPERSET OF" #x2283)
+    ("NOT A SUBSET OF" #x2284)
+    ("NOT A SUPERSET OF" #x2285)
+    ("SUBSET OF OR EQUAL TO" #x2286)
+    ("SUPERSET OF OR EQUAL TO" #x2287)
+    ("NEITHER A SUBSET OF NOR EQUAL TO" #x2288)
+    ("NEITHER A SUPERSET OF NOR EQUAL TO" #x2289)
+    ("SUBSET OF WITH NOT EQUAL TO" #x228A)
+    ("SUPERSET OF WITH NOT EQUAL TO" #x228B)
+    ("MULTISET" #x228C)
+    ("MULTISET MULTIPLICATION" #x228D)
+    ("MULTISET UNION" #x228E)
+    ("SQUARE IMAGE OF" #x228F)
+    ("SQUARE ORIGINAL OF" #x2290)
+    ("SQUARE IMAGE OF OR EQUAL TO" #x2291)
+    ("SQUARE ORIGINAL OF OR EQUAL TO" #x2292)
+    ("SQUARE CAP" #x2293)
+    ("SQUARE CUP" #x2294)
+    ("CIRCLED PLUS" #x2295)
+    ("CIRCLED MINUS" #x2296)
+    ("CIRCLED TIMES" #x2297)
+    ("CIRCLED DIVISION SLASH" #x2298)
+    ("CIRCLED DOT OPERATOR" #x2299)
+    ("CIRCLED RING OPERATOR" #x229A)
+    ("CIRCLED ASTERISK OPERATOR" #x229B)
+    ("CIRCLED EQUALS" #x229C)
+    ("CIRCLED DASH" #x229D)
+    ("SQUARED PLUS" #x229E)
+    ("SQUARED MINUS" #x229F)
+    ("SQUARED TIMES" #x22A0)
+    ("SQUARED DOT OPERATOR" #x22A1)
+    ("RIGHT TACK" #x22A2)
+    ("LEFT TACK" #x22A3)
+    ("DOWN TACK" #x22A4)
+    ("UP TACK" #x22A5)
+    ("ASSERTION" #x22A6)
+    ("MODELS" #x22A7)
+    ("TRUE" #x22A8)
+    ("FORCES" #x22A9)
+    ("TRIPLE VERTICAL BAR RIGHT TURNSTILE" #x22AA)
+    ("DOUBLE VERTICAL BAR DOUBLE RIGHT TURNSTILE" #x22AB)
+    ("DOES NOT PROVE" #x22AC)
+    ("NOT TRUE" #x22AD)
+    ("DOES NOT FORCE" #x22AE)
+    ("NEGATED DOUBLE VERTICAL BAR DOUBLE RIGHT TURNSTILE" #x22AF)
+    ("PRECEDES UNDER RELATION" #x22B0)
+    ("SUCCEEDS UNDER RELATION" #x22B1)
+    ("NORMAL SUBGROUP OF" #x22B2)
+    ("CONTAINS AS NORMAL SUBGROUP" #x22B3)
+    ("NORMAL SUBGROUP OF OR EQUAL TO" #x22B4)
+    ("CONTAINS AS NORMAL SUBGROUP OR EQUAL TO" #x22B5)
+    ("ORIGINAL OF" #x22B6)
+    ("IMAGE OF" #x22B7)
+    ("MULTIMAP" #x22B8)
+    ("HERMITIAN CONJUGATE MATRIX" #x22B9)
+    ("INTERCALATE" #x22BA)
+    ("XOR" #x22BB)
+    ("NAND" #x22BC)
+    ("NOR" #x22BD)
+    ("RIGHT ANGLE WITH ARC" #x22BE)
+    ("RIGHT TRIANGLE" #x22BF)
+    ("N-ARY LOGICAL AND" #x22C0)
+    ("N-ARY LOGICAL OR" #x22C1)
+    ("N-ARY INTERSECTION" #x22C2)
+    ("N-ARY UNION" #x22C3)
+    ("DIAMOND OPERATOR" #x22C4)
+    ("DOT OPERATOR" #x22C5)
+    ("STAR OPERATOR" #x22C6)
+    ("DIVISION TIMES" #x22C7)
+    ("BOWTIE" #x22C8)
+    ("LEFT NORMAL FACTOR SEMIDIRECT PRODUCT" #x22C9)
+    ("RIGHT NORMAL FACTOR SEMIDIRECT PRODUCT" #x22CA)
+    ("LEFT SEMIDIRECT PRODUCT" #x22CB)
+    ("RIGHT SEMIDIRECT PRODUCT" #x22CC)
+    ("REVERSED TILDE EQUALS" #x22CD)
+    ("CURLY LOGICAL OR" #x22CE)
+    ("CURLY LOGICAL AND" #x22CF)
+    ("DOUBLE SUBSET" #x22D0)
+    ("DOUBLE SUPERSET" #x22D1)
+    ("DOUBLE INTERSECTION" #x22D2)
+    ("DOUBLE UNION" #x22D3)
+    ("PITCHFORK" #x22D4)
+    ("EQUAL AND PARALLEL TO" #x22D5)
+    ("LESS-THAN WITH DOT" #x22D6)
+    ("GREATER-THAN WITH DOT" #x22D7)
+    ("VERY MUCH LESS-THAN" #x22D8)
+    ("VERY MUCH GREATER-THAN" #x22D9)
+    ("LESS-THAN EQUAL TO OR GREATER-THAN" #x22DA)
+    ("GREATER-THAN EQUAL TO OR LESS-THAN" #x22DB)
+    ("EQUAL TO OR LESS-THAN" #x22DC)
+    ("EQUAL TO OR GREATER-THAN" #x22DD)
+    ("EQUAL TO OR PRECEDES" #x22DE)
+    ("EQUAL TO OR SUCCEEDS" #x22DF)
+    ("DOES NOT PRECEDE OR EQUAL" #x22E0)
+    ("DOES NOT SUCCEED OR EQUAL" #x22E1)
+    ("NOT SQUARE IMAGE OF OR EQUAL TO" #x22E2)
+    ("NOT SQUARE ORIGINAL OF OR EQUAL TO" #x22E3)
+    ("SQUARE IMAGE OF OR NOT EQUAL TO" #x22E4)
+    ("SQUARE ORIGINAL OF OR NOT EQUAL TO" #x22E5)
+    ("LESS-THAN BUT NOT EQUIVALENT TO" #x22E6)
+    ("GREATER-THAN BUT NOT EQUIVALENT TO" #x22E7)
+    ("PRECEDES BUT NOT EQUIVALENT TO" #x22E8)
+    ("SUCCEEDS BUT NOT EQUIVALENT TO" #x22E9)
+    ("NOT NORMAL SUBGROUP OF" #x22EA)
+    ("DOES NOT CONTAIN AS NORMAL SUBGROUP" #x22EB)
+    ("NOT NORMAL SUBGROUP OF OR EQUAL TO" #x22EC)
+    ("DOES NOT CONTAIN AS NORMAL SUBGROUP OR EQUAL" #x22ED)
+    ("VERTICAL ELLIPSIS" #x22EE)
+    ("MIDLINE HORIZONTAL ELLIPSIS" #x22EF)
+    ("UP RIGHT DIAGONAL ELLIPSIS" #x22F0)
+    ("DOWN RIGHT DIAGONAL ELLIPSIS" #x22F1)
+    ("ELEMENT OF WITH LONG HORIZONTAL STROKE" #x22F2)
+    ("ELEMENT OF WITH VERTICAL BAR AT END OF HORIZONTAL STROKE" #x22F3)
+    ("SMALL ELEMENT OF WITH VERTICAL BAR AT END OF HORIZONTAL STROKE" #x22F4)
+    ("ELEMENT OF WITH DOT ABOVE" #x22F5)
+    ("ELEMENT OF WITH OVERBAR" #x22F6)
+    ("SMALL ELEMENT OF WITH OVERBAR" #x22F7)
+    ("ELEMENT OF WITH UNDERBAR" #x22F8)
+    ("ELEMENT OF WITH TWO HORIZONTAL STROKES" #x22F9)
+    ("CONTAINS WITH LONG HORIZONTAL STROKE" #x22FA)
+    ("CONTAINS WITH VERTICAL BAR AT END OF HORIZONTAL STROKE" #x22FB)
+    ("SMALL CONTAINS WITH VERTICAL BAR AT END OF HORIZONTAL STROKE" #x22FC)
+    ("CONTAINS WITH OVERBAR" #x22FD)
+    ("SMALL CONTAINS WITH OVERBAR" #x22FE)
+    ("Z NOTATION BAG MEMBERSHIP" #x22FF)
+    ))
diff --git a/lisp/nxml/char-name/unicode/02300-023FF.el b/lisp/nxml/char-name/unicode/02300-023FF.el
new file mode 100644
index 00000000000..a2558948319
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/02300-023FF.el
@@ -0,0 +1,209 @@
+(nxml-define-char-name-set 'miscellaneous-technical
+  '(("DIAMETER SIGN" #x2300)
+    ("ELECTRIC ARROW" #x2301)
+    ("HOUSE" #x2302)
+    ("UP ARROWHEAD" #x2303)
+    ("DOWN ARROWHEAD" #x2304)
+    ("PROJECTIVE" #x2305)
+    ("PERSPECTIVE" #x2306)
+    ("WAVY LINE" #x2307)
+    ("LEFT CEILING" #x2308)
+    ("RIGHT CEILING" #x2309)
+    ("LEFT FLOOR" #x230A)
+    ("RIGHT FLOOR" #x230B)
+    ("BOTTOM RIGHT CROP" #x230C)
+    ("BOTTOM LEFT CROP" #x230D)
+    ("TOP RIGHT CROP" #x230E)
+    ("TOP LEFT CROP" #x230F)
+    ("REVERSED NOT SIGN" #x2310)
+    ("SQUARE LOZENGE" #x2311)
+    ("ARC" #x2312)
+    ("SEGMENT" #x2313)
+    ("SECTOR" #x2314)
+    ("TELEPHONE RECORDER" #x2315)
+    ("POSITION INDICATOR" #x2316)
+    ("VIEWDATA SQUARE" #x2317)
+    ("PLACE OF INTEREST SIGN" #x2318)
+    ("TURNED NOT SIGN" #x2319)
+    ("WATCH" #x231A)
+    ("HOURGLASS" #x231B)
+    ("TOP LEFT CORNER" #x231C)
+    ("TOP RIGHT CORNER" #x231D)
+    ("BOTTOM LEFT CORNER" #x231E)
+    ("BOTTOM RIGHT CORNER" #x231F)
+    ("TOP HALF INTEGRAL" #x2320)
+    ("BOTTOM HALF INTEGRAL" #x2321)
+    ("FROWN" #x2322)
+    ("SMILE" #x2323)
+    ("UP ARROWHEAD BETWEEN TWO HORIZONTAL BARS" #x2324)
+    ("OPTION KEY" #x2325)
+    ("ERASE TO THE RIGHT" #x2326)
+    ("X IN A RECTANGLE BOX" #x2327)
+    ("KEYBOARD" #x2328)
+    ("LEFT-POINTING ANGLE BRACKET" #x2329)
+    ("RIGHT-POINTING ANGLE BRACKET" #x232A)
+    ("ERASE TO THE LEFT" #x232B)
+    ("BENZENE RING" #x232C)
+    ("CYLINDRICITY" #x232D)
+    ("ALL AROUND-PROFILE" #x232E)
+    ("SYMMETRY" #x232F)
+    ("TOTAL RUNOUT" #x2330)
+    ("DIMENSION ORIGIN" #x2331)
+    ("CONICAL TAPER" #x2332)
+    ("SLOPE" #x2333)
+    ("COUNTERBORE" #x2334)
+    ("COUNTERSINK" #x2335)
+    ("APL FUNCTIONAL SYMBOL I-BEAM" #x2336)
+    ("APL FUNCTIONAL SYMBOL SQUISH QUAD" #x2337)
+    ("APL FUNCTIONAL SYMBOL QUAD EQUAL" #x2338)
+    ("APL FUNCTIONAL SYMBOL QUAD DIVIDE" #x2339)
+    ("APL FUNCTIONAL SYMBOL QUAD DIAMOND" #x233A)
+    ("APL FUNCTIONAL SYMBOL QUAD JOT" #x233B)
+    ("APL FUNCTIONAL SYMBOL QUAD CIRCLE" #x233C)
+    ("APL FUNCTIONAL SYMBOL CIRCLE STILE" #x233D)
+    ("APL FUNCTIONAL SYMBOL CIRCLE JOT" #x233E)
+    ("APL FUNCTIONAL SYMBOL SLASH BAR" #x233F)
+    ("APL FUNCTIONAL SYMBOL BACKSLASH BAR" #x2340)
+    ("APL FUNCTIONAL SYMBOL QUAD SLASH" #x2341)
+    ("APL FUNCTIONAL SYMBOL QUAD BACKSLASH" #x2342)
+    ("APL FUNCTIONAL SYMBOL QUAD LESS-THAN" #x2343)
+    ("APL FUNCTIONAL SYMBOL QUAD GREATER-THAN" #x2344)
+    ("APL FUNCTIONAL SYMBOL LEFTWARDS VANE" #x2345)
+    ("APL FUNCTIONAL SYMBOL RIGHTWARDS VANE" #x2346)
+    ("APL FUNCTIONAL SYMBOL QUAD LEFTWARDS ARROW" #x2347)
+    ("APL FUNCTIONAL SYMBOL QUAD RIGHTWARDS ARROW" #x2348)
+    ("APL FUNCTIONAL SYMBOL CIRCLE BACKSLASH" #x2349)
+    ("APL FUNCTIONAL SYMBOL DOWN TACK UNDERBAR" #x234A)
+    ("APL FUNCTIONAL SYMBOL DELTA STILE" #x234B)
+    ("APL FUNCTIONAL SYMBOL QUAD DOWN CARET" #x234C)
+    ("APL FUNCTIONAL SYMBOL QUAD DELTA" #x234D)
+    ("APL FUNCTIONAL SYMBOL DOWN TACK JOT" #x234E)
+    ("APL FUNCTIONAL SYMBOL UPWARDS VANE" #x234F)
+    ("APL FUNCTIONAL SYMBOL QUAD UPWARDS ARROW" #x2350)
+    ("APL FUNCTIONAL SYMBOL UP TACK OVERBAR" #x2351)
+    ("APL FUNCTIONAL SYMBOL DEL STILE" #x2352)
+    ("APL FUNCTIONAL SYMBOL QUAD UP CARET" #x2353)
+    ("APL FUNCTIONAL SYMBOL QUAD DEL" #x2354)
+    ("APL FUNCTIONAL SYMBOL UP TACK JOT" #x2355)
+    ("APL FUNCTIONAL SYMBOL DOWNWARDS VANE" #x2356)
+    ("APL FUNCTIONAL SYMBOL QUAD DOWNWARDS ARROW" #x2357)
+    ("APL FUNCTIONAL SYMBOL QUOTE UNDERBAR" #x2358)
+    ("APL FUNCTIONAL SYMBOL DELTA UNDERBAR" #x2359)
+    ("APL FUNCTIONAL SYMBOL DIAMOND UNDERBAR" #x235A)
+    ("APL FUNCTIONAL SYMBOL JOT UNDERBAR" #x235B)
+    ("APL FUNCTIONAL SYMBOL CIRCLE UNDERBAR" #x235C)
+    ("APL FUNCTIONAL SYMBOL UP SHOE JOT" #x235D)
+    ("APL FUNCTIONAL SYMBOL QUOTE QUAD" #x235E)
+    ("APL FUNCTIONAL SYMBOL CIRCLE STAR" #x235F)
+    ("APL FUNCTIONAL SYMBOL QUAD COLON" #x2360)
+    ("APL FUNCTIONAL SYMBOL UP TACK DIAERESIS" #x2361)
+    ("APL FUNCTIONAL SYMBOL DEL DIAERESIS" #x2362)
+    ("APL FUNCTIONAL SYMBOL STAR DIAERESIS" #x2363)
+    ("APL FUNCTIONAL SYMBOL JOT DIAERESIS" #x2364)
+    ("APL FUNCTIONAL SYMBOL CIRCLE DIAERESIS" #x2365)
+    ("APL FUNCTIONAL SYMBOL DOWN SHOE STILE" #x2366)
+    ("APL FUNCTIONAL SYMBOL LEFT SHOE STILE" #x2367)
+    ("APL FUNCTIONAL SYMBOL TILDE DIAERESIS" #x2368)
+    ("APL FUNCTIONAL SYMBOL GREATER-THAN DIAERESIS" #x2369)
+    ("APL FUNCTIONAL SYMBOL COMMA BAR" #x236A)
+    ("APL FUNCTIONAL SYMBOL DEL TILDE" #x236B)
+    ("APL FUNCTIONAL SYMBOL ZILDE" #x236C)
+    ("APL FUNCTIONAL SYMBOL STILE TILDE" #x236D)
+    ("APL FUNCTIONAL SYMBOL SEMICOLON UNDERBAR" #x236E)
+    ("APL FUNCTIONAL SYMBOL QUAD NOT EQUAL" #x236F)
+    ("APL FUNCTIONAL SYMBOL QUAD QUESTION" #x2370)
+    ("APL FUNCTIONAL SYMBOL DOWN CARET TILDE" #x2371)
+    ("APL FUNCTIONAL SYMBOL UP CARET TILDE" #x2372)
+    ("APL FUNCTIONAL SYMBOL IOTA" #x2373)
+    ("APL FUNCTIONAL SYMBOL RHO" #x2374)
+    ("APL FUNCTIONAL SYMBOL OMEGA" #x2375)
+    ("APL FUNCTIONAL SYMBOL ALPHA UNDERBAR" #x2376)
+    ("APL FUNCTIONAL SYMBOL EPSILON UNDERBAR" #x2377)
+    ("APL FUNCTIONAL SYMBOL IOTA UNDERBAR" #x2378)
+    ("APL FUNCTIONAL SYMBOL OMEGA UNDERBAR" #x2379)
+    ("APL FUNCTIONAL SYMBOL ALPHA" #x237A)
+    ("NOT CHECK MARK" #x237B)
+    ("RIGHT ANGLE WITH DOWNWARDS ZIGZAG ARROW" #x237C)
+    ("SHOULDERED OPEN BOX" #x237D)
+    ("BELL SYMBOL" #x237E)
+    ("VERTICAL LINE WITH MIDDLE DOT" #x237F)
+    ("INSERTION SYMBOL" #x2380)
+    ("CONTINUOUS UNDERLINE SYMBOL" #x2381)
+    ("DISCONTINUOUS UNDERLINE SYMBOL" #x2382)
+    ("EMPHASIS SYMBOL" #x2383)
+    ("COMPOSITION SYMBOL" #x2384)
+    ("WHITE SQUARE WITH CENTRE VERTICAL LINE" #x2385)
+    ("ENTER SYMBOL" #x2386)
+    ("ALTERNATIVE KEY SYMBOL" #x2387)
+    ("HELM SYMBOL" #x2388)
+    ("CIRCLED HORIZONTAL BAR WITH NOTCH" #x2389)
+    ("CIRCLED TRIANGLE DOWN" #x238A)
+    ("BROKEN CIRCLE WITH NORTHWEST ARROW" #x238B)
+    ("UNDO SYMBOL" #x238C)
+    ("MONOSTABLE SYMBOL" #x238D)
+    ("HYSTERESIS SYMBOL" #x238E)
+    ("OPEN-CIRCUIT-OUTPUT H-TYPE SYMBOL" #x238F)
+    ("OPEN-CIRCUIT-OUTPUT L-TYPE SYMBOL" #x2390)
+    ("PASSIVE-PULL-DOWN-OUTPUT SYMBOL" #x2391)
+    ("PASSIVE-PULL-UP-OUTPUT SYMBOL" #x2392)
+    ("DIRECT CURRENT SYMBOL FORM TWO" #x2393)
+    ("SOFTWARE-FUNCTION SYMBOL" #x2394)
+    ("APL FUNCTIONAL SYMBOL QUAD" #x2395)
+    ("DECIMAL SEPARATOR KEY SYMBOL" #x2396)
+    ("PREVIOUS PAGE" #x2397)
+    ("NEXT PAGE" #x2398)
+    ("PRINT SCREEN SYMBOL" #x2399)
+    ("CLEAR SCREEN SYMBOL" #x239A)
+    ("LEFT PARENTHESIS UPPER HOOK" #x239B)
+    ("LEFT PARENTHESIS EXTENSION" #x239C)
+    ("LEFT PARENTHESIS LOWER HOOK" #x239D)
+    ("RIGHT PARENTHESIS UPPER HOOK" #x239E)
+    ("RIGHT PARENTHESIS EXTENSION" #x239F)
+    ("RIGHT PARENTHESIS LOWER HOOK" #x23A0)
+    ("LEFT SQUARE BRACKET UPPER CORNER" #x23A1)
+    ("LEFT SQUARE BRACKET EXTENSION" #x23A2)
+    ("LEFT SQUARE BRACKET LOWER CORNER" #x23A3)
+    ("RIGHT SQUARE BRACKET UPPER CORNER" #x23A4)
+    ("RIGHT SQUARE BRACKET EXTENSION" #x23A5)
+    ("RIGHT SQUARE BRACKET LOWER CORNER" #x23A6)
+    ("LEFT CURLY BRACKET UPPER HOOK" #x23A7)
+    ("LEFT CURLY BRACKET MIDDLE PIECE" #x23A8)
+    ("LEFT CURLY BRACKET LOWER HOOK" #x23A9)
+    ("CURLY BRACKET EXTENSION" #x23AA)
+    ("RIGHT CURLY BRACKET UPPER HOOK" #x23AB)
+    ("RIGHT CURLY BRACKET MIDDLE PIECE" #x23AC)
+    ("RIGHT CURLY BRACKET LOWER HOOK" #x23AD)
+    ("INTEGRAL EXTENSION" #x23AE)
+    ("HORIZONTAL LINE EXTENSION" #x23AF)
+    ("UPPER LEFT OR LOWER RIGHT CURLY BRACKET SECTION" #x23B0)
+    ("UPPER RIGHT OR LOWER LEFT CURLY BRACKET SECTION" #x23B1)
+    ("SUMMATION TOP" #x23B2)
+    ("SUMMATION BOTTOM" #x23B3)
+    ("TOP SQUARE BRACKET" #x23B4)
+    ("BOTTOM SQUARE BRACKET" #x23B5)
+    ("BOTTOM SQUARE BRACKET OVER TOP SQUARE BRACKET" #x23B6)
+    ("RADICAL SYMBOL BOTTOM" #x23B7)
+    ("LEFT VERTICAL BOX LINE" #x23B8)
+    ("RIGHT VERTICAL BOX LINE" #x23B9)
+    ("HORIZONTAL SCAN LINE-1" #x23BA)
+    ("HORIZONTAL SCAN LINE-3" #x23BB)
+    ("HORIZONTAL SCAN LINE-7" #x23BC)
+    ("HORIZONTAL SCAN LINE-9" #x23BD)
+    ("DENTISTRY SYMBOL LIGHT VERTICAL AND TOP RIGHT" #x23BE)
+    ("DENTISTRY SYMBOL LIGHT VERTICAL AND BOTTOM RIGHT" #x23BF)
+    ("DENTISTRY SYMBOL LIGHT VERTICAL WITH CIRCLE" #x23C0)
+    ("DENTISTRY SYMBOL LIGHT DOWN AND HORIZONTAL WITH CIRCLE" #x23C1)
+    ("DENTISTRY SYMBOL LIGHT UP AND HORIZONTAL WITH CIRCLE" #x23C2)
+    ("DENTISTRY SYMBOL LIGHT VERTICAL WITH TRIANGLE" #x23C3)
+    ("DENTISTRY SYMBOL LIGHT DOWN AND HORIZONTAL WITH TRIANGLE" #x23C4)
+    ("DENTISTRY SYMBOL LIGHT UP AND HORIZONTAL WITH TRIANGLE" #x23C5)
+    ("DENTISTRY SYMBOL LIGHT VERTICAL AND WAVE" #x23C6)
+    ("DENTISTRY SYMBOL LIGHT DOWN AND HORIZONTAL WITH WAVE" #x23C7)
+    ("DENTISTRY SYMBOL LIGHT UP AND HORIZONTAL WITH WAVE" #x23C8)
+    ("DENTISTRY SYMBOL LIGHT DOWN AND HORIZONTAL" #x23C9)
+    ("DENTISTRY SYMBOL LIGHT UP AND HORIZONTAL" #x23CA)
+    ("DENTISTRY SYMBOL LIGHT VERTICAL AND TOP LEFT" #x23CB)
+    ("DENTISTRY SYMBOL LIGHT VERTICAL AND BOTTOM LEFT" #x23CC)
+    ("SQUARE FOOT" #x23CD)
+    ("RETURN SYMBOL" #x23CE)
+    ))
diff --git a/lisp/nxml/char-name/unicode/02400-0243F.el b/lisp/nxml/char-name/unicode/02400-0243F.el
new file mode 100644
index 00000000000..b4cc42640f4
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/02400-0243F.el
@@ -0,0 +1,41 @@
+(nxml-define-char-name-set 'control-pictures
+  '(("SYMBOL FOR NULL" #x2400)
+    ("SYMBOL FOR START OF HEADING" #x2401)
+    ("SYMBOL FOR START OF TEXT" #x2402)
+    ("SYMBOL FOR END OF TEXT" #x2403)
+    ("SYMBOL FOR END OF TRANSMISSION" #x2404)
+    ("SYMBOL FOR ENQUIRY" #x2405)
+    ("SYMBOL FOR ACKNOWLEDGE" #x2406)
+    ("SYMBOL FOR BELL" #x2407)
+    ("SYMBOL FOR BACKSPACE" #x2408)
+    ("SYMBOL FOR HORIZONTAL TABULATION" #x2409)
+    ("SYMBOL FOR LINE FEED" #x240A)
+    ("SYMBOL FOR VERTICAL TABULATION" #x240B)
+    ("SYMBOL FOR FORM FEED" #x240C)
+    ("SYMBOL FOR CARRIAGE RETURN" #x240D)
+    ("SYMBOL FOR SHIFT OUT" #x240E)
+    ("SYMBOL FOR SHIFT IN" #x240F)
+    ("SYMBOL FOR DATA LINK ESCAPE" #x2410)
+    ("SYMBOL FOR DEVICE CONTROL ONE" #x2411)
+    ("SYMBOL FOR DEVICE CONTROL TWO" #x2412)
+    ("SYMBOL FOR DEVICE CONTROL THREE" #x2413)
+    ("SYMBOL FOR DEVICE CONTROL FOUR" #x2414)
+    ("SYMBOL FOR NEGATIVE ACKNOWLEDGE" #x2415)
+    ("SYMBOL FOR SYNCHRONOUS IDLE" #x2416)
+    ("SYMBOL FOR END OF TRANSMISSION BLOCK" #x2417)
+    ("SYMBOL FOR CANCEL" #x2418)
+    ("SYMBOL FOR END OF MEDIUM" #x2419)
+    ("SYMBOL FOR SUBSTITUTE" #x241A)
+    ("SYMBOL FOR ESCAPE" #x241B)
+    ("SYMBOL FOR FILE SEPARATOR" #x241C)
+    ("SYMBOL FOR GROUP SEPARATOR" #x241D)
+    ("SYMBOL FOR RECORD SEPARATOR" #x241E)
+    ("SYMBOL FOR UNIT SEPARATOR" #x241F)
+    ("SYMBOL FOR SPACE" #x2420)
+    ("SYMBOL FOR DELETE" #x2421)
+    ("BLANK SYMBOL" #x2422)
+    ("OPEN BOX" #x2423)
+    ("SYMBOL FOR NEWLINE" #x2424)
+    ("SYMBOL FOR DELETE FORM TWO" #x2425)
+    ("SYMBOL FOR SUBSTITUTE FORM TWO" #x2426)
+    ))
diff --git a/lisp/nxml/char-name/unicode/02440-0245F.el b/lisp/nxml/char-name/unicode/02440-0245F.el
new file mode 100644
index 00000000000..332720d71f0
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/02440-0245F.el
@@ -0,0 +1,13 @@
+(nxml-define-char-name-set 'optical-character-recognition
+  '(("OCR HOOK" #x2440)
+    ("OCR CHAIR" #x2441)
+    ("OCR FORK" #x2442)
+    ("OCR INVERTED FORK" #x2443)
+    ("OCR BELT BUCKLE" #x2444)
+    ("OCR BOW TIE" #x2445)
+    ("OCR BRANCH BANK IDENTIFICATION" #x2446)
+    ("OCR AMOUNT OF CHECK" #x2447)
+    ("OCR DASH" #x2448)
+    ("OCR CUSTOMER ACCOUNT NUMBER" #x2449)
+    ("OCR DOUBLE BACKSLASH" #x244A)
+    ))
diff --git a/lisp/nxml/char-name/unicode/02460-024FF.el b/lisp/nxml/char-name/unicode/02460-024FF.el
new file mode 100644
index 00000000000..41152bff4a6
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/02460-024FF.el
@@ -0,0 +1,161 @@
+(nxml-define-char-name-set 'enclosed-alphanumerics
+  '(("CIRCLED DIGIT ONE" #x2460)
+    ("CIRCLED DIGIT TWO" #x2461)
+    ("CIRCLED DIGIT THREE" #x2462)
+    ("CIRCLED DIGIT FOUR" #x2463)
+    ("CIRCLED DIGIT FIVE" #x2464)
+    ("CIRCLED DIGIT SIX" #x2465)
+    ("CIRCLED DIGIT SEVEN" #x2466)
+    ("CIRCLED DIGIT EIGHT" #x2467)
+    ("CIRCLED DIGIT NINE" #x2468)
+    ("CIRCLED NUMBER TEN" #x2469)
+    ("CIRCLED NUMBER ELEVEN" #x246A)
+    ("CIRCLED NUMBER TWELVE" #x246B)
+    ("CIRCLED NUMBER THIRTEEN" #x246C)
+    ("CIRCLED NUMBER FOURTEEN" #x246D)
+    ("CIRCLED NUMBER FIFTEEN" #x246E)
+    ("CIRCLED NUMBER SIXTEEN" #x246F)
+    ("CIRCLED NUMBER SEVENTEEN" #x2470)
+    ("CIRCLED NUMBER EIGHTEEN" #x2471)
+    ("CIRCLED NUMBER NINETEEN" #x2472)
+    ("CIRCLED NUMBER TWENTY" #x2473)
+    ("PARENTHESIZED DIGIT ONE" #x2474)
+    ("PARENTHESIZED DIGIT TWO" #x2475)
+    ("PARENTHESIZED DIGIT THREE" #x2476)
+    ("PARENTHESIZED DIGIT FOUR" #x2477)
+    ("PARENTHESIZED DIGIT FIVE" #x2478)
+    ("PARENTHESIZED DIGIT SIX" #x2479)
+    ("PARENTHESIZED DIGIT SEVEN" #x247A)
+    ("PARENTHESIZED DIGIT EIGHT" #x247B)
+    ("PARENTHESIZED DIGIT NINE" #x247C)
+    ("PARENTHESIZED NUMBER TEN" #x247D)
+    ("PARENTHESIZED NUMBER ELEVEN" #x247E)
+    ("PARENTHESIZED NUMBER TWELVE" #x247F)
+    ("PARENTHESIZED NUMBER THIRTEEN" #x2480)
+    ("PARENTHESIZED NUMBER FOURTEEN" #x2481)
+    ("PARENTHESIZED NUMBER FIFTEEN" #x2482)
+    ("PARENTHESIZED NUMBER SIXTEEN" #x2483)
+    ("PARENTHESIZED NUMBER SEVENTEEN" #x2484)
+    ("PARENTHESIZED NUMBER EIGHTEEN" #x2485)
+    ("PARENTHESIZED NUMBER NINETEEN" #x2486)
+    ("PARENTHESIZED NUMBER TWENTY" #x2487)
+    ("DIGIT ONE FULL STOP" #x2488)
+    ("DIGIT TWO FULL STOP" #x2489)
+    ("DIGIT THREE FULL STOP" #x248A)
+    ("DIGIT FOUR FULL STOP" #x248B)
+    ("DIGIT FIVE FULL STOP" #x248C)
+    ("DIGIT SIX FULL STOP" #x248D)
+    ("DIGIT SEVEN FULL STOP" #x248E)
+    ("DIGIT EIGHT FULL STOP" #x248F)
+    ("DIGIT NINE FULL STOP" #x2490)
+    ("NUMBER TEN FULL STOP" #x2491)
+    ("NUMBER ELEVEN FULL STOP" #x2492)
+    ("NUMBER TWELVE FULL STOP" #x2493)
+    ("NUMBER THIRTEEN FULL STOP" #x2494)
+    ("NUMBER FOURTEEN FULL STOP" #x2495)
+    ("NUMBER FIFTEEN FULL STOP" #x2496)
+    ("NUMBER SIXTEEN FULL STOP" #x2497)
+    ("NUMBER SEVENTEEN FULL STOP" #x2498)
+    ("NUMBER EIGHTEEN FULL STOP" #x2499)
+    ("NUMBER NINETEEN FULL STOP" #x249A)
+    ("NUMBER TWENTY FULL STOP" #x249B)
+    ("PARENTHESIZED LATIN SMALL LETTER A" #x249C)
+    ("PARENTHESIZED LATIN SMALL LETTER B" #x249D)
+    ("PARENTHESIZED LATIN SMALL LETTER C" #x249E)
+    ("PARENTHESIZED LATIN SMALL LETTER D" #x249F)
+    ("PARENTHESIZED LATIN SMALL LETTER E" #x24A0)
+    ("PARENTHESIZED LATIN SMALL LETTER F" #x24A1)
+    ("PARENTHESIZED LATIN SMALL LETTER G" #x24A2)
+    ("PARENTHESIZED LATIN SMALL LETTER H" #x24A3)
+    ("PARENTHESIZED LATIN SMALL LETTER I" #x24A4)
+    ("PARENTHESIZED LATIN SMALL LETTER J" #x24A5)
+    ("PARENTHESIZED LATIN SMALL LETTER K" #x24A6)
+    ("PARENTHESIZED LATIN SMALL LETTER L" #x24A7)
+    ("PARENTHESIZED LATIN SMALL LETTER M" #x24A8)
+    ("PARENTHESIZED LATIN SMALL LETTER N" #x24A9)
+    ("PARENTHESIZED LATIN SMALL LETTER O" #x24AA)
+    ("PARENTHESIZED LATIN SMALL LETTER P" #x24AB)
+    ("PARENTHESIZED LATIN SMALL LETTER Q" #x24AC)
+    ("PARENTHESIZED LATIN SMALL LETTER R" #x24AD)
+    ("PARENTHESIZED LATIN SMALL LETTER S" #x24AE)
+    ("PARENTHESIZED LATIN SMALL LETTER T" #x24AF)
+    ("PARENTHESIZED LATIN SMALL LETTER U" #x24B0)
+    ("PARENTHESIZED LATIN SMALL LETTER V" #x24B1)
+    ("PARENTHESIZED LATIN SMALL LETTER W" #x24B2)
+    ("PARENTHESIZED LATIN SMALL LETTER X" #x24B3)
+    ("PARENTHESIZED LATIN SMALL LETTER Y" #x24B4)
+    ("PARENTHESIZED LATIN SMALL LETTER Z" #x24B5)
+    ("CIRCLED LATIN CAPITAL LETTER A" #x24B6)
+    ("CIRCLED LATIN CAPITAL LETTER B" #x24B7)
+    ("CIRCLED LATIN CAPITAL LETTER C" #x24B8)
+    ("CIRCLED LATIN CAPITAL LETTER D" #x24B9)
+    ("CIRCLED LATIN CAPITAL LETTER E" #x24BA)
+    ("CIRCLED LATIN CAPITAL LETTER F" #x24BB)
+    ("CIRCLED LATIN CAPITAL LETTER G" #x24BC)
+    ("CIRCLED LATIN CAPITAL LETTER H" #x24BD)
+    ("CIRCLED LATIN CAPITAL LETTER I" #x24BE)
+    ("CIRCLED LATIN CAPITAL LETTER J" #x24BF)
+    ("CIRCLED LATIN CAPITAL LETTER K" #x24C0)
+    ("CIRCLED LATIN CAPITAL LETTER L" #x24C1)
+    ("CIRCLED LATIN CAPITAL LETTER M" #x24C2)
+    ("CIRCLED LATIN CAPITAL LETTER N" #x24C3)
+    ("CIRCLED LATIN CAPITAL LETTER O" #x24C4)
+    ("CIRCLED LATIN CAPITAL LETTER P" #x24C5)
+    ("CIRCLED LATIN CAPITAL LETTER Q" #x24C6)
+    ("CIRCLED LATIN CAPITAL LETTER R" #x24C7)
+    ("CIRCLED LATIN CAPITAL LETTER S" #x24C8)
+    ("CIRCLED LATIN CAPITAL LETTER T" #x24C9)
+    ("CIRCLED LATIN CAPITAL LETTER U" #x24CA)
+    ("CIRCLED LATIN CAPITAL LETTER V" #x24CB)
+    ("CIRCLED LATIN CAPITAL LETTER W" #x24CC)
+    ("CIRCLED LATIN CAPITAL LETTER X" #x24CD)
+    ("CIRCLED LATIN CAPITAL LETTER Y" #x24CE)
+    ("CIRCLED LATIN CAPITAL LETTER Z" #x24CF)
+    ("CIRCLED LATIN SMALL LETTER A" #x24D0)
+    ("CIRCLED LATIN SMALL LETTER B" #x24D1)
+    ("CIRCLED LATIN SMALL LETTER C" #x24D2)
+    ("CIRCLED LATIN SMALL LETTER D" #x24D3)
+    ("CIRCLED LATIN SMALL LETTER E" #x24D4)
+    ("CIRCLED LATIN SMALL LETTER F" #x24D5)
+    ("CIRCLED LATIN SMALL LETTER G" #x24D6)
+    ("CIRCLED LATIN SMALL LETTER H" #x24D7)
+    ("CIRCLED LATIN SMALL LETTER I" #x24D8)
+    ("CIRCLED LATIN SMALL LETTER J" #x24D9)
+    ("CIRCLED LATIN SMALL LETTER K" #x24DA)
+    ("CIRCLED LATIN SMALL LETTER L" #x24DB)
+    ("CIRCLED LATIN SMALL LETTER M" #x24DC)
+    ("CIRCLED LATIN SMALL LETTER N" #x24DD)
+    ("CIRCLED LATIN SMALL LETTER O" #x24DE)
+    ("CIRCLED LATIN SMALL LETTER P" #x24DF)
+    ("CIRCLED LATIN SMALL LETTER Q" #x24E0)
+    ("CIRCLED LATIN SMALL LETTER R" #x24E1)
+    ("CIRCLED LATIN SMALL LETTER S" #x24E2)
+    ("CIRCLED LATIN SMALL LETTER T" #x24E3)
+    ("CIRCLED LATIN SMALL LETTER U" #x24E4)
+    ("CIRCLED LATIN SMALL LETTER V" #x24E5)
+    ("CIRCLED LATIN SMALL LETTER W" #x24E6)
+    ("CIRCLED LATIN SMALL LETTER X" #x24E7)
+    ("CIRCLED LATIN SMALL LETTER Y" #x24E8)
+    ("CIRCLED LATIN SMALL LETTER Z" #x24E9)
+    ("CIRCLED DIGIT ZERO" #x24EA)
+    ("NEGATIVE CIRCLED NUMBER ELEVEN" #x24EB)
+    ("NEGATIVE CIRCLED NUMBER TWELVE" #x24EC)
+    ("NEGATIVE CIRCLED NUMBER THIRTEEN" #x24ED)
+    ("NEGATIVE CIRCLED NUMBER FOURTEEN" #x24EE)
+    ("NEGATIVE CIRCLED NUMBER FIFTEEN" #x24EF)
+    ("NEGATIVE CIRCLED NUMBER SIXTEEN" #x24F0)
+    ("NEGATIVE CIRCLED NUMBER SEVENTEEN" #x24F1)
+    ("NEGATIVE CIRCLED NUMBER EIGHTEEN" #x24F2)
+    ("NEGATIVE CIRCLED NUMBER NINETEEN" #x24F3)
+    ("NEGATIVE CIRCLED NUMBER TWENTY" #x24F4)
+    ("DOUBLE CIRCLED DIGIT ONE" #x24F5)
+    ("DOUBLE CIRCLED DIGIT TWO" #x24F6)
+    ("DOUBLE CIRCLED DIGIT THREE" #x24F7)
+    ("DOUBLE CIRCLED DIGIT FOUR" #x24F8)
+    ("DOUBLE CIRCLED DIGIT FIVE" #x24F9)
+    ("DOUBLE CIRCLED DIGIT SIX" #x24FA)
+    ("DOUBLE CIRCLED DIGIT SEVEN" #x24FB)
+    ("DOUBLE CIRCLED DIGIT EIGHT" #x24FC)
+    ("DOUBLE CIRCLED DIGIT NINE" #x24FD)
+    ("DOUBLE CIRCLED NUMBER TEN" #x24FE)
+    ))
diff --git a/lisp/nxml/char-name/unicode/02500-0257F.el b/lisp/nxml/char-name/unicode/02500-0257F.el
new file mode 100644
index 00000000000..bf17039df2b
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/02500-0257F.el
@@ -0,0 +1,130 @@
+(nxml-define-char-name-set 'box-drawing
+  '(("BOX DRAWINGS LIGHT HORIZONTAL" #x2500)
+    ("BOX DRAWINGS HEAVY HORIZONTAL" #x2501)
+    ("BOX DRAWINGS LIGHT VERTICAL" #x2502)
+    ("BOX DRAWINGS HEAVY VERTICAL" #x2503)
+    ("BOX DRAWINGS LIGHT TRIPLE DASH HORIZONTAL" #x2504)
+    ("BOX DRAWINGS HEAVY TRIPLE DASH HORIZONTAL" #x2505)
+    ("BOX DRAWINGS LIGHT TRIPLE DASH VERTICAL" #x2506)
+    ("BOX DRAWINGS HEAVY TRIPLE DASH VERTICAL" #x2507)
+    ("BOX DRAWINGS LIGHT QUADRUPLE DASH HORIZONTAL" #x2508)
+    ("BOX DRAWINGS HEAVY QUADRUPLE DASH HORIZONTAL" #x2509)
+    ("BOX DRAWINGS LIGHT QUADRUPLE DASH VERTICAL" #x250A)
+    ("BOX DRAWINGS HEAVY QUADRUPLE DASH VERTICAL" #x250B)
+    ("BOX DRAWINGS LIGHT DOWN AND RIGHT" #x250C)
+    ("BOX DRAWINGS DOWN LIGHT AND RIGHT HEAVY" #x250D)
+    ("BOX DRAWINGS DOWN HEAVY AND RIGHT LIGHT" #x250E)
+    ("BOX DRAWINGS HEAVY DOWN AND RIGHT" #x250F)
+    ("BOX DRAWINGS LIGHT DOWN AND LEFT" #x2510)
+    ("BOX DRAWINGS DOWN LIGHT AND LEFT HEAVY" #x2511)
+    ("BOX DRAWINGS DOWN HEAVY AND LEFT LIGHT" #x2512)
+    ("BOX DRAWINGS HEAVY DOWN AND LEFT" #x2513)
+    ("BOX DRAWINGS LIGHT UP AND RIGHT" #x2514)
+    ("BOX DRAWINGS UP LIGHT AND RIGHT HEAVY" #x2515)
+    ("BOX DRAWINGS UP HEAVY AND RIGHT LIGHT" #x2516)
+    ("BOX DRAWINGS HEAVY UP AND RIGHT" #x2517)
+    ("BOX DRAWINGS LIGHT UP AND LEFT" #x2518)
+    ("BOX DRAWINGS UP LIGHT AND LEFT HEAVY" #x2519)
+    ("BOX DRAWINGS UP HEAVY AND LEFT LIGHT" #x251A)
+    ("BOX DRAWINGS HEAVY UP AND LEFT" #x251B)
+    ("BOX DRAWINGS LIGHT VERTICAL AND RIGHT" #x251C)
+    ("BOX DRAWINGS VERTICAL LIGHT AND RIGHT HEAVY" #x251D)
+    ("BOX DRAWINGS UP HEAVY AND RIGHT DOWN LIGHT" #x251E)
+    ("BOX DRAWINGS DOWN HEAVY AND RIGHT UP LIGHT" #x251F)
+    ("BOX DRAWINGS VERTICAL HEAVY AND RIGHT LIGHT" #x2520)
+    ("BOX DRAWINGS DOWN LIGHT AND RIGHT UP HEAVY" #x2521)
+    ("BOX DRAWINGS UP LIGHT AND RIGHT DOWN HEAVY" #x2522)
+    ("BOX DRAWINGS HEAVY VERTICAL AND RIGHT" #x2523)
+    ("BOX DRAWINGS LIGHT VERTICAL AND LEFT" #x2524)
+    ("BOX DRAWINGS VERTICAL LIGHT AND LEFT HEAVY" #x2525)
+    ("BOX DRAWINGS UP HEAVY AND LEFT DOWN LIGHT" #x2526)
+    ("BOX DRAWINGS DOWN HEAVY AND LEFT UP LIGHT" #x2527)
+    ("BOX DRAWINGS VERTICAL HEAVY AND LEFT LIGHT" #x2528)
+    ("BOX DRAWINGS DOWN LIGHT AND LEFT UP HEAVY" #x2529)
+    ("BOX DRAWINGS UP LIGHT AND LEFT DOWN HEAVY" #x252A)
+    ("BOX DRAWINGS HEAVY VERTICAL AND LEFT" #x252B)
+    ("BOX DRAWINGS LIGHT DOWN AND HORIZONTAL" #x252C)
+    ("BOX DRAWINGS LEFT HEAVY AND RIGHT DOWN LIGHT" #x252D)
+    ("BOX DRAWINGS RIGHT HEAVY AND LEFT DOWN LIGHT" #x252E)
+    ("BOX DRAWINGS DOWN LIGHT AND HORIZONTAL HEAVY" #x252F)
+    ("BOX DRAWINGS DOWN HEAVY AND HORIZONTAL LIGHT" #x2530)
+    ("BOX DRAWINGS RIGHT LIGHT AND LEFT DOWN HEAVY" #x2531)
+    ("BOX DRAWINGS LEFT LIGHT AND RIGHT DOWN HEAVY" #x2532)
+    ("BOX DRAWINGS HEAVY DOWN AND HORIZONTAL" #x2533)
+    ("BOX DRAWINGS LIGHT UP AND HORIZONTAL" #x2534)
+    ("BOX DRAWINGS LEFT HEAVY AND RIGHT UP LIGHT" #x2535)
+    ("BOX DRAWINGS RIGHT HEAVY AND LEFT UP LIGHT" #x2536)
+    ("BOX DRAWINGS UP LIGHT AND HORIZONTAL HEAVY" #x2537)
+    ("BOX DRAWINGS UP HEAVY AND HORIZONTAL LIGHT" #x2538)
+    ("BOX DRAWINGS RIGHT LIGHT AND LEFT UP HEAVY" #x2539)
+    ("BOX DRAWINGS LEFT LIGHT AND RIGHT UP HEAVY" #x253A)
+    ("BOX DRAWINGS HEAVY UP AND HORIZONTAL" #x253B)
+    ("BOX DRAWINGS LIGHT VERTICAL AND HORIZONTAL" #x253C)
+    ("BOX DRAWINGS LEFT HEAVY AND RIGHT VERTICAL LIGHT" #x253D)
+    ("BOX DRAWINGS RIGHT HEAVY AND LEFT VERTICAL LIGHT" #x253E)
+    ("BOX DRAWINGS VERTICAL LIGHT AND HORIZONTAL HEAVY" #x253F)
+    ("BOX DRAWINGS UP HEAVY AND DOWN HORIZONTAL LIGHT" #x2540)
+    ("BOX DRAWINGS DOWN HEAVY AND UP HORIZONTAL LIGHT" #x2541)
+    ("BOX DRAWINGS VERTICAL HEAVY AND HORIZONTAL LIGHT" #x2542)
+    ("BOX DRAWINGS LEFT UP HEAVY AND RIGHT DOWN LIGHT" #x2543)
+    ("BOX DRAWINGS RIGHT UP HEAVY AND LEFT DOWN LIGHT" #x2544)
+    ("BOX DRAWINGS LEFT DOWN HEAVY AND RIGHT UP LIGHT" #x2545)
+    ("BOX DRAWINGS RIGHT DOWN HEAVY AND LEFT UP LIGHT" #x2546)
+    ("BOX DRAWINGS DOWN LIGHT AND UP HORIZONTAL HEAVY" #x2547)
+    ("BOX DRAWINGS UP LIGHT AND DOWN HORIZONTAL HEAVY" #x2548)
+    ("BOX DRAWINGS RIGHT LIGHT AND LEFT VERTICAL HEAVY" #x2549)
+    ("BOX DRAWINGS LEFT LIGHT AND RIGHT VERTICAL HEAVY" #x254A)
+    ("BOX DRAWINGS HEAVY VERTICAL AND HORIZONTAL" #x254B)
+    ("BOX DRAWINGS LIGHT DOUBLE DASH HORIZONTAL" #x254C)
+    ("BOX DRAWINGS HEAVY DOUBLE DASH HORIZONTAL" #x254D)
+    ("BOX DRAWINGS LIGHT DOUBLE DASH VERTICAL" #x254E)
+    ("BOX DRAWINGS HEAVY DOUBLE DASH VERTICAL" #x254F)
+    ("BOX DRAWINGS DOUBLE HORIZONTAL" #x2550)
+    ("BOX DRAWINGS DOUBLE VERTICAL" #x2551)
+    ("BOX DRAWINGS DOWN SINGLE AND RIGHT DOUBLE" #x2552)
+    ("BOX DRAWINGS DOWN DOUBLE AND RIGHT SINGLE" #x2553)
+    ("BOX DRAWINGS DOUBLE DOWN AND RIGHT" #x2554)
+    ("BOX DRAWINGS DOWN SINGLE AND LEFT DOUBLE" #x2555)
+    ("BOX DRAWINGS DOWN DOUBLE AND LEFT SINGLE" #x2556)
+    ("BOX DRAWINGS DOUBLE DOWN AND LEFT" #x2557)
+    ("BOX DRAWINGS UP SINGLE AND RIGHT DOUBLE" #x2558)
+    ("BOX DRAWINGS UP DOUBLE AND RIGHT SINGLE" #x2559)
+    ("BOX DRAWINGS DOUBLE UP AND RIGHT" #x255A)
+    ("BOX DRAWINGS UP SINGLE AND LEFT DOUBLE" #x255B)
+    ("BOX DRAWINGS UP DOUBLE AND LEFT SINGLE" #x255C)
+    ("BOX DRAWINGS DOUBLE UP AND LEFT" #x255D)
+    ("BOX DRAWINGS VERTICAL SINGLE AND RIGHT DOUBLE" #x255E)
+    ("BOX DRAWINGS VERTICAL DOUBLE AND RIGHT SINGLE" #x255F)
+    ("BOX DRAWINGS DOUBLE VERTICAL AND RIGHT" #x2560)
+    ("BOX DRAWINGS VERTICAL SINGLE AND LEFT DOUBLE" #x2561)
+    ("BOX DRAWINGS VERTICAL DOUBLE AND LEFT SINGLE" #x2562)
+    ("BOX DRAWINGS DOUBLE VERTICAL AND LEFT" #x2563)
+    ("BOX DRAWINGS DOWN SINGLE AND HORIZONTAL DOUBLE" #x2564)
+    ("BOX DRAWINGS DOWN DOUBLE AND HORIZONTAL SINGLE" #x2565)
+    ("BOX DRAWINGS DOUBLE DOWN AND HORIZONTAL" #x2566)
+    ("BOX DRAWINGS UP SINGLE AND HORIZONTAL DOUBLE" #x2567)
+    ("BOX DRAWINGS UP DOUBLE AND HORIZONTAL SINGLE" #x2568)
+    ("BOX DRAWINGS DOUBLE UP AND HORIZONTAL" #x2569)
+    ("BOX DRAWINGS VERTICAL SINGLE AND HORIZONTAL DOUBLE" #x256A)
+    ("BOX DRAWINGS VERTICAL DOUBLE AND HORIZONTAL SINGLE" #x256B)
+    ("BOX DRAWINGS DOUBLE VERTICAL AND HORIZONTAL" #x256C)
+    ("BOX DRAWINGS LIGHT ARC DOWN AND RIGHT" #x256D)
+    ("BOX DRAWINGS LIGHT ARC DOWN AND LEFT" #x256E)
+    ("BOX DRAWINGS LIGHT ARC UP AND LEFT" #x256F)
+    ("BOX DRAWINGS LIGHT ARC UP AND RIGHT" #x2570)
+    ("BOX DRAWINGS LIGHT DIAGONAL UPPER RIGHT TO LOWER LEFT" #x2571)
+    ("BOX DRAWINGS LIGHT DIAGONAL UPPER LEFT TO LOWER RIGHT" #x2572)
+    ("BOX DRAWINGS LIGHT DIAGONAL CROSS" #x2573)
+    ("BOX DRAWINGS LIGHT LEFT" #x2574)
+    ("BOX DRAWINGS LIGHT UP" #x2575)
+    ("BOX DRAWINGS LIGHT RIGHT" #x2576)
+    ("BOX DRAWINGS LIGHT DOWN" #x2577)
+    ("BOX DRAWINGS HEAVY LEFT" #x2578)
+    ("BOX DRAWINGS HEAVY UP" #x2579)
+    ("BOX DRAWINGS HEAVY RIGHT" #x257A)
+    ("BOX DRAWINGS HEAVY DOWN" #x257B)
+    ("BOX DRAWINGS LIGHT LEFT AND HEAVY RIGHT" #x257C)
+    ("BOX DRAWINGS LIGHT UP AND HEAVY DOWN" #x257D)
+    ("BOX DRAWINGS HEAVY LEFT AND LIGHT RIGHT" #x257E)
+    ("BOX DRAWINGS HEAVY UP AND LIGHT DOWN" #x257F)
+    ))
diff --git a/lisp/nxml/char-name/unicode/02580-0259F.el b/lisp/nxml/char-name/unicode/02580-0259F.el
new file mode 100644
index 00000000000..89413a2e441
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/02580-0259F.el
@@ -0,0 +1,34 @@
+(nxml-define-char-name-set 'block-elements
+  '(("UPPER HALF BLOCK" #x2580)
+    ("LOWER ONE EIGHTH BLOCK" #x2581)
+    ("LOWER ONE QUARTER BLOCK" #x2582)
+    ("LOWER THREE EIGHTHS BLOCK" #x2583)
+    ("LOWER HALF BLOCK" #x2584)
+    ("LOWER FIVE EIGHTHS BLOCK" #x2585)
+    ("LOWER THREE QUARTERS BLOCK" #x2586)
+    ("LOWER SEVEN EIGHTHS BLOCK" #x2587)
+    ("FULL BLOCK" #x2588)
+    ("LEFT SEVEN EIGHTHS BLOCK" #x2589)
+    ("LEFT THREE QUARTERS BLOCK" #x258A)
+    ("LEFT FIVE EIGHTHS BLOCK" #x258B)
+    ("LEFT HALF BLOCK" #x258C)
+    ("LEFT THREE EIGHTHS BLOCK" #x258D)
+    ("LEFT ONE QUARTER BLOCK" #x258E)
+    ("LEFT ONE EIGHTH BLOCK" #x258F)
+    ("RIGHT HALF BLOCK" #x2590)
+    ("LIGHT SHADE" #x2591)
+    ("MEDIUM SHADE" #x2592)
+    ("DARK SHADE" #x2593)
+    ("UPPER ONE EIGHTH BLOCK" #x2594)
+    ("RIGHT ONE EIGHTH BLOCK" #x2595)
+    ("QUADRANT LOWER LEFT" #x2596)
+    ("QUADRANT LOWER RIGHT" #x2597)
+    ("QUADRANT UPPER LEFT" #x2598)
+    ("QUADRANT UPPER LEFT AND LOWER LEFT AND LOWER RIGHT" #x2599)
+    ("QUADRANT UPPER LEFT AND LOWER RIGHT" #x259A)
+    ("QUADRANT UPPER LEFT AND UPPER RIGHT AND LOWER LEFT" #x259B)
+    ("QUADRANT UPPER LEFT AND UPPER RIGHT AND LOWER RIGHT" #x259C)
+    ("QUADRANT UPPER RIGHT" #x259D)
+    ("QUADRANT UPPER RIGHT AND LOWER LEFT" #x259E)
+    ("QUADRANT UPPER RIGHT AND LOWER LEFT AND LOWER RIGHT" #x259F)
+    ))
diff --git a/lisp/nxml/char-name/unicode/025A0-025FF.el b/lisp/nxml/char-name/unicode/025A0-025FF.el
new file mode 100644
index 00000000000..2313c781d66
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/025A0-025FF.el
@@ -0,0 +1,98 @@
+(nxml-define-char-name-set 'geometric-shapes
+  '(("BLACK SQUARE" #x25A0)
+    ("WHITE SQUARE" #x25A1)
+    ("WHITE SQUARE WITH ROUNDED CORNERS" #x25A2)
+    ("WHITE SQUARE CONTAINING BLACK SMALL SQUARE" #x25A3)
+    ("SQUARE WITH HORIZONTAL FILL" #x25A4)
+    ("SQUARE WITH VERTICAL FILL" #x25A5)
+    ("SQUARE WITH ORTHOGONAL CROSSHATCH FILL" #x25A6)
+    ("SQUARE WITH UPPER LEFT TO LOWER RIGHT FILL" #x25A7)
+    ("SQUARE WITH UPPER RIGHT TO LOWER LEFT FILL" #x25A8)
+    ("SQUARE WITH DIAGONAL CROSSHATCH FILL" #x25A9)
+    ("BLACK SMALL SQUARE" #x25AA)
+    ("WHITE SMALL SQUARE" #x25AB)
+    ("BLACK RECTANGLE" #x25AC)
+    ("WHITE RECTANGLE" #x25AD)
+    ("BLACK VERTICAL RECTANGLE" #x25AE)
+    ("WHITE VERTICAL RECTANGLE" #x25AF)
+    ("BLACK PARALLELOGRAM" #x25B0)
+    ("WHITE PARALLELOGRAM" #x25B1)
+    ("BLACK UP-POINTING TRIANGLE" #x25B2)
+    ("WHITE UP-POINTING TRIANGLE" #x25B3)
+    ("BLACK UP-POINTING SMALL TRIANGLE" #x25B4)
+    ("WHITE UP-POINTING SMALL TRIANGLE" #x25B5)
+    ("BLACK RIGHT-POINTING TRIANGLE" #x25B6)
+    ("WHITE RIGHT-POINTING TRIANGLE" #x25B7)
+    ("BLACK RIGHT-POINTING SMALL TRIANGLE" #x25B8)
+    ("WHITE RIGHT-POINTING SMALL TRIANGLE" #x25B9)
+    ("BLACK RIGHT-POINTING POINTER" #x25BA)
+    ("WHITE RIGHT-POINTING POINTER" #x25BB)
+    ("BLACK DOWN-POINTING TRIANGLE" #x25BC)
+    ("WHITE DOWN-POINTING TRIANGLE" #x25BD)
+    ("BLACK DOWN-POINTING SMALL TRIANGLE" #x25BE)
+    ("WHITE DOWN-POINTING SMALL TRIANGLE" #x25BF)
+    ("BLACK LEFT-POINTING TRIANGLE" #x25C0)
+    ("WHITE LEFT-POINTING TRIANGLE" #x25C1)
+    ("BLACK LEFT-POINTING SMALL TRIANGLE" #x25C2)
+    ("WHITE LEFT-POINTING SMALL TRIANGLE" #x25C3)
+    ("BLACK LEFT-POINTING POINTER" #x25C4)
+    ("WHITE LEFT-POINTING POINTER" #x25C5)
+    ("BLACK DIAMOND" #x25C6)
+    ("WHITE DIAMOND" #x25C7)
+    ("WHITE DIAMOND CONTAINING BLACK SMALL DIAMOND" #x25C8)
+    ("FISHEYE" #x25C9)
+    ("LOZENGE" #x25CA)
+    ("WHITE CIRCLE" #x25CB)
+    ("DOTTED CIRCLE" #x25CC)
+    ("CIRCLE WITH VERTICAL FILL" #x25CD)
+    ("BULLSEYE" #x25CE)
+    ("BLACK CIRCLE" #x25CF)
+    ("CIRCLE WITH LEFT HALF BLACK" #x25D0)
+    ("CIRCLE WITH RIGHT HALF BLACK" #x25D1)
+    ("CIRCLE WITH LOWER HALF BLACK" #x25D2)
+    ("CIRCLE WITH UPPER HALF BLACK" #x25D3)
+    ("CIRCLE WITH UPPER RIGHT QUADRANT BLACK" #x25D4)
+    ("CIRCLE WITH ALL BUT UPPER LEFT QUADRANT BLACK" #x25D5)
+    ("LEFT HALF BLACK CIRCLE" #x25D6)
+    ("RIGHT HALF BLACK CIRCLE" #x25D7)
+    ("INVERSE BULLET" #x25D8)
+    ("INVERSE WHITE CIRCLE" #x25D9)
+    ("UPPER HALF INVERSE WHITE CIRCLE" #x25DA)
+    ("LOWER HALF INVERSE WHITE CIRCLE" #x25DB)
+    ("UPPER LEFT QUADRANT CIRCULAR ARC" #x25DC)
+    ("UPPER RIGHT QUADRANT CIRCULAR ARC" #x25DD)
+    ("LOWER RIGHT QUADRANT CIRCULAR ARC" #x25DE)
+    ("LOWER LEFT QUADRANT CIRCULAR ARC" #x25DF)
+    ("UPPER HALF CIRCLE" #x25E0)
+    ("LOWER HALF CIRCLE" #x25E1)
+    ("BLACK LOWER RIGHT TRIANGLE" #x25E2)
+    ("BLACK LOWER LEFT TRIANGLE" #x25E3)
+    ("BLACK UPPER LEFT TRIANGLE" #x25E4)
+    ("BLACK UPPER RIGHT TRIANGLE" #x25E5)
+    ("WHITE BULLET" #x25E6)
+    ("SQUARE WITH LEFT HALF BLACK" #x25E7)
+    ("SQUARE WITH RIGHT HALF BLACK" #x25E8)
+    ("SQUARE WITH UPPER LEFT DIAGONAL HALF BLACK" #x25E9)
+    ("SQUARE WITH LOWER RIGHT DIAGONAL HALF BLACK" #x25EA)
+    ("WHITE SQUARE WITH VERTICAL BISECTING LINE" #x25EB)
+    ("WHITE UP-POINTING TRIANGLE WITH DOT" #x25EC)
+    ("UP-POINTING TRIANGLE WITH LEFT HALF BLACK" #x25ED)
+    ("UP-POINTING TRIANGLE WITH RIGHT HALF BLACK" #x25EE)
+    ("LARGE CIRCLE" #x25EF)
+    ("WHITE SQUARE WITH UPPER LEFT QUADRANT" #x25F0)
+    ("WHITE SQUARE WITH LOWER LEFT QUADRANT" #x25F1)
+    ("WHITE SQUARE WITH LOWER RIGHT QUADRANT" #x25F2)
+    ("WHITE SQUARE WITH UPPER RIGHT QUADRANT" #x25F3)
+    ("WHITE CIRCLE WITH UPPER LEFT QUADRANT" #x25F4)
+    ("WHITE CIRCLE WITH LOWER LEFT QUADRANT" #x25F5)
+    ("WHITE CIRCLE WITH LOWER RIGHT QUADRANT" #x25F6)
+    ("WHITE CIRCLE WITH UPPER RIGHT QUADRANT" #x25F7)
+    ("UPPER LEFT TRIANGLE" #x25F8)
+    ("UPPER RIGHT TRIANGLE" #x25F9)
+    ("LOWER LEFT TRIANGLE" #x25FA)
+    ("WHITE MEDIUM SQUARE" #x25FB)
+    ("BLACK MEDIUM SQUARE" #x25FC)
+    ("WHITE MEDIUM SMALL SQUARE" #x25FD)
+    ("BLACK MEDIUM SMALL SQUARE" #x25FE)
+    ("LOWER RIGHT TRIANGLE" #x25FF)
+    ))
diff --git a/lisp/nxml/char-name/unicode/02600-026FF.el b/lisp/nxml/char-name/unicode/02600-026FF.el
new file mode 100644
index 00000000000..eaae9bec08f
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/02600-026FF.el
@@ -0,0 +1,135 @@
+(nxml-define-char-name-set 'miscellaneous-symbols
+  '(("BLACK SUN WITH RAYS" #x2600)
+    ("CLOUD" #x2601)
+    ("UMBRELLA" #x2602)
+    ("SNOWMAN" #x2603)
+    ("COMET" #x2604)
+    ("BLACK STAR" #x2605)
+    ("WHITE STAR" #x2606)
+    ("LIGHTNING" #x2607)
+    ("THUNDERSTORM" #x2608)
+    ("SUN" #x2609)
+    ("ASCENDING NODE" #x260A)
+    ("DESCENDING NODE" #x260B)
+    ("CONJUNCTION" #x260C)
+    ("OPPOSITION" #x260D)
+    ("BLACK TELEPHONE" #x260E)
+    ("WHITE TELEPHONE" #x260F)
+    ("BALLOT BOX" #x2610)
+    ("BALLOT BOX WITH CHECK" #x2611)
+    ("BALLOT BOX WITH X" #x2612)
+    ("SALTIRE" #x2613)
+    ("WHITE SHOGI PIECE" #x2616)
+    ("BLACK SHOGI PIECE" #x2617)
+    ("REVERSED ROTATED FLORAL HEART BULLET" #x2619)
+    ("BLACK LEFT POINTING INDEX" #x261A)
+    ("BLACK RIGHT POINTING INDEX" #x261B)
+    ("WHITE LEFT POINTING INDEX" #x261C)
+    ("WHITE UP POINTING INDEX" #x261D)
+    ("WHITE RIGHT POINTING INDEX" #x261E)
+    ("WHITE DOWN POINTING INDEX" #x261F)
+    ("SKULL AND CROSSBONES" #x2620)
+    ("CAUTION SIGN" #x2621)
+    ("RADIOACTIVE SIGN" #x2622)
+    ("BIOHAZARD SIGN" #x2623)
+    ("CADUCEUS" #x2624)
+    ("ANKH" #x2625)
+    ("ORTHODOX CROSS" #x2626)
+    ("CHI RHO" #x2627)
+    ("CROSS OF LORRAINE" #x2628)
+    ("CROSS OF JERUSALEM" #x2629)
+    ("STAR AND CRESCENT" #x262A)
+    ("FARSI SYMBOL" #x262B)
+    ("ADI SHAKTI" #x262C)
+    ("HAMMER AND SICKLE" #x262D)
+    ("PEACE SYMBOL" #x262E)
+    ("YIN YANG" #x262F)
+    ("TRIGRAM FOR HEAVEN" #x2630)
+    ("TRIGRAM FOR LAKE" #x2631)
+    ("TRIGRAM FOR FIRE" #x2632)
+    ("TRIGRAM FOR THUNDER" #x2633)
+    ("TRIGRAM FOR WIND" #x2634)
+    ("TRIGRAM FOR WATER" #x2635)
+    ("TRIGRAM FOR MOUNTAIN" #x2636)
+    ("TRIGRAM FOR EARTH" #x2637)
+    ("WHEEL OF DHARMA" #x2638)
+    ("WHITE FROWNING FACE" #x2639)
+    ("WHITE SMILING FACE" #x263A)
+    ("BLACK SMILING FACE" #x263B)
+    ("WHITE SUN WITH RAYS" #x263C)
+    ("FIRST QUARTER MOON" #x263D)
+    ("LAST QUARTER MOON" #x263E)
+    ("MERCURY" #x263F)
+    ("FEMALE SIGN" #x2640)
+    ("EARTH" #x2641)
+    ("MALE SIGN" #x2642)
+    ("JUPITER" #x2643)
+    ("SATURN" #x2644)
+    ("URANUS" #x2645)
+    ("NEPTUNE" #x2646)
+    ("PLUTO" #x2647)
+    ("ARIES" #x2648)
+    ("TAURUS" #x2649)
+    ("GEMINI" #x264A)
+    ("CANCER" #x264B)
+    ("LEO" #x264C)
+    ("VIRGO" #x264D)
+    ("LIBRA" #x264E)
+    ("SCORPIUS" #x264F)
+    ("SAGITTARIUS" #x2650)
+    ("CAPRICORN" #x2651)
+    ("AQUARIUS" #x2652)
+    ("PISCES" #x2653)
+    ("WHITE CHESS KING" #x2654)
+    ("WHITE CHESS QUEEN" #x2655)
+    ("WHITE CHESS ROOK" #x2656)
+    ("WHITE CHESS BISHOP" #x2657)
+    ("WHITE CHESS KNIGHT" #x2658)
+    ("WHITE CHESS PAWN" #x2659)
+    ("BLACK CHESS KING" #x265A)
+    ("BLACK CHESS QUEEN" #x265B)
+    ("BLACK CHESS ROOK" #x265C)
+    ("BLACK CHESS BISHOP" #x265D)
+    ("BLACK CHESS KNIGHT" #x265E)
+    ("BLACK CHESS PAWN" #x265F)
+    ("BLACK SPADE SUIT" #x2660)
+    ("WHITE HEART SUIT" #x2661)
+    ("WHITE DIAMOND SUIT" #x2662)
+    ("BLACK CLUB SUIT" #x2663)
+    ("WHITE SPADE SUIT" #x2664)
+    ("BLACK HEART SUIT" #x2665)
+    ("BLACK DIAMOND SUIT" #x2666)
+    ("WHITE CLUB SUIT" #x2667)
+    ("HOT SPRINGS" #x2668)
+    ("QUARTER NOTE" #x2669)
+    ("EIGHTH NOTE" #x266A)
+    ("BEAMED EIGHTH NOTES" #x266B)
+    ("BEAMED SIXTEENTH NOTES" #x266C)
+    ("MUSIC FLAT SIGN" #x266D)
+    ("MUSIC NATURAL SIGN" #x266E)
+    ("MUSIC SHARP SIGN" #x266F)
+    ("WEST SYRIAC CROSS" #x2670)
+    ("EAST SYRIAC CROSS" #x2671)
+    ("UNIVERSAL RECYCLING SYMBOL" #x2672)
+    ("RECYCLING SYMBOL FOR TYPE-1 PLASTICS" #x2673)
+    ("RECYCLING SYMBOL FOR TYPE-2 PLASTICS" #x2674)
+    ("RECYCLING SYMBOL FOR TYPE-3 PLASTICS" #x2675)
+    ("RECYCLING SYMBOL FOR TYPE-4 PLASTICS" #x2676)
+    ("RECYCLING SYMBOL FOR TYPE-5 PLASTICS" #x2677)
+    ("RECYCLING SYMBOL FOR TYPE-6 PLASTICS" #x2678)
+    ("RECYCLING SYMBOL FOR TYPE-7 PLASTICS" #x2679)
+    ("RECYCLING SYMBOL FOR GENERIC MATERIALS" #x267A)
+    ("BLACK UNIVERSAL RECYCLING SYMBOL" #x267B)
+    ("RECYCLED PAPER SYMBOL" #x267C)
+    ("PARTIALLY-RECYCLED PAPER SYMBOL" #x267D)
+    ("DIE FACE-1" #x2680)
+    ("DIE FACE-2" #x2681)
+    ("DIE FACE-3" #x2682)
+    ("DIE FACE-4" #x2683)
+    ("DIE FACE-5" #x2684)
+    ("DIE FACE-6" #x2685)
+    ("WHITE CIRCLE WITH DOT RIGHT" #x2686)
+    ("WHITE CIRCLE WITH TWO DOTS" #x2687)
+    ("BLACK CIRCLE WITH WHITE DOT RIGHT" #x2688)
+    ("BLACK CIRCLE WITH TWO WHITE DOTS" #x2689)
+    ))
diff --git a/lisp/nxml/char-name/unicode/02700-027BF.el b/lisp/nxml/char-name/unicode/02700-027BF.el
new file mode 100644
index 00000000000..e4361a32404
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/02700-027BF.el
@@ -0,0 +1,176 @@
+(nxml-define-char-name-set 'dingbats
+  '(("UPPER BLADE SCISSORS" #x2701)
+    ("BLACK SCISSORS" #x2702)
+    ("LOWER BLADE SCISSORS" #x2703)
+    ("WHITE SCISSORS" #x2704)
+    ("TELEPHONE LOCATION SIGN" #x2706)
+    ("TAPE DRIVE" #x2707)
+    ("AIRPLANE" #x2708)
+    ("ENVELOPE" #x2709)
+    ("VICTORY HAND" #x270C)
+    ("WRITING HAND" #x270D)
+    ("LOWER RIGHT PENCIL" #x270E)
+    ("PENCIL" #x270F)
+    ("UPPER RIGHT PENCIL" #x2710)
+    ("WHITE NIB" #x2711)
+    ("BLACK NIB" #x2712)
+    ("CHECK MARK" #x2713)
+    ("HEAVY CHECK MARK" #x2714)
+    ("MULTIPLICATION X" #x2715)
+    ("HEAVY MULTIPLICATION X" #x2716)
+    ("BALLOT X" #x2717)
+    ("HEAVY BALLOT X" #x2718)
+    ("OUTLINED GREEK CROSS" #x2719)
+    ("HEAVY GREEK CROSS" #x271A)
+    ("OPEN CENTRE CROSS" #x271B)
+    ("HEAVY OPEN CENTRE CROSS" #x271C)
+    ("LATIN CROSS" #x271D)
+    ("SHADOWED WHITE LATIN CROSS" #x271E)
+    ("OUTLINED LATIN CROSS" #x271F)
+    ("MALTESE CROSS" #x2720)
+    ("STAR OF DAVID" #x2721)
+    ("FOUR TEARDROP-SPOKED ASTERISK" #x2722)
+    ("FOUR BALLOON-SPOKED ASTERISK" #x2723)
+    ("HEAVY FOUR BALLOON-SPOKED ASTERISK" #x2724)
+    ("FOUR CLUB-SPOKED ASTERISK" #x2725)
+    ("BLACK FOUR POINTED STAR" #x2726)
+    ("WHITE FOUR POINTED STAR" #x2727)
+    ("STRESS OUTLINED WHITE STAR" #x2729)
+    ("CIRCLED WHITE STAR" #x272A)
+    ("OPEN CENTRE BLACK STAR" #x272B)
+    ("BLACK CENTRE WHITE STAR" #x272C)
+    ("OUTLINED BLACK STAR" #x272D)
+    ("HEAVY OUTLINED BLACK STAR" #x272E)
+    ("PINWHEEL STAR" #x272F)
+    ("SHADOWED WHITE STAR" #x2730)
+    ("HEAVY ASTERISK" #x2731)
+    ("OPEN CENTRE ASTERISK" #x2732)
+    ("EIGHT SPOKED ASTERISK" #x2733)
+    ("EIGHT POINTED BLACK STAR" #x2734)
+    ("EIGHT POINTED PINWHEEL STAR" #x2735)
+    ("SIX POINTED BLACK STAR" #x2736)
+    ("EIGHT POINTED RECTILINEAR BLACK STAR" #x2737)
+    ("HEAVY EIGHT POINTED RECTILINEAR BLACK STAR" #x2738)
+    ("TWELVE POINTED BLACK STAR" #x2739)
+    ("SIXTEEN POINTED ASTERISK" #x273A)
+    ("TEARDROP-SPOKED ASTERISK" #x273B)
+    ("OPEN CENTRE TEARDROP-SPOKED ASTERISK" #x273C)
+    ("HEAVY TEARDROP-SPOKED ASTERISK" #x273D)
+    ("SIX PETALLED BLACK AND WHITE FLORETTE" #x273E)
+    ("BLACK FLORETTE" #x273F)
+    ("WHITE FLORETTE" #x2740)
+    ("EIGHT PETALLED OUTLINED BLACK FLORETTE" #x2741)
+    ("CIRCLED OPEN CENTRE EIGHT POINTED STAR" #x2742)
+    ("HEAVY TEARDROP-SPOKED PINWHEEL ASTERISK" #x2743)
+    ("SNOWFLAKE" #x2744)
+    ("TIGHT TRIFOLIATE SNOWFLAKE" #x2745)
+    ("HEAVY CHEVRON SNOWFLAKE" #x2746)
+    ("SPARKLE" #x2747)
+    ("HEAVY SPARKLE" #x2748)
+    ("BALLOON-SPOKED ASTERISK" #x2749)
+    ("EIGHT TEARDROP-SPOKED PROPELLER ASTERISK" #x274A)
+    ("HEAVY EIGHT TEARDROP-SPOKED PROPELLER ASTERISK" #x274B)
+    ("SHADOWED WHITE CIRCLE" #x274D)
+    ("LOWER RIGHT DROP-SHADOWED WHITE SQUARE" #x274F)
+    ("UPPER RIGHT DROP-SHADOWED WHITE SQUARE" #x2750)
+    ("LOWER RIGHT SHADOWED WHITE SQUARE" #x2751)
+    ("UPPER RIGHT SHADOWED WHITE SQUARE" #x2752)
+    ("BLACK DIAMOND MINUS WHITE X" #x2756)
+    ("LIGHT VERTICAL BAR" #x2758)
+    ("MEDIUM VERTICAL BAR" #x2759)
+    ("HEAVY VERTICAL BAR" #x275A)
+    ("HEAVY SINGLE TURNED COMMA QUOTATION MARK ORNAMENT" #x275B)
+    ("HEAVY SINGLE COMMA QUOTATION MARK ORNAMENT" #x275C)
+    ("HEAVY DOUBLE TURNED COMMA QUOTATION MARK ORNAMENT" #x275D)
+    ("HEAVY DOUBLE COMMA QUOTATION MARK ORNAMENT" #x275E)
+    ("CURVED STEM PARAGRAPH SIGN ORNAMENT" #x2761)
+    ("HEAVY EXCLAMATION MARK ORNAMENT" #x2762)
+    ("HEAVY HEART EXCLAMATION MARK ORNAMENT" #x2763)
+    ("HEAVY BLACK HEART" #x2764)
+    ("ROTATED HEAVY BLACK HEART BULLET" #x2765)
+    ("FLORAL HEART" #x2766)
+    ("ROTATED FLORAL HEART BULLET" #x2767)
+    ("MEDIUM LEFT PARENTHESIS ORNAMENT" #x2768)
+    ("MEDIUM RIGHT PARENTHESIS ORNAMENT" #x2769)
+    ("MEDIUM FLATTENED LEFT PARENTHESIS ORNAMENT" #x276A)
+    ("MEDIUM FLATTENED RIGHT PARENTHESIS ORNAMENT" #x276B)
+    ("MEDIUM LEFT-POINTING ANGLE BRACKET ORNAMENT" #x276C)
+    ("MEDIUM RIGHT-POINTING ANGLE BRACKET ORNAMENT" #x276D)
+    ("HEAVY LEFT-POINTING ANGLE QUOTATION MARK ORNAMENT" #x276E)
+    ("HEAVY RIGHT-POINTING ANGLE QUOTATION MARK ORNAMENT" #x276F)
+    ("HEAVY LEFT-POINTING ANGLE BRACKET ORNAMENT" #x2770)
+    ("HEAVY RIGHT-POINTING ANGLE BRACKET ORNAMENT" #x2771)
+    ("LIGHT LEFT TORTOISE SHELL BRACKET ORNAMENT" #x2772)
+    ("LIGHT RIGHT TORTOISE SHELL BRACKET ORNAMENT" #x2773)
+    ("MEDIUM LEFT CURLY BRACKET ORNAMENT" #x2774)
+    ("MEDIUM RIGHT CURLY BRACKET ORNAMENT" #x2775)
+    ("DINGBAT NEGATIVE CIRCLED DIGIT ONE" #x2776)
+    ("DINGBAT NEGATIVE CIRCLED DIGIT TWO" #x2777)
+    ("DINGBAT NEGATIVE CIRCLED DIGIT THREE" #x2778)
+    ("DINGBAT NEGATIVE CIRCLED DIGIT FOUR" #x2779)
+    ("DINGBAT NEGATIVE CIRCLED DIGIT FIVE" #x277A)
+    ("DINGBAT NEGATIVE CIRCLED DIGIT SIX" #x277B)
+    ("DINGBAT NEGATIVE CIRCLED DIGIT SEVEN" #x277C)
+    ("DINGBAT NEGATIVE CIRCLED DIGIT EIGHT" #x277D)
+    ("DINGBAT NEGATIVE CIRCLED DIGIT NINE" #x277E)
+    ("DINGBAT NEGATIVE CIRCLED NUMBER TEN" #x277F)
+    ("DINGBAT CIRCLED SANS-SERIF DIGIT ONE" #x2780)
+    ("DINGBAT CIRCLED SANS-SERIF DIGIT TWO" #x2781)
+    ("DINGBAT CIRCLED SANS-SERIF DIGIT THREE" #x2782)
+    ("DINGBAT CIRCLED SANS-SERIF DIGIT FOUR" #x2783)
+    ("DINGBAT CIRCLED SANS-SERIF DIGIT FIVE" #x2784)
+    ("DINGBAT CIRCLED SANS-SERIF DIGIT SIX" #x2785)
+    ("DINGBAT CIRCLED SANS-SERIF DIGIT SEVEN" #x2786)
+    ("DINGBAT CIRCLED SANS-SERIF DIGIT EIGHT" #x2787)
+    ("DINGBAT CIRCLED SANS-SERIF DIGIT NINE" #x2788)
+    ("DINGBAT CIRCLED SANS-SERIF NUMBER TEN" #x2789)
+    ("DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT ONE" #x278A)
+    ("DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT TWO" #x278B)
+    ("DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT THREE" #x278C)
+    ("DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT FOUR" #x278D)
+    ("DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT FIVE" #x278E)
+    ("DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT SIX" #x278F)
+    ("DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT SEVEN" #x2790)
+    ("DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT EIGHT" #x2791)
+    ("DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT NINE" #x2792)
+    ("DINGBAT NEGATIVE CIRCLED SANS-SERIF NUMBER TEN" #x2793)
+    ("HEAVY WIDE-HEADED RIGHTWARDS ARROW" #x2794)
+    ("HEAVY SOUTH EAST ARROW" #x2798)
+    ("HEAVY RIGHTWARDS ARROW" #x2799)
+    ("HEAVY NORTH EAST ARROW" #x279A)
+    ("DRAFTING POINT RIGHTWARDS ARROW" #x279B)
+    ("HEAVY ROUND-TIPPED RIGHTWARDS ARROW" #x279C)
+    ("TRIANGLE-HEADED RIGHTWARDS ARROW" #x279D)
+    ("HEAVY TRIANGLE-HEADED RIGHTWARDS ARROW" #x279E)
+    ("DASHED TRIANGLE-HEADED RIGHTWARDS ARROW" #x279F)
+    ("HEAVY DASHED TRIANGLE-HEADED RIGHTWARDS ARROW" #x27A0)
+    ("BLACK RIGHTWARDS ARROW" #x27A1)
+    ("THREE-D TOP-LIGHTED RIGHTWARDS ARROWHEAD" #x27A2)
+    ("THREE-D BOTTOM-LIGHTED RIGHTWARDS ARROWHEAD" #x27A3)
+    ("BLACK RIGHTWARDS ARROWHEAD" #x27A4)
+    ("HEAVY BLACK CURVED DOWNWARDS AND RIGHTWARDS ARROW" #x27A5)
+    ("HEAVY BLACK CURVED UPWARDS AND RIGHTWARDS ARROW" #x27A6)
+    ("SQUAT BLACK RIGHTWARDS ARROW" #x27A7)
+    ("HEAVY CONCAVE-POINTED BLACK RIGHTWARDS ARROW" #x27A8)
+    ("RIGHT-SHADED WHITE RIGHTWARDS ARROW" #x27A9)
+    ("LEFT-SHADED WHITE RIGHTWARDS ARROW" #x27AA)
+    ("BACK-TILTED SHADOWED WHITE RIGHTWARDS ARROW" #x27AB)
+    ("FRONT-TILTED SHADOWED WHITE RIGHTWARDS ARROW" #x27AC)
+    ("HEAVY LOWER RIGHT-SHADOWED WHITE RIGHTWARDS ARROW" #x27AD)
+    ("HEAVY UPPER RIGHT-SHADOWED WHITE RIGHTWARDS ARROW" #x27AE)
+    ("NOTCHED LOWER RIGHT-SHADOWED WHITE RIGHTWARDS ARROW" #x27AF)
+    ("NOTCHED UPPER RIGHT-SHADOWED WHITE RIGHTWARDS ARROW" #x27B1)
+    ("CIRCLED HEAVY WHITE RIGHTWARDS ARROW" #x27B2)
+    ("WHITE-FEATHERED RIGHTWARDS ARROW" #x27B3)
+    ("BLACK-FEATHERED SOUTH EAST ARROW" #x27B4)
+    ("BLACK-FEATHERED RIGHTWARDS ARROW" #x27B5)
+    ("BLACK-FEATHERED NORTH EAST ARROW" #x27B6)
+    ("HEAVY BLACK-FEATHERED SOUTH EAST ARROW" #x27B7)
+    ("HEAVY BLACK-FEATHERED RIGHTWARDS ARROW" #x27B8)
+    ("HEAVY BLACK-FEATHERED NORTH EAST ARROW" #x27B9)
+    ("TEARDROP-BARBED RIGHTWARDS ARROW" #x27BA)
+    ("HEAVY TEARDROP-SHANKED RIGHTWARDS ARROW" #x27BB)
+    ("WEDGE-TAILED RIGHTWARDS ARROW" #x27BC)
+    ("HEAVY WEDGE-TAILED RIGHTWARDS ARROW" #x27BD)
+    ("OPEN-OUTLINED RIGHTWARDS ARROW" #x27BE)
+    ))
diff --git a/lisp/nxml/char-name/unicode/027C0-027EF.el b/lisp/nxml/char-name/unicode/027C0-027EF.el
new file mode 100644
index 00000000000..c68207cff76
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/027C0-027EF.el
@@ -0,0 +1,30 @@
+(nxml-define-char-name-set 'miscellaneous-mathematical-symbols-a
+  '(("WHITE DIAMOND WITH CENTRED DOT" #x27D0)
+    ("AND WITH DOT" #x27D1)
+    ("ELEMENT OF OPENING UPWARDS" #x27D2)
+    ("LOWER RIGHT CORNER WITH DOT" #x27D3)
+    ("UPPER LEFT CORNER WITH DOT" #x27D4)
+    ("LEFT OUTER JOIN" #x27D5)
+    ("RIGHT OUTER JOIN" #x27D6)
+    ("FULL OUTER JOIN" #x27D7)
+    ("LARGE UP TACK" #x27D8)
+    ("LARGE DOWN TACK" #x27D9)
+    ("LEFT AND RIGHT DOUBLE TURNSTILE" #x27DA)
+    ("LEFT AND RIGHT TACK" #x27DB)
+    ("LEFT MULTIMAP" #x27DC)
+    ("LONG RIGHT TACK" #x27DD)
+    ("LONG LEFT TACK" #x27DE)
+    ("UP TACK WITH CIRCLE ABOVE" #x27DF)
+    ("LOZENGE DIVIDED BY HORIZONTAL RULE" #x27E0)
+    ("WHITE CONCAVE-SIDED DIAMOND" #x27E1)
+    ("WHITE CONCAVE-SIDED DIAMOND WITH LEFTWARDS TICK" #x27E2)
+    ("WHITE CONCAVE-SIDED DIAMOND WITH RIGHTWARDS TICK" #x27E3)
+    ("WHITE SQUARE WITH LEFTWARDS TICK" #x27E4)
+    ("WHITE SQUARE WITH RIGHTWARDS TICK" #x27E5)
+    ("MATHEMATICAL LEFT WHITE SQUARE BRACKET" #x27E6)
+    ("MATHEMATICAL RIGHT WHITE SQUARE BRACKET" #x27E7)
+    ("MATHEMATICAL LEFT ANGLE BRACKET" #x27E8)
+    ("MATHEMATICAL RIGHT ANGLE BRACKET" #x27E9)
+    ("MATHEMATICAL LEFT DOUBLE ANGLE BRACKET" #x27EA)
+    ("MATHEMATICAL RIGHT DOUBLE ANGLE BRACKET" #x27EB)
+    ))
diff --git a/lisp/nxml/char-name/unicode/027F0-027FF.el b/lisp/nxml/char-name/unicode/027F0-027FF.el
new file mode 100644
index 00000000000..3403ce46146
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/027F0-027FF.el
@@ -0,0 +1,18 @@
+(nxml-define-char-name-set 'supplemental-arrows-a
+  '(("UPWARDS QUADRUPLE ARROW" #x27F0)
+    ("DOWNWARDS QUADRUPLE ARROW" #x27F1)
+    ("ANTICLOCKWISE GAPPED CIRCLE ARROW" #x27F2)
+    ("CLOCKWISE GAPPED CIRCLE ARROW" #x27F3)
+    ("RIGHT ARROW WITH CIRCLED PLUS" #x27F4)
+    ("LONG LEFTWARDS ARROW" #x27F5)
+    ("LONG RIGHTWARDS ARROW" #x27F6)
+    ("LONG LEFT RIGHT ARROW" #x27F7)
+    ("LONG LEFTWARDS DOUBLE ARROW" #x27F8)
+    ("LONG RIGHTWARDS DOUBLE ARROW" #x27F9)
+    ("LONG LEFT RIGHT DOUBLE ARROW" #x27FA)
+    ("LONG LEFTWARDS ARROW FROM BAR" #x27FB)
+    ("LONG RIGHTWARDS ARROW FROM BAR" #x27FC)
+    ("LONG LEFTWARDS DOUBLE ARROW FROM BAR" #x27FD)
+    ("LONG RIGHTWARDS DOUBLE ARROW FROM BAR" #x27FE)
+    ("LONG RIGHTWARDS SQUIGGLE ARROW" #x27FF)
+    ))
diff --git a/lisp/nxml/char-name/unicode/02800-028FF.el b/lisp/nxml/char-name/unicode/02800-028FF.el
new file mode 100644
index 00000000000..91876d840bf
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/02800-028FF.el
@@ -0,0 +1,258 @@
+(nxml-define-char-name-set 'braille-patterns
+  '(("BRAILLE PATTERN BLANK" #x2800)
+    ("BRAILLE PATTERN DOTS-1" #x2801)
+    ("BRAILLE PATTERN DOTS-2" #x2802)
+    ("BRAILLE PATTERN DOTS-12" #x2803)
+    ("BRAILLE PATTERN DOTS-3" #x2804)
+    ("BRAILLE PATTERN DOTS-13" #x2805)
+    ("BRAILLE PATTERN DOTS-23" #x2806)
+    ("BRAILLE PATTERN DOTS-123" #x2807)
+    ("BRAILLE PATTERN DOTS-4" #x2808)
+    ("BRAILLE PATTERN DOTS-14" #x2809)
+    ("BRAILLE PATTERN DOTS-24" #x280A)
+    ("BRAILLE PATTERN DOTS-124" #x280B)
+    ("BRAILLE PATTERN DOTS-34" #x280C)
+    ("BRAILLE PATTERN DOTS-134" #x280D)
+    ("BRAILLE PATTERN DOTS-234" #x280E)
+    ("BRAILLE PATTERN DOTS-1234" #x280F)
+    ("BRAILLE PATTERN DOTS-5" #x2810)
+    ("BRAILLE PATTERN DOTS-15" #x2811)
+    ("BRAILLE PATTERN DOTS-25" #x2812)
+    ("BRAILLE PATTERN DOTS-125" #x2813)
+    ("BRAILLE PATTERN DOTS-35" #x2814)
+    ("BRAILLE PATTERN DOTS-135" #x2815)
+    ("BRAILLE PATTERN DOTS-235" #x2816)
+    ("BRAILLE PATTERN DOTS-1235" #x2817)
+    ("BRAILLE PATTERN DOTS-45" #x2818)
+    ("BRAILLE PATTERN DOTS-145" #x2819)
+    ("BRAILLE PATTERN DOTS-245" #x281A)
+    ("BRAILLE PATTERN DOTS-1245" #x281B)
+    ("BRAILLE PATTERN DOTS-345" #x281C)
+    ("BRAILLE PATTERN DOTS-1345" #x281D)
+    ("BRAILLE PATTERN DOTS-2345" #x281E)
+    ("BRAILLE PATTERN DOTS-12345" #x281F)
+    ("BRAILLE PATTERN DOTS-6" #x2820)
+    ("BRAILLE PATTERN DOTS-16" #x2821)
+    ("BRAILLE PATTERN DOTS-26" #x2822)
+    ("BRAILLE PATTERN DOTS-126" #x2823)
+    ("BRAILLE PATTERN DOTS-36" #x2824)
+    ("BRAILLE PATTERN DOTS-136" #x2825)
+    ("BRAILLE PATTERN DOTS-236" #x2826)
+    ("BRAILLE PATTERN DOTS-1236" #x2827)
+    ("BRAILLE PATTERN DOTS-46" #x2828)
+    ("BRAILLE PATTERN DOTS-146" #x2829)
+    ("BRAILLE PATTERN DOTS-246" #x282A)
+    ("BRAILLE PATTERN DOTS-1246" #x282B)
+    ("BRAILLE PATTERN DOTS-346" #x282C)
+    ("BRAILLE PATTERN DOTS-1346" #x282D)
+    ("BRAILLE PATTERN DOTS-2346" #x282E)
+    ("BRAILLE PATTERN DOTS-12346" #x282F)
+    ("BRAILLE PATTERN DOTS-56" #x2830)
+    ("BRAILLE PATTERN DOTS-156" #x2831)
+    ("BRAILLE PATTERN DOTS-256" #x2832)
+    ("BRAILLE PATTERN DOTS-1256" #x2833)
+    ("BRAILLE PATTERN DOTS-356" #x2834)
+    ("BRAILLE PATTERN DOTS-1356" #x2835)
+    ("BRAILLE PATTERN DOTS-2356" #x2836)
+    ("BRAILLE PATTERN DOTS-12356" #x2837)
+    ("BRAILLE PATTERN DOTS-456" #x2838)
+    ("BRAILLE PATTERN DOTS-1456" #x2839)
+    ("BRAILLE PATTERN DOTS-2456" #x283A)
+    ("BRAILLE PATTERN DOTS-12456" #x283B)
+    ("BRAILLE PATTERN DOTS-3456" #x283C)
+    ("BRAILLE PATTERN DOTS-13456" #x283D)
+    ("BRAILLE PATTERN DOTS-23456" #x283E)
+    ("BRAILLE PATTERN DOTS-123456" #x283F)
+    ("BRAILLE PATTERN DOTS-7" #x2840)
+    ("BRAILLE PATTERN DOTS-17" #x2841)
+    ("BRAILLE PATTERN DOTS-27" #x2842)
+    ("BRAILLE PATTERN DOTS-127" #x2843)
+    ("BRAILLE PATTERN DOTS-37" #x2844)
+    ("BRAILLE PATTERN DOTS-137" #x2845)
+    ("BRAILLE PATTERN DOTS-237" #x2846)
+    ("BRAILLE PATTERN DOTS-1237" #x2847)
+    ("BRAILLE PATTERN DOTS-47" #x2848)
+    ("BRAILLE PATTERN DOTS-147" #x2849)
+    ("BRAILLE PATTERN DOTS-247" #x284A)
+    ("BRAILLE PATTERN DOTS-1247" #x284B)
+    ("BRAILLE PATTERN DOTS-347" #x284C)
+    ("BRAILLE PATTERN DOTS-1347" #x284D)
+    ("BRAILLE PATTERN DOTS-2347" #x284E)
+    ("BRAILLE PATTERN DOTS-12347" #x284F)
+    ("BRAILLE PATTERN DOTS-57" #x2850)
+    ("BRAILLE PATTERN DOTS-157" #x2851)
+    ("BRAILLE PATTERN DOTS-257" #x2852)
+    ("BRAILLE PATTERN DOTS-1257" #x2853)
+    ("BRAILLE PATTERN DOTS-357" #x2854)
+    ("BRAILLE PATTERN DOTS-1357" #x2855)
+    ("BRAILLE PATTERN DOTS-2357" #x2856)
+    ("BRAILLE PATTERN DOTS-12357" #x2857)
+    ("BRAILLE PATTERN DOTS-457" #x2858)
+    ("BRAILLE PATTERN DOTS-1457" #x2859)
+    ("BRAILLE PATTERN DOTS-2457" #x285A)
+    ("BRAILLE PATTERN DOTS-12457" #x285B)
+    ("BRAILLE PATTERN DOTS-3457" #x285C)
+    ("BRAILLE PATTERN DOTS-13457" #x285D)
+    ("BRAILLE PATTERN DOTS-23457" #x285E)
+    ("BRAILLE PATTERN DOTS-123457" #x285F)
+    ("BRAILLE PATTERN DOTS-67" #x2860)
+    ("BRAILLE PATTERN DOTS-167" #x2861)
+    ("BRAILLE PATTERN DOTS-267" #x2862)
+    ("BRAILLE PATTERN DOTS-1267" #x2863)
+    ("BRAILLE PATTERN DOTS-367" #x2864)
+    ("BRAILLE PATTERN DOTS-1367" #x2865)
+    ("BRAILLE PATTERN DOTS-2367" #x2866)
+    ("BRAILLE PATTERN DOTS-12367" #x2867)
+    ("BRAILLE PATTERN DOTS-467" #x2868)
+    ("BRAILLE PATTERN DOTS-1467" #x2869)
+    ("BRAILLE PATTERN DOTS-2467" #x286A)
+    ("BRAILLE PATTERN DOTS-12467" #x286B)
+    ("BRAILLE PATTERN DOTS-3467" #x286C)
+    ("BRAILLE PATTERN DOTS-13467" #x286D)
+    ("BRAILLE PATTERN DOTS-23467" #x286E)
+    ("BRAILLE PATTERN DOTS-123467" #x286F)
+    ("BRAILLE PATTERN DOTS-567" #x2870)
+    ("BRAILLE PATTERN DOTS-1567" #x2871)
+    ("BRAILLE PATTERN DOTS-2567" #x2872)
+    ("BRAILLE PATTERN DOTS-12567" #x2873)
+    ("BRAILLE PATTERN DOTS-3567" #x2874)
+    ("BRAILLE PATTERN DOTS-13567" #x2875)
+    ("BRAILLE PATTERN DOTS-23567" #x2876)
+    ("BRAILLE PATTERN DOTS-123567" #x2877)
+    ("BRAILLE PATTERN DOTS-4567" #x2878)
+    ("BRAILLE PATTERN DOTS-14567" #x2879)
+    ("BRAILLE PATTERN DOTS-24567" #x287A)
+    ("BRAILLE PATTERN DOTS-124567" #x287B)
+    ("BRAILLE PATTERN DOTS-34567" #x287C)
+    ("BRAILLE PATTERN DOTS-134567" #x287D)
+    ("BRAILLE PATTERN DOTS-234567" #x287E)
+    ("BRAILLE PATTERN DOTS-1234567" #x287F)
+    ("BRAILLE PATTERN DOTS-8" #x2880)
+    ("BRAILLE PATTERN DOTS-18" #x2881)
+    ("BRAILLE PATTERN DOTS-28" #x2882)
+    ("BRAILLE PATTERN DOTS-128" #x2883)
+    ("BRAILLE PATTERN DOTS-38" #x2884)
+    ("BRAILLE PATTERN DOTS-138" #x2885)
+    ("BRAILLE PATTERN DOTS-238" #x2886)
+    ("BRAILLE PATTERN DOTS-1238" #x2887)
+    ("BRAILLE PATTERN DOTS-48" #x2888)
+    ("BRAILLE PATTERN DOTS-148" #x2889)
+    ("BRAILLE PATTERN DOTS-248" #x288A)
+    ("BRAILLE PATTERN DOTS-1248" #x288B)
+    ("BRAILLE PATTERN DOTS-348" #x288C)
+    ("BRAILLE PATTERN DOTS-1348" #x288D)
+    ("BRAILLE PATTERN DOTS-2348" #x288E)
+    ("BRAILLE PATTERN DOTS-12348" #x288F)
+    ("BRAILLE PATTERN DOTS-58" #x2890)
+    ("BRAILLE PATTERN DOTS-158" #x2891)
+    ("BRAILLE PATTERN DOTS-258" #x2892)
+    ("BRAILLE PATTERN DOTS-1258" #x2893)
+    ("BRAILLE PATTERN DOTS-358" #x2894)
+    ("BRAILLE PATTERN DOTS-1358" #x2895)
+    ("BRAILLE PATTERN DOTS-2358" #x2896)
+    ("BRAILLE PATTERN DOTS-12358" #x2897)
+    ("BRAILLE PATTERN DOTS-458" #x2898)
+    ("BRAILLE PATTERN DOTS-1458" #x2899)
+    ("BRAILLE PATTERN DOTS-2458" #x289A)
+    ("BRAILLE PATTERN DOTS-12458" #x289B)
+    ("BRAILLE PATTERN DOTS-3458" #x289C)
+    ("BRAILLE PATTERN DOTS-13458" #x289D)
+    ("BRAILLE PATTERN DOTS-23458" #x289E)
+    ("BRAILLE PATTERN DOTS-123458" #x289F)
+    ("BRAILLE PATTERN DOTS-68" #x28A0)
+    ("BRAILLE PATTERN DOTS-168" #x28A1)
+    ("BRAILLE PATTERN DOTS-268" #x28A2)
+    ("BRAILLE PATTERN DOTS-1268" #x28A3)
+    ("BRAILLE PATTERN DOTS-368" #x28A4)
+    ("BRAILLE PATTERN DOTS-1368" #x28A5)
+    ("BRAILLE PATTERN DOTS-2368" #x28A6)
+    ("BRAILLE PATTERN DOTS-12368" #x28A7)
+    ("BRAILLE PATTERN DOTS-468" #x28A8)
+    ("BRAILLE PATTERN DOTS-1468" #x28A9)
+    ("BRAILLE PATTERN DOTS-2468" #x28AA)
+    ("BRAILLE PATTERN DOTS-12468" #x28AB)
+    ("BRAILLE PATTERN DOTS-3468" #x28AC)
+    ("BRAILLE PATTERN DOTS-13468" #x28AD)
+    ("BRAILLE PATTERN DOTS-23468" #x28AE)
+    ("BRAILLE PATTERN DOTS-123468" #x28AF)
+    ("BRAILLE PATTERN DOTS-568" #x28B0)
+    ("BRAILLE PATTERN DOTS-1568" #x28B1)
+    ("BRAILLE PATTERN DOTS-2568" #x28B2)
+    ("BRAILLE PATTERN DOTS-12568" #x28B3)
+    ("BRAILLE PATTERN DOTS-3568" #x28B4)
+    ("BRAILLE PATTERN DOTS-13568" #x28B5)
+    ("BRAILLE PATTERN DOTS-23568" #x28B6)
+    ("BRAILLE PATTERN DOTS-123568" #x28B7)
+    ("BRAILLE PATTERN DOTS-4568" #x28B8)
+    ("BRAILLE PATTERN DOTS-14568" #x28B9)
+    ("BRAILLE PATTERN DOTS-24568" #x28BA)
+    ("BRAILLE PATTERN DOTS-124568" #x28BB)
+    ("BRAILLE PATTERN DOTS-34568" #x28BC)
+    ("BRAILLE PATTERN DOTS-134568" #x28BD)
+    ("BRAILLE PATTERN DOTS-234568" #x28BE)
+    ("BRAILLE PATTERN DOTS-1234568" #x28BF)
+    ("BRAILLE PATTERN DOTS-78" #x28C0)
+    ("BRAILLE PATTERN DOTS-178" #x28C1)
+    ("BRAILLE PATTERN DOTS-278" #x28C2)
+    ("BRAILLE PATTERN DOTS-1278" #x28C3)
+    ("BRAILLE PATTERN DOTS-378" #x28C4)
+    ("BRAILLE PATTERN DOTS-1378" #x28C5)
+    ("BRAILLE PATTERN DOTS-2378" #x28C6)
+    ("BRAILLE PATTERN DOTS-12378" #x28C7)
+    ("BRAILLE PATTERN DOTS-478" #x28C8)
+    ("BRAILLE PATTERN DOTS-1478" #x28C9)
+    ("BRAILLE PATTERN DOTS-2478" #x28CA)
+    ("BRAILLE PATTERN DOTS-12478" #x28CB)
+    ("BRAILLE PATTERN DOTS-3478" #x28CC)
+    ("BRAILLE PATTERN DOTS-13478" #x28CD)
+    ("BRAILLE PATTERN DOTS-23478" #x28CE)
+    ("BRAILLE PATTERN DOTS-123478" #x28CF)
+    ("BRAILLE PATTERN DOTS-578" #x28D0)
+    ("BRAILLE PATTERN DOTS-1578" #x28D1)
+    ("BRAILLE PATTERN DOTS-2578" #x28D2)
+    ("BRAILLE PATTERN DOTS-12578" #x28D3)
+    ("BRAILLE PATTERN DOTS-3578" #x28D4)
+    ("BRAILLE PATTERN DOTS-13578" #x28D5)
+    ("BRAILLE PATTERN DOTS-23578" #x28D6)
+    ("BRAILLE PATTERN DOTS-123578" #x28D7)
+    ("BRAILLE PATTERN DOTS-4578" #x28D8)
+    ("BRAILLE PATTERN DOTS-14578" #x28D9)
+    ("BRAILLE PATTERN DOTS-24578" #x28DA)
+    ("BRAILLE PATTERN DOTS-124578" #x28DB)
+    ("BRAILLE PATTERN DOTS-34578" #x28DC)
+    ("BRAILLE PATTERN DOTS-134578" #x28DD)
+    ("BRAILLE PATTERN DOTS-234578" #x28DE)
+    ("BRAILLE PATTERN DOTS-1234578" #x28DF)
+    ("BRAILLE PATTERN DOTS-678" #x28E0)
+    ("BRAILLE PATTERN DOTS-1678" #x28E1)
+    ("BRAILLE PATTERN DOTS-2678" #x28E2)
+    ("BRAILLE PATTERN DOTS-12678" #x28E3)
+    ("BRAILLE PATTERN DOTS-3678" #x28E4)
+    ("BRAILLE PATTERN DOTS-13678" #x28E5)
+    ("BRAILLE PATTERN DOTS-23678" #x28E6)
+    ("BRAILLE PATTERN DOTS-123678" #x28E7)
+    ("BRAILLE PATTERN DOTS-4678" #x28E8)
+    ("BRAILLE PATTERN DOTS-14678" #x28E9)
+    ("BRAILLE PATTERN DOTS-24678" #x28EA)
+    ("BRAILLE PATTERN DOTS-124678" #x28EB)
+    ("BRAILLE PATTERN DOTS-34678" #x28EC)
+    ("BRAILLE PATTERN DOTS-134678" #x28ED)
+    ("BRAILLE PATTERN DOTS-234678" #x28EE)
+    ("BRAILLE PATTERN DOTS-1234678" #x28EF)
+    ("BRAILLE PATTERN DOTS-5678" #x28F0)
+    ("BRAILLE PATTERN DOTS-15678" #x28F1)
+    ("BRAILLE PATTERN DOTS-25678" #x28F2)
+    ("BRAILLE PATTERN DOTS-125678" #x28F3)
+    ("BRAILLE PATTERN DOTS-35678" #x28F4)
+    ("BRAILLE PATTERN DOTS-135678" #x28F5)
+    ("BRAILLE PATTERN DOTS-235678" #x28F6)
+    ("BRAILLE PATTERN DOTS-1235678" #x28F7)
+    ("BRAILLE PATTERN DOTS-45678" #x28F8)
+    ("BRAILLE PATTERN DOTS-145678" #x28F9)
+    ("BRAILLE PATTERN DOTS-245678" #x28FA)
+    ("BRAILLE PATTERN DOTS-1245678" #x28FB)
+    ("BRAILLE PATTERN DOTS-345678" #x28FC)
+    ("BRAILLE PATTERN DOTS-1345678" #x28FD)
+    ("BRAILLE PATTERN DOTS-2345678" #x28FE)
+    ("BRAILLE PATTERN DOTS-12345678" #x28FF)
+    ))
diff --git a/lisp/nxml/char-name/unicode/02900-0297F.el b/lisp/nxml/char-name/unicode/02900-0297F.el
new file mode 100644
index 00000000000..a70eb7fe839
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/02900-0297F.el
@@ -0,0 +1,130 @@
+(nxml-define-char-name-set 'supplemental-arrows-b
+  '(("RIGHTWARDS TWO-HEADED ARROW WITH VERTICAL STROKE" #x2900)
+    ("RIGHTWARDS TWO-HEADED ARROW WITH DOUBLE VERTICAL STROKE" #x2901)
+    ("LEFTWARDS DOUBLE ARROW WITH VERTICAL STROKE" #x2902)
+    ("RIGHTWARDS DOUBLE ARROW WITH VERTICAL STROKE" #x2903)
+    ("LEFT RIGHT DOUBLE ARROW WITH VERTICAL STROKE" #x2904)
+    ("RIGHTWARDS TWO-HEADED ARROW FROM BAR" #x2905)
+    ("LEFTWARDS DOUBLE ARROW FROM BAR" #x2906)
+    ("RIGHTWARDS DOUBLE ARROW FROM BAR" #x2907)
+    ("DOWNWARDS ARROW WITH HORIZONTAL STROKE" #x2908)
+    ("UPWARDS ARROW WITH HORIZONTAL STROKE" #x2909)
+    ("UPWARDS TRIPLE ARROW" #x290A)
+    ("DOWNWARDS TRIPLE ARROW" #x290B)
+    ("LEFTWARDS DOUBLE DASH ARROW" #x290C)
+    ("RIGHTWARDS DOUBLE DASH ARROW" #x290D)
+    ("LEFTWARDS TRIPLE DASH ARROW" #x290E)
+    ("RIGHTWARDS TRIPLE DASH ARROW" #x290F)
+    ("RIGHTWARDS TWO-HEADED TRIPLE DASH ARROW" #x2910)
+    ("RIGHTWARDS ARROW WITH DOTTED STEM" #x2911)
+    ("UPWARDS ARROW TO BAR" #x2912)
+    ("DOWNWARDS ARROW TO BAR" #x2913)
+    ("RIGHTWARDS ARROW WITH TAIL WITH VERTICAL STROKE" #x2914)
+    ("RIGHTWARDS ARROW WITH TAIL WITH DOUBLE VERTICAL STROKE" #x2915)
+    ("RIGHTWARDS TWO-HEADED ARROW WITH TAIL" #x2916)
+    ("RIGHTWARDS TWO-HEADED ARROW WITH TAIL WITH VERTICAL STROKE" #x2917)
+    ("RIGHTWARDS TWO-HEADED ARROW WITH TAIL WITH DOUBLE VERTICAL STROKE" #x2918)
+    ("LEFTWARDS ARROW-TAIL" #x2919)
+    ("RIGHTWARDS ARROW-TAIL" #x291A)
+    ("LEFTWARDS DOUBLE ARROW-TAIL" #x291B)
+    ("RIGHTWARDS DOUBLE ARROW-TAIL" #x291C)
+    ("LEFTWARDS ARROW TO BLACK DIAMOND" #x291D)
+    ("RIGHTWARDS ARROW TO BLACK DIAMOND" #x291E)
+    ("LEFTWARDS ARROW FROM BAR TO BLACK DIAMOND" #x291F)
+    ("RIGHTWARDS ARROW FROM BAR TO BLACK DIAMOND" #x2920)
+    ("NORTH WEST AND SOUTH EAST ARROW" #x2921)
+    ("NORTH EAST AND SOUTH WEST ARROW" #x2922)
+    ("NORTH WEST ARROW WITH HOOK" #x2923)
+    ("NORTH EAST ARROW WITH HOOK" #x2924)
+    ("SOUTH EAST ARROW WITH HOOK" #x2925)
+    ("SOUTH WEST ARROW WITH HOOK" #x2926)
+    ("NORTH WEST ARROW AND NORTH EAST ARROW" #x2927)
+    ("NORTH EAST ARROW AND SOUTH EAST ARROW" #x2928)
+    ("SOUTH EAST ARROW AND SOUTH WEST ARROW" #x2929)
+    ("SOUTH WEST ARROW AND NORTH WEST ARROW" #x292A)
+    ("RISING DIAGONAL CROSSING FALLING DIAGONAL" #x292B)
+    ("FALLING DIAGONAL CROSSING RISING DIAGONAL" #x292C)
+    ("SOUTH EAST ARROW CROSSING NORTH EAST ARROW" #x292D)
+    ("NORTH EAST ARROW CROSSING SOUTH EAST ARROW" #x292E)
+    ("FALLING DIAGONAL CROSSING NORTH EAST ARROW" #x292F)
+    ("RISING DIAGONAL CROSSING SOUTH EAST ARROW" #x2930)
+    ("NORTH EAST ARROW CROSSING NORTH WEST ARROW" #x2931)
+    ("NORTH WEST ARROW CROSSING NORTH EAST ARROW" #x2932)
+    ("WAVE ARROW POINTING DIRECTLY RIGHT" #x2933)
+    ("ARROW POINTING RIGHTWARDS THEN CURVING UPWARDS" #x2934)
+    ("ARROW POINTING RIGHTWARDS THEN CURVING DOWNWARDS" #x2935)
+    ("ARROW POINTING DOWNWARDS THEN CURVING LEFTWARDS" #x2936)
+    ("ARROW POINTING DOWNWARDS THEN CURVING RIGHTWARDS" #x2937)
+    ("RIGHT-SIDE ARC CLOCKWISE ARROW" #x2938)
+    ("LEFT-SIDE ARC ANTICLOCKWISE ARROW" #x2939)
+    ("TOP ARC ANTICLOCKWISE ARROW" #x293A)
+    ("BOTTOM ARC ANTICLOCKWISE ARROW" #x293B)
+    ("TOP ARC CLOCKWISE ARROW WITH MINUS" #x293C)
+    ("TOP ARC ANTICLOCKWISE ARROW WITH PLUS" #x293D)
+    ("LOWER RIGHT SEMICIRCULAR CLOCKWISE ARROW" #x293E)
+    ("LOWER LEFT SEMICIRCULAR ANTICLOCKWISE ARROW" #x293F)
+    ("ANTICLOCKWISE CLOSED CIRCLE ARROW" #x2940)
+    ("CLOCKWISE CLOSED CIRCLE ARROW" #x2941)
+    ("RIGHTWARDS ARROW ABOVE SHORT LEFTWARDS ARROW" #x2942)
+    ("LEFTWARDS ARROW ABOVE SHORT RIGHTWARDS ARROW" #x2943)
+    ("SHORT RIGHTWARDS ARROW ABOVE LEFTWARDS ARROW" #x2944)
+    ("RIGHTWARDS ARROW WITH PLUS BELOW" #x2945)
+    ("LEFTWARDS ARROW WITH PLUS BELOW" #x2946)
+    ("RIGHTWARDS ARROW THROUGH X" #x2947)
+    ("LEFT RIGHT ARROW THROUGH SMALL CIRCLE" #x2948)
+    ("UPWARDS TWO-HEADED ARROW FROM SMALL CIRCLE" #x2949)
+    ("LEFT BARB UP RIGHT BARB DOWN HARPOON" #x294A)
+    ("LEFT BARB DOWN RIGHT BARB UP HARPOON" #x294B)
+    ("UP BARB RIGHT DOWN BARB LEFT HARPOON" #x294C)
+    ("UP BARB LEFT DOWN BARB RIGHT HARPOON" #x294D)
+    ("LEFT BARB UP RIGHT BARB UP HARPOON" #x294E)
+    ("UP BARB RIGHT DOWN BARB RIGHT HARPOON" #x294F)
+    ("LEFT BARB DOWN RIGHT BARB DOWN HARPOON" #x2950)
+    ("UP BARB LEFT DOWN BARB LEFT HARPOON" #x2951)
+    ("LEFTWARDS HARPOON WITH BARB UP TO BAR" #x2952)
+    ("RIGHTWARDS HARPOON WITH BARB UP TO BAR" #x2953)
+    ("UPWARDS HARPOON WITH BARB RIGHT TO BAR" #x2954)
+    ("DOWNWARDS HARPOON WITH BARB RIGHT TO BAR" #x2955)
+    ("LEFTWARDS HARPOON WITH BARB DOWN TO BAR" #x2956)
+    ("RIGHTWARDS HARPOON WITH BARB DOWN TO BAR" #x2957)
+    ("UPWARDS HARPOON WITH BARB LEFT TO BAR" #x2958)
+    ("DOWNWARDS HARPOON WITH BARB LEFT TO BAR" #x2959)
+    ("LEFTWARDS HARPOON WITH BARB UP FROM BAR" #x295A)
+    ("RIGHTWARDS HARPOON WITH BARB UP FROM BAR" #x295B)
+    ("UPWARDS HARPOON WITH BARB RIGHT FROM BAR" #x295C)
+    ("DOWNWARDS HARPOON WITH BARB RIGHT FROM BAR" #x295D)
+    ("LEFTWARDS HARPOON WITH BARB DOWN FROM BAR" #x295E)
+    ("RIGHTWARDS HARPOON WITH BARB DOWN FROM BAR" #x295F)
+    ("UPWARDS HARPOON WITH BARB LEFT FROM BAR" #x2960)
+    ("DOWNWARDS HARPOON WITH BARB LEFT FROM BAR" #x2961)
+    ("LEFTWARDS HARPOON WITH BARB UP ABOVE LEFTWARDS HARPOON WITH BARB DOWN" #x2962)
+    ("UPWARDS HARPOON WITH BARB LEFT BESIDE UPWARDS HARPOON WITH BARB RIGHT" #x2963)
+    ("RIGHTWARDS HARPOON WITH BARB UP ABOVE RIGHTWARDS HARPOON WITH BARB DOWN" #x2964)
+    ("DOWNWARDS HARPOON WITH BARB LEFT BESIDE DOWNWARDS HARPOON WITH BARB RIGHT" #x2965)
+    ("LEFTWARDS HARPOON WITH BARB UP ABOVE RIGHTWARDS HARPOON WITH BARB UP" #x2966)
+    ("LEFTWARDS HARPOON WITH BARB DOWN ABOVE RIGHTWARDS HARPOON WITH BARB DOWN" #x2967)
+    ("RIGHTWARDS HARPOON WITH BARB UP ABOVE LEFTWARDS HARPOON WITH BARB UP" #x2968)
+    ("RIGHTWARDS HARPOON WITH BARB DOWN ABOVE LEFTWARDS HARPOON WITH BARB DOWN" #x2969)
+    ("LEFTWARDS HARPOON WITH BARB UP ABOVE LONG DASH" #x296A)
+    ("LEFTWARDS HARPOON WITH BARB DOWN BELOW LONG DASH" #x296B)
+    ("RIGHTWARDS HARPOON WITH BARB UP ABOVE LONG DASH" #x296C)
+    ("RIGHTWARDS HARPOON WITH BARB DOWN BELOW LONG DASH" #x296D)
+    ("UPWARDS HARPOON WITH BARB LEFT BESIDE DOWNWARDS HARPOON WITH BARB RIGHT" #x296E)
+    ("DOWNWARDS HARPOON WITH BARB LEFT BESIDE UPWARDS HARPOON WITH BARB RIGHT" #x296F)
+    ("RIGHT DOUBLE ARROW WITH ROUNDED HEAD" #x2970)
+    ("EQUALS SIGN ABOVE RIGHTWARDS ARROW" #x2971)
+    ("TILDE OPERATOR ABOVE RIGHTWARDS ARROW" #x2972)
+    ("LEFTWARDS ARROW ABOVE TILDE OPERATOR" #x2973)
+    ("RIGHTWARDS ARROW ABOVE TILDE OPERATOR" #x2974)
+    ("RIGHTWARDS ARROW ABOVE ALMOST EQUAL TO" #x2975)
+    ("LESS-THAN ABOVE LEFTWARDS ARROW" #x2976)
+    ("LEFTWARDS ARROW THROUGH LESS-THAN" #x2977)
+    ("GREATER-THAN ABOVE RIGHTWARDS ARROW" #x2978)
+    ("SUBSET ABOVE RIGHTWARDS ARROW" #x2979)
+    ("LEFTWARDS ARROW THROUGH SUBSET" #x297A)
+    ("SUPERSET ABOVE LEFTWARDS ARROW" #x297B)
+    ("LEFT FISH TAIL" #x297C)
+    ("RIGHT FISH TAIL" #x297D)
+    ("UP FISH TAIL" #x297E)
+    ("DOWN FISH TAIL" #x297F)
+    ))
diff --git a/lisp/nxml/char-name/unicode/02980-029FF.el b/lisp/nxml/char-name/unicode/02980-029FF.el
new file mode 100644
index 00000000000..f1e368783a6
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/02980-029FF.el
@@ -0,0 +1,130 @@
+(nxml-define-char-name-set 'miscellaneous-mathematical-symbols-b
+  '(("TRIPLE VERTICAL BAR DELIMITER" #x2980)
+    ("Z NOTATION SPOT" #x2981)
+    ("Z NOTATION TYPE COLON" #x2982)
+    ("LEFT WHITE CURLY BRACKET" #x2983)
+    ("RIGHT WHITE CURLY BRACKET" #x2984)
+    ("LEFT WHITE PARENTHESIS" #x2985)
+    ("RIGHT WHITE PARENTHESIS" #x2986)
+    ("Z NOTATION LEFT IMAGE BRACKET" #x2987)
+    ("Z NOTATION RIGHT IMAGE BRACKET" #x2988)
+    ("Z NOTATION LEFT BINDING BRACKET" #x2989)
+    ("Z NOTATION RIGHT BINDING BRACKET" #x298A)
+    ("LEFT SQUARE BRACKET WITH UNDERBAR" #x298B)
+    ("RIGHT SQUARE BRACKET WITH UNDERBAR" #x298C)
+    ("LEFT SQUARE BRACKET WITH TICK IN TOP CORNER" #x298D)
+    ("RIGHT SQUARE BRACKET WITH TICK IN BOTTOM CORNER" #x298E)
+    ("LEFT SQUARE BRACKET WITH TICK IN BOTTOM CORNER" #x298F)
+    ("RIGHT SQUARE BRACKET WITH TICK IN TOP CORNER" #x2990)
+    ("LEFT ANGLE BRACKET WITH DOT" #x2991)
+    ("RIGHT ANGLE BRACKET WITH DOT" #x2992)
+    ("LEFT ARC LESS-THAN BRACKET" #x2993)
+    ("RIGHT ARC GREATER-THAN BRACKET" #x2994)
+    ("DOUBLE LEFT ARC GREATER-THAN BRACKET" #x2995)
+    ("DOUBLE RIGHT ARC LESS-THAN BRACKET" #x2996)
+    ("LEFT BLACK TORTOISE SHELL BRACKET" #x2997)
+    ("RIGHT BLACK TORTOISE SHELL BRACKET" #x2998)
+    ("DOTTED FENCE" #x2999)
+    ("VERTICAL ZIGZAG LINE" #x299A)
+    ("MEASURED ANGLE OPENING LEFT" #x299B)
+    ("RIGHT ANGLE VARIANT WITH SQUARE" #x299C)
+    ("MEASURED RIGHT ANGLE WITH DOT" #x299D)
+    ("ANGLE WITH S INSIDE" #x299E)
+    ("ACUTE ANGLE" #x299F)
+    ("SPHERICAL ANGLE OPENING LEFT" #x29A0)
+    ("SPHERICAL ANGLE OPENING UP" #x29A1)
+    ("TURNED ANGLE" #x29A2)
+    ("REVERSED ANGLE" #x29A3)
+    ("ANGLE WITH UNDERBAR" #x29A4)
+    ("REVERSED ANGLE WITH UNDERBAR" #x29A5)
+    ("OBLIQUE ANGLE OPENING UP" #x29A6)
+    ("OBLIQUE ANGLE OPENING DOWN" #x29A7)
+    ("MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING UP AND RIGHT" #x29A8)
+    ("MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING UP AND LEFT" #x29A9)
+    ("MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING DOWN AND RIGHT" #x29AA)
+    ("MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING DOWN AND LEFT" #x29AB)
+    ("MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING RIGHT AND UP" #x29AC)
+    ("MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING LEFT AND UP" #x29AD)
+    ("MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING RIGHT AND DOWN" #x29AE)
+    ("MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING LEFT AND DOWN" #x29AF)
+    ("REVERSED EMPTY SET" #x29B0)
+    ("EMPTY SET WITH OVERBAR" #x29B1)
+    ("EMPTY SET WITH SMALL CIRCLE ABOVE" #x29B2)
+    ("EMPTY SET WITH RIGHT ARROW ABOVE" #x29B3)
+    ("EMPTY SET WITH LEFT ARROW ABOVE" #x29B4)
+    ("CIRCLE WITH HORIZONTAL BAR" #x29B5)
+    ("CIRCLED VERTICAL BAR" #x29B6)
+    ("CIRCLED PARALLEL" #x29B7)
+    ("CIRCLED REVERSE SOLIDUS" #x29B8)
+    ("CIRCLED PERPENDICULAR" #x29B9)
+    ("CIRCLE DIVIDED BY HORIZONTAL BAR AND TOP HALF DIVIDED BY VERTICAL BAR" #x29BA)
+    ("CIRCLE WITH SUPERIMPOSED X" #x29BB)
+    ("CIRCLED ANTICLOCKWISE-ROTATED DIVISION SIGN" #x29BC)
+    ("UP ARROW THROUGH CIRCLE" #x29BD)
+    ("CIRCLED WHITE BULLET" #x29BE)
+    ("CIRCLED BULLET" #x29BF)
+    ("CIRCLED LESS-THAN" #x29C0)
+    ("CIRCLED GREATER-THAN" #x29C1)
+    ("CIRCLE WITH SMALL CIRCLE TO THE RIGHT" #x29C2)
+    ("CIRCLE WITH TWO HORIZONTAL STROKES TO THE RIGHT" #x29C3)
+    ("SQUARED RISING DIAGONAL SLASH" #x29C4)
+    ("SQUARED FALLING DIAGONAL SLASH" #x29C5)
+    ("SQUARED ASTERISK" #x29C6)
+    ("SQUARED SMALL CIRCLE" #x29C7)
+    ("SQUARED SQUARE" #x29C8)
+    ("TWO JOINED SQUARES" #x29C9)
+    ("TRIANGLE WITH DOT ABOVE" #x29CA)
+    ("TRIANGLE WITH UNDERBAR" #x29CB)
+    ("S IN TRIANGLE" #x29CC)
+    ("TRIANGLE WITH SERIFS AT BOTTOM" #x29CD)
+    ("RIGHT TRIANGLE ABOVE LEFT TRIANGLE" #x29CE)
+    ("LEFT TRIANGLE BESIDE VERTICAL BAR" #x29CF)
+    ("VERTICAL BAR BESIDE RIGHT TRIANGLE" #x29D0)
+    ("BOWTIE WITH LEFT HALF BLACK" #x29D1)
+    ("BOWTIE WITH RIGHT HALF BLACK" #x29D2)
+    ("BLACK BOWTIE" #x29D3)
+    ("TIMES WITH LEFT HALF BLACK" #x29D4)
+    ("TIMES WITH RIGHT HALF BLACK" #x29D5)
+    ("WHITE HOURGLASS" #x29D6)
+    ("BLACK HOURGLASS" #x29D7)
+    ("LEFT WIGGLY FENCE" #x29D8)
+    ("RIGHT WIGGLY FENCE" #x29D9)
+    ("LEFT DOUBLE WIGGLY FENCE" #x29DA)
+    ("RIGHT DOUBLE WIGGLY FENCE" #x29DB)
+    ("INCOMPLETE INFINITY" #x29DC)
+    ("TIE OVER INFINITY" #x29DD)
+    ("INFINITY NEGATED WITH VERTICAL BAR" #x29DE)
+    ("DOUBLE-ENDED MULTIMAP" #x29DF)
+    ("SQUARE WITH CONTOURED OUTLINE" #x29E0)
+    ("INCREASES AS" #x29E1)
+    ("SHUFFLE PRODUCT" #x29E2)
+    ("EQUALS SIGN AND SLANTED PARALLEL" #x29E3)
+    ("EQUALS SIGN AND SLANTED PARALLEL WITH TILDE ABOVE" #x29E4)
+    ("IDENTICAL TO AND SLANTED PARALLEL" #x29E5)
+    ("GLEICH STARK" #x29E6)
+    ("THERMODYNAMIC" #x29E7)
+    ("DOWN-POINTING TRIANGLE WITH LEFT HALF BLACK" #x29E8)
+    ("DOWN-POINTING TRIANGLE WITH RIGHT HALF BLACK" #x29E9)
+    ("BLACK DIAMOND WITH DOWN ARROW" #x29EA)
+    ("BLACK LOZENGE" #x29EB)
+    ("WHITE CIRCLE WITH DOWN ARROW" #x29EC)
+    ("BLACK CIRCLE WITH DOWN ARROW" #x29ED)
+    ("ERROR-BARRED WHITE SQUARE" #x29EE)
+    ("ERROR-BARRED BLACK SQUARE" #x29EF)
+    ("ERROR-BARRED WHITE DIAMOND" #x29F0)
+    ("ERROR-BARRED BLACK DIAMOND" #x29F1)
+    ("ERROR-BARRED WHITE CIRCLE" #x29F2)
+    ("ERROR-BARRED BLACK CIRCLE" #x29F3)
+    ("RULE-DELAYED" #x29F4)
+    ("REVERSE SOLIDUS OPERATOR" #x29F5)
+    ("SOLIDUS WITH OVERBAR" #x29F6)
+    ("REVERSE SOLIDUS WITH HORIZONTAL STROKE" #x29F7)
+    ("BIG SOLIDUS" #x29F8)
+    ("BIG REVERSE SOLIDUS" #x29F9)
+    ("DOUBLE PLUS" #x29FA)
+    ("TRIPLE PLUS" #x29FB)
+    ("LEFT-POINTING CURVED ANGLE BRACKET" #x29FC)
+    ("RIGHT-POINTING CURVED ANGLE BRACKET" #x29FD)
+    ("TINY" #x29FE)
+    ("MINY" #x29FF)
+    ))
diff --git a/lisp/nxml/char-name/unicode/02A00-02AFF.el b/lisp/nxml/char-name/unicode/02A00-02AFF.el
new file mode 100644
index 00000000000..e6f9ca432bb
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/02A00-02AFF.el
@@ -0,0 +1,258 @@
+(nxml-define-char-name-set 'supplemental-mathematical-operators
+  '(("N-ARY CIRCLED DOT OPERATOR" #x2A00)
+    ("N-ARY CIRCLED PLUS OPERATOR" #x2A01)
+    ("N-ARY CIRCLED TIMES OPERATOR" #x2A02)
+    ("N-ARY UNION OPERATOR WITH DOT" #x2A03)
+    ("N-ARY UNION OPERATOR WITH PLUS" #x2A04)
+    ("N-ARY SQUARE INTERSECTION OPERATOR" #x2A05)
+    ("N-ARY SQUARE UNION OPERATOR" #x2A06)
+    ("TWO LOGICAL AND OPERATOR" #x2A07)
+    ("TWO LOGICAL OR OPERATOR" #x2A08)
+    ("N-ARY TIMES OPERATOR" #x2A09)
+    ("MODULO TWO SUM" #x2A0A)
+    ("SUMMATION WITH INTEGRAL" #x2A0B)
+    ("QUADRUPLE INTEGRAL OPERATOR" #x2A0C)
+    ("FINITE PART INTEGRAL" #x2A0D)
+    ("INTEGRAL WITH DOUBLE STROKE" #x2A0E)
+    ("INTEGRAL AVERAGE WITH SLASH" #x2A0F)
+    ("CIRCULATION FUNCTION" #x2A10)
+    ("ANTICLOCKWISE INTEGRATION" #x2A11)
+    ("LINE INTEGRATION WITH RECTANGULAR PATH AROUND POLE" #x2A12)
+    ("LINE INTEGRATION WITH SEMICIRCULAR PATH AROUND POLE" #x2A13)
+    ("LINE INTEGRATION NOT INCLUDING THE POLE" #x2A14)
+    ("INTEGRAL AROUND A POINT OPERATOR" #x2A15)
+    ("QUATERNION INTEGRAL OPERATOR" #x2A16)
+    ("INTEGRAL WITH LEFTWARDS ARROW WITH HOOK" #x2A17)
+    ("INTEGRAL WITH TIMES SIGN" #x2A18)
+    ("INTEGRAL WITH INTERSECTION" #x2A19)
+    ("INTEGRAL WITH UNION" #x2A1A)
+    ("INTEGRAL WITH OVERBAR" #x2A1B)
+    ("INTEGRAL WITH UNDERBAR" #x2A1C)
+    ("JOIN" #x2A1D)
+    ("LARGE LEFT TRIANGLE OPERATOR" #x2A1E)
+    ("Z NOTATION SCHEMA COMPOSITION" #x2A1F)
+    ("Z NOTATION SCHEMA PIPING" #x2A20)
+    ("Z NOTATION SCHEMA PROJECTION" #x2A21)
+    ("PLUS SIGN WITH SMALL CIRCLE ABOVE" #x2A22)
+    ("PLUS SIGN WITH CIRCUMFLEX ACCENT ABOVE" #x2A23)
+    ("PLUS SIGN WITH TILDE ABOVE" #x2A24)
+    ("PLUS SIGN WITH DOT BELOW" #x2A25)
+    ("PLUS SIGN WITH TILDE BELOW" #x2A26)
+    ("PLUS SIGN WITH SUBSCRIPT TWO" #x2A27)
+    ("PLUS SIGN WITH BLACK TRIANGLE" #x2A28)
+    ("MINUS SIGN WITH COMMA ABOVE" #x2A29)
+    ("MINUS SIGN WITH DOT BELOW" #x2A2A)
+    ("MINUS SIGN WITH FALLING DOTS" #x2A2B)
+    ("MINUS SIGN WITH RISING DOTS" #x2A2C)
+    ("PLUS SIGN IN LEFT HALF CIRCLE" #x2A2D)
+    ("PLUS SIGN IN RIGHT HALF CIRCLE" #x2A2E)
+    ("VECTOR OR CROSS PRODUCT" #x2A2F)
+    ("MULTIPLICATION SIGN WITH DOT ABOVE" #x2A30)
+    ("MULTIPLICATION SIGN WITH UNDERBAR" #x2A31)
+    ("SEMIDIRECT PRODUCT WITH BOTTOM CLOSED" #x2A32)
+    ("SMASH PRODUCT" #x2A33)
+    ("MULTIPLICATION SIGN IN LEFT HALF CIRCLE" #x2A34)
+    ("MULTIPLICATION SIGN IN RIGHT HALF CIRCLE" #x2A35)
+    ("CIRCLED MULTIPLICATION SIGN WITH CIRCUMFLEX ACCENT" #x2A36)
+    ("MULTIPLICATION SIGN IN DOUBLE CIRCLE" #x2A37)
+    ("CIRCLED DIVISION SIGN" #x2A38)
+    ("PLUS SIGN IN TRIANGLE" #x2A39)
+    ("MINUS SIGN IN TRIANGLE" #x2A3A)
+    ("MULTIPLICATION SIGN IN TRIANGLE" #x2A3B)
+    ("INTERIOR PRODUCT" #x2A3C)
+    ("RIGHTHAND INTERIOR PRODUCT" #x2A3D)
+    ("Z NOTATION RELATIONAL COMPOSITION" #x2A3E)
+    ("AMALGAMATION OR COPRODUCT" #x2A3F)
+    ("INTERSECTION WITH DOT" #x2A40)
+    ("UNION WITH MINUS SIGN" #x2A41)
+    ("UNION WITH OVERBAR" #x2A42)
+    ("INTERSECTION WITH OVERBAR" #x2A43)
+    ("INTERSECTION WITH LOGICAL AND" #x2A44)
+    ("UNION WITH LOGICAL OR" #x2A45)
+    ("UNION ABOVE INTERSECTION" #x2A46)
+    ("INTERSECTION ABOVE UNION" #x2A47)
+    ("UNION ABOVE BAR ABOVE INTERSECTION" #x2A48)
+    ("INTERSECTION ABOVE BAR ABOVE UNION" #x2A49)
+    ("UNION BESIDE AND JOINED WITH UNION" #x2A4A)
+    ("INTERSECTION BESIDE AND JOINED WITH INTERSECTION" #x2A4B)
+    ("CLOSED UNION WITH SERIFS" #x2A4C)
+    ("CLOSED INTERSECTION WITH SERIFS" #x2A4D)
+    ("DOUBLE SQUARE INTERSECTION" #x2A4E)
+    ("DOUBLE SQUARE UNION" #x2A4F)
+    ("CLOSED UNION WITH SERIFS AND SMASH PRODUCT" #x2A50)
+    ("LOGICAL AND WITH DOT ABOVE" #x2A51)
+    ("LOGICAL OR WITH DOT ABOVE" #x2A52)
+    ("DOUBLE LOGICAL AND" #x2A53)
+    ("DOUBLE LOGICAL OR" #x2A54)
+    ("TWO INTERSECTING LOGICAL AND" #x2A55)
+    ("TWO INTERSECTING LOGICAL OR" #x2A56)
+    ("SLOPING LARGE OR" #x2A57)
+    ("SLOPING LARGE AND" #x2A58)
+    ("LOGICAL OR OVERLAPPING LOGICAL AND" #x2A59)
+    ("LOGICAL AND WITH MIDDLE STEM" #x2A5A)
+    ("LOGICAL OR WITH MIDDLE STEM" #x2A5B)
+    ("LOGICAL AND WITH HORIZONTAL DASH" #x2A5C)
+    ("LOGICAL OR WITH HORIZONTAL DASH" #x2A5D)
+    ("LOGICAL AND WITH DOUBLE OVERBAR" #x2A5E)
+    ("LOGICAL AND WITH UNDERBAR" #x2A5F)
+    ("LOGICAL AND WITH DOUBLE UNDERBAR" #x2A60)
+    ("SMALL VEE WITH UNDERBAR" #x2A61)
+    ("LOGICAL OR WITH DOUBLE OVERBAR" #x2A62)
+    ("LOGICAL OR WITH DOUBLE UNDERBAR" #x2A63)
+    ("Z NOTATION DOMAIN ANTIRESTRICTION" #x2A64)
+    ("Z NOTATION RANGE ANTIRESTRICTION" #x2A65)
+    ("EQUALS SIGN WITH DOT BELOW" #x2A66)
+    ("IDENTICAL WITH DOT ABOVE" #x2A67)
+    ("TRIPLE HORIZONTAL BAR WITH DOUBLE VERTICAL STROKE" #x2A68)
+    ("TRIPLE HORIZONTAL BAR WITH TRIPLE VERTICAL STROKE" #x2A69)
+    ("TILDE OPERATOR WITH DOT ABOVE" #x2A6A)
+    ("TILDE OPERATOR WITH RISING DOTS" #x2A6B)
+    ("SIMILAR MINUS SIMILAR" #x2A6C)
+    ("CONGRUENT WITH DOT ABOVE" #x2A6D)
+    ("EQUALS WITH ASTERISK" #x2A6E)
+    ("ALMOST EQUAL TO WITH CIRCUMFLEX ACCENT" #x2A6F)
+    ("APPROXIMATELY EQUAL OR EQUAL TO" #x2A70)
+    ("EQUALS SIGN ABOVE PLUS SIGN" #x2A71)
+    ("PLUS SIGN ABOVE EQUALS SIGN" #x2A72)
+    ("EQUALS SIGN ABOVE TILDE OPERATOR" #x2A73)
+    ("DOUBLE COLON EQUAL" #x2A74)
+    ("TWO CONSECUTIVE EQUALS SIGNS" #x2A75)
+    ("THREE CONSECUTIVE EQUALS SIGNS" #x2A76)
+    ("EQUALS SIGN WITH TWO DOTS ABOVE AND TWO DOTS BELOW" #x2A77)
+    ("EQUIVALENT WITH FOUR DOTS ABOVE" #x2A78)
+    ("LESS-THAN WITH CIRCLE INSIDE" #x2A79)
+    ("GREATER-THAN WITH CIRCLE INSIDE" #x2A7A)
+    ("LESS-THAN WITH QUESTION MARK ABOVE" #x2A7B)
+    ("GREATER-THAN WITH QUESTION MARK ABOVE" #x2A7C)
+    ("LESS-THAN OR SLANTED EQUAL TO" #x2A7D)
+    ("GREATER-THAN OR SLANTED EQUAL TO" #x2A7E)
+    ("LESS-THAN OR SLANTED EQUAL TO WITH DOT INSIDE" #x2A7F)
+    ("GREATER-THAN OR SLANTED EQUAL TO WITH DOT INSIDE" #x2A80)
+    ("LESS-THAN OR SLANTED EQUAL TO WITH DOT ABOVE" #x2A81)
+    ("GREATER-THAN OR SLANTED EQUAL TO WITH DOT ABOVE" #x2A82)
+    ("LESS-THAN OR SLANTED EQUAL TO WITH DOT ABOVE RIGHT" #x2A83)
+    ("GREATER-THAN OR SLANTED EQUAL TO WITH DOT ABOVE LEFT" #x2A84)
+    ("LESS-THAN OR APPROXIMATE" #x2A85)
+    ("GREATER-THAN OR APPROXIMATE" #x2A86)
+    ("LESS-THAN AND SINGLE-LINE NOT EQUAL TO" #x2A87)
+    ("GREATER-THAN AND SINGLE-LINE NOT EQUAL TO" #x2A88)
+    ("LESS-THAN AND NOT APPROXIMATE" #x2A89)
+    ("GREATER-THAN AND NOT APPROXIMATE" #x2A8A)
+    ("LESS-THAN ABOVE DOUBLE-LINE EQUAL ABOVE GREATER-THAN" #x2A8B)
+    ("GREATER-THAN ABOVE DOUBLE-LINE EQUAL ABOVE LESS-THAN" #x2A8C)
+    ("LESS-THAN ABOVE SIMILAR OR EQUAL" #x2A8D)
+    ("GREATER-THAN ABOVE SIMILAR OR EQUAL" #x2A8E)
+    ("LESS-THAN ABOVE SIMILAR ABOVE GREATER-THAN" #x2A8F)
+    ("GREATER-THAN ABOVE SIMILAR ABOVE LESS-THAN" #x2A90)
+    ("LESS-THAN ABOVE GREATER-THAN ABOVE DOUBLE-LINE EQUAL" #x2A91)
+    ("GREATER-THAN ABOVE LESS-THAN ABOVE DOUBLE-LINE EQUAL" #x2A92)
+    ("LESS-THAN ABOVE SLANTED EQUAL ABOVE GREATER-THAN ABOVE SLANTED EQUAL" #x2A93)
+    ("GREATER-THAN ABOVE SLANTED EQUAL ABOVE LESS-THAN ABOVE SLANTED EQUAL" #x2A94)
+    ("SLANTED EQUAL TO OR LESS-THAN" #x2A95)
+    ("SLANTED EQUAL TO OR GREATER-THAN" #x2A96)
+    ("SLANTED EQUAL TO OR LESS-THAN WITH DOT INSIDE" #x2A97)
+    ("SLANTED EQUAL TO OR GREATER-THAN WITH DOT INSIDE" #x2A98)
+    ("DOUBLE-LINE EQUAL TO OR LESS-THAN" #x2A99)
+    ("DOUBLE-LINE EQUAL TO OR GREATER-THAN" #x2A9A)
+    ("DOUBLE-LINE SLANTED EQUAL TO OR LESS-THAN" #x2A9B)
+    ("DOUBLE-LINE SLANTED EQUAL TO OR GREATER-THAN" #x2A9C)
+    ("SIMILAR OR LESS-THAN" #x2A9D)
+    ("SIMILAR OR GREATER-THAN" #x2A9E)
+    ("SIMILAR ABOVE LESS-THAN ABOVE EQUALS SIGN" #x2A9F)
+    ("SIMILAR ABOVE GREATER-THAN ABOVE EQUALS SIGN" #x2AA0)
+    ("DOUBLE NESTED LESS-THAN" #x2AA1)
+    ("DOUBLE NESTED GREATER-THAN" #x2AA2)
+    ("DOUBLE NESTED LESS-THAN WITH UNDERBAR" #x2AA3)
+    ("GREATER-THAN OVERLAPPING LESS-THAN" #x2AA4)
+    ("GREATER-THAN BESIDE LESS-THAN" #x2AA5)
+    ("LESS-THAN CLOSED BY CURVE" #x2AA6)
+    ("GREATER-THAN CLOSED BY CURVE" #x2AA7)
+    ("LESS-THAN CLOSED BY CURVE ABOVE SLANTED EQUAL" #x2AA8)
+    ("GREATER-THAN CLOSED BY CURVE ABOVE SLANTED EQUAL" #x2AA9)
+    ("SMALLER THAN" #x2AAA)
+    ("LARGER THAN" #x2AAB)
+    ("SMALLER THAN OR EQUAL TO" #x2AAC)
+    ("LARGER THAN OR EQUAL TO" #x2AAD)
+    ("EQUALS SIGN WITH BUMPY ABOVE" #x2AAE)
+    ("PRECEDES ABOVE SINGLE-LINE EQUALS SIGN" #x2AAF)
+    ("SUCCEEDS ABOVE SINGLE-LINE EQUALS SIGN" #x2AB0)
+    ("PRECEDES ABOVE SINGLE-LINE NOT EQUAL TO" #x2AB1)
+    ("SUCCEEDS ABOVE SINGLE-LINE NOT EQUAL TO" #x2AB2)
+    ("PRECEDES ABOVE EQUALS SIGN" #x2AB3)
+    ("SUCCEEDS ABOVE EQUALS SIGN" #x2AB4)
+    ("PRECEDES ABOVE NOT EQUAL TO" #x2AB5)
+    ("SUCCEEDS ABOVE NOT EQUAL TO" #x2AB6)
+    ("PRECEDES ABOVE ALMOST EQUAL TO" #x2AB7)
+    ("SUCCEEDS ABOVE ALMOST EQUAL TO" #x2AB8)
+    ("PRECEDES ABOVE NOT ALMOST EQUAL TO" #x2AB9)
+    ("SUCCEEDS ABOVE NOT ALMOST EQUAL TO" #x2ABA)
+    ("DOUBLE PRECEDES" #x2ABB)
+    ("DOUBLE SUCCEEDS" #x2ABC)
+    ("SUBSET WITH DOT" #x2ABD)
+    ("SUPERSET WITH DOT" #x2ABE)
+    ("SUBSET WITH PLUS SIGN BELOW" #x2ABF)
+    ("SUPERSET WITH PLUS SIGN BELOW" #x2AC0)
+    ("SUBSET WITH MULTIPLICATION SIGN BELOW" #x2AC1)
+    ("SUPERSET WITH MULTIPLICATION SIGN BELOW" #x2AC2)
+    ("SUBSET OF OR EQUAL TO WITH DOT ABOVE" #x2AC3)
+    ("SUPERSET OF OR EQUAL TO WITH DOT ABOVE" #x2AC4)
+    ("SUBSET OF ABOVE EQUALS SIGN" #x2AC5)
+    ("SUPERSET OF ABOVE EQUALS SIGN" #x2AC6)
+    ("SUBSET OF ABOVE TILDE OPERATOR" #x2AC7)
+    ("SUPERSET OF ABOVE TILDE OPERATOR" #x2AC8)
+    ("SUBSET OF ABOVE ALMOST EQUAL TO" #x2AC9)
+    ("SUPERSET OF ABOVE ALMOST EQUAL TO" #x2ACA)
+    ("SUBSET OF ABOVE NOT EQUAL TO" #x2ACB)
+    ("SUPERSET OF ABOVE NOT EQUAL TO" #x2ACC)
+    ("SQUARE LEFT OPEN BOX OPERATOR" #x2ACD)
+    ("SQUARE RIGHT OPEN BOX OPERATOR" #x2ACE)
+    ("CLOSED SUBSET" #x2ACF)
+    ("CLOSED SUPERSET" #x2AD0)
+    ("CLOSED SUBSET OR EQUAL TO" #x2AD1)
+    ("CLOSED SUPERSET OR EQUAL TO" #x2AD2)
+    ("SUBSET ABOVE SUPERSET" #x2AD3)
+    ("SUPERSET ABOVE SUBSET" #x2AD4)
+    ("SUBSET ABOVE SUBSET" #x2AD5)
+    ("SUPERSET ABOVE SUPERSET" #x2AD6)
+    ("SUPERSET BESIDE SUBSET" #x2AD7)
+    ("SUPERSET BESIDE AND JOINED BY DASH WITH SUBSET" #x2AD8)
+    ("ELEMENT OF OPENING DOWNWARDS" #x2AD9)
+    ("PITCHFORK WITH TEE TOP" #x2ADA)
+    ("TRANSVERSAL INTERSECTION" #x2ADB)
+    ("FORKING" #x2ADC)
+    ("NONFORKING" #x2ADD)
+    ("SHORT LEFT TACK" #x2ADE)
+    ("SHORT DOWN TACK" #x2ADF)
+    ("SHORT UP TACK" #x2AE0)
+    ("PERPENDICULAR WITH S" #x2AE1)
+    ("VERTICAL BAR TRIPLE RIGHT TURNSTILE" #x2AE2)
+    ("DOUBLE VERTICAL BAR LEFT TURNSTILE" #x2AE3)
+    ("VERTICAL BAR DOUBLE LEFT TURNSTILE" #x2AE4)
+    ("DOUBLE VERTICAL BAR DOUBLE LEFT TURNSTILE" #x2AE5)
+    ("LONG DASH FROM LEFT MEMBER OF DOUBLE VERTICAL" #x2AE6)
+    ("SHORT DOWN TACK WITH OVERBAR" #x2AE7)
+    ("SHORT UP TACK WITH UNDERBAR" #x2AE8)
+    ("SHORT UP TACK ABOVE SHORT DOWN TACK" #x2AE9)
+    ("DOUBLE DOWN TACK" #x2AEA)
+    ("DOUBLE UP TACK" #x2AEB)
+    ("DOUBLE STROKE NOT SIGN" #x2AEC)
+    ("REVERSED DOUBLE STROKE NOT SIGN" #x2AED)
+    ("DOES NOT DIVIDE WITH REVERSED NEGATION SLASH" #x2AEE)
+    ("VERTICAL LINE WITH CIRCLE ABOVE" #x2AEF)
+    ("VERTICAL LINE WITH CIRCLE BELOW" #x2AF0)
+    ("DOWN TACK WITH CIRCLE BELOW" #x2AF1)
+    ("PARALLEL WITH HORIZONTAL STROKE" #x2AF2)
+    ("PARALLEL WITH TILDE OPERATOR" #x2AF3)
+    ("TRIPLE VERTICAL BAR BINARY RELATION" #x2AF4)
+    ("TRIPLE VERTICAL BAR WITH HORIZONTAL STROKE" #x2AF5)
+    ("TRIPLE COLON OPERATOR" #x2AF6)
+    ("TRIPLE NESTED LESS-THAN" #x2AF7)
+    ("TRIPLE NESTED GREATER-THAN" #x2AF8)
+    ("DOUBLE-LINE SLANTED LESS-THAN OR EQUAL TO" #x2AF9)
+    ("DOUBLE-LINE SLANTED GREATER-THAN OR EQUAL TO" #x2AFA)
+    ("TRIPLE SOLIDUS BINARY RELATION" #x2AFB)
+    ("LARGE TRIPLE VERTICAL BAR OPERATOR" #x2AFC)
+    ("DOUBLE SOLIDUS OPERATOR" #x2AFD)
+    ("WHITE VERTICAL BAR" #x2AFE)
+    ("N-ARY WHITE VERTICAL BAR" #x2AFF)
+    ))
diff --git a/lisp/nxml/char-name/unicode/02E80-02EFF.el b/lisp/nxml/char-name/unicode/02E80-02EFF.el
new file mode 100644
index 00000000000..3cb901803bc
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/02E80-02EFF.el
@@ -0,0 +1,117 @@
+(nxml-define-char-name-set 'cjk-radicals-supplement
+  '(("CJK RADICAL REPEAT" #x2E80)
+    ("CJK RADICAL CLIFF" #x2E81)
+    ("CJK RADICAL SECOND ONE" #x2E82)
+    ("CJK RADICAL SECOND TWO" #x2E83)
+    ("CJK RADICAL SECOND THREE" #x2E84)
+    ("CJK RADICAL PERSON" #x2E85)
+    ("CJK RADICAL BOX" #x2E86)
+    ("CJK RADICAL TABLE" #x2E87)
+    ("CJK RADICAL KNIFE ONE" #x2E88)
+    ("CJK RADICAL KNIFE TWO" #x2E89)
+    ("CJK RADICAL DIVINATION" #x2E8A)
+    ("CJK RADICAL SEAL" #x2E8B)
+    ("CJK RADICAL SMALL ONE" #x2E8C)
+    ("CJK RADICAL SMALL TWO" #x2E8D)
+    ("CJK RADICAL LAME ONE" #x2E8E)
+    ("CJK RADICAL LAME TWO" #x2E8F)
+    ("CJK RADICAL LAME THREE" #x2E90)
+    ("CJK RADICAL LAME FOUR" #x2E91)
+    ("CJK RADICAL SNAKE" #x2E92)
+    ("CJK RADICAL THREAD" #x2E93)
+    ("CJK RADICAL SNOUT ONE" #x2E94)
+    ("CJK RADICAL SNOUT TWO" #x2E95)
+    ("CJK RADICAL HEART ONE" #x2E96)
+    ("CJK RADICAL HEART TWO" #x2E97)
+    ("CJK RADICAL HAND" #x2E98)
+    ("CJK RADICAL RAP" #x2E99)
+    ("CJK RADICAL CHOKE" #x2E9B)
+    ("CJK RADICAL SUN" #x2E9C)
+    ("CJK RADICAL MOON" #x2E9D)
+    ("CJK RADICAL DEATH" #x2E9E)
+    ("CJK RADICAL MOTHER" #x2E9F)
+    ("CJK RADICAL CIVILIAN" #x2EA0)
+    ("CJK RADICAL WATER ONE" #x2EA1)
+    ("CJK RADICAL WATER TWO" #x2EA2)
+    ("CJK RADICAL FIRE" #x2EA3)
+    ("CJK RADICAL PAW ONE" #x2EA4)
+    ("CJK RADICAL PAW TWO" #x2EA5)
+    ("CJK RADICAL SIMPLIFIED HALF TREE TRUNK" #x2EA6)
+    ("CJK RADICAL COW" #x2EA7)
+    ("CJK RADICAL DOG" #x2EA8)
+    ("CJK RADICAL JADE" #x2EA9)
+    ("CJK RADICAL BOLT OF CLOTH" #x2EAA)
+    ("CJK RADICAL EYE" #x2EAB)
+    ("CJK RADICAL SPIRIT ONE" #x2EAC)
+    ("CJK RADICAL SPIRIT TWO" #x2EAD)
+    ("CJK RADICAL BAMBOO" #x2EAE)
+    ("CJK RADICAL SILK" #x2EAF)
+    ("CJK RADICAL C-SIMPLIFIED SILK" #x2EB0)
+    ("CJK RADICAL NET ONE" #x2EB1)
+    ("CJK RADICAL NET TWO" #x2EB2)
+    ("CJK RADICAL NET THREE" #x2EB3)
+    ("CJK RADICAL NET FOUR" #x2EB4)
+    ("CJK RADICAL MESH" #x2EB5)
+    ("CJK RADICAL SHEEP" #x2EB6)
+    ("CJK RADICAL RAM" #x2EB7)
+    ("CJK RADICAL EWE" #x2EB8)
+    ("CJK RADICAL OLD" #x2EB9)
+    ("CJK RADICAL BRUSH ONE" #x2EBA)
+    ("CJK RADICAL BRUSH TWO" #x2EBB)
+    ("CJK RADICAL MEAT" #x2EBC)
+    ("CJK RADICAL MORTAR" #x2EBD)
+    ("CJK RADICAL GRASS ONE" #x2EBE)
+    ("CJK RADICAL GRASS TWO" #x2EBF)
+    ("CJK RADICAL GRASS THREE" #x2EC0)
+    ("CJK RADICAL TIGER" #x2EC1)
+    ("CJK RADICAL CLOTHES" #x2EC2)
+    ("CJK RADICAL WEST ONE" #x2EC3)
+    ("CJK RADICAL WEST TWO" #x2EC4)
+    ("CJK RADICAL C-SIMPLIFIED SEE" #x2EC5)
+    ("CJK RADICAL SIMPLIFIED HORN" #x2EC6)
+    ("CJK RADICAL HORN" #x2EC7)
+    ("CJK RADICAL C-SIMPLIFIED SPEECH" #x2EC8)
+    ("CJK RADICAL C-SIMPLIFIED SHELL" #x2EC9)
+    ("CJK RADICAL FOOT" #x2ECA)
+    ("CJK RADICAL C-SIMPLIFIED CART" #x2ECB)
+    ("CJK RADICAL SIMPLIFIED WALK" #x2ECC)
+    ("CJK RADICAL WALK ONE" #x2ECD)
+    ("CJK RADICAL WALK TWO" #x2ECE)
+    ("CJK RADICAL CITY" #x2ECF)
+    ("CJK RADICAL C-SIMPLIFIED GOLD" #x2ED0)
+    ("CJK RADICAL LONG ONE" #x2ED1)
+    ("CJK RADICAL LONG TWO" #x2ED2)
+    ("CJK RADICAL C-SIMPLIFIED LONG" #x2ED3)
+    ("CJK RADICAL C-SIMPLIFIED GATE" #x2ED4)
+    ("CJK RADICAL MOUND ONE" #x2ED5)
+    ("CJK RADICAL MOUND TWO" #x2ED6)
+    ("CJK RADICAL RAIN" #x2ED7)
+    ("CJK RADICAL BLUE" #x2ED8)
+    ("CJK RADICAL C-SIMPLIFIED TANNED LEATHER" #x2ED9)
+    ("CJK RADICAL C-SIMPLIFIED LEAF" #x2EDA)
+    ("CJK RADICAL C-SIMPLIFIED WIND" #x2EDB)
+    ("CJK RADICAL C-SIMPLIFIED FLY" #x2EDC)
+    ("CJK RADICAL EAT ONE" #x2EDD)
+    ("CJK RADICAL EAT TWO" #x2EDE)
+    ("CJK RADICAL EAT THREE" #x2EDF)
+    ("CJK RADICAL C-SIMPLIFIED EAT" #x2EE0)
+    ("CJK RADICAL HEAD" #x2EE1)
+    ("CJK RADICAL C-SIMPLIFIED HORSE" #x2EE2)
+    ("CJK RADICAL BONE" #x2EE3)
+    ("CJK RADICAL GHOST" #x2EE4)
+    ("CJK RADICAL C-SIMPLIFIED FISH" #x2EE5)
+    ("CJK RADICAL C-SIMPLIFIED BIRD" #x2EE6)
+    ("CJK RADICAL C-SIMPLIFIED SALT" #x2EE7)
+    ("CJK RADICAL SIMPLIFIED WHEAT" #x2EE8)
+    ("CJK RADICAL SIMPLIFIED YELLOW" #x2EE9)
+    ("CJK RADICAL C-SIMPLIFIED FROG" #x2EEA)
+    ("CJK RADICAL J-SIMPLIFIED EVEN" #x2EEB)
+    ("CJK RADICAL C-SIMPLIFIED EVEN" #x2EEC)
+    ("CJK RADICAL J-SIMPLIFIED TOOTH" #x2EED)
+    ("CJK RADICAL C-SIMPLIFIED TOOTH" #x2EEE)
+    ("CJK RADICAL J-SIMPLIFIED DRAGON" #x2EEF)
+    ("CJK RADICAL C-SIMPLIFIED DRAGON" #x2EF0)
+    ("CJK RADICAL TURTLE" #x2EF1)
+    ("CJK RADICAL J-SIMPLIFIED TURTLE" #x2EF2)
+    ("CJK RADICAL C-SIMPLIFIED TURTLE" #x2EF3)
+    ))
diff --git a/lisp/nxml/char-name/unicode/02F00-02FDF.el b/lisp/nxml/char-name/unicode/02F00-02FDF.el
new file mode 100644
index 00000000000..89c202709f6
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/02F00-02FDF.el
@@ -0,0 +1,216 @@
+(nxml-define-char-name-set 'kangxi-radicals
+  '(("KANGXI RADICAL ONE" #x2F00)
+    ("KANGXI RADICAL LINE" #x2F01)
+    ("KANGXI RADICAL DOT" #x2F02)
+    ("KANGXI RADICAL SLASH" #x2F03)
+    ("KANGXI RADICAL SECOND" #x2F04)
+    ("KANGXI RADICAL HOOK" #x2F05)
+    ("KANGXI RADICAL TWO" #x2F06)
+    ("KANGXI RADICAL LID" #x2F07)
+    ("KANGXI RADICAL MAN" #x2F08)
+    ("KANGXI RADICAL LEGS" #x2F09)
+    ("KANGXI RADICAL ENTER" #x2F0A)
+    ("KANGXI RADICAL EIGHT" #x2F0B)
+    ("KANGXI RADICAL DOWN BOX" #x2F0C)
+    ("KANGXI RADICAL COVER" #x2F0D)
+    ("KANGXI RADICAL ICE" #x2F0E)
+    ("KANGXI RADICAL TABLE" #x2F0F)
+    ("KANGXI RADICAL OPEN BOX" #x2F10)
+    ("KANGXI RADICAL KNIFE" #x2F11)
+    ("KANGXI RADICAL POWER" #x2F12)
+    ("KANGXI RADICAL WRAP" #x2F13)
+    ("KANGXI RADICAL SPOON" #x2F14)
+    ("KANGXI RADICAL RIGHT OPEN BOX" #x2F15)
+    ("KANGXI RADICAL HIDING ENCLOSURE" #x2F16)
+    ("KANGXI RADICAL TEN" #x2F17)
+    ("KANGXI RADICAL DIVINATION" #x2F18)
+    ("KANGXI RADICAL SEAL" #x2F19)
+    ("KANGXI RADICAL CLIFF" #x2F1A)
+    ("KANGXI RADICAL PRIVATE" #x2F1B)
+    ("KANGXI RADICAL AGAIN" #x2F1C)
+    ("KANGXI RADICAL MOUTH" #x2F1D)
+    ("KANGXI RADICAL ENCLOSURE" #x2F1E)
+    ("KANGXI RADICAL EARTH" #x2F1F)
+    ("KANGXI RADICAL SCHOLAR" #x2F20)
+    ("KANGXI RADICAL GO" #x2F21)
+    ("KANGXI RADICAL GO SLOWLY" #x2F22)
+    ("KANGXI RADICAL EVENING" #x2F23)
+    ("KANGXI RADICAL BIG" #x2F24)
+    ("KANGXI RADICAL WOMAN" #x2F25)
+    ("KANGXI RADICAL CHILD" #x2F26)
+    ("KANGXI RADICAL ROOF" #x2F27)
+    ("KANGXI RADICAL INCH" #x2F28)
+    ("KANGXI RADICAL SMALL" #x2F29)
+    ("KANGXI RADICAL LAME" #x2F2A)
+    ("KANGXI RADICAL CORPSE" #x2F2B)
+    ("KANGXI RADICAL SPROUT" #x2F2C)
+    ("KANGXI RADICAL MOUNTAIN" #x2F2D)
+    ("KANGXI RADICAL RIVER" #x2F2E)
+    ("KANGXI RADICAL WORK" #x2F2F)
+    ("KANGXI RADICAL ONESELF" #x2F30)
+    ("KANGXI RADICAL TURBAN" #x2F31)
+    ("KANGXI RADICAL DRY" #x2F32)
+    ("KANGXI RADICAL SHORT THREAD" #x2F33)
+    ("KANGXI RADICAL DOTTED CLIFF" #x2F34)
+    ("KANGXI RADICAL LONG STRIDE" #x2F35)
+    ("KANGXI RADICAL TWO HANDS" #x2F36)
+    ("KANGXI RADICAL SHOOT" #x2F37)
+    ("KANGXI RADICAL BOW" #x2F38)
+    ("KANGXI RADICAL SNOUT" #x2F39)
+    ("KANGXI RADICAL BRISTLE" #x2F3A)
+    ("KANGXI RADICAL STEP" #x2F3B)
+    ("KANGXI RADICAL HEART" #x2F3C)
+    ("KANGXI RADICAL HALBERD" #x2F3D)
+    ("KANGXI RADICAL DOOR" #x2F3E)
+    ("KANGXI RADICAL HAND" #x2F3F)
+    ("KANGXI RADICAL BRANCH" #x2F40)
+    ("KANGXI RADICAL RAP" #x2F41)
+    ("KANGXI RADICAL SCRIPT" #x2F42)
+    ("KANGXI RADICAL DIPPER" #x2F43)
+    ("KANGXI RADICAL AXE" #x2F44)
+    ("KANGXI RADICAL SQUARE" #x2F45)
+    ("KANGXI RADICAL NOT" #x2F46)
+    ("KANGXI RADICAL SUN" #x2F47)
+    ("KANGXI RADICAL SAY" #x2F48)
+    ("KANGXI RADICAL MOON" #x2F49)
+    ("KANGXI RADICAL TREE" #x2F4A)
+    ("KANGXI RADICAL LACK" #x2F4B)
+    ("KANGXI RADICAL STOP" #x2F4C)
+    ("KANGXI RADICAL DEATH" #x2F4D)
+    ("KANGXI RADICAL WEAPON" #x2F4E)
+    ("KANGXI RADICAL DO NOT" #x2F4F)
+    ("KANGXI RADICAL COMPARE" #x2F50)
+    ("KANGXI RADICAL FUR" #x2F51)
+    ("KANGXI RADICAL CLAN" #x2F52)
+    ("KANGXI RADICAL STEAM" #x2F53)
+    ("KANGXI RADICAL WATER" #x2F54)
+    ("KANGXI RADICAL FIRE" #x2F55)
+    ("KANGXI RADICAL CLAW" #x2F56)
+    ("KANGXI RADICAL FATHER" #x2F57)
+    ("KANGXI RADICAL DOUBLE X" #x2F58)
+    ("KANGXI RADICAL HALF TREE TRUNK" #x2F59)
+    ("KANGXI RADICAL SLICE" #x2F5A)
+    ("KANGXI RADICAL FANG" #x2F5B)
+    ("KANGXI RADICAL COW" #x2F5C)
+    ("KANGXI RADICAL DOG" #x2F5D)
+    ("KANGXI RADICAL PROFOUND" #x2F5E)
+    ("KANGXI RADICAL JADE" #x2F5F)
+    ("KANGXI RADICAL MELON" #x2F60)
+    ("KANGXI RADICAL TILE" #x2F61)
+    ("KANGXI RADICAL SWEET" #x2F62)
+    ("KANGXI RADICAL LIFE" #x2F63)
+    ("KANGXI RADICAL USE" #x2F64)
+    ("KANGXI RADICAL FIELD" #x2F65)
+    ("KANGXI RADICAL BOLT OF CLOTH" #x2F66)
+    ("KANGXI RADICAL SICKNESS" #x2F67)
+    ("KANGXI RADICAL DOTTED TENT" #x2F68)
+    ("KANGXI RADICAL WHITE" #x2F69)
+    ("KANGXI RADICAL SKIN" #x2F6A)
+    ("KANGXI RADICAL DISH" #x2F6B)
+    ("KANGXI RADICAL EYE" #x2F6C)
+    ("KANGXI RADICAL SPEAR" #x2F6D)
+    ("KANGXI RADICAL ARROW" #x2F6E)
+    ("KANGXI RADICAL STONE" #x2F6F)
+    ("KANGXI RADICAL SPIRIT" #x2F70)
+    ("KANGXI RADICAL TRACK" #x2F71)
+    ("KANGXI RADICAL GRAIN" #x2F72)
+    ("KANGXI RADICAL CAVE" #x2F73)
+    ("KANGXI RADICAL STAND" #x2F74)
+    ("KANGXI RADICAL BAMBOO" #x2F75)
+    ("KANGXI RADICAL RICE" #x2F76)
+    ("KANGXI RADICAL SILK" #x2F77)
+    ("KANGXI RADICAL JAR" #x2F78)
+    ("KANGXI RADICAL NET" #x2F79)
+    ("KANGXI RADICAL SHEEP" #x2F7A)
+    ("KANGXI RADICAL FEATHER" #x2F7B)
+    ("KANGXI RADICAL OLD" #x2F7C)
+    ("KANGXI RADICAL AND" #x2F7D)
+    ("KANGXI RADICAL PLOW" #x2F7E)
+    ("KANGXI RADICAL EAR" #x2F7F)
+    ("KANGXI RADICAL BRUSH" #x2F80)
+    ("KANGXI RADICAL MEAT" #x2F81)
+    ("KANGXI RADICAL MINISTER" #x2F82)
+    ("KANGXI RADICAL SELF" #x2F83)
+    ("KANGXI RADICAL ARRIVE" #x2F84)
+    ("KANGXI RADICAL MORTAR" #x2F85)
+    ("KANGXI RADICAL TONGUE" #x2F86)
+    ("KANGXI RADICAL OPPOSE" #x2F87)
+    ("KANGXI RADICAL BOAT" #x2F88)
+    ("KANGXI RADICAL STOPPING" #x2F89)
+    ("KANGXI RADICAL COLOR" #x2F8A)
+    ("KANGXI RADICAL GRASS" #x2F8B)
+    ("KANGXI RADICAL TIGER" #x2F8C)
+    ("KANGXI RADICAL INSECT" #x2F8D)
+    ("KANGXI RADICAL BLOOD" #x2F8E)
+    ("KANGXI RADICAL WALK ENCLOSURE" #x2F8F)
+    ("KANGXI RADICAL CLOTHES" #x2F90)
+    ("KANGXI RADICAL WEST" #x2F91)
+    ("KANGXI RADICAL SEE" #x2F92)
+    ("KANGXI RADICAL HORN" #x2F93)
+    ("KANGXI RADICAL SPEECH" #x2F94)
+    ("KANGXI RADICAL VALLEY" #x2F95)
+    ("KANGXI RADICAL BEAN" #x2F96)
+    ("KANGXI RADICAL PIG" #x2F97)
+    ("KANGXI RADICAL BADGER" #x2F98)
+    ("KANGXI RADICAL SHELL" #x2F99)
+    ("KANGXI RADICAL RED" #x2F9A)
+    ("KANGXI RADICAL RUN" #x2F9B)
+    ("KANGXI RADICAL FOOT" #x2F9C)
+    ("KANGXI RADICAL BODY" #x2F9D)
+    ("KANGXI RADICAL CART" #x2F9E)
+    ("KANGXI RADICAL BITTER" #x2F9F)
+    ("KANGXI RADICAL MORNING" #x2FA0)
+    ("KANGXI RADICAL WALK" #x2FA1)
+    ("KANGXI RADICAL CITY" #x2FA2)
+    ("KANGXI RADICAL WINE" #x2FA3)
+    ("KANGXI RADICAL DISTINGUISH" #x2FA4)
+    ("KANGXI RADICAL VILLAGE" #x2FA5)
+    ("KANGXI RADICAL GOLD" #x2FA6)
+    ("KANGXI RADICAL LONG" #x2FA7)
+    ("KANGXI RADICAL GATE" #x2FA8)
+    ("KANGXI RADICAL MOUND" #x2FA9)
+    ("KANGXI RADICAL SLAVE" #x2FAA)
+    ("KANGXI RADICAL SHORT TAILED BIRD" #x2FAB)
+    ("KANGXI RADICAL RAIN" #x2FAC)
+    ("KANGXI RADICAL BLUE" #x2FAD)
+    ("KANGXI RADICAL WRONG" #x2FAE)
+    ("KANGXI RADICAL FACE" #x2FAF)
+    ("KANGXI RADICAL LEATHER" #x2FB0)
+    ("KANGXI RADICAL TANNED LEATHER" #x2FB1)
+    ("KANGXI RADICAL LEEK" #x2FB2)
+    ("KANGXI RADICAL SOUND" #x2FB3)
+    ("KANGXI RADICAL LEAF" #x2FB4)
+    ("KANGXI RADICAL WIND" #x2FB5)
+    ("KANGXI RADICAL FLY" #x2FB6)
+    ("KANGXI RADICAL EAT" #x2FB7)
+    ("KANGXI RADICAL HEAD" #x2FB8)
+    ("KANGXI RADICAL FRAGRANT" #x2FB9)
+    ("KANGXI RADICAL HORSE" #x2FBA)
+    ("KANGXI RADICAL BONE" #x2FBB)
+    ("KANGXI RADICAL TALL" #x2FBC)
+    ("KANGXI RADICAL HAIR" #x2FBD)
+    ("KANGXI RADICAL FIGHT" #x2FBE)
+    ("KANGXI RADICAL SACRIFICIAL WINE" #x2FBF)
+    ("KANGXI RADICAL CAULDRON" #x2FC0)
+    ("KANGXI RADICAL GHOST" #x2FC1)
+    ("KANGXI RADICAL FISH" #x2FC2)
+    ("KANGXI RADICAL BIRD" #x2FC3)
+    ("KANGXI RADICAL SALT" #x2FC4)
+    ("KANGXI RADICAL DEER" #x2FC5)
+    ("KANGXI RADICAL WHEAT" #x2FC6)
+    ("KANGXI RADICAL HEMP" #x2FC7)
+    ("KANGXI RADICAL YELLOW" #x2FC8)
+    ("KANGXI RADICAL MILLET" #x2FC9)
+    ("KANGXI RADICAL BLACK" #x2FCA)
+    ("KANGXI RADICAL EMBROIDERY" #x2FCB)
+    ("KANGXI RADICAL FROG" #x2FCC)
+    ("KANGXI RADICAL TRIPOD" #x2FCD)
+    ("KANGXI RADICAL DRUM" #x2FCE)
+    ("KANGXI RADICAL RAT" #x2FCF)
+    ("KANGXI RADICAL NOSE" #x2FD0)
+    ("KANGXI RADICAL EVEN" #x2FD1)
+    ("KANGXI RADICAL TOOTH" #x2FD2)
+    ("KANGXI RADICAL DRAGON" #x2FD3)
+    ("KANGXI RADICAL TURTLE" #x2FD4)
+    ("KANGXI RADICAL FLUTE" #x2FD5)
+    ))
diff --git a/lisp/nxml/char-name/unicode/02FF0-02FFF.el b/lisp/nxml/char-name/unicode/02FF0-02FFF.el
new file mode 100644
index 00000000000..9232af9cab1
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/02FF0-02FFF.el
@@ -0,0 +1,14 @@
+(nxml-define-char-name-set 'ideographic-description-characters
+  '(("IDEOGRAPHIC DESCRIPTION CHARACTER LEFT TO RIGHT" #x2FF0)
+    ("IDEOGRAPHIC DESCRIPTION CHARACTER ABOVE TO BELOW" #x2FF1)
+    ("IDEOGRAPHIC DESCRIPTION CHARACTER LEFT TO MIDDLE AND RIGHT" #x2FF2)
+    ("IDEOGRAPHIC DESCRIPTION CHARACTER ABOVE TO MIDDLE AND BELOW" #x2FF3)
+    ("IDEOGRAPHIC DESCRIPTION CHARACTER FULL SURROUND" #x2FF4)
+    ("IDEOGRAPHIC DESCRIPTION CHARACTER SURROUND FROM ABOVE" #x2FF5)
+    ("IDEOGRAPHIC DESCRIPTION CHARACTER SURROUND FROM BELOW" #x2FF6)
+    ("IDEOGRAPHIC DESCRIPTION CHARACTER SURROUND FROM LEFT" #x2FF7)
+    ("IDEOGRAPHIC DESCRIPTION CHARACTER SURROUND FROM UPPER LEFT" #x2FF8)
+    ("IDEOGRAPHIC DESCRIPTION CHARACTER SURROUND FROM UPPER RIGHT" #x2FF9)
+    ("IDEOGRAPHIC DESCRIPTION CHARACTER SURROUND FROM LOWER LEFT" #x2FFA)
+    ("IDEOGRAPHIC DESCRIPTION CHARACTER OVERLAID" #x2FFB)
+    ))
diff --git a/lisp/nxml/char-name/unicode/03000-0303F.el b/lisp/nxml/char-name/unicode/03000-0303F.el
new file mode 100644
index 00000000000..0b481adb4c4
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/03000-0303F.el
@@ -0,0 +1,66 @@
+(nxml-define-char-name-set 'cjk-symbols-and-punctuation
+  '(("IDEOGRAPHIC SPACE" #x3000)
+    ("IDEOGRAPHIC COMMA" #x3001)
+    ("IDEOGRAPHIC FULL STOP" #x3002)
+    ("DITTO MARK" #x3003)
+    ("JAPANESE INDUSTRIAL STANDARD SYMBOL" #x3004)
+    ("IDEOGRAPHIC ITERATION MARK" #x3005)
+    ("IDEOGRAPHIC CLOSING MARK" #x3006)
+    ("IDEOGRAPHIC NUMBER ZERO" #x3007)
+    ("LEFT ANGLE BRACKET" #x3008)
+    ("RIGHT ANGLE BRACKET" #x3009)
+    ("LEFT DOUBLE ANGLE BRACKET" #x300A)
+    ("RIGHT DOUBLE ANGLE BRACKET" #x300B)
+    ("LEFT CORNER BRACKET" #x300C)
+    ("RIGHT CORNER BRACKET" #x300D)
+    ("LEFT WHITE CORNER BRACKET" #x300E)
+    ("RIGHT WHITE CORNER BRACKET" #x300F)
+    ("LEFT BLACK LENTICULAR BRACKET" #x3010)
+    ("RIGHT BLACK LENTICULAR BRACKET" #x3011)
+    ("POSTAL MARK" #x3012)
+    ("GETA MARK" #x3013)
+    ("LEFT TORTOISE SHELL BRACKET" #x3014)
+    ("RIGHT TORTOISE SHELL BRACKET" #x3015)
+    ("LEFT WHITE LENTICULAR BRACKET" #x3016)
+    ("RIGHT WHITE LENTICULAR BRACKET" #x3017)
+    ("LEFT WHITE TORTOISE SHELL BRACKET" #x3018)
+    ("RIGHT WHITE TORTOISE SHELL BRACKET" #x3019)
+    ("LEFT WHITE SQUARE BRACKET" #x301A)
+    ("RIGHT WHITE SQUARE BRACKET" #x301B)
+    ("WAVE DASH" #x301C)
+    ("REVERSED DOUBLE PRIME QUOTATION MARK" #x301D)
+    ("DOUBLE PRIME QUOTATION MARK" #x301E)
+    ("LOW DOUBLE PRIME QUOTATION MARK" #x301F)
+    ("POSTAL MARK FACE" #x3020)
+    ("HANGZHOU NUMERAL ONE" #x3021)
+    ("HANGZHOU NUMERAL TWO" #x3022)
+    ("HANGZHOU NUMERAL THREE" #x3023)
+    ("HANGZHOU NUMERAL FOUR" #x3024)
+    ("HANGZHOU NUMERAL FIVE" #x3025)
+    ("HANGZHOU NUMERAL SIX" #x3026)
+    ("HANGZHOU NUMERAL SEVEN" #x3027)
+    ("HANGZHOU NUMERAL EIGHT" #x3028)
+    ("HANGZHOU NUMERAL NINE" #x3029)
+    ("IDEOGRAPHIC LEVEL TONE MARK" #x302A)
+    ("IDEOGRAPHIC RISING TONE MARK" #x302B)
+    ("IDEOGRAPHIC DEPARTING TONE MARK" #x302C)
+    ("IDEOGRAPHIC ENTERING TONE MARK" #x302D)
+    ("HANGUL SINGLE DOT TONE MARK" #x302E)
+    ("HANGUL DOUBLE DOT TONE MARK" #x302F)
+    ("WAVY DASH" #x3030)
+    ("VERTICAL KANA REPEAT MARK" #x3031)
+    ("VERTICAL KANA REPEAT WITH VOICED SOUND MARK" #x3032)
+    ("VERTICAL KANA REPEAT MARK UPPER HALF" #x3033)
+    ("VERTICAL KANA REPEAT WITH VOICED SOUND MARK UPPER HALF" #x3034)
+    ("VERTICAL KANA REPEAT MARK LOWER HALF" #x3035)
+    ("CIRCLED POSTAL MARK" #x3036)
+    ("IDEOGRAPHIC TELEGRAPH LINE FEED SEPARATOR SYMBOL" #x3037)
+    ("HANGZHOU NUMERAL TEN" #x3038)
+    ("HANGZHOU NUMERAL TWENTY" #x3039)
+    ("HANGZHOU NUMERAL THIRTY" #x303A)
+    ("VERTICAL IDEOGRAPHIC ITERATION MARK" #x303B)
+    ("MASU MARK" #x303C)
+    ("PART ALTERNATION MARK" #x303D)
+    ("IDEOGRAPHIC VARIATION INDICATOR" #x303E)
+    ("IDEOGRAPHIC HALF FILL SPACE" #x303F)
+    ))
diff --git a/lisp/nxml/char-name/unicode/03040-0309F.el b/lisp/nxml/char-name/unicode/03040-0309F.el
new file mode 100644
index 00000000000..c19e541e0a4
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/03040-0309F.el
@@ -0,0 +1,95 @@
+(nxml-define-char-name-set 'hiragana
+  '(("HIRAGANA LETTER SMALL A" #x3041)
+    ("HIRAGANA LETTER A" #x3042)
+    ("HIRAGANA LETTER SMALL I" #x3043)
+    ("HIRAGANA LETTER I" #x3044)
+    ("HIRAGANA LETTER SMALL U" #x3045)
+    ("HIRAGANA LETTER U" #x3046)
+    ("HIRAGANA LETTER SMALL E" #x3047)
+    ("HIRAGANA LETTER E" #x3048)
+    ("HIRAGANA LETTER SMALL O" #x3049)
+    ("HIRAGANA LETTER O" #x304A)
+    ("HIRAGANA LETTER KA" #x304B)
+    ("HIRAGANA LETTER GA" #x304C)
+    ("HIRAGANA LETTER KI" #x304D)
+    ("HIRAGANA LETTER GI" #x304E)
+    ("HIRAGANA LETTER KU" #x304F)
+    ("HIRAGANA LETTER GU" #x3050)
+    ("HIRAGANA LETTER KE" #x3051)
+    ("HIRAGANA LETTER GE" #x3052)
+    ("HIRAGANA LETTER KO" #x3053)
+    ("HIRAGANA LETTER GO" #x3054)
+    ("HIRAGANA LETTER SA" #x3055)
+    ("HIRAGANA LETTER ZA" #x3056)
+    ("HIRAGANA LETTER SI" #x3057)
+    ("HIRAGANA LETTER ZI" #x3058)
+    ("HIRAGANA LETTER SU" #x3059)
+    ("HIRAGANA LETTER ZU" #x305A)
+    ("HIRAGANA LETTER SE" #x305B)
+    ("HIRAGANA LETTER ZE" #x305C)
+    ("HIRAGANA LETTER SO" #x305D)
+    ("HIRAGANA LETTER ZO" #x305E)
+    ("HIRAGANA LETTER TA" #x305F)
+    ("HIRAGANA LETTER DA" #x3060)
+    ("HIRAGANA LETTER TI" #x3061)
+    ("HIRAGANA LETTER DI" #x3062)
+    ("HIRAGANA LETTER SMALL TU" #x3063)
+    ("HIRAGANA LETTER TU" #x3064)
+    ("HIRAGANA LETTER DU" #x3065)
+    ("HIRAGANA LETTER TE" #x3066)
+    ("HIRAGANA LETTER DE" #x3067)
+    ("HIRAGANA LETTER TO" #x3068)
+    ("HIRAGANA LETTER DO" #x3069)
+    ("HIRAGANA LETTER NA" #x306A)
+    ("HIRAGANA LETTER NI" #x306B)
+    ("HIRAGANA LETTER NU" #x306C)
+    ("HIRAGANA LETTER NE" #x306D)
+    ("HIRAGANA LETTER NO" #x306E)
+    ("HIRAGANA LETTER HA" #x306F)
+    ("HIRAGANA LETTER BA" #x3070)
+    ("HIRAGANA LETTER PA" #x3071)
+    ("HIRAGANA LETTER HI" #x3072)
+    ("HIRAGANA LETTER BI" #x3073)
+    ("HIRAGANA LETTER PI" #x3074)
+    ("HIRAGANA LETTER HU" #x3075)
+    ("HIRAGANA LETTER BU" #x3076)
+    ("HIRAGANA LETTER PU" #x3077)
+    ("HIRAGANA LETTER HE" #x3078)
+    ("HIRAGANA LETTER BE" #x3079)
+    ("HIRAGANA LETTER PE" #x307A)
+    ("HIRAGANA LETTER HO" #x307B)
+    ("HIRAGANA LETTER BO" #x307C)
+    ("HIRAGANA LETTER PO" #x307D)
+    ("HIRAGANA LETTER MA" #x307E)
+    ("HIRAGANA LETTER MI" #x307F)
+    ("HIRAGANA LETTER MU" #x3080)
+    ("HIRAGANA LETTER ME" #x3081)
+    ("HIRAGANA LETTER MO" #x3082)
+    ("HIRAGANA LETTER SMALL YA" #x3083)
+    ("HIRAGANA LETTER YA" #x3084)
+    ("HIRAGANA LETTER SMALL YU" #x3085)
+    ("HIRAGANA LETTER YU" #x3086)
+    ("HIRAGANA LETTER SMALL YO" #x3087)
+    ("HIRAGANA LETTER YO" #x3088)
+    ("HIRAGANA LETTER RA" #x3089)
+    ("HIRAGANA LETTER RI" #x308A)
+    ("HIRAGANA LETTER RU" #x308B)
+    ("HIRAGANA LETTER RE" #x308C)
+    ("HIRAGANA LETTER RO" #x308D)
+    ("HIRAGANA LETTER SMALL WA" #x308E)
+    ("HIRAGANA LETTER WA" #x308F)
+    ("HIRAGANA LETTER WI" #x3090)
+    ("HIRAGANA LETTER WE" #x3091)
+    ("HIRAGANA LETTER WO" #x3092)
+    ("HIRAGANA LETTER N" #x3093)
+    ("HIRAGANA LETTER VU" #x3094)
+    ("HIRAGANA LETTER SMALL KA" #x3095)
+    ("HIRAGANA LETTER SMALL KE" #x3096)
+    ("COMBINING KATAKANA-HIRAGANA VOICED SOUND MARK" #x3099)
+    ("COMBINING KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK" #x309A)
+    ("KATAKANA-HIRAGANA VOICED SOUND MARK" #x309B)
+    ("KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK" #x309C)
+    ("HIRAGANA ITERATION MARK" #x309D)
+    ("HIRAGANA VOICED ITERATION MARK" #x309E)
+    ("HIRAGANA DIGRAPH YORI" #x309F)
+    ))
diff --git a/lisp/nxml/char-name/unicode/030A0-030FF.el b/lisp/nxml/char-name/unicode/030A0-030FF.el
new file mode 100644
index 00000000000..52168c73ad0
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/030A0-030FF.el
@@ -0,0 +1,98 @@
+(nxml-define-char-name-set 'katakana
+  '(("KATAKANA-HIRAGANA DOUBLE HYPHEN" #x30A0)
+    ("KATAKANA LETTER SMALL A" #x30A1)
+    ("KATAKANA LETTER A" #x30A2)
+    ("KATAKANA LETTER SMALL I" #x30A3)
+    ("KATAKANA LETTER I" #x30A4)
+    ("KATAKANA LETTER SMALL U" #x30A5)
+    ("KATAKANA LETTER U" #x30A6)
+    ("KATAKANA LETTER SMALL E" #x30A7)
+    ("KATAKANA LETTER E" #x30A8)
+    ("KATAKANA LETTER SMALL O" #x30A9)
+    ("KATAKANA LETTER O" #x30AA)
+    ("KATAKANA LETTER KA" #x30AB)
+    ("KATAKANA LETTER GA" #x30AC)
+    ("KATAKANA LETTER KI" #x30AD)
+    ("KATAKANA LETTER GI" #x30AE)
+    ("KATAKANA LETTER KU" #x30AF)
+    ("KATAKANA LETTER GU" #x30B0)
+    ("KATAKANA LETTER KE" #x30B1)
+    ("KATAKANA LETTER GE" #x30B2)
+    ("KATAKANA LETTER KO" #x30B3)
+    ("KATAKANA LETTER GO" #x30B4)
+    ("KATAKANA LETTER SA" #x30B5)
+    ("KATAKANA LETTER ZA" #x30B6)
+    ("KATAKANA LETTER SI" #x30B7)
+    ("KATAKANA LETTER ZI" #x30B8)
+    ("KATAKANA LETTER SU" #x30B9)
+    ("KATAKANA LETTER ZU" #x30BA)
+    ("KATAKANA LETTER SE" #x30BB)
+    ("KATAKANA LETTER ZE" #x30BC)
+    ("KATAKANA LETTER SO" #x30BD)
+    ("KATAKANA LETTER ZO" #x30BE)
+    ("KATAKANA LETTER TA" #x30BF)
+    ("KATAKANA LETTER DA" #x30C0)
+    ("KATAKANA LETTER TI" #x30C1)
+    ("KATAKANA LETTER DI" #x30C2)
+    ("KATAKANA LETTER SMALL TU" #x30C3)
+    ("KATAKANA LETTER TU" #x30C4)
+    ("KATAKANA LETTER DU" #x30C5)
+    ("KATAKANA LETTER TE" #x30C6)
+    ("KATAKANA LETTER DE" #x30C7)
+    ("KATAKANA LETTER TO" #x30C8)
+    ("KATAKANA LETTER DO" #x30C9)
+    ("KATAKANA LETTER NA" #x30CA)
+    ("KATAKANA LETTER NI" #x30CB)
+    ("KATAKANA LETTER NU" #x30CC)
+    ("KATAKANA LETTER NE" #x30CD)
+    ("KATAKANA LETTER NO" #x30CE)
+    ("KATAKANA LETTER HA" #x30CF)
+    ("KATAKANA LETTER BA" #x30D0)
+    ("KATAKANA LETTER PA" #x30D1)
+    ("KATAKANA LETTER HI" #x30D2)
+    ("KATAKANA LETTER BI" #x30D3)
+    ("KATAKANA LETTER PI" #x30D4)
+    ("KATAKANA LETTER HU" #x30D5)
+    ("KATAKANA LETTER BU" #x30D6)
+    ("KATAKANA LETTER PU" #x30D7)
+    ("KATAKANA LETTER HE" #x30D8)
+    ("KATAKANA LETTER BE" #x30D9)
+    ("KATAKANA LETTER PE" #x30DA)
+    ("KATAKANA LETTER HO" #x30DB)
+    ("KATAKANA LETTER BO" #x30DC)
+    ("KATAKANA LETTER PO" #x30DD)
+    ("KATAKANA LETTER MA" #x30DE)
+    ("KATAKANA LETTER MI" #x30DF)
+    ("KATAKANA LETTER MU" #x30E0)
+    ("KATAKANA LETTER ME" #x30E1)
+    ("KATAKANA LETTER MO" #x30E2)
+    ("KATAKANA LETTER SMALL YA" #x30E3)
+    ("KATAKANA LETTER YA" #x30E4)
+    ("KATAKANA LETTER SMALL YU" #x30E5)
+    ("KATAKANA LETTER YU" #x30E6)
+    ("KATAKANA LETTER SMALL YO" #x30E7)
+    ("KATAKANA LETTER YO" #x30E8)
+    ("KATAKANA LETTER RA" #x30E9)
+    ("KATAKANA LETTER RI" #x30EA)
+    ("KATAKANA LETTER RU" #x30EB)
+    ("KATAKANA LETTER RE" #x30EC)
+    ("KATAKANA LETTER RO" #x30ED)
+    ("KATAKANA LETTER SMALL WA" #x30EE)
+    ("KATAKANA LETTER WA" #x30EF)
+    ("KATAKANA LETTER WI" #x30F0)
+    ("KATAKANA LETTER WE" #x30F1)
+    ("KATAKANA LETTER WO" #x30F2)
+    ("KATAKANA LETTER N" #x30F3)
+    ("KATAKANA LETTER VU" #x30F4)
+    ("KATAKANA LETTER SMALL KA" #x30F5)
+    ("KATAKANA LETTER SMALL KE" #x30F6)
+    ("KATAKANA LETTER VA" #x30F7)
+    ("KATAKANA LETTER VI" #x30F8)
+    ("KATAKANA LETTER VE" #x30F9)
+    ("KATAKANA LETTER VO" #x30FA)
+    ("KATAKANA MIDDLE DOT" #x30FB)
+    ("KATAKANA-HIRAGANA PROLONGED SOUND MARK" #x30FC)
+    ("KATAKANA ITERATION MARK" #x30FD)
+    ("KATAKANA VOICED ITERATION MARK" #x30FE)
+    ("KATAKANA DIGRAPH KOTO" #x30FF)
+    ))
diff --git a/lisp/nxml/char-name/unicode/03100-0312F.el b/lisp/nxml/char-name/unicode/03100-0312F.el
new file mode 100644
index 00000000000..ea0cc9ee5e1
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/03100-0312F.el
@@ -0,0 +1,42 @@
+(nxml-define-char-name-set 'bopomofo
+  '(("BOPOMOFO LETTER B" #x3105)
+    ("BOPOMOFO LETTER P" #x3106)
+    ("BOPOMOFO LETTER M" #x3107)
+    ("BOPOMOFO LETTER F" #x3108)
+    ("BOPOMOFO LETTER D" #x3109)
+    ("BOPOMOFO LETTER T" #x310A)
+    ("BOPOMOFO LETTER N" #x310B)
+    ("BOPOMOFO LETTER L" #x310C)
+    ("BOPOMOFO LETTER G" #x310D)
+    ("BOPOMOFO LETTER K" #x310E)
+    ("BOPOMOFO LETTER H" #x310F)
+    ("BOPOMOFO LETTER J" #x3110)
+    ("BOPOMOFO LETTER Q" #x3111)
+    ("BOPOMOFO LETTER X" #x3112)
+    ("BOPOMOFO LETTER ZH" #x3113)
+    ("BOPOMOFO LETTER CH" #x3114)
+    ("BOPOMOFO LETTER SH" #x3115)
+    ("BOPOMOFO LETTER R" #x3116)
+    ("BOPOMOFO LETTER Z" #x3117)
+    ("BOPOMOFO LETTER C" #x3118)
+    ("BOPOMOFO LETTER S" #x3119)
+    ("BOPOMOFO LETTER A" #x311A)
+    ("BOPOMOFO LETTER O" #x311B)
+    ("BOPOMOFO LETTER E" #x311C)
+    ("BOPOMOFO LETTER EH" #x311D)
+    ("BOPOMOFO LETTER AI" #x311E)
+    ("BOPOMOFO LETTER EI" #x311F)
+    ("BOPOMOFO LETTER AU" #x3120)
+    ("BOPOMOFO LETTER OU" #x3121)
+    ("BOPOMOFO LETTER AN" #x3122)
+    ("BOPOMOFO LETTER EN" #x3123)
+    ("BOPOMOFO LETTER ANG" #x3124)
+    ("BOPOMOFO LETTER ENG" #x3125)
+    ("BOPOMOFO LETTER ER" #x3126)
+    ("BOPOMOFO LETTER I" #x3127)
+    ("BOPOMOFO LETTER U" #x3128)
+    ("BOPOMOFO LETTER IU" #x3129)
+    ("BOPOMOFO LETTER V" #x312A)
+    ("BOPOMOFO LETTER NG" #x312B)
+    ("BOPOMOFO LETTER GN" #x312C)
+    ))
diff --git a/lisp/nxml/char-name/unicode/03130-0318F.el b/lisp/nxml/char-name/unicode/03130-0318F.el
new file mode 100644
index 00000000000..5e7746f4a50
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/03130-0318F.el
@@ -0,0 +1,96 @@
+(nxml-define-char-name-set 'hangul-compatibility-jamo
+  '(("HANGUL LETTER KIYEOK" #x3131)
+    ("HANGUL LETTER SSANGKIYEOK" #x3132)
+    ("HANGUL LETTER KIYEOK-SIOS" #x3133)
+    ("HANGUL LETTER NIEUN" #x3134)
+    ("HANGUL LETTER NIEUN-CIEUC" #x3135)
+    ("HANGUL LETTER NIEUN-HIEUH" #x3136)
+    ("HANGUL LETTER TIKEUT" #x3137)
+    ("HANGUL LETTER SSANGTIKEUT" #x3138)
+    ("HANGUL LETTER RIEUL" #x3139)
+    ("HANGUL LETTER RIEUL-KIYEOK" #x313A)
+    ("HANGUL LETTER RIEUL-MIEUM" #x313B)
+    ("HANGUL LETTER RIEUL-PIEUP" #x313C)
+    ("HANGUL LETTER RIEUL-SIOS" #x313D)
+    ("HANGUL LETTER RIEUL-THIEUTH" #x313E)
+    ("HANGUL LETTER RIEUL-PHIEUPH" #x313F)
+    ("HANGUL LETTER RIEUL-HIEUH" #x3140)
+    ("HANGUL LETTER MIEUM" #x3141)
+    ("HANGUL LETTER PIEUP" #x3142)
+    ("HANGUL LETTER SSANGPIEUP" #x3143)
+    ("HANGUL LETTER PIEUP-SIOS" #x3144)
+    ("HANGUL LETTER SIOS" #x3145)
+    ("HANGUL LETTER SSANGSIOS" #x3146)
+    ("HANGUL LETTER IEUNG" #x3147)
+    ("HANGUL LETTER CIEUC" #x3148)
+    ("HANGUL LETTER SSANGCIEUC" #x3149)
+    ("HANGUL LETTER CHIEUCH" #x314A)
+    ("HANGUL LETTER KHIEUKH" #x314B)
+    ("HANGUL LETTER THIEUTH" #x314C)
+    ("HANGUL LETTER PHIEUPH" #x314D)
+    ("HANGUL LETTER HIEUH" #x314E)
+    ("HANGUL LETTER A" #x314F)
+    ("HANGUL LETTER AE" #x3150)
+    ("HANGUL LETTER YA" #x3151)
+    ("HANGUL LETTER YAE" #x3152)
+    ("HANGUL LETTER EO" #x3153)
+    ("HANGUL LETTER E" #x3154)
+    ("HANGUL LETTER YEO" #x3155)
+    ("HANGUL LETTER YE" #x3156)
+    ("HANGUL LETTER O" #x3157)
+    ("HANGUL LETTER WA" #x3158)
+    ("HANGUL LETTER WAE" #x3159)
+    ("HANGUL LETTER OE" #x315A)
+    ("HANGUL LETTER YO" #x315B)
+    ("HANGUL LETTER U" #x315C)
+    ("HANGUL LETTER WEO" #x315D)
+    ("HANGUL LETTER WE" #x315E)
+    ("HANGUL LETTER WI" #x315F)
+    ("HANGUL LETTER YU" #x3160)
+    ("HANGUL LETTER EU" #x3161)
+    ("HANGUL LETTER YI" #x3162)
+    ("HANGUL LETTER I" #x3163)
+    ("HANGUL FILLER" #x3164)
+    ("HANGUL LETTER SSANGNIEUN" #x3165)
+    ("HANGUL LETTER NIEUN-TIKEUT" #x3166)
+    ("HANGUL LETTER NIEUN-SIOS" #x3167)
+    ("HANGUL LETTER NIEUN-PANSIOS" #x3168)
+    ("HANGUL LETTER RIEUL-KIYEOK-SIOS" #x3169)
+    ("HANGUL LETTER RIEUL-TIKEUT" #x316A)
+    ("HANGUL LETTER RIEUL-PIEUP-SIOS" #x316B)
+    ("HANGUL LETTER RIEUL-PANSIOS" #x316C)
+    ("HANGUL LETTER RIEUL-YEORINHIEUH" #x316D)
+    ("HANGUL LETTER MIEUM-PIEUP" #x316E)
+    ("HANGUL LETTER MIEUM-SIOS" #x316F)
+    ("HANGUL LETTER MIEUM-PANSIOS" #x3170)
+    ("HANGUL LETTER KAPYEOUNMIEUM" #x3171)
+    ("HANGUL LETTER PIEUP-KIYEOK" #x3172)
+    ("HANGUL LETTER PIEUP-TIKEUT" #x3173)
+    ("HANGUL LETTER PIEUP-SIOS-KIYEOK" #x3174)
+    ("HANGUL LETTER PIEUP-SIOS-TIKEUT" #x3175)
+    ("HANGUL LETTER PIEUP-CIEUC" #x3176)
+    ("HANGUL LETTER PIEUP-THIEUTH" #x3177)
+    ("HANGUL LETTER KAPYEOUNPIEUP" #x3178)
+    ("HANGUL LETTER KAPYEOUNSSANGPIEUP" #x3179)
+    ("HANGUL LETTER SIOS-KIYEOK" #x317A)
+    ("HANGUL LETTER SIOS-NIEUN" #x317B)
+    ("HANGUL LETTER SIOS-TIKEUT" #x317C)
+    ("HANGUL LETTER SIOS-PIEUP" #x317D)
+    ("HANGUL LETTER SIOS-CIEUC" #x317E)
+    ("HANGUL LETTER PANSIOS" #x317F)
+    ("HANGUL LETTER SSANGIEUNG" #x3180)
+    ("HANGUL LETTER YESIEUNG" #x3181)
+    ("HANGUL LETTER YESIEUNG-SIOS" #x3182)
+    ("HANGUL LETTER YESIEUNG-PANSIOS" #x3183)
+    ("HANGUL LETTER KAPYEOUNPHIEUPH" #x3184)
+    ("HANGUL LETTER SSANGHIEUH" #x3185)
+    ("HANGUL LETTER YEORINHIEUH" #x3186)
+    ("HANGUL LETTER YO-YA" #x3187)
+    ("HANGUL LETTER YO-YAE" #x3188)
+    ("HANGUL LETTER YO-I" #x3189)
+    ("HANGUL LETTER YU-YEO" #x318A)
+    ("HANGUL LETTER YU-YE" #x318B)
+    ("HANGUL LETTER YU-I" #x318C)
+    ("HANGUL LETTER ARAEA" #x318D)
+    ("HANGUL LETTER ARAEAE" #x318E)
+    ))
diff --git a/lisp/nxml/char-name/unicode/03190-0319F.el b/lisp/nxml/char-name/unicode/03190-0319F.el
new file mode 100644
index 00000000000..b8520da93a0
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/03190-0319F.el
@@ -0,0 +1,18 @@
+(nxml-define-char-name-set 'kanbun
+  '(("IDEOGRAPHIC ANNOTATION LINKING MARK" #x3190)
+    ("IDEOGRAPHIC ANNOTATION REVERSE MARK" #x3191)
+    ("IDEOGRAPHIC ANNOTATION ONE MARK" #x3192)
+    ("IDEOGRAPHIC ANNOTATION TWO MARK" #x3193)
+    ("IDEOGRAPHIC ANNOTATION THREE MARK" #x3194)
+    ("IDEOGRAPHIC ANNOTATION FOUR MARK" #x3195)
+    ("IDEOGRAPHIC ANNOTATION TOP MARK" #x3196)
+    ("IDEOGRAPHIC ANNOTATION MIDDLE MARK" #x3197)
+    ("IDEOGRAPHIC ANNOTATION BOTTOM MARK" #x3198)
+    ("IDEOGRAPHIC ANNOTATION FIRST MARK" #x3199)
+    ("IDEOGRAPHIC ANNOTATION SECOND MARK" #x319A)
+    ("IDEOGRAPHIC ANNOTATION THIRD MARK" #x319B)
+    ("IDEOGRAPHIC ANNOTATION FOURTH MARK" #x319C)
+    ("IDEOGRAPHIC ANNOTATION HEAVEN MARK" #x319D)
+    ("IDEOGRAPHIC ANNOTATION EARTH MARK" #x319E)
+    ("IDEOGRAPHIC ANNOTATION MAN MARK" #x319F)
+    ))
diff --git a/lisp/nxml/char-name/unicode/031A0-031BF.el b/lisp/nxml/char-name/unicode/031A0-031BF.el
new file mode 100644
index 00000000000..18392547c89
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/031A0-031BF.el
@@ -0,0 +1,26 @@
+(nxml-define-char-name-set 'bopomofo-extended
+  '(("BOPOMOFO LETTER BU" #x31A0)
+    ("BOPOMOFO LETTER ZI" #x31A1)
+    ("BOPOMOFO LETTER JI" #x31A2)
+    ("BOPOMOFO LETTER GU" #x31A3)
+    ("BOPOMOFO LETTER EE" #x31A4)
+    ("BOPOMOFO LETTER ENN" #x31A5)
+    ("BOPOMOFO LETTER OO" #x31A6)
+    ("BOPOMOFO LETTER ONN" #x31A7)
+    ("BOPOMOFO LETTER IR" #x31A8)
+    ("BOPOMOFO LETTER ANN" #x31A9)
+    ("BOPOMOFO LETTER INN" #x31AA)
+    ("BOPOMOFO LETTER UNN" #x31AB)
+    ("BOPOMOFO LETTER IM" #x31AC)
+    ("BOPOMOFO LETTER NGG" #x31AD)
+    ("BOPOMOFO LETTER AINN" #x31AE)
+    ("BOPOMOFO LETTER AUNN" #x31AF)
+    ("BOPOMOFO LETTER AM" #x31B0)
+    ("BOPOMOFO LETTER OM" #x31B1)
+    ("BOPOMOFO LETTER ONG" #x31B2)
+    ("BOPOMOFO LETTER INNN" #x31B3)
+    ("BOPOMOFO FINAL LETTER P" #x31B4)
+    ("BOPOMOFO FINAL LETTER T" #x31B5)
+    ("BOPOMOFO FINAL LETTER K" #x31B6)
+    ("BOPOMOFO FINAL LETTER H" #x31B7)
+    ))
diff --git a/lisp/nxml/char-name/unicode/031F0-031FF.el b/lisp/nxml/char-name/unicode/031F0-031FF.el
new file mode 100644
index 00000000000..e637bf3c6d7
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/031F0-031FF.el
@@ -0,0 +1,18 @@
+(nxml-define-char-name-set 'katakana-phonetic-extensions
+  '(("KATAKANA LETTER SMALL KU" #x31F0)
+    ("KATAKANA LETTER SMALL SI" #x31F1)
+    ("KATAKANA LETTER SMALL SU" #x31F2)
+    ("KATAKANA LETTER SMALL TO" #x31F3)
+    ("KATAKANA LETTER SMALL NU" #x31F4)
+    ("KATAKANA LETTER SMALL HA" #x31F5)
+    ("KATAKANA LETTER SMALL HI" #x31F6)
+    ("KATAKANA LETTER SMALL HU" #x31F7)
+    ("KATAKANA LETTER SMALL HE" #x31F8)
+    ("KATAKANA LETTER SMALL HO" #x31F9)
+    ("KATAKANA LETTER SMALL MU" #x31FA)
+    ("KATAKANA LETTER SMALL RA" #x31FB)
+    ("KATAKANA LETTER SMALL RI" #x31FC)
+    ("KATAKANA LETTER SMALL RU" #x31FD)
+    ("KATAKANA LETTER SMALL RE" #x31FE)
+    ("KATAKANA LETTER SMALL RO" #x31FF)
+    ))
diff --git a/lisp/nxml/char-name/unicode/03200-032FF.el b/lisp/nxml/char-name/unicode/03200-032FF.el
new file mode 100644
index 00000000000..625ff5bdfdb
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/03200-032FF.el
@@ -0,0 +1,234 @@
+(nxml-define-char-name-set 'enclosed-cjk-letters-and-months
+  '(("PARENTHESIZED HANGUL KIYEOK" #x3200)
+    ("PARENTHESIZED HANGUL NIEUN" #x3201)
+    ("PARENTHESIZED HANGUL TIKEUT" #x3202)
+    ("PARENTHESIZED HANGUL RIEUL" #x3203)
+    ("PARENTHESIZED HANGUL MIEUM" #x3204)
+    ("PARENTHESIZED HANGUL PIEUP" #x3205)
+    ("PARENTHESIZED HANGUL SIOS" #x3206)
+    ("PARENTHESIZED HANGUL IEUNG" #x3207)
+    ("PARENTHESIZED HANGUL CIEUC" #x3208)
+    ("PARENTHESIZED HANGUL CHIEUCH" #x3209)
+    ("PARENTHESIZED HANGUL KHIEUKH" #x320A)
+    ("PARENTHESIZED HANGUL THIEUTH" #x320B)
+    ("PARENTHESIZED HANGUL PHIEUPH" #x320C)
+    ("PARENTHESIZED HANGUL HIEUH" #x320D)
+    ("PARENTHESIZED HANGUL KIYEOK A" #x320E)
+    ("PARENTHESIZED HANGUL NIEUN A" #x320F)
+    ("PARENTHESIZED HANGUL TIKEUT A" #x3210)
+    ("PARENTHESIZED HANGUL RIEUL A" #x3211)
+    ("PARENTHESIZED HANGUL MIEUM A" #x3212)
+    ("PARENTHESIZED HANGUL PIEUP A" #x3213)
+    ("PARENTHESIZED HANGUL SIOS A" #x3214)
+    ("PARENTHESIZED HANGUL IEUNG A" #x3215)
+    ("PARENTHESIZED HANGUL CIEUC A" #x3216)
+    ("PARENTHESIZED HANGUL CHIEUCH A" #x3217)
+    ("PARENTHESIZED HANGUL KHIEUKH A" #x3218)
+    ("PARENTHESIZED HANGUL THIEUTH A" #x3219)
+    ("PARENTHESIZED HANGUL PHIEUPH A" #x321A)
+    ("PARENTHESIZED HANGUL HIEUH A" #x321B)
+    ("PARENTHESIZED HANGUL CIEUC U" #x321C)
+    ("PARENTHESIZED IDEOGRAPH ONE" #x3220)
+    ("PARENTHESIZED IDEOGRAPH TWO" #x3221)
+    ("PARENTHESIZED IDEOGRAPH THREE" #x3222)
+    ("PARENTHESIZED IDEOGRAPH FOUR" #x3223)
+    ("PARENTHESIZED IDEOGRAPH FIVE" #x3224)
+    ("PARENTHESIZED IDEOGRAPH SIX" #x3225)
+    ("PARENTHESIZED IDEOGRAPH SEVEN" #x3226)
+    ("PARENTHESIZED IDEOGRAPH EIGHT" #x3227)
+    ("PARENTHESIZED IDEOGRAPH NINE" #x3228)
+    ("PARENTHESIZED IDEOGRAPH TEN" #x3229)
+    ("PARENTHESIZED IDEOGRAPH MOON" #x322A)
+    ("PARENTHESIZED IDEOGRAPH FIRE" #x322B)
+    ("PARENTHESIZED IDEOGRAPH WATER" #x322C)
+    ("PARENTHESIZED IDEOGRAPH WOOD" #x322D)
+    ("PARENTHESIZED IDEOGRAPH METAL" #x322E)
+    ("PARENTHESIZED IDEOGRAPH EARTH" #x322F)
+    ("PARENTHESIZED IDEOGRAPH SUN" #x3230)
+    ("PARENTHESIZED IDEOGRAPH STOCK" #x3231)
+    ("PARENTHESIZED IDEOGRAPH HAVE" #x3232)
+    ("PARENTHESIZED IDEOGRAPH SOCIETY" #x3233)
+    ("PARENTHESIZED IDEOGRAPH NAME" #x3234)
+    ("PARENTHESIZED IDEOGRAPH SPECIAL" #x3235)
+    ("PARENTHESIZED IDEOGRAPH FINANCIAL" #x3236)
+    ("PARENTHESIZED IDEOGRAPH CONGRATULATION" #x3237)
+    ("PARENTHESIZED IDEOGRAPH LABOR" #x3238)
+    ("PARENTHESIZED IDEOGRAPH REPRESENT" #x3239)
+    ("PARENTHESIZED IDEOGRAPH CALL" #x323A)
+    ("PARENTHESIZED IDEOGRAPH STUDY" #x323B)
+    ("PARENTHESIZED IDEOGRAPH SUPERVISE" #x323C)
+    ("PARENTHESIZED IDEOGRAPH ENTERPRISE" #x323D)
+    ("PARENTHESIZED IDEOGRAPH RESOURCE" #x323E)
+    ("PARENTHESIZED IDEOGRAPH ALLIANCE" #x323F)
+    ("PARENTHESIZED IDEOGRAPH FESTIVAL" #x3240)
+    ("PARENTHESIZED IDEOGRAPH REST" #x3241)
+    ("PARENTHESIZED IDEOGRAPH SELF" #x3242)
+    ("PARENTHESIZED IDEOGRAPH REACH" #x3243)
+    ("CIRCLED NUMBER TWENTY ONE" #x3251)
+    ("CIRCLED NUMBER TWENTY TWO" #x3252)
+    ("CIRCLED NUMBER TWENTY THREE" #x3253)
+    ("CIRCLED NUMBER TWENTY FOUR" #x3254)
+    ("CIRCLED NUMBER TWENTY FIVE" #x3255)
+    ("CIRCLED NUMBER TWENTY SIX" #x3256)
+    ("CIRCLED NUMBER TWENTY SEVEN" #x3257)
+    ("CIRCLED NUMBER TWENTY EIGHT" #x3258)
+    ("CIRCLED NUMBER TWENTY NINE" #x3259)
+    ("CIRCLED NUMBER THIRTY" #x325A)
+    ("CIRCLED NUMBER THIRTY ONE" #x325B)
+    ("CIRCLED NUMBER THIRTY TWO" #x325C)
+    ("CIRCLED NUMBER THIRTY THREE" #x325D)
+    ("CIRCLED NUMBER THIRTY FOUR" #x325E)
+    ("CIRCLED NUMBER THIRTY FIVE" #x325F)
+    ("CIRCLED HANGUL KIYEOK" #x3260)
+    ("CIRCLED HANGUL NIEUN" #x3261)
+    ("CIRCLED HANGUL TIKEUT" #x3262)
+    ("CIRCLED HANGUL RIEUL" #x3263)
+    ("CIRCLED HANGUL MIEUM" #x3264)
+    ("CIRCLED HANGUL PIEUP" #x3265)
+    ("CIRCLED HANGUL SIOS" #x3266)
+    ("CIRCLED HANGUL IEUNG" #x3267)
+    ("CIRCLED HANGUL CIEUC" #x3268)
+    ("CIRCLED HANGUL CHIEUCH" #x3269)
+    ("CIRCLED HANGUL KHIEUKH" #x326A)
+    ("CIRCLED HANGUL THIEUTH" #x326B)
+    ("CIRCLED HANGUL PHIEUPH" #x326C)
+    ("CIRCLED HANGUL HIEUH" #x326D)
+    ("CIRCLED HANGUL KIYEOK A" #x326E)
+    ("CIRCLED HANGUL NIEUN A" #x326F)
+    ("CIRCLED HANGUL TIKEUT A" #x3270)
+    ("CIRCLED HANGUL RIEUL A" #x3271)
+    ("CIRCLED HANGUL MIEUM A" #x3272)
+    ("CIRCLED HANGUL PIEUP A" #x3273)
+    ("CIRCLED HANGUL SIOS A" #x3274)
+    ("CIRCLED HANGUL IEUNG A" #x3275)
+    ("CIRCLED HANGUL CIEUC A" #x3276)
+    ("CIRCLED HANGUL CHIEUCH A" #x3277)
+    ("CIRCLED HANGUL KHIEUKH A" #x3278)
+    ("CIRCLED HANGUL THIEUTH A" #x3279)
+    ("CIRCLED HANGUL PHIEUPH A" #x327A)
+    ("CIRCLED HANGUL HIEUH A" #x327B)
+    ("KOREAN STANDARD SYMBOL" #x327F)
+    ("CIRCLED IDEOGRAPH ONE" #x3280)
+    ("CIRCLED IDEOGRAPH TWO" #x3281)
+    ("CIRCLED IDEOGRAPH THREE" #x3282)
+    ("CIRCLED IDEOGRAPH FOUR" #x3283)
+    ("CIRCLED IDEOGRAPH FIVE" #x3284)
+    ("CIRCLED IDEOGRAPH SIX" #x3285)
+    ("CIRCLED IDEOGRAPH SEVEN" #x3286)
+    ("CIRCLED IDEOGRAPH EIGHT" #x3287)
+    ("CIRCLED IDEOGRAPH NINE" #x3288)
+    ("CIRCLED IDEOGRAPH TEN" #x3289)
+    ("CIRCLED IDEOGRAPH MOON" #x328A)
+    ("CIRCLED IDEOGRAPH FIRE" #x328B)
+    ("CIRCLED IDEOGRAPH WATER" #x328C)
+    ("CIRCLED IDEOGRAPH WOOD" #x328D)
+    ("CIRCLED IDEOGRAPH METAL" #x328E)
+    ("CIRCLED IDEOGRAPH EARTH" #x328F)
+    ("CIRCLED IDEOGRAPH SUN" #x3290)
+    ("CIRCLED IDEOGRAPH STOCK" #x3291)
+    ("CIRCLED IDEOGRAPH HAVE" #x3292)
+    ("CIRCLED IDEOGRAPH SOCIETY" #x3293)
+    ("CIRCLED IDEOGRAPH NAME" #x3294)
+    ("CIRCLED IDEOGRAPH SPECIAL" #x3295)
+    ("CIRCLED IDEOGRAPH FINANCIAL" #x3296)
+    ("CIRCLED IDEOGRAPH CONGRATULATION" #x3297)
+    ("CIRCLED IDEOGRAPH LABOR" #x3298)
+    ("CIRCLED IDEOGRAPH SECRET" #x3299)
+    ("CIRCLED IDEOGRAPH MALE" #x329A)
+    ("CIRCLED IDEOGRAPH FEMALE" #x329B)
+    ("CIRCLED IDEOGRAPH SUITABLE" #x329C)
+    ("CIRCLED IDEOGRAPH EXCELLENT" #x329D)
+    ("CIRCLED IDEOGRAPH PRINT" #x329E)
+    ("CIRCLED IDEOGRAPH ATTENTION" #x329F)
+    ("CIRCLED IDEOGRAPH ITEM" #x32A0)
+    ("CIRCLED IDEOGRAPH REST" #x32A1)
+    ("CIRCLED IDEOGRAPH COPY" #x32A2)
+    ("CIRCLED IDEOGRAPH CORRECT" #x32A3)
+    ("CIRCLED IDEOGRAPH HIGH" #x32A4)
+    ("CIRCLED IDEOGRAPH CENTRE" #x32A5)
+    ("CIRCLED IDEOGRAPH LOW" #x32A6)
+    ("CIRCLED IDEOGRAPH LEFT" #x32A7)
+    ("CIRCLED IDEOGRAPH RIGHT" #x32A8)
+    ("CIRCLED IDEOGRAPH MEDICINE" #x32A9)
+    ("CIRCLED IDEOGRAPH RELIGION" #x32AA)
+    ("CIRCLED IDEOGRAPH STUDY" #x32AB)
+    ("CIRCLED IDEOGRAPH SUPERVISE" #x32AC)
+    ("CIRCLED IDEOGRAPH ENTERPRISE" #x32AD)
+    ("CIRCLED IDEOGRAPH RESOURCE" #x32AE)
+    ("CIRCLED IDEOGRAPH ALLIANCE" #x32AF)
+    ("CIRCLED IDEOGRAPH NIGHT" #x32B0)
+    ("CIRCLED NUMBER THIRTY SIX" #x32B1)
+    ("CIRCLED NUMBER THIRTY SEVEN" #x32B2)
+    ("CIRCLED NUMBER THIRTY EIGHT" #x32B3)
+    ("CIRCLED NUMBER THIRTY NINE" #x32B4)
+    ("CIRCLED NUMBER FORTY" #x32B5)
+    ("CIRCLED NUMBER FORTY ONE" #x32B6)
+    ("CIRCLED NUMBER FORTY TWO" #x32B7)
+    ("CIRCLED NUMBER FORTY THREE" #x32B8)
+    ("CIRCLED NUMBER FORTY FOUR" #x32B9)
+    ("CIRCLED NUMBER FORTY FIVE" #x32BA)
+    ("CIRCLED NUMBER FORTY SIX" #x32BB)
+    ("CIRCLED NUMBER FORTY SEVEN" #x32BC)
+    ("CIRCLED NUMBER FORTY EIGHT" #x32BD)
+    ("CIRCLED NUMBER FORTY NINE" #x32BE)
+    ("CIRCLED NUMBER FIFTY" #x32BF)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR JANUARY" #x32C0)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR FEBRUARY" #x32C1)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR MARCH" #x32C2)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR APRIL" #x32C3)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR MAY" #x32C4)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR JUNE" #x32C5)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR JULY" #x32C6)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR AUGUST" #x32C7)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR SEPTEMBER" #x32C8)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR OCTOBER" #x32C9)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR NOVEMBER" #x32CA)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR DECEMBER" #x32CB)
+    ("CIRCLED KATAKANA A" #x32D0)
+    ("CIRCLED KATAKANA I" #x32D1)
+    ("CIRCLED KATAKANA U" #x32D2)
+    ("CIRCLED KATAKANA E" #x32D3)
+    ("CIRCLED KATAKANA O" #x32D4)
+    ("CIRCLED KATAKANA KA" #x32D5)
+    ("CIRCLED KATAKANA KI" #x32D6)
+    ("CIRCLED KATAKANA KU" #x32D7)
+    ("CIRCLED KATAKANA KE" #x32D8)
+    ("CIRCLED KATAKANA KO" #x32D9)
+    ("CIRCLED KATAKANA SA" #x32DA)
+    ("CIRCLED KATAKANA SI" #x32DB)
+    ("CIRCLED KATAKANA SU" #x32DC)
+    ("CIRCLED KATAKANA SE" #x32DD)
+    ("CIRCLED KATAKANA SO" #x32DE)
+    ("CIRCLED KATAKANA TA" #x32DF)
+    ("CIRCLED KATAKANA TI" #x32E0)
+    ("CIRCLED KATAKANA TU" #x32E1)
+    ("CIRCLED KATAKANA TE" #x32E2)
+    ("CIRCLED KATAKANA TO" #x32E3)
+    ("CIRCLED KATAKANA NA" #x32E4)
+    ("CIRCLED KATAKANA NI" #x32E5)
+    ("CIRCLED KATAKANA NU" #x32E6)
+    ("CIRCLED KATAKANA NE" #x32E7)
+    ("CIRCLED KATAKANA NO" #x32E8)
+    ("CIRCLED KATAKANA HA" #x32E9)
+    ("CIRCLED KATAKANA HI" #x32EA)
+    ("CIRCLED KATAKANA HU" #x32EB)
+    ("CIRCLED KATAKANA HE" #x32EC)
+    ("CIRCLED KATAKANA HO" #x32ED)
+    ("CIRCLED KATAKANA MA" #x32EE)
+    ("CIRCLED KATAKANA MI" #x32EF)
+    ("CIRCLED KATAKANA MU" #x32F0)
+    ("CIRCLED KATAKANA ME" #x32F1)
+    ("CIRCLED KATAKANA MO" #x32F2)
+    ("CIRCLED KATAKANA YA" #x32F3)
+    ("CIRCLED KATAKANA YU" #x32F4)
+    ("CIRCLED KATAKANA YO" #x32F5)
+    ("CIRCLED KATAKANA RA" #x32F6)
+    ("CIRCLED KATAKANA RI" #x32F7)
+    ("CIRCLED KATAKANA RU" #x32F8)
+    ("CIRCLED KATAKANA RE" #x32F9)
+    ("CIRCLED KATAKANA RO" #x32FA)
+    ("CIRCLED KATAKANA WA" #x32FB)
+    ("CIRCLED KATAKANA WI" #x32FC)
+    ("CIRCLED KATAKANA WE" #x32FD)
+    ("CIRCLED KATAKANA WO" #x32FE)
+    ))
diff --git a/lisp/nxml/char-name/unicode/03300-033FF.el b/lisp/nxml/char-name/unicode/03300-033FF.el
new file mode 100644
index 00000000000..25a070fd6cf
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/03300-033FF.el
@@ -0,0 +1,251 @@
+(nxml-define-char-name-set 'cjk-compatibility
+  '(("SQUARE APAATO" #x3300)
+    ("SQUARE ARUHUA" #x3301)
+    ("SQUARE ANPEA" #x3302)
+    ("SQUARE AARU" #x3303)
+    ("SQUARE ININGU" #x3304)
+    ("SQUARE INTI" #x3305)
+    ("SQUARE UON" #x3306)
+    ("SQUARE ESUKUUDO" #x3307)
+    ("SQUARE EEKAA" #x3308)
+    ("SQUARE ONSU" #x3309)
+    ("SQUARE OOMU" #x330A)
+    ("SQUARE KAIRI" #x330B)
+    ("SQUARE KARATTO" #x330C)
+    ("SQUARE KARORII" #x330D)
+    ("SQUARE GARON" #x330E)
+    ("SQUARE GANMA" #x330F)
+    ("SQUARE GIGA" #x3310)
+    ("SQUARE GINII" #x3311)
+    ("SQUARE KYURII" #x3312)
+    ("SQUARE GIRUDAA" #x3313)
+    ("SQUARE KIRO" #x3314)
+    ("SQUARE KIROGURAMU" #x3315)
+    ("SQUARE KIROMEETORU" #x3316)
+    ("SQUARE KIROWATTO" #x3317)
+    ("SQUARE GURAMU" #x3318)
+    ("SQUARE GURAMUTON" #x3319)
+    ("SQUARE KURUZEIRO" #x331A)
+    ("SQUARE KUROONE" #x331B)
+    ("SQUARE KEESU" #x331C)
+    ("SQUARE KORUNA" #x331D)
+    ("SQUARE KOOPO" #x331E)
+    ("SQUARE SAIKURU" #x331F)
+    ("SQUARE SANTIIMU" #x3320)
+    ("SQUARE SIRINGU" #x3321)
+    ("SQUARE SENTI" #x3322)
+    ("SQUARE SENTO" #x3323)
+    ("SQUARE DAASU" #x3324)
+    ("SQUARE DESI" #x3325)
+    ("SQUARE DORU" #x3326)
+    ("SQUARE TON" #x3327)
+    ("SQUARE NANO" #x3328)
+    ("SQUARE NOTTO" #x3329)
+    ("SQUARE HAITU" #x332A)
+    ("SQUARE PAASENTO" #x332B)
+    ("SQUARE PAATU" #x332C)
+    ("SQUARE BAARERU" #x332D)
+    ("SQUARE PIASUTORU" #x332E)
+    ("SQUARE PIKURU" #x332F)
+    ("SQUARE PIKO" #x3330)
+    ("SQUARE BIRU" #x3331)
+    ("SQUARE HUARADDO" #x3332)
+    ("SQUARE HUIITO" #x3333)
+    ("SQUARE BUSSYERU" #x3334)
+    ("SQUARE HURAN" #x3335)
+    ("SQUARE HEKUTAARU" #x3336)
+    ("SQUARE PESO" #x3337)
+    ("SQUARE PENIHI" #x3338)
+    ("SQUARE HERUTU" #x3339)
+    ("SQUARE PENSU" #x333A)
+    ("SQUARE PEEZI" #x333B)
+    ("SQUARE BEETA" #x333C)
+    ("SQUARE POINTO" #x333D)
+    ("SQUARE BORUTO" #x333E)
+    ("SQUARE HON" #x333F)
+    ("SQUARE PONDO" #x3340)
+    ("SQUARE HOORU" #x3341)
+    ("SQUARE HOON" #x3342)
+    ("SQUARE MAIKURO" #x3343)
+    ("SQUARE MAIRU" #x3344)
+    ("SQUARE MAHHA" #x3345)
+    ("SQUARE MARUKU" #x3346)
+    ("SQUARE MANSYON" #x3347)
+    ("SQUARE MIKURON" #x3348)
+    ("SQUARE MIRI" #x3349)
+    ("SQUARE MIRIBAARU" #x334A)
+    ("SQUARE MEGA" #x334B)
+    ("SQUARE MEGATON" #x334C)
+    ("SQUARE MEETORU" #x334D)
+    ("SQUARE YAADO" #x334E)
+    ("SQUARE YAARU" #x334F)
+    ("SQUARE YUAN" #x3350)
+    ("SQUARE RITTORU" #x3351)
+    ("SQUARE RIRA" #x3352)
+    ("SQUARE RUPII" #x3353)
+    ("SQUARE RUUBURU" #x3354)
+    ("SQUARE REMU" #x3355)
+    ("SQUARE RENTOGEN" #x3356)
+    ("SQUARE WATTO" #x3357)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR ZERO" #x3358)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR ONE" #x3359)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR TWO" #x335A)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR THREE" #x335B)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR FOUR" #x335C)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR FIVE" #x335D)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR SIX" #x335E)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR SEVEN" #x335F)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR EIGHT" #x3360)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR NINE" #x3361)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR TEN" #x3362)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR ELEVEN" #x3363)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR TWELVE" #x3364)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR THIRTEEN" #x3365)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR FOURTEEN" #x3366)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR FIFTEEN" #x3367)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR SIXTEEN" #x3368)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR SEVENTEEN" #x3369)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR EIGHTEEN" #x336A)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR NINETEEN" #x336B)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR TWENTY" #x336C)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR TWENTY-ONE" #x336D)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR TWENTY-TWO" #x336E)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR TWENTY-THREE" #x336F)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR TWENTY-FOUR" #x3370)
+    ("SQUARE HPA" #x3371)
+    ("SQUARE DA" #x3372)
+    ("SQUARE AU" #x3373)
+    ("SQUARE BAR" #x3374)
+    ("SQUARE OV" #x3375)
+    ("SQUARE PC" #x3376)
+    ("SQUARE ERA NAME HEISEI" #x337B)
+    ("SQUARE ERA NAME SYOUWA" #x337C)
+    ("SQUARE ERA NAME TAISYOU" #x337D)
+    ("SQUARE ERA NAME MEIZI" #x337E)
+    ("SQUARE CORPORATION" #x337F)
+    ("SQUARE PA AMPS" #x3380)
+    ("SQUARE NA" #x3381)
+    ("SQUARE MU A" #x3382)
+    ("SQUARE MA" #x3383)
+    ("SQUARE KA" #x3384)
+    ("SQUARE KB" #x3385)
+    ("SQUARE MB" #x3386)
+    ("SQUARE GB" #x3387)
+    ("SQUARE CAL" #x3388)
+    ("SQUARE KCAL" #x3389)
+    ("SQUARE PF" #x338A)
+    ("SQUARE NF" #x338B)
+    ("SQUARE MU F" #x338C)
+    ("SQUARE MU G" #x338D)
+    ("SQUARE MG" #x338E)
+    ("SQUARE KG" #x338F)
+    ("SQUARE HZ" #x3390)
+    ("SQUARE KHZ" #x3391)
+    ("SQUARE MHZ" #x3392)
+    ("SQUARE GHZ" #x3393)
+    ("SQUARE THZ" #x3394)
+    ("SQUARE MU L" #x3395)
+    ("SQUARE ML" #x3396)
+    ("SQUARE DL" #x3397)
+    ("SQUARE KL" #x3398)
+    ("SQUARE FM" #x3399)
+    ("SQUARE NM" #x339A)
+    ("SQUARE MU M" #x339B)
+    ("SQUARE MM" #x339C)
+    ("SQUARE CM" #x339D)
+    ("SQUARE KM" #x339E)
+    ("SQUARE MM SQUARED" #x339F)
+    ("SQUARE CM SQUARED" #x33A0)
+    ("SQUARE M SQUARED" #x33A1)
+    ("SQUARE KM SQUARED" #x33A2)
+    ("SQUARE MM CUBED" #x33A3)
+    ("SQUARE CM CUBED" #x33A4)
+    ("SQUARE M CUBED" #x33A5)
+    ("SQUARE KM CUBED" #x33A6)
+    ("SQUARE M OVER S" #x33A7)
+    ("SQUARE M OVER S SQUARED" #x33A8)
+    ("SQUARE PA" #x33A9)
+    ("SQUARE KPA" #x33AA)
+    ("SQUARE MPA" #x33AB)
+    ("SQUARE GPA" #x33AC)
+    ("SQUARE RAD" #x33AD)
+    ("SQUARE RAD OVER S" #x33AE)
+    ("SQUARE RAD OVER S SQUARED" #x33AF)
+    ("SQUARE PS" #x33B0)
+    ("SQUARE NS" #x33B1)
+    ("SQUARE MU S" #x33B2)
+    ("SQUARE MS" #x33B3)
+    ("SQUARE PV" #x33B4)
+    ("SQUARE NV" #x33B5)
+    ("SQUARE MU V" #x33B6)
+    ("SQUARE MV" #x33B7)
+    ("SQUARE KV" #x33B8)
+    ("SQUARE MV MEGA" #x33B9)
+    ("SQUARE PW" #x33BA)
+    ("SQUARE NW" #x33BB)
+    ("SQUARE MU W" #x33BC)
+    ("SQUARE MW" #x33BD)
+    ("SQUARE KW" #x33BE)
+    ("SQUARE MW MEGA" #x33BF)
+    ("SQUARE K OHM" #x33C0)
+    ("SQUARE M OHM" #x33C1)
+    ("SQUARE AM" #x33C2)
+    ("SQUARE BQ" #x33C3)
+    ("SQUARE CC" #x33C4)
+    ("SQUARE CD" #x33C5)
+    ("SQUARE C OVER KG" #x33C6)
+    ("SQUARE CO" #x33C7)
+    ("SQUARE DB" #x33C8)
+    ("SQUARE GY" #x33C9)
+    ("SQUARE HA" #x33CA)
+    ("SQUARE HP" #x33CB)
+    ("SQUARE IN" #x33CC)
+    ("SQUARE KK" #x33CD)
+    ("SQUARE KM CAPITAL" #x33CE)
+    ("SQUARE KT" #x33CF)
+    ("SQUARE LM" #x33D0)
+    ("SQUARE LN" #x33D1)
+    ("SQUARE LOG" #x33D2)
+    ("SQUARE LX" #x33D3)
+    ("SQUARE MB SMALL" #x33D4)
+    ("SQUARE MIL" #x33D5)
+    ("SQUARE MOL" #x33D6)
+    ("SQUARE PH" #x33D7)
+    ("SQUARE PM" #x33D8)
+    ("SQUARE PPM" #x33D9)
+    ("SQUARE PR" #x33DA)
+    ("SQUARE SR" #x33DB)
+    ("SQUARE SV" #x33DC)
+    ("SQUARE WB" #x33DD)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY ONE" #x33E0)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWO" #x33E1)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY THREE" #x33E2)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY FOUR" #x33E3)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY FIVE" #x33E4)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY SIX" #x33E5)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY SEVEN" #x33E6)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY EIGHT" #x33E7)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY NINE" #x33E8)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TEN" #x33E9)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY ELEVEN" #x33EA)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWELVE" #x33EB)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY THIRTEEN" #x33EC)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY FOURTEEN" #x33ED)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY FIFTEEN" #x33EE)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY SIXTEEN" #x33EF)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY SEVENTEEN" #x33F0)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY EIGHTEEN" #x33F1)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY NINETEEN" #x33F2)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY" #x33F3)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY-ONE" #x33F4)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY-TWO" #x33F5)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY-THREE" #x33F6)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY-FOUR" #x33F7)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY-FIVE" #x33F8)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY-SIX" #x33F9)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY-SEVEN" #x33FA)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY-EIGHT" #x33FB)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY-NINE" #x33FC)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY THIRTY" #x33FD)
+    ("IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY THIRTY-ONE" #x33FE)
+    ))
diff --git a/lisp/nxml/char-name/unicode/03400-04DBF.el b/lisp/nxml/char-name/unicode/03400-04DBF.el
new file mode 100644
index 00000000000..14d5c4bff57
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/03400-04DBF.el
@@ -0,0 +1,2 @@
+(nxml-define-char-name-set 'cjk-unified-ideographs-extension-a
+  '())
diff --git a/lisp/nxml/char-name/unicode/0A000-0A48F.el b/lisp/nxml/char-name/unicode/0A000-0A48F.el
new file mode 100644
index 00000000000..8d0727f6c1d
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/0A000-0A48F.el
@@ -0,0 +1,1167 @@
+(nxml-define-char-name-set 'yi-syllables
+  '(("YI SYLLABLE IT" #xA000)
+    ("YI SYLLABLE IX" #xA001)
+    ("YI SYLLABLE I" #xA002)
+    ("YI SYLLABLE IP" #xA003)
+    ("YI SYLLABLE IET" #xA004)
+    ("YI SYLLABLE IEX" #xA005)
+    ("YI SYLLABLE IE" #xA006)
+    ("YI SYLLABLE IEP" #xA007)
+    ("YI SYLLABLE AT" #xA008)
+    ("YI SYLLABLE AX" #xA009)
+    ("YI SYLLABLE A" #xA00A)
+    ("YI SYLLABLE AP" #xA00B)
+    ("YI SYLLABLE UOX" #xA00C)
+    ("YI SYLLABLE UO" #xA00D)
+    ("YI SYLLABLE UOP" #xA00E)
+    ("YI SYLLABLE OT" #xA00F)
+    ("YI SYLLABLE OX" #xA010)
+    ("YI SYLLABLE O" #xA011)
+    ("YI SYLLABLE OP" #xA012)
+    ("YI SYLLABLE EX" #xA013)
+    ("YI SYLLABLE E" #xA014)
+    ("YI SYLLABLE WU" #xA015)
+    ("YI SYLLABLE BIT" #xA016)
+    ("YI SYLLABLE BIX" #xA017)
+    ("YI SYLLABLE BI" #xA018)
+    ("YI SYLLABLE BIP" #xA019)
+    ("YI SYLLABLE BIET" #xA01A)
+    ("YI SYLLABLE BIEX" #xA01B)
+    ("YI SYLLABLE BIE" #xA01C)
+    ("YI SYLLABLE BIEP" #xA01D)
+    ("YI SYLLABLE BAT" #xA01E)
+    ("YI SYLLABLE BAX" #xA01F)
+    ("YI SYLLABLE BA" #xA020)
+    ("YI SYLLABLE BAP" #xA021)
+    ("YI SYLLABLE BUOX" #xA022)
+    ("YI SYLLABLE BUO" #xA023)
+    ("YI SYLLABLE BUOP" #xA024)
+    ("YI SYLLABLE BOT" #xA025)
+    ("YI SYLLABLE BOX" #xA026)
+    ("YI SYLLABLE BO" #xA027)
+    ("YI SYLLABLE BOP" #xA028)
+    ("YI SYLLABLE BEX" #xA029)
+    ("YI SYLLABLE BE" #xA02A)
+    ("YI SYLLABLE BEP" #xA02B)
+    ("YI SYLLABLE BUT" #xA02C)
+    ("YI SYLLABLE BUX" #xA02D)
+    ("YI SYLLABLE BU" #xA02E)
+    ("YI SYLLABLE BUP" #xA02F)
+    ("YI SYLLABLE BURX" #xA030)
+    ("YI SYLLABLE BUR" #xA031)
+    ("YI SYLLABLE BYT" #xA032)
+    ("YI SYLLABLE BYX" #xA033)
+    ("YI SYLLABLE BY" #xA034)
+    ("YI SYLLABLE BYP" #xA035)
+    ("YI SYLLABLE BYRX" #xA036)
+    ("YI SYLLABLE BYR" #xA037)
+    ("YI SYLLABLE PIT" #xA038)
+    ("YI SYLLABLE PIX" #xA039)
+    ("YI SYLLABLE PI" #xA03A)
+    ("YI SYLLABLE PIP" #xA03B)
+    ("YI SYLLABLE PIEX" #xA03C)
+    ("YI SYLLABLE PIE" #xA03D)
+    ("YI SYLLABLE PIEP" #xA03E)
+    ("YI SYLLABLE PAT" #xA03F)
+    ("YI SYLLABLE PAX" #xA040)
+    ("YI SYLLABLE PA" #xA041)
+    ("YI SYLLABLE PAP" #xA042)
+    ("YI SYLLABLE PUOX" #xA043)
+    ("YI SYLLABLE PUO" #xA044)
+    ("YI SYLLABLE PUOP" #xA045)
+    ("YI SYLLABLE POT" #xA046)
+    ("YI SYLLABLE POX" #xA047)
+    ("YI SYLLABLE PO" #xA048)
+    ("YI SYLLABLE POP" #xA049)
+    ("YI SYLLABLE PUT" #xA04A)
+    ("YI SYLLABLE PUX" #xA04B)
+    ("YI SYLLABLE PU" #xA04C)
+    ("YI SYLLABLE PUP" #xA04D)
+    ("YI SYLLABLE PURX" #xA04E)
+    ("YI SYLLABLE PUR" #xA04F)
+    ("YI SYLLABLE PYT" #xA050)
+    ("YI SYLLABLE PYX" #xA051)
+    ("YI SYLLABLE PY" #xA052)
+    ("YI SYLLABLE PYP" #xA053)
+    ("YI SYLLABLE PYRX" #xA054)
+    ("YI SYLLABLE PYR" #xA055)
+    ("YI SYLLABLE BBIT" #xA056)
+    ("YI SYLLABLE BBIX" #xA057)
+    ("YI SYLLABLE BBI" #xA058)
+    ("YI SYLLABLE BBIP" #xA059)
+    ("YI SYLLABLE BBIET" #xA05A)
+    ("YI SYLLABLE BBIEX" #xA05B)
+    ("YI SYLLABLE BBIE" #xA05C)
+    ("YI SYLLABLE BBIEP" #xA05D)
+    ("YI SYLLABLE BBAT" #xA05E)
+    ("YI SYLLABLE BBAX" #xA05F)
+    ("YI SYLLABLE BBA" #xA060)
+    ("YI SYLLABLE BBAP" #xA061)
+    ("YI SYLLABLE BBUOX" #xA062)
+    ("YI SYLLABLE BBUO" #xA063)
+    ("YI SYLLABLE BBUOP" #xA064)
+    ("YI SYLLABLE BBOT" #xA065)
+    ("YI SYLLABLE BBOX" #xA066)
+    ("YI SYLLABLE BBO" #xA067)
+    ("YI SYLLABLE BBOP" #xA068)
+    ("YI SYLLABLE BBEX" #xA069)
+    ("YI SYLLABLE BBE" #xA06A)
+    ("YI SYLLABLE BBEP" #xA06B)
+    ("YI SYLLABLE BBUT" #xA06C)
+    ("YI SYLLABLE BBUX" #xA06D)
+    ("YI SYLLABLE BBU" #xA06E)
+    ("YI SYLLABLE BBUP" #xA06F)
+    ("YI SYLLABLE BBURX" #xA070)
+    ("YI SYLLABLE BBUR" #xA071)
+    ("YI SYLLABLE BBYT" #xA072)
+    ("YI SYLLABLE BBYX" #xA073)
+    ("YI SYLLABLE BBY" #xA074)
+    ("YI SYLLABLE BBYP" #xA075)
+    ("YI SYLLABLE NBIT" #xA076)
+    ("YI SYLLABLE NBIX" #xA077)
+    ("YI SYLLABLE NBI" #xA078)
+    ("YI SYLLABLE NBIP" #xA079)
+    ("YI SYLLABLE NBIEX" #xA07A)
+    ("YI SYLLABLE NBIE" #xA07B)
+    ("YI SYLLABLE NBIEP" #xA07C)
+    ("YI SYLLABLE NBAT" #xA07D)
+    ("YI SYLLABLE NBAX" #xA07E)
+    ("YI SYLLABLE NBA" #xA07F)
+    ("YI SYLLABLE NBAP" #xA080)
+    ("YI SYLLABLE NBOT" #xA081)
+    ("YI SYLLABLE NBOX" #xA082)
+    ("YI SYLLABLE NBO" #xA083)
+    ("YI SYLLABLE NBOP" #xA084)
+    ("YI SYLLABLE NBUT" #xA085)
+    ("YI SYLLABLE NBUX" #xA086)
+    ("YI SYLLABLE NBU" #xA087)
+    ("YI SYLLABLE NBUP" #xA088)
+    ("YI SYLLABLE NBURX" #xA089)
+    ("YI SYLLABLE NBUR" #xA08A)
+    ("YI SYLLABLE NBYT" #xA08B)
+    ("YI SYLLABLE NBYX" #xA08C)
+    ("YI SYLLABLE NBY" #xA08D)
+    ("YI SYLLABLE NBYP" #xA08E)
+    ("YI SYLLABLE NBYRX" #xA08F)
+    ("YI SYLLABLE NBYR" #xA090)
+    ("YI SYLLABLE HMIT" #xA091)
+    ("YI SYLLABLE HMIX" #xA092)
+    ("YI SYLLABLE HMI" #xA093)
+    ("YI SYLLABLE HMIP" #xA094)
+    ("YI SYLLABLE HMIEX" #xA095)
+    ("YI SYLLABLE HMIE" #xA096)
+    ("YI SYLLABLE HMIEP" #xA097)
+    ("YI SYLLABLE HMAT" #xA098)
+    ("YI SYLLABLE HMAX" #xA099)
+    ("YI SYLLABLE HMA" #xA09A)
+    ("YI SYLLABLE HMAP" #xA09B)
+    ("YI SYLLABLE HMUOX" #xA09C)
+    ("YI SYLLABLE HMUO" #xA09D)
+    ("YI SYLLABLE HMUOP" #xA09E)
+    ("YI SYLLABLE HMOT" #xA09F)
+    ("YI SYLLABLE HMOX" #xA0A0)
+    ("YI SYLLABLE HMO" #xA0A1)
+    ("YI SYLLABLE HMOP" #xA0A2)
+    ("YI SYLLABLE HMUT" #xA0A3)
+    ("YI SYLLABLE HMUX" #xA0A4)
+    ("YI SYLLABLE HMU" #xA0A5)
+    ("YI SYLLABLE HMUP" #xA0A6)
+    ("YI SYLLABLE HMURX" #xA0A7)
+    ("YI SYLLABLE HMUR" #xA0A8)
+    ("YI SYLLABLE HMYX" #xA0A9)
+    ("YI SYLLABLE HMY" #xA0AA)
+    ("YI SYLLABLE HMYP" #xA0AB)
+    ("YI SYLLABLE HMYRX" #xA0AC)
+    ("YI SYLLABLE HMYR" #xA0AD)
+    ("YI SYLLABLE MIT" #xA0AE)
+    ("YI SYLLABLE MIX" #xA0AF)
+    ("YI SYLLABLE MI" #xA0B0)
+    ("YI SYLLABLE MIP" #xA0B1)
+    ("YI SYLLABLE MIEX" #xA0B2)
+    ("YI SYLLABLE MIE" #xA0B3)
+    ("YI SYLLABLE MIEP" #xA0B4)
+    ("YI SYLLABLE MAT" #xA0B5)
+    ("YI SYLLABLE MAX" #xA0B6)
+    ("YI SYLLABLE MA" #xA0B7)
+    ("YI SYLLABLE MAP" #xA0B8)
+    ("YI SYLLABLE MUOT" #xA0B9)
+    ("YI SYLLABLE MUOX" #xA0BA)
+    ("YI SYLLABLE MUO" #xA0BB)
+    ("YI SYLLABLE MUOP" #xA0BC)
+    ("YI SYLLABLE MOT" #xA0BD)
+    ("YI SYLLABLE MOX" #xA0BE)
+    ("YI SYLLABLE MO" #xA0BF)
+    ("YI SYLLABLE MOP" #xA0C0)
+    ("YI SYLLABLE MEX" #xA0C1)
+    ("YI SYLLABLE ME" #xA0C2)
+    ("YI SYLLABLE MUT" #xA0C3)
+    ("YI SYLLABLE MUX" #xA0C4)
+    ("YI SYLLABLE MU" #xA0C5)
+    ("YI SYLLABLE MUP" #xA0C6)
+    ("YI SYLLABLE MURX" #xA0C7)
+    ("YI SYLLABLE MUR" #xA0C8)
+    ("YI SYLLABLE MYT" #xA0C9)
+    ("YI SYLLABLE MYX" #xA0CA)
+    ("YI SYLLABLE MY" #xA0CB)
+    ("YI SYLLABLE MYP" #xA0CC)
+    ("YI SYLLABLE FIT" #xA0CD)
+    ("YI SYLLABLE FIX" #xA0CE)
+    ("YI SYLLABLE FI" #xA0CF)
+    ("YI SYLLABLE FIP" #xA0D0)
+    ("YI SYLLABLE FAT" #xA0D1)
+    ("YI SYLLABLE FAX" #xA0D2)
+    ("YI SYLLABLE FA" #xA0D3)
+    ("YI SYLLABLE FAP" #xA0D4)
+    ("YI SYLLABLE FOX" #xA0D5)
+    ("YI SYLLABLE FO" #xA0D6)
+    ("YI SYLLABLE FOP" #xA0D7)
+    ("YI SYLLABLE FUT" #xA0D8)
+    ("YI SYLLABLE FUX" #xA0D9)
+    ("YI SYLLABLE FU" #xA0DA)
+    ("YI SYLLABLE FUP" #xA0DB)
+    ("YI SYLLABLE FURX" #xA0DC)
+    ("YI SYLLABLE FUR" #xA0DD)
+    ("YI SYLLABLE FYT" #xA0DE)
+    ("YI SYLLABLE FYX" #xA0DF)
+    ("YI SYLLABLE FY" #xA0E0)
+    ("YI SYLLABLE FYP" #xA0E1)
+    ("YI SYLLABLE VIT" #xA0E2)
+    ("YI SYLLABLE VIX" #xA0E3)
+    ("YI SYLLABLE VI" #xA0E4)
+    ("YI SYLLABLE VIP" #xA0E5)
+    ("YI SYLLABLE VIET" #xA0E6)
+    ("YI SYLLABLE VIEX" #xA0E7)
+    ("YI SYLLABLE VIE" #xA0E8)
+    ("YI SYLLABLE VIEP" #xA0E9)
+    ("YI SYLLABLE VAT" #xA0EA)
+    ("YI SYLLABLE VAX" #xA0EB)
+    ("YI SYLLABLE VA" #xA0EC)
+    ("YI SYLLABLE VAP" #xA0ED)
+    ("YI SYLLABLE VOT" #xA0EE)
+    ("YI SYLLABLE VOX" #xA0EF)
+    ("YI SYLLABLE VO" #xA0F0)
+    ("YI SYLLABLE VOP" #xA0F1)
+    ("YI SYLLABLE VEX" #xA0F2)
+    ("YI SYLLABLE VEP" #xA0F3)
+    ("YI SYLLABLE VUT" #xA0F4)
+    ("YI SYLLABLE VUX" #xA0F5)
+    ("YI SYLLABLE VU" #xA0F6)
+    ("YI SYLLABLE VUP" #xA0F7)
+    ("YI SYLLABLE VURX" #xA0F8)
+    ("YI SYLLABLE VUR" #xA0F9)
+    ("YI SYLLABLE VYT" #xA0FA)
+    ("YI SYLLABLE VYX" #xA0FB)
+    ("YI SYLLABLE VY" #xA0FC)
+    ("YI SYLLABLE VYP" #xA0FD)
+    ("YI SYLLABLE VYRX" #xA0FE)
+    ("YI SYLLABLE VYR" #xA0FF)
+    ("YI SYLLABLE DIT" #xA100)
+    ("YI SYLLABLE DIX" #xA101)
+    ("YI SYLLABLE DI" #xA102)
+    ("YI SYLLABLE DIP" #xA103)
+    ("YI SYLLABLE DIEX" #xA104)
+    ("YI SYLLABLE DIE" #xA105)
+    ("YI SYLLABLE DIEP" #xA106)
+    ("YI SYLLABLE DAT" #xA107)
+    ("YI SYLLABLE DAX" #xA108)
+    ("YI SYLLABLE DA" #xA109)
+    ("YI SYLLABLE DAP" #xA10A)
+    ("YI SYLLABLE DUOX" #xA10B)
+    ("YI SYLLABLE DUO" #xA10C)
+    ("YI SYLLABLE DOT" #xA10D)
+    ("YI SYLLABLE DOX" #xA10E)
+    ("YI SYLLABLE DO" #xA10F)
+    ("YI SYLLABLE DOP" #xA110)
+    ("YI SYLLABLE DEX" #xA111)
+    ("YI SYLLABLE DE" #xA112)
+    ("YI SYLLABLE DEP" #xA113)
+    ("YI SYLLABLE DUT" #xA114)
+    ("YI SYLLABLE DUX" #xA115)
+    ("YI SYLLABLE DU" #xA116)
+    ("YI SYLLABLE DUP" #xA117)
+    ("YI SYLLABLE DURX" #xA118)
+    ("YI SYLLABLE DUR" #xA119)
+    ("YI SYLLABLE TIT" #xA11A)
+    ("YI SYLLABLE TIX" #xA11B)
+    ("YI SYLLABLE TI" #xA11C)
+    ("YI SYLLABLE TIP" #xA11D)
+    ("YI SYLLABLE TIEX" #xA11E)
+    ("YI SYLLABLE TIE" #xA11F)
+    ("YI SYLLABLE TIEP" #xA120)
+    ("YI SYLLABLE TAT" #xA121)
+    ("YI SYLLABLE TAX" #xA122)
+    ("YI SYLLABLE TA" #xA123)
+    ("YI SYLLABLE TAP" #xA124)
+    ("YI SYLLABLE TUOT" #xA125)
+    ("YI SYLLABLE TUOX" #xA126)
+    ("YI SYLLABLE TUO" #xA127)
+    ("YI SYLLABLE TUOP" #xA128)
+    ("YI SYLLABLE TOT" #xA129)
+    ("YI SYLLABLE TOX" #xA12A)
+    ("YI SYLLABLE TO" #xA12B)
+    ("YI SYLLABLE TOP" #xA12C)
+    ("YI SYLLABLE TEX" #xA12D)
+    ("YI SYLLABLE TE" #xA12E)
+    ("YI SYLLABLE TEP" #xA12F)
+    ("YI SYLLABLE TUT" #xA130)
+    ("YI SYLLABLE TUX" #xA131)
+    ("YI SYLLABLE TU" #xA132)
+    ("YI SYLLABLE TUP" #xA133)
+    ("YI SYLLABLE TURX" #xA134)
+    ("YI SYLLABLE TUR" #xA135)
+    ("YI SYLLABLE DDIT" #xA136)
+    ("YI SYLLABLE DDIX" #xA137)
+    ("YI SYLLABLE DDI" #xA138)
+    ("YI SYLLABLE DDIP" #xA139)
+    ("YI SYLLABLE DDIEX" #xA13A)
+    ("YI SYLLABLE DDIE" #xA13B)
+    ("YI SYLLABLE DDIEP" #xA13C)
+    ("YI SYLLABLE DDAT" #xA13D)
+    ("YI SYLLABLE DDAX" #xA13E)
+    ("YI SYLLABLE DDA" #xA13F)
+    ("YI SYLLABLE DDAP" #xA140)
+    ("YI SYLLABLE DDUOX" #xA141)
+    ("YI SYLLABLE DDUO" #xA142)
+    ("YI SYLLABLE DDUOP" #xA143)
+    ("YI SYLLABLE DDOT" #xA144)
+    ("YI SYLLABLE DDOX" #xA145)
+    ("YI SYLLABLE DDO" #xA146)
+    ("YI SYLLABLE DDOP" #xA147)
+    ("YI SYLLABLE DDEX" #xA148)
+    ("YI SYLLABLE DDE" #xA149)
+    ("YI SYLLABLE DDEP" #xA14A)
+    ("YI SYLLABLE DDUT" #xA14B)
+    ("YI SYLLABLE DDUX" #xA14C)
+    ("YI SYLLABLE DDU" #xA14D)
+    ("YI SYLLABLE DDUP" #xA14E)
+    ("YI SYLLABLE DDURX" #xA14F)
+    ("YI SYLLABLE DDUR" #xA150)
+    ("YI SYLLABLE NDIT" #xA151)
+    ("YI SYLLABLE NDIX" #xA152)
+    ("YI SYLLABLE NDI" #xA153)
+    ("YI SYLLABLE NDIP" #xA154)
+    ("YI SYLLABLE NDIEX" #xA155)
+    ("YI SYLLABLE NDIE" #xA156)
+    ("YI SYLLABLE NDAT" #xA157)
+    ("YI SYLLABLE NDAX" #xA158)
+    ("YI SYLLABLE NDA" #xA159)
+    ("YI SYLLABLE NDAP" #xA15A)
+    ("YI SYLLABLE NDOT" #xA15B)
+    ("YI SYLLABLE NDOX" #xA15C)
+    ("YI SYLLABLE NDO" #xA15D)
+    ("YI SYLLABLE NDOP" #xA15E)
+    ("YI SYLLABLE NDEX" #xA15F)
+    ("YI SYLLABLE NDE" #xA160)
+    ("YI SYLLABLE NDEP" #xA161)
+    ("YI SYLLABLE NDUT" #xA162)
+    ("YI SYLLABLE NDUX" #xA163)
+    ("YI SYLLABLE NDU" #xA164)
+    ("YI SYLLABLE NDUP" #xA165)
+    ("YI SYLLABLE NDURX" #xA166)
+    ("YI SYLLABLE NDUR" #xA167)
+    ("YI SYLLABLE HNIT" #xA168)
+    ("YI SYLLABLE HNIX" #xA169)
+    ("YI SYLLABLE HNI" #xA16A)
+    ("YI SYLLABLE HNIP" #xA16B)
+    ("YI SYLLABLE HNIET" #xA16C)
+    ("YI SYLLABLE HNIEX" #xA16D)
+    ("YI SYLLABLE HNIE" #xA16E)
+    ("YI SYLLABLE HNIEP" #xA16F)
+    ("YI SYLLABLE HNAT" #xA170)
+    ("YI SYLLABLE HNAX" #xA171)
+    ("YI SYLLABLE HNA" #xA172)
+    ("YI SYLLABLE HNAP" #xA173)
+    ("YI SYLLABLE HNUOX" #xA174)
+    ("YI SYLLABLE HNUO" #xA175)
+    ("YI SYLLABLE HNOT" #xA176)
+    ("YI SYLLABLE HNOX" #xA177)
+    ("YI SYLLABLE HNOP" #xA178)
+    ("YI SYLLABLE HNEX" #xA179)
+    ("YI SYLLABLE HNE" #xA17A)
+    ("YI SYLLABLE HNEP" #xA17B)
+    ("YI SYLLABLE HNUT" #xA17C)
+    ("YI SYLLABLE NIT" #xA17D)
+    ("YI SYLLABLE NIX" #xA17E)
+    ("YI SYLLABLE NI" #xA17F)
+    ("YI SYLLABLE NIP" #xA180)
+    ("YI SYLLABLE NIEX" #xA181)
+    ("YI SYLLABLE NIE" #xA182)
+    ("YI SYLLABLE NIEP" #xA183)
+    ("YI SYLLABLE NAX" #xA184)
+    ("YI SYLLABLE NA" #xA185)
+    ("YI SYLLABLE NAP" #xA186)
+    ("YI SYLLABLE NUOX" #xA187)
+    ("YI SYLLABLE NUO" #xA188)
+    ("YI SYLLABLE NUOP" #xA189)
+    ("YI SYLLABLE NOT" #xA18A)
+    ("YI SYLLABLE NOX" #xA18B)
+    ("YI SYLLABLE NO" #xA18C)
+    ("YI SYLLABLE NOP" #xA18D)
+    ("YI SYLLABLE NEX" #xA18E)
+    ("YI SYLLABLE NE" #xA18F)
+    ("YI SYLLABLE NEP" #xA190)
+    ("YI SYLLABLE NUT" #xA191)
+    ("YI SYLLABLE NUX" #xA192)
+    ("YI SYLLABLE NU" #xA193)
+    ("YI SYLLABLE NUP" #xA194)
+    ("YI SYLLABLE NURX" #xA195)
+    ("YI SYLLABLE NUR" #xA196)
+    ("YI SYLLABLE HLIT" #xA197)
+    ("YI SYLLABLE HLIX" #xA198)
+    ("YI SYLLABLE HLI" #xA199)
+    ("YI SYLLABLE HLIP" #xA19A)
+    ("YI SYLLABLE HLIEX" #xA19B)
+    ("YI SYLLABLE HLIE" #xA19C)
+    ("YI SYLLABLE HLIEP" #xA19D)
+    ("YI SYLLABLE HLAT" #xA19E)
+    ("YI SYLLABLE HLAX" #xA19F)
+    ("YI SYLLABLE HLA" #xA1A0)
+    ("YI SYLLABLE HLAP" #xA1A1)
+    ("YI SYLLABLE HLUOX" #xA1A2)
+    ("YI SYLLABLE HLUO" #xA1A3)
+    ("YI SYLLABLE HLUOP" #xA1A4)
+    ("YI SYLLABLE HLOX" #xA1A5)
+    ("YI SYLLABLE HLO" #xA1A6)
+    ("YI SYLLABLE HLOP" #xA1A7)
+    ("YI SYLLABLE HLEX" #xA1A8)
+    ("YI SYLLABLE HLE" #xA1A9)
+    ("YI SYLLABLE HLEP" #xA1AA)
+    ("YI SYLLABLE HLUT" #xA1AB)
+    ("YI SYLLABLE HLUX" #xA1AC)
+    ("YI SYLLABLE HLU" #xA1AD)
+    ("YI SYLLABLE HLUP" #xA1AE)
+    ("YI SYLLABLE HLURX" #xA1AF)
+    ("YI SYLLABLE HLUR" #xA1B0)
+    ("YI SYLLABLE HLYT" #xA1B1)
+    ("YI SYLLABLE HLYX" #xA1B2)
+    ("YI SYLLABLE HLY" #xA1B3)
+    ("YI SYLLABLE HLYP" #xA1B4)
+    ("YI SYLLABLE HLYRX" #xA1B5)
+    ("YI SYLLABLE HLYR" #xA1B6)
+    ("YI SYLLABLE LIT" #xA1B7)
+    ("YI SYLLABLE LIX" #xA1B8)
+    ("YI SYLLABLE LI" #xA1B9)
+    ("YI SYLLABLE LIP" #xA1BA)
+    ("YI SYLLABLE LIET" #xA1BB)
+    ("YI SYLLABLE LIEX" #xA1BC)
+    ("YI SYLLABLE LIE" #xA1BD)
+    ("YI SYLLABLE LIEP" #xA1BE)
+    ("YI SYLLABLE LAT" #xA1BF)
+    ("YI SYLLABLE LAX" #xA1C0)
+    ("YI SYLLABLE LA" #xA1C1)
+    ("YI SYLLABLE LAP" #xA1C2)
+    ("YI SYLLABLE LUOT" #xA1C3)
+    ("YI SYLLABLE LUOX" #xA1C4)
+    ("YI SYLLABLE LUO" #xA1C5)
+    ("YI SYLLABLE LUOP" #xA1C6)
+    ("YI SYLLABLE LOT" #xA1C7)
+    ("YI SYLLABLE LOX" #xA1C8)
+    ("YI SYLLABLE LO" #xA1C9)
+    ("YI SYLLABLE LOP" #xA1CA)
+    ("YI SYLLABLE LEX" #xA1CB)
+    ("YI SYLLABLE LE" #xA1CC)
+    ("YI SYLLABLE LEP" #xA1CD)
+    ("YI SYLLABLE LUT" #xA1CE)
+    ("YI SYLLABLE LUX" #xA1CF)
+    ("YI SYLLABLE LU" #xA1D0)
+    ("YI SYLLABLE LUP" #xA1D1)
+    ("YI SYLLABLE LURX" #xA1D2)
+    ("YI SYLLABLE LUR" #xA1D3)
+    ("YI SYLLABLE LYT" #xA1D4)
+    ("YI SYLLABLE LYX" #xA1D5)
+    ("YI SYLLABLE LY" #xA1D6)
+    ("YI SYLLABLE LYP" #xA1D7)
+    ("YI SYLLABLE LYRX" #xA1D8)
+    ("YI SYLLABLE LYR" #xA1D9)
+    ("YI SYLLABLE GIT" #xA1DA)
+    ("YI SYLLABLE GIX" #xA1DB)
+    ("YI SYLLABLE GI" #xA1DC)
+    ("YI SYLLABLE GIP" #xA1DD)
+    ("YI SYLLABLE GIET" #xA1DE)
+    ("YI SYLLABLE GIEX" #xA1DF)
+    ("YI SYLLABLE GIE" #xA1E0)
+    ("YI SYLLABLE GIEP" #xA1E1)
+    ("YI SYLLABLE GAT" #xA1E2)
+    ("YI SYLLABLE GAX" #xA1E3)
+    ("YI SYLLABLE GA" #xA1E4)
+    ("YI SYLLABLE GAP" #xA1E5)
+    ("YI SYLLABLE GUOT" #xA1E6)
+    ("YI SYLLABLE GUOX" #xA1E7)
+    ("YI SYLLABLE GUO" #xA1E8)
+    ("YI SYLLABLE GUOP" #xA1E9)
+    ("YI SYLLABLE GOT" #xA1EA)
+    ("YI SYLLABLE GOX" #xA1EB)
+    ("YI SYLLABLE GO" #xA1EC)
+    ("YI SYLLABLE GOP" #xA1ED)
+    ("YI SYLLABLE GET" #xA1EE)
+    ("YI SYLLABLE GEX" #xA1EF)
+    ("YI SYLLABLE GE" #xA1F0)
+    ("YI SYLLABLE GEP" #xA1F1)
+    ("YI SYLLABLE GUT" #xA1F2)
+    ("YI SYLLABLE GUX" #xA1F3)
+    ("YI SYLLABLE GU" #xA1F4)
+    ("YI SYLLABLE GUP" #xA1F5)
+    ("YI SYLLABLE GURX" #xA1F6)
+    ("YI SYLLABLE GUR" #xA1F7)
+    ("YI SYLLABLE KIT" #xA1F8)
+    ("YI SYLLABLE KIX" #xA1F9)
+    ("YI SYLLABLE KI" #xA1FA)
+    ("YI SYLLABLE KIP" #xA1FB)
+    ("YI SYLLABLE KIEX" #xA1FC)
+    ("YI SYLLABLE KIE" #xA1FD)
+    ("YI SYLLABLE KIEP" #xA1FE)
+    ("YI SYLLABLE KAT" #xA1FF)
+    ("YI SYLLABLE KAX" #xA200)
+    ("YI SYLLABLE KA" #xA201)
+    ("YI SYLLABLE KAP" #xA202)
+    ("YI SYLLABLE KUOX" #xA203)
+    ("YI SYLLABLE KUO" #xA204)
+    ("YI SYLLABLE KUOP" #xA205)
+    ("YI SYLLABLE KOT" #xA206)
+    ("YI SYLLABLE KOX" #xA207)
+    ("YI SYLLABLE KO" #xA208)
+    ("YI SYLLABLE KOP" #xA209)
+    ("YI SYLLABLE KET" #xA20A)
+    ("YI SYLLABLE KEX" #xA20B)
+    ("YI SYLLABLE KE" #xA20C)
+    ("YI SYLLABLE KEP" #xA20D)
+    ("YI SYLLABLE KUT" #xA20E)
+    ("YI SYLLABLE KUX" #xA20F)
+    ("YI SYLLABLE KU" #xA210)
+    ("YI SYLLABLE KUP" #xA211)
+    ("YI SYLLABLE KURX" #xA212)
+    ("YI SYLLABLE KUR" #xA213)
+    ("YI SYLLABLE GGIT" #xA214)
+    ("YI SYLLABLE GGIX" #xA215)
+    ("YI SYLLABLE GGI" #xA216)
+    ("YI SYLLABLE GGIEX" #xA217)
+    ("YI SYLLABLE GGIE" #xA218)
+    ("YI SYLLABLE GGIEP" #xA219)
+    ("YI SYLLABLE GGAT" #xA21A)
+    ("YI SYLLABLE GGAX" #xA21B)
+    ("YI SYLLABLE GGA" #xA21C)
+    ("YI SYLLABLE GGAP" #xA21D)
+    ("YI SYLLABLE GGUOT" #xA21E)
+    ("YI SYLLABLE GGUOX" #xA21F)
+    ("YI SYLLABLE GGUO" #xA220)
+    ("YI SYLLABLE GGUOP" #xA221)
+    ("YI SYLLABLE GGOT" #xA222)
+    ("YI SYLLABLE GGOX" #xA223)
+    ("YI SYLLABLE GGO" #xA224)
+    ("YI SYLLABLE GGOP" #xA225)
+    ("YI SYLLABLE GGET" #xA226)
+    ("YI SYLLABLE GGEX" #xA227)
+    ("YI SYLLABLE GGE" #xA228)
+    ("YI SYLLABLE GGEP" #xA229)
+    ("YI SYLLABLE GGUT" #xA22A)
+    ("YI SYLLABLE GGUX" #xA22B)
+    ("YI SYLLABLE GGU" #xA22C)
+    ("YI SYLLABLE GGUP" #xA22D)
+    ("YI SYLLABLE GGURX" #xA22E)
+    ("YI SYLLABLE GGUR" #xA22F)
+    ("YI SYLLABLE MGIEX" #xA230)
+    ("YI SYLLABLE MGIE" #xA231)
+    ("YI SYLLABLE MGAT" #xA232)
+    ("YI SYLLABLE MGAX" #xA233)
+    ("YI SYLLABLE MGA" #xA234)
+    ("YI SYLLABLE MGAP" #xA235)
+    ("YI SYLLABLE MGUOX" #xA236)
+    ("YI SYLLABLE MGUO" #xA237)
+    ("YI SYLLABLE MGUOP" #xA238)
+    ("YI SYLLABLE MGOT" #xA239)
+    ("YI SYLLABLE MGOX" #xA23A)
+    ("YI SYLLABLE MGO" #xA23B)
+    ("YI SYLLABLE MGOP" #xA23C)
+    ("YI SYLLABLE MGEX" #xA23D)
+    ("YI SYLLABLE MGE" #xA23E)
+    ("YI SYLLABLE MGEP" #xA23F)
+    ("YI SYLLABLE MGUT" #xA240)
+    ("YI SYLLABLE MGUX" #xA241)
+    ("YI SYLLABLE MGU" #xA242)
+    ("YI SYLLABLE MGUP" #xA243)
+    ("YI SYLLABLE MGURX" #xA244)
+    ("YI SYLLABLE MGUR" #xA245)
+    ("YI SYLLABLE HXIT" #xA246)
+    ("YI SYLLABLE HXIX" #xA247)
+    ("YI SYLLABLE HXI" #xA248)
+    ("YI SYLLABLE HXIP" #xA249)
+    ("YI SYLLABLE HXIET" #xA24A)
+    ("YI SYLLABLE HXIEX" #xA24B)
+    ("YI SYLLABLE HXIE" #xA24C)
+    ("YI SYLLABLE HXIEP" #xA24D)
+    ("YI SYLLABLE HXAT" #xA24E)
+    ("YI SYLLABLE HXAX" #xA24F)
+    ("YI SYLLABLE HXA" #xA250)
+    ("YI SYLLABLE HXAP" #xA251)
+    ("YI SYLLABLE HXUOT" #xA252)
+    ("YI SYLLABLE HXUOX" #xA253)
+    ("YI SYLLABLE HXUO" #xA254)
+    ("YI SYLLABLE HXUOP" #xA255)
+    ("YI SYLLABLE HXOT" #xA256)
+    ("YI SYLLABLE HXOX" #xA257)
+    ("YI SYLLABLE HXO" #xA258)
+    ("YI SYLLABLE HXOP" #xA259)
+    ("YI SYLLABLE HXEX" #xA25A)
+    ("YI SYLLABLE HXE" #xA25B)
+    ("YI SYLLABLE HXEP" #xA25C)
+    ("YI SYLLABLE NGIEX" #xA25D)
+    ("YI SYLLABLE NGIE" #xA25E)
+    ("YI SYLLABLE NGIEP" #xA25F)
+    ("YI SYLLABLE NGAT" #xA260)
+    ("YI SYLLABLE NGAX" #xA261)
+    ("YI SYLLABLE NGA" #xA262)
+    ("YI SYLLABLE NGAP" #xA263)
+    ("YI SYLLABLE NGUOT" #xA264)
+    ("YI SYLLABLE NGUOX" #xA265)
+    ("YI SYLLABLE NGUO" #xA266)
+    ("YI SYLLABLE NGOT" #xA267)
+    ("YI SYLLABLE NGOX" #xA268)
+    ("YI SYLLABLE NGO" #xA269)
+    ("YI SYLLABLE NGOP" #xA26A)
+    ("YI SYLLABLE NGEX" #xA26B)
+    ("YI SYLLABLE NGE" #xA26C)
+    ("YI SYLLABLE NGEP" #xA26D)
+    ("YI SYLLABLE HIT" #xA26E)
+    ("YI SYLLABLE HIEX" #xA26F)
+    ("YI SYLLABLE HIE" #xA270)
+    ("YI SYLLABLE HAT" #xA271)
+    ("YI SYLLABLE HAX" #xA272)
+    ("YI SYLLABLE HA" #xA273)
+    ("YI SYLLABLE HAP" #xA274)
+    ("YI SYLLABLE HUOT" #xA275)
+    ("YI SYLLABLE HUOX" #xA276)
+    ("YI SYLLABLE HUO" #xA277)
+    ("YI SYLLABLE HUOP" #xA278)
+    ("YI SYLLABLE HOT" #xA279)
+    ("YI SYLLABLE HOX" #xA27A)
+    ("YI SYLLABLE HO" #xA27B)
+    ("YI SYLLABLE HOP" #xA27C)
+    ("YI SYLLABLE HEX" #xA27D)
+    ("YI SYLLABLE HE" #xA27E)
+    ("YI SYLLABLE HEP" #xA27F)
+    ("YI SYLLABLE WAT" #xA280)
+    ("YI SYLLABLE WAX" #xA281)
+    ("YI SYLLABLE WA" #xA282)
+    ("YI SYLLABLE WAP" #xA283)
+    ("YI SYLLABLE WUOX" #xA284)
+    ("YI SYLLABLE WUO" #xA285)
+    ("YI SYLLABLE WUOP" #xA286)
+    ("YI SYLLABLE WOX" #xA287)
+    ("YI SYLLABLE WO" #xA288)
+    ("YI SYLLABLE WOP" #xA289)
+    ("YI SYLLABLE WEX" #xA28A)
+    ("YI SYLLABLE WE" #xA28B)
+    ("YI SYLLABLE WEP" #xA28C)
+    ("YI SYLLABLE ZIT" #xA28D)
+    ("YI SYLLABLE ZIX" #xA28E)
+    ("YI SYLLABLE ZI" #xA28F)
+    ("YI SYLLABLE ZIP" #xA290)
+    ("YI SYLLABLE ZIEX" #xA291)
+    ("YI SYLLABLE ZIE" #xA292)
+    ("YI SYLLABLE ZIEP" #xA293)
+    ("YI SYLLABLE ZAT" #xA294)
+    ("YI SYLLABLE ZAX" #xA295)
+    ("YI SYLLABLE ZA" #xA296)
+    ("YI SYLLABLE ZAP" #xA297)
+    ("YI SYLLABLE ZUOX" #xA298)
+    ("YI SYLLABLE ZUO" #xA299)
+    ("YI SYLLABLE ZUOP" #xA29A)
+    ("YI SYLLABLE ZOT" #xA29B)
+    ("YI SYLLABLE ZOX" #xA29C)
+    ("YI SYLLABLE ZO" #xA29D)
+    ("YI SYLLABLE ZOP" #xA29E)
+    ("YI SYLLABLE ZEX" #xA29F)
+    ("YI SYLLABLE ZE" #xA2A0)
+    ("YI SYLLABLE ZEP" #xA2A1)
+    ("YI SYLLABLE ZUT" #xA2A2)
+    ("YI SYLLABLE ZUX" #xA2A3)
+    ("YI SYLLABLE ZU" #xA2A4)
+    ("YI SYLLABLE ZUP" #xA2A5)
+    ("YI SYLLABLE ZURX" #xA2A6)
+    ("YI SYLLABLE ZUR" #xA2A7)
+    ("YI SYLLABLE ZYT" #xA2A8)
+    ("YI SYLLABLE ZYX" #xA2A9)
+    ("YI SYLLABLE ZY" #xA2AA)
+    ("YI SYLLABLE ZYP" #xA2AB)
+    ("YI SYLLABLE ZYRX" #xA2AC)
+    ("YI SYLLABLE ZYR" #xA2AD)
+    ("YI SYLLABLE CIT" #xA2AE)
+    ("YI SYLLABLE CIX" #xA2AF)
+    ("YI SYLLABLE CI" #xA2B0)
+    ("YI SYLLABLE CIP" #xA2B1)
+    ("YI SYLLABLE CIET" #xA2B2)
+    ("YI SYLLABLE CIEX" #xA2B3)
+    ("YI SYLLABLE CIE" #xA2B4)
+    ("YI SYLLABLE CIEP" #xA2B5)
+    ("YI SYLLABLE CAT" #xA2B6)
+    ("YI SYLLABLE CAX" #xA2B7)
+    ("YI SYLLABLE CA" #xA2B8)
+    ("YI SYLLABLE CAP" #xA2B9)
+    ("YI SYLLABLE CUOX" #xA2BA)
+    ("YI SYLLABLE CUO" #xA2BB)
+    ("YI SYLLABLE CUOP" #xA2BC)
+    ("YI SYLLABLE COT" #xA2BD)
+    ("YI SYLLABLE COX" #xA2BE)
+    ("YI SYLLABLE CO" #xA2BF)
+    ("YI SYLLABLE COP" #xA2C0)
+    ("YI SYLLABLE CEX" #xA2C1)
+    ("YI SYLLABLE CE" #xA2C2)
+    ("YI SYLLABLE CEP" #xA2C3)
+    ("YI SYLLABLE CUT" #xA2C4)
+    ("YI SYLLABLE CUX" #xA2C5)
+    ("YI SYLLABLE CU" #xA2C6)
+    ("YI SYLLABLE CUP" #xA2C7)
+    ("YI SYLLABLE CURX" #xA2C8)
+    ("YI SYLLABLE CUR" #xA2C9)
+    ("YI SYLLABLE CYT" #xA2CA)
+    ("YI SYLLABLE CYX" #xA2CB)
+    ("YI SYLLABLE CY" #xA2CC)
+    ("YI SYLLABLE CYP" #xA2CD)
+    ("YI SYLLABLE CYRX" #xA2CE)
+    ("YI SYLLABLE CYR" #xA2CF)
+    ("YI SYLLABLE ZZIT" #xA2D0)
+    ("YI SYLLABLE ZZIX" #xA2D1)
+    ("YI SYLLABLE ZZI" #xA2D2)
+    ("YI SYLLABLE ZZIP" #xA2D3)
+    ("YI SYLLABLE ZZIET" #xA2D4)
+    ("YI SYLLABLE ZZIEX" #xA2D5)
+    ("YI SYLLABLE ZZIE" #xA2D6)
+    ("YI SYLLABLE ZZIEP" #xA2D7)
+    ("YI SYLLABLE ZZAT" #xA2D8)
+    ("YI SYLLABLE ZZAX" #xA2D9)
+    ("YI SYLLABLE ZZA" #xA2DA)
+    ("YI SYLLABLE ZZAP" #xA2DB)
+    ("YI SYLLABLE ZZOX" #xA2DC)
+    ("YI SYLLABLE ZZO" #xA2DD)
+    ("YI SYLLABLE ZZOP" #xA2DE)
+    ("YI SYLLABLE ZZEX" #xA2DF)
+    ("YI SYLLABLE ZZE" #xA2E0)
+    ("YI SYLLABLE ZZEP" #xA2E1)
+    ("YI SYLLABLE ZZUX" #xA2E2)
+    ("YI SYLLABLE ZZU" #xA2E3)
+    ("YI SYLLABLE ZZUP" #xA2E4)
+    ("YI SYLLABLE ZZURX" #xA2E5)
+    ("YI SYLLABLE ZZUR" #xA2E6)
+    ("YI SYLLABLE ZZYT" #xA2E7)
+    ("YI SYLLABLE ZZYX" #xA2E8)
+    ("YI SYLLABLE ZZY" #xA2E9)
+    ("YI SYLLABLE ZZYP" #xA2EA)
+    ("YI SYLLABLE ZZYRX" #xA2EB)
+    ("YI SYLLABLE ZZYR" #xA2EC)
+    ("YI SYLLABLE NZIT" #xA2ED)
+    ("YI SYLLABLE NZIX" #xA2EE)
+    ("YI SYLLABLE NZI" #xA2EF)
+    ("YI SYLLABLE NZIP" #xA2F0)
+    ("YI SYLLABLE NZIEX" #xA2F1)
+    ("YI SYLLABLE NZIE" #xA2F2)
+    ("YI SYLLABLE NZIEP" #xA2F3)
+    ("YI SYLLABLE NZAT" #xA2F4)
+    ("YI SYLLABLE NZAX" #xA2F5)
+    ("YI SYLLABLE NZA" #xA2F6)
+    ("YI SYLLABLE NZAP" #xA2F7)
+    ("YI SYLLABLE NZUOX" #xA2F8)
+    ("YI SYLLABLE NZUO" #xA2F9)
+    ("YI SYLLABLE NZOX" #xA2FA)
+    ("YI SYLLABLE NZOP" #xA2FB)
+    ("YI SYLLABLE NZEX" #xA2FC)
+    ("YI SYLLABLE NZE" #xA2FD)
+    ("YI SYLLABLE NZUX" #xA2FE)
+    ("YI SYLLABLE NZU" #xA2FF)
+    ("YI SYLLABLE NZUP" #xA300)
+    ("YI SYLLABLE NZURX" #xA301)
+    ("YI SYLLABLE NZUR" #xA302)
+    ("YI SYLLABLE NZYT" #xA303)
+    ("YI SYLLABLE NZYX" #xA304)
+    ("YI SYLLABLE NZY" #xA305)
+    ("YI SYLLABLE NZYP" #xA306)
+    ("YI SYLLABLE NZYRX" #xA307)
+    ("YI SYLLABLE NZYR" #xA308)
+    ("YI SYLLABLE SIT" #xA309)
+    ("YI SYLLABLE SIX" #xA30A)
+    ("YI SYLLABLE SI" #xA30B)
+    ("YI SYLLABLE SIP" #xA30C)
+    ("YI SYLLABLE SIEX" #xA30D)
+    ("YI SYLLABLE SIE" #xA30E)
+    ("YI SYLLABLE SIEP" #xA30F)
+    ("YI SYLLABLE SAT" #xA310)
+    ("YI SYLLABLE SAX" #xA311)
+    ("YI SYLLABLE SA" #xA312)
+    ("YI SYLLABLE SAP" #xA313)
+    ("YI SYLLABLE SUOX" #xA314)
+    ("YI SYLLABLE SUO" #xA315)
+    ("YI SYLLABLE SUOP" #xA316)
+    ("YI SYLLABLE SOT" #xA317)
+    ("YI SYLLABLE SOX" #xA318)
+    ("YI SYLLABLE SO" #xA319)
+    ("YI SYLLABLE SOP" #xA31A)
+    ("YI SYLLABLE SEX" #xA31B)
+    ("YI SYLLABLE SE" #xA31C)
+    ("YI SYLLABLE SEP" #xA31D)
+    ("YI SYLLABLE SUT" #xA31E)
+    ("YI SYLLABLE SUX" #xA31F)
+    ("YI SYLLABLE SU" #xA320)
+    ("YI SYLLABLE SUP" #xA321)
+    ("YI SYLLABLE SURX" #xA322)
+    ("YI SYLLABLE SUR" #xA323)
+    ("YI SYLLABLE SYT" #xA324)
+    ("YI SYLLABLE SYX" #xA325)
+    ("YI SYLLABLE SY" #xA326)
+    ("YI SYLLABLE SYP" #xA327)
+    ("YI SYLLABLE SYRX" #xA328)
+    ("YI SYLLABLE SYR" #xA329)
+    ("YI SYLLABLE SSIT" #xA32A)
+    ("YI SYLLABLE SSIX" #xA32B)
+    ("YI SYLLABLE SSI" #xA32C)
+    ("YI SYLLABLE SSIP" #xA32D)
+    ("YI SYLLABLE SSIEX" #xA32E)
+    ("YI SYLLABLE SSIE" #xA32F)
+    ("YI SYLLABLE SSIEP" #xA330)
+    ("YI SYLLABLE SSAT" #xA331)
+    ("YI SYLLABLE SSAX" #xA332)
+    ("YI SYLLABLE SSA" #xA333)
+    ("YI SYLLABLE SSAP" #xA334)
+    ("YI SYLLABLE SSOT" #xA335)
+    ("YI SYLLABLE SSOX" #xA336)
+    ("YI SYLLABLE SSO" #xA337)
+    ("YI SYLLABLE SSOP" #xA338)
+    ("YI SYLLABLE SSEX" #xA339)
+    ("YI SYLLABLE SSE" #xA33A)
+    ("YI SYLLABLE SSEP" #xA33B)
+    ("YI SYLLABLE SSUT" #xA33C)
+    ("YI SYLLABLE SSUX" #xA33D)
+    ("YI SYLLABLE SSU" #xA33E)
+    ("YI SYLLABLE SSUP" #xA33F)
+    ("YI SYLLABLE SSYT" #xA340)
+    ("YI SYLLABLE SSYX" #xA341)
+    ("YI SYLLABLE SSY" #xA342)
+    ("YI SYLLABLE SSYP" #xA343)
+    ("YI SYLLABLE SSYRX" #xA344)
+    ("YI SYLLABLE SSYR" #xA345)
+    ("YI SYLLABLE ZHAT" #xA346)
+    ("YI SYLLABLE ZHAX" #xA347)
+    ("YI SYLLABLE ZHA" #xA348)
+    ("YI SYLLABLE ZHAP" #xA349)
+    ("YI SYLLABLE ZHUOX" #xA34A)
+    ("YI SYLLABLE ZHUO" #xA34B)
+    ("YI SYLLABLE ZHUOP" #xA34C)
+    ("YI SYLLABLE ZHOT" #xA34D)
+    ("YI SYLLABLE ZHOX" #xA34E)
+    ("YI SYLLABLE ZHO" #xA34F)
+    ("YI SYLLABLE ZHOP" #xA350)
+    ("YI SYLLABLE ZHET" #xA351)
+    ("YI SYLLABLE ZHEX" #xA352)
+    ("YI SYLLABLE ZHE" #xA353)
+    ("YI SYLLABLE ZHEP" #xA354)
+    ("YI SYLLABLE ZHUT" #xA355)
+    ("YI SYLLABLE ZHUX" #xA356)
+    ("YI SYLLABLE ZHU" #xA357)
+    ("YI SYLLABLE ZHUP" #xA358)
+    ("YI SYLLABLE ZHURX" #xA359)
+    ("YI SYLLABLE ZHUR" #xA35A)
+    ("YI SYLLABLE ZHYT" #xA35B)
+    ("YI SYLLABLE ZHYX" #xA35C)
+    ("YI SYLLABLE ZHY" #xA35D)
+    ("YI SYLLABLE ZHYP" #xA35E)
+    ("YI SYLLABLE ZHYRX" #xA35F)
+    ("YI SYLLABLE ZHYR" #xA360)
+    ("YI SYLLABLE CHAT" #xA361)
+    ("YI SYLLABLE CHAX" #xA362)
+    ("YI SYLLABLE CHA" #xA363)
+    ("YI SYLLABLE CHAP" #xA364)
+    ("YI SYLLABLE CHUOT" #xA365)
+    ("YI SYLLABLE CHUOX" #xA366)
+    ("YI SYLLABLE CHUO" #xA367)
+    ("YI SYLLABLE CHUOP" #xA368)
+    ("YI SYLLABLE CHOT" #xA369)
+    ("YI SYLLABLE CHOX" #xA36A)
+    ("YI SYLLABLE CHO" #xA36B)
+    ("YI SYLLABLE CHOP" #xA36C)
+    ("YI SYLLABLE CHET" #xA36D)
+    ("YI SYLLABLE CHEX" #xA36E)
+    ("YI SYLLABLE CHE" #xA36F)
+    ("YI SYLLABLE CHEP" #xA370)
+    ("YI SYLLABLE CHUX" #xA371)
+    ("YI SYLLABLE CHU" #xA372)
+    ("YI SYLLABLE CHUP" #xA373)
+    ("YI SYLLABLE CHURX" #xA374)
+    ("YI SYLLABLE CHUR" #xA375)
+    ("YI SYLLABLE CHYT" #xA376)
+    ("YI SYLLABLE CHYX" #xA377)
+    ("YI SYLLABLE CHY" #xA378)
+    ("YI SYLLABLE CHYP" #xA379)
+    ("YI SYLLABLE CHYRX" #xA37A)
+    ("YI SYLLABLE CHYR" #xA37B)
+    ("YI SYLLABLE RRAX" #xA37C)
+    ("YI SYLLABLE RRA" #xA37D)
+    ("YI SYLLABLE RRUOX" #xA37E)
+    ("YI SYLLABLE RRUO" #xA37F)
+    ("YI SYLLABLE RROT" #xA380)
+    ("YI SYLLABLE RROX" #xA381)
+    ("YI SYLLABLE RRO" #xA382)
+    ("YI SYLLABLE RROP" #xA383)
+    ("YI SYLLABLE RRET" #xA384)
+    ("YI SYLLABLE RREX" #xA385)
+    ("YI SYLLABLE RRE" #xA386)
+    ("YI SYLLABLE RREP" #xA387)
+    ("YI SYLLABLE RRUT" #xA388)
+    ("YI SYLLABLE RRUX" #xA389)
+    ("YI SYLLABLE RRU" #xA38A)
+    ("YI SYLLABLE RRUP" #xA38B)
+    ("YI SYLLABLE RRURX" #xA38C)
+    ("YI SYLLABLE RRUR" #xA38D)
+    ("YI SYLLABLE RRYT" #xA38E)
+    ("YI SYLLABLE RRYX" #xA38F)
+    ("YI SYLLABLE RRY" #xA390)
+    ("YI SYLLABLE RRYP" #xA391)
+    ("YI SYLLABLE RRYRX" #xA392)
+    ("YI SYLLABLE RRYR" #xA393)
+    ("YI SYLLABLE NRAT" #xA394)
+    ("YI SYLLABLE NRAX" #xA395)
+    ("YI SYLLABLE NRA" #xA396)
+    ("YI SYLLABLE NRAP" #xA397)
+    ("YI SYLLABLE NROX" #xA398)
+    ("YI SYLLABLE NRO" #xA399)
+    ("YI SYLLABLE NROP" #xA39A)
+    ("YI SYLLABLE NRET" #xA39B)
+    ("YI SYLLABLE NREX" #xA39C)
+    ("YI SYLLABLE NRE" #xA39D)
+    ("YI SYLLABLE NREP" #xA39E)
+    ("YI SYLLABLE NRUT" #xA39F)
+    ("YI SYLLABLE NRUX" #xA3A0)
+    ("YI SYLLABLE NRU" #xA3A1)
+    ("YI SYLLABLE NRUP" #xA3A2)
+    ("YI SYLLABLE NRURX" #xA3A3)
+    ("YI SYLLABLE NRUR" #xA3A4)
+    ("YI SYLLABLE NRYT" #xA3A5)
+    ("YI SYLLABLE NRYX" #xA3A6)
+    ("YI SYLLABLE NRY" #xA3A7)
+    ("YI SYLLABLE NRYP" #xA3A8)
+    ("YI SYLLABLE NRYRX" #xA3A9)
+    ("YI SYLLABLE NRYR" #xA3AA)
+    ("YI SYLLABLE SHAT" #xA3AB)
+    ("YI SYLLABLE SHAX" #xA3AC)
+    ("YI SYLLABLE SHA" #xA3AD)
+    ("YI SYLLABLE SHAP" #xA3AE)
+    ("YI SYLLABLE SHUOX" #xA3AF)
+    ("YI SYLLABLE SHUO" #xA3B0)
+    ("YI SYLLABLE SHUOP" #xA3B1)
+    ("YI SYLLABLE SHOT" #xA3B2)
+    ("YI SYLLABLE SHOX" #xA3B3)
+    ("YI SYLLABLE SHO" #xA3B4)
+    ("YI SYLLABLE SHOP" #xA3B5)
+    ("YI SYLLABLE SHET" #xA3B6)
+    ("YI SYLLABLE SHEX" #xA3B7)
+    ("YI SYLLABLE SHE" #xA3B8)
+    ("YI SYLLABLE SHEP" #xA3B9)
+    ("YI SYLLABLE SHUT" #xA3BA)
+    ("YI SYLLABLE SHUX" #xA3BB)
+    ("YI SYLLABLE SHU" #xA3BC)
+    ("YI SYLLABLE SHUP" #xA3BD)
+    ("YI SYLLABLE SHURX" #xA3BE)
+    ("YI SYLLABLE SHUR" #xA3BF)
+    ("YI SYLLABLE SHYT" #xA3C0)
+    ("YI SYLLABLE SHYX" #xA3C1)
+    ("YI SYLLABLE SHY" #xA3C2)
+    ("YI SYLLABLE SHYP" #xA3C3)
+    ("YI SYLLABLE SHYRX" #xA3C4)
+    ("YI SYLLABLE SHYR" #xA3C5)
+    ("YI SYLLABLE RAT" #xA3C6)
+    ("YI SYLLABLE RAX" #xA3C7)
+    ("YI SYLLABLE RA" #xA3C8)
+    ("YI SYLLABLE RAP" #xA3C9)
+    ("YI SYLLABLE RUOX" #xA3CA)
+    ("YI SYLLABLE RUO" #xA3CB)
+    ("YI SYLLABLE RUOP" #xA3CC)
+    ("YI SYLLABLE ROT" #xA3CD)
+    ("YI SYLLABLE ROX" #xA3CE)
+    ("YI SYLLABLE RO" #xA3CF)
+    ("YI SYLLABLE ROP" #xA3D0)
+    ("YI SYLLABLE REX" #xA3D1)
+    ("YI SYLLABLE RE" #xA3D2)
+    ("YI SYLLABLE REP" #xA3D3)
+    ("YI SYLLABLE RUT" #xA3D4)
+    ("YI SYLLABLE RUX" #xA3D5)
+    ("YI SYLLABLE RU" #xA3D6)
+    ("YI SYLLABLE RUP" #xA3D7)
+    ("YI SYLLABLE RURX" #xA3D8)
+    ("YI SYLLABLE RUR" #xA3D9)
+    ("YI SYLLABLE RYT" #xA3DA)
+    ("YI SYLLABLE RYX" #xA3DB)
+    ("YI SYLLABLE RY" #xA3DC)
+    ("YI SYLLABLE RYP" #xA3DD)
+    ("YI SYLLABLE RYRX" #xA3DE)
+    ("YI SYLLABLE RYR" #xA3DF)
+    ("YI SYLLABLE JIT" #xA3E0)
+    ("YI SYLLABLE JIX" #xA3E1)
+    ("YI SYLLABLE JI" #xA3E2)
+    ("YI SYLLABLE JIP" #xA3E3)
+    ("YI SYLLABLE JIET" #xA3E4)
+    ("YI SYLLABLE JIEX" #xA3E5)
+    ("YI SYLLABLE JIE" #xA3E6)
+    ("YI SYLLABLE JIEP" #xA3E7)
+    ("YI SYLLABLE JUOT" #xA3E8)
+    ("YI SYLLABLE JUOX" #xA3E9)
+    ("YI SYLLABLE JUO" #xA3EA)
+    ("YI SYLLABLE JUOP" #xA3EB)
+    ("YI SYLLABLE JOT" #xA3EC)
+    ("YI SYLLABLE JOX" #xA3ED)
+    ("YI SYLLABLE JO" #xA3EE)
+    ("YI SYLLABLE JOP" #xA3EF)
+    ("YI SYLLABLE JUT" #xA3F0)
+    ("YI SYLLABLE JUX" #xA3F1)
+    ("YI SYLLABLE JU" #xA3F2)
+    ("YI SYLLABLE JUP" #xA3F3)
+    ("YI SYLLABLE JURX" #xA3F4)
+    ("YI SYLLABLE JUR" #xA3F5)
+    ("YI SYLLABLE JYT" #xA3F6)
+    ("YI SYLLABLE JYX" #xA3F7)
+    ("YI SYLLABLE JY" #xA3F8)
+    ("YI SYLLABLE JYP" #xA3F9)
+    ("YI SYLLABLE JYRX" #xA3FA)
+    ("YI SYLLABLE JYR" #xA3FB)
+    ("YI SYLLABLE QIT" #xA3FC)
+    ("YI SYLLABLE QIX" #xA3FD)
+    ("YI SYLLABLE QI" #xA3FE)
+    ("YI SYLLABLE QIP" #xA3FF)
+    ("YI SYLLABLE QIET" #xA400)
+    ("YI SYLLABLE QIEX" #xA401)
+    ("YI SYLLABLE QIE" #xA402)
+    ("YI SYLLABLE QIEP" #xA403)
+    ("YI SYLLABLE QUOT" #xA404)
+    ("YI SYLLABLE QUOX" #xA405)
+    ("YI SYLLABLE QUO" #xA406)
+    ("YI SYLLABLE QUOP" #xA407)
+    ("YI SYLLABLE QOT" #xA408)
+    ("YI SYLLABLE QOX" #xA409)
+    ("YI SYLLABLE QO" #xA40A)
+    ("YI SYLLABLE QOP" #xA40B)
+    ("YI SYLLABLE QUT" #xA40C)
+    ("YI SYLLABLE QUX" #xA40D)
+    ("YI SYLLABLE QU" #xA40E)
+    ("YI SYLLABLE QUP" #xA40F)
+    ("YI SYLLABLE QURX" #xA410)
+    ("YI SYLLABLE QUR" #xA411)
+    ("YI SYLLABLE QYT" #xA412)
+    ("YI SYLLABLE QYX" #xA413)
+    ("YI SYLLABLE QY" #xA414)
+    ("YI SYLLABLE QYP" #xA415)
+    ("YI SYLLABLE QYRX" #xA416)
+    ("YI SYLLABLE QYR" #xA417)
+    ("YI SYLLABLE JJIT" #xA418)
+    ("YI SYLLABLE JJIX" #xA419)
+    ("YI SYLLABLE JJI" #xA41A)
+    ("YI SYLLABLE JJIP" #xA41B)
+    ("YI SYLLABLE JJIET" #xA41C)
+    ("YI SYLLABLE JJIEX" #xA41D)
+    ("YI SYLLABLE JJIE" #xA41E)
+    ("YI SYLLABLE JJIEP" #xA41F)
+    ("YI SYLLABLE JJUOX" #xA420)
+    ("YI SYLLABLE JJUO" #xA421)
+    ("YI SYLLABLE JJUOP" #xA422)
+    ("YI SYLLABLE JJOT" #xA423)
+    ("YI SYLLABLE JJOX" #xA424)
+    ("YI SYLLABLE JJO" #xA425)
+    ("YI SYLLABLE JJOP" #xA426)
+    ("YI SYLLABLE JJUT" #xA427)
+    ("YI SYLLABLE JJUX" #xA428)
+    ("YI SYLLABLE JJU" #xA429)
+    ("YI SYLLABLE JJUP" #xA42A)
+    ("YI SYLLABLE JJURX" #xA42B)
+    ("YI SYLLABLE JJUR" #xA42C)
+    ("YI SYLLABLE JJYT" #xA42D)
+    ("YI SYLLABLE JJYX" #xA42E)
+    ("YI SYLLABLE JJY" #xA42F)
+    ("YI SYLLABLE JJYP" #xA430)
+    ("YI SYLLABLE NJIT" #xA431)
+    ("YI SYLLABLE NJIX" #xA432)
+    ("YI SYLLABLE NJI" #xA433)
+    ("YI SYLLABLE NJIP" #xA434)
+    ("YI SYLLABLE NJIET" #xA435)
+    ("YI SYLLABLE NJIEX" #xA436)
+    ("YI SYLLABLE NJIE" #xA437)
+    ("YI SYLLABLE NJIEP" #xA438)
+    ("YI SYLLABLE NJUOX" #xA439)
+    ("YI SYLLABLE NJUO" #xA43A)
+    ("YI SYLLABLE NJOT" #xA43B)
+    ("YI SYLLABLE NJOX" #xA43C)
+    ("YI SYLLABLE NJO" #xA43D)
+    ("YI SYLLABLE NJOP" #xA43E)
+    ("YI SYLLABLE NJUX" #xA43F)
+    ("YI SYLLABLE NJU" #xA440)
+    ("YI SYLLABLE NJUP" #xA441)
+    ("YI SYLLABLE NJURX" #xA442)
+    ("YI SYLLABLE NJUR" #xA443)
+    ("YI SYLLABLE NJYT" #xA444)
+    ("YI SYLLABLE NJYX" #xA445)
+    ("YI SYLLABLE NJY" #xA446)
+    ("YI SYLLABLE NJYP" #xA447)
+    ("YI SYLLABLE NJYRX" #xA448)
+    ("YI SYLLABLE NJYR" #xA449)
+    ("YI SYLLABLE NYIT" #xA44A)
+    ("YI SYLLABLE NYIX" #xA44B)
+    ("YI SYLLABLE NYI" #xA44C)
+    ("YI SYLLABLE NYIP" #xA44D)
+    ("YI SYLLABLE NYIET" #xA44E)
+    ("YI SYLLABLE NYIEX" #xA44F)
+    ("YI SYLLABLE NYIE" #xA450)
+    ("YI SYLLABLE NYIEP" #xA451)
+    ("YI SYLLABLE NYUOX" #xA452)
+    ("YI SYLLABLE NYUO" #xA453)
+    ("YI SYLLABLE NYUOP" #xA454)
+    ("YI SYLLABLE NYOT" #xA455)
+    ("YI SYLLABLE NYOX" #xA456)
+    ("YI SYLLABLE NYO" #xA457)
+    ("YI SYLLABLE NYOP" #xA458)
+    ("YI SYLLABLE NYUT" #xA459)
+    ("YI SYLLABLE NYUX" #xA45A)
+    ("YI SYLLABLE NYU" #xA45B)
+    ("YI SYLLABLE NYUP" #xA45C)
+    ("YI SYLLABLE XIT" #xA45D)
+    ("YI SYLLABLE XIX" #xA45E)
+    ("YI SYLLABLE XI" #xA45F)
+    ("YI SYLLABLE XIP" #xA460)
+    ("YI SYLLABLE XIET" #xA461)
+    ("YI SYLLABLE XIEX" #xA462)
+    ("YI SYLLABLE XIE" #xA463)
+    ("YI SYLLABLE XIEP" #xA464)
+    ("YI SYLLABLE XUOX" #xA465)
+    ("YI SYLLABLE XUO" #xA466)
+    ("YI SYLLABLE XOT" #xA467)
+    ("YI SYLLABLE XOX" #xA468)
+    ("YI SYLLABLE XO" #xA469)
+    ("YI SYLLABLE XOP" #xA46A)
+    ("YI SYLLABLE XYT" #xA46B)
+    ("YI SYLLABLE XYX" #xA46C)
+    ("YI SYLLABLE XY" #xA46D)
+    ("YI SYLLABLE XYP" #xA46E)
+    ("YI SYLLABLE XYRX" #xA46F)
+    ("YI SYLLABLE XYR" #xA470)
+    ("YI SYLLABLE YIT" #xA471)
+    ("YI SYLLABLE YIX" #xA472)
+    ("YI SYLLABLE YI" #xA473)
+    ("YI SYLLABLE YIP" #xA474)
+    ("YI SYLLABLE YIET" #xA475)
+    ("YI SYLLABLE YIEX" #xA476)
+    ("YI SYLLABLE YIE" #xA477)
+    ("YI SYLLABLE YIEP" #xA478)
+    ("YI SYLLABLE YUOT" #xA479)
+    ("YI SYLLABLE YUOX" #xA47A)
+    ("YI SYLLABLE YUO" #xA47B)
+    ("YI SYLLABLE YUOP" #xA47C)
+    ("YI SYLLABLE YOT" #xA47D)
+    ("YI SYLLABLE YOX" #xA47E)
+    ("YI SYLLABLE YO" #xA47F)
+    ("YI SYLLABLE YOP" #xA480)
+    ("YI SYLLABLE YUT" #xA481)
+    ("YI SYLLABLE YUX" #xA482)
+    ("YI SYLLABLE YU" #xA483)
+    ("YI SYLLABLE YUP" #xA484)
+    ("YI SYLLABLE YURX" #xA485)
+    ("YI SYLLABLE YUR" #xA486)
+    ("YI SYLLABLE YYT" #xA487)
+    ("YI SYLLABLE YYX" #xA488)
+    ("YI SYLLABLE YY" #xA489)
+    ("YI SYLLABLE YYP" #xA48A)
+    ("YI SYLLABLE YYRX" #xA48B)
+    ("YI SYLLABLE YYR" #xA48C)
+    ))
diff --git a/lisp/nxml/char-name/unicode/0A490-0A4CF.el b/lisp/nxml/char-name/unicode/0A490-0A4CF.el
new file mode 100644
index 00000000000..16c8656b48d
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/0A490-0A4CF.el
@@ -0,0 +1,57 @@
+(nxml-define-char-name-set 'yi-radicals
+  '(("YI RADICAL QOT" #xA490)
+    ("YI RADICAL LI" #xA491)
+    ("YI RADICAL KIT" #xA492)
+    ("YI RADICAL NYIP" #xA493)
+    ("YI RADICAL CYP" #xA494)
+    ("YI RADICAL SSI" #xA495)
+    ("YI RADICAL GGOP" #xA496)
+    ("YI RADICAL GEP" #xA497)
+    ("YI RADICAL MI" #xA498)
+    ("YI RADICAL HXIT" #xA499)
+    ("YI RADICAL LYR" #xA49A)
+    ("YI RADICAL BBUT" #xA49B)
+    ("YI RADICAL MOP" #xA49C)
+    ("YI RADICAL YO" #xA49D)
+    ("YI RADICAL PUT" #xA49E)
+    ("YI RADICAL HXUO" #xA49F)
+    ("YI RADICAL TAT" #xA4A0)
+    ("YI RADICAL GA" #xA4A1)
+    ("YI RADICAL ZUP" #xA4A2)
+    ("YI RADICAL CYT" #xA4A3)
+    ("YI RADICAL DDUR" #xA4A4)
+    ("YI RADICAL BUR" #xA4A5)
+    ("YI RADICAL GGUO" #xA4A6)
+    ("YI RADICAL NYOP" #xA4A7)
+    ("YI RADICAL TU" #xA4A8)
+    ("YI RADICAL OP" #xA4A9)
+    ("YI RADICAL JJUT" #xA4AA)
+    ("YI RADICAL ZOT" #xA4AB)
+    ("YI RADICAL PYT" #xA4AC)
+    ("YI RADICAL HMO" #xA4AD)
+    ("YI RADICAL YIT" #xA4AE)
+    ("YI RADICAL VUR" #xA4AF)
+    ("YI RADICAL SHY" #xA4B0)
+    ("YI RADICAL VEP" #xA4B1)
+    ("YI RADICAL ZA" #xA4B2)
+    ("YI RADICAL JO" #xA4B3)
+    ("YI RADICAL NZUP" #xA4B4)
+    ("YI RADICAL JJY" #xA4B5)
+    ("YI RADICAL GOT" #xA4B6)
+    ("YI RADICAL JJIE" #xA4B7)
+    ("YI RADICAL WO" #xA4B8)
+    ("YI RADICAL DU" #xA4B9)
+    ("YI RADICAL SHUR" #xA4BA)
+    ("YI RADICAL LIE" #xA4BB)
+    ("YI RADICAL CY" #xA4BC)
+    ("YI RADICAL CUOP" #xA4BD)
+    ("YI RADICAL CIP" #xA4BE)
+    ("YI RADICAL HXOP" #xA4BF)
+    ("YI RADICAL SHAT" #xA4C0)
+    ("YI RADICAL ZUR" #xA4C1)
+    ("YI RADICAL SHOP" #xA4C2)
+    ("YI RADICAL CHE" #xA4C3)
+    ("YI RADICAL ZZIET" #xA4C4)
+    ("YI RADICAL NBIE" #xA4C5)
+    ("YI RADICAL KE" #xA4C6)
+    ))
diff --git a/lisp/nxml/char-name/unicode/0FB00-0FB4F.el b/lisp/nxml/char-name/unicode/0FB00-0FB4F.el
new file mode 100644
index 00000000000..36818c1e130
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/0FB00-0FB4F.el
@@ -0,0 +1,60 @@
+(nxml-define-char-name-set 'alphabetic-presentation-forms
+  '(("LATIN SMALL LIGATURE FF" #xFB00)
+    ("LATIN SMALL LIGATURE FI" #xFB01)
+    ("LATIN SMALL LIGATURE FL" #xFB02)
+    ("LATIN SMALL LIGATURE FFI" #xFB03)
+    ("LATIN SMALL LIGATURE FFL" #xFB04)
+    ("LATIN SMALL LIGATURE LONG S T" #xFB05)
+    ("LATIN SMALL LIGATURE ST" #xFB06)
+    ("ARMENIAN SMALL LIGATURE MEN NOW" #xFB13)
+    ("ARMENIAN SMALL LIGATURE MEN ECH" #xFB14)
+    ("ARMENIAN SMALL LIGATURE MEN INI" #xFB15)
+    ("ARMENIAN SMALL LIGATURE VEW NOW" #xFB16)
+    ("ARMENIAN SMALL LIGATURE MEN XEH" #xFB17)
+    ("HEBREW LETTER YOD WITH HIRIQ" #xFB1D)
+    ("HEBREW POINT JUDEO-SPANISH VARIKA" #xFB1E)
+    ("HEBREW LIGATURE YIDDISH YOD YOD PATAH" #xFB1F)
+    ("HEBREW LETTER ALTERNATIVE AYIN" #xFB20)
+    ("HEBREW LETTER WIDE ALEF" #xFB21)
+    ("HEBREW LETTER WIDE DALET" #xFB22)
+    ("HEBREW LETTER WIDE HE" #xFB23)
+    ("HEBREW LETTER WIDE KAF" #xFB24)
+    ("HEBREW LETTER WIDE LAMED" #xFB25)
+    ("HEBREW LETTER WIDE FINAL MEM" #xFB26)
+    ("HEBREW LETTER WIDE RESH" #xFB27)
+    ("HEBREW LETTER WIDE TAV" #xFB28)
+    ("HEBREW LETTER ALTERNATIVE PLUS SIGN" #xFB29)
+    ("HEBREW LETTER SHIN WITH SHIN DOT" #xFB2A)
+    ("HEBREW LETTER SHIN WITH SIN DOT" #xFB2B)
+    ("HEBREW LETTER SHIN WITH DAGESH AND SHIN DOT" #xFB2C)
+    ("HEBREW LETTER SHIN WITH DAGESH AND SIN DOT" #xFB2D)
+    ("HEBREW LETTER ALEF WITH PATAH" #xFB2E)
+    ("HEBREW LETTER ALEF WITH QAMATS" #xFB2F)
+    ("HEBREW LETTER ALEF WITH MAPIQ" #xFB30)
+    ("HEBREW LETTER BET WITH DAGESH" #xFB31)
+    ("HEBREW LETTER GIMEL WITH DAGESH" #xFB32)
+    ("HEBREW LETTER DALET WITH DAGESH" #xFB33)
+    ("HEBREW LETTER HE WITH MAPIQ" #xFB34)
+    ("HEBREW LETTER VAV WITH DAGESH" #xFB35)
+    ("HEBREW LETTER ZAYIN WITH DAGESH" #xFB36)
+    ("HEBREW LETTER TET WITH DAGESH" #xFB38)
+    ("HEBREW LETTER YOD WITH DAGESH" #xFB39)
+    ("HEBREW LETTER FINAL KAF WITH DAGESH" #xFB3A)
+    ("HEBREW LETTER KAF WITH DAGESH" #xFB3B)
+    ("HEBREW LETTER LAMED WITH DAGESH" #xFB3C)
+    ("HEBREW LETTER MEM WITH DAGESH" #xFB3E)
+    ("HEBREW LETTER NUN WITH DAGESH" #xFB40)
+    ("HEBREW LETTER SAMEKH WITH DAGESH" #xFB41)
+    ("HEBREW LETTER FINAL PE WITH DAGESH" #xFB43)
+    ("HEBREW LETTER PE WITH DAGESH" #xFB44)
+    ("HEBREW LETTER TSADI WITH DAGESH" #xFB46)
+    ("HEBREW LETTER QOF WITH DAGESH" #xFB47)
+    ("HEBREW LETTER RESH WITH DAGESH" #xFB48)
+    ("HEBREW LETTER SHIN WITH DAGESH" #xFB49)
+    ("HEBREW LETTER TAV WITH DAGESH" #xFB4A)
+    ("HEBREW LETTER VAV WITH HOLAM" #xFB4B)
+    ("HEBREW LETTER BET WITH RAFE" #xFB4C)
+    ("HEBREW LETTER KAF WITH RAFE" #xFB4D)
+    ("HEBREW LETTER PE WITH RAFE" #xFB4E)
+    ("HEBREW LIGATURE ALEF LAMED" #xFB4F)
+    ))
diff --git a/lisp/nxml/char-name/unicode/0FB50-0FDFF.el b/lisp/nxml/char-name/unicode/0FB50-0FDFF.el
new file mode 100644
index 00000000000..a39ae4700be
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/0FB50-0FDFF.el
@@ -0,0 +1,596 @@
+(nxml-define-char-name-set 'arabic-presentation-forms-a
+  '(("ARABIC LETTER ALEF WASLA ISOLATED FORM" #xFB50)
+    ("ARABIC LETTER ALEF WASLA FINAL FORM" #xFB51)
+    ("ARABIC LETTER BEEH ISOLATED FORM" #xFB52)
+    ("ARABIC LETTER BEEH FINAL FORM" #xFB53)
+    ("ARABIC LETTER BEEH INITIAL FORM" #xFB54)
+    ("ARABIC LETTER BEEH MEDIAL FORM" #xFB55)
+    ("ARABIC LETTER PEH ISOLATED FORM" #xFB56)
+    ("ARABIC LETTER PEH FINAL FORM" #xFB57)
+    ("ARABIC LETTER PEH INITIAL FORM" #xFB58)
+    ("ARABIC LETTER PEH MEDIAL FORM" #xFB59)
+    ("ARABIC LETTER BEHEH ISOLATED FORM" #xFB5A)
+    ("ARABIC LETTER BEHEH FINAL FORM" #xFB5B)
+    ("ARABIC LETTER BEHEH INITIAL FORM" #xFB5C)
+    ("ARABIC LETTER BEHEH MEDIAL FORM" #xFB5D)
+    ("ARABIC LETTER TTEHEH ISOLATED FORM" #xFB5E)
+    ("ARABIC LETTER TTEHEH FINAL FORM" #xFB5F)
+    ("ARABIC LETTER TTEHEH INITIAL FORM" #xFB60)
+    ("ARABIC LETTER TTEHEH MEDIAL FORM" #xFB61)
+    ("ARABIC LETTER TEHEH ISOLATED FORM" #xFB62)
+    ("ARABIC LETTER TEHEH FINAL FORM" #xFB63)
+    ("ARABIC LETTER TEHEH INITIAL FORM" #xFB64)
+    ("ARABIC LETTER TEHEH MEDIAL FORM" #xFB65)
+    ("ARABIC LETTER TTEH ISOLATED FORM" #xFB66)
+    ("ARABIC LETTER TTEH FINAL FORM" #xFB67)
+    ("ARABIC LETTER TTEH INITIAL FORM" #xFB68)
+    ("ARABIC LETTER TTEH MEDIAL FORM" #xFB69)
+    ("ARABIC LETTER VEH ISOLATED FORM" #xFB6A)
+    ("ARABIC LETTER VEH FINAL FORM" #xFB6B)
+    ("ARABIC LETTER VEH INITIAL FORM" #xFB6C)
+    ("ARABIC LETTER VEH MEDIAL FORM" #xFB6D)
+    ("ARABIC LETTER PEHEH ISOLATED FORM" #xFB6E)
+    ("ARABIC LETTER PEHEH FINAL FORM" #xFB6F)
+    ("ARABIC LETTER PEHEH INITIAL FORM" #xFB70)
+    ("ARABIC LETTER PEHEH MEDIAL FORM" #xFB71)
+    ("ARABIC LETTER DYEH ISOLATED FORM" #xFB72)
+    ("ARABIC LETTER DYEH FINAL FORM" #xFB73)
+    ("ARABIC LETTER DYEH INITIAL FORM" #xFB74)
+    ("ARABIC LETTER DYEH MEDIAL FORM" #xFB75)
+    ("ARABIC LETTER NYEH ISOLATED FORM" #xFB76)
+    ("ARABIC LETTER NYEH FINAL FORM" #xFB77)
+    ("ARABIC LETTER NYEH INITIAL FORM" #xFB78)
+    ("ARABIC LETTER NYEH MEDIAL FORM" #xFB79)
+    ("ARABIC LETTER TCHEH ISOLATED FORM" #xFB7A)
+    ("ARABIC LETTER TCHEH FINAL FORM" #xFB7B)
+    ("ARABIC LETTER TCHEH INITIAL FORM" #xFB7C)
+    ("ARABIC LETTER TCHEH MEDIAL FORM" #xFB7D)
+    ("ARABIC LETTER TCHEHEH ISOLATED FORM" #xFB7E)
+    ("ARABIC LETTER TCHEHEH FINAL FORM" #xFB7F)
+    ("ARABIC LETTER TCHEHEH INITIAL FORM" #xFB80)
+    ("ARABIC LETTER TCHEHEH MEDIAL FORM" #xFB81)
+    ("ARABIC LETTER DDAHAL ISOLATED FORM" #xFB82)
+    ("ARABIC LETTER DDAHAL FINAL FORM" #xFB83)
+    ("ARABIC LETTER DAHAL ISOLATED FORM" #xFB84)
+    ("ARABIC LETTER DAHAL FINAL FORM" #xFB85)
+    ("ARABIC LETTER DUL ISOLATED FORM" #xFB86)
+    ("ARABIC LETTER DUL FINAL FORM" #xFB87)
+    ("ARABIC LETTER DDAL ISOLATED FORM" #xFB88)
+    ("ARABIC LETTER DDAL FINAL FORM" #xFB89)
+    ("ARABIC LETTER JEH ISOLATED FORM" #xFB8A)
+    ("ARABIC LETTER JEH FINAL FORM" #xFB8B)
+    ("ARABIC LETTER RREH ISOLATED FORM" #xFB8C)
+    ("ARABIC LETTER RREH FINAL FORM" #xFB8D)
+    ("ARABIC LETTER KEHEH ISOLATED FORM" #xFB8E)
+    ("ARABIC LETTER KEHEH FINAL FORM" #xFB8F)
+    ("ARABIC LETTER KEHEH INITIAL FORM" #xFB90)
+    ("ARABIC LETTER KEHEH MEDIAL FORM" #xFB91)
+    ("ARABIC LETTER GAF ISOLATED FORM" #xFB92)
+    ("ARABIC LETTER GAF FINAL FORM" #xFB93)
+    ("ARABIC LETTER GAF INITIAL FORM" #xFB94)
+    ("ARABIC LETTER GAF MEDIAL FORM" #xFB95)
+    ("ARABIC LETTER GUEH ISOLATED FORM" #xFB96)
+    ("ARABIC LETTER GUEH FINAL FORM" #xFB97)
+    ("ARABIC LETTER GUEH INITIAL FORM" #xFB98)
+    ("ARABIC LETTER GUEH MEDIAL FORM" #xFB99)
+    ("ARABIC LETTER NGOEH ISOLATED FORM" #xFB9A)
+    ("ARABIC LETTER NGOEH FINAL FORM" #xFB9B)
+    ("ARABIC LETTER NGOEH INITIAL FORM" #xFB9C)
+    ("ARABIC LETTER NGOEH MEDIAL FORM" #xFB9D)
+    ("ARABIC LETTER NOON GHUNNA ISOLATED FORM" #xFB9E)
+    ("ARABIC LETTER NOON GHUNNA FINAL FORM" #xFB9F)
+    ("ARABIC LETTER RNOON ISOLATED FORM" #xFBA0)
+    ("ARABIC LETTER RNOON FINAL FORM" #xFBA1)
+    ("ARABIC LETTER RNOON INITIAL FORM" #xFBA2)
+    ("ARABIC LETTER RNOON MEDIAL FORM" #xFBA3)
+    ("ARABIC LETTER HEH WITH YEH ABOVE ISOLATED FORM" #xFBA4)
+    ("ARABIC LETTER HEH WITH YEH ABOVE FINAL FORM" #xFBA5)
+    ("ARABIC LETTER HEH GOAL ISOLATED FORM" #xFBA6)
+    ("ARABIC LETTER HEH GOAL FINAL FORM" #xFBA7)
+    ("ARABIC LETTER HEH GOAL INITIAL FORM" #xFBA8)
+    ("ARABIC LETTER HEH GOAL MEDIAL FORM" #xFBA9)
+    ("ARABIC LETTER HEH DOACHASHMEE ISOLATED FORM" #xFBAA)
+    ("ARABIC LETTER HEH DOACHASHMEE FINAL FORM" #xFBAB)
+    ("ARABIC LETTER HEH DOACHASHMEE INITIAL FORM" #xFBAC)
+    ("ARABIC LETTER HEH DOACHASHMEE MEDIAL FORM" #xFBAD)
+    ("ARABIC LETTER YEH BARREE ISOLATED FORM" #xFBAE)
+    ("ARABIC LETTER YEH BARREE FINAL FORM" #xFBAF)
+    ("ARABIC LETTER YEH BARREE WITH HAMZA ABOVE ISOLATED FORM" #xFBB0)
+    ("ARABIC LETTER YEH BARREE WITH HAMZA ABOVE FINAL FORM" #xFBB1)
+    ("ARABIC LETTER NG ISOLATED FORM" #xFBD3)
+    ("ARABIC LETTER NG FINAL FORM" #xFBD4)
+    ("ARABIC LETTER NG INITIAL FORM" #xFBD5)
+    ("ARABIC LETTER NG MEDIAL FORM" #xFBD6)
+    ("ARABIC LETTER U ISOLATED FORM" #xFBD7)
+    ("ARABIC LETTER U FINAL FORM" #xFBD8)
+    ("ARABIC LETTER OE ISOLATED FORM" #xFBD9)
+    ("ARABIC LETTER OE FINAL FORM" #xFBDA)
+    ("ARABIC LETTER YU ISOLATED FORM" #xFBDB)
+    ("ARABIC LETTER YU FINAL FORM" #xFBDC)
+    ("ARABIC LETTER U WITH HAMZA ABOVE ISOLATED FORM" #xFBDD)
+    ("ARABIC LETTER VE ISOLATED FORM" #xFBDE)
+    ("ARABIC LETTER VE FINAL FORM" #xFBDF)
+    ("ARABIC LETTER KIRGHIZ OE ISOLATED FORM" #xFBE0)
+    ("ARABIC LETTER KIRGHIZ OE FINAL FORM" #xFBE1)
+    ("ARABIC LETTER KIRGHIZ YU ISOLATED FORM" #xFBE2)
+    ("ARABIC LETTER KIRGHIZ YU FINAL FORM" #xFBE3)
+    ("ARABIC LETTER E ISOLATED FORM" #xFBE4)
+    ("ARABIC LETTER E FINAL FORM" #xFBE5)
+    ("ARABIC LETTER E INITIAL FORM" #xFBE6)
+    ("ARABIC LETTER E MEDIAL FORM" #xFBE7)
+    ("ARABIC LETTER UIGHUR KAZAKH KIRGHIZ ALEF MAKSURA INITIAL FORM" #xFBE8)
+    ("ARABIC LETTER UIGHUR KAZAKH KIRGHIZ ALEF MAKSURA MEDIAL FORM" #xFBE9)
+    ("ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH ALEF ISOLATED FORM" #xFBEA)
+    ("ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH ALEF FINAL FORM" #xFBEB)
+    ("ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH AE ISOLATED FORM" #xFBEC)
+    ("ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH AE FINAL FORM" #xFBED)
+    ("ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH WAW ISOLATED FORM" #xFBEE)
+    ("ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH WAW FINAL FORM" #xFBEF)
+    ("ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH U ISOLATED FORM" #xFBF0)
+    ("ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH U FINAL FORM" #xFBF1)
+    ("ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH OE ISOLATED FORM" #xFBF2)
+    ("ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH OE FINAL FORM" #xFBF3)
+    ("ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH YU ISOLATED FORM" #xFBF4)
+    ("ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH YU FINAL FORM" #xFBF5)
+    ("ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH E ISOLATED FORM" #xFBF6)
+    ("ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH E FINAL FORM" #xFBF7)
+    ("ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH E INITIAL FORM" #xFBF8)
+    ("ARABIC LIGATURE UIGHUR KIRGHIZ YEH WITH HAMZA ABOVE WITH ALEF MAKSURA ISOLATED FORM" #xFBF9)
+    ("ARABIC LIGATURE UIGHUR KIRGHIZ YEH WITH HAMZA ABOVE WITH ALEF MAKSURA FINAL FORM" #xFBFA)
+    ("ARABIC LIGATURE UIGHUR KIRGHIZ YEH WITH HAMZA ABOVE WITH ALEF MAKSURA INITIAL FORM" #xFBFB)
+    ("ARABIC LETTER FARSI YEH ISOLATED FORM" #xFBFC)
+    ("ARABIC LETTER FARSI YEH FINAL FORM" #xFBFD)
+    ("ARABIC LETTER FARSI YEH INITIAL FORM" #xFBFE)
+    ("ARABIC LETTER FARSI YEH MEDIAL FORM" #xFBFF)
+    ("ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH JEEM ISOLATED FORM" #xFC00)
+    ("ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH HAH ISOLATED FORM" #xFC01)
+    ("ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH MEEM ISOLATED FORM" #xFC02)
+    ("ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH ALEF MAKSURA ISOLATED FORM" #xFC03)
+    ("ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH YEH ISOLATED FORM" #xFC04)
+    ("ARABIC LIGATURE BEH WITH JEEM ISOLATED FORM" #xFC05)
+    ("ARABIC LIGATURE BEH WITH HAH ISOLATED FORM" #xFC06)
+    ("ARABIC LIGATURE BEH WITH KHAH ISOLATED FORM" #xFC07)
+    ("ARABIC LIGATURE BEH WITH MEEM ISOLATED FORM" #xFC08)
+    ("ARABIC LIGATURE BEH WITH ALEF MAKSURA ISOLATED FORM" #xFC09)
+    ("ARABIC LIGATURE BEH WITH YEH ISOLATED FORM" #xFC0A)
+    ("ARABIC LIGATURE TEH WITH JEEM ISOLATED FORM" #xFC0B)
+    ("ARABIC LIGATURE TEH WITH HAH ISOLATED FORM" #xFC0C)
+    ("ARABIC LIGATURE TEH WITH KHAH ISOLATED FORM" #xFC0D)
+    ("ARABIC LIGATURE TEH WITH MEEM ISOLATED FORM" #xFC0E)
+    ("ARABIC LIGATURE TEH WITH ALEF MAKSURA ISOLATED FORM" #xFC0F)
+    ("ARABIC LIGATURE TEH WITH YEH ISOLATED FORM" #xFC10)
+    ("ARABIC LIGATURE THEH WITH JEEM ISOLATED FORM" #xFC11)
+    ("ARABIC LIGATURE THEH WITH MEEM ISOLATED FORM" #xFC12)
+    ("ARABIC LIGATURE THEH WITH ALEF MAKSURA ISOLATED FORM" #xFC13)
+    ("ARABIC LIGATURE THEH WITH YEH ISOLATED FORM" #xFC14)
+    ("ARABIC LIGATURE JEEM WITH HAH ISOLATED FORM" #xFC15)
+    ("ARABIC LIGATURE JEEM WITH MEEM ISOLATED FORM" #xFC16)
+    ("ARABIC LIGATURE HAH WITH JEEM ISOLATED FORM" #xFC17)
+    ("ARABIC LIGATURE HAH WITH MEEM ISOLATED FORM" #xFC18)
+    ("ARABIC LIGATURE KHAH WITH JEEM ISOLATED FORM" #xFC19)
+    ("ARABIC LIGATURE KHAH WITH HAH ISOLATED FORM" #xFC1A)
+    ("ARABIC LIGATURE KHAH WITH MEEM ISOLATED FORM" #xFC1B)
+    ("ARABIC LIGATURE SEEN WITH JEEM ISOLATED FORM" #xFC1C)
+    ("ARABIC LIGATURE SEEN WITH HAH ISOLATED FORM" #xFC1D)
+    ("ARABIC LIGATURE SEEN WITH KHAH ISOLATED FORM" #xFC1E)
+    ("ARABIC LIGATURE SEEN WITH MEEM ISOLATED FORM" #xFC1F)
+    ("ARABIC LIGATURE SAD WITH HAH ISOLATED FORM" #xFC20)
+    ("ARABIC LIGATURE SAD WITH MEEM ISOLATED FORM" #xFC21)
+    ("ARABIC LIGATURE DAD WITH JEEM ISOLATED FORM" #xFC22)
+    ("ARABIC LIGATURE DAD WITH HAH ISOLATED FORM" #xFC23)
+    ("ARABIC LIGATURE DAD WITH KHAH ISOLATED FORM" #xFC24)
+    ("ARABIC LIGATURE DAD WITH MEEM ISOLATED FORM" #xFC25)
+    ("ARABIC LIGATURE TAH WITH HAH ISOLATED FORM" #xFC26)
+    ("ARABIC LIGATURE TAH WITH MEEM ISOLATED FORM" #xFC27)
+    ("ARABIC LIGATURE ZAH WITH MEEM ISOLATED FORM" #xFC28)
+    ("ARABIC LIGATURE AIN WITH JEEM ISOLATED FORM" #xFC29)
+    ("ARABIC LIGATURE AIN WITH MEEM ISOLATED FORM" #xFC2A)
+    ("ARABIC LIGATURE GHAIN WITH JEEM ISOLATED FORM" #xFC2B)
+    ("ARABIC LIGATURE GHAIN WITH MEEM ISOLATED FORM" #xFC2C)
+    ("ARABIC LIGATURE FEH WITH JEEM ISOLATED FORM" #xFC2D)
+    ("ARABIC LIGATURE FEH WITH HAH ISOLATED FORM" #xFC2E)
+    ("ARABIC LIGATURE FEH WITH KHAH ISOLATED FORM" #xFC2F)
+    ("ARABIC LIGATURE FEH WITH MEEM ISOLATED FORM" #xFC30)
+    ("ARABIC LIGATURE FEH WITH ALEF MAKSURA ISOLATED FORM" #xFC31)
+    ("ARABIC LIGATURE FEH WITH YEH ISOLATED FORM" #xFC32)
+    ("ARABIC LIGATURE QAF WITH HAH ISOLATED FORM" #xFC33)
+    ("ARABIC LIGATURE QAF WITH MEEM ISOLATED FORM" #xFC34)
+    ("ARABIC LIGATURE QAF WITH ALEF MAKSURA ISOLATED FORM" #xFC35)
+    ("ARABIC LIGATURE QAF WITH YEH ISOLATED FORM" #xFC36)
+    ("ARABIC LIGATURE KAF WITH ALEF ISOLATED FORM" #xFC37)
+    ("ARABIC LIGATURE KAF WITH JEEM ISOLATED FORM" #xFC38)
+    ("ARABIC LIGATURE KAF WITH HAH ISOLATED FORM" #xFC39)
+    ("ARABIC LIGATURE KAF WITH KHAH ISOLATED FORM" #xFC3A)
+    ("ARABIC LIGATURE KAF WITH LAM ISOLATED FORM" #xFC3B)
+    ("ARABIC LIGATURE KAF WITH MEEM ISOLATED FORM" #xFC3C)
+    ("ARABIC LIGATURE KAF WITH ALEF MAKSURA ISOLATED FORM" #xFC3D)
+    ("ARABIC LIGATURE KAF WITH YEH ISOLATED FORM" #xFC3E)
+    ("ARABIC LIGATURE LAM WITH JEEM ISOLATED FORM" #xFC3F)
+    ("ARABIC LIGATURE LAM WITH HAH ISOLATED FORM" #xFC40)
+    ("ARABIC LIGATURE LAM WITH KHAH ISOLATED FORM" #xFC41)
+    ("ARABIC LIGATURE LAM WITH MEEM ISOLATED FORM" #xFC42)
+    ("ARABIC LIGATURE LAM WITH ALEF MAKSURA ISOLATED FORM" #xFC43)
+    ("ARABIC LIGATURE LAM WITH YEH ISOLATED FORM" #xFC44)
+    ("ARABIC LIGATURE MEEM WITH JEEM ISOLATED FORM" #xFC45)
+    ("ARABIC LIGATURE MEEM WITH HAH ISOLATED FORM" #xFC46)
+    ("ARABIC LIGATURE MEEM WITH KHAH ISOLATED FORM" #xFC47)
+    ("ARABIC LIGATURE MEEM WITH MEEM ISOLATED FORM" #xFC48)
+    ("ARABIC LIGATURE MEEM WITH ALEF MAKSURA ISOLATED FORM" #xFC49)
+    ("ARABIC LIGATURE MEEM WITH YEH ISOLATED FORM" #xFC4A)
+    ("ARABIC LIGATURE NOON WITH JEEM ISOLATED FORM" #xFC4B)
+    ("ARABIC LIGATURE NOON WITH HAH ISOLATED FORM" #xFC4C)
+    ("ARABIC LIGATURE NOON WITH KHAH ISOLATED FORM" #xFC4D)
+    ("ARABIC LIGATURE NOON WITH MEEM ISOLATED FORM" #xFC4E)
+    ("ARABIC LIGATURE NOON WITH ALEF MAKSURA ISOLATED FORM" #xFC4F)
+    ("ARABIC LIGATURE NOON WITH YEH ISOLATED FORM" #xFC50)
+    ("ARABIC LIGATURE HEH WITH JEEM ISOLATED FORM" #xFC51)
+    ("ARABIC LIGATURE HEH WITH MEEM ISOLATED FORM" #xFC52)
+    ("ARABIC LIGATURE HEH WITH ALEF MAKSURA ISOLATED FORM" #xFC53)
+    ("ARABIC LIGATURE HEH WITH YEH ISOLATED FORM" #xFC54)
+    ("ARABIC LIGATURE YEH WITH JEEM ISOLATED FORM" #xFC55)
+    ("ARABIC LIGATURE YEH WITH HAH ISOLATED FORM" #xFC56)
+    ("ARABIC LIGATURE YEH WITH KHAH ISOLATED FORM" #xFC57)
+    ("ARABIC LIGATURE YEH WITH MEEM ISOLATED FORM" #xFC58)
+    ("ARABIC LIGATURE YEH WITH ALEF MAKSURA ISOLATED FORM" #xFC59)
+    ("ARABIC LIGATURE YEH WITH YEH ISOLATED FORM" #xFC5A)
+    ("ARABIC LIGATURE THAL WITH SUPERSCRIPT ALEF ISOLATED FORM" #xFC5B)
+    ("ARABIC LIGATURE REH WITH SUPERSCRIPT ALEF ISOLATED FORM" #xFC5C)
+    ("ARABIC LIGATURE ALEF MAKSURA WITH SUPERSCRIPT ALEF ISOLATED FORM" #xFC5D)
+    ("ARABIC LIGATURE SHADDA WITH DAMMATAN ISOLATED FORM" #xFC5E)
+    ("ARABIC LIGATURE SHADDA WITH KASRATAN ISOLATED FORM" #xFC5F)
+    ("ARABIC LIGATURE SHADDA WITH FATHA ISOLATED FORM" #xFC60)
+    ("ARABIC LIGATURE SHADDA WITH DAMMA ISOLATED FORM" #xFC61)
+    ("ARABIC LIGATURE SHADDA WITH KASRA ISOLATED FORM" #xFC62)
+    ("ARABIC LIGATURE SHADDA WITH SUPERSCRIPT ALEF ISOLATED FORM" #xFC63)
+    ("ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH REH FINAL FORM" #xFC64)
+    ("ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH ZAIN FINAL FORM" #xFC65)
+    ("ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH MEEM FINAL FORM" #xFC66)
+    ("ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH NOON FINAL FORM" #xFC67)
+    ("ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH ALEF MAKSURA FINAL FORM" #xFC68)
+    ("ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH YEH FINAL FORM" #xFC69)
+    ("ARABIC LIGATURE BEH WITH REH FINAL FORM" #xFC6A)
+    ("ARABIC LIGATURE BEH WITH ZAIN FINAL FORM" #xFC6B)
+    ("ARABIC LIGATURE BEH WITH MEEM FINAL FORM" #xFC6C)
+    ("ARABIC LIGATURE BEH WITH NOON FINAL FORM" #xFC6D)
+    ("ARABIC LIGATURE BEH WITH ALEF MAKSURA FINAL FORM" #xFC6E)
+    ("ARABIC LIGATURE BEH WITH YEH FINAL FORM" #xFC6F)
+    ("ARABIC LIGATURE TEH WITH REH FINAL FORM" #xFC70)
+    ("ARABIC LIGATURE TEH WITH ZAIN FINAL FORM" #xFC71)
+    ("ARABIC LIGATURE TEH WITH MEEM FINAL FORM" #xFC72)
+    ("ARABIC LIGATURE TEH WITH NOON FINAL FORM" #xFC73)
+    ("ARABIC LIGATURE TEH WITH ALEF MAKSURA FINAL FORM" #xFC74)
+    ("ARABIC LIGATURE TEH WITH YEH FINAL FORM" #xFC75)
+    ("ARABIC LIGATURE THEH WITH REH FINAL FORM" #xFC76)
+    ("ARABIC LIGATURE THEH WITH ZAIN FINAL FORM" #xFC77)
+    ("ARABIC LIGATURE THEH WITH MEEM FINAL FORM" #xFC78)
+    ("ARABIC LIGATURE THEH WITH NOON FINAL FORM" #xFC79)
+    ("ARABIC LIGATURE THEH WITH ALEF MAKSURA FINAL FORM" #xFC7A)
+    ("ARABIC LIGATURE THEH WITH YEH FINAL FORM" #xFC7B)
+    ("ARABIC LIGATURE FEH WITH ALEF MAKSURA FINAL FORM" #xFC7C)
+    ("ARABIC LIGATURE FEH WITH YEH FINAL FORM" #xFC7D)
+    ("ARABIC LIGATURE QAF WITH ALEF MAKSURA FINAL FORM" #xFC7E)
+    ("ARABIC LIGATURE QAF WITH YEH FINAL FORM" #xFC7F)
+    ("ARABIC LIGATURE KAF WITH ALEF FINAL FORM" #xFC80)
+    ("ARABIC LIGATURE KAF WITH LAM FINAL FORM" #xFC81)
+    ("ARABIC LIGATURE KAF WITH MEEM FINAL FORM" #xFC82)
+    ("ARABIC LIGATURE KAF WITH ALEF MAKSURA FINAL FORM" #xFC83)
+    ("ARABIC LIGATURE KAF WITH YEH FINAL FORM" #xFC84)
+    ("ARABIC LIGATURE LAM WITH MEEM FINAL FORM" #xFC85)
+    ("ARABIC LIGATURE LAM WITH ALEF MAKSURA FINAL FORM" #xFC86)
+    ("ARABIC LIGATURE LAM WITH YEH FINAL FORM" #xFC87)
+    ("ARABIC LIGATURE MEEM WITH ALEF FINAL FORM" #xFC88)
+    ("ARABIC LIGATURE MEEM WITH MEEM FINAL FORM" #xFC89)
+    ("ARABIC LIGATURE NOON WITH REH FINAL FORM" #xFC8A)
+    ("ARABIC LIGATURE NOON WITH ZAIN FINAL FORM" #xFC8B)
+    ("ARABIC LIGATURE NOON WITH MEEM FINAL FORM" #xFC8C)
+    ("ARABIC LIGATURE NOON WITH NOON FINAL FORM" #xFC8D)
+    ("ARABIC LIGATURE NOON WITH ALEF MAKSURA FINAL FORM" #xFC8E)
+    ("ARABIC LIGATURE NOON WITH YEH FINAL FORM" #xFC8F)
+    ("ARABIC LIGATURE ALEF MAKSURA WITH SUPERSCRIPT ALEF FINAL FORM" #xFC90)
+    ("ARABIC LIGATURE YEH WITH REH FINAL FORM" #xFC91)
+    ("ARABIC LIGATURE YEH WITH ZAIN FINAL FORM" #xFC92)
+    ("ARABIC LIGATURE YEH WITH MEEM FINAL FORM" #xFC93)
+    ("ARABIC LIGATURE YEH WITH NOON FINAL FORM" #xFC94)
+    ("ARABIC LIGATURE YEH WITH ALEF MAKSURA FINAL FORM" #xFC95)
+    ("ARABIC LIGATURE YEH WITH YEH FINAL FORM" #xFC96)
+    ("ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH JEEM INITIAL FORM" #xFC97)
+    ("ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH HAH INITIAL FORM" #xFC98)
+    ("ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH KHAH INITIAL FORM" #xFC99)
+    ("ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH MEEM INITIAL FORM" #xFC9A)
+    ("ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH HEH INITIAL FORM" #xFC9B)
+    ("ARABIC LIGATURE BEH WITH JEEM INITIAL FORM" #xFC9C)
+    ("ARABIC LIGATURE BEH WITH HAH INITIAL FORM" #xFC9D)
+    ("ARABIC LIGATURE BEH WITH KHAH INITIAL FORM" #xFC9E)
+    ("ARABIC LIGATURE BEH WITH MEEM INITIAL FORM" #xFC9F)
+    ("ARABIC LIGATURE BEH WITH HEH INITIAL FORM" #xFCA0)
+    ("ARABIC LIGATURE TEH WITH JEEM INITIAL FORM" #xFCA1)
+    ("ARABIC LIGATURE TEH WITH HAH INITIAL FORM" #xFCA2)
+    ("ARABIC LIGATURE TEH WITH KHAH INITIAL FORM" #xFCA3)
+    ("ARABIC LIGATURE TEH WITH MEEM INITIAL FORM" #xFCA4)
+    ("ARABIC LIGATURE TEH WITH HEH INITIAL FORM" #xFCA5)
+    ("ARABIC LIGATURE THEH WITH MEEM INITIAL FORM" #xFCA6)
+    ("ARABIC LIGATURE JEEM WITH HAH INITIAL FORM" #xFCA7)
+    ("ARABIC LIGATURE JEEM WITH MEEM INITIAL FORM" #xFCA8)
+    ("ARABIC LIGATURE HAH WITH JEEM INITIAL FORM" #xFCA9)
+    ("ARABIC LIGATURE HAH WITH MEEM INITIAL FORM" #xFCAA)
+    ("ARABIC LIGATURE KHAH WITH JEEM INITIAL FORM" #xFCAB)
+    ("ARABIC LIGATURE KHAH WITH MEEM INITIAL FORM" #xFCAC)
+    ("ARABIC LIGATURE SEEN WITH JEEM INITIAL FORM" #xFCAD)
+    ("ARABIC LIGATURE SEEN WITH HAH INITIAL FORM" #xFCAE)
+    ("ARABIC LIGATURE SEEN WITH KHAH INITIAL FORM" #xFCAF)
+    ("ARABIC LIGATURE SEEN WITH MEEM INITIAL FORM" #xFCB0)
+    ("ARABIC LIGATURE SAD WITH HAH INITIAL FORM" #xFCB1)
+    ("ARABIC LIGATURE SAD WITH KHAH INITIAL FORM" #xFCB2)
+    ("ARABIC LIGATURE SAD WITH MEEM INITIAL FORM" #xFCB3)
+    ("ARABIC LIGATURE DAD WITH JEEM INITIAL FORM" #xFCB4)
+    ("ARABIC LIGATURE DAD WITH HAH INITIAL FORM" #xFCB5)
+    ("ARABIC LIGATURE DAD WITH KHAH INITIAL FORM" #xFCB6)
+    ("ARABIC LIGATURE DAD WITH MEEM INITIAL FORM" #xFCB7)
+    ("ARABIC LIGATURE TAH WITH HAH INITIAL FORM" #xFCB8)
+    ("ARABIC LIGATURE ZAH WITH MEEM INITIAL FORM" #xFCB9)
+    ("ARABIC LIGATURE AIN WITH JEEM INITIAL FORM" #xFCBA)
+    ("ARABIC LIGATURE AIN WITH MEEM INITIAL FORM" #xFCBB)
+    ("ARABIC LIGATURE GHAIN WITH JEEM INITIAL FORM" #xFCBC)
+    ("ARABIC LIGATURE GHAIN WITH MEEM INITIAL FORM" #xFCBD)
+    ("ARABIC LIGATURE FEH WITH JEEM INITIAL FORM" #xFCBE)
+    ("ARABIC LIGATURE FEH WITH HAH INITIAL FORM" #xFCBF)
+    ("ARABIC LIGATURE FEH WITH KHAH INITIAL FORM" #xFCC0)
+    ("ARABIC LIGATURE FEH WITH MEEM INITIAL FORM" #xFCC1)
+    ("ARABIC LIGATURE QAF WITH HAH INITIAL FORM" #xFCC2)
+    ("ARABIC LIGATURE QAF WITH MEEM INITIAL FORM" #xFCC3)
+    ("ARABIC LIGATURE KAF WITH JEEM INITIAL FORM" #xFCC4)
+    ("ARABIC LIGATURE KAF WITH HAH INITIAL FORM" #xFCC5)
+    ("ARABIC LIGATURE KAF WITH KHAH INITIAL FORM" #xFCC6)
+    ("ARABIC LIGATURE KAF WITH LAM INITIAL FORM" #xFCC7)
+    ("ARABIC LIGATURE KAF WITH MEEM INITIAL FORM" #xFCC8)
+    ("ARABIC LIGATURE LAM WITH JEEM INITIAL FORM" #xFCC9)
+    ("ARABIC LIGATURE LAM WITH HAH INITIAL FORM" #xFCCA)
+    ("ARABIC LIGATURE LAM WITH KHAH INITIAL FORM" #xFCCB)
+    ("ARABIC LIGATURE LAM WITH MEEM INITIAL FORM" #xFCCC)
+    ("ARABIC LIGATURE LAM WITH HEH INITIAL FORM" #xFCCD)
+    ("ARABIC LIGATURE MEEM WITH JEEM INITIAL FORM" #xFCCE)
+    ("ARABIC LIGATURE MEEM WITH HAH INITIAL FORM" #xFCCF)
+    ("ARABIC LIGATURE MEEM WITH KHAH INITIAL FORM" #xFCD0)
+    ("ARABIC LIGATURE MEEM WITH MEEM INITIAL FORM" #xFCD1)
+    ("ARABIC LIGATURE NOON WITH JEEM INITIAL FORM" #xFCD2)
+    ("ARABIC LIGATURE NOON WITH HAH INITIAL FORM" #xFCD3)
+    ("ARABIC LIGATURE NOON WITH KHAH INITIAL FORM" #xFCD4)
+    ("ARABIC LIGATURE NOON WITH MEEM INITIAL FORM" #xFCD5)
+    ("ARABIC LIGATURE NOON WITH HEH INITIAL FORM" #xFCD6)
+    ("ARABIC LIGATURE HEH WITH JEEM INITIAL FORM" #xFCD7)
+    ("ARABIC LIGATURE HEH WITH MEEM INITIAL FORM" #xFCD8)
+    ("ARABIC LIGATURE HEH WITH SUPERSCRIPT ALEF INITIAL FORM" #xFCD9)
+    ("ARABIC LIGATURE YEH WITH JEEM INITIAL FORM" #xFCDA)
+    ("ARABIC LIGATURE YEH WITH HAH INITIAL FORM" #xFCDB)
+    ("ARABIC LIGATURE YEH WITH KHAH INITIAL FORM" #xFCDC)
+    ("ARABIC LIGATURE YEH WITH MEEM INITIAL FORM" #xFCDD)
+    ("ARABIC LIGATURE YEH WITH HEH INITIAL FORM" #xFCDE)
+    ("ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH MEEM MEDIAL FORM" #xFCDF)
+    ("ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH HEH MEDIAL FORM" #xFCE0)
+    ("ARABIC LIGATURE BEH WITH MEEM MEDIAL FORM" #xFCE1)
+    ("ARABIC LIGATURE BEH WITH HEH MEDIAL FORM" #xFCE2)
+    ("ARABIC LIGATURE TEH WITH MEEM MEDIAL FORM" #xFCE3)
+    ("ARABIC LIGATURE TEH WITH HEH MEDIAL FORM" #xFCE4)
+    ("ARABIC LIGATURE THEH WITH MEEM MEDIAL FORM" #xFCE5)
+    ("ARABIC LIGATURE THEH WITH HEH MEDIAL FORM" #xFCE6)
+    ("ARABIC LIGATURE SEEN WITH MEEM MEDIAL FORM" #xFCE7)
+    ("ARABIC LIGATURE SEEN WITH HEH MEDIAL FORM" #xFCE8)
+    ("ARABIC LIGATURE SHEEN WITH MEEM MEDIAL FORM" #xFCE9)
+    ("ARABIC LIGATURE SHEEN WITH HEH MEDIAL FORM" #xFCEA)
+    ("ARABIC LIGATURE KAF WITH LAM MEDIAL FORM" #xFCEB)
+    ("ARABIC LIGATURE KAF WITH MEEM MEDIAL FORM" #xFCEC)
+    ("ARABIC LIGATURE LAM WITH MEEM MEDIAL FORM" #xFCED)
+    ("ARABIC LIGATURE NOON WITH MEEM MEDIAL FORM" #xFCEE)
+    ("ARABIC LIGATURE NOON WITH HEH MEDIAL FORM" #xFCEF)
+    ("ARABIC LIGATURE YEH WITH MEEM MEDIAL FORM" #xFCF0)
+    ("ARABIC LIGATURE YEH WITH HEH MEDIAL FORM" #xFCF1)
+    ("ARABIC LIGATURE SHADDA WITH FATHA MEDIAL FORM" #xFCF2)
+    ("ARABIC LIGATURE SHADDA WITH DAMMA MEDIAL FORM" #xFCF3)
+    ("ARABIC LIGATURE SHADDA WITH KASRA MEDIAL FORM" #xFCF4)
+    ("ARABIC LIGATURE TAH WITH ALEF MAKSURA ISOLATED FORM" #xFCF5)
+    ("ARABIC LIGATURE TAH WITH YEH ISOLATED FORM" #xFCF6)
+    ("ARABIC LIGATURE AIN WITH ALEF MAKSURA ISOLATED FORM" #xFCF7)
+    ("ARABIC LIGATURE AIN WITH YEH ISOLATED FORM" #xFCF8)
+    ("ARABIC LIGATURE GHAIN WITH ALEF MAKSURA ISOLATED FORM" #xFCF9)
+    ("ARABIC LIGATURE GHAIN WITH YEH ISOLATED FORM" #xFCFA)
+    ("ARABIC LIGATURE SEEN WITH ALEF MAKSURA ISOLATED FORM" #xFCFB)
+    ("ARABIC LIGATURE SEEN WITH YEH ISOLATED FORM" #xFCFC)
+    ("ARABIC LIGATURE SHEEN WITH ALEF MAKSURA ISOLATED FORM" #xFCFD)
+    ("ARABIC LIGATURE SHEEN WITH YEH ISOLATED FORM" #xFCFE)
+    ("ARABIC LIGATURE HAH WITH ALEF MAKSURA ISOLATED FORM" #xFCFF)
+    ("ARABIC LIGATURE HAH WITH YEH ISOLATED FORM" #xFD00)
+    ("ARABIC LIGATURE JEEM WITH ALEF MAKSURA ISOLATED FORM" #xFD01)
+    ("ARABIC LIGATURE JEEM WITH YEH ISOLATED FORM" #xFD02)
+    ("ARABIC LIGATURE KHAH WITH ALEF MAKSURA ISOLATED FORM" #xFD03)
+    ("ARABIC LIGATURE KHAH WITH YEH ISOLATED FORM" #xFD04)
+    ("ARABIC LIGATURE SAD WITH ALEF MAKSURA ISOLATED FORM" #xFD05)
+    ("ARABIC LIGATURE SAD WITH YEH ISOLATED FORM" #xFD06)
+    ("ARABIC LIGATURE DAD WITH ALEF MAKSURA ISOLATED FORM" #xFD07)
+    ("ARABIC LIGATURE DAD WITH YEH ISOLATED FORM" #xFD08)
+    ("ARABIC LIGATURE SHEEN WITH JEEM ISOLATED FORM" #xFD09)
+    ("ARABIC LIGATURE SHEEN WITH HAH ISOLATED FORM" #xFD0A)
+    ("ARABIC LIGATURE SHEEN WITH KHAH ISOLATED FORM" #xFD0B)
+    ("ARABIC LIGATURE SHEEN WITH MEEM ISOLATED FORM" #xFD0C)
+    ("ARABIC LIGATURE SHEEN WITH REH ISOLATED FORM" #xFD0D)
+    ("ARABIC LIGATURE SEEN WITH REH ISOLATED FORM" #xFD0E)
+    ("ARABIC LIGATURE SAD WITH REH ISOLATED FORM" #xFD0F)
+    ("ARABIC LIGATURE DAD WITH REH ISOLATED FORM" #xFD10)
+    ("ARABIC LIGATURE TAH WITH ALEF MAKSURA FINAL FORM" #xFD11)
+    ("ARABIC LIGATURE TAH WITH YEH FINAL FORM" #xFD12)
+    ("ARABIC LIGATURE AIN WITH ALEF MAKSURA FINAL FORM" #xFD13)
+    ("ARABIC LIGATURE AIN WITH YEH FINAL FORM" #xFD14)
+    ("ARABIC LIGATURE GHAIN WITH ALEF MAKSURA FINAL FORM" #xFD15)
+    ("ARABIC LIGATURE GHAIN WITH YEH FINAL FORM" #xFD16)
+    ("ARABIC LIGATURE SEEN WITH ALEF MAKSURA FINAL FORM" #xFD17)
+    ("ARABIC LIGATURE SEEN WITH YEH FINAL FORM" #xFD18)
+    ("ARABIC LIGATURE SHEEN WITH ALEF MAKSURA FINAL FORM" #xFD19)
+    ("ARABIC LIGATURE SHEEN WITH YEH FINAL FORM" #xFD1A)
+    ("ARABIC LIGATURE HAH WITH ALEF MAKSURA FINAL FORM" #xFD1B)
+    ("ARABIC LIGATURE HAH WITH YEH FINAL FORM" #xFD1C)
+    ("ARABIC LIGATURE JEEM WITH ALEF MAKSURA FINAL FORM" #xFD1D)
+    ("ARABIC LIGATURE JEEM WITH YEH FINAL FORM" #xFD1E)
+    ("ARABIC LIGATURE KHAH WITH ALEF MAKSURA FINAL FORM" #xFD1F)
+    ("ARABIC LIGATURE KHAH WITH YEH FINAL FORM" #xFD20)
+    ("ARABIC LIGATURE SAD WITH ALEF MAKSURA FINAL FORM" #xFD21)
+    ("ARABIC LIGATURE SAD WITH YEH FINAL FORM" #xFD22)
+    ("ARABIC LIGATURE DAD WITH ALEF MAKSURA FINAL FORM" #xFD23)
+    ("ARABIC LIGATURE DAD WITH YEH FINAL FORM" #xFD24)
+    ("ARABIC LIGATURE SHEEN WITH JEEM FINAL FORM" #xFD25)
+    ("ARABIC LIGATURE SHEEN WITH HAH FINAL FORM" #xFD26)
+    ("ARABIC LIGATURE SHEEN WITH KHAH FINAL FORM" #xFD27)
+    ("ARABIC LIGATURE SHEEN WITH MEEM FINAL FORM" #xFD28)
+    ("ARABIC LIGATURE SHEEN WITH REH FINAL FORM" #xFD29)
+    ("ARABIC LIGATURE SEEN WITH REH FINAL FORM" #xFD2A)
+    ("ARABIC LIGATURE SAD WITH REH FINAL FORM" #xFD2B)
+    ("ARABIC LIGATURE DAD WITH REH FINAL FORM" #xFD2C)
+    ("ARABIC LIGATURE SHEEN WITH JEEM INITIAL FORM" #xFD2D)
+    ("ARABIC LIGATURE SHEEN WITH HAH INITIAL FORM" #xFD2E)
+    ("ARABIC LIGATURE SHEEN WITH KHAH INITIAL FORM" #xFD2F)
+    ("ARABIC LIGATURE SHEEN WITH MEEM INITIAL FORM" #xFD30)
+    ("ARABIC LIGATURE SEEN WITH HEH INITIAL FORM" #xFD31)
+    ("ARABIC LIGATURE SHEEN WITH HEH INITIAL FORM" #xFD32)
+    ("ARABIC LIGATURE TAH WITH MEEM INITIAL FORM" #xFD33)
+    ("ARABIC LIGATURE SEEN WITH JEEM MEDIAL FORM" #xFD34)
+    ("ARABIC LIGATURE SEEN WITH HAH MEDIAL FORM" #xFD35)
+    ("ARABIC LIGATURE SEEN WITH KHAH MEDIAL FORM" #xFD36)
+    ("ARABIC LIGATURE SHEEN WITH JEEM MEDIAL FORM" #xFD37)
+    ("ARABIC LIGATURE SHEEN WITH HAH MEDIAL FORM" #xFD38)
+    ("ARABIC LIGATURE SHEEN WITH KHAH MEDIAL FORM" #xFD39)
+    ("ARABIC LIGATURE TAH WITH MEEM MEDIAL FORM" #xFD3A)
+    ("ARABIC LIGATURE ZAH WITH MEEM MEDIAL FORM" #xFD3B)
+    ("ARABIC LIGATURE ALEF WITH FATHATAN FINAL FORM" #xFD3C)
+    ("ARABIC LIGATURE ALEF WITH FATHATAN ISOLATED FORM" #xFD3D)
+    ("ORNATE LEFT PARENTHESIS" #xFD3E)
+    ("ORNATE RIGHT PARENTHESIS" #xFD3F)
+    ("ARABIC LIGATURE TEH WITH JEEM WITH MEEM INITIAL FORM" #xFD50)
+    ("ARABIC LIGATURE TEH WITH HAH WITH JEEM FINAL FORM" #xFD51)
+    ("ARABIC LIGATURE TEH WITH HAH WITH JEEM INITIAL FORM" #xFD52)
+    ("ARABIC LIGATURE TEH WITH HAH WITH MEEM INITIAL FORM" #xFD53)
+    ("ARABIC LIGATURE TEH WITH KHAH WITH MEEM INITIAL FORM" #xFD54)
+    ("ARABIC LIGATURE TEH WITH MEEM WITH JEEM INITIAL FORM" #xFD55)
+    ("ARABIC LIGATURE TEH WITH MEEM WITH HAH INITIAL FORM" #xFD56)
+    ("ARABIC LIGATURE TEH WITH MEEM WITH KHAH INITIAL FORM" #xFD57)
+    ("ARABIC LIGATURE JEEM WITH MEEM WITH HAH FINAL FORM" #xFD58)
+    ("ARABIC LIGATURE JEEM WITH MEEM WITH HAH INITIAL FORM" #xFD59)
+    ("ARABIC LIGATURE HAH WITH MEEM WITH YEH FINAL FORM" #xFD5A)
+    ("ARABIC LIGATURE HAH WITH MEEM WITH ALEF MAKSURA FINAL FORM" #xFD5B)
+    ("ARABIC LIGATURE SEEN WITH HAH WITH JEEM INITIAL FORM" #xFD5C)
+    ("ARABIC LIGATURE SEEN WITH JEEM WITH HAH INITIAL FORM" #xFD5D)
+    ("ARABIC LIGATURE SEEN WITH JEEM WITH ALEF MAKSURA FINAL FORM" #xFD5E)
+    ("ARABIC LIGATURE SEEN WITH MEEM WITH HAH FINAL FORM" #xFD5F)
+    ("ARABIC LIGATURE SEEN WITH MEEM WITH HAH INITIAL FORM" #xFD60)
+    ("ARABIC LIGATURE SEEN WITH MEEM WITH JEEM INITIAL FORM" #xFD61)
+    ("ARABIC LIGATURE SEEN WITH MEEM WITH MEEM FINAL FORM" #xFD62)
+    ("ARABIC LIGATURE SEEN WITH MEEM WITH MEEM INITIAL FORM" #xFD63)
+    ("ARABIC LIGATURE SAD WITH HAH WITH HAH FINAL FORM" #xFD64)
+    ("ARABIC LIGATURE SAD WITH HAH WITH HAH INITIAL FORM" #xFD65)
+    ("ARABIC LIGATURE SAD WITH MEEM WITH MEEM FINAL FORM" #xFD66)
+    ("ARABIC LIGATURE SHEEN WITH HAH WITH MEEM FINAL FORM" #xFD67)
+    ("ARABIC LIGATURE SHEEN WITH HAH WITH MEEM INITIAL FORM" #xFD68)
+    ("ARABIC LIGATURE SHEEN WITH JEEM WITH YEH FINAL FORM" #xFD69)
+    ("ARABIC LIGATURE SHEEN WITH MEEM WITH KHAH FINAL FORM" #xFD6A)
+    ("ARABIC LIGATURE SHEEN WITH MEEM WITH KHAH INITIAL FORM" #xFD6B)
+    ("ARABIC LIGATURE SHEEN WITH MEEM WITH MEEM FINAL FORM" #xFD6C)
+    ("ARABIC LIGATURE SHEEN WITH MEEM WITH MEEM INITIAL FORM" #xFD6D)
+    ("ARABIC LIGATURE DAD WITH HAH WITH ALEF MAKSURA FINAL FORM" #xFD6E)
+    ("ARABIC LIGATURE DAD WITH KHAH WITH MEEM FINAL FORM" #xFD6F)
+    ("ARABIC LIGATURE DAD WITH KHAH WITH MEEM INITIAL FORM" #xFD70)
+    ("ARABIC LIGATURE TAH WITH MEEM WITH HAH FINAL FORM" #xFD71)
+    ("ARABIC LIGATURE TAH WITH MEEM WITH HAH INITIAL FORM" #xFD72)
+    ("ARABIC LIGATURE TAH WITH MEEM WITH MEEM INITIAL FORM" #xFD73)
+    ("ARABIC LIGATURE TAH WITH MEEM WITH YEH FINAL FORM" #xFD74)
+    ("ARABIC LIGATURE AIN WITH JEEM WITH MEEM FINAL FORM" #xFD75)
+    ("ARABIC LIGATURE AIN WITH MEEM WITH MEEM FINAL FORM" #xFD76)
+    ("ARABIC LIGATURE AIN WITH MEEM WITH MEEM INITIAL FORM" #xFD77)
+    ("ARABIC LIGATURE AIN WITH MEEM WITH ALEF MAKSURA FINAL FORM" #xFD78)
+    ("ARABIC LIGATURE GHAIN WITH MEEM WITH MEEM FINAL FORM" #xFD79)
+    ("ARABIC LIGATURE GHAIN WITH MEEM WITH YEH FINAL FORM" #xFD7A)
+    ("ARABIC LIGATURE GHAIN WITH MEEM WITH ALEF MAKSURA FINAL FORM" #xFD7B)
+    ("ARABIC LIGATURE FEH WITH KHAH WITH MEEM FINAL FORM" #xFD7C)
+    ("ARABIC LIGATURE FEH WITH KHAH WITH MEEM INITIAL FORM" #xFD7D)
+    ("ARABIC LIGATURE QAF WITH MEEM WITH HAH FINAL FORM" #xFD7E)
+    ("ARABIC LIGATURE QAF WITH MEEM WITH MEEM FINAL FORM" #xFD7F)
+    ("ARABIC LIGATURE LAM WITH HAH WITH MEEM FINAL FORM" #xFD80)
+    ("ARABIC LIGATURE LAM WITH HAH WITH YEH FINAL FORM" #xFD81)
+    ("ARABIC LIGATURE LAM WITH HAH WITH ALEF MAKSURA FINAL FORM" #xFD82)
+    ("ARABIC LIGATURE LAM WITH JEEM WITH JEEM INITIAL FORM" #xFD83)
+    ("ARABIC LIGATURE LAM WITH JEEM WITH JEEM FINAL FORM" #xFD84)
+    ("ARABIC LIGATURE LAM WITH KHAH WITH MEEM FINAL FORM" #xFD85)
+    ("ARABIC LIGATURE LAM WITH KHAH WITH MEEM INITIAL FORM" #xFD86)
+    ("ARABIC LIGATURE LAM WITH MEEM WITH HAH FINAL FORM" #xFD87)
+    ("ARABIC LIGATURE LAM WITH MEEM WITH HAH INITIAL FORM" #xFD88)
+    ("ARABIC LIGATURE MEEM WITH HAH WITH JEEM INITIAL FORM" #xFD89)
+    ("ARABIC LIGATURE MEEM WITH HAH WITH MEEM INITIAL FORM" #xFD8A)
+    ("ARABIC LIGATURE MEEM WITH HAH WITH YEH FINAL FORM" #xFD8B)
+    ("ARABIC LIGATURE MEEM WITH JEEM WITH HAH INITIAL FORM" #xFD8C)
+    ("ARABIC LIGATURE MEEM WITH JEEM WITH MEEM INITIAL FORM" #xFD8D)
+    ("ARABIC LIGATURE MEEM WITH KHAH WITH JEEM INITIAL FORM" #xFD8E)
+    ("ARABIC LIGATURE MEEM WITH KHAH WITH MEEM INITIAL FORM" #xFD8F)
+    ("ARABIC LIGATURE MEEM WITH JEEM WITH KHAH INITIAL FORM" #xFD92)
+    ("ARABIC LIGATURE HEH WITH MEEM WITH JEEM INITIAL FORM" #xFD93)
+    ("ARABIC LIGATURE HEH WITH MEEM WITH MEEM INITIAL FORM" #xFD94)
+    ("ARABIC LIGATURE NOON WITH HAH WITH MEEM INITIAL FORM" #xFD95)
+    ("ARABIC LIGATURE NOON WITH HAH WITH ALEF MAKSURA FINAL FORM" #xFD96)
+    ("ARABIC LIGATURE NOON WITH JEEM WITH MEEM FINAL FORM" #xFD97)
+    ("ARABIC LIGATURE NOON WITH JEEM WITH MEEM INITIAL FORM" #xFD98)
+    ("ARABIC LIGATURE NOON WITH JEEM WITH ALEF MAKSURA FINAL FORM" #xFD99)
+    ("ARABIC LIGATURE NOON WITH MEEM WITH YEH FINAL FORM" #xFD9A)
+    ("ARABIC LIGATURE NOON WITH MEEM WITH ALEF MAKSURA FINAL FORM" #xFD9B)
+    ("ARABIC LIGATURE YEH WITH MEEM WITH MEEM FINAL FORM" #xFD9C)
+    ("ARABIC LIGATURE YEH WITH MEEM WITH MEEM INITIAL FORM" #xFD9D)
+    ("ARABIC LIGATURE BEH WITH KHAH WITH YEH FINAL FORM" #xFD9E)
+    ("ARABIC LIGATURE TEH WITH JEEM WITH YEH FINAL FORM" #xFD9F)
+    ("ARABIC LIGATURE TEH WITH JEEM WITH ALEF MAKSURA FINAL FORM" #xFDA0)
+    ("ARABIC LIGATURE TEH WITH KHAH WITH YEH FINAL FORM" #xFDA1)
+    ("ARABIC LIGATURE TEH WITH KHAH WITH ALEF MAKSURA FINAL FORM" #xFDA2)
+    ("ARABIC LIGATURE TEH WITH MEEM WITH YEH FINAL FORM" #xFDA3)
+    ("ARABIC LIGATURE TEH WITH MEEM WITH ALEF MAKSURA FINAL FORM" #xFDA4)
+    ("ARABIC LIGATURE JEEM WITH MEEM WITH YEH FINAL FORM" #xFDA5)
+    ("ARABIC LIGATURE JEEM WITH HAH WITH ALEF MAKSURA FINAL FORM" #xFDA6)
+    ("ARABIC LIGATURE JEEM WITH MEEM WITH ALEF MAKSURA FINAL FORM" #xFDA7)
+    ("ARABIC LIGATURE SEEN WITH KHAH WITH ALEF MAKSURA FINAL FORM" #xFDA8)
+    ("ARABIC LIGATURE SAD WITH HAH WITH YEH FINAL FORM" #xFDA9)
+    ("ARABIC LIGATURE SHEEN WITH HAH WITH YEH FINAL FORM" #xFDAA)
+    ("ARABIC LIGATURE DAD WITH HAH WITH YEH FINAL FORM" #xFDAB)
+    ("ARABIC LIGATURE LAM WITH JEEM WITH YEH FINAL FORM" #xFDAC)
+    ("ARABIC LIGATURE LAM WITH MEEM WITH YEH FINAL FORM" #xFDAD)
+    ("ARABIC LIGATURE YEH WITH HAH WITH YEH FINAL FORM" #xFDAE)
+    ("ARABIC LIGATURE YEH WITH JEEM WITH YEH FINAL FORM" #xFDAF)
+    ("ARABIC LIGATURE YEH WITH MEEM WITH YEH FINAL FORM" #xFDB0)
+    ("ARABIC LIGATURE MEEM WITH MEEM WITH YEH FINAL FORM" #xFDB1)
+    ("ARABIC LIGATURE QAF WITH MEEM WITH YEH FINAL FORM" #xFDB2)
+    ("ARABIC LIGATURE NOON WITH HAH WITH YEH FINAL FORM" #xFDB3)
+    ("ARABIC LIGATURE QAF WITH MEEM WITH HAH INITIAL FORM" #xFDB4)
+    ("ARABIC LIGATURE LAM WITH HAH WITH MEEM INITIAL FORM" #xFDB5)
+    ("ARABIC LIGATURE AIN WITH MEEM WITH YEH FINAL FORM" #xFDB6)
+    ("ARABIC LIGATURE KAF WITH MEEM WITH YEH FINAL FORM" #xFDB7)
+    ("ARABIC LIGATURE NOON WITH JEEM WITH HAH INITIAL FORM" #xFDB8)
+    ("ARABIC LIGATURE MEEM WITH KHAH WITH YEH FINAL FORM" #xFDB9)
+    ("ARABIC LIGATURE LAM WITH JEEM WITH MEEM INITIAL FORM" #xFDBA)
+    ("ARABIC LIGATURE KAF WITH MEEM WITH MEEM FINAL FORM" #xFDBB)
+    ("ARABIC LIGATURE LAM WITH JEEM WITH MEEM FINAL FORM" #xFDBC)
+    ("ARABIC LIGATURE NOON WITH JEEM WITH HAH FINAL FORM" #xFDBD)
+    ("ARABIC LIGATURE JEEM WITH HAH WITH YEH FINAL FORM" #xFDBE)
+    ("ARABIC LIGATURE HAH WITH JEEM WITH YEH FINAL FORM" #xFDBF)
+    ("ARABIC LIGATURE MEEM WITH JEEM WITH YEH FINAL FORM" #xFDC0)
+    ("ARABIC LIGATURE FEH WITH MEEM WITH YEH FINAL FORM" #xFDC1)
+    ("ARABIC LIGATURE BEH WITH HAH WITH YEH FINAL FORM" #xFDC2)
+    ("ARABIC LIGATURE KAF WITH MEEM WITH MEEM INITIAL FORM" #xFDC3)
+    ("ARABIC LIGATURE AIN WITH JEEM WITH MEEM INITIAL FORM" #xFDC4)
+    ("ARABIC LIGATURE SAD WITH MEEM WITH MEEM INITIAL FORM" #xFDC5)
+    ("ARABIC LIGATURE SEEN WITH KHAH WITH YEH FINAL FORM" #xFDC6)
+    ("ARABIC LIGATURE NOON WITH JEEM WITH YEH FINAL FORM" #xFDC7)
+    ("ARABIC LIGATURE SALLA USED AS KORANIC STOP SIGN ISOLATED FORM" #xFDF0)
+    ("ARABIC LIGATURE QALA USED AS KORANIC STOP SIGN ISOLATED FORM" #xFDF1)
+    ("ARABIC LIGATURE ALLAH ISOLATED FORM" #xFDF2)
+    ("ARABIC LIGATURE AKBAR ISOLATED FORM" #xFDF3)
+    ("ARABIC LIGATURE MOHAMMAD ISOLATED FORM" #xFDF4)
+    ("ARABIC LIGATURE SALAM ISOLATED FORM" #xFDF5)
+    ("ARABIC LIGATURE RASOUL ISOLATED FORM" #xFDF6)
+    ("ARABIC LIGATURE ALAYHE ISOLATED FORM" #xFDF7)
+    ("ARABIC LIGATURE WASALLAM ISOLATED FORM" #xFDF8)
+    ("ARABIC LIGATURE SALLA ISOLATED FORM" #xFDF9)
+    ("ARABIC LIGATURE SALLALLAHOU ALAYHE WASALLAM" #xFDFA)
+    ("ARABIC LIGATURE JALLAJALALOUHOU" #xFDFB)
+    ("RIAL SIGN" #xFDFC)
+    ))
diff --git a/lisp/nxml/char-name/unicode/0FE00-0FE0F.el b/lisp/nxml/char-name/unicode/0FE00-0FE0F.el
new file mode 100644
index 00000000000..f1eb897599b
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/0FE00-0FE0F.el
@@ -0,0 +1,18 @@
+(nxml-define-char-name-set 'variation-selectors
+  '(("VARIATION SELECTOR-1" #xFE00)
+    ("VARIATION SELECTOR-2" #xFE01)
+    ("VARIATION SELECTOR-3" #xFE02)
+    ("VARIATION SELECTOR-4" #xFE03)
+    ("VARIATION SELECTOR-5" #xFE04)
+    ("VARIATION SELECTOR-6" #xFE05)
+    ("VARIATION SELECTOR-7" #xFE06)
+    ("VARIATION SELECTOR-8" #xFE07)
+    ("VARIATION SELECTOR-9" #xFE08)
+    ("VARIATION SELECTOR-10" #xFE09)
+    ("VARIATION SELECTOR-11" #xFE0A)
+    ("VARIATION SELECTOR-12" #xFE0B)
+    ("VARIATION SELECTOR-13" #xFE0C)
+    ("VARIATION SELECTOR-14" #xFE0D)
+    ("VARIATION SELECTOR-15" #xFE0E)
+    ("VARIATION SELECTOR-16" #xFE0F)
+    ))
diff --git a/lisp/nxml/char-name/unicode/0FE20-0FE2F.el b/lisp/nxml/char-name/unicode/0FE20-0FE2F.el
new file mode 100644
index 00000000000..2cc5ef2bb05
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/0FE20-0FE2F.el
@@ -0,0 +1,6 @@
+(nxml-define-char-name-set 'combining-half-marks
+  '(("COMBINING LIGATURE LEFT HALF" #xFE20)
+    ("COMBINING LIGATURE RIGHT HALF" #xFE21)
+    ("COMBINING DOUBLE TILDE LEFT HALF" #xFE22)
+    ("COMBINING DOUBLE TILDE RIGHT HALF" #xFE23)
+    ))
diff --git a/lisp/nxml/char-name/unicode/0FE30-0FE4F.el b/lisp/nxml/char-name/unicode/0FE30-0FE4F.el
new file mode 100644
index 00000000000..83893e4b936
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/0FE30-0FE4F.el
@@ -0,0 +1,32 @@
+(nxml-define-char-name-set 'cjk-compatibility-forms
+  '(("PRESENTATION FORM FOR VERTICAL TWO DOT LEADER" #xFE30)
+    ("PRESENTATION FORM FOR VERTICAL EM DASH" #xFE31)
+    ("PRESENTATION FORM FOR VERTICAL EN DASH" #xFE32)
+    ("PRESENTATION FORM FOR VERTICAL LOW LINE" #xFE33)
+    ("PRESENTATION FORM FOR VERTICAL WAVY LOW LINE" #xFE34)
+    ("PRESENTATION FORM FOR VERTICAL LEFT PARENTHESIS" #xFE35)
+    ("PRESENTATION FORM FOR VERTICAL RIGHT PARENTHESIS" #xFE36)
+    ("PRESENTATION FORM FOR VERTICAL LEFT CURLY BRACKET" #xFE37)
+    ("PRESENTATION FORM FOR VERTICAL RIGHT CURLY BRACKET" #xFE38)
+    ("PRESENTATION FORM FOR VERTICAL LEFT TORTOISE SHELL BRACKET" #xFE39)
+    ("PRESENTATION FORM FOR VERTICAL RIGHT TORTOISE SHELL BRACKET" #xFE3A)
+    ("PRESENTATION FORM FOR VERTICAL LEFT BLACK LENTICULAR BRACKET" #xFE3B)
+    ("PRESENTATION FORM FOR VERTICAL RIGHT BLACK LENTICULAR BRACKET" #xFE3C)
+    ("PRESENTATION FORM FOR VERTICAL LEFT DOUBLE ANGLE BRACKET" #xFE3D)
+    ("PRESENTATION FORM FOR VERTICAL RIGHT DOUBLE ANGLE BRACKET" #xFE3E)
+    ("PRESENTATION FORM FOR VERTICAL LEFT ANGLE BRACKET" #xFE3F)
+    ("PRESENTATION FORM FOR VERTICAL RIGHT ANGLE BRACKET" #xFE40)
+    ("PRESENTATION FORM FOR VERTICAL LEFT CORNER BRACKET" #xFE41)
+    ("PRESENTATION FORM FOR VERTICAL RIGHT CORNER BRACKET" #xFE42)
+    ("PRESENTATION FORM FOR VERTICAL LEFT WHITE CORNER BRACKET" #xFE43)
+    ("PRESENTATION FORM FOR VERTICAL RIGHT WHITE CORNER BRACKET" #xFE44)
+    ("SESAME DOT" #xFE45)
+    ("WHITE SESAME DOT" #xFE46)
+    ("DASHED OVERLINE" #xFE49)
+    ("CENTRELINE OVERLINE" #xFE4A)
+    ("WAVY OVERLINE" #xFE4B)
+    ("DOUBLE WAVY OVERLINE" #xFE4C)
+    ("DASHED LOW LINE" #xFE4D)
+    ("CENTRELINE LOW LINE" #xFE4E)
+    ("WAVY LOW LINE" #xFE4F)
+    ))
diff --git a/lisp/nxml/char-name/unicode/0FE50-0FE6F.el b/lisp/nxml/char-name/unicode/0FE50-0FE6F.el
new file mode 100644
index 00000000000..d94cc453f4f
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/0FE50-0FE6F.el
@@ -0,0 +1,28 @@
+(nxml-define-char-name-set 'small-form-variants
+  '(("SMALL COMMA" #xFE50)
+    ("SMALL IDEOGRAPHIC COMMA" #xFE51)
+    ("SMALL FULL STOP" #xFE52)
+    ("SMALL SEMICOLON" #xFE54)
+    ("SMALL COLON" #xFE55)
+    ("SMALL QUESTION MARK" #xFE56)
+    ("SMALL EXCLAMATION MARK" #xFE57)
+    ("SMALL EM DASH" #xFE58)
+    ("SMALL LEFT PARENTHESIS" #xFE59)
+    ("SMALL RIGHT PARENTHESIS" #xFE5A)
+    ("SMALL LEFT CURLY BRACKET" #xFE5B)
+    ("SMALL RIGHT CURLY BRACKET" #xFE5C)
+    ("SMALL LEFT TORTOISE SHELL BRACKET" #xFE5D)
+    ("SMALL RIGHT TORTOISE SHELL BRACKET" #xFE5E)
+    ("SMALL NUMBER SIGN" #xFE5F)
+    ("SMALL AMPERSAND" #xFE60)
+    ("SMALL ASTERISK" #xFE61)
+    ("SMALL PLUS SIGN" #xFE62)
+    ("SMALL HYPHEN-MINUS" #xFE63)
+    ("SMALL LESS-THAN SIGN" #xFE64)
+    ("SMALL GREATER-THAN SIGN" #xFE65)
+    ("SMALL EQUALS SIGN" #xFE66)
+    ("SMALL REVERSE SOLIDUS" #xFE68)
+    ("SMALL DOLLAR SIGN" #xFE69)
+    ("SMALL PERCENT SIGN" #xFE6A)
+    ("SMALL COMMERCIAL AT" #xFE6B)
+    ))
diff --git a/lisp/nxml/char-name/unicode/0FE70-0FEFF.el b/lisp/nxml/char-name/unicode/0FE70-0FEFF.el
new file mode 100644
index 00000000000..d0e54b64ec1
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/0FE70-0FEFF.el
@@ -0,0 +1,143 @@
+(nxml-define-char-name-set 'arabic-presentation-forms-b
+  '(("ARABIC FATHATAN ISOLATED FORM" #xFE70)
+    ("ARABIC TATWEEL WITH FATHATAN ABOVE" #xFE71)
+    ("ARABIC DAMMATAN ISOLATED FORM" #xFE72)
+    ("ARABIC TAIL FRAGMENT" #xFE73)
+    ("ARABIC KASRATAN ISOLATED FORM" #xFE74)
+    ("ARABIC FATHA ISOLATED FORM" #xFE76)
+    ("ARABIC FATHA MEDIAL FORM" #xFE77)
+    ("ARABIC DAMMA ISOLATED FORM" #xFE78)
+    ("ARABIC DAMMA MEDIAL FORM" #xFE79)
+    ("ARABIC KASRA ISOLATED FORM" #xFE7A)
+    ("ARABIC KASRA MEDIAL FORM" #xFE7B)
+    ("ARABIC SHADDA ISOLATED FORM" #xFE7C)
+    ("ARABIC SHADDA MEDIAL FORM" #xFE7D)
+    ("ARABIC SUKUN ISOLATED FORM" #xFE7E)
+    ("ARABIC SUKUN MEDIAL FORM" #xFE7F)
+    ("ARABIC LETTER HAMZA ISOLATED FORM" #xFE80)
+    ("ARABIC LETTER ALEF WITH MADDA ABOVE ISOLATED FORM" #xFE81)
+    ("ARABIC LETTER ALEF WITH MADDA ABOVE FINAL FORM" #xFE82)
+    ("ARABIC LETTER ALEF WITH HAMZA ABOVE ISOLATED FORM" #xFE83)
+    ("ARABIC LETTER ALEF WITH HAMZA ABOVE FINAL FORM" #xFE84)
+    ("ARABIC LETTER WAW WITH HAMZA ABOVE ISOLATED FORM" #xFE85)
+    ("ARABIC LETTER WAW WITH HAMZA ABOVE FINAL FORM" #xFE86)
+    ("ARABIC LETTER ALEF WITH HAMZA BELOW ISOLATED FORM" #xFE87)
+    ("ARABIC LETTER ALEF WITH HAMZA BELOW FINAL FORM" #xFE88)
+    ("ARABIC LETTER YEH WITH HAMZA ABOVE ISOLATED FORM" #xFE89)
+    ("ARABIC LETTER YEH WITH HAMZA ABOVE FINAL FORM" #xFE8A)
+    ("ARABIC LETTER YEH WITH HAMZA ABOVE INITIAL FORM" #xFE8B)
+    ("ARABIC LETTER YEH WITH HAMZA ABOVE MEDIAL FORM" #xFE8C)
+    ("ARABIC LETTER ALEF ISOLATED FORM" #xFE8D)
+    ("ARABIC LETTER ALEF FINAL FORM" #xFE8E)
+    ("ARABIC LETTER BEH ISOLATED FORM" #xFE8F)
+    ("ARABIC LETTER BEH FINAL FORM" #xFE90)
+    ("ARABIC LETTER BEH INITIAL FORM" #xFE91)
+    ("ARABIC LETTER BEH MEDIAL FORM" #xFE92)
+    ("ARABIC LETTER TEH MARBUTA ISOLATED FORM" #xFE93)
+    ("ARABIC LETTER TEH MARBUTA FINAL FORM" #xFE94)
+    ("ARABIC LETTER TEH ISOLATED FORM" #xFE95)
+    ("ARABIC LETTER TEH FINAL FORM" #xFE96)
+    ("ARABIC LETTER TEH INITIAL FORM" #xFE97)
+    ("ARABIC LETTER TEH MEDIAL FORM" #xFE98)
+    ("ARABIC LETTER THEH ISOLATED FORM" #xFE99)
+    ("ARABIC LETTER THEH FINAL FORM" #xFE9A)
+    ("ARABIC LETTER THEH INITIAL FORM" #xFE9B)
+    ("ARABIC LETTER THEH MEDIAL FORM" #xFE9C)
+    ("ARABIC LETTER JEEM ISOLATED FORM" #xFE9D)
+    ("ARABIC LETTER JEEM FINAL FORM" #xFE9E)
+    ("ARABIC LETTER JEEM INITIAL FORM" #xFE9F)
+    ("ARABIC LETTER JEEM MEDIAL FORM" #xFEA0)
+    ("ARABIC LETTER HAH ISOLATED FORM" #xFEA1)
+    ("ARABIC LETTER HAH FINAL FORM" #xFEA2)
+    ("ARABIC LETTER HAH INITIAL FORM" #xFEA3)
+    ("ARABIC LETTER HAH MEDIAL FORM" #xFEA4)
+    ("ARABIC LETTER KHAH ISOLATED FORM" #xFEA5)
+    ("ARABIC LETTER KHAH FINAL FORM" #xFEA6)
+    ("ARABIC LETTER KHAH INITIAL FORM" #xFEA7)
+    ("ARABIC LETTER KHAH MEDIAL FORM" #xFEA8)
+    ("ARABIC LETTER DAL ISOLATED FORM" #xFEA9)
+    ("ARABIC LETTER DAL FINAL FORM" #xFEAA)
+    ("ARABIC LETTER THAL ISOLATED FORM" #xFEAB)
+    ("ARABIC LETTER THAL FINAL FORM" #xFEAC)
+    ("ARABIC LETTER REH ISOLATED FORM" #xFEAD)
+    ("ARABIC LETTER REH FINAL FORM" #xFEAE)
+    ("ARABIC LETTER ZAIN ISOLATED FORM" #xFEAF)
+    ("ARABIC LETTER ZAIN FINAL FORM" #xFEB0)
+    ("ARABIC LETTER SEEN ISOLATED FORM" #xFEB1)
+    ("ARABIC LETTER SEEN FINAL FORM" #xFEB2)
+    ("ARABIC LETTER SEEN INITIAL FORM" #xFEB3)
+    ("ARABIC LETTER SEEN MEDIAL FORM" #xFEB4)
+    ("ARABIC LETTER SHEEN ISOLATED FORM" #xFEB5)
+    ("ARABIC LETTER SHEEN FINAL FORM" #xFEB6)
+    ("ARABIC LETTER SHEEN INITIAL FORM" #xFEB7)
+    ("ARABIC LETTER SHEEN MEDIAL FORM" #xFEB8)
+    ("ARABIC LETTER SAD ISOLATED FORM" #xFEB9)
+    ("ARABIC LETTER SAD FINAL FORM" #xFEBA)
+    ("ARABIC LETTER SAD INITIAL FORM" #xFEBB)
+    ("ARABIC LETTER SAD MEDIAL FORM" #xFEBC)
+    ("ARABIC LETTER DAD ISOLATED FORM" #xFEBD)
+    ("ARABIC LETTER DAD FINAL FORM" #xFEBE)
+    ("ARABIC LETTER DAD INITIAL FORM" #xFEBF)
+    ("ARABIC LETTER DAD MEDIAL FORM" #xFEC0)
+    ("ARABIC LETTER TAH ISOLATED FORM" #xFEC1)
+    ("ARABIC LETTER TAH FINAL FORM" #xFEC2)
+    ("ARABIC LETTER TAH INITIAL FORM" #xFEC3)
+    ("ARABIC LETTER TAH MEDIAL FORM" #xFEC4)
+    ("ARABIC LETTER ZAH ISOLATED FORM" #xFEC5)
+    ("ARABIC LETTER ZAH FINAL FORM" #xFEC6)
+    ("ARABIC LETTER ZAH INITIAL FORM" #xFEC7)
+    ("ARABIC LETTER ZAH MEDIAL FORM" #xFEC8)
+    ("ARABIC LETTER AIN ISOLATED FORM" #xFEC9)
+    ("ARABIC LETTER AIN FINAL FORM" #xFECA)
+    ("ARABIC LETTER AIN INITIAL FORM" #xFECB)
+    ("ARABIC LETTER AIN MEDIAL FORM" #xFECC)
+    ("ARABIC LETTER GHAIN ISOLATED FORM" #xFECD)
+    ("ARABIC LETTER GHAIN FINAL FORM" #xFECE)
+    ("ARABIC LETTER GHAIN INITIAL FORM" #xFECF)
+    ("ARABIC LETTER GHAIN MEDIAL FORM" #xFED0)
+    ("ARABIC LETTER FEH ISOLATED FORM" #xFED1)
+    ("ARABIC LETTER FEH FINAL FORM" #xFED2)
+    ("ARABIC LETTER FEH INITIAL FORM" #xFED3)
+    ("ARABIC LETTER FEH MEDIAL FORM" #xFED4)
+    ("ARABIC LETTER QAF ISOLATED FORM" #xFED5)
+    ("ARABIC LETTER QAF FINAL FORM" #xFED6)
+    ("ARABIC LETTER QAF INITIAL FORM" #xFED7)
+    ("ARABIC LETTER QAF MEDIAL FORM" #xFED8)
+    ("ARABIC LETTER KAF ISOLATED FORM" #xFED9)
+    ("ARABIC LETTER KAF FINAL FORM" #xFEDA)
+    ("ARABIC LETTER KAF INITIAL FORM" #xFEDB)
+    ("ARABIC LETTER KAF MEDIAL FORM" #xFEDC)
+    ("ARABIC LETTER LAM ISOLATED FORM" #xFEDD)
+    ("ARABIC LETTER LAM FINAL FORM" #xFEDE)
+    ("ARABIC LETTER LAM INITIAL FORM" #xFEDF)
+    ("ARABIC LETTER LAM MEDIAL FORM" #xFEE0)
+    ("ARABIC LETTER MEEM ISOLATED FORM" #xFEE1)
+    ("ARABIC LETTER MEEM FINAL FORM" #xFEE2)
+    ("ARABIC LETTER MEEM INITIAL FORM" #xFEE3)
+    ("ARABIC LETTER MEEM MEDIAL FORM" #xFEE4)
+    ("ARABIC LETTER NOON ISOLATED FORM" #xFEE5)
+    ("ARABIC LETTER NOON FINAL FORM" #xFEE6)
+    ("ARABIC LETTER NOON INITIAL FORM" #xFEE7)
+    ("ARABIC LETTER NOON MEDIAL FORM" #xFEE8)
+    ("ARABIC LETTER HEH ISOLATED FORM" #xFEE9)
+    ("ARABIC LETTER HEH FINAL FORM" #xFEEA)
+    ("ARABIC LETTER HEH INITIAL FORM" #xFEEB)
+    ("ARABIC LETTER HEH MEDIAL FORM" #xFEEC)
+    ("ARABIC LETTER WAW ISOLATED FORM" #xFEED)
+    ("ARABIC LETTER WAW FINAL FORM" #xFEEE)
+    ("ARABIC LETTER ALEF MAKSURA ISOLATED FORM" #xFEEF)
+    ("ARABIC LETTER ALEF MAKSURA FINAL FORM" #xFEF0)
+    ("ARABIC LETTER YEH ISOLATED FORM" #xFEF1)
+    ("ARABIC LETTER YEH FINAL FORM" #xFEF2)
+    ("ARABIC LETTER YEH INITIAL FORM" #xFEF3)
+    ("ARABIC LETTER YEH MEDIAL FORM" #xFEF4)
+    ("ARABIC LIGATURE LAM WITH ALEF WITH MADDA ABOVE ISOLATED FORM" #xFEF5)
+    ("ARABIC LIGATURE LAM WITH ALEF WITH MADDA ABOVE FINAL FORM" #xFEF6)
+    ("ARABIC LIGATURE LAM WITH ALEF WITH HAMZA ABOVE ISOLATED FORM" #xFEF7)
+    ("ARABIC LIGATURE LAM WITH ALEF WITH HAMZA ABOVE FINAL FORM" #xFEF8)
+    ("ARABIC LIGATURE LAM WITH ALEF WITH HAMZA BELOW ISOLATED FORM" #xFEF9)
+    ("ARABIC LIGATURE LAM WITH ALEF WITH HAMZA BELOW FINAL FORM" #xFEFA)
+    ("ARABIC LIGATURE LAM WITH ALEF ISOLATED FORM" #xFEFB)
+    ("ARABIC LIGATURE LAM WITH ALEF FINAL FORM" #xFEFC)
+    ("ZERO WIDTH NO-BREAK SPACE" #xFEFF)
+    ))
diff --git a/lisp/nxml/char-name/unicode/0FF00-0FFEF.el b/lisp/nxml/char-name/unicode/0FF00-0FFEF.el
new file mode 100644
index 00000000000..004f043c19b
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/0FF00-0FFEF.el
@@ -0,0 +1,227 @@
+(nxml-define-char-name-set 'halfwidth-and-fullwidth-forms
+  '(("FULLWIDTH EXCLAMATION MARK" #xFF01)
+    ("FULLWIDTH QUOTATION MARK" #xFF02)
+    ("FULLWIDTH NUMBER SIGN" #xFF03)
+    ("FULLWIDTH DOLLAR SIGN" #xFF04)
+    ("FULLWIDTH PERCENT SIGN" #xFF05)
+    ("FULLWIDTH AMPERSAND" #xFF06)
+    ("FULLWIDTH APOSTROPHE" #xFF07)
+    ("FULLWIDTH LEFT PARENTHESIS" #xFF08)
+    ("FULLWIDTH RIGHT PARENTHESIS" #xFF09)
+    ("FULLWIDTH ASTERISK" #xFF0A)
+    ("FULLWIDTH PLUS SIGN" #xFF0B)
+    ("FULLWIDTH COMMA" #xFF0C)
+    ("FULLWIDTH HYPHEN-MINUS" #xFF0D)
+    ("FULLWIDTH FULL STOP" #xFF0E)
+    ("FULLWIDTH SOLIDUS" #xFF0F)
+    ("FULLWIDTH DIGIT ZERO" #xFF10)
+    ("FULLWIDTH DIGIT ONE" #xFF11)
+    ("FULLWIDTH DIGIT TWO" #xFF12)
+    ("FULLWIDTH DIGIT THREE" #xFF13)
+    ("FULLWIDTH DIGIT FOUR" #xFF14)
+    ("FULLWIDTH DIGIT FIVE" #xFF15)
+    ("FULLWIDTH DIGIT SIX" #xFF16)
+    ("FULLWIDTH DIGIT SEVEN" #xFF17)
+    ("FULLWIDTH DIGIT EIGHT" #xFF18)
+    ("FULLWIDTH DIGIT NINE" #xFF19)
+    ("FULLWIDTH COLON" #xFF1A)
+    ("FULLWIDTH SEMICOLON" #xFF1B)
+    ("FULLWIDTH LESS-THAN SIGN" #xFF1C)
+    ("FULLWIDTH EQUALS SIGN" #xFF1D)
+    ("FULLWIDTH GREATER-THAN SIGN" #xFF1E)
+    ("FULLWIDTH QUESTION MARK" #xFF1F)
+    ("FULLWIDTH COMMERCIAL AT" #xFF20)
+    ("FULLWIDTH LATIN CAPITAL LETTER A" #xFF21)
+    ("FULLWIDTH LATIN CAPITAL LETTER B" #xFF22)
+    ("FULLWIDTH LATIN CAPITAL LETTER C" #xFF23)
+    ("FULLWIDTH LATIN CAPITAL LETTER D" #xFF24)
+    ("FULLWIDTH LATIN CAPITAL LETTER E" #xFF25)
+    ("FULLWIDTH LATIN CAPITAL LETTER F" #xFF26)
+    ("FULLWIDTH LATIN CAPITAL LETTER G" #xFF27)
+    ("FULLWIDTH LATIN CAPITAL LETTER H" #xFF28)
+    ("FULLWIDTH LATIN CAPITAL LETTER I" #xFF29)
+    ("FULLWIDTH LATIN CAPITAL LETTER J" #xFF2A)
+    ("FULLWIDTH LATIN CAPITAL LETTER K" #xFF2B)
+    ("FULLWIDTH LATIN CAPITAL LETTER L" #xFF2C)
+    ("FULLWIDTH LATIN CAPITAL LETTER M" #xFF2D)
+    ("FULLWIDTH LATIN CAPITAL LETTER N" #xFF2E)
+    ("FULLWIDTH LATIN CAPITAL LETTER O" #xFF2F)
+    ("FULLWIDTH LATIN CAPITAL LETTER P" #xFF30)
+    ("FULLWIDTH LATIN CAPITAL LETTER Q" #xFF31)
+    ("FULLWIDTH LATIN CAPITAL LETTER R" #xFF32)
+    ("FULLWIDTH LATIN CAPITAL LETTER S" #xFF33)
+    ("FULLWIDTH LATIN CAPITAL LETTER T" #xFF34)
+    ("FULLWIDTH LATIN CAPITAL LETTER U" #xFF35)
+    ("FULLWIDTH LATIN CAPITAL LETTER V" #xFF36)
+    ("FULLWIDTH LATIN CAPITAL LETTER W" #xFF37)
+    ("FULLWIDTH LATIN CAPITAL LETTER X" #xFF38)
+    ("FULLWIDTH LATIN CAPITAL LETTER Y" #xFF39)
+    ("FULLWIDTH LATIN CAPITAL LETTER Z" #xFF3A)
+    ("FULLWIDTH LEFT SQUARE BRACKET" #xFF3B)
+    ("FULLWIDTH REVERSE SOLIDUS" #xFF3C)
+    ("FULLWIDTH RIGHT SQUARE BRACKET" #xFF3D)
+    ("FULLWIDTH CIRCUMFLEX ACCENT" #xFF3E)
+    ("FULLWIDTH LOW LINE" #xFF3F)
+    ("FULLWIDTH GRAVE ACCENT" #xFF40)
+    ("FULLWIDTH LATIN SMALL LETTER A" #xFF41)
+    ("FULLWIDTH LATIN SMALL LETTER B" #xFF42)
+    ("FULLWIDTH LATIN SMALL LETTER C" #xFF43)
+    ("FULLWIDTH LATIN SMALL LETTER D" #xFF44)
+    ("FULLWIDTH LATIN SMALL LETTER E" #xFF45)
+    ("FULLWIDTH LATIN SMALL LETTER F" #xFF46)
+    ("FULLWIDTH LATIN SMALL LETTER G" #xFF47)
+    ("FULLWIDTH LATIN SMALL LETTER H" #xFF48)
+    ("FULLWIDTH LATIN SMALL LETTER I" #xFF49)
+    ("FULLWIDTH LATIN SMALL LETTER J" #xFF4A)
+    ("FULLWIDTH LATIN SMALL LETTER K" #xFF4B)
+    ("FULLWIDTH LATIN SMALL LETTER L" #xFF4C)
+    ("FULLWIDTH LATIN SMALL LETTER M" #xFF4D)
+    ("FULLWIDTH LATIN SMALL LETTER N" #xFF4E)
+    ("FULLWIDTH LATIN SMALL LETTER O" #xFF4F)
+    ("FULLWIDTH LATIN SMALL LETTER P" #xFF50)
+    ("FULLWIDTH LATIN SMALL LETTER Q" #xFF51)
+    ("FULLWIDTH LATIN SMALL LETTER R" #xFF52)
+    ("FULLWIDTH LATIN SMALL LETTER S" #xFF53)
+    ("FULLWIDTH LATIN SMALL LETTER T" #xFF54)
+    ("FULLWIDTH LATIN SMALL LETTER U" #xFF55)
+    ("FULLWIDTH LATIN SMALL LETTER V" #xFF56)
+    ("FULLWIDTH LATIN SMALL LETTER W" #xFF57)
+    ("FULLWIDTH LATIN SMALL LETTER X" #xFF58)
+    ("FULLWIDTH LATIN SMALL LETTER Y" #xFF59)
+    ("FULLWIDTH LATIN SMALL LETTER Z" #xFF5A)
+    ("FULLWIDTH LEFT CURLY BRACKET" #xFF5B)
+    ("FULLWIDTH VERTICAL LINE" #xFF5C)
+    ("FULLWIDTH RIGHT CURLY BRACKET" #xFF5D)
+    ("FULLWIDTH TILDE" #xFF5E)
+    ("FULLWIDTH LEFT WHITE PARENTHESIS" #xFF5F)
+    ("FULLWIDTH RIGHT WHITE PARENTHESIS" #xFF60)
+    ("HALFWIDTH IDEOGRAPHIC FULL STOP" #xFF61)
+    ("HALFWIDTH LEFT CORNER BRACKET" #xFF62)
+    ("HALFWIDTH RIGHT CORNER BRACKET" #xFF63)
+    ("HALFWIDTH IDEOGRAPHIC COMMA" #xFF64)
+    ("HALFWIDTH KATAKANA MIDDLE DOT" #xFF65)
+    ("HALFWIDTH KATAKANA LETTER WO" #xFF66)
+    ("HALFWIDTH KATAKANA LETTER SMALL A" #xFF67)
+    ("HALFWIDTH KATAKANA LETTER SMALL I" #xFF68)
+    ("HALFWIDTH KATAKANA LETTER SMALL U" #xFF69)
+    ("HALFWIDTH KATAKANA LETTER SMALL E" #xFF6A)
+    ("HALFWIDTH KATAKANA LETTER SMALL O" #xFF6B)
+    ("HALFWIDTH KATAKANA LETTER SMALL YA" #xFF6C)
+    ("HALFWIDTH KATAKANA LETTER SMALL YU" #xFF6D)
+    ("HALFWIDTH KATAKANA LETTER SMALL YO" #xFF6E)
+    ("HALFWIDTH KATAKANA LETTER SMALL TU" #xFF6F)
+    ("HALFWIDTH KATAKANA-HIRAGANA PROLONGED SOUND MARK" #xFF70)
+    ("HALFWIDTH KATAKANA LETTER A" #xFF71)
+    ("HALFWIDTH KATAKANA LETTER I" #xFF72)
+    ("HALFWIDTH KATAKANA LETTER U" #xFF73)
+    ("HALFWIDTH KATAKANA LETTER E" #xFF74)
+    ("HALFWIDTH KATAKANA LETTER O" #xFF75)
+    ("HALFWIDTH KATAKANA LETTER KA" #xFF76)
+    ("HALFWIDTH KATAKANA LETTER KI" #xFF77)
+    ("HALFWIDTH KATAKANA LETTER KU" #xFF78)
+    ("HALFWIDTH KATAKANA LETTER KE" #xFF79)
+    ("HALFWIDTH KATAKANA LETTER KO" #xFF7A)
+    ("HALFWIDTH KATAKANA LETTER SA" #xFF7B)
+    ("HALFWIDTH KATAKANA LETTER SI" #xFF7C)
+    ("HALFWIDTH KATAKANA LETTER SU" #xFF7D)
+    ("HALFWIDTH KATAKANA LETTER SE" #xFF7E)
+    ("HALFWIDTH KATAKANA LETTER SO" #xFF7F)
+    ("HALFWIDTH KATAKANA LETTER TA" #xFF80)
+    ("HALFWIDTH KATAKANA LETTER TI" #xFF81)
+    ("HALFWIDTH KATAKANA LETTER TU" #xFF82)
+    ("HALFWIDTH KATAKANA LETTER TE" #xFF83)
+    ("HALFWIDTH KATAKANA LETTER TO" #xFF84)
+    ("HALFWIDTH KATAKANA LETTER NA" #xFF85)
+    ("HALFWIDTH KATAKANA LETTER NI" #xFF86)
+    ("HALFWIDTH KATAKANA LETTER NU" #xFF87)
+    ("HALFWIDTH KATAKANA LETTER NE" #xFF88)
+    ("HALFWIDTH KATAKANA LETTER NO" #xFF89)
+    ("HALFWIDTH KATAKANA LETTER HA" #xFF8A)
+    ("HALFWIDTH KATAKANA LETTER HI" #xFF8B)
+    ("HALFWIDTH KATAKANA LETTER HU" #xFF8C)
+    ("HALFWIDTH KATAKANA LETTER HE" #xFF8D)
+    ("HALFWIDTH KATAKANA LETTER HO" #xFF8E)
+    ("HALFWIDTH KATAKANA LETTER MA" #xFF8F)
+    ("HALFWIDTH KATAKANA LETTER MI" #xFF90)
+    ("HALFWIDTH KATAKANA LETTER MU" #xFF91)
+    ("HALFWIDTH KATAKANA LETTER ME" #xFF92)
+    ("HALFWIDTH KATAKANA LETTER MO" #xFF93)
+    ("HALFWIDTH KATAKANA LETTER YA" #xFF94)
+    ("HALFWIDTH KATAKANA LETTER YU" #xFF95)
+    ("HALFWIDTH KATAKANA LETTER YO" #xFF96)
+    ("HALFWIDTH KATAKANA LETTER RA" #xFF97)
+    ("HALFWIDTH KATAKANA LETTER RI" #xFF98)
+    ("HALFWIDTH KATAKANA LETTER RU" #xFF99)
+    ("HALFWIDTH KATAKANA LETTER RE" #xFF9A)
+    ("HALFWIDTH KATAKANA LETTER RO" #xFF9B)
+    ("HALFWIDTH KATAKANA LETTER WA" #xFF9C)
+    ("HALFWIDTH KATAKANA LETTER N" #xFF9D)
+    ("HALFWIDTH KATAKANA VOICED SOUND MARK" #xFF9E)
+    ("HALFWIDTH KATAKANA SEMI-VOICED SOUND MARK" #xFF9F)
+    ("HALFWIDTH HANGUL FILLER" #xFFA0)
+    ("HALFWIDTH HANGUL LETTER KIYEOK" #xFFA1)
+    ("HALFWIDTH HANGUL LETTER SSANGKIYEOK" #xFFA2)
+    ("HALFWIDTH HANGUL LETTER KIYEOK-SIOS" #xFFA3)
+    ("HALFWIDTH HANGUL LETTER NIEUN" #xFFA4)
+    ("HALFWIDTH HANGUL LETTER NIEUN-CIEUC" #xFFA5)
+    ("HALFWIDTH HANGUL LETTER NIEUN-HIEUH" #xFFA6)
+    ("HALFWIDTH HANGUL LETTER TIKEUT" #xFFA7)
+    ("HALFWIDTH HANGUL LETTER SSANGTIKEUT" #xFFA8)
+    ("HALFWIDTH HANGUL LETTER RIEUL" #xFFA9)
+    ("HALFWIDTH HANGUL LETTER RIEUL-KIYEOK" #xFFAA)
+    ("HALFWIDTH HANGUL LETTER RIEUL-MIEUM" #xFFAB)
+    ("HALFWIDTH HANGUL LETTER RIEUL-PIEUP" #xFFAC)
+    ("HALFWIDTH HANGUL LETTER RIEUL-SIOS" #xFFAD)
+    ("HALFWIDTH HANGUL LETTER RIEUL-THIEUTH" #xFFAE)
+    ("HALFWIDTH HANGUL LETTER RIEUL-PHIEUPH" #xFFAF)
+    ("HALFWIDTH HANGUL LETTER RIEUL-HIEUH" #xFFB0)
+    ("HALFWIDTH HANGUL LETTER MIEUM" #xFFB1)
+    ("HALFWIDTH HANGUL LETTER PIEUP" #xFFB2)
+    ("HALFWIDTH HANGUL LETTER SSANGPIEUP" #xFFB3)
+    ("HALFWIDTH HANGUL LETTER PIEUP-SIOS" #xFFB4)
+    ("HALFWIDTH HANGUL LETTER SIOS" #xFFB5)
+    ("HALFWIDTH HANGUL LETTER SSANGSIOS" #xFFB6)
+    ("HALFWIDTH HANGUL LETTER IEUNG" #xFFB7)
+    ("HALFWIDTH HANGUL LETTER CIEUC" #xFFB8)
+    ("HALFWIDTH HANGUL LETTER SSANGCIEUC" #xFFB9)
+    ("HALFWIDTH HANGUL LETTER CHIEUCH" #xFFBA)
+    ("HALFWIDTH HANGUL LETTER KHIEUKH" #xFFBB)
+    ("HALFWIDTH HANGUL LETTER THIEUTH" #xFFBC)
+    ("HALFWIDTH HANGUL LETTER PHIEUPH" #xFFBD)
+    ("HALFWIDTH HANGUL LETTER HIEUH" #xFFBE)
+    ("HALFWIDTH HANGUL LETTER A" #xFFC2)
+    ("HALFWIDTH HANGUL LETTER AE" #xFFC3)
+    ("HALFWIDTH HANGUL LETTER YA" #xFFC4)
+    ("HALFWIDTH HANGUL LETTER YAE" #xFFC5)
+    ("HALFWIDTH HANGUL LETTER EO" #xFFC6)
+    ("HALFWIDTH HANGUL LETTER E" #xFFC7)
+    ("HALFWIDTH HANGUL LETTER YEO" #xFFCA)
+    ("HALFWIDTH HANGUL LETTER YE" #xFFCB)
+    ("HALFWIDTH HANGUL LETTER O" #xFFCC)
+    ("HALFWIDTH HANGUL LETTER WA" #xFFCD)
+    ("HALFWIDTH HANGUL LETTER WAE" #xFFCE)
+    ("HALFWIDTH HANGUL LETTER OE" #xFFCF)
+    ("HALFWIDTH HANGUL LETTER YO" #xFFD2)
+    ("HALFWIDTH HANGUL LETTER U" #xFFD3)
+    ("HALFWIDTH HANGUL LETTER WEO" #xFFD4)
+    ("HALFWIDTH HANGUL LETTER WE" #xFFD5)
+    ("HALFWIDTH HANGUL LETTER WI" #xFFD6)
+    ("HALFWIDTH HANGUL LETTER YU" #xFFD7)
+    ("HALFWIDTH HANGUL LETTER EU" #xFFDA)
+    ("HALFWIDTH HANGUL LETTER YI" #xFFDB)
+    ("HALFWIDTH HANGUL LETTER I" #xFFDC)
+    ("FULLWIDTH CENT SIGN" #xFFE0)
+    ("FULLWIDTH POUND SIGN" #xFFE1)
+    ("FULLWIDTH NOT SIGN" #xFFE2)
+    ("FULLWIDTH MACRON" #xFFE3)
+    ("FULLWIDTH BROKEN BAR" #xFFE4)
+    ("FULLWIDTH YEN SIGN" #xFFE5)
+    ("FULLWIDTH WON SIGN" #xFFE6)
+    ("HALFWIDTH FORMS LIGHT VERTICAL" #xFFE8)
+    ("HALFWIDTH LEFTWARDS ARROW" #xFFE9)
+    ("HALFWIDTH UPWARDS ARROW" #xFFEA)
+    ("HALFWIDTH RIGHTWARDS ARROW" #xFFEB)
+    ("HALFWIDTH DOWNWARDS ARROW" #xFFEC)
+    ("HALFWIDTH BLACK SQUARE" #xFFED)
+    ("HALFWIDTH WHITE CIRCLE" #xFFEE)
+    ))
diff --git a/lisp/nxml/char-name/unicode/0FFF0-0FFFF.el b/lisp/nxml/char-name/unicode/0FFF0-0FFFF.el
new file mode 100644
index 00000000000..f381a28e05a
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/0FFF0-0FFFF.el
@@ -0,0 +1,7 @@
+(nxml-define-char-name-set 'specials
+  '(("INTERLINEAR ANNOTATION ANCHOR" #xFFF9)
+    ("INTERLINEAR ANNOTATION SEPARATOR" #xFFFA)
+    ("INTERLINEAR ANNOTATION TERMINATOR" #xFFFB)
+    ("OBJECT REPLACEMENT CHARACTER" #xFFFC)
+    ("REPLACEMENT CHARACTER" #xFFFD)
+    ))
diff --git a/lisp/nxml/char-name/unicode/10300-1032F.el b/lisp/nxml/char-name/unicode/10300-1032F.el
new file mode 100644
index 00000000000..fbb5cb8f253
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/10300-1032F.el
@@ -0,0 +1,37 @@
+(nxml-define-char-name-set 'old-italic
+  '(("OLD ITALIC LETTER A" #x10300)
+    ("OLD ITALIC LETTER BE" #x10301)
+    ("OLD ITALIC LETTER KE" #x10302)
+    ("OLD ITALIC LETTER DE" #x10303)
+    ("OLD ITALIC LETTER E" #x10304)
+    ("OLD ITALIC LETTER VE" #x10305)
+    ("OLD ITALIC LETTER ZE" #x10306)
+    ("OLD ITALIC LETTER HE" #x10307)
+    ("OLD ITALIC LETTER THE" #x10308)
+    ("OLD ITALIC LETTER I" #x10309)
+    ("OLD ITALIC LETTER KA" #x1030A)
+    ("OLD ITALIC LETTER EL" #x1030B)
+    ("OLD ITALIC LETTER EM" #x1030C)
+    ("OLD ITALIC LETTER EN" #x1030D)
+    ("OLD ITALIC LETTER ESH" #x1030E)
+    ("OLD ITALIC LETTER O" #x1030F)
+    ("OLD ITALIC LETTER PE" #x10310)
+    ("OLD ITALIC LETTER SHE" #x10311)
+    ("OLD ITALIC LETTER KU" #x10312)
+    ("OLD ITALIC LETTER ER" #x10313)
+    ("OLD ITALIC LETTER ES" #x10314)
+    ("OLD ITALIC LETTER TE" #x10315)
+    ("OLD ITALIC LETTER U" #x10316)
+    ("OLD ITALIC LETTER EKS" #x10317)
+    ("OLD ITALIC LETTER PHE" #x10318)
+    ("OLD ITALIC LETTER KHE" #x10319)
+    ("OLD ITALIC LETTER EF" #x1031A)
+    ("OLD ITALIC LETTER ERS" #x1031B)
+    ("OLD ITALIC LETTER CHE" #x1031C)
+    ("OLD ITALIC LETTER II" #x1031D)
+    ("OLD ITALIC LETTER UU" #x1031E)
+    ("OLD ITALIC NUMERAL ONE" #x10320)
+    ("OLD ITALIC NUMERAL FIVE" #x10321)
+    ("OLD ITALIC NUMERAL TEN" #x10322)
+    ("OLD ITALIC NUMERAL FIFTY" #x10323)
+    ))
diff --git a/lisp/nxml/char-name/unicode/10330-1034F.el b/lisp/nxml/char-name/unicode/10330-1034F.el
new file mode 100644
index 00000000000..38ba2988a4c
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/10330-1034F.el
@@ -0,0 +1,29 @@
+(nxml-define-char-name-set 'gothic
+  '(("GOTHIC LETTER AHSA" #x10330)
+    ("GOTHIC LETTER BAIRKAN" #x10331)
+    ("GOTHIC LETTER GIBA" #x10332)
+    ("GOTHIC LETTER DAGS" #x10333)
+    ("GOTHIC LETTER AIHVUS" #x10334)
+    ("GOTHIC LETTER QAIRTHRA" #x10335)
+    ("GOTHIC LETTER IUJA" #x10336)
+    ("GOTHIC LETTER HAGL" #x10337)
+    ("GOTHIC LETTER THIUTH" #x10338)
+    ("GOTHIC LETTER EIS" #x10339)
+    ("GOTHIC LETTER KUSMA" #x1033A)
+    ("GOTHIC LETTER LAGUS" #x1033B)
+    ("GOTHIC LETTER MANNA" #x1033C)
+    ("GOTHIC LETTER NAUTHS" #x1033D)
+    ("GOTHIC LETTER JER" #x1033E)
+    ("GOTHIC LETTER URUS" #x1033F)
+    ("GOTHIC LETTER PAIRTHRA" #x10340)
+    ("GOTHIC LETTER NINETY" #x10341)
+    ("GOTHIC LETTER RAIDA" #x10342)
+    ("GOTHIC LETTER SAUIL" #x10343)
+    ("GOTHIC LETTER TEIWS" #x10344)
+    ("GOTHIC LETTER WINJA" #x10345)
+    ("GOTHIC LETTER FAIHU" #x10346)
+    ("GOTHIC LETTER IGGWS" #x10347)
+    ("GOTHIC LETTER HWAIR" #x10348)
+    ("GOTHIC LETTER OTHAL" #x10349)
+    ("GOTHIC LETTER NINE HUNDRED" #x1034A)
+    ))
diff --git a/lisp/nxml/char-name/unicode/10400-1044F.el b/lisp/nxml/char-name/unicode/10400-1044F.el
new file mode 100644
index 00000000000..1637cf666bf
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/10400-1044F.el
@@ -0,0 +1,78 @@
+(nxml-define-char-name-set 'deseret
+  '(("DESERET CAPITAL LETTER LONG I" #x10400)
+    ("DESERET CAPITAL LETTER LONG E" #x10401)
+    ("DESERET CAPITAL LETTER LONG A" #x10402)
+    ("DESERET CAPITAL LETTER LONG AH" #x10403)
+    ("DESERET CAPITAL LETTER LONG O" #x10404)
+    ("DESERET CAPITAL LETTER LONG OO" #x10405)
+    ("DESERET CAPITAL LETTER SHORT I" #x10406)
+    ("DESERET CAPITAL LETTER SHORT E" #x10407)
+    ("DESERET CAPITAL LETTER SHORT A" #x10408)
+    ("DESERET CAPITAL LETTER SHORT AH" #x10409)
+    ("DESERET CAPITAL LETTER SHORT O" #x1040A)
+    ("DESERET CAPITAL LETTER SHORT OO" #x1040B)
+    ("DESERET CAPITAL LETTER AY" #x1040C)
+    ("DESERET CAPITAL LETTER OW" #x1040D)
+    ("DESERET CAPITAL LETTER WU" #x1040E)
+    ("DESERET CAPITAL LETTER YEE" #x1040F)
+    ("DESERET CAPITAL LETTER H" #x10410)
+    ("DESERET CAPITAL LETTER PEE" #x10411)
+    ("DESERET CAPITAL LETTER BEE" #x10412)
+    ("DESERET CAPITAL LETTER TEE" #x10413)
+    ("DESERET CAPITAL LETTER DEE" #x10414)
+    ("DESERET CAPITAL LETTER CHEE" #x10415)
+    ("DESERET CAPITAL LETTER JEE" #x10416)
+    ("DESERET CAPITAL LETTER KAY" #x10417)
+    ("DESERET CAPITAL LETTER GAY" #x10418)
+    ("DESERET CAPITAL LETTER EF" #x10419)
+    ("DESERET CAPITAL LETTER VEE" #x1041A)
+    ("DESERET CAPITAL LETTER ETH" #x1041B)
+    ("DESERET CAPITAL LETTER THEE" #x1041C)
+    ("DESERET CAPITAL LETTER ES" #x1041D)
+    ("DESERET CAPITAL LETTER ZEE" #x1041E)
+    ("DESERET CAPITAL LETTER ESH" #x1041F)
+    ("DESERET CAPITAL LETTER ZHEE" #x10420)
+    ("DESERET CAPITAL LETTER ER" #x10421)
+    ("DESERET CAPITAL LETTER EL" #x10422)
+    ("DESERET CAPITAL LETTER EM" #x10423)
+    ("DESERET CAPITAL LETTER EN" #x10424)
+    ("DESERET CAPITAL LETTER ENG" #x10425)
+    ("DESERET SMALL LETTER LONG I" #x10428)
+    ("DESERET SMALL LETTER LONG E" #x10429)
+    ("DESERET SMALL LETTER LONG A" #x1042A)
+    ("DESERET SMALL LETTER LONG AH" #x1042B)
+    ("DESERET SMALL LETTER LONG O" #x1042C)
+    ("DESERET SMALL LETTER LONG OO" #x1042D)
+    ("DESERET SMALL LETTER SHORT I" #x1042E)
+    ("DESERET SMALL LETTER SHORT E" #x1042F)
+    ("DESERET SMALL LETTER SHORT A" #x10430)
+    ("DESERET SMALL LETTER SHORT AH" #x10431)
+    ("DESERET SMALL LETTER SHORT O" #x10432)
+    ("DESERET SMALL LETTER SHORT OO" #x10433)
+    ("DESERET SMALL LETTER AY" #x10434)
+    ("DESERET SMALL LETTER OW" #x10435)
+    ("DESERET SMALL LETTER WU" #x10436)
+    ("DESERET SMALL LETTER YEE" #x10437)
+    ("DESERET SMALL LETTER H" #x10438)
+    ("DESERET SMALL LETTER PEE" #x10439)
+    ("DESERET SMALL LETTER BEE" #x1043A)
+    ("DESERET SMALL LETTER TEE" #x1043B)
+    ("DESERET SMALL LETTER DEE" #x1043C)
+    ("DESERET SMALL LETTER CHEE" #x1043D)
+    ("DESERET SMALL LETTER JEE" #x1043E)
+    ("DESERET SMALL LETTER KAY" #x1043F)
+    ("DESERET SMALL LETTER GAY" #x10440)
+    ("DESERET SMALL LETTER EF" #x10441)
+    ("DESERET SMALL LETTER VEE" #x10442)
+    ("DESERET SMALL LETTER ETH" #x10443)
+    ("DESERET SMALL LETTER THEE" #x10444)
+    ("DESERET SMALL LETTER ES" #x10445)
+    ("DESERET SMALL LETTER ZEE" #x10446)
+    ("DESERET SMALL LETTER ESH" #x10447)
+    ("DESERET SMALL LETTER ZHEE" #x10448)
+    ("DESERET SMALL LETTER ER" #x10449)
+    ("DESERET SMALL LETTER EL" #x1044A)
+    ("DESERET SMALL LETTER EM" #x1044B)
+    ("DESERET SMALL LETTER EN" #x1044C)
+    ("DESERET SMALL LETTER ENG" #x1044D)
+    ))
diff --git a/lisp/nxml/char-name/unicode/1D000-1D0FF.el b/lisp/nxml/char-name/unicode/1D000-1D0FF.el
new file mode 100644
index 00000000000..f1a6f36dff7
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/1D000-1D0FF.el
@@ -0,0 +1,248 @@
+(nxml-define-char-name-set 'byzantine-musical-symbols
+  '(("BYZANTINE MUSICAL SYMBOL PSILI" #x1D000)
+    ("BYZANTINE MUSICAL SYMBOL DASEIA" #x1D001)
+    ("BYZANTINE MUSICAL SYMBOL PERISPOMENI" #x1D002)
+    ("BYZANTINE MUSICAL SYMBOL OXEIA EKFONITIKON" #x1D003)
+    ("BYZANTINE MUSICAL SYMBOL OXEIA DIPLI" #x1D004)
+    ("BYZANTINE MUSICAL SYMBOL VAREIA EKFONITIKON" #x1D005)
+    ("BYZANTINE MUSICAL SYMBOL VAREIA DIPLI" #x1D006)
+    ("BYZANTINE MUSICAL SYMBOL KATHISTI" #x1D007)
+    ("BYZANTINE MUSICAL SYMBOL SYRMATIKI" #x1D008)
+    ("BYZANTINE MUSICAL SYMBOL PARAKLITIKI" #x1D009)
+    ("BYZANTINE MUSICAL SYMBOL YPOKRISIS" #x1D00A)
+    ("BYZANTINE MUSICAL SYMBOL YPOKRISIS DIPLI" #x1D00B)
+    ("BYZANTINE MUSICAL SYMBOL KREMASTI" #x1D00C)
+    ("BYZANTINE MUSICAL SYMBOL APESO EKFONITIKON" #x1D00D)
+    ("BYZANTINE MUSICAL SYMBOL EXO EKFONITIKON" #x1D00E)
+    ("BYZANTINE MUSICAL SYMBOL TELEIA" #x1D00F)
+    ("BYZANTINE MUSICAL SYMBOL KENTIMATA" #x1D010)
+    ("BYZANTINE MUSICAL SYMBOL APOSTROFOS" #x1D011)
+    ("BYZANTINE MUSICAL SYMBOL APOSTROFOS DIPLI" #x1D012)
+    ("BYZANTINE MUSICAL SYMBOL SYNEVMA" #x1D013)
+    ("BYZANTINE MUSICAL SYMBOL THITA" #x1D014)
+    ("BYZANTINE MUSICAL SYMBOL OLIGON ARCHAION" #x1D015)
+    ("BYZANTINE MUSICAL SYMBOL GORGON ARCHAION" #x1D016)
+    ("BYZANTINE MUSICAL SYMBOL PSILON" #x1D017)
+    ("BYZANTINE MUSICAL SYMBOL CHAMILON" #x1D018)
+    ("BYZANTINE MUSICAL SYMBOL VATHY" #x1D019)
+    ("BYZANTINE MUSICAL SYMBOL ISON ARCHAION" #x1D01A)
+    ("BYZANTINE MUSICAL SYMBOL KENTIMA ARCHAION" #x1D01B)
+    ("BYZANTINE MUSICAL SYMBOL KENTIMATA ARCHAION" #x1D01C)
+    ("BYZANTINE MUSICAL SYMBOL SAXIMATA" #x1D01D)
+    ("BYZANTINE MUSICAL SYMBOL PARICHON" #x1D01E)
+    ("BYZANTINE MUSICAL SYMBOL STAVROS APODEXIA" #x1D01F)
+    ("BYZANTINE MUSICAL SYMBOL OXEIAI ARCHAION" #x1D020)
+    ("BYZANTINE MUSICAL SYMBOL VAREIAI ARCHAION" #x1D021)
+    ("BYZANTINE MUSICAL SYMBOL APODERMA ARCHAION" #x1D022)
+    ("BYZANTINE MUSICAL SYMBOL APOTHEMA" #x1D023)
+    ("BYZANTINE MUSICAL SYMBOL KLASMA" #x1D024)
+    ("BYZANTINE MUSICAL SYMBOL REVMA" #x1D025)
+    ("BYZANTINE MUSICAL SYMBOL PIASMA ARCHAION" #x1D026)
+    ("BYZANTINE MUSICAL SYMBOL TINAGMA" #x1D027)
+    ("BYZANTINE MUSICAL SYMBOL ANATRICHISMA" #x1D028)
+    ("BYZANTINE MUSICAL SYMBOL SEISMA" #x1D029)
+    ("BYZANTINE MUSICAL SYMBOL SYNAGMA ARCHAION" #x1D02A)
+    ("BYZANTINE MUSICAL SYMBOL SYNAGMA META STAVROU" #x1D02B)
+    ("BYZANTINE MUSICAL SYMBOL OYRANISMA ARCHAION" #x1D02C)
+    ("BYZANTINE MUSICAL SYMBOL THEMA" #x1D02D)
+    ("BYZANTINE MUSICAL SYMBOL LEMOI" #x1D02E)
+    ("BYZANTINE MUSICAL SYMBOL DYO" #x1D02F)
+    ("BYZANTINE MUSICAL SYMBOL TRIA" #x1D030)
+    ("BYZANTINE MUSICAL SYMBOL TESSERA" #x1D031)
+    ("BYZANTINE MUSICAL SYMBOL KRATIMATA" #x1D032)
+    ("BYZANTINE MUSICAL SYMBOL APESO EXO NEO" #x1D033)
+    ("BYZANTINE MUSICAL SYMBOL FTHORA ARCHAION" #x1D034)
+    ("BYZANTINE MUSICAL SYMBOL IMIFTHORA" #x1D035)
+    ("BYZANTINE MUSICAL SYMBOL TROMIKON ARCHAION" #x1D036)
+    ("BYZANTINE MUSICAL SYMBOL KATAVA TROMIKON" #x1D037)
+    ("BYZANTINE MUSICAL SYMBOL PELASTON" #x1D038)
+    ("BYZANTINE MUSICAL SYMBOL PSIFISTON" #x1D039)
+    ("BYZANTINE MUSICAL SYMBOL KONTEVMA" #x1D03A)
+    ("BYZANTINE MUSICAL SYMBOL CHOREVMA ARCHAION" #x1D03B)
+    ("BYZANTINE MUSICAL SYMBOL RAPISMA" #x1D03C)
+    ("BYZANTINE MUSICAL SYMBOL PARAKALESMA ARCHAION" #x1D03D)
+    ("BYZANTINE MUSICAL SYMBOL PARAKLITIKI ARCHAION" #x1D03E)
+    ("BYZANTINE MUSICAL SYMBOL ICHADIN" #x1D03F)
+    ("BYZANTINE MUSICAL SYMBOL NANA" #x1D040)
+    ("BYZANTINE MUSICAL SYMBOL PETASMA" #x1D041)
+    ("BYZANTINE MUSICAL SYMBOL KONTEVMA ALLO" #x1D042)
+    ("BYZANTINE MUSICAL SYMBOL TROMIKON ALLO" #x1D043)
+    ("BYZANTINE MUSICAL SYMBOL STRAGGISMATA" #x1D044)
+    ("BYZANTINE MUSICAL SYMBOL GRONTHISMATA" #x1D045)
+    ("BYZANTINE MUSICAL SYMBOL ISON NEO" #x1D046)
+    ("BYZANTINE MUSICAL SYMBOL OLIGON NEO" #x1D047)
+    ("BYZANTINE MUSICAL SYMBOL OXEIA NEO" #x1D048)
+    ("BYZANTINE MUSICAL SYMBOL PETASTI" #x1D049)
+    ("BYZANTINE MUSICAL SYMBOL KOUFISMA" #x1D04A)
+    ("BYZANTINE MUSICAL SYMBOL PETASTOKOUFISMA" #x1D04B)
+    ("BYZANTINE MUSICAL SYMBOL KRATIMOKOUFISMA" #x1D04C)
+    ("BYZANTINE MUSICAL SYMBOL PELASTON NEO" #x1D04D)
+    ("BYZANTINE MUSICAL SYMBOL KENTIMATA NEO ANO" #x1D04E)
+    ("BYZANTINE MUSICAL SYMBOL KENTIMA NEO ANO" #x1D04F)
+    ("BYZANTINE MUSICAL SYMBOL YPSILI" #x1D050)
+    ("BYZANTINE MUSICAL SYMBOL APOSTROFOS NEO" #x1D051)
+    ("BYZANTINE MUSICAL SYMBOL APOSTROFOI SYNDESMOS NEO" #x1D052)
+    ("BYZANTINE MUSICAL SYMBOL YPORROI" #x1D053)
+    ("BYZANTINE MUSICAL SYMBOL KRATIMOYPORROON" #x1D054)
+    ("BYZANTINE MUSICAL SYMBOL ELAFRON" #x1D055)
+    ("BYZANTINE MUSICAL SYMBOL CHAMILI" #x1D056)
+    ("BYZANTINE MUSICAL SYMBOL MIKRON ISON" #x1D057)
+    ("BYZANTINE MUSICAL SYMBOL VAREIA NEO" #x1D058)
+    ("BYZANTINE MUSICAL SYMBOL PIASMA NEO" #x1D059)
+    ("BYZANTINE MUSICAL SYMBOL PSIFISTON NEO" #x1D05A)
+    ("BYZANTINE MUSICAL SYMBOL OMALON" #x1D05B)
+    ("BYZANTINE MUSICAL SYMBOL ANTIKENOMA" #x1D05C)
+    ("BYZANTINE MUSICAL SYMBOL LYGISMA" #x1D05D)
+    ("BYZANTINE MUSICAL SYMBOL PARAKLITIKI NEO" #x1D05E)
+    ("BYZANTINE MUSICAL SYMBOL PARAKALESMA NEO" #x1D05F)
+    ("BYZANTINE MUSICAL SYMBOL ETERON PARAKALESMA" #x1D060)
+    ("BYZANTINE MUSICAL SYMBOL KYLISMA" #x1D061)
+    ("BYZANTINE MUSICAL SYMBOL ANTIKENOKYLISMA" #x1D062)
+    ("BYZANTINE MUSICAL SYMBOL TROMIKON NEO" #x1D063)
+    ("BYZANTINE MUSICAL SYMBOL EKSTREPTON" #x1D064)
+    ("BYZANTINE MUSICAL SYMBOL SYNAGMA NEO" #x1D065)
+    ("BYZANTINE MUSICAL SYMBOL SYRMA" #x1D066)
+    ("BYZANTINE MUSICAL SYMBOL CHOREVMA NEO" #x1D067)
+    ("BYZANTINE MUSICAL SYMBOL EPEGERMA" #x1D068)
+    ("BYZANTINE MUSICAL SYMBOL SEISMA NEO" #x1D069)
+    ("BYZANTINE MUSICAL SYMBOL XIRON KLASMA" #x1D06A)
+    ("BYZANTINE MUSICAL SYMBOL TROMIKOPSIFISTON" #x1D06B)
+    ("BYZANTINE MUSICAL SYMBOL PSIFISTOLYGISMA" #x1D06C)
+    ("BYZANTINE MUSICAL SYMBOL TROMIKOLYGISMA" #x1D06D)
+    ("BYZANTINE MUSICAL SYMBOL TROMIKOPARAKALESMA" #x1D06E)
+    ("BYZANTINE MUSICAL SYMBOL PSIFISTOPARAKALESMA" #x1D06F)
+    ("BYZANTINE MUSICAL SYMBOL TROMIKOSYNAGMA" #x1D070)
+    ("BYZANTINE MUSICAL SYMBOL PSIFISTOSYNAGMA" #x1D071)
+    ("BYZANTINE MUSICAL SYMBOL GORGOSYNTHETON" #x1D072)
+    ("BYZANTINE MUSICAL SYMBOL ARGOSYNTHETON" #x1D073)
+    ("BYZANTINE MUSICAL SYMBOL ETERON ARGOSYNTHETON" #x1D074)
+    ("BYZANTINE MUSICAL SYMBOL OYRANISMA NEO" #x1D075)
+    ("BYZANTINE MUSICAL SYMBOL THEMATISMOS ESO" #x1D076)
+    ("BYZANTINE MUSICAL SYMBOL THEMATISMOS EXO" #x1D077)
+    ("BYZANTINE MUSICAL SYMBOL THEMA APLOUN" #x1D078)
+    ("BYZANTINE MUSICAL SYMBOL THES KAI APOTHES" #x1D079)
+    ("BYZANTINE MUSICAL SYMBOL KATAVASMA" #x1D07A)
+    ("BYZANTINE MUSICAL SYMBOL ENDOFONON" #x1D07B)
+    ("BYZANTINE MUSICAL SYMBOL YFEN KATO" #x1D07C)
+    ("BYZANTINE MUSICAL SYMBOL YFEN ANO" #x1D07D)
+    ("BYZANTINE MUSICAL SYMBOL STAVROS" #x1D07E)
+    ("BYZANTINE MUSICAL SYMBOL KLASMA ANO" #x1D07F)
+    ("BYZANTINE MUSICAL SYMBOL DIPLI ARCHAION" #x1D080)
+    ("BYZANTINE MUSICAL SYMBOL KRATIMA ARCHAION" #x1D081)
+    ("BYZANTINE MUSICAL SYMBOL KRATIMA ALLO" #x1D082)
+    ("BYZANTINE MUSICAL SYMBOL KRATIMA NEO" #x1D083)
+    ("BYZANTINE MUSICAL SYMBOL APODERMA NEO" #x1D084)
+    ("BYZANTINE MUSICAL SYMBOL APLI" #x1D085)
+    ("BYZANTINE MUSICAL SYMBOL DIPLI" #x1D086)
+    ("BYZANTINE MUSICAL SYMBOL TRIPLI" #x1D087)
+    ("BYZANTINE MUSICAL SYMBOL TETRAPLI" #x1D088)
+    ("BYZANTINE MUSICAL SYMBOL KORONIS" #x1D089)
+    ("BYZANTINE MUSICAL SYMBOL LEIMMA ENOS CHRONOU" #x1D08A)
+    ("BYZANTINE MUSICAL SYMBOL LEIMMA DYO CHRONON" #x1D08B)
+    ("BYZANTINE MUSICAL SYMBOL LEIMMA TRION CHRONON" #x1D08C)
+    ("BYZANTINE MUSICAL SYMBOL LEIMMA TESSARON CHRONON" #x1D08D)
+    ("BYZANTINE MUSICAL SYMBOL LEIMMA IMISEOS CHRONOU" #x1D08E)
+    ("BYZANTINE MUSICAL SYMBOL GORGON NEO ANO" #x1D08F)
+    ("BYZANTINE MUSICAL SYMBOL GORGON PARESTIGMENON ARISTERA" #x1D090)
+    ("BYZANTINE MUSICAL SYMBOL GORGON PARESTIGMENON DEXIA" #x1D091)
+    ("BYZANTINE MUSICAL SYMBOL DIGORGON" #x1D092)
+    ("BYZANTINE MUSICAL SYMBOL DIGORGON PARESTIGMENON ARISTERA KATO" #x1D093)
+    ("BYZANTINE MUSICAL SYMBOL DIGORGON PARESTIGMENON ARISTERA ANO" #x1D094)
+    ("BYZANTINE MUSICAL SYMBOL DIGORGON PARESTIGMENON DEXIA" #x1D095)
+    ("BYZANTINE MUSICAL SYMBOL TRIGORGON" #x1D096)
+    ("BYZANTINE MUSICAL SYMBOL ARGON" #x1D097)
+    ("BYZANTINE MUSICAL SYMBOL IMIDIARGON" #x1D098)
+    ("BYZANTINE MUSICAL SYMBOL DIARGON" #x1D099)
+    ("BYZANTINE MUSICAL SYMBOL AGOGI POLI ARGI" #x1D09A)
+    ("BYZANTINE MUSICAL SYMBOL AGOGI ARGOTERI" #x1D09B)
+    ("BYZANTINE MUSICAL SYMBOL AGOGI ARGI" #x1D09C)
+    ("BYZANTINE MUSICAL SYMBOL AGOGI METRIA" #x1D09D)
+    ("BYZANTINE MUSICAL SYMBOL AGOGI MESI" #x1D09E)
+    ("BYZANTINE MUSICAL SYMBOL AGOGI GORGI" #x1D09F)
+    ("BYZANTINE MUSICAL SYMBOL AGOGI GORGOTERI" #x1D0A0)
+    ("BYZANTINE MUSICAL SYMBOL AGOGI POLI GORGI" #x1D0A1)
+    ("BYZANTINE MUSICAL SYMBOL MARTYRIA PROTOS ICHOS" #x1D0A2)
+    ("BYZANTINE MUSICAL SYMBOL MARTYRIA ALLI PROTOS ICHOS" #x1D0A3)
+    ("BYZANTINE MUSICAL SYMBOL MARTYRIA DEYTEROS ICHOS" #x1D0A4)
+    ("BYZANTINE MUSICAL SYMBOL MARTYRIA ALLI DEYTEROS ICHOS" #x1D0A5)
+    ("BYZANTINE MUSICAL SYMBOL MARTYRIA TRITOS ICHOS" #x1D0A6)
+    ("BYZANTINE MUSICAL SYMBOL MARTYRIA TRIFONIAS" #x1D0A7)
+    ("BYZANTINE MUSICAL SYMBOL MARTYRIA TETARTOS ICHOS" #x1D0A8)
+    ("BYZANTINE MUSICAL SYMBOL MARTYRIA TETARTOS LEGETOS ICHOS" #x1D0A9)
+    ("BYZANTINE MUSICAL SYMBOL MARTYRIA LEGETOS ICHOS" #x1D0AA)
+    ("BYZANTINE MUSICAL SYMBOL MARTYRIA PLAGIOS ICHOS" #x1D0AB)
+    ("BYZANTINE MUSICAL SYMBOL ISAKIA TELOUS ICHIMATOS" #x1D0AC)
+    ("BYZANTINE MUSICAL SYMBOL APOSTROFOI TELOUS ICHIMATOS" #x1D0AD)
+    ("BYZANTINE MUSICAL SYMBOL FANEROSIS TETRAFONIAS" #x1D0AE)
+    ("BYZANTINE MUSICAL SYMBOL FANEROSIS MONOFONIAS" #x1D0AF)
+    ("BYZANTINE MUSICAL SYMBOL FANEROSIS DIFONIAS" #x1D0B0)
+    ("BYZANTINE MUSICAL SYMBOL MARTYRIA VARYS ICHOS" #x1D0B1)
+    ("BYZANTINE MUSICAL SYMBOL MARTYRIA PROTOVARYS ICHOS" #x1D0B2)
+    ("BYZANTINE MUSICAL SYMBOL MARTYRIA PLAGIOS TETARTOS ICHOS" #x1D0B3)
+    ("BYZANTINE MUSICAL SYMBOL GORTHMIKON N APLOUN" #x1D0B4)
+    ("BYZANTINE MUSICAL SYMBOL GORTHMIKON N DIPLOUN" #x1D0B5)
+    ("BYZANTINE MUSICAL SYMBOL ENARXIS KAI FTHORA VOU" #x1D0B6)
+    ("BYZANTINE MUSICAL SYMBOL IMIFONON" #x1D0B7)
+    ("BYZANTINE MUSICAL SYMBOL IMIFTHORON" #x1D0B8)
+    ("BYZANTINE MUSICAL SYMBOL FTHORA ARCHAION DEYTEROU ICHOU" #x1D0B9)
+    ("BYZANTINE MUSICAL SYMBOL FTHORA DIATONIKI PA" #x1D0BA)
+    ("BYZANTINE MUSICAL SYMBOL FTHORA DIATONIKI NANA" #x1D0BB)
+    ("BYZANTINE MUSICAL SYMBOL FTHORA NAOS ICHOS" #x1D0BC)
+    ("BYZANTINE MUSICAL SYMBOL FTHORA DIATONIKI DI" #x1D0BD)
+    ("BYZANTINE MUSICAL SYMBOL FTHORA SKLIRON DIATONON DI" #x1D0BE)
+    ("BYZANTINE MUSICAL SYMBOL FTHORA DIATONIKI KE" #x1D0BF)
+    ("BYZANTINE MUSICAL SYMBOL FTHORA DIATONIKI ZO" #x1D0C0)
+    ("BYZANTINE MUSICAL SYMBOL FTHORA DIATONIKI NI KATO" #x1D0C1)
+    ("BYZANTINE MUSICAL SYMBOL FTHORA DIATONIKI NI ANO" #x1D0C2)
+    ("BYZANTINE MUSICAL SYMBOL FTHORA MALAKON CHROMA DIFONIAS" #x1D0C3)
+    ("BYZANTINE MUSICAL SYMBOL FTHORA MALAKON CHROMA MONOFONIAS" #x1D0C4)
+    ("BYZANTINE MUSICAL SYMBOL FHTORA SKLIRON CHROMA VASIS" #x1D0C5)
+    ("BYZANTINE MUSICAL SYMBOL FTHORA SKLIRON CHROMA SYNAFI" #x1D0C6)
+    ("BYZANTINE MUSICAL SYMBOL FTHORA NENANO" #x1D0C7)
+    ("BYZANTINE MUSICAL SYMBOL CHROA ZYGOS" #x1D0C8)
+    ("BYZANTINE MUSICAL SYMBOL CHROA KLITON" #x1D0C9)
+    ("BYZANTINE MUSICAL SYMBOL CHROA SPATHI" #x1D0CA)
+    ("BYZANTINE MUSICAL SYMBOL FTHORA I YFESIS TETARTIMORION" #x1D0CB)
+    ("BYZANTINE MUSICAL SYMBOL FTHORA ENARMONIOS ANTIFONIA" #x1D0CC)
+    ("BYZANTINE MUSICAL SYMBOL YFESIS TRITIMORION" #x1D0CD)
+    ("BYZANTINE MUSICAL SYMBOL DIESIS TRITIMORION" #x1D0CE)
+    ("BYZANTINE MUSICAL SYMBOL DIESIS TETARTIMORION" #x1D0CF)
+    ("BYZANTINE MUSICAL SYMBOL DIESIS APLI DYO DODEKATA" #x1D0D0)
+    ("BYZANTINE MUSICAL SYMBOL DIESIS MONOGRAMMOS TESSERA DODEKATA" #x1D0D1)
+    ("BYZANTINE MUSICAL SYMBOL DIESIS DIGRAMMOS EX DODEKATA" #x1D0D2)
+    ("BYZANTINE MUSICAL SYMBOL DIESIS TRIGRAMMOS OKTO DODEKATA" #x1D0D3)
+    ("BYZANTINE MUSICAL SYMBOL YFESIS APLI DYO DODEKATA" #x1D0D4)
+    ("BYZANTINE MUSICAL SYMBOL YFESIS MONOGRAMMOS TESSERA DODEKATA" #x1D0D5)
+    ("BYZANTINE MUSICAL SYMBOL YFESIS DIGRAMMOS EX DODEKATA" #x1D0D6)
+    ("BYZANTINE MUSICAL SYMBOL YFESIS TRIGRAMMOS OKTO DODEKATA" #x1D0D7)
+    ("BYZANTINE MUSICAL SYMBOL GENIKI DIESIS" #x1D0D8)
+    ("BYZANTINE MUSICAL SYMBOL GENIKI YFESIS" #x1D0D9)
+    ("BYZANTINE MUSICAL SYMBOL DIASTOLI APLI MIKRI" #x1D0DA)
+    ("BYZANTINE MUSICAL SYMBOL DIASTOLI APLI MEGALI" #x1D0DB)
+    ("BYZANTINE MUSICAL SYMBOL DIASTOLI DIPLI" #x1D0DC)
+    ("BYZANTINE MUSICAL SYMBOL DIASTOLI THESEOS" #x1D0DD)
+    ("BYZANTINE MUSICAL SYMBOL SIMANSIS THESEOS" #x1D0DE)
+    ("BYZANTINE MUSICAL SYMBOL SIMANSIS THESEOS DISIMOU" #x1D0DF)
+    ("BYZANTINE MUSICAL SYMBOL SIMANSIS THESEOS TRISIMOU" #x1D0E0)
+    ("BYZANTINE MUSICAL SYMBOL SIMANSIS THESEOS TETRASIMOU" #x1D0E1)
+    ("BYZANTINE MUSICAL SYMBOL SIMANSIS ARSEOS" #x1D0E2)
+    ("BYZANTINE MUSICAL SYMBOL SIMANSIS ARSEOS DISIMOU" #x1D0E3)
+    ("BYZANTINE MUSICAL SYMBOL SIMANSIS ARSEOS TRISIMOU" #x1D0E4)
+    ("BYZANTINE MUSICAL SYMBOL SIMANSIS ARSEOS TETRASIMOU" #x1D0E5)
+    ("BYZANTINE MUSICAL SYMBOL DIGRAMMA GG" #x1D0E6)
+    ("BYZANTINE MUSICAL SYMBOL DIFTOGGOS OU" #x1D0E7)
+    ("BYZANTINE MUSICAL SYMBOL STIGMA" #x1D0E8)
+    ("BYZANTINE MUSICAL SYMBOL ARKTIKO PA" #x1D0E9)
+    ("BYZANTINE MUSICAL SYMBOL ARKTIKO VOU" #x1D0EA)
+    ("BYZANTINE MUSICAL SYMBOL ARKTIKO GA" #x1D0EB)
+    ("BYZANTINE MUSICAL SYMBOL ARKTIKO DI" #x1D0EC)
+    ("BYZANTINE MUSICAL SYMBOL ARKTIKO KE" #x1D0ED)
+    ("BYZANTINE MUSICAL SYMBOL ARKTIKO ZO" #x1D0EE)
+    ("BYZANTINE MUSICAL SYMBOL ARKTIKO NI" #x1D0EF)
+    ("BYZANTINE MUSICAL SYMBOL KENTIMATA NEO MESO" #x1D0F0)
+    ("BYZANTINE MUSICAL SYMBOL KENTIMA NEO MESO" #x1D0F1)
+    ("BYZANTINE MUSICAL SYMBOL KENTIMATA NEO KATO" #x1D0F2)
+    ("BYZANTINE MUSICAL SYMBOL KENTIMA NEO KATO" #x1D0F3)
+    ("BYZANTINE MUSICAL SYMBOL KLASMA KATO" #x1D0F4)
+    ("BYZANTINE MUSICAL SYMBOL GORGON NEO KATO" #x1D0F5)
+    ))
diff --git a/lisp/nxml/char-name/unicode/1D100-1D1FF.el b/lisp/nxml/char-name/unicode/1D100-1D1FF.el
new file mode 100644
index 00000000000..29803dd0a7d
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/1D100-1D1FF.el
@@ -0,0 +1,221 @@
+(nxml-define-char-name-set 'musical-symbols
+  '(("MUSICAL SYMBOL SINGLE BARLINE" #x1D100)
+    ("MUSICAL SYMBOL DOUBLE BARLINE" #x1D101)
+    ("MUSICAL SYMBOL FINAL BARLINE" #x1D102)
+    ("MUSICAL SYMBOL REVERSE FINAL BARLINE" #x1D103)
+    ("MUSICAL SYMBOL DASHED BARLINE" #x1D104)
+    ("MUSICAL SYMBOL SHORT BARLINE" #x1D105)
+    ("MUSICAL SYMBOL LEFT REPEAT SIGN" #x1D106)
+    ("MUSICAL SYMBOL RIGHT REPEAT SIGN" #x1D107)
+    ("MUSICAL SYMBOL REPEAT DOTS" #x1D108)
+    ("MUSICAL SYMBOL DAL SEGNO" #x1D109)
+    ("MUSICAL SYMBOL DA CAPO" #x1D10A)
+    ("MUSICAL SYMBOL SEGNO" #x1D10B)
+    ("MUSICAL SYMBOL CODA" #x1D10C)
+    ("MUSICAL SYMBOL REPEATED FIGURE-1" #x1D10D)
+    ("MUSICAL SYMBOL REPEATED FIGURE-2" #x1D10E)
+    ("MUSICAL SYMBOL REPEATED FIGURE-3" #x1D10F)
+    ("MUSICAL SYMBOL FERMATA" #x1D110)
+    ("MUSICAL SYMBOL FERMATA BELOW" #x1D111)
+    ("MUSICAL SYMBOL BREATH MARK" #x1D112)
+    ("MUSICAL SYMBOL CAESURA" #x1D113)
+    ("MUSICAL SYMBOL BRACE" #x1D114)
+    ("MUSICAL SYMBOL BRACKET" #x1D115)
+    ("MUSICAL SYMBOL ONE-LINE STAFF" #x1D116)
+    ("MUSICAL SYMBOL TWO-LINE STAFF" #x1D117)
+    ("MUSICAL SYMBOL THREE-LINE STAFF" #x1D118)
+    ("MUSICAL SYMBOL FOUR-LINE STAFF" #x1D119)
+    ("MUSICAL SYMBOL FIVE-LINE STAFF" #x1D11A)
+    ("MUSICAL SYMBOL SIX-LINE STAFF" #x1D11B)
+    ("MUSICAL SYMBOL SIX-STRING FRETBOARD" #x1D11C)
+    ("MUSICAL SYMBOL FOUR-STRING FRETBOARD" #x1D11D)
+    ("MUSICAL SYMBOL G CLEF" #x1D11E)
+    ("MUSICAL SYMBOL G CLEF OTTAVA ALTA" #x1D11F)
+    ("MUSICAL SYMBOL G CLEF OTTAVA BASSA" #x1D120)
+    ("MUSICAL SYMBOL C CLEF" #x1D121)
+    ("MUSICAL SYMBOL F CLEF" #x1D122)
+    ("MUSICAL SYMBOL F CLEF OTTAVA ALTA" #x1D123)
+    ("MUSICAL SYMBOL F CLEF OTTAVA BASSA" #x1D124)
+    ("MUSICAL SYMBOL DRUM CLEF-1" #x1D125)
+    ("MUSICAL SYMBOL DRUM CLEF-2" #x1D126)
+    ("MUSICAL SYMBOL DOUBLE SHARP" #x1D12A)
+    ("MUSICAL SYMBOL DOUBLE FLAT" #x1D12B)
+    ("MUSICAL SYMBOL FLAT UP" #x1D12C)
+    ("MUSICAL SYMBOL FLAT DOWN" #x1D12D)
+    ("MUSICAL SYMBOL NATURAL UP" #x1D12E)
+    ("MUSICAL SYMBOL NATURAL DOWN" #x1D12F)
+    ("MUSICAL SYMBOL SHARP UP" #x1D130)
+    ("MUSICAL SYMBOL SHARP DOWN" #x1D131)
+    ("MUSICAL SYMBOL QUARTER TONE SHARP" #x1D132)
+    ("MUSICAL SYMBOL QUARTER TONE FLAT" #x1D133)
+    ("MUSICAL SYMBOL COMMON TIME" #x1D134)
+    ("MUSICAL SYMBOL CUT TIME" #x1D135)
+    ("MUSICAL SYMBOL OTTAVA ALTA" #x1D136)
+    ("MUSICAL SYMBOL OTTAVA BASSA" #x1D137)
+    ("MUSICAL SYMBOL QUINDICESIMA ALTA" #x1D138)
+    ("MUSICAL SYMBOL QUINDICESIMA BASSA" #x1D139)
+    ("MUSICAL SYMBOL MULTI REST" #x1D13A)
+    ("MUSICAL SYMBOL WHOLE REST" #x1D13B)
+    ("MUSICAL SYMBOL HALF REST" #x1D13C)
+    ("MUSICAL SYMBOL QUARTER REST" #x1D13D)
+    ("MUSICAL SYMBOL EIGHTH REST" #x1D13E)
+    ("MUSICAL SYMBOL SIXTEENTH REST" #x1D13F)
+    ("MUSICAL SYMBOL THIRTY-SECOND REST" #x1D140)
+    ("MUSICAL SYMBOL SIXTY-FOURTH REST" #x1D141)
+    ("MUSICAL SYMBOL ONE HUNDRED TWENTY-EIGHTH REST" #x1D142)
+    ("MUSICAL SYMBOL X NOTEHEAD" #x1D143)
+    ("MUSICAL SYMBOL PLUS NOTEHEAD" #x1D144)
+    ("MUSICAL SYMBOL CIRCLE X NOTEHEAD" #x1D145)
+    ("MUSICAL SYMBOL SQUARE NOTEHEAD WHITE" #x1D146)
+    ("MUSICAL SYMBOL SQUARE NOTEHEAD BLACK" #x1D147)
+    ("MUSICAL SYMBOL TRIANGLE NOTEHEAD UP WHITE" #x1D148)
+    ("MUSICAL SYMBOL TRIANGLE NOTEHEAD UP BLACK" #x1D149)
+    ("MUSICAL SYMBOL TRIANGLE NOTEHEAD LEFT WHITE" #x1D14A)
+    ("MUSICAL SYMBOL TRIANGLE NOTEHEAD LEFT BLACK" #x1D14B)
+    ("MUSICAL SYMBOL TRIANGLE NOTEHEAD RIGHT WHITE" #x1D14C)
+    ("MUSICAL SYMBOL TRIANGLE NOTEHEAD RIGHT BLACK" #x1D14D)
+    ("MUSICAL SYMBOL TRIANGLE NOTEHEAD DOWN WHITE" #x1D14E)
+    ("MUSICAL SYMBOL TRIANGLE NOTEHEAD DOWN BLACK" #x1D14F)
+    ("MUSICAL SYMBOL TRIANGLE NOTEHEAD UP RIGHT WHITE" #x1D150)
+    ("MUSICAL SYMBOL TRIANGLE NOTEHEAD UP RIGHT BLACK" #x1D151)
+    ("MUSICAL SYMBOL MOON NOTEHEAD WHITE" #x1D152)
+    ("MUSICAL SYMBOL MOON NOTEHEAD BLACK" #x1D153)
+    ("MUSICAL SYMBOL TRIANGLE-ROUND NOTEHEAD DOWN WHITE" #x1D154)
+    ("MUSICAL SYMBOL TRIANGLE-ROUND NOTEHEAD DOWN BLACK" #x1D155)
+    ("MUSICAL SYMBOL PARENTHESIS NOTEHEAD" #x1D156)
+    ("MUSICAL SYMBOL VOID NOTEHEAD" #x1D157)
+    ("MUSICAL SYMBOL NOTEHEAD BLACK" #x1D158)
+    ("MUSICAL SYMBOL NULL NOTEHEAD" #x1D159)
+    ("MUSICAL SYMBOL CLUSTER NOTEHEAD WHITE" #x1D15A)
+    ("MUSICAL SYMBOL CLUSTER NOTEHEAD BLACK" #x1D15B)
+    ("MUSICAL SYMBOL BREVE" #x1D15C)
+    ("MUSICAL SYMBOL WHOLE NOTE" #x1D15D)
+    ("MUSICAL SYMBOL HALF NOTE" #x1D15E)
+    ("MUSICAL SYMBOL QUARTER NOTE" #x1D15F)
+    ("MUSICAL SYMBOL EIGHTH NOTE" #x1D160)
+    ("MUSICAL SYMBOL SIXTEENTH NOTE" #x1D161)
+    ("MUSICAL SYMBOL THIRTY-SECOND NOTE" #x1D162)
+    ("MUSICAL SYMBOL SIXTY-FOURTH NOTE" #x1D163)
+    ("MUSICAL SYMBOL ONE HUNDRED TWENTY-EIGHTH NOTE" #x1D164)
+    ("MUSICAL SYMBOL COMBINING STEM" #x1D165)
+    ("MUSICAL SYMBOL COMBINING SPRECHGESANG STEM" #x1D166)
+    ("MUSICAL SYMBOL COMBINING TREMOLO-1" #x1D167)
+    ("MUSICAL SYMBOL COMBINING TREMOLO-2" #x1D168)
+    ("MUSICAL SYMBOL COMBINING TREMOLO-3" #x1D169)
+    ("MUSICAL SYMBOL FINGERED TREMOLO-1" #x1D16A)
+    ("MUSICAL SYMBOL FINGERED TREMOLO-2" #x1D16B)
+    ("MUSICAL SYMBOL FINGERED TREMOLO-3" #x1D16C)
+    ("MUSICAL SYMBOL COMBINING AUGMENTATION DOT" #x1D16D)
+    ("MUSICAL SYMBOL COMBINING FLAG-1" #x1D16E)
+    ("MUSICAL SYMBOL COMBINING FLAG-2" #x1D16F)
+    ("MUSICAL SYMBOL COMBINING FLAG-3" #x1D170)
+    ("MUSICAL SYMBOL COMBINING FLAG-4" #x1D171)
+    ("MUSICAL SYMBOL COMBINING FLAG-5" #x1D172)
+    ("MUSICAL SYMBOL BEGIN BEAM" #x1D173)
+    ("MUSICAL SYMBOL END BEAM" #x1D174)
+    ("MUSICAL SYMBOL BEGIN TIE" #x1D175)
+    ("MUSICAL SYMBOL END TIE" #x1D176)
+    ("MUSICAL SYMBOL BEGIN SLUR" #x1D177)
+    ("MUSICAL SYMBOL END SLUR" #x1D178)
+    ("MUSICAL SYMBOL BEGIN PHRASE" #x1D179)
+    ("MUSICAL SYMBOL END PHRASE" #x1D17A)
+    ("MUSICAL SYMBOL COMBINING ACCENT" #x1D17B)
+    ("MUSICAL SYMBOL COMBINING STACCATO" #x1D17C)
+    ("MUSICAL SYMBOL COMBINING TENUTO" #x1D17D)
+    ("MUSICAL SYMBOL COMBINING STACCATISSIMO" #x1D17E)
+    ("MUSICAL SYMBOL COMBINING MARCATO" #x1D17F)
+    ("MUSICAL SYMBOL COMBINING MARCATO-STACCATO" #x1D180)
+    ("MUSICAL SYMBOL COMBINING ACCENT-STACCATO" #x1D181)
+    ("MUSICAL SYMBOL COMBINING LOURE" #x1D182)
+    ("MUSICAL SYMBOL ARPEGGIATO UP" #x1D183)
+    ("MUSICAL SYMBOL ARPEGGIATO DOWN" #x1D184)
+    ("MUSICAL SYMBOL COMBINING DOIT" #x1D185)
+    ("MUSICAL SYMBOL COMBINING RIP" #x1D186)
+    ("MUSICAL SYMBOL COMBINING FLIP" #x1D187)
+    ("MUSICAL SYMBOL COMBINING SMEAR" #x1D188)
+    ("MUSICAL SYMBOL COMBINING BEND" #x1D189)
+    ("MUSICAL SYMBOL COMBINING DOUBLE TONGUE" #x1D18A)
+    ("MUSICAL SYMBOL COMBINING TRIPLE TONGUE" #x1D18B)
+    ("MUSICAL SYMBOL RINFORZANDO" #x1D18C)
+    ("MUSICAL SYMBOL SUBITO" #x1D18D)
+    ("MUSICAL SYMBOL Z" #x1D18E)
+    ("MUSICAL SYMBOL PIANO" #x1D18F)
+    ("MUSICAL SYMBOL MEZZO" #x1D190)
+    ("MUSICAL SYMBOL FORTE" #x1D191)
+    ("MUSICAL SYMBOL CRESCENDO" #x1D192)
+    ("MUSICAL SYMBOL DECRESCENDO" #x1D193)
+    ("MUSICAL SYMBOL GRACE NOTE SLASH" #x1D194)
+    ("MUSICAL SYMBOL GRACE NOTE NO SLASH" #x1D195)
+    ("MUSICAL SYMBOL TR" #x1D196)
+    ("MUSICAL SYMBOL TURN" #x1D197)
+    ("MUSICAL SYMBOL INVERTED TURN" #x1D198)
+    ("MUSICAL SYMBOL TURN SLASH" #x1D199)
+    ("MUSICAL SYMBOL TURN UP" #x1D19A)
+    ("MUSICAL SYMBOL ORNAMENT STROKE-1" #x1D19B)
+    ("MUSICAL SYMBOL ORNAMENT STROKE-2" #x1D19C)
+    ("MUSICAL SYMBOL ORNAMENT STROKE-3" #x1D19D)
+    ("MUSICAL SYMBOL ORNAMENT STROKE-4" #x1D19E)
+    ("MUSICAL SYMBOL ORNAMENT STROKE-5" #x1D19F)
+    ("MUSICAL SYMBOL ORNAMENT STROKE-6" #x1D1A0)
+    ("MUSICAL SYMBOL ORNAMENT STROKE-7" #x1D1A1)
+    ("MUSICAL SYMBOL ORNAMENT STROKE-8" #x1D1A2)
+    ("MUSICAL SYMBOL ORNAMENT STROKE-9" #x1D1A3)
+    ("MUSICAL SYMBOL ORNAMENT STROKE-10" #x1D1A4)
+    ("MUSICAL SYMBOL ORNAMENT STROKE-11" #x1D1A5)
+    ("MUSICAL SYMBOL HAUPTSTIMME" #x1D1A6)
+    ("MUSICAL SYMBOL NEBENSTIMME" #x1D1A7)
+    ("MUSICAL SYMBOL END OF STIMME" #x1D1A8)
+    ("MUSICAL SYMBOL DEGREE SLASH" #x1D1A9)
+    ("MUSICAL SYMBOL COMBINING DOWN BOW" #x1D1AA)
+    ("MUSICAL SYMBOL COMBINING UP BOW" #x1D1AB)
+    ("MUSICAL SYMBOL COMBINING HARMONIC" #x1D1AC)
+    ("MUSICAL SYMBOL COMBINING SNAP PIZZICATO" #x1D1AD)
+    ("MUSICAL SYMBOL PEDAL MARK" #x1D1AE)
+    ("MUSICAL SYMBOL PEDAL UP MARK" #x1D1AF)
+    ("MUSICAL SYMBOL HALF PEDAL MARK" #x1D1B0)
+    ("MUSICAL SYMBOL GLISSANDO UP" #x1D1B1)
+    ("MUSICAL SYMBOL GLISSANDO DOWN" #x1D1B2)
+    ("MUSICAL SYMBOL WITH FINGERNAILS" #x1D1B3)
+    ("MUSICAL SYMBOL DAMP" #x1D1B4)
+    ("MUSICAL SYMBOL DAMP ALL" #x1D1B5)
+    ("MUSICAL SYMBOL MAXIMA" #x1D1B6)
+    ("MUSICAL SYMBOL LONGA" #x1D1B7)
+    ("MUSICAL SYMBOL BREVIS" #x1D1B8)
+    ("MUSICAL SYMBOL SEMIBREVIS WHITE" #x1D1B9)
+    ("MUSICAL SYMBOL SEMIBREVIS BLACK" #x1D1BA)
+    ("MUSICAL SYMBOL MINIMA" #x1D1BB)
+    ("MUSICAL SYMBOL MINIMA BLACK" #x1D1BC)
+    ("MUSICAL SYMBOL SEMIMINIMA WHITE" #x1D1BD)
+    ("MUSICAL SYMBOL SEMIMINIMA BLACK" #x1D1BE)
+    ("MUSICAL SYMBOL FUSA WHITE" #x1D1BF)
+    ("MUSICAL SYMBOL FUSA BLACK" #x1D1C0)
+    ("MUSICAL SYMBOL LONGA PERFECTA REST" #x1D1C1)
+    ("MUSICAL SYMBOL LONGA IMPERFECTA REST" #x1D1C2)
+    ("MUSICAL SYMBOL BREVIS REST" #x1D1C3)
+    ("MUSICAL SYMBOL SEMIBREVIS REST" #x1D1C4)
+    ("MUSICAL SYMBOL MINIMA REST" #x1D1C5)
+    ("MUSICAL SYMBOL SEMIMINIMA REST" #x1D1C6)
+    ("MUSICAL SYMBOL TEMPUS PERFECTUM CUM PROLATIONE PERFECTA" #x1D1C7)
+    ("MUSICAL SYMBOL TEMPUS PERFECTUM CUM PROLATIONE IMPERFECTA" #x1D1C8)
+    ("MUSICAL SYMBOL TEMPUS PERFECTUM CUM PROLATIONE PERFECTA DIMINUTION-1" #x1D1C9)
+    ("MUSICAL SYMBOL TEMPUS IMPERFECTUM CUM PROLATIONE PERFECTA" #x1D1CA)
+    ("MUSICAL SYMBOL TEMPUS IMPERFECTUM CUM PROLATIONE IMPERFECTA" #x1D1CB)
+    ("MUSICAL SYMBOL TEMPUS IMPERFECTUM CUM PROLATIONE IMPERFECTA DIMINUTION-1" #x1D1CC)
+    ("MUSICAL SYMBOL TEMPUS IMPERFECTUM CUM PROLATIONE IMPERFECTA DIMINUTION-2" #x1D1CD)
+    ("MUSICAL SYMBOL TEMPUS IMPERFECTUM CUM PROLATIONE IMPERFECTA DIMINUTION-3" #x1D1CE)
+    ("MUSICAL SYMBOL CROIX" #x1D1CF)
+    ("MUSICAL SYMBOL GREGORIAN C CLEF" #x1D1D0)
+    ("MUSICAL SYMBOL GREGORIAN F CLEF" #x1D1D1)
+    ("MUSICAL SYMBOL SQUARE B" #x1D1D2)
+    ("MUSICAL SYMBOL VIRGA" #x1D1D3)
+    ("MUSICAL SYMBOL PODATUS" #x1D1D4)
+    ("MUSICAL SYMBOL CLIVIS" #x1D1D5)
+    ("MUSICAL SYMBOL SCANDICUS" #x1D1D6)
+    ("MUSICAL SYMBOL CLIMACUS" #x1D1D7)
+    ("MUSICAL SYMBOL TORCULUS" #x1D1D8)
+    ("MUSICAL SYMBOL PORRECTUS" #x1D1D9)
+    ("MUSICAL SYMBOL PORRECTUS FLEXUS" #x1D1DA)
+    ("MUSICAL SYMBOL SCANDICUS FLEXUS" #x1D1DB)
+    ("MUSICAL SYMBOL TORCULUS RESUPINUS" #x1D1DC)
+    ("MUSICAL SYMBOL PES SUBPUNCTIS" #x1D1DD)
+    ))
diff --git a/lisp/nxml/char-name/unicode/1D400-1D7FF.el b/lisp/nxml/char-name/unicode/1D400-1D7FF.el
new file mode 100644
index 00000000000..98e8c2382cd
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/1D400-1D7FF.el
@@ -0,0 +1,993 @@
+(nxml-define-char-name-set 'mathematical-alphanumeric-symbols
+  '(("MATHEMATICAL BOLD CAPITAL A" #x1D400)
+    ("MATHEMATICAL BOLD CAPITAL B" #x1D401)
+    ("MATHEMATICAL BOLD CAPITAL C" #x1D402)
+    ("MATHEMATICAL BOLD CAPITAL D" #x1D403)
+    ("MATHEMATICAL BOLD CAPITAL E" #x1D404)
+    ("MATHEMATICAL BOLD CAPITAL F" #x1D405)
+    ("MATHEMATICAL BOLD CAPITAL G" #x1D406)
+    ("MATHEMATICAL BOLD CAPITAL H" #x1D407)
+    ("MATHEMATICAL BOLD CAPITAL I" #x1D408)
+    ("MATHEMATICAL BOLD CAPITAL J" #x1D409)
+    ("MATHEMATICAL BOLD CAPITAL K" #x1D40A)
+    ("MATHEMATICAL BOLD CAPITAL L" #x1D40B)
+    ("MATHEMATICAL BOLD CAPITAL M" #x1D40C)
+    ("MATHEMATICAL BOLD CAPITAL N" #x1D40D)
+    ("MATHEMATICAL BOLD CAPITAL O" #x1D40E)
+    ("MATHEMATICAL BOLD CAPITAL P" #x1D40F)
+    ("MATHEMATICAL BOLD CAPITAL Q" #x1D410)
+    ("MATHEMATICAL BOLD CAPITAL R" #x1D411)
+    ("MATHEMATICAL BOLD CAPITAL S" #x1D412)
+    ("MATHEMATICAL BOLD CAPITAL T" #x1D413)
+    ("MATHEMATICAL BOLD CAPITAL U" #x1D414)
+    ("MATHEMATICAL BOLD CAPITAL V" #x1D415)
+    ("MATHEMATICAL BOLD CAPITAL W" #x1D416)
+    ("MATHEMATICAL BOLD CAPITAL X" #x1D417)
+    ("MATHEMATICAL BOLD CAPITAL Y" #x1D418)
+    ("MATHEMATICAL BOLD CAPITAL Z" #x1D419)
+    ("MATHEMATICAL BOLD SMALL A" #x1D41A)
+    ("MATHEMATICAL BOLD SMALL B" #x1D41B)
+    ("MATHEMATICAL BOLD SMALL C" #x1D41C)
+    ("MATHEMATICAL BOLD SMALL D" #x1D41D)
+    ("MATHEMATICAL BOLD SMALL E" #x1D41E)
+    ("MATHEMATICAL BOLD SMALL F" #x1D41F)
+    ("MATHEMATICAL BOLD SMALL G" #x1D420)
+    ("MATHEMATICAL BOLD SMALL H" #x1D421)
+    ("MATHEMATICAL BOLD SMALL I" #x1D422)
+    ("MATHEMATICAL BOLD SMALL J" #x1D423)
+    ("MATHEMATICAL BOLD SMALL K" #x1D424)
+    ("MATHEMATICAL BOLD SMALL L" #x1D425)
+    ("MATHEMATICAL BOLD SMALL M" #x1D426)
+    ("MATHEMATICAL BOLD SMALL N" #x1D427)
+    ("MATHEMATICAL BOLD SMALL O" #x1D428)
+    ("MATHEMATICAL BOLD SMALL P" #x1D429)
+    ("MATHEMATICAL BOLD SMALL Q" #x1D42A)
+    ("MATHEMATICAL BOLD SMALL R" #x1D42B)
+    ("MATHEMATICAL BOLD SMALL S" #x1D42C)
+    ("MATHEMATICAL BOLD SMALL T" #x1D42D)
+    ("MATHEMATICAL BOLD SMALL U" #x1D42E)
+    ("MATHEMATICAL BOLD SMALL V" #x1D42F)
+    ("MATHEMATICAL BOLD SMALL W" #x1D430)
+    ("MATHEMATICAL BOLD SMALL X" #x1D431)
+    ("MATHEMATICAL BOLD SMALL Y" #x1D432)
+    ("MATHEMATICAL BOLD SMALL Z" #x1D433)
+    ("MATHEMATICAL ITALIC CAPITAL A" #x1D434)
+    ("MATHEMATICAL ITALIC CAPITAL B" #x1D435)
+    ("MATHEMATICAL ITALIC CAPITAL C" #x1D436)
+    ("MATHEMATICAL ITALIC CAPITAL D" #x1D437)
+    ("MATHEMATICAL ITALIC CAPITAL E" #x1D438)
+    ("MATHEMATICAL ITALIC CAPITAL F" #x1D439)
+    ("MATHEMATICAL ITALIC CAPITAL G" #x1D43A)
+    ("MATHEMATICAL ITALIC CAPITAL H" #x1D43B)
+    ("MATHEMATICAL ITALIC CAPITAL I" #x1D43C)
+    ("MATHEMATICAL ITALIC CAPITAL J" #x1D43D)
+    ("MATHEMATICAL ITALIC CAPITAL K" #x1D43E)
+    ("MATHEMATICAL ITALIC CAPITAL L" #x1D43F)
+    ("MATHEMATICAL ITALIC CAPITAL M" #x1D440)
+    ("MATHEMATICAL ITALIC CAPITAL N" #x1D441)
+    ("MATHEMATICAL ITALIC CAPITAL O" #x1D442)
+    ("MATHEMATICAL ITALIC CAPITAL P" #x1D443)
+    ("MATHEMATICAL ITALIC CAPITAL Q" #x1D444)
+    ("MATHEMATICAL ITALIC CAPITAL R" #x1D445)
+    ("MATHEMATICAL ITALIC CAPITAL S" #x1D446)
+    ("MATHEMATICAL ITALIC CAPITAL T" #x1D447)
+    ("MATHEMATICAL ITALIC CAPITAL U" #x1D448)
+    ("MATHEMATICAL ITALIC CAPITAL V" #x1D449)
+    ("MATHEMATICAL ITALIC CAPITAL W" #x1D44A)
+    ("MATHEMATICAL ITALIC CAPITAL X" #x1D44B)
+    ("MATHEMATICAL ITALIC CAPITAL Y" #x1D44C)
+    ("MATHEMATICAL ITALIC CAPITAL Z" #x1D44D)
+    ("MATHEMATICAL ITALIC SMALL A" #x1D44E)
+    ("MATHEMATICAL ITALIC SMALL B" #x1D44F)
+    ("MATHEMATICAL ITALIC SMALL C" #x1D450)
+    ("MATHEMATICAL ITALIC SMALL D" #x1D451)
+    ("MATHEMATICAL ITALIC SMALL E" #x1D452)
+    ("MATHEMATICAL ITALIC SMALL F" #x1D453)
+    ("MATHEMATICAL ITALIC SMALL G" #x1D454)
+    ("MATHEMATICAL ITALIC SMALL I" #x1D456)
+    ("MATHEMATICAL ITALIC SMALL J" #x1D457)
+    ("MATHEMATICAL ITALIC SMALL K" #x1D458)
+    ("MATHEMATICAL ITALIC SMALL L" #x1D459)
+    ("MATHEMATICAL ITALIC SMALL M" #x1D45A)
+    ("MATHEMATICAL ITALIC SMALL N" #x1D45B)
+    ("MATHEMATICAL ITALIC SMALL O" #x1D45C)
+    ("MATHEMATICAL ITALIC SMALL P" #x1D45D)
+    ("MATHEMATICAL ITALIC SMALL Q" #x1D45E)
+    ("MATHEMATICAL ITALIC SMALL R" #x1D45F)
+    ("MATHEMATICAL ITALIC SMALL S" #x1D460)
+    ("MATHEMATICAL ITALIC SMALL T" #x1D461)
+    ("MATHEMATICAL ITALIC SMALL U" #x1D462)
+    ("MATHEMATICAL ITALIC SMALL V" #x1D463)
+    ("MATHEMATICAL ITALIC SMALL W" #x1D464)
+    ("MATHEMATICAL ITALIC SMALL X" #x1D465)
+    ("MATHEMATICAL ITALIC SMALL Y" #x1D466)
+    ("MATHEMATICAL ITALIC SMALL Z" #x1D467)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL A" #x1D468)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL B" #x1D469)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL C" #x1D46A)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL D" #x1D46B)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL E" #x1D46C)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL F" #x1D46D)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL G" #x1D46E)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL H" #x1D46F)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL I" #x1D470)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL J" #x1D471)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL K" #x1D472)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL L" #x1D473)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL M" #x1D474)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL N" #x1D475)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL O" #x1D476)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL P" #x1D477)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL Q" #x1D478)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL R" #x1D479)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL S" #x1D47A)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL T" #x1D47B)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL U" #x1D47C)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL V" #x1D47D)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL W" #x1D47E)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL X" #x1D47F)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL Y" #x1D480)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL Z" #x1D481)
+    ("MATHEMATICAL BOLD ITALIC SMALL A" #x1D482)
+    ("MATHEMATICAL BOLD ITALIC SMALL B" #x1D483)
+    ("MATHEMATICAL BOLD ITALIC SMALL C" #x1D484)
+    ("MATHEMATICAL BOLD ITALIC SMALL D" #x1D485)
+    ("MATHEMATICAL BOLD ITALIC SMALL E" #x1D486)
+    ("MATHEMATICAL BOLD ITALIC SMALL F" #x1D487)
+    ("MATHEMATICAL BOLD ITALIC SMALL G" #x1D488)
+    ("MATHEMATICAL BOLD ITALIC SMALL H" #x1D489)
+    ("MATHEMATICAL BOLD ITALIC SMALL I" #x1D48A)
+    ("MATHEMATICAL BOLD ITALIC SMALL J" #x1D48B)
+    ("MATHEMATICAL BOLD ITALIC SMALL K" #x1D48C)
+    ("MATHEMATICAL BOLD ITALIC SMALL L" #x1D48D)
+    ("MATHEMATICAL BOLD ITALIC SMALL M" #x1D48E)
+    ("MATHEMATICAL BOLD ITALIC SMALL N" #x1D48F)
+    ("MATHEMATICAL BOLD ITALIC SMALL O" #x1D490)
+    ("MATHEMATICAL BOLD ITALIC SMALL P" #x1D491)
+    ("MATHEMATICAL BOLD ITALIC SMALL Q" #x1D492)
+    ("MATHEMATICAL BOLD ITALIC SMALL R" #x1D493)
+    ("MATHEMATICAL BOLD ITALIC SMALL S" #x1D494)
+    ("MATHEMATICAL BOLD ITALIC SMALL T" #x1D495)
+    ("MATHEMATICAL BOLD ITALIC SMALL U" #x1D496)
+    ("MATHEMATICAL BOLD ITALIC SMALL V" #x1D497)
+    ("MATHEMATICAL BOLD ITALIC SMALL W" #x1D498)
+    ("MATHEMATICAL BOLD ITALIC SMALL X" #x1D499)
+    ("MATHEMATICAL BOLD ITALIC SMALL Y" #x1D49A)
+    ("MATHEMATICAL BOLD ITALIC SMALL Z" #x1D49B)
+    ("MATHEMATICAL SCRIPT CAPITAL A" #x1D49C)
+    ("MATHEMATICAL SCRIPT CAPITAL C" #x1D49E)
+    ("MATHEMATICAL SCRIPT CAPITAL D" #x1D49F)
+    ("MATHEMATICAL SCRIPT CAPITAL G" #x1D4A2)
+    ("MATHEMATICAL SCRIPT CAPITAL J" #x1D4A5)
+    ("MATHEMATICAL SCRIPT CAPITAL K" #x1D4A6)
+    ("MATHEMATICAL SCRIPT CAPITAL N" #x1D4A9)
+    ("MATHEMATICAL SCRIPT CAPITAL O" #x1D4AA)
+    ("MATHEMATICAL SCRIPT CAPITAL P" #x1D4AB)
+    ("MATHEMATICAL SCRIPT CAPITAL Q" #x1D4AC)
+    ("MATHEMATICAL SCRIPT CAPITAL S" #x1D4AE)
+    ("MATHEMATICAL SCRIPT CAPITAL T" #x1D4AF)
+    ("MATHEMATICAL SCRIPT CAPITAL U" #x1D4B0)
+    ("MATHEMATICAL SCRIPT CAPITAL V" #x1D4B1)
+    ("MATHEMATICAL SCRIPT CAPITAL W" #x1D4B2)
+    ("MATHEMATICAL SCRIPT CAPITAL X" #x1D4B3)
+    ("MATHEMATICAL SCRIPT CAPITAL Y" #x1D4B4)
+    ("MATHEMATICAL SCRIPT CAPITAL Z" #x1D4B5)
+    ("MATHEMATICAL SCRIPT SMALL A" #x1D4B6)
+    ("MATHEMATICAL SCRIPT SMALL B" #x1D4B7)
+    ("MATHEMATICAL SCRIPT SMALL C" #x1D4B8)
+    ("MATHEMATICAL SCRIPT SMALL D" #x1D4B9)
+    ("MATHEMATICAL SCRIPT SMALL F" #x1D4BB)
+    ("MATHEMATICAL SCRIPT SMALL H" #x1D4BD)
+    ("MATHEMATICAL SCRIPT SMALL I" #x1D4BE)
+    ("MATHEMATICAL SCRIPT SMALL J" #x1D4BF)
+    ("MATHEMATICAL SCRIPT SMALL K" #x1D4C0)
+    ("MATHEMATICAL SCRIPT SMALL M" #x1D4C2)
+    ("MATHEMATICAL SCRIPT SMALL N" #x1D4C3)
+    ("MATHEMATICAL SCRIPT SMALL P" #x1D4C5)
+    ("MATHEMATICAL SCRIPT SMALL Q" #x1D4C6)
+    ("MATHEMATICAL SCRIPT SMALL R" #x1D4C7)
+    ("MATHEMATICAL SCRIPT SMALL S" #x1D4C8)
+    ("MATHEMATICAL SCRIPT SMALL T" #x1D4C9)
+    ("MATHEMATICAL SCRIPT SMALL U" #x1D4CA)
+    ("MATHEMATICAL SCRIPT SMALL V" #x1D4CB)
+    ("MATHEMATICAL SCRIPT SMALL W" #x1D4CC)
+    ("MATHEMATICAL SCRIPT SMALL X" #x1D4CD)
+    ("MATHEMATICAL SCRIPT SMALL Y" #x1D4CE)
+    ("MATHEMATICAL SCRIPT SMALL Z" #x1D4CF)
+    ("MATHEMATICAL BOLD SCRIPT CAPITAL A" #x1D4D0)
+    ("MATHEMATICAL BOLD SCRIPT CAPITAL B" #x1D4D1)
+    ("MATHEMATICAL BOLD SCRIPT CAPITAL C" #x1D4D2)
+    ("MATHEMATICAL BOLD SCRIPT CAPITAL D" #x1D4D3)
+    ("MATHEMATICAL BOLD SCRIPT CAPITAL E" #x1D4D4)
+    ("MATHEMATICAL BOLD SCRIPT CAPITAL F" #x1D4D5)
+    ("MATHEMATICAL BOLD SCRIPT CAPITAL G" #x1D4D6)
+    ("MATHEMATICAL BOLD SCRIPT CAPITAL H" #x1D4D7)
+    ("MATHEMATICAL BOLD SCRIPT CAPITAL I" #x1D4D8)
+    ("MATHEMATICAL BOLD SCRIPT CAPITAL J" #x1D4D9)
+    ("MATHEMATICAL BOLD SCRIPT CAPITAL K" #x1D4DA)
+    ("MATHEMATICAL BOLD SCRIPT CAPITAL L" #x1D4DB)
+    ("MATHEMATICAL BOLD SCRIPT CAPITAL M" #x1D4DC)
+    ("MATHEMATICAL BOLD SCRIPT CAPITAL N" #x1D4DD)
+    ("MATHEMATICAL BOLD SCRIPT CAPITAL O" #x1D4DE)
+    ("MATHEMATICAL BOLD SCRIPT CAPITAL P" #x1D4DF)
+    ("MATHEMATICAL BOLD SCRIPT CAPITAL Q" #x1D4E0)
+    ("MATHEMATICAL BOLD SCRIPT CAPITAL R" #x1D4E1)
+    ("MATHEMATICAL BOLD SCRIPT CAPITAL S" #x1D4E2)
+    ("MATHEMATICAL BOLD SCRIPT CAPITAL T" #x1D4E3)
+    ("MATHEMATICAL BOLD SCRIPT CAPITAL U" #x1D4E4)
+    ("MATHEMATICAL BOLD SCRIPT CAPITAL V" #x1D4E5)
+    ("MATHEMATICAL BOLD SCRIPT CAPITAL W" #x1D4E6)
+    ("MATHEMATICAL BOLD SCRIPT CAPITAL X" #x1D4E7)
+    ("MATHEMATICAL BOLD SCRIPT CAPITAL Y" #x1D4E8)
+    ("MATHEMATICAL BOLD SCRIPT CAPITAL Z" #x1D4E9)
+    ("MATHEMATICAL BOLD SCRIPT SMALL A" #x1D4EA)
+    ("MATHEMATICAL BOLD SCRIPT SMALL B" #x1D4EB)
+    ("MATHEMATICAL BOLD SCRIPT SMALL C" #x1D4EC)
+    ("MATHEMATICAL BOLD SCRIPT SMALL D" #x1D4ED)
+    ("MATHEMATICAL BOLD SCRIPT SMALL E" #x1D4EE)
+    ("MATHEMATICAL BOLD SCRIPT SMALL F" #x1D4EF)
+    ("MATHEMATICAL BOLD SCRIPT SMALL G" #x1D4F0)
+    ("MATHEMATICAL BOLD SCRIPT SMALL H" #x1D4F1)
+    ("MATHEMATICAL BOLD SCRIPT SMALL I" #x1D4F2)
+    ("MATHEMATICAL BOLD SCRIPT SMALL J" #x1D4F3)
+    ("MATHEMATICAL BOLD SCRIPT SMALL K" #x1D4F4)
+    ("MATHEMATICAL BOLD SCRIPT SMALL L" #x1D4F5)
+    ("MATHEMATICAL BOLD SCRIPT SMALL M" #x1D4F6)
+    ("MATHEMATICAL BOLD SCRIPT SMALL N" #x1D4F7)
+    ("MATHEMATICAL BOLD SCRIPT SMALL O" #x1D4F8)
+    ("MATHEMATICAL BOLD SCRIPT SMALL P" #x1D4F9)
+    ("MATHEMATICAL BOLD SCRIPT SMALL Q" #x1D4FA)
+    ("MATHEMATICAL BOLD SCRIPT SMALL R" #x1D4FB)
+    ("MATHEMATICAL BOLD SCRIPT SMALL S" #x1D4FC)
+    ("MATHEMATICAL BOLD SCRIPT SMALL T" #x1D4FD)
+    ("MATHEMATICAL BOLD SCRIPT SMALL U" #x1D4FE)
+    ("MATHEMATICAL BOLD SCRIPT SMALL V" #x1D4FF)
+    ("MATHEMATICAL BOLD SCRIPT SMALL W" #x1D500)
+    ("MATHEMATICAL BOLD SCRIPT SMALL X" #x1D501)
+    ("MATHEMATICAL BOLD SCRIPT SMALL Y" #x1D502)
+    ("MATHEMATICAL BOLD SCRIPT SMALL Z" #x1D503)
+    ("MATHEMATICAL FRAKTUR CAPITAL A" #x1D504)
+    ("MATHEMATICAL FRAKTUR CAPITAL B" #x1D505)
+    ("MATHEMATICAL FRAKTUR CAPITAL D" #x1D507)
+    ("MATHEMATICAL FRAKTUR CAPITAL E" #x1D508)
+    ("MATHEMATICAL FRAKTUR CAPITAL F" #x1D509)
+    ("MATHEMATICAL FRAKTUR CAPITAL G" #x1D50A)
+    ("MATHEMATICAL FRAKTUR CAPITAL J" #x1D50D)
+    ("MATHEMATICAL FRAKTUR CAPITAL K" #x1D50E)
+    ("MATHEMATICAL FRAKTUR CAPITAL L" #x1D50F)
+    ("MATHEMATICAL FRAKTUR CAPITAL M" #x1D510)
+    ("MATHEMATICAL FRAKTUR CAPITAL N" #x1D511)
+    ("MATHEMATICAL FRAKTUR CAPITAL O" #x1D512)
+    ("MATHEMATICAL FRAKTUR CAPITAL P" #x1D513)
+    ("MATHEMATICAL FRAKTUR CAPITAL Q" #x1D514)
+    ("MATHEMATICAL FRAKTUR CAPITAL S" #x1D516)
+    ("MATHEMATICAL FRAKTUR CAPITAL T" #x1D517)
+    ("MATHEMATICAL FRAKTUR CAPITAL U" #x1D518)
+    ("MATHEMATICAL FRAKTUR CAPITAL V" #x1D519)
+    ("MATHEMATICAL FRAKTUR CAPITAL W" #x1D51A)
+    ("MATHEMATICAL FRAKTUR CAPITAL X" #x1D51B)
+    ("MATHEMATICAL FRAKTUR CAPITAL Y" #x1D51C)
+    ("MATHEMATICAL FRAKTUR SMALL A" #x1D51E)
+    ("MATHEMATICAL FRAKTUR SMALL B" #x1D51F)
+    ("MATHEMATICAL FRAKTUR SMALL C" #x1D520)
+    ("MATHEMATICAL FRAKTUR SMALL D" #x1D521)
+    ("MATHEMATICAL FRAKTUR SMALL E" #x1D522)
+    ("MATHEMATICAL FRAKTUR SMALL F" #x1D523)
+    ("MATHEMATICAL FRAKTUR SMALL G" #x1D524)
+    ("MATHEMATICAL FRAKTUR SMALL H" #x1D525)
+    ("MATHEMATICAL FRAKTUR SMALL I" #x1D526)
+    ("MATHEMATICAL FRAKTUR SMALL J" #x1D527)
+    ("MATHEMATICAL FRAKTUR SMALL K" #x1D528)
+    ("MATHEMATICAL FRAKTUR SMALL L" #x1D529)
+    ("MATHEMATICAL FRAKTUR SMALL M" #x1D52A)
+    ("MATHEMATICAL FRAKTUR SMALL N" #x1D52B)
+    ("MATHEMATICAL FRAKTUR SMALL O" #x1D52C)
+    ("MATHEMATICAL FRAKTUR SMALL P" #x1D52D)
+    ("MATHEMATICAL FRAKTUR SMALL Q" #x1D52E)
+    ("MATHEMATICAL FRAKTUR SMALL R" #x1D52F)
+    ("MATHEMATICAL FRAKTUR SMALL S" #x1D530)
+    ("MATHEMATICAL FRAKTUR SMALL T" #x1D531)
+    ("MATHEMATICAL FRAKTUR SMALL U" #x1D532)
+    ("MATHEMATICAL FRAKTUR SMALL V" #x1D533)
+    ("MATHEMATICAL FRAKTUR SMALL W" #x1D534)
+    ("MATHEMATICAL FRAKTUR SMALL X" #x1D535)
+    ("MATHEMATICAL FRAKTUR SMALL Y" #x1D536)
+    ("MATHEMATICAL FRAKTUR SMALL Z" #x1D537)
+    ("MATHEMATICAL DOUBLE-STRUCK CAPITAL A" #x1D538)
+    ("MATHEMATICAL DOUBLE-STRUCK CAPITAL B" #x1D539)
+    ("MATHEMATICAL DOUBLE-STRUCK CAPITAL D" #x1D53B)
+    ("MATHEMATICAL DOUBLE-STRUCK CAPITAL E" #x1D53C)
+    ("MATHEMATICAL DOUBLE-STRUCK CAPITAL F" #x1D53D)
+    ("MATHEMATICAL DOUBLE-STRUCK CAPITAL G" #x1D53E)
+    ("MATHEMATICAL DOUBLE-STRUCK CAPITAL I" #x1D540)
+    ("MATHEMATICAL DOUBLE-STRUCK CAPITAL J" #x1D541)
+    ("MATHEMATICAL DOUBLE-STRUCK CAPITAL K" #x1D542)
+    ("MATHEMATICAL DOUBLE-STRUCK CAPITAL L" #x1D543)
+    ("MATHEMATICAL DOUBLE-STRUCK CAPITAL M" #x1D544)
+    ("MATHEMATICAL DOUBLE-STRUCK CAPITAL O" #x1D546)
+    ("MATHEMATICAL DOUBLE-STRUCK CAPITAL S" #x1D54A)
+    ("MATHEMATICAL DOUBLE-STRUCK CAPITAL T" #x1D54B)
+    ("MATHEMATICAL DOUBLE-STRUCK CAPITAL U" #x1D54C)
+    ("MATHEMATICAL DOUBLE-STRUCK CAPITAL V" #x1D54D)
+    ("MATHEMATICAL DOUBLE-STRUCK CAPITAL W" #x1D54E)
+    ("MATHEMATICAL DOUBLE-STRUCK CAPITAL X" #x1D54F)
+    ("MATHEMATICAL DOUBLE-STRUCK CAPITAL Y" #x1D550)
+    ("MATHEMATICAL DOUBLE-STRUCK SMALL A" #x1D552)
+    ("MATHEMATICAL DOUBLE-STRUCK SMALL B" #x1D553)
+    ("MATHEMATICAL DOUBLE-STRUCK SMALL C" #x1D554)
+    ("MATHEMATICAL DOUBLE-STRUCK SMALL D" #x1D555)
+    ("MATHEMATICAL DOUBLE-STRUCK SMALL E" #x1D556)
+    ("MATHEMATICAL DOUBLE-STRUCK SMALL F" #x1D557)
+    ("MATHEMATICAL DOUBLE-STRUCK SMALL G" #x1D558)
+    ("MATHEMATICAL DOUBLE-STRUCK SMALL H" #x1D559)
+    ("MATHEMATICAL DOUBLE-STRUCK SMALL I" #x1D55A)
+    ("MATHEMATICAL DOUBLE-STRUCK SMALL J" #x1D55B)
+    ("MATHEMATICAL DOUBLE-STRUCK SMALL K" #x1D55C)
+    ("MATHEMATICAL DOUBLE-STRUCK SMALL L" #x1D55D)
+    ("MATHEMATICAL DOUBLE-STRUCK SMALL M" #x1D55E)
+    ("MATHEMATICAL DOUBLE-STRUCK SMALL N" #x1D55F)
+    ("MATHEMATICAL DOUBLE-STRUCK SMALL O" #x1D560)
+    ("MATHEMATICAL DOUBLE-STRUCK SMALL P" #x1D561)
+    ("MATHEMATICAL DOUBLE-STRUCK SMALL Q" #x1D562)
+    ("MATHEMATICAL DOUBLE-STRUCK SMALL R" #x1D563)
+    ("MATHEMATICAL DOUBLE-STRUCK SMALL S" #x1D564)
+    ("MATHEMATICAL DOUBLE-STRUCK SMALL T" #x1D565)
+    ("MATHEMATICAL DOUBLE-STRUCK SMALL U" #x1D566)
+    ("MATHEMATICAL DOUBLE-STRUCK SMALL V" #x1D567)
+    ("MATHEMATICAL DOUBLE-STRUCK SMALL W" #x1D568)
+    ("MATHEMATICAL DOUBLE-STRUCK SMALL X" #x1D569)
+    ("MATHEMATICAL DOUBLE-STRUCK SMALL Y" #x1D56A)
+    ("MATHEMATICAL DOUBLE-STRUCK SMALL Z" #x1D56B)
+    ("MATHEMATICAL BOLD FRAKTUR CAPITAL A" #x1D56C)
+    ("MATHEMATICAL BOLD FRAKTUR CAPITAL B" #x1D56D)
+    ("MATHEMATICAL BOLD FRAKTUR CAPITAL C" #x1D56E)
+    ("MATHEMATICAL BOLD FRAKTUR CAPITAL D" #x1D56F)
+    ("MATHEMATICAL BOLD FRAKTUR CAPITAL E" #x1D570)
+    ("MATHEMATICAL BOLD FRAKTUR CAPITAL F" #x1D571)
+    ("MATHEMATICAL BOLD FRAKTUR CAPITAL G" #x1D572)
+    ("MATHEMATICAL BOLD FRAKTUR CAPITAL H" #x1D573)
+    ("MATHEMATICAL BOLD FRAKTUR CAPITAL I" #x1D574)
+    ("MATHEMATICAL BOLD FRAKTUR CAPITAL J" #x1D575)
+    ("MATHEMATICAL BOLD FRAKTUR CAPITAL K" #x1D576)
+    ("MATHEMATICAL BOLD FRAKTUR CAPITAL L" #x1D577)
+    ("MATHEMATICAL BOLD FRAKTUR CAPITAL M" #x1D578)
+    ("MATHEMATICAL BOLD FRAKTUR CAPITAL N" #x1D579)
+    ("MATHEMATICAL BOLD FRAKTUR CAPITAL O" #x1D57A)
+    ("MATHEMATICAL BOLD FRAKTUR CAPITAL P" #x1D57B)
+    ("MATHEMATICAL BOLD FRAKTUR CAPITAL Q" #x1D57C)
+    ("MATHEMATICAL BOLD FRAKTUR CAPITAL R" #x1D57D)
+    ("MATHEMATICAL BOLD FRAKTUR CAPITAL S" #x1D57E)
+    ("MATHEMATICAL BOLD FRAKTUR CAPITAL T" #x1D57F)
+    ("MATHEMATICAL BOLD FRAKTUR CAPITAL U" #x1D580)
+    ("MATHEMATICAL BOLD FRAKTUR CAPITAL V" #x1D581)
+    ("MATHEMATICAL BOLD FRAKTUR CAPITAL W" #x1D582)
+    ("MATHEMATICAL BOLD FRAKTUR CAPITAL X" #x1D583)
+    ("MATHEMATICAL BOLD FRAKTUR CAPITAL Y" #x1D584)
+    ("MATHEMATICAL BOLD FRAKTUR CAPITAL Z" #x1D585)
+    ("MATHEMATICAL BOLD FRAKTUR SMALL A" #x1D586)
+    ("MATHEMATICAL BOLD FRAKTUR SMALL B" #x1D587)
+    ("MATHEMATICAL BOLD FRAKTUR SMALL C" #x1D588)
+    ("MATHEMATICAL BOLD FRAKTUR SMALL D" #x1D589)
+    ("MATHEMATICAL BOLD FRAKTUR SMALL E" #x1D58A)
+    ("MATHEMATICAL BOLD FRAKTUR SMALL F" #x1D58B)
+    ("MATHEMATICAL BOLD FRAKTUR SMALL G" #x1D58C)
+    ("MATHEMATICAL BOLD FRAKTUR SMALL H" #x1D58D)
+    ("MATHEMATICAL BOLD FRAKTUR SMALL I" #x1D58E)
+    ("MATHEMATICAL BOLD FRAKTUR SMALL J" #x1D58F)
+    ("MATHEMATICAL BOLD FRAKTUR SMALL K" #x1D590)
+    ("MATHEMATICAL BOLD FRAKTUR SMALL L" #x1D591)
+    ("MATHEMATICAL BOLD FRAKTUR SMALL M" #x1D592)
+    ("MATHEMATICAL BOLD FRAKTUR SMALL N" #x1D593)
+    ("MATHEMATICAL BOLD FRAKTUR SMALL O" #x1D594)
+    ("MATHEMATICAL BOLD FRAKTUR SMALL P" #x1D595)
+    ("MATHEMATICAL BOLD FRAKTUR SMALL Q" #x1D596)
+    ("MATHEMATICAL BOLD FRAKTUR SMALL R" #x1D597)
+    ("MATHEMATICAL BOLD FRAKTUR SMALL S" #x1D598)
+    ("MATHEMATICAL BOLD FRAKTUR SMALL T" #x1D599)
+    ("MATHEMATICAL BOLD FRAKTUR SMALL U" #x1D59A)
+    ("MATHEMATICAL BOLD FRAKTUR SMALL V" #x1D59B)
+    ("MATHEMATICAL BOLD FRAKTUR SMALL W" #x1D59C)
+    ("MATHEMATICAL BOLD FRAKTUR SMALL X" #x1D59D)
+    ("MATHEMATICAL BOLD FRAKTUR SMALL Y" #x1D59E)
+    ("MATHEMATICAL BOLD FRAKTUR SMALL Z" #x1D59F)
+    ("MATHEMATICAL SANS-SERIF CAPITAL A" #x1D5A0)
+    ("MATHEMATICAL SANS-SERIF CAPITAL B" #x1D5A1)
+    ("MATHEMATICAL SANS-SERIF CAPITAL C" #x1D5A2)
+    ("MATHEMATICAL SANS-SERIF CAPITAL D" #x1D5A3)
+    ("MATHEMATICAL SANS-SERIF CAPITAL E" #x1D5A4)
+    ("MATHEMATICAL SANS-SERIF CAPITAL F" #x1D5A5)
+    ("MATHEMATICAL SANS-SERIF CAPITAL G" #x1D5A6)
+    ("MATHEMATICAL SANS-SERIF CAPITAL H" #x1D5A7)
+    ("MATHEMATICAL SANS-SERIF CAPITAL I" #x1D5A8)
+    ("MATHEMATICAL SANS-SERIF CAPITAL J" #x1D5A9)
+    ("MATHEMATICAL SANS-SERIF CAPITAL K" #x1D5AA)
+    ("MATHEMATICAL SANS-SERIF CAPITAL L" #x1D5AB)
+    ("MATHEMATICAL SANS-SERIF CAPITAL M" #x1D5AC)
+    ("MATHEMATICAL SANS-SERIF CAPITAL N" #x1D5AD)
+    ("MATHEMATICAL SANS-SERIF CAPITAL O" #x1D5AE)
+    ("MATHEMATICAL SANS-SERIF CAPITAL P" #x1D5AF)
+    ("MATHEMATICAL SANS-SERIF CAPITAL Q" #x1D5B0)
+    ("MATHEMATICAL SANS-SERIF CAPITAL R" #x1D5B1)
+    ("MATHEMATICAL SANS-SERIF CAPITAL S" #x1D5B2)
+    ("MATHEMATICAL SANS-SERIF CAPITAL T" #x1D5B3)
+    ("MATHEMATICAL SANS-SERIF CAPITAL U" #x1D5B4)
+    ("MATHEMATICAL SANS-SERIF CAPITAL V" #x1D5B5)
+    ("MATHEMATICAL SANS-SERIF CAPITAL W" #x1D5B6)
+    ("MATHEMATICAL SANS-SERIF CAPITAL X" #x1D5B7)
+    ("MATHEMATICAL SANS-SERIF CAPITAL Y" #x1D5B8)
+    ("MATHEMATICAL SANS-SERIF CAPITAL Z" #x1D5B9)
+    ("MATHEMATICAL SANS-SERIF SMALL A" #x1D5BA)
+    ("MATHEMATICAL SANS-SERIF SMALL B" #x1D5BB)
+    ("MATHEMATICAL SANS-SERIF SMALL C" #x1D5BC)
+    ("MATHEMATICAL SANS-SERIF SMALL D" #x1D5BD)
+    ("MATHEMATICAL SANS-SERIF SMALL E" #x1D5BE)
+    ("MATHEMATICAL SANS-SERIF SMALL F" #x1D5BF)
+    ("MATHEMATICAL SANS-SERIF SMALL G" #x1D5C0)
+    ("MATHEMATICAL SANS-SERIF SMALL H" #x1D5C1)
+    ("MATHEMATICAL SANS-SERIF SMALL I" #x1D5C2)
+    ("MATHEMATICAL SANS-SERIF SMALL J" #x1D5C3)
+    ("MATHEMATICAL SANS-SERIF SMALL K" #x1D5C4)
+    ("MATHEMATICAL SANS-SERIF SMALL L" #x1D5C5)
+    ("MATHEMATICAL SANS-SERIF SMALL M" #x1D5C6)
+    ("MATHEMATICAL SANS-SERIF SMALL N" #x1D5C7)
+    ("MATHEMATICAL SANS-SERIF SMALL O" #x1D5C8)
+    ("MATHEMATICAL SANS-SERIF SMALL P" #x1D5C9)
+    ("MATHEMATICAL SANS-SERIF SMALL Q" #x1D5CA)
+    ("MATHEMATICAL SANS-SERIF SMALL R" #x1D5CB)
+    ("MATHEMATICAL SANS-SERIF SMALL S" #x1D5CC)
+    ("MATHEMATICAL SANS-SERIF SMALL T" #x1D5CD)
+    ("MATHEMATICAL SANS-SERIF SMALL U" #x1D5CE)
+    ("MATHEMATICAL SANS-SERIF SMALL V" #x1D5CF)
+    ("MATHEMATICAL SANS-SERIF SMALL W" #x1D5D0)
+    ("MATHEMATICAL SANS-SERIF SMALL X" #x1D5D1)
+    ("MATHEMATICAL SANS-SERIF SMALL Y" #x1D5D2)
+    ("MATHEMATICAL SANS-SERIF SMALL Z" #x1D5D3)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL A" #x1D5D4)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL B" #x1D5D5)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL C" #x1D5D6)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL D" #x1D5D7)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL E" #x1D5D8)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL F" #x1D5D9)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL G" #x1D5DA)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL H" #x1D5DB)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL I" #x1D5DC)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL J" #x1D5DD)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL K" #x1D5DE)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL L" #x1D5DF)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL M" #x1D5E0)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL N" #x1D5E1)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL O" #x1D5E2)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL P" #x1D5E3)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL Q" #x1D5E4)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL R" #x1D5E5)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL S" #x1D5E6)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL T" #x1D5E7)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL U" #x1D5E8)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL V" #x1D5E9)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL W" #x1D5EA)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL X" #x1D5EB)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL Y" #x1D5EC)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL Z" #x1D5ED)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL A" #x1D5EE)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL B" #x1D5EF)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL C" #x1D5F0)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL D" #x1D5F1)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL E" #x1D5F2)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL F" #x1D5F3)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL G" #x1D5F4)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL H" #x1D5F5)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL I" #x1D5F6)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL J" #x1D5F7)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL K" #x1D5F8)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL L" #x1D5F9)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL M" #x1D5FA)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL N" #x1D5FB)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL O" #x1D5FC)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL P" #x1D5FD)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL Q" #x1D5FE)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL R" #x1D5FF)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL S" #x1D600)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL T" #x1D601)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL U" #x1D602)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL V" #x1D603)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL W" #x1D604)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL X" #x1D605)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL Y" #x1D606)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL Z" #x1D607)
+    ("MATHEMATICAL SANS-SERIF ITALIC CAPITAL A" #x1D608)
+    ("MATHEMATICAL SANS-SERIF ITALIC CAPITAL B" #x1D609)
+    ("MATHEMATICAL SANS-SERIF ITALIC CAPITAL C" #x1D60A)
+    ("MATHEMATICAL SANS-SERIF ITALIC CAPITAL D" #x1D60B)
+    ("MATHEMATICAL SANS-SERIF ITALIC CAPITAL E" #x1D60C)
+    ("MATHEMATICAL SANS-SERIF ITALIC CAPITAL F" #x1D60D)
+    ("MATHEMATICAL SANS-SERIF ITALIC CAPITAL G" #x1D60E)
+    ("MATHEMATICAL SANS-SERIF ITALIC CAPITAL H" #x1D60F)
+    ("MATHEMATICAL SANS-SERIF ITALIC CAPITAL I" #x1D610)
+    ("MATHEMATICAL SANS-SERIF ITALIC CAPITAL J" #x1D611)
+    ("MATHEMATICAL SANS-SERIF ITALIC CAPITAL K" #x1D612)
+    ("MATHEMATICAL SANS-SERIF ITALIC CAPITAL L" #x1D613)
+    ("MATHEMATICAL SANS-SERIF ITALIC CAPITAL M" #x1D614)
+    ("MATHEMATICAL SANS-SERIF ITALIC CAPITAL N" #x1D615)
+    ("MATHEMATICAL SANS-SERIF ITALIC CAPITAL O" #x1D616)
+    ("MATHEMATICAL SANS-SERIF ITALIC CAPITAL P" #x1D617)
+    ("MATHEMATICAL SANS-SERIF ITALIC CAPITAL Q" #x1D618)
+    ("MATHEMATICAL SANS-SERIF ITALIC CAPITAL R" #x1D619)
+    ("MATHEMATICAL SANS-SERIF ITALIC CAPITAL S" #x1D61A)
+    ("MATHEMATICAL SANS-SERIF ITALIC CAPITAL T" #x1D61B)
+    ("MATHEMATICAL SANS-SERIF ITALIC CAPITAL U" #x1D61C)
+    ("MATHEMATICAL SANS-SERIF ITALIC CAPITAL V" #x1D61D)
+    ("MATHEMATICAL SANS-SERIF ITALIC CAPITAL W" #x1D61E)
+    ("MATHEMATICAL SANS-SERIF ITALIC CAPITAL X" #x1D61F)
+    ("MATHEMATICAL SANS-SERIF ITALIC CAPITAL Y" #x1D620)
+    ("MATHEMATICAL SANS-SERIF ITALIC CAPITAL Z" #x1D621)
+    ("MATHEMATICAL SANS-SERIF ITALIC SMALL A" #x1D622)
+    ("MATHEMATICAL SANS-SERIF ITALIC SMALL B" #x1D623)
+    ("MATHEMATICAL SANS-SERIF ITALIC SMALL C" #x1D624)
+    ("MATHEMATICAL SANS-SERIF ITALIC SMALL D" #x1D625)
+    ("MATHEMATICAL SANS-SERIF ITALIC SMALL E" #x1D626)
+    ("MATHEMATICAL SANS-SERIF ITALIC SMALL F" #x1D627)
+    ("MATHEMATICAL SANS-SERIF ITALIC SMALL G" #x1D628)
+    ("MATHEMATICAL SANS-SERIF ITALIC SMALL H" #x1D629)
+    ("MATHEMATICAL SANS-SERIF ITALIC SMALL I" #x1D62A)
+    ("MATHEMATICAL SANS-SERIF ITALIC SMALL J" #x1D62B)
+    ("MATHEMATICAL SANS-SERIF ITALIC SMALL K" #x1D62C)
+    ("MATHEMATICAL SANS-SERIF ITALIC SMALL L" #x1D62D)
+    ("MATHEMATICAL SANS-SERIF ITALIC SMALL M" #x1D62E)
+    ("MATHEMATICAL SANS-SERIF ITALIC SMALL N" #x1D62F)
+    ("MATHEMATICAL SANS-SERIF ITALIC SMALL O" #x1D630)
+    ("MATHEMATICAL SANS-SERIF ITALIC SMALL P" #x1D631)
+    ("MATHEMATICAL SANS-SERIF ITALIC SMALL Q" #x1D632)
+    ("MATHEMATICAL SANS-SERIF ITALIC SMALL R" #x1D633)
+    ("MATHEMATICAL SANS-SERIF ITALIC SMALL S" #x1D634)
+    ("MATHEMATICAL SANS-SERIF ITALIC SMALL T" #x1D635)
+    ("MATHEMATICAL SANS-SERIF ITALIC SMALL U" #x1D636)
+    ("MATHEMATICAL SANS-SERIF ITALIC SMALL V" #x1D637)
+    ("MATHEMATICAL SANS-SERIF ITALIC SMALL W" #x1D638)
+    ("MATHEMATICAL SANS-SERIF ITALIC SMALL X" #x1D639)
+    ("MATHEMATICAL SANS-SERIF ITALIC SMALL Y" #x1D63A)
+    ("MATHEMATICAL SANS-SERIF ITALIC SMALL Z" #x1D63B)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL A" #x1D63C)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL B" #x1D63D)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL C" #x1D63E)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL D" #x1D63F)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL E" #x1D640)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL F" #x1D641)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL G" #x1D642)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL H" #x1D643)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL I" #x1D644)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL J" #x1D645)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL K" #x1D646)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL L" #x1D647)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL M" #x1D648)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL N" #x1D649)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL O" #x1D64A)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL P" #x1D64B)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL Q" #x1D64C)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL R" #x1D64D)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL S" #x1D64E)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL T" #x1D64F)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL U" #x1D650)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL V" #x1D651)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL W" #x1D652)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL X" #x1D653)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL Y" #x1D654)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL Z" #x1D655)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL A" #x1D656)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL B" #x1D657)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL C" #x1D658)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL D" #x1D659)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL E" #x1D65A)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL F" #x1D65B)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL G" #x1D65C)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL H" #x1D65D)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL I" #x1D65E)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL J" #x1D65F)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL K" #x1D660)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL L" #x1D661)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL M" #x1D662)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL N" #x1D663)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL O" #x1D664)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL P" #x1D665)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL Q" #x1D666)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL R" #x1D667)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL S" #x1D668)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL T" #x1D669)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL U" #x1D66A)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL V" #x1D66B)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL W" #x1D66C)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL X" #x1D66D)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL Y" #x1D66E)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL Z" #x1D66F)
+    ("MATHEMATICAL MONOSPACE CAPITAL A" #x1D670)
+    ("MATHEMATICAL MONOSPACE CAPITAL B" #x1D671)
+    ("MATHEMATICAL MONOSPACE CAPITAL C" #x1D672)
+    ("MATHEMATICAL MONOSPACE CAPITAL D" #x1D673)
+    ("MATHEMATICAL MONOSPACE CAPITAL E" #x1D674)
+    ("MATHEMATICAL MONOSPACE CAPITAL F" #x1D675)
+    ("MATHEMATICAL MONOSPACE CAPITAL G" #x1D676)
+    ("MATHEMATICAL MONOSPACE CAPITAL H" #x1D677)
+    ("MATHEMATICAL MONOSPACE CAPITAL I" #x1D678)
+    ("MATHEMATICAL MONOSPACE CAPITAL J" #x1D679)
+    ("MATHEMATICAL MONOSPACE CAPITAL K" #x1D67A)
+    ("MATHEMATICAL MONOSPACE CAPITAL L" #x1D67B)
+    ("MATHEMATICAL MONOSPACE CAPITAL M" #x1D67C)
+    ("MATHEMATICAL MONOSPACE CAPITAL N" #x1D67D)
+    ("MATHEMATICAL MONOSPACE CAPITAL O" #x1D67E)
+    ("MATHEMATICAL MONOSPACE CAPITAL P" #x1D67F)
+    ("MATHEMATICAL MONOSPACE CAPITAL Q" #x1D680)
+    ("MATHEMATICAL MONOSPACE CAPITAL R" #x1D681)
+    ("MATHEMATICAL MONOSPACE CAPITAL S" #x1D682)
+    ("MATHEMATICAL MONOSPACE CAPITAL T" #x1D683)
+    ("MATHEMATICAL MONOSPACE CAPITAL U" #x1D684)
+    ("MATHEMATICAL MONOSPACE CAPITAL V" #x1D685)
+    ("MATHEMATICAL MONOSPACE CAPITAL W" #x1D686)
+    ("MATHEMATICAL MONOSPACE CAPITAL X" #x1D687)
+    ("MATHEMATICAL MONOSPACE CAPITAL Y" #x1D688)
+    ("MATHEMATICAL MONOSPACE CAPITAL Z" #x1D689)
+    ("MATHEMATICAL MONOSPACE SMALL A" #x1D68A)
+    ("MATHEMATICAL MONOSPACE SMALL B" #x1D68B)
+    ("MATHEMATICAL MONOSPACE SMALL C" #x1D68C)
+    ("MATHEMATICAL MONOSPACE SMALL D" #x1D68D)
+    ("MATHEMATICAL MONOSPACE SMALL E" #x1D68E)
+    ("MATHEMATICAL MONOSPACE SMALL F" #x1D68F)
+    ("MATHEMATICAL MONOSPACE SMALL G" #x1D690)
+    ("MATHEMATICAL MONOSPACE SMALL H" #x1D691)
+    ("MATHEMATICAL MONOSPACE SMALL I" #x1D692)
+    ("MATHEMATICAL MONOSPACE SMALL J" #x1D693)
+    ("MATHEMATICAL MONOSPACE SMALL K" #x1D694)
+    ("MATHEMATICAL MONOSPACE SMALL L" #x1D695)
+    ("MATHEMATICAL MONOSPACE SMALL M" #x1D696)
+    ("MATHEMATICAL MONOSPACE SMALL N" #x1D697)
+    ("MATHEMATICAL MONOSPACE SMALL O" #x1D698)
+    ("MATHEMATICAL MONOSPACE SMALL P" #x1D699)
+    ("MATHEMATICAL MONOSPACE SMALL Q" #x1D69A)
+    ("MATHEMATICAL MONOSPACE SMALL R" #x1D69B)
+    ("MATHEMATICAL MONOSPACE SMALL S" #x1D69C)
+    ("MATHEMATICAL MONOSPACE SMALL T" #x1D69D)
+    ("MATHEMATICAL MONOSPACE SMALL U" #x1D69E)
+    ("MATHEMATICAL MONOSPACE SMALL V" #x1D69F)
+    ("MATHEMATICAL MONOSPACE SMALL W" #x1D6A0)
+    ("MATHEMATICAL MONOSPACE SMALL X" #x1D6A1)
+    ("MATHEMATICAL MONOSPACE SMALL Y" #x1D6A2)
+    ("MATHEMATICAL MONOSPACE SMALL Z" #x1D6A3)
+    ("MATHEMATICAL BOLD CAPITAL ALPHA" #x1D6A8)
+    ("MATHEMATICAL BOLD CAPITAL BETA" #x1D6A9)
+    ("MATHEMATICAL BOLD CAPITAL GAMMA" #x1D6AA)
+    ("MATHEMATICAL BOLD CAPITAL DELTA" #x1D6AB)
+    ("MATHEMATICAL BOLD CAPITAL EPSILON" #x1D6AC)
+    ("MATHEMATICAL BOLD CAPITAL ZETA" #x1D6AD)
+    ("MATHEMATICAL BOLD CAPITAL ETA" #x1D6AE)
+    ("MATHEMATICAL BOLD CAPITAL THETA" #x1D6AF)
+    ("MATHEMATICAL BOLD CAPITAL IOTA" #x1D6B0)
+    ("MATHEMATICAL BOLD CAPITAL KAPPA" #x1D6B1)
+    ("MATHEMATICAL BOLD CAPITAL LAMDA" #x1D6B2)
+    ("MATHEMATICAL BOLD CAPITAL MU" #x1D6B3)
+    ("MATHEMATICAL BOLD CAPITAL NU" #x1D6B4)
+    ("MATHEMATICAL BOLD CAPITAL XI" #x1D6B5)
+    ("MATHEMATICAL BOLD CAPITAL OMICRON" #x1D6B6)
+    ("MATHEMATICAL BOLD CAPITAL PI" #x1D6B7)
+    ("MATHEMATICAL BOLD CAPITAL RHO" #x1D6B8)
+    ("MATHEMATICAL BOLD CAPITAL THETA SYMBOL" #x1D6B9)
+    ("MATHEMATICAL BOLD CAPITAL SIGMA" #x1D6BA)
+    ("MATHEMATICAL BOLD CAPITAL TAU" #x1D6BB)
+    ("MATHEMATICAL BOLD CAPITAL UPSILON" #x1D6BC)
+    ("MATHEMATICAL BOLD CAPITAL PHI" #x1D6BD)
+    ("MATHEMATICAL BOLD CAPITAL CHI" #x1D6BE)
+    ("MATHEMATICAL BOLD CAPITAL PSI" #x1D6BF)
+    ("MATHEMATICAL BOLD CAPITAL OMEGA" #x1D6C0)
+    ("MATHEMATICAL BOLD NABLA" #x1D6C1)
+    ("MATHEMATICAL BOLD SMALL ALPHA" #x1D6C2)
+    ("MATHEMATICAL BOLD SMALL BETA" #x1D6C3)
+    ("MATHEMATICAL BOLD SMALL GAMMA" #x1D6C4)
+    ("MATHEMATICAL BOLD SMALL DELTA" #x1D6C5)
+    ("MATHEMATICAL BOLD SMALL EPSILON" #x1D6C6)
+    ("MATHEMATICAL BOLD SMALL ZETA" #x1D6C7)
+    ("MATHEMATICAL BOLD SMALL ETA" #x1D6C8)
+    ("MATHEMATICAL BOLD SMALL THETA" #x1D6C9)
+    ("MATHEMATICAL BOLD SMALL IOTA" #x1D6CA)
+    ("MATHEMATICAL BOLD SMALL KAPPA" #x1D6CB)
+    ("MATHEMATICAL BOLD SMALL LAMDA" #x1D6CC)
+    ("MATHEMATICAL BOLD SMALL MU" #x1D6CD)
+    ("MATHEMATICAL BOLD SMALL NU" #x1D6CE)
+    ("MATHEMATICAL BOLD SMALL XI" #x1D6CF)
+    ("MATHEMATICAL BOLD SMALL OMICRON" #x1D6D0)
+    ("MATHEMATICAL BOLD SMALL PI" #x1D6D1)
+    ("MATHEMATICAL BOLD SMALL RHO" #x1D6D2)
+    ("MATHEMATICAL BOLD SMALL FINAL SIGMA" #x1D6D3)
+    ("MATHEMATICAL BOLD SMALL SIGMA" #x1D6D4)
+    ("MATHEMATICAL BOLD SMALL TAU" #x1D6D5)
+    ("MATHEMATICAL BOLD SMALL UPSILON" #x1D6D6)
+    ("MATHEMATICAL BOLD SMALL PHI" #x1D6D7)
+    ("MATHEMATICAL BOLD SMALL CHI" #x1D6D8)
+    ("MATHEMATICAL BOLD SMALL PSI" #x1D6D9)
+    ("MATHEMATICAL BOLD SMALL OMEGA" #x1D6DA)
+    ("MATHEMATICAL BOLD PARTIAL DIFFERENTIAL" #x1D6DB)
+    ("MATHEMATICAL BOLD EPSILON SYMBOL" #x1D6DC)
+    ("MATHEMATICAL BOLD THETA SYMBOL" #x1D6DD)
+    ("MATHEMATICAL BOLD KAPPA SYMBOL" #x1D6DE)
+    ("MATHEMATICAL BOLD PHI SYMBOL" #x1D6DF)
+    ("MATHEMATICAL BOLD RHO SYMBOL" #x1D6E0)
+    ("MATHEMATICAL BOLD PI SYMBOL" #x1D6E1)
+    ("MATHEMATICAL ITALIC CAPITAL ALPHA" #x1D6E2)
+    ("MATHEMATICAL ITALIC CAPITAL BETA" #x1D6E3)
+    ("MATHEMATICAL ITALIC CAPITAL GAMMA" #x1D6E4)
+    ("MATHEMATICAL ITALIC CAPITAL DELTA" #x1D6E5)
+    ("MATHEMATICAL ITALIC CAPITAL EPSILON" #x1D6E6)
+    ("MATHEMATICAL ITALIC CAPITAL ZETA" #x1D6E7)
+    ("MATHEMATICAL ITALIC CAPITAL ETA" #x1D6E8)
+    ("MATHEMATICAL ITALIC CAPITAL THETA" #x1D6E9)
+    ("MATHEMATICAL ITALIC CAPITAL IOTA" #x1D6EA)
+    ("MATHEMATICAL ITALIC CAPITAL KAPPA" #x1D6EB)
+    ("MATHEMATICAL ITALIC CAPITAL LAMDA" #x1D6EC)
+    ("MATHEMATICAL ITALIC CAPITAL MU" #x1D6ED)
+    ("MATHEMATICAL ITALIC CAPITAL NU" #x1D6EE)
+    ("MATHEMATICAL ITALIC CAPITAL XI" #x1D6EF)
+    ("MATHEMATICAL ITALIC CAPITAL OMICRON" #x1D6F0)
+    ("MATHEMATICAL ITALIC CAPITAL PI" #x1D6F1)
+    ("MATHEMATICAL ITALIC CAPITAL RHO" #x1D6F2)
+    ("MATHEMATICAL ITALIC CAPITAL THETA SYMBOL" #x1D6F3)
+    ("MATHEMATICAL ITALIC CAPITAL SIGMA" #x1D6F4)
+    ("MATHEMATICAL ITALIC CAPITAL TAU" #x1D6F5)
+    ("MATHEMATICAL ITALIC CAPITAL UPSILON" #x1D6F6)
+    ("MATHEMATICAL ITALIC CAPITAL PHI" #x1D6F7)
+    ("MATHEMATICAL ITALIC CAPITAL CHI" #x1D6F8)
+    ("MATHEMATICAL ITALIC CAPITAL PSI" #x1D6F9)
+    ("MATHEMATICAL ITALIC CAPITAL OMEGA" #x1D6FA)
+    ("MATHEMATICAL ITALIC NABLA" #x1D6FB)
+    ("MATHEMATICAL ITALIC SMALL ALPHA" #x1D6FC)
+    ("MATHEMATICAL ITALIC SMALL BETA" #x1D6FD)
+    ("MATHEMATICAL ITALIC SMALL GAMMA" #x1D6FE)
+    ("MATHEMATICAL ITALIC SMALL DELTA" #x1D6FF)
+    ("MATHEMATICAL ITALIC SMALL EPSILON" #x1D700)
+    ("MATHEMATICAL ITALIC SMALL ZETA" #x1D701)
+    ("MATHEMATICAL ITALIC SMALL ETA" #x1D702)
+    ("MATHEMATICAL ITALIC SMALL THETA" #x1D703)
+    ("MATHEMATICAL ITALIC SMALL IOTA" #x1D704)
+    ("MATHEMATICAL ITALIC SMALL KAPPA" #x1D705)
+    ("MATHEMATICAL ITALIC SMALL LAMDA" #x1D706)
+    ("MATHEMATICAL ITALIC SMALL MU" #x1D707)
+    ("MATHEMATICAL ITALIC SMALL NU" #x1D708)
+    ("MATHEMATICAL ITALIC SMALL XI" #x1D709)
+    ("MATHEMATICAL ITALIC SMALL OMICRON" #x1D70A)
+    ("MATHEMATICAL ITALIC SMALL PI" #x1D70B)
+    ("MATHEMATICAL ITALIC SMALL RHO" #x1D70C)
+    ("MATHEMATICAL ITALIC SMALL FINAL SIGMA" #x1D70D)
+    ("MATHEMATICAL ITALIC SMALL SIGMA" #x1D70E)
+    ("MATHEMATICAL ITALIC SMALL TAU" #x1D70F)
+    ("MATHEMATICAL ITALIC SMALL UPSILON" #x1D710)
+    ("MATHEMATICAL ITALIC SMALL PHI" #x1D711)
+    ("MATHEMATICAL ITALIC SMALL CHI" #x1D712)
+    ("MATHEMATICAL ITALIC SMALL PSI" #x1D713)
+    ("MATHEMATICAL ITALIC SMALL OMEGA" #x1D714)
+    ("MATHEMATICAL ITALIC PARTIAL DIFFERENTIAL" #x1D715)
+    ("MATHEMATICAL ITALIC EPSILON SYMBOL" #x1D716)
+    ("MATHEMATICAL ITALIC THETA SYMBOL" #x1D717)
+    ("MATHEMATICAL ITALIC KAPPA SYMBOL" #x1D718)
+    ("MATHEMATICAL ITALIC PHI SYMBOL" #x1D719)
+    ("MATHEMATICAL ITALIC RHO SYMBOL" #x1D71A)
+    ("MATHEMATICAL ITALIC PI SYMBOL" #x1D71B)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL ALPHA" #x1D71C)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL BETA" #x1D71D)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL GAMMA" #x1D71E)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL DELTA" #x1D71F)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL EPSILON" #x1D720)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL ZETA" #x1D721)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL ETA" #x1D722)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL THETA" #x1D723)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL IOTA" #x1D724)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL KAPPA" #x1D725)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL LAMDA" #x1D726)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL MU" #x1D727)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL NU" #x1D728)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL XI" #x1D729)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL OMICRON" #x1D72A)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL PI" #x1D72B)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL RHO" #x1D72C)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL THETA SYMBOL" #x1D72D)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL SIGMA" #x1D72E)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL TAU" #x1D72F)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL UPSILON" #x1D730)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL PHI" #x1D731)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL CHI" #x1D732)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL PSI" #x1D733)
+    ("MATHEMATICAL BOLD ITALIC CAPITAL OMEGA" #x1D734)
+    ("MATHEMATICAL BOLD ITALIC NABLA" #x1D735)
+    ("MATHEMATICAL BOLD ITALIC SMALL ALPHA" #x1D736)
+    ("MATHEMATICAL BOLD ITALIC SMALL BETA" #x1D737)
+    ("MATHEMATICAL BOLD ITALIC SMALL GAMMA" #x1D738)
+    ("MATHEMATICAL BOLD ITALIC SMALL DELTA" #x1D739)
+    ("MATHEMATICAL BOLD ITALIC SMALL EPSILON" #x1D73A)
+    ("MATHEMATICAL BOLD ITALIC SMALL ZETA" #x1D73B)
+    ("MATHEMATICAL BOLD ITALIC SMALL ETA" #x1D73C)
+    ("MATHEMATICAL BOLD ITALIC SMALL THETA" #x1D73D)
+    ("MATHEMATICAL BOLD ITALIC SMALL IOTA" #x1D73E)
+    ("MATHEMATICAL BOLD ITALIC SMALL KAPPA" #x1D73F)
+    ("MATHEMATICAL BOLD ITALIC SMALL LAMDA" #x1D740)
+    ("MATHEMATICAL BOLD ITALIC SMALL MU" #x1D741)
+    ("MATHEMATICAL BOLD ITALIC SMALL NU" #x1D742)
+    ("MATHEMATICAL BOLD ITALIC SMALL XI" #x1D743)
+    ("MATHEMATICAL BOLD ITALIC SMALL OMICRON" #x1D744)
+    ("MATHEMATICAL BOLD ITALIC SMALL PI" #x1D745)
+    ("MATHEMATICAL BOLD ITALIC SMALL RHO" #x1D746)
+    ("MATHEMATICAL BOLD ITALIC SMALL FINAL SIGMA" #x1D747)
+    ("MATHEMATICAL BOLD ITALIC SMALL SIGMA" #x1D748)
+    ("MATHEMATICAL BOLD ITALIC SMALL TAU" #x1D749)
+    ("MATHEMATICAL BOLD ITALIC SMALL UPSILON" #x1D74A)
+    ("MATHEMATICAL BOLD ITALIC SMALL PHI" #x1D74B)
+    ("MATHEMATICAL BOLD ITALIC SMALL CHI" #x1D74C)
+    ("MATHEMATICAL BOLD ITALIC SMALL PSI" #x1D74D)
+    ("MATHEMATICAL BOLD ITALIC SMALL OMEGA" #x1D74E)
+    ("MATHEMATICAL BOLD ITALIC PARTIAL DIFFERENTIAL" #x1D74F)
+    ("MATHEMATICAL BOLD ITALIC EPSILON SYMBOL" #x1D750)
+    ("MATHEMATICAL BOLD ITALIC THETA SYMBOL" #x1D751)
+    ("MATHEMATICAL BOLD ITALIC KAPPA SYMBOL" #x1D752)
+    ("MATHEMATICAL BOLD ITALIC PHI SYMBOL" #x1D753)
+    ("MATHEMATICAL BOLD ITALIC RHO SYMBOL" #x1D754)
+    ("MATHEMATICAL BOLD ITALIC PI SYMBOL" #x1D755)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL ALPHA" #x1D756)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL BETA" #x1D757)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL GAMMA" #x1D758)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL DELTA" #x1D759)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL EPSILON" #x1D75A)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL ZETA" #x1D75B)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL ETA" #x1D75C)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL THETA" #x1D75D)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL IOTA" #x1D75E)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL KAPPA" #x1D75F)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL LAMDA" #x1D760)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL MU" #x1D761)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL NU" #x1D762)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL XI" #x1D763)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL OMICRON" #x1D764)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL PI" #x1D765)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL RHO" #x1D766)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL THETA SYMBOL" #x1D767)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL SIGMA" #x1D768)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL TAU" #x1D769)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL UPSILON" #x1D76A)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL PHI" #x1D76B)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL CHI" #x1D76C)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL PSI" #x1D76D)
+    ("MATHEMATICAL SANS-SERIF BOLD CAPITAL OMEGA" #x1D76E)
+    ("MATHEMATICAL SANS-SERIF BOLD NABLA" #x1D76F)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL ALPHA" #x1D770)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL BETA" #x1D771)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL GAMMA" #x1D772)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL DELTA" #x1D773)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL EPSILON" #x1D774)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL ZETA" #x1D775)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL ETA" #x1D776)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL THETA" #x1D777)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL IOTA" #x1D778)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL KAPPA" #x1D779)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL LAMDA" #x1D77A)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL MU" #x1D77B)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL NU" #x1D77C)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL XI" #x1D77D)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL OMICRON" #x1D77E)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL PI" #x1D77F)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL RHO" #x1D780)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL FINAL SIGMA" #x1D781)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL SIGMA" #x1D782)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL TAU" #x1D783)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL UPSILON" #x1D784)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL PHI" #x1D785)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL CHI" #x1D786)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL PSI" #x1D787)
+    ("MATHEMATICAL SANS-SERIF BOLD SMALL OMEGA" #x1D788)
+    ("MATHEMATICAL SANS-SERIF BOLD PARTIAL DIFFERENTIAL" #x1D789)
+    ("MATHEMATICAL SANS-SERIF BOLD EPSILON SYMBOL" #x1D78A)
+    ("MATHEMATICAL SANS-SERIF BOLD THETA SYMBOL" #x1D78B)
+    ("MATHEMATICAL SANS-SERIF BOLD KAPPA SYMBOL" #x1D78C)
+    ("MATHEMATICAL SANS-SERIF BOLD PHI SYMBOL" #x1D78D)
+    ("MATHEMATICAL SANS-SERIF BOLD RHO SYMBOL" #x1D78E)
+    ("MATHEMATICAL SANS-SERIF BOLD PI SYMBOL" #x1D78F)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL ALPHA" #x1D790)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL BETA" #x1D791)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL GAMMA" #x1D792)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL DELTA" #x1D793)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL EPSILON" #x1D794)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL ZETA" #x1D795)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL ETA" #x1D796)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL THETA" #x1D797)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL IOTA" #x1D798)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL KAPPA" #x1D799)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL LAMDA" #x1D79A)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL MU" #x1D79B)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL NU" #x1D79C)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL XI" #x1D79D)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL OMICRON" #x1D79E)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL PI" #x1D79F)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL RHO" #x1D7A0)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL THETA SYMBOL" #x1D7A1)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL SIGMA" #x1D7A2)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL TAU" #x1D7A3)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL UPSILON" #x1D7A4)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL PHI" #x1D7A5)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL CHI" #x1D7A6)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL PSI" #x1D7A7)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL OMEGA" #x1D7A8)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC NABLA" #x1D7A9)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL ALPHA" #x1D7AA)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL BETA" #x1D7AB)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL GAMMA" #x1D7AC)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL DELTA" #x1D7AD)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL EPSILON" #x1D7AE)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL ZETA" #x1D7AF)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL ETA" #x1D7B0)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL THETA" #x1D7B1)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL IOTA" #x1D7B2)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL KAPPA" #x1D7B3)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL LAMDA" #x1D7B4)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL MU" #x1D7B5)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL NU" #x1D7B6)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL XI" #x1D7B7)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL OMICRON" #x1D7B8)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL PI" #x1D7B9)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL RHO" #x1D7BA)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL FINAL SIGMA" #x1D7BB)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL SIGMA" #x1D7BC)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL TAU" #x1D7BD)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL UPSILON" #x1D7BE)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL PHI" #x1D7BF)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL CHI" #x1D7C0)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL PSI" #x1D7C1)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL OMEGA" #x1D7C2)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC PARTIAL DIFFERENTIAL" #x1D7C3)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC EPSILON SYMBOL" #x1D7C4)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC THETA SYMBOL" #x1D7C5)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC KAPPA SYMBOL" #x1D7C6)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC PHI SYMBOL" #x1D7C7)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC RHO SYMBOL" #x1D7C8)
+    ("MATHEMATICAL SANS-SERIF BOLD ITALIC PI SYMBOL" #x1D7C9)
+    ("MATHEMATICAL BOLD DIGIT ZERO" #x1D7CE)
+    ("MATHEMATICAL BOLD DIGIT ONE" #x1D7CF)
+    ("MATHEMATICAL BOLD DIGIT TWO" #x1D7D0)
+    ("MATHEMATICAL BOLD DIGIT THREE" #x1D7D1)
+    ("MATHEMATICAL BOLD DIGIT FOUR" #x1D7D2)
+    ("MATHEMATICAL BOLD DIGIT FIVE" #x1D7D3)
+    ("MATHEMATICAL BOLD DIGIT SIX" #x1D7D4)
+    ("MATHEMATICAL BOLD DIGIT SEVEN" #x1D7D5)
+    ("MATHEMATICAL BOLD DIGIT EIGHT" #x1D7D6)
+    ("MATHEMATICAL BOLD DIGIT NINE" #x1D7D7)
+    ("MATHEMATICAL DOUBLE-STRUCK DIGIT ZERO" #x1D7D8)
+    ("MATHEMATICAL DOUBLE-STRUCK DIGIT ONE" #x1D7D9)
+    ("MATHEMATICAL DOUBLE-STRUCK DIGIT TWO" #x1D7DA)
+    ("MATHEMATICAL DOUBLE-STRUCK DIGIT THREE" #x1D7DB)
+    ("MATHEMATICAL DOUBLE-STRUCK DIGIT FOUR" #x1D7DC)
+    ("MATHEMATICAL DOUBLE-STRUCK DIGIT FIVE" #x1D7DD)
+    ("MATHEMATICAL DOUBLE-STRUCK DIGIT SIX" #x1D7DE)
+    ("MATHEMATICAL DOUBLE-STRUCK DIGIT SEVEN" #x1D7DF)
+    ("MATHEMATICAL DOUBLE-STRUCK DIGIT EIGHT" #x1D7E0)
+    ("MATHEMATICAL DOUBLE-STRUCK DIGIT NINE" #x1D7E1)
+    ("MATHEMATICAL SANS-SERIF DIGIT ZERO" #x1D7E2)
+    ("MATHEMATICAL SANS-SERIF DIGIT ONE" #x1D7E3)
+    ("MATHEMATICAL SANS-SERIF DIGIT TWO" #x1D7E4)
+    ("MATHEMATICAL SANS-SERIF DIGIT THREE" #x1D7E5)
+    ("MATHEMATICAL SANS-SERIF DIGIT FOUR" #x1D7E6)
+    ("MATHEMATICAL SANS-SERIF DIGIT FIVE" #x1D7E7)
+    ("MATHEMATICAL SANS-SERIF DIGIT SIX" #x1D7E8)
+    ("MATHEMATICAL SANS-SERIF DIGIT SEVEN" #x1D7E9)
+    ("MATHEMATICAL SANS-SERIF DIGIT EIGHT" #x1D7EA)
+    ("MATHEMATICAL SANS-SERIF DIGIT NINE" #x1D7EB)
+    ("MATHEMATICAL SANS-SERIF BOLD DIGIT ZERO" #x1D7EC)
+    ("MATHEMATICAL SANS-SERIF BOLD DIGIT ONE" #x1D7ED)
+    ("MATHEMATICAL SANS-SERIF BOLD DIGIT TWO" #x1D7EE)
+    ("MATHEMATICAL SANS-SERIF BOLD DIGIT THREE" #x1D7EF)
+    ("MATHEMATICAL SANS-SERIF BOLD DIGIT FOUR" #x1D7F0)
+    ("MATHEMATICAL SANS-SERIF BOLD DIGIT FIVE" #x1D7F1)
+    ("MATHEMATICAL SANS-SERIF BOLD DIGIT SIX" #x1D7F2)
+    ("MATHEMATICAL SANS-SERIF BOLD DIGIT SEVEN" #x1D7F3)
+    ("MATHEMATICAL SANS-SERIF BOLD DIGIT EIGHT" #x1D7F4)
+    ("MATHEMATICAL SANS-SERIF BOLD DIGIT NINE" #x1D7F5)
+    ("MATHEMATICAL MONOSPACE DIGIT ZERO" #x1D7F6)
+    ("MATHEMATICAL MONOSPACE DIGIT ONE" #x1D7F7)
+    ("MATHEMATICAL MONOSPACE DIGIT TWO" #x1D7F8)
+    ("MATHEMATICAL MONOSPACE DIGIT THREE" #x1D7F9)
+    ("MATHEMATICAL MONOSPACE DIGIT FOUR" #x1D7FA)
+    ("MATHEMATICAL MONOSPACE DIGIT FIVE" #x1D7FB)
+    ("MATHEMATICAL MONOSPACE DIGIT SIX" #x1D7FC)
+    ("MATHEMATICAL MONOSPACE DIGIT SEVEN" #x1D7FD)
+    ("MATHEMATICAL MONOSPACE DIGIT EIGHT" #x1D7FE)
+    ("MATHEMATICAL MONOSPACE DIGIT NINE" #x1D7FF)
+    ))
diff --git a/lisp/nxml/char-name/unicode/E0000-E007F.el b/lisp/nxml/char-name/unicode/E0000-E007F.el
new file mode 100644
index 00000000000..b4aeb1fd2b4
--- /dev/null
+++ b/lisp/nxml/char-name/unicode/E0000-E007F.el
@@ -0,0 +1,99 @@
+(nxml-define-char-name-set 'tags
+  '(("LANGUAGE TAG" #xE0001)
+    ("TAG SPACE" #xE0020)
+    ("TAG EXCLAMATION MARK" #xE0021)
+    ("TAG QUOTATION MARK" #xE0022)
+    ("TAG NUMBER SIGN" #xE0023)
+    ("TAG DOLLAR SIGN" #xE0024)
+    ("TAG PERCENT SIGN" #xE0025)
+    ("TAG AMPERSAND" #xE0026)
+    ("TAG APOSTROPHE" #xE0027)
+    ("TAG LEFT PARENTHESIS" #xE0028)
+    ("TAG RIGHT PARENTHESIS" #xE0029)
+    ("TAG ASTERISK" #xE002A)
+    ("TAG PLUS SIGN" #xE002B)
+    ("TAG COMMA" #xE002C)
+    ("TAG HYPHEN-MINUS" #xE002D)
+    ("TAG FULL STOP" #xE002E)
+    ("TAG SOLIDUS" #xE002F)
+    ("TAG DIGIT ZERO" #xE0030)
+    ("TAG DIGIT ONE" #xE0031)
+    ("TAG DIGIT TWO" #xE0032)
+    ("TAG DIGIT THREE" #xE0033)
+    ("TAG DIGIT FOUR" #xE0034)
+    ("TAG DIGIT FIVE" #xE0035)
+    ("TAG DIGIT SIX" #xE0036)
+    ("TAG DIGIT SEVEN" #xE0037)
+    ("TAG DIGIT EIGHT" #xE0038)
+    ("TAG DIGIT NINE" #xE0039)
+    ("TAG COLON" #xE003A)
+    ("TAG SEMICOLON" #xE003B)
+    ("TAG LESS-THAN SIGN" #xE003C)
+    ("TAG EQUALS SIGN" #xE003D)
+    ("TAG GREATER-THAN SIGN" #xE003E)
+    ("TAG QUESTION MARK" #xE003F)
+    ("TAG COMMERCIAL AT" #xE0040)
+    ("TAG LATIN CAPITAL LETTER A" #xE0041)
+    ("TAG LATIN CAPITAL LETTER B" #xE0042)
+    ("TAG LATIN CAPITAL LETTER C" #xE0043)
+    ("TAG LATIN CAPITAL LETTER D" #xE0044)
+    ("TAG LATIN CAPITAL LETTER E" #xE0045)
+    ("TAG LATIN CAPITAL LETTER F" #xE0046)
+    ("TAG LATIN CAPITAL LETTER G" #xE0047)
+    ("TAG LATIN CAPITAL LETTER H" #xE0048)
+    ("TAG LATIN CAPITAL LETTER I" #xE0049)
+    ("TAG LATIN CAPITAL LETTER J" #xE004A)
+    ("TAG LATIN CAPITAL LETTER K" #xE004B)
+    ("TAG LATIN CAPITAL LETTER L" #xE004C)
+    ("TAG LATIN CAPITAL LETTER M" #xE004D)
+    ("TAG LATIN CAPITAL LETTER N" #xE004E)
+    ("TAG LATIN CAPITAL LETTER O" #xE004F)
+    ("TAG LATIN CAPITAL LETTER P" #xE0050)
+    ("TAG LATIN CAPITAL LETTER Q" #xE0051)
+    ("TAG LATIN CAPITAL LETTER R" #xE0052)
+    ("TAG LATIN CAPITAL LETTER S" #xE0053)
+    ("TAG LATIN CAPITAL LETTER T" #xE0054)
+    ("TAG LATIN CAPITAL LETTER U" #xE0055)
+    ("TAG LATIN CAPITAL LETTER V" #xE0056)
+    ("TAG LATIN CAPITAL LETTER W" #xE0057)
+    ("TAG LATIN CAPITAL LETTER X" #xE0058)
+    ("TAG LATIN CAPITAL LETTER Y" #xE0059)
+    ("TAG LATIN CAPITAL LETTER Z" #xE005A)
+    ("TAG LEFT SQUARE BRACKET" #xE005B)
+    ("TAG REVERSE SOLIDUS" #xE005C)
+    ("TAG RIGHT SQUARE BRACKET" #xE005D)
+    ("TAG CIRCUMFLEX ACCENT" #xE005E)
+    ("TAG LOW LINE" #xE005F)
+    ("TAG GRAVE ACCENT" #xE0060)
+    ("TAG LATIN SMALL LETTER A" #xE0061)
+    ("TAG LATIN SMALL LETTER B" #xE0062)
+    ("TAG LATIN SMALL LETTER C" #xE0063)
+    ("TAG LATIN SMALL LETTER D" #xE0064)
+    ("TAG LATIN SMALL LETTER E" #xE0065)
+    ("TAG LATIN SMALL LETTER F" #xE0066)
+    ("TAG LATIN SMALL LETTER G" #xE0067)
+    ("TAG LATIN SMALL LETTER H" #xE0068)
+    ("TAG LATIN SMALL LETTER I" #xE0069)
+    ("TAG LATIN SMALL LETTER J" #xE006A)
+    ("TAG LATIN SMALL LETTER K" #xE006B)
+    ("TAG LATIN SMALL LETTER L" #xE006C)
+    ("TAG LATIN SMALL LETTER M" #xE006D)
+    ("TAG LATIN SMALL LETTER N" #xE006E)
+    ("TAG LATIN SMALL LETTER O" #xE006F)
+    ("TAG LATIN SMALL LETTER P" #xE0070)
+    ("TAG LATIN SMALL LETTER Q" #xE0071)
+    ("TAG LATIN SMALL LETTER R" #xE0072)
+    ("TAG LATIN SMALL LETTER S" #xE0073)
+    ("TAG LATIN SMALL LETTER T" #xE0074)
+    ("TAG LATIN SMALL LETTER U" #xE0075)
+    ("TAG LATIN SMALL LETTER V" #xE0076)
+    ("TAG LATIN SMALL LETTER W" #xE0077)
+    ("TAG LATIN SMALL LETTER X" #xE0078)
+    ("TAG LATIN SMALL LETTER Y" #xE0079)
+    ("TAG LATIN SMALL LETTER Z" #xE007A)
+    ("TAG LEFT CURLY BRACKET" #xE007B)
+    ("TAG VERTICAL LINE" #xE007C)
+    ("TAG RIGHT CURLY BRACKET" #xE007D)
+    ("TAG TILDE" #xE007E)
+    ("CANCEL TAG" #xE007F)
+    ))
diff --git a/lisp/nxml/nxml-enc.el b/lisp/nxml/nxml-enc.el
new file mode 100644
index 00000000000..ba75580301a
--- /dev/null
+++ b/lisp/nxml/nxml-enc.el
@@ -0,0 +1,167 @@
+;;; nxml-enc.el --- XML encoding auto-detection
+
+;; Copyright (C) 2003 Free Software Foundation, Inc.
+
+;; Author: James Clark
+;; Keywords: XML
+
+;; This program is free software; you can redistribute it and/or
+;; modify it under the terms of the GNU General Public License as
+;; published by the Free Software Foundation; either version 2 of
+;; the License, or (at your option) any later version.
+
+;; This program is distributed in the hope that it will be
+;; useful, but WITHOUT ANY WARRANTY; without even the implied
+;; warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+;; PURPOSE.  See the GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public
+;; License along with this program; if not, write to the Free
+;; Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+;; MA 02111-1307 USA
+
+;;; Commentary:
+
+;; User entry points are nxml-start-auto-coding and
+;; nxml-stop-auto-coding.  This is separate from nxml-mode, because
+;; this cannot be autoloaded.  It may use
+;; `xmltok-get-declared-encoding-position' which can be autoloaded.
+;; It's separate from rng-auto.el so it can be byte-compiled, and
+;; because it provides independent, useful functionality.
+
+;;; Code:
+
+(defvar nxml-file-name-ignore-case
+  (memq system-type '(vax-vms windows-nt)))
+
+(defvar nxml-cached-file-name-auto-coding-regexp nil)
+(defvar nxml-cached-auto-mode-alist nil)
+
+(defun nxml-file-name-auto-coding-regexp ()
+  "Return regexp for filenames for which XML auto-coding should be done."
+  (if (eq auto-mode-alist nxml-cached-auto-mode-alist)
+      nxml-cached-file-name-auto-coding-regexp
+    (let ((alist auto-mode-alist)
+          (case-fold-search nxml-file-name-ignore-case)
+          regexps)
+      (setq nxml-cached-auto-mode-alist alist)
+      (while alist
+        (when (eq (cdar alist) 'nxml-mode)
+          (setq regexps (cons (caar alist) regexps)))
+        (setq alist (cdr alist)))
+      (setq nxml-cached-file-name-auto-coding-regexp
+            (if (null (cdr regexps))
+                (car regexps)
+              (mapconcat (lambda (r)
+                           (concat "\\(?:" r "\\)"))
+                         regexps
+                         "\\|"))))))
+
+(defvar nxml-non-xml-set-auto-coding-function nil
+  "The function that `set-auto-coding-function' should call for non-XML files.")
+(defun nxml-set-auto-coding (file-name size)
+  (if (let ((case-fold-search nxml-file-name-ignore-case)
+            (regexp (nxml-file-name-auto-coding-regexp)))
+        (and regexp
+             (string-match regexp file-name)))
+      (nxml-set-xml-coding file-name size)
+    (and nxml-non-xml-set-auto-coding-function
+         (funcall nxml-non-xml-set-auto-coding-function file-name size))))
+
+(defun nxml-set-xml-coding (file-name size)
+  "Function to use as `set-auto-coding-function' when file is known to be XML."
+  (nxml-detect-coding-system (+ (point) (min size 1024))))
+
+(defun nxml-detect-coding-system (limit)
+  (if (< limit (+ (point) 2))
+      (if (eq (char-after) 0) 'no-conversion 'utf-8)
+    (let ((first-two-chars (list (char-after)
+                                 (char-after (1+ (point))))))
+      (cond ((equal first-two-chars '(#xFE #xFF))
+             (and (coding-system-p 'utf-16-be) 'utf-16-be))
+            ((equal first-two-chars '(#xFF #xFE))
+             (and (coding-system-p 'utf-16-le) 'utf-16-le))
+            ((memq 0 first-two-chars)
+             ;; Certainly not well-formed XML;
+             ;; perhaps UTF-16 without BOM.
+             ;; In any case, we can't handle it.
+             ;; no-conversion gives the user a chance to fix it.
+             'no-conversion)
+            ;; There are other things we might try here in the future
+            ;; eg UTF-8 BOM, UTF-16 with no BOM 
+            ;; translate to EBCDIC
+            (t
+             (let ((enc-pos (xmltok-get-declared-encoding-position limit)))
+               (cond ((consp enc-pos)
+                      (or (nxml-mime-charset-coding-system
+                           (buffer-substring-no-properties (car enc-pos)
+                                                           (cdr enc-pos)))
+                          ;; We have an encoding whose name we don't recognize.
+                          ;; What to do?
+                          ;; raw-text seems the best bet: since we got
+                          ;; the XML decl it must be a superset of ASCII,
+                          ;; so we don't need to go to no-conversion
+                          'raw-text))
+                     (enc-pos 'utf-8)
+                     ;; invalid XML declaration
+                     (t nil))))))))
+
+(defun nxml-mime-charset-coding-system (charset)
+  (let ((charset-sym (intern (downcase charset)))
+        (coding-systems (coding-system-list t))
+        coding-system ret)
+    (while (and coding-systems (not ret))
+      (setq coding-system (car coding-systems))
+      (if (eq (coding-system-get coding-system 'mime-charset)
+              charset-sym)
+          (setq ret coding-system)
+        (setq coding-systems (cdr coding-systems))))
+    ret))
+
+(defun nxml-start-auto-coding ()
+  "Do encoding auto-detection as specified in the XML standard.
+Applied to any files that `auto-mode-alist' says should be handled by
+`nxml-mode'."
+  (interactive)
+  (unless (eq set-auto-coding-function 'nxml-set-auto-coding)
+    (let ((inhibit-quit t))
+      (setq nxml-non-xml-set-auto-coding-function set-auto-coding-function)
+      (setq set-auto-coding-function 'nxml-set-auto-coding))))
+
+(defun nxml-stop-auto-coding ()
+  "Stop doing encoding auto-detection as specified in the XML standard."
+  (interactive)
+  (when (eq set-auto-coding-function 'nxml-set-auto-coding)
+    (let ((inhibit-quit t))
+      (setq set-auto-coding-function nxml-non-xml-set-auto-coding-function)
+      (setq nxml-non-xml-set-auto-coding-function nil))))
+
+(unless (coding-system-p 'us-ascii)
+  (make-coding-system
+   ;; Unicode Emacs uses ?- last time I looked
+   'us-ascii 2 ?-
+   "ISO 2022 based 7-bit encoding for ASCII (MIME:US-ASCII)"
+   '(ascii)
+   '((safe-charsets ascii)
+     (mime-charset . us-ascii))))
+
+;; Emacs 21.3.50 makes us-ascii an alias for iso-safe without
+;; giving it a mime-charset property.
+(unless (coding-system-get 'us-ascii 'mime-charset)
+  (coding-system-put 'us-ascii 'mime-charset 'us-ascii))
+
+;; Work around bug in Emacs 21.3
+
+(when (and (coding-system-p 'utf-16-le)
+           (eq (coding-system-get 'utf-16-le 'pre-write-conversion)
+               'utf-16-le-pre-write-conversion))
+  (coding-system-put 'utf-16-le 'pre-write-conversion nil))
+
+(when (and (coding-system-p 'utf-16-le)
+           (eq (coding-system-get 'utf-16-be 'pre-write-conversion)
+               'utf-16-be-pre-write-conversion))
+  (coding-system-put 'utf-16-be 'pre-write-conversion nil))
+
+(provide 'nxml-enc)
+
+;;; nxml-enc.el ends here
diff --git a/lisp/nxml/nxml-glyph.el b/lisp/nxml/nxml-glyph.el
new file mode 100644
index 00000000000..b5a70b2694b
--- /dev/null
+++ b/lisp/nxml/nxml-glyph.el
@@ -0,0 +1,418 @@
+;;; nxml-glyph.el --- glyph-handling for nxml-mode
+
+;; Copyright (C) 2003 Free Software Foundation, Inc.
+
+;; Author: James Clark
+;; Keywords: XML
+
+;; This program is free software; you can redistribute it and/or
+;; modify it under the terms of the GNU General Public License as
+;; published by the Free Software Foundation; either version 2 of
+;; the License, or (at your option) any later version.
+
+;; This program is distributed in the hope that it will be
+;; useful, but WITHOUT ANY WARRANTY; without even the implied
+;; warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+;; PURPOSE.  See the GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public
+;; License along with this program; if not, write to the Free
+;; Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+;; MA 02111-1307 USA
+
+;;; Commentary:
+
+;; The entry point to this file is `nxml-glyph-display-string'.
+;; The current implementation is heuristic due to a lack of
+;; Emacs primitives necessary to implement it properly.  The user
+;; can tweak the heuristics using `nxml-glyph-set-hook'.
+
+;;; Code:
+
+(defconst nxml-ascii-glyph-set
+  [(#x0020 . #x007E)])
+
+(defconst nxml-latin1-glyph-set
+  [(#x0020 . #x007E)
+   (#x00A0 . #x00FF)])
+
+;; These were generated by using nxml-insert-target-repertoire-glyph-set
+;; on the TARGET[123] files in
+;; http://www.cl.cam.ac.uk/~mgk25/download/ucs-fonts.tar.gz
+
+(defconst nxml-misc-fixed-1-glyph-set
+  [(#x0020 . #x007E)
+   (#x00A0 . #x00FF)
+   (#x0100 . #x017F)
+   #x018F #x0192
+   (#x0218 . #x021B)
+   #x0259
+   (#x02C6 . #x02C7)
+   (#x02D8 . #x02DD)
+   (#x0374 . #x0375)
+   #x037A #x037E
+   (#x0384 . #x038A)
+   #x038C
+   (#x038E . #x03A1)
+   (#x03A3 . #x03CE)
+   (#x0401 . #x040C)
+   (#x040E . #x044F)
+   (#x0451 . #x045C)
+   (#x045E . #x045F)
+   (#x0490 . #x0491)
+   (#x05D0 . #x05EA)
+   (#x1E02 . #x1E03)
+   (#x1E0A . #x1E0B)
+   (#x1E1E . #x1E1F)
+   (#x1E40 . #x1E41)
+   (#x1E56 . #x1E57)
+   (#x1E60 . #x1E61)
+   (#x1E6A . #x1E6B)
+   (#x1E80 . #x1E85)
+   (#x1EF2 . #x1EF3)
+   (#x2010 . #x2022)
+   #x2026 #x2030
+   (#x2039 . #x203A)
+   #x20AC #x2116 #x2122 #x2126
+   (#x215B . #x215E)
+   (#x2190 . #x2193)
+   #x2260
+   (#x2264 . #x2265)
+   (#x23BA . #x23BD)
+   (#x2409 . #x240D)
+   #x2424 #x2500 #x2502 #x250C #x2510 #x2514 #x2518 #x251C #x2524 #x252C #x2534 #x253C #x2592 #x25C6 #x266A #xFFFD]
+  "Glyph set for TARGET1 glyph repertoire of misc-fixed-* font.
+This repertoire is supported for the bold and oblique fonts.")
+
+(defconst nxml-misc-fixed-2-glyph-set
+  [(#x0020 . #x007E)
+   (#x00A0 . #x00FF)
+   (#x0100 . #x017F)
+   #x018F #x0192
+   (#x01FA . #x01FF)
+   (#x0218 . #x021B)
+   #x0259
+   (#x02C6 . #x02C7)
+   #x02C9
+   (#x02D8 . #x02DD)
+   (#x0300 . #x0311)
+   (#x0374 . #x0375)
+   #x037A #x037E
+   (#x0384 . #x038A)
+   #x038C
+   (#x038E . #x03A1)
+   (#x03A3 . #x03CE)
+   #x03D1
+   (#x03D5 . #x03D6)
+   #x03F1
+   (#x0401 . #x040C)
+   (#x040E . #x044F)
+   (#x0451 . #x045C)
+   (#x045E . #x045F)
+   (#x0490 . #x0491)
+   (#x05D0 . #x05EA)
+   (#x1E02 . #x1E03)
+   (#x1E0A . #x1E0B)
+   (#x1E1E . #x1E1F)
+   (#x1E40 . #x1E41)
+   (#x1E56 . #x1E57)
+   (#x1E60 . #x1E61)
+   (#x1E6A . #x1E6B)
+   (#x1E80 . #x1E85)
+   (#x1EF2 . #x1EF3)
+   (#x2010 . #x2022)
+   #x2026 #x2030
+   (#x2032 . #x2034)
+   (#x2039 . #x203A)
+   #x203C #x203E #x2044
+   (#x2070 . #x2071)
+   (#x2074 . #x208E)
+   (#x20A3 . #x20A4)
+   #x20A7 #x20AC
+   (#x20D0 . #x20D7)
+   #x2102 #x2105 #x2113
+   (#x2115 . #x2116)
+   #x211A #x211D #x2122 #x2124 #x2126 #x212E
+   (#x215B . #x215E)
+   (#x2190 . #x2195)
+   (#x21A4 . #x21A8)
+   (#x21D0 . #x21D5)
+   (#x2200 . #x2209)
+   (#x220B . #x220C)
+   #x220F
+   (#x2211 . #x2213)
+   #x2215
+   (#x2218 . #x221A)
+   (#x221D . #x221F)
+   #x2221
+   (#x2224 . #x222B)
+   #x222E #x223C #x2243 #x2245
+   (#x2248 . #x2249)
+   #x2259
+   (#x225F . #x2262)
+   (#x2264 . #x2265)
+   (#x226A . #x226B)
+   (#x2282 . #x228B)
+   #x2295 #x2297
+   (#x22A4 . #x22A7)
+   (#x22C2 . #x22C3)
+   #x22C5 #x2300 #x2302
+   (#x2308 . #x230B)
+   #x2310
+   (#x2320 . #x2321)
+   (#x2329 . #x232A)
+   (#x23BA . #x23BD)
+   (#x2409 . #x240D)
+   #x2424 #x2500 #x2502 #x250C #x2510 #x2514 #x2518 #x251C #x2524 #x252C #x2534 #x253C
+   (#x254C . #x2573)
+   (#x2580 . #x25A1)
+   (#x25AA . #x25AC)
+   (#x25B2 . #x25B3)
+   #x25BA #x25BC #x25C4 #x25C6
+   (#x25CA . #x25CB)
+   #x25CF
+   (#x25D8 . #x25D9)
+   #x25E6
+   (#x263A . #x263C)
+   #x2640 #x2642 #x2660 #x2663
+   (#x2665 . #x2666)
+   (#x266A . #x266B)
+   (#xFB01 . #xFB02)
+   #xFFFD]
+  "Glyph set for TARGET2 glyph repertoire of the misc-fixed-* fonts.
+This repertoire is supported for the following fonts:
+5x7.bdf 5x8.bdf 6x9.bdf 6x10.bdf 6x12.bdf 7x13.bdf 7x14.bdf clR6x12.bdf")
+
+(defconst nxml-misc-fixed-3-glyph-set
+  [(#x0020 . #x007E)
+   (#x00A0 . #x00FF)
+   (#x0100 . #x01FF)
+   (#x0200 . #x0220)
+   (#x0222 . #x0233)
+   (#x0250 . #x02AD)
+   (#x02B0 . #x02EE)
+   (#x0300 . #x034F)
+   (#x0360 . #x036F)
+   (#x0374 . #x0375)
+   #x037A #x037E
+   (#x0384 . #x038A)
+   #x038C
+   (#x038E . #x03A1)
+   (#x03A3 . #x03CE)
+   (#x03D0 . #x03F6)
+   (#x0400 . #x0486)
+   (#x0488 . #x04CE)
+   (#x04D0 . #x04F5)
+   (#x04F8 . #x04F9)
+   (#x0500 . #x050F)
+   (#x0531 . #x0556)
+   (#x0559 . #x055F)
+   (#x0561 . #x0587)
+   (#x0589 . #x058A)
+   (#x05B0 . #x05B9)
+   (#x05BB . #x05C4)
+   (#x05D0 . #x05EA)
+   (#x05F0 . #x05F4)
+   (#x10D0 . #x10F8)
+   #x10FB
+   (#x1E00 . #x1E9B)
+   (#x1EA0 . #x1EF9)
+   (#x1F00 . #x1F15)
+   (#x1F18 . #x1F1D)
+   (#x1F20 . #x1F45)
+   (#x1F48 . #x1F4D)
+   (#x1F50 . #x1F57)
+   #x1F59 #x1F5B #x1F5D
+   (#x1F5F . #x1F7D)
+   (#x1F80 . #x1FB4)
+   (#x1FB6 . #x1FC4)
+   (#x1FC6 . #x1FD3)
+   (#x1FD6 . #x1FDB)
+   (#x1FDD . #x1FEF)
+   (#x1FF2 . #x1FF4)
+   (#x1FF6 . #x1FFE)
+   (#x2000 . #x200A)
+   (#x2010 . #x2027)
+   (#x202F . #x2052)
+   #x2057
+   (#x205F . #x2063)
+   (#x2070 . #x2071)
+   (#x2074 . #x208E)
+   (#x20A0 . #x20B1)
+   (#x20D0 . #x20EA)
+   (#x2100 . #x213A)
+   (#x213D . #x214B)
+   (#x2153 . #x2183)
+   (#x2190 . #x21FF)
+   (#x2200 . #x22FF)
+   (#x2300 . #x23CE)
+   (#x2400 . #x2426)
+   (#x2440 . #x244A)
+   (#x2500 . #x25FF)
+   (#x2600 . #x2613)
+   (#x2616 . #x2617)
+   (#x2619 . #x267D)
+   (#x2680 . #x2689)
+   (#x27E6 . #x27EB)
+   (#x27F5 . #x27FF)
+   (#x2A00 . #x2A06)
+   #x2A1D #x2A3F #x303F
+   (#xFB00 . #xFB06)
+   (#xFB13 . #xFB17)
+   (#xFB1D . #xFB36)
+   (#xFB38 . #xFB3C)
+   #xFB3E
+   (#xFB40 . #xFB41)
+   (#xFB43 . #xFB44)
+   (#xFB46 . #xFB4F)
+   (#xFE20 . #xFE23)
+   (#xFF61 . #xFF9F)
+   #xFFFD]
+  "Glyph set for TARGET3 glyph repertoire of the misc-fixed-* fonts.
+This repertoire is supported for the following fonts:
+6x13.bdf 8x13.bdf 9x15.bdf 9x18.bdf 10x20.bdf")
+  
+(defconst nxml-wgl4-glyph-set
+  [(#x0020 . #x007E)
+   (#x00A0 . #x017F)
+   #x0192
+   (#x01FA . #x01FF)
+   (#x02C6 . #x02C7)
+   #x02C9
+   (#x02D8 . #x02DB)
+   #x02DD
+   (#x0384 . #x038A)
+   #x038C
+   (#x038E . #x03A1)
+   (#x03A3 . #x03CE)
+   (#x0401 . #x040C)
+   (#x040E . #x044F)
+   (#x0451 . #x045C)
+   (#x045E . #x045F)
+   (#x0490 . #x0491)
+   (#x1E80 . #x1E85)
+   (#x1EF2 . #x1EF3)
+   (#x2013 . #x2015)
+   (#x2017 . #x201E)
+   (#x2020 . #x2022)
+   #x2026 #x2030
+   (#x2032 . #x2033)
+   (#x2039 . #x203A)
+   #x203C #x203E #x2044 #x207F
+   (#x20A3 . #x20A4)
+   #x20A7 #x20AC #x2105 #x2113 #x2116 #x2122 #x2126 #x212E
+   (#x215B . #x215E)
+   (#x2190 . #x2195)
+   #x21A8 #x2202 #x2206 #x220F
+   (#x2211 . #x2212)
+   #x2215
+   (#x2219 . #x221A)
+   (#x221E . #x221F)
+   #x2229 #x222B #x2248
+   (#x2260 . #x2261)
+   (#x2264 . #x2265)
+   #x2302 #x2310
+   (#x2320 . #x2321)
+   #x2500 #x2502 #x250C #x2510 #x2514 #x2518 #x251C #x2524
+   #x252C #x2534 #x253C
+   (#x2550 . #x256C)
+   #x2580 #x2584 #x2588 #x258C
+   (#x2590 . #x2593)
+   (#x25A0 . #x25A1)
+   (#x25AA . #x25AC)
+   #x25B2 #x25BA #x25BC #x25C4
+   (#x25CA . #x25CB)
+   #x25CF
+   (#x25D8 . #x25D9)
+   #x25E6
+   (#x263A . #x263C)
+   #x2640 #x2642 #x2660 #x2663
+   (#x2665 . #x2666)
+   (#x266A . #x266B)
+   (#xFB01 . #xFB02)]
+  "Glyph set corresponding to Windows Glyph List 4.")
+
+(defvar nxml-glyph-set-hook nil
+  "*Hook for determining the set of glyphs in a face.
+The hook will receive a single argument FACE.  If it can determine the
+set of glyphs representable by FACE, it must set the variable
+`nxml-glyph-set' and return non-nil.  Otherwise, it must return
+nil. The hook will be run until success.  The constants
+`nxml-ascii-glyph-set', `nxml-latin1-glyph-set',
+`nxml-misc-fixed-1-glyph-set', `nxml-misc-fixed-2-glyph-set',
+`nxml-misc-fixed-3-glyph-set' and `nxml-wgl4-glyph-set' are predefined
+for use by `nxml-glyph-set-hook'.")
+
+(defvar nxml-glyph-set nil
+  "Used by `nxml-glyph-set-hook' to return set of glyphs in a FACE.
+This should dynamically bound by any function that runs
+`nxml-glyph-set-hook'.  The value must be either nil representing an
+empty set or a vector. Each member of the vector is either a single
+integer or a cons (FIRST . LAST) representing the range of integers
+from FIRST to LAST.  An integer represents a glyph with that Unicode
+code-point.  The vector must be ordered.")
+
+(defun nxml-x-set-glyph-set (face)
+  (setq nxml-glyph-set
+        (if (equal (face-attribute face :family) "misc-fixed")
+            nxml-misc-fixed-3-glyph-set
+          nxml-wgl4-glyph-set)))
+
+(defun nxml-w32-set-glyph-set (face)
+  (setq nxml-glyph-set nxml-wgl4-glyph-set))
+
+(defun nxml-window-system-set-glyph-set (face)
+  (setq nxml-glyph-set nxml-latin1-glyph-set))
+
+(defun nxml-terminal-set-glyph-set (face)
+  (setq nxml-glyph-set nxml-ascii-glyph-set))
+
+(add-hook 'nxml-glyph-set-hook
+          (or (cdr (assq window-system
+                         '((x . nxml-x-set-glyph-set)
+                           (w32 . nxml-w32-set-glyph-set)
+                           (nil . nxml-terminal-set-glyph-set))))
+              'nxml-window-system-set-glyph-set)
+          t)
+
+;;;###autoload
+(defun nxml-glyph-display-string (n face)
+  "Return a string that can display a glyph for Unicode code-point N.
+FACE gives the face that will be used for displaying the string.
+Return nil if the face cannot display a glyph for N."
+  (let ((nxml-glyph-set nil))
+    (run-hook-with-args-until-success 'nxml-glyph-set-hook face)
+    (and nxml-glyph-set
+         (nxml-glyph-set-contains-p n nxml-glyph-set)
+         (let ((ch (decode-char 'ucs n)))
+           (and ch (string ch))))))
+      
+(defun nxml-glyph-set-contains-p (n v)
+  (let ((start 0)
+        (end (length v))
+        found mid mid-val mid-start-val mid-end-val)
+    (while (> end start)
+      (setq mid (+ start
+                   (/ (- end start) 2)))
+      (setq mid-val (aref v mid))
+      (if (consp mid-val)
+          (setq mid-start-val (car mid-val)
+                mid-end-val (cdr mid-val))
+        (setq mid-start-val mid-val
+              mid-end-val mid-val))
+      (cond ((and (<= mid-start-val n)
+                  (<= n mid-end-val))
+             (setq found t)
+             (setq start end))
+            ((< n mid-start-val)
+             (setq end mid))
+            (t
+             (setq start
+                   (if (eq start mid)
+                       end
+                     mid)))))
+    found))
+
+(provide 'nxml-glyph)
+
+;;; nxml-glyph.el ends here
diff --git a/lisp/nxml/nxml-maint.el b/lisp/nxml/nxml-maint.el
new file mode 100644
index 00000000000..015c0c7dadf
--- /dev/null
+++ b/lisp/nxml/nxml-maint.el
@@ -0,0 +1,106 @@
+;;; nxml-maint.el --- commands for maintainers of nxml-*.el
+
+;; Copyright (C) 2003 Free Software Foundation, Inc.
+
+;; Author: James Clark
+;; Keywords: XML
+
+;; This program is free software; you can redistribute it and/or
+;; modify it under the terms of the GNU General Public License as
+;; published by the Free Software Foundation; either version 2 of
+;; the License, or (at your option) any later version.
+
+;; This program is distributed in the hope that it will be
+;; useful, but WITHOUT ANY WARRANTY; without even the implied
+;; warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+;; PURPOSE.  See the GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public
+;; License along with this program; if not, write to the Free
+;; Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+;; MA 02111-1307 USA
+
+;;; Commentary:
+
+;;; Code:
+
+;;; Generating files with Unicode char names.
+
+(require 'nxml-uchnm)
+
+(defun nxml-create-unicode-char-name-sets (file)
+  "Generate files containing char names from Unicode standard."
+  (interactive "fUnicodeData file: ")
+  (mapcar (lambda (block)
+            (let ((nameset (nxml-unicode-block-char-name-set (nth 0 block))))
+              (save-excursion
+                (find-file (concat (get nameset 'nxml-char-name-set-file)
+                                   ".el"))
+                (erase-buffer)
+                (insert "(nxml-define-char-name-set '")
+                (prin1 nameset (current-buffer))
+                (insert "\n  '())\n")
+                (goto-char (- (point) 3)))))
+          nxml-unicode-blocks)
+  (save-excursion
+    (find-file file)
+    (goto-char (point-min))
+    (let ((blocks nxml-unicode-blocks)
+          code name)
+      (while (re-search-forward "^\\([0-9A-F]+\\);\\([^<;][^;]*\\);"
+                                nil
+                                t)
+        (setq code (string-to-number (match-string 1) 16))
+        (setq name (match-string 2))
+        (while (and blocks
+                    (> code (nth 2 (car blocks))))
+          (setq blocks (cdr blocks)))
+        (when (and (<= (nth 1 (car blocks)) code)
+                   (<= code (nth 2 (car blocks))))
+          (save-excursion
+            (find-file (concat (get (nxml-unicode-block-char-name-set
+                                     (nth 0 (car blocks)))
+                                    'nxml-char-name-set-file)
+                               ".el"))
+            (insert "(")
+            (prin1 name (current-buffer))
+            (insert (format " #x%04X)\n    " code))))))))
+
+;;; Parsing target repertoire files from ucs-fonts.
+;; This is for converting the TARGET? files in
+;; http://www.cl.cam.ac.uk/~mgk25/download/ucs-fonts.tar.gz
+;; into a glyph set.
+
+(defun nxml-insert-target-repertoire-glyph-set (file var)
+  (interactive "fTarget file: \nSVariable name: ")
+  (let (lst head)
+    (save-excursion
+      (set-buffer (find-file-noselect file))
+      (goto-char (point-min))
+      (while (re-search-forward "^ *\\([a-FA-F0-9]\\{2\\}\\)[ \t]+" nil t)
+        (let ((row (match-string 1))
+              (eol (save-excursion (end-of-line) (point))))
+          (while (re-search-forward "\\([a-FA-F0-9]\\{2\\}\\)-\\([a-FA-F0-9]\\{2\\}\\)\\|\\([a-FA-F0-9]\\{2\\}\\)" eol t)
+            (setq lst
+                  (cons (if (match-beginning 3)
+                            (concat "#x" row (match-string 3))
+                        (concat "(#x" row (match-string 1)
+                                " . #x" row (match-string 2) ")"))
+                        lst))))))
+    (setq lst (nreverse lst))
+    (insert (format "(defconst %s\n  [" var))
+    (while lst
+      (setq head (car lst))
+      (setq lst (cdr lst))
+      (insert head)
+      (when (= (length head) 6)
+        (while (and lst (= (length (car lst)) 6))
+          (insert " ")
+          (insert (car lst))
+          (setq lst (cdr lst))))
+      (when lst (insert "\n   ")))
+    (insert "])\n")))
+
+(provide 'nxml-maint)
+
+;;; nxml-maint.el ends here
diff --git a/lisp/nxml/nxml-mode.el b/lisp/nxml/nxml-mode.el
new file mode 100644
index 00000000000..821b40621f0
--- /dev/null
+++ b/lisp/nxml/nxml-mode.el
@@ -0,0 +1,2665 @@
+;;; nxml-mode.el --- a new XML mode
+
+;; Copyright (C) 2003, 2004 Free Software Foundation, Inc.
+
+;; Author: James Clark
+;; Keywords: XML
+
+;; This program is free software; you can redistribute it and/or
+;; modify it under the terms of the GNU General Public License as
+;; published by the Free Software Foundation; either version 2 of
+;; the License, or (at your option) any later version.
+
+;; This program is distributed in the hope that it will be
+;; useful, but WITHOUT ANY WARRANTY; without even the implied
+;; warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+;; PURPOSE.  See the GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public
+;; License along with this program; if not, write to the Free
+;; Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+;; MA 02111-1307 USA
+
+;;; Commentary:
+
+;; To use this include rng-auto.el in your .emacs.
+
+;; See nxml-rap.el for description of parsing strategy.
+
+;; The font locking here is independent of font-lock.el.  We want to
+;; do more sophisticated handling of changes and we want to use the
+;; same xmltok rather than regexps for parsing so that we parse
+;; consistently and correctly.
+
+;;; Code:
+
+(when (featurep 'mucs)
+  (error "nxml-mode is not compatible with Mule-UCS"))
+
+(require 'xmltok)
+(require 'nxml-enc)
+(require 'nxml-glyph)
+(require 'nxml-util)
+(require 'nxml-rap)
+(require 'nxml-outln)
+
+;;; Customization
+
+(defgroup nxml nil
+  "New XML editing mode"
+  :group 'languages
+  :group 'wp)
+
+(defgroup nxml-highlighting-faces nil
+  "Faces for XML syntax highlighting."
+  :group 'nxml
+  :group 'font-lock-highlighting-faces)
+
+(defcustom nxml-syntax-highlight-flag t
+  "*Non-nil means nxml-mode should perform syntax highlighting."
+  :group 'nxml
+  :type 'boolean)
+
+(defcustom nxml-char-ref-display-glyph-flag t
+  "*Non-nil means display glyph following character reference.
+The glyph is displayed in `nxml-glyph-face'.  The hook
+`nxml-glyph-set-hook' can be used to customize for which characters
+glyphs are displayed."
+  :group 'nxml
+  :type 'boolean)
+
+(defcustom nxml-mode-hook nil
+  "Hook run by command `nxml-mode'."
+  :group 'nxml
+  :type 'hook)
+
+(defcustom nxml-sexp-element-flag nil
+  "*Non-nil means sexp commands treat an element as a single expression."
+  :group 'nxml
+  :type 'boolean)
+
+(defcustom nxml-slash-auto-complete-flag nil
+  "*Non-nil means typing a slash automatically completes the end-tag.
+This is used by `nxml-electric-slash'."
+  :group 'nxml
+  :type 'boolean)
+
+(defcustom nxml-child-indent 2
+  "*Indentation for the children of an element relative to the start-tag.
+This only applies when the line or lines containing the start-tag contains
+nothing else other than that start-tag."
+  :group 'nxml
+  :type 'integer)
+
+(defcustom nxml-attribute-indent 4
+  "*Indentation for the attributes of an element relative to the start-tag.
+This only applies when the first attribute of a tag starts a line. In other
+cases, the first attribute on one line is indented the same as the first
+attribute on the previous line."
+  :group 'nxml
+  :type 'integer)
+
+(defvar nxml-fontify-chunk-size 500)
+
+(defcustom nxml-bind-meta-tab-to-complete-flag (not window-system)
+  "*Non-nil means bind M-TAB in `nxml-mode-map' to `nxml-complete'.
+C-return will be bound to `nxml-complete' in any case.
+M-TAB gets swallowed by many window systems/managers, and
+`documentation' will show M-TAB rather than C-return as the
+binding `rng-complete' when both are bound.  So it's better
+to bind M-TAB only when it will work."
+  :group 'nxml
+  :set (lambda (sym flag)
+         (set-default sym flag)
+         (when (and (boundp 'nxml-mode-map) nxml-mode-map)
+           (define-key nxml-mode-map "\M-\t" (and flag 'nxml-complete))))
+  :type 'boolean)
+
+(defcustom nxml-prefer-utf-16-to-utf-8-flag nil
+  "*Non-nil means prefer UTF-16 to UTF-8 when saving a buffer.
+This is used only when a buffer does not contain an encoding declaration
+and when its current `buffer-file-coding-system' specifies neither UTF-16
+nor UTF-8."
+  :group 'nxml
+  :type 'boolean)
+
+(defcustom nxml-prefer-utf-16-little-to-big-endian-flag (eq system-type
+                                                            'windows-nt)
+  "*Non-nil means prefer little-endian to big-endian byte-order for UTF-16.
+This is used only for saving a buffer; when reading the byte-order is
+auto-detected. It may be relevant both when there is no encoding declaration
+and when the encoding declaration specifies `UTF-16'."
+  :group 'nxml
+  :type 'boolean)
+
+(defcustom nxml-default-buffer-file-coding-system nil
+  "*Default value for `buffer-file-coding-system' for a buffer for a new file.
+Nil means use the default value of `buffer-file-coding-system' as normal.
+A buffer's `buffer-file-coding-system' affects what \\[nxml-insert-xml-declaration] inserts."
+  :group 'nxml
+  :type 'coding-system)
+
+(defcustom nxml-auto-insert-xml-declaration-flag nil
+  "*Non-nil means automatically insert an XML declaration in a new file.
+The XML declaration is inserted using `nxml-insert-xml-declaration'."
+  :group 'nxml
+  :type 'boolean)
+
+;; The following are the colors we use with a light background.
+;; The two blues have the same hue but contrasting saturation/value.
+;; The hue of the green is 120 degrees different from that of the
+;; blue.  The red used for highlighting errors is 120 degrees
+;; different again.  We use the light blue only for refs and
+;; delimiters, since these are short (long stretches in a light color
+;; would be too hard to read).  The dark blue is closest to black
+;; (which we use by default for text), so we use it for attribute
+;; values, which are similar to text.
+
+(defconst nxml-light-blue-color "#9292C9") ; hue 240
+(defconst nxml-dark-blue-color "#3A3A7B") ; hue 240
+(defconst nxml-green-color "#257A25") ; hue 120
+
+;; Similar principles apply with a dark background.  However,
+;; we switch green and blue, because darker blues are very hard to
+;; read (for me anyway) on a dark background.
+
+(defconst nxml-sky-blue-color "#ACACFC") ; hue 240
+(defconst nxml-dark-green-color "#00AD00") ; hue 120
+(defconst nxml-light-green-color "#70F170") ; hue 120
+
+(defface nxml-delimited-data-face
+  `((((class color) (background light)) (:foreground ,nxml-dark-blue-color))
+    (((class color) (background dark)) (:foreground ,nxml-light-green-color)))
+  "Face used to highlight data enclosed between delimiters.
+By default, this is inherited by `nxml-attribute-value-face'
+and `nxml-processing-instruction-content-face'."
+  :group 'nxml-highlighting-faces)
+
+(defface nxml-name-face
+  `((((class color) (background light)) (:foreground ,nxml-green-color))
+    (((class color) (background dark)) (:foreground ,nxml-sky-blue-color)))
+  "Face used to highlight various names.
+This includes element and attribute names, processing
+instruction targets and the CDATA keyword in a CDATA section.
+This is not used directly, but only via inheritance by other faces."
+  :group 'nxml-highlighting-faces)
+
+(defface nxml-ref-face
+  `((((class color) (background light)) (:foreground ,nxml-light-blue-color))
+    (((class color) (background dark)) (:foreground ,nxml-dark-green-color)))
+  "Face used to highlight character and entity references.
+This is not used directly, but only via inheritance by other faces."
+  :group 'nxml-highlighting-faces)
+
+(defface nxml-delimiter-face
+  `((((class color) (background light)) (:foreground ,nxml-light-blue-color))
+    (((class color) (background dark)) (:foreground ,nxml-dark-green-color))
+    (t (:bold t)))
+  "Face used to highlight delimiters.
+This is not used directly, but only via inheritance by other faces."
+  :group 'nxml-highlighting-faces)
+
+(defface nxml-text-face
+  nil
+  "Face used to highlight text."
+  :group 'nxml-highlighting-faces)
+
+(defface nxml-comment-content-face
+  '((t (:italic t)))
+  "Face used to highlight the content of comments."
+  :group 'nxml-highlighting-faces)
+
+(defface nxml-comment-delimiter-face
+  '((t (:inherit nxml-delimiter-face)))
+  "Face used for the delimiters of comments, i.e <!-- and -->."
+  :group 'nxml-highlighting-faces)
+
+(defface nxml-processing-instruction-delimiter-face
+  '((t (:inherit nxml-delimiter-face)))
+  "Face used for the delimiters of processing instructions, i.e <? and ?>."
+  :group 'nxml-highlighting-faces)
+
+(defface nxml-processing-instruction-target-face
+  '((t (:inherit nxml-name-face)))
+  "Face used for the target of processing instructions."
+  :group 'nxml-highlighting-faces)
+
+(defface nxml-processing-instruction-content-face
+  '((t (:inherit nxml-delimited-data-face)))
+  "Face used for the content of processing instructions."
+  :group 'nxml-highlighting-faces)
+
+(defface nxml-cdata-section-delimiter-face
+  '((t (:inherit nxml-delimiter-face)))
+  "Face used for the delimiters of CDATA sections, i.e <![, [, and ]]>."
+  :group 'nxml-highlighting-faces)
+
+(defface nxml-cdata-section-CDATA-face
+  '((t (:inherit nxml-name-face)))
+  "Face used for the CDATA keyword in CDATA sections."
+  :group 'nxml-highlighting-faces)
+
+(defface nxml-cdata-section-content-face
+  '((t (:inherit nxml-text-face)))
+  "Face used for the content of CDATA sections."
+  :group 'nxml-highlighting-faces)
+
+(defface nxml-char-ref-number-face
+  '((t (:inherit nxml-ref-face)))
+  "Face used for the number in character references.
+This includes ths `x' in hex references."
+  :group 'nxml-highlighting-faces)
+
+(defface nxml-char-ref-delimiter-face
+  '((t (:inherit nxml-ref-face)))
+  "Face used for the delimiters of character references, i.e &# and ;."
+  :group 'nxml-highlighting-faces)
+
+(defface nxml-entity-ref-name-face
+  '((t (:inherit nxml-ref-face)))
+  "Face used for the entity name in general entity references."
+  :group 'nxml-highlighting-faces)
+
+(defface nxml-entity-ref-delimiter-face
+  '((t (:inherit nxml-ref-face)))
+  "Face used for the delimiters of entity references, i.e & and ;."
+  :group 'nxml-highlighting-faces)
+
+(defface nxml-tag-delimiter-face
+  '((t (:inherit nxml-delimiter-face)))
+  "Face used for the angle brackets delimiting tags.
+`nxml-tag-slash-face' is used for slashes."
+  :group 'nxml-highlighting-faces)
+
+(defface nxml-tag-slash-face
+  '((t (:inherit nxml-name-face)))
+  "Face used for slashes in tags, both in end-tags and empty-elements."
+  :group 'nxml-highlighting-faces)
+
+(defface nxml-element-prefix-face
+  '((t (:inherit nxml-name-face)))
+  "Face used for the prefix of elements."
+  :group 'nxml-highlighting-faces)
+
+(defface nxml-element-colon-face
+  '((t (:inherit nxml-name-face)))
+  "Face used for the colon in element names."
+  :group 'nxml-highlighting-faces)
+
+(defface nxml-element-local-name-face
+  '((t (:inherit nxml-name-face)))
+  "Face used for the local name of elements."
+  :group 'nxml-highlighting-faces)
+
+(defface nxml-attribute-prefix-face
+  '((t (:inherit nxml-name-face)))
+  "Face used for the prefix of attributes."
+  :group 'nxml-highlighting-faces)
+
+(defface nxml-attribute-colon-face
+  '((t (:inherit nxml-name-face)))
+  "Face used for the colon in attribute names."
+  :group 'nxml-highlighting-faces)
+  
+(defface nxml-attribute-local-name-face
+  '((t (:inherit nxml-name-face)))
+  "Face used for the local name of attributes."
+  :group 'nxml-highlighting-faces)
+
+(defface nxml-namespace-attribute-xmlns-face
+  '((t (:inherit nxml-name-face)))
+  "Face used for `xmlns' in namespace attributes."
+  :group 'nxml-highlighting-faces)
+
+(defface nxml-namespace-attribute-colon-face
+  '((t (:inherit nxml-name-face)))
+  "Face used for the colon in namespace attributes."
+  :group 'nxml-highlighting-faces)
+
+(defface nxml-namespace-attribute-prefix-face
+  '((t (:inherit nxml-name-face)))
+  "Face used for the prefix declared in namespace attributes."
+  :group 'nxml-highlighting-faces)
+
+(defface nxml-attribute-value-face
+  '((t (:inherit nxml-delimited-data-face)))
+  "Face used for the value of attributes."
+  :group 'nxml-highlighting-faces)
+
+(defface nxml-attribute-value-delimiter-face
+  '((t (:inherit nxml-delimiter-face)))
+  "Face used for the delimiters of attribute values."
+  :group 'nxml-highlighting-faces)
+
+(defface nxml-namespace-attribute-value-face
+  '((t (:inherit nxml-attribute-value-face)))
+  "Face used for the value of namespace attributes."
+  :group 'nxml-highlighting-faces)
+
+(defface nxml-namespace-attribute-value-delimiter-face
+  '((t (:inherit nxml-attribute-value-delimiter-face)))
+  "Face used for the delimiters of namespace attribute values."
+  :group 'nxml-highlighting-faces)
+
+(defface nxml-prolog-literal-delimiter-face
+  '((t (:inherit nxml-delimiter-face)))
+  "Face used for the delimiters of literals in the prolog."
+  :group 'nxml-highlighting-faces)
+
+(defface nxml-prolog-literal-content-face
+  '((t (:inherit nxml-delimited-data-face)))
+  "Face used for the content of literals in the prolog."
+  :group 'nxml-highlighting-faces)
+
+(defface nxml-prolog-keyword-face
+  '((t (:inherit nxml-name-face)))
+  "Face used for keywords in the prolog."
+  :group 'nxml-highlighting-faces)
+
+(defface nxml-markup-declaration-delimiter-face
+  '((t (:inherit nxml-delimiter-face)))
+  "Face used for the delimiters of markup declarations in the prolog.
+The delimiters are <! and >."
+  :group 'nxml-highlighting-faces)
+
+(defface nxml-hash-face
+  '((t (:inherit nxml-name-face)))
+  "Face used for # before a name in the prolog."
+  :group 'nxml-highlighting-faces)
+
+(defface nxml-glyph-face
+  '((((type x))
+     (:family
+      "misc-fixed"
+      :background
+      "light grey"
+      :foreground
+      "black"
+      :weight
+      normal 
+      :slant
+      normal))
+    (t
+     (:background
+      "light grey"
+      :foreground
+      "black"
+      :weight
+      normal 
+      :slant
+      normal)))
+  "Face used for glyph for char references."
+  :group 'nxml-highlighting-faces)
+
+;;; Global variables
+
+;; This is initialized in rng-auto.el.
+(defvar nxml-version nil
+  "*The version of nxml-mode that is being used.")
+
+(defvar nxml-prolog-regions nil
+  "List of regions in the prolog to be fontified.
+See the function `xmltok-forward-prolog' for more information.")
+(make-variable-buffer-local 'nxml-prolog-regions)
+
+(defvar nxml-last-fontify-end nil
+  "Position where fontification last ended.
+Nil if the buffer changed since the last fontification.")
+(make-variable-buffer-local 'nxml-last-fontify-end)
+
+(defvar nxml-degraded nil
+  "Non-nil if currently operating in degraded mode.
+Degraded mode is enabled when an internal error is encountered in the
+fontification or after-change functions.")
+(make-variable-buffer-local 'nxml-degraded)
+
+(defvar nxml-completion-hook nil
+  "Hook run by `nxml-complete'.
+This hook is run until success.")
+
+(defvar nxml-in-mixed-content-hook nil
+  "Hook to determine whether point is in mixed content.
+The hook is called without arguments.  It should return nil if it is
+definitely not mixed; non-nil otherwise.  The hook will be run until
+one of the functions returns nil.")
+
+(defvar nxml-mixed-scan-distance 4000
+  "Maximum distance from point to scan when checking for mixed content.")
+
+(defvar nxml-end-tag-indent-scan-distance 4000
+  "Maximum distance from point to scan backwards when indenting end-tag.")
+
+(defvar nxml-char-ref-extra-display t
+  "Non-nil means display extra information for character references.
+The extra information consists of a tooltip with the character name
+and, if `nxml-char-ref-display-glyph-flag' is non-nil, a glyph
+corresponding to the referenced character following the character
+reference.")
+(make-variable-buffer-local 'nxml-char-ref-extra-display)
+
+(defvar nxml-mode-map
+  (let ((map (make-sparse-keymap)))
+    (define-key map "\M-\C-u" 'nxml-backward-up-element)
+    (define-key map "\M-\C-d" 'nxml-down-element)
+    (define-key map "\M-\C-n" 'nxml-forward-element)
+    (define-key map "\M-\C-p" 'nxml-backward-element)
+    (define-key map "\M-{" 'nxml-backward-paragraph)
+    (define-key map "\M-}" 'nxml-forward-paragraph)
+    (define-key map "\M-h" 'nxml-mark-paragraph)
+    (define-key map "\C-c\C-f" 'nxml-finish-element)
+    (define-key map "\C-c\C-m" 'nxml-split-element)
+    (define-key map "\C-c\C-b" 'nxml-balanced-close-start-tag-block)
+    (define-key map "\C-c\C-i" 'nxml-balanced-close-start-tag-inline)
+    (define-key map "\C-c\C-x" 'nxml-insert-xml-declaration)
+    (define-key map "\C-c\C-d" 'nxml-dynamic-markup-word)
+    ;; u is for Unicode
+    (define-key map "\C-c\C-u" 'nxml-insert-named-char)
+    (define-key map "\C-c\C-o" nxml-outline-prefix-map)
+    (define-key map [S-mouse-2] 'nxml-mouse-hide-direct-text-content)
+    (define-key map "/" 'nxml-electric-slash)
+    (define-key map [C-return] 'nxml-complete) 
+    (when nxml-bind-meta-tab-to-complete-flag
+      (define-key map "\M-\t" 'nxml-complete))
+    map)
+  "Keymap for nxml-mode.")
+
+(defsubst nxml-set-face (start end face)
+  (when (and face (< start end))
+    (put-text-property start end 'face face)))
+
+(defun nxml-clear-face (start end)
+  (remove-text-properties start end '(face nil))
+  (nxml-clear-char-ref-extra-display start end))
+
+(defsubst nxml-set-fontified (start end)
+  (put-text-property start end 'fontified t))
+
+(defsubst nxml-clear-fontified (start end)
+  (remove-text-properties start end '(fontified nil)))
+
+;;;###autoload
+(defun nxml-mode ()
+  ;; We use C-c C-i instead of \\[nxml-balanced-close-start-tag-inline]
+  ;; because Emacs turns C-c C-i into C-c TAB which is hard to type and
+  ;; not mnemonic.
+  "Major mode for editing XML.
+
+Syntax highlighting is performed unless the variable
+`nxml-syntax-highlight-flag' is nil.
+
+\\[nxml-finish-element] finishes the current element by inserting an end-tag.
+C-c C-i closes a start-tag with `>' and then inserts a balancing end-tag
+leaving point between the start-tag and end-tag. 
+\\[nxml-balanced-close-start-tag-block] is similar but for block rather than inline elements:
+the start-tag, point, and end-tag are all left on separate lines.
+If `nxml-slash-auto-complete-flag' is non-nil, then inserting a `</'
+automatically inserts the rest of the end-tag.
+
+\\[nxml-complete] performs completion on the symbol preceding point.
+
+\\[nxml-dynamic-markup-word] uses the contents of the current buffer
+to choose a tag to put around the word preceding point.
+
+Sections of the document can be displayed in outline form.  The
+variable `nxml-section-element-name-regexp' controls when an element
+is recognized as a section.  The same key sequences that change
+visibility in outline mode are used except that they start with C-c C-o
+instead of C-c.
+
+Validation is provided by the related minor-mode `rng-validate-mode'.
+This also makes completion schema- and context- sensitive.  Element
+names, attribute names, attribute values and namespace URIs can all be
+completed. By default, `rng-validate-mode' is automatically enabled by
+`rng-nxml-mode-init' which is normally added to `nxml-mode-hook'. You
+can toggle it using \\[rng-validate-mode].
+
+\\[indent-for-tab-command] indents the current line appropriately.
+This can be customized using the variable `nxml-child-indent'
+and the variable `nxml-attribute-indent'.
+
+\\[nxml-insert-named-char] inserts a character reference using
+the character's name (by default, the Unicode name). \\[universal-argument] \\[nxml-insert-named-char]
+inserts the character directly.
+
+The Emacs commands that normally operate on balanced expressions will
+operate on XML markup items.  Thus \\[forward-sexp] will move forward
+across one markup item; \\[backward-sexp] will move backward across
+one markup item; \\[kill-sexp] will kill the following markup item;
+\\[mark-sexp] will mark the following markup item.  By default, each
+tag each treated as a single markup item; to make the complete element
+be treated as a single markup item, set the variable
+`nxml-sexp-element-flag' to t.  For more details, see the function
+`nxml-forward-balanced-item'.
+
+\\[nxml-backward-up-element] and \\[nxml-down-element] move up and down the element structure.
+
+Many aspects this mode can be customized using
+\\[customize-group] nxml RET."
+  (interactive)
+  (kill-all-local-variables)
+  (setq major-mode 'nxml-mode)
+  (setq mode-name "nXML")
+  ;; We'll determine the fill prefix ourselves
+  (make-local-variable 'adaptive-fill-mode)
+  (setq adaptive-fill-mode nil)
+  (make-local-variable 'forward-sexp-function)
+  (setq forward-sexp-function 'nxml-forward-balanced-item)
+  (make-local-variable 'indent-line-function)
+  (setq indent-line-function 'nxml-indent-line)
+  (make-local-variable 'fill-paragraph-function)
+  (setq fill-paragraph-function 'nxml-do-fill-paragraph)
+  ;; Comment support
+  ;; This doesn't seem to work too well;
+  ;; I think we should probably roll our own nxml-comment-dwim function.
+  (make-local-variable 'comment-indent-function)
+  (setq comment-indent-function 'nxml-indent-line)
+  (make-local-variable 'comment-start)
+  (setq comment-start "<!--")
+  (make-local-variable 'comment-start-skip)
+  (setq comment-start-skip "<!--[ \t\r\n]*")
+  (make-local-variable 'comment-end)
+  (setq comment-end "-->")
+  (make-local-variable 'comment-end-skip)
+  (setq comment-end-skip "[ \t\r\n]*-->")
+  (make-local-variable 'comment-line-break-function)
+  (setq comment-line-break-function 'nxml-newline-and-indent)
+  (use-local-map nxml-mode-map)
+  (save-excursion
+    (save-restriction
+      (widen)
+      (nxml-clear-dependent-regions (point-min) (point-max))
+      (setq nxml-scan-end (copy-marker (point-min) nil))
+      (nxml-with-unmodifying-text-property-changes
+        (when nxml-syntax-highlight-flag
+          (nxml-clear-fontified (point-min) (point-max)))
+        (nxml-clear-inside (point-min) (point-max))
+        (nxml-with-invisible-motion
+          (nxml-scan-prolog)))))
+  (when nxml-syntax-highlight-flag
+    (add-hook 'fontification-functions 'nxml-fontify nil t))
+  (add-hook 'after-change-functions 'nxml-after-change nil t)
+  (add-hook 'write-contents-hooks 'nxml-prepare-to-save)
+  (when (not (and (buffer-file-name) (file-exists-p (buffer-file-name))))
+    (when (and nxml-default-buffer-file-coding-system
+               (not (local-variable-p 'buffer-file-coding-system)))
+      (setq buffer-file-coding-system nxml-default-buffer-file-coding-system))
+    (when nxml-auto-insert-xml-declaration-flag
+      (nxml-insert-xml-declaration)))
+  (run-hooks 'nxml-mode-hook))
+
+(defun nxml-degrade (context err)
+  (message "Internal nXML mode error in %s (%s), degrading"
+           context
+           (error-message-string err))
+  (ding)
+  (setq nxml-degraded t)
+  (setq nxml-prolog-end 1)
+  (save-excursion
+    (save-restriction
+      (widen)
+      (nxml-with-unmodifying-text-property-changes
+        (nxml-clear-face (point-min) (point-max))
+        (nxml-set-fontified (point-min) (point-max))
+        (nxml-clear-inside (point-min) (point-max)))
+      (setq mode-name "nXML/degraded"))))
+
+;;; Change management
+
+(defun nxml-after-change (start end pre-change-length)
+  ;; Work around bug in insert-file-contents.
+  (when (> end (1+ (buffer-size)))
+    (setq start 1)
+    (setq end (1+ (buffer-size))))
+  (unless nxml-degraded
+    (condition-case err
+        (save-excursion
+          (save-restriction
+            (widen)
+            (save-match-data
+              (nxml-with-invisible-motion
+                (nxml-with-unmodifying-text-property-changes
+                  (nxml-after-change1 start end pre-change-length))))))
+      (error
+       (nxml-degrade 'nxml-after-change err)))))
+
+(defun nxml-after-change1 (start end pre-change-length)
+  (setq nxml-last-fontify-end nil)
+  (let ((pre-change-end (+ start pre-change-length)))
+    (setq start
+          (nxml-adjust-start-for-dependent-regions start
+                                                   end
+                                                   pre-change-length))
+    (when (<= start
+              ;; Add 2 so as to include the < and following char
+              ;; that start the instance, since changing these
+              ;; can change where the prolog ends.
+              (+ nxml-prolog-end 2))
+      ;; end must be extended to at least the end of the old prolog
+      (when (< pre-change-end nxml-prolog-end)
+        (setq end
+              ;; don't let end get out of range even if pre-change-length
+              ;; is bogus
+              (min (point-max)
+                   (+ end (- nxml-prolog-end pre-change-end)))))
+      (nxml-scan-prolog)))
+  (cond ((<= end nxml-prolog-end)
+         (setq end nxml-prolog-end)
+         (goto-char start)
+         ;; This is so that Emacs redisplay works
+         (setq start (line-beginning-position)))
+        ((and (<= start nxml-scan-end)
+              (> start (point-min))
+              (nxml-get-inside (1- start)))
+         ;; The closing delimiter might have been removed.
+         ;; So we may need to redisplay from the beginning
+         ;; of the token.
+         (goto-char (1- start))
+         (nxml-move-outside-backwards)
+         ;; This is so that Emacs redisplay works
+         (setq start (line-beginning-position))
+         (setq end (max (nxml-scan-after-change (point) end)
+                        end)))
+        (t
+         (goto-char start)
+         ;; This is both for redisplay and to move back
+         ;; past any incomplete opening delimiters
+         (setq start (line-beginning-position))
+         (setq end (max (nxml-scan-after-change start end)
+                        end))))
+  (when nxml-syntax-highlight-flag
+    (when (>= start end)
+      ;; Must clear at least one char so as to trigger redisplay.
+      (cond ((< start (point-max))
+             (setq end (1+ start)))
+            (t
+             (setq end (point-max))
+             (goto-char end)
+             (setq start (line-beginning-position)))))
+    (nxml-clear-fontified start end)))
+  
+;;; Encodings
+
+(defun nxml-insert-xml-declaration ()
+  "Insert an XML declaration at the beginning of buffer.
+The XML declaration will declare an encoding depending on the buffer's
+`buffer-file-coding-system'."
+  (interactive "*")
+  (let ((coding-system
+         (if (and buffer-file-coding-system
+                  (coding-system-p buffer-file-coding-system)
+                  (coding-system-get buffer-file-coding-system
+                                     'mime-charset))
+             buffer-file-coding-system
+           (nxml-choose-utf-coding-system))))
+    (goto-char (point-min))
+    (insert (format "<?xml version=\"1.0\" encoding=\"%s\"?>\n"
+                    (nxml-coding-system-name coding-system)))))
+
+(defun nxml-prepare-to-save ()
+  (unless (and (not enable-multibyte-characters)
+               (local-variable-p 'buffer-file-coding-system)
+               buffer-file-coding-system
+               (or (eq (coding-system-type buffer-file-coding-system) 5)
+                   (eq buffer-file-coding-system 'no-conversion)))
+    (save-excursion
+      (setq buffer-file-coding-system (nxml-select-coding-system))))
+  ;; nil from a function in `write-contents-hooks' means
+  ;; to continue and write the file as normal
+  nil)
+
+(defun nxml-select-coding-system ()
+  (let* ((suitable-coding-systems
+          (find-coding-systems-region (point-min) (point-max)))
+         (enc-pos (progn
+                    (goto-char (point-min))
+                    (xmltok-get-declared-encoding-position)))
+         (enc-name
+          (and (consp enc-pos)
+               (buffer-substring-no-properties (car enc-pos)
+                                               (cdr enc-pos))))
+         (coding-system
+          (cond (enc-name
+                 (if (string= (downcase enc-name) "utf-16")
+                     (nxml-choose-utf-16-coding-system)
+                   (nxml-mime-charset-coding-system enc-name)))
+                (enc-pos (nxml-choose-utf-coding-system)))))
+    ;; Make sure we have a coding-system
+    (unless coding-system
+      (setq coding-system
+            (and (not buffer-read-only)
+                 (nxml-choose-suitable-coding-system
+                  suitable-coding-systems)))
+      (let ((message
+             (if enc-name
+                 (format "Unknown encoding %s" enc-name)
+               "XML declaration is not well-formed")))
+        (cond ((not coding-system)
+               (error "%s" message))
+              ((y-or-n-p
+                (concat message
+                        ". "
+                        (format (if enc-name
+                                    "Save with %s"
+                                  "Modify and save with encoding %s")
+                                (nxml-coding-system-name coding-system))
+                        " "))
+               (nxml-fix-encoding-declaration enc-pos coding-system))
+              (t (signal 'quit nil)))))
+    ;; Make sure it can encode all the characters in the buffer
+    (unless (or (memq (coding-system-base coding-system)
+                      suitable-coding-systems)
+                (equal suitable-coding-systems '(undecided)))
+      (let ((message
+             (nxml-unsuitable-coding-system-message coding-system
+                                                    enc-name)))
+        (setq coding-system
+              (and (not buffer-read-only)
+                   (nxml-choose-suitable-coding-system
+                    suitable-coding-systems)))
+        (cond ((not coding-system) (error "%s" message))
+              ((y-or-n-p (concat message
+                                 (format ". Save with %s "
+                                         (nxml-coding-system-name
+                                          coding-system))))
+               (nxml-fix-encoding-declaration enc-pos coding-system))
+              (t (signal 'quit nil)))))
+    ;; Merge the newline type of our existing encoding
+    (let ((current-eol-type
+           (coding-system-eol-type buffer-file-coding-system)))
+      (when (and current-eol-type (integerp current-eol-type))
+        (setq coding-system
+              (coding-system-change-eol-conversion coding-system
+                                                   current-eol-type))))
+    coding-system))
+
+(defun nxml-unsuitable-coding-system-message (coding-system &optional enc-name)
+  (if (nxml-coding-system-unicode-p coding-system)
+      "Cannot translate some characters to Unicode"
+    (format "Cannot encode some characters with %s"
+            (or enc-name
+                (nxml-coding-system-name coding-system)))))
+
+(defconst nxml-utf-16-coding-systems (and (coding-system-p 'utf-16-be)
+                                          (coding-system-p 'utf-16-le)
+                                          '(utf-16-be utf-16-le)))
+
+(defconst nxml-utf-coding-systems (cons 'utf-8 nxml-utf-16-coding-systems))
+
+(defun nxml-coding-system-unicode-p (coding-system)
+  (nxml-coding-system-member (coding-system-base coding-system)
+                             nxml-utf-coding-systems))
+
+(defun nxml-coding-system-name (coding-system)
+  (setq coding-system (coding-system-base coding-system))
+  (symbol-name
+   (if (nxml-coding-system-member coding-system nxml-utf-16-coding-systems)
+       'utf-16
+     (or (coding-system-get coding-system 'mime-charset)
+         coding-system))))
+
+(defun nxml-fix-encoding-declaration (enc-pos coding-system)
+  (let ((charset (nxml-coding-system-name coding-system)))
+    (cond ((consp enc-pos)
+           (delete-region (car enc-pos) (cdr enc-pos))
+           (goto-char (car enc-pos))
+           (insert charset))
+          ((integerp enc-pos)
+           (goto-char enc-pos)
+           (insert " encoding=\"" charset ?\"))
+          (t
+           (goto-char (point-min))
+           (insert "<?xml version=\"1.0\" encoding=\""
+                   charset
+                   "\"?>\n")
+           (when (and (not enc-pos)
+                      (let ((case-fold-search t))
+                        (looking-at xmltok-bad-xml-decl-regexp)))
+             (delete-region (point) (match-end 0)))))))
+
+(defun nxml-choose-suitable-coding-system (suitable-coding-systems)
+  (let (ret coding-system)
+    (if (and buffer-file-coding-system
+             (memq (coding-system-base buffer-file-coding-system)
+                   suitable-coding-systems))
+        buffer-file-coding-system
+      (while (and suitable-coding-systems (not ret))
+        (setq coding-system (car suitable-coding-systems))
+        (if (coding-system-get coding-system 'mime-charset)
+            (setq ret coding-system)
+          (setq suitable-coding-systems (cdr suitable-coding-systems))))
+      ret)))
+
+(defun nxml-choose-utf-coding-system ()      
+  (let ((cur (and (local-variable-p 'buffer-file-coding-system)
+                  buffer-file-coding-system
+                  (coding-system-base buffer-file-coding-system))))
+    (cond ((car (nxml-coding-system-member cur nxml-utf-coding-systems)))
+          ((and nxml-prefer-utf-16-to-utf-8-flag
+                (coding-system-p 'utf-16-le)
+                (coding-system-p 'utf-16-be))
+           (if nxml-prefer-utf-16-little-to-big-endian-flag
+               'utf-16-le
+             'utf-16-be))
+          (t 'utf-8))))
+
+(defun nxml-choose-utf-16-coding-system ()
+  (let ((cur (and (local-variable-p 'buffer-file-coding-system)
+                  buffer-file-coding-system
+                  (coding-system-base buffer-file-coding-system))))
+    (cond ((car (nxml-coding-system-member cur nxml-utf-16-coding-systems)))
+          (nxml-prefer-utf-16-little-to-big-endian-flag
+           (and (coding-system-p 'utf-16-le) 'utf-16-le))
+          (t (and (coding-system-p 'utf-16-be) 'utf-16-be)))))
+
+(defun nxml-coding-system-member (coding-system coding-systems)
+  (let (ret)
+    (while (and coding-systems (not ret))
+      (if (coding-system-equal coding-system
+                               (car coding-systems))
+          (setq ret coding-systems)
+        (setq coding-systems (cdr coding-systems))))
+    ret))
+
+;;; Fontification
+
+(defun nxml-fontify (start)
+  (condition-case err
+      (save-excursion
+        (save-restriction
+          (widen)
+          (save-match-data
+            (nxml-with-invisible-motion
+              (nxml-with-unmodifying-text-property-changes
+                (if (or nxml-degraded
+                        ;; just in case we get called in the wrong buffer
+                        (not nxml-prolog-end))
+                    (nxml-set-fontified start (point-max))
+                  (nxml-fontify1 start)))))))
+    (error
+     (nxml-degrade 'nxml-fontify err))))
+
+(defun nxml-fontify1 (start)
+  (cond ((< start nxml-prolog-end)
+         (nxml-fontify-prolog)
+         (nxml-set-fontified (point-min)
+                             nxml-prolog-end))
+        (t
+         (goto-char start)
+         (when (not (eq nxml-last-fontify-end start))
+           (when (not (equal (char-after) ?\<))
+             (search-backward "<" nxml-prolog-end t))
+           (nxml-ensure-scan-up-to-date)
+           (nxml-move-outside-backwards))
+         (let ((start (point)))
+           (nxml-do-fontify (min (point-max)
+                                 (+ start nxml-fontify-chunk-size)))
+           (setq nxml-last-fontify-end (point))
+           (nxml-set-fontified start nxml-last-fontify-end)))))
+
+(defun nxml-fontify-buffer ()
+  (interactive)
+  (save-excursion
+    (save-restriction
+      (widen)
+      (nxml-with-invisible-motion
+        (goto-char (point-min))
+        (nxml-with-unmodifying-text-property-changes
+          (nxml-fontify-prolog)
+          (goto-char nxml-prolog-end)
+          (nxml-do-fontify))))))
+
+(defun nxml-fontify-prolog ()
+  "Fontify the prolog.
+The buffer is assumed to be prepared for fontification.
+This does not set the fontified property, but it does clear
+faces appropriately."
+  (let ((regions nxml-prolog-regions))
+    (nxml-clear-face (point-min) nxml-prolog-end)
+    (while regions
+      (let ((region (car regions)))
+        (nxml-apply-fontify-rule (aref region 0)
+                                 (aref region 1)
+                                 (aref region 2)))
+      (setq regions (cdr regions)))))
+
+(defun nxml-do-fontify (&optional bound)
+  "Fontify at least as far as bound.
+Leave point after last fontified position."
+  (unless bound (setq bound (point-max)))
+  (let (xmltok-dependent-regions
+        xmltok-errors)
+    (while (and (< (point) bound)
+                (nxml-tokenize-forward))
+      (nxml-clear-face xmltok-start (point))
+      (nxml-apply-fontify-rule))))
+
+;; Vectors identify a substring of the token to be highlighted in some face.
+
+;; Token types returned by xmltok-forward.
+
+(put 'start-tag
+     'nxml-fontify-rule
+     '([nil 1 nxml-tag-delimiter-face]
+       [-1 nil nxml-tag-delimiter-face]
+       (element-qname . 1)
+       attributes))
+
+(put 'partial-start-tag
+     'nxml-fontify-rule
+     '([nil 1 nxml-tag-delimiter-face]
+       (element-qname . 1)
+       attributes))
+
+(put 'end-tag
+     'nxml-fontify-rule
+     '([nil 1 nxml-tag-delimiter-face]
+       [1 2 nxml-tag-slash-face]
+       [-1 nil nxml-tag-delimiter-face]
+       (element-qname . 2)))
+
+(put 'partial-end-tag
+     'nxml-fontify-rule
+     '([nil 1 nxml-tag-delimiter-face]
+       [1 2 nxml-tag-slash-face]
+       (element-qname . 2)))
+
+(put 'empty-element
+     'nxml-fontify-rule
+     '([nil 1 nxml-tag-delimiter-face]
+       [-2 -1 nxml-tag-slash-face]
+       [-1 nil nxml-tag-delimiter-face]
+       (element-qname . 1)
+       attributes))
+
+(put 'partial-empty-element
+     'nxml-fontify-rule
+     '([nil 1 nxml-tag-delimiter-face]
+       [-1 nil nxml-tag-slash-face]
+       (element-qname . 1)
+       attributes))
+
+(put 'char-ref
+     'nxml-fontify-rule
+     '([nil 2 nxml-char-ref-delimiter-face]
+       [2 -1 nxml-char-ref-number-face]
+       [-1 nil nxml-char-ref-delimiter-face]
+       char-ref))
+
+(put 'entity-ref
+     'nxml-fontify-rule
+     '([nil 1 nxml-entity-ref-delimiter-face]
+       [1 -1 nxml-entity-ref-name-face]
+       [-1 nil nxml-entity-ref-delimiter-face]))
+
+(put 'comment
+     'nxml-fontify-rule
+     '([nil 4 nxml-comment-delimiter-face]
+       [4 -3 nxml-comment-content-face]
+       [-3 nil nxml-comment-delimiter-face]))
+
+(put 'processing-instruction
+     'nxml-fontify-rule
+     '([nil 2 nxml-processing-instruction-delimiter-face]
+       [-2 nil nxml-processing-instruction-delimiter-face]
+       processing-instruction-content))
+
+(put 'cdata-section
+     'nxml-fontify-rule
+     '([nil 3 nxml-cdata-section-delimiter-face] ; <![
+       [3 8 nxml-cdata-section-CDATA-face] ; CDATA
+       [8 9 nxml-cdata-section-delimiter-face] ; [
+       [9 -3 nxml-cdata-section-content-face] ; ]]>
+       [-3 nil nxml-cdata-section-delimiter-face]))
+
+(put 'data
+     'nxml-fontify-rule
+     '([nil nil nxml-text-face]))
+
+;; Prolog region types in list returned by xmltok-forward-prolog.
+
+(put 'xml-declaration
+     'nxml-fontify-rule
+     '([nil 2 nxml-processing-instruction-delimiter-face]
+       [2 5 nxml-processing-instruction-target-face]
+       [-2 nil nxml-processing-instruction-delimiter-face]))
+
+(put 'xml-declaration-attribute-name
+     'nxml-fontify-rule
+     '([nil nil nxml-attribute-local-name-face]))
+
+(put 'xml-declaration-attribute-value
+     'nxml-fontify-rule
+     '([nil 1 nxml-attribute-value-delimiter-face]
+       [1 -1 nxml-attribute-value-face]
+       [-1 nil nxml-attribute-value-delimiter-face]))
+
+(put 'processing-instruction-left
+     'nxml-fontify-rule
+     '([nil 2 nxml-processing-instruction-delimiter-face]
+       [2 nil nxml-processing-instruction-target-face]))
+
+(put 'processing-instruction-right
+     'nxml-fontify-rule
+     '([nil -2 nxml-processing-instruction-content-face]
+       [-2 nil nxml-processing-instruction-delimiter-face]))
+
+(put 'literal
+     'nxml-fontify-rule
+     '([nil 1 nxml-prolog-literal-delimiter-face]
+       [1 -1 nxml-prolog-literal-content-face]
+       [-1 nil nxml-prolog-literal-delimiter-face]))
+
+(put 'keyword
+     'nxml-fontify-rule
+     '([nil nil nxml-prolog-keyword-face]))
+
+(put 'markup-declaration-open
+     'nxml-fontify-rule
+     '([0 2 nxml-markup-declaration-delimiter-face]
+       [2 nil nxml-prolog-keyword-face]))
+
+(put 'markup-declaration-close
+     'nxml-fontify-rule
+     '([nil nil nxml-markup-declaration-delimiter-face]))
+
+(put 'internal-subset-open
+     'nxml-fontify-rule
+     '([nil nil nxml-markup-declaration-delimiter-face]))
+
+(put 'internal-subset-close
+     'nxml-fontify-rule
+     '([nil 1 nxml-markup-declaration-delimiter-face]
+       [-1 nil nxml-markup-declaration-delimiter-face]))
+
+(put 'hash-name
+     'nxml-fontify-rule
+     '([nil 1 nxml-hash-face]
+       [1 nil nxml-prolog-keyword-face]))
+
+(defun nxml-apply-fontify-rule (&optional type start end)
+  (let ((rule (get (or type xmltok-type) 'nxml-fontify-rule)))
+    (unless start (setq start xmltok-start))
+    (unless end (setq end (point)))
+    (while rule
+      (let* ((action (car rule)))
+        (setq rule (cdr rule))
+        (cond ((vectorp action)
+               (nxml-set-face (let ((offset (aref action 0)))
+                                (cond ((not offset) start)
+                                      ((< offset 0) (+ end offset))
+                                      (t (+ start offset))))
+                              (let ((offset (aref action 1)))
+                                (cond ((not offset) end)
+                                      ((< offset 0) (+ end offset))
+                                      (t (+ start offset))))
+                              (aref action 2)))
+              ((and (consp action)
+                    (eq (car action) 'element-qname))
+               (when xmltok-name-end ; maybe nil in partial-end-tag case
+                 (nxml-fontify-qname (+ start (cdr action))
+                                     xmltok-name-colon
+                                     xmltok-name-end
+                                     'nxml-element-prefix-face
+                                     'nxml-element-colon-face
+                                     'nxml-element-local-name-face)))
+              ((eq action 'attributes)
+               (nxml-fontify-attributes))
+              ((eq action 'processing-instruction-content)
+               (nxml-set-face (+ start 2)
+                              xmltok-name-end
+                              'nxml-processing-instruction-target-face)
+               (nxml-set-face (save-excursion
+                                (goto-char xmltok-name-end)
+                                (skip-chars-forward " \t\r\n")
+                                (point))
+                              (- end 2)
+                              'nxml-processing-instruction-content-face))
+              ((eq action 'char-ref)
+               (nxml-char-ref-display-extra start
+                                            end
+                                            (xmltok-char-number start end)))
+              (t (error "Invalid nxml-fontify-rule action %s" action)))))))
+
+(defun nxml-fontify-attributes ()
+  (while xmltok-namespace-attributes
+    (nxml-fontify-attribute (car xmltok-namespace-attributes)
+                            'namespace)
+    (setq xmltok-namespace-attributes
+          (cdr xmltok-namespace-attributes)))
+  (while xmltok-attributes
+    (nxml-fontify-attribute (car xmltok-attributes))
+    (setq xmltok-attributes
+          (cdr xmltok-attributes))))
+
+(defun nxml-fontify-attribute (att &optional namespace-declaration)
+  (if namespace-declaration
+      (nxml-fontify-qname (xmltok-attribute-name-start att)
+                          (xmltok-attribute-name-colon att)
+                          (xmltok-attribute-name-end att)
+                          'nxml-namespace-attribute-xmlns-face
+                          'nxml-namespace-attribute-colon-face
+                          'nxml-namespace-attribute-prefix-face
+                          'nxml-namespace-attribute-xmlns-face)
+    (nxml-fontify-qname (xmltok-attribute-name-start att)
+                        (xmltok-attribute-name-colon att)
+                        (xmltok-attribute-name-end att)
+                        'nxml-attribute-prefix-face
+                        'nxml-attribute-colon-face
+                        'nxml-attribute-local-name-face))
+  (let ((start (xmltok-attribute-value-start att))
+        (end (xmltok-attribute-value-end att))
+        (refs (xmltok-attribute-refs att))
+        (delimiter-face (if namespace-declaration
+                            'nxml-namespace-attribute-value-delimiter-face
+                          'nxml-attribute-value-delimiter-face))
+        (value-face (if namespace-declaration
+                        'nxml-namespace-attribute-value-face
+                      'nxml-attribute-value-face)))
+    (when start
+      (nxml-set-face (1- start) start delimiter-face)
+      (nxml-set-face end (1+ end) delimiter-face)
+      (while refs
+        (let* ((ref (car refs))
+               (ref-type (aref ref 0))
+               (ref-start (aref ref 1))
+               (ref-end (aref ref 2)))
+          (nxml-set-face start ref-start value-face)
+          (nxml-apply-fontify-rule ref-type ref-start ref-end)
+          (setq start ref-end))
+        (setq refs (cdr refs)))
+      (nxml-set-face start end value-face))))
+
+(defun nxml-fontify-qname (start
+                           colon
+                           end
+                           prefix-face
+                           colon-face
+                           local-name-face
+                           &optional
+                           unprefixed-face)
+  (cond (colon (nxml-set-face start colon prefix-face)
+               (nxml-set-face colon (1+ colon) colon-face)
+               (nxml-set-face (1+ colon) end local-name-face))
+        (t (nxml-set-face start end (or unprefixed-face
+                                        local-name-face)))))
+
+;;; Editing
+
+(defun nxml-electric-slash (arg)
+  "Insert a slash.
+
+With a prefix ARG, do nothing other than insert the slash.
+
+Otherwise, if `nxml-slash-auto-complete-flag' is non-nil, insert the
+rest of the end-tag or empty-element if the slash is potentially part
+of an end-tag or the close of an empty-element.
+
+If the slash is part of an end-tag that is the first non-whitespace
+on the line, reindent the line."
+  (interactive "*P")
+  (nxml-ensure-scan-up-to-date)
+  (let* ((slash-pos (point))
+         (end-tag-p (and (eq (char-before slash-pos) ?<)
+                         (not (nxml-get-inside slash-pos))))
+         (at-indentation (save-excursion
+                           (back-to-indentation)
+                           (eq (point) (1- slash-pos)))))
+    (self-insert-command (prefix-numeric-value arg))
+    (unless arg
+      (if nxml-slash-auto-complete-flag
+          (if end-tag-p
+              (condition-case err
+                  (let ((start-tag-end
+                         (nxml-scan-element-backward (1- slash-pos) t)))
+                    (when start-tag-end
+                      (insert (xmltok-start-tag-qname) ">")
+                      ;; copy the indentation of the start-tag
+                      (when (and at-indentation
+                                 (save-excursion
+                                   (goto-char xmltok-start)
+                                   (back-to-indentation)
+                                   (eq (point) xmltok-start)))
+                        (save-excursion
+                          (indent-line-to (save-excursion
+                                            (goto-char xmltok-start)
+                                            (current-column)))))))
+                (nxml-scan-error nil))
+            (when (and (eq (nxml-token-before) (point))
+                       (eq xmltok-type 'partial-empty-element))
+              (insert ">")))
+        (when (and end-tag-p at-indentation)
+          (nxml-indent-line))))))
+
+(defun nxml-balanced-close-start-tag-block ()
+  "Close the start-tag before point with `>' and insert a balancing end-tag.
+Point is left between the start-tag and the end-tag.
+If there is nothing but whitespace before the `<' that opens the
+start-tag, then put point on a blank line, and put the end-tag on
+another line aligned with the start-tag."
+  (interactive "*")
+  (nxml-balanced-close-start-tag 'block))
+
+(defun nxml-balanced-close-start-tag-inline ()
+  "Close the start-tag before point with `>' and insert a balancing end-tag.
+Point is left between the start-tag and the end-tag.
+No extra whitespace is inserted."
+  (interactive "*")
+  (nxml-balanced-close-start-tag 'inline))
+
+(defun nxml-balanced-close-start-tag (block-or-inline)
+  (let ((token-end (nxml-token-before))
+        (pos (1+ (point))))
+    (unless (or (eq xmltok-type 'partial-start-tag)
+                (and (memq xmltok-type '(start-tag
+                                         empty-element
+                                         partial-empty-element))
+                     (>= token-end pos)))
+      (error "Not in a start-tag"))
+    (insert "></"
+            (buffer-substring-no-properties (+ xmltok-start 1)
+                                            (min xmltok-name-end (point)))
+            ">")
+    (if (eq block-or-inline 'inline)
+        (goto-char pos)
+      (goto-char xmltok-start)
+      (back-to-indentation)
+      (if (= (point) xmltok-start)
+          (let ((indent (current-column)))
+          (goto-char pos)
+          (insert "\n")
+          (indent-line-to indent)
+          (goto-char pos)
+          (insert "\n")
+          (indent-line-to (+ nxml-child-indent indent)))
+        (goto-char pos)))))
+        
+(defun nxml-finish-element ()
+  "Finish the current element by inserting an end-tag."
+  (interactive "*")
+  (nxml-finish-element-1 nil))
+
+(defvar nxml-last-split-position nil
+  "Position where `nxml-split-element' split the current element.")
+
+(defun nxml-split-element ()
+  "Split the current element by inserting an end-tag and a start-tag.
+Point is left after the newly inserted start-tag.  When repeated,
+split immediately before the previously inserted start-tag and leave
+point unchanged."
+  (interactive "*")
+  (setq nxml-last-split-position
+        (if (and (eq last-command this-command)
+                 nxml-last-split-position)
+            (save-excursion
+              (goto-char nxml-last-split-position)
+              (nxml-finish-element-1 t))
+          (nxml-finish-element-1 t))))
+
+(defun nxml-finish-element-1 (startp)
+  "Insert an end-tag for the current element and optionally a start-tag.
+The start-tag is inserted if STARTP is non-nil.  Return the position
+of the inserted start-tag or nil if none was inserted."
+  (interactive "*")
+  (let* ((token-end (nxml-token-before))
+         (start-tag-end
+          (save-excursion
+            (when (and (< (point) token-end)
+                       (memq xmltok-type
+                             '(cdata-section
+                               processing-instruction
+                               comment
+                               start-tag
+                               end-tag
+                               empty-element)))
+              (error "Point is inside a %s"
+                     (nxml-token-type-friendly-name xmltok-type)))
+            (nxml-scan-element-backward token-end t)))
+         (starts-line
+          (save-excursion
+            (unless (eq xmltok-type 'start-tag)
+              (error "No matching start-tag"))
+            (goto-char xmltok-start)
+            (back-to-indentation)
+            (eq (point) xmltok-start)))
+         (ends-line
+          (save-excursion
+            (goto-char start-tag-end)
+            (looking-at "[ \t\r\n]*$")))
+         (start-tag-indent (save-excursion
+                             (goto-char xmltok-start)
+                             (current-column)))
+         (qname (xmltok-start-tag-qname))
+         inserted-start-tag-pos)
+    (when (and starts-line ends-line)
+      ;; start-tag is on a line by itself
+      ;; => put the end-tag on a line by itself
+      (unless (<= (point)
+                  (save-excursion
+                    (back-to-indentation)
+                    (point)))
+        (insert "\n"))
+      (indent-line-to start-tag-indent))
+    (insert "</" qname ">")
+    (when startp
+      (when starts-line
+        (insert "\n")
+        (indent-line-to start-tag-indent))
+      (setq inserted-start-tag-pos (point))
+      (insert "<" qname ">")
+      (when (and starts-line ends-line)
+        (insert "\n")
+        (indent-line-to (save-excursion
+                          (goto-char xmltok-start)
+                          (forward-line 1)
+                          (back-to-indentation)
+                          (if (= (current-column)
+                                 (+ start-tag-indent nxml-child-indent))
+                              (+ start-tag-indent nxml-child-indent)
+                            start-tag-indent)))))
+    inserted-start-tag-pos))
+
+;;; Indentation
+
+(defun nxml-indent-line ()
+  "Indent current line as XML."
+  (let ((indent (nxml-compute-indent))
+        (from-end (- (point-max) (point))))
+    (when indent
+      (beginning-of-line)
+      (let ((bol (point)))
+        (skip-chars-forward " \t")
+        (delete-region bol (point)))
+      (indent-to indent)
+      (when (> (- (point-max) from-end) (point))
+        (goto-char (- (point-max) from-end))))))
+
+(defun nxml-compute-indent ()
+  "Return the indent for the line containing point."
+  (or (nxml-compute-indent-from-matching-start-tag)
+      (nxml-compute-indent-from-previous-line)))
+
+(defun nxml-compute-indent-from-matching-start-tag ()
+  "Compute the indent for a line with an end-tag using the matching start-tag.
+When the line containing point ends with an end-tag and does not start
+in the middle of a token, return the indent of the line containing the
+matching start-tag, if there is one and it occurs at the beginning of
+its line.  Otherwise return nil."
+  (save-excursion
+    (back-to-indentation)
+    (let ((bol (point)))
+      (let ((inhibit-field-text-motion t))
+        (end-of-line))
+      (skip-chars-backward " \t")
+      (and (= (nxml-token-before) (point))
+           (memq xmltok-type '(end-tag partial-end-tag))
+           ;; start of line must not be inside a token
+           (or (= xmltok-start bol)
+               (save-excursion
+                 (goto-char bol)
+                 (nxml-token-after)
+                 (= xmltok-start bol))
+               (eq xmltok-type 'data))
+           (condition-case err
+               (nxml-scan-element-backward
+                (point)
+                nil
+                (- (point)
+                   nxml-end-tag-indent-scan-distance))
+             (nxml-scan-error nil))
+           (< xmltok-start bol)
+           (progn
+             (goto-char xmltok-start)
+             (skip-chars-backward " \t")
+             (bolp))
+           (current-indentation)))))
+
+(defun nxml-compute-indent-from-previous-line ()
+  "Compute the indent for a line using the indentation of a previous line."
+  (save-excursion
+    (end-of-line)
+    (let ((eol (point))
+          bol prev-bol ref
+          before-context after-context)
+      (back-to-indentation)
+      (setq bol (point))
+      (catch 'indent
+        ;; Move backwards until the start of a non-blank line that is
+        ;; not inside a token.
+        (while (progn
+                 (when (= (forward-line -1) -1)
+                   (throw 'indent 0))
+                 (back-to-indentation)
+                 (if (looking-at "[ \t]*$")
+                     t
+                   (or prev-bol
+                       (setq prev-bol (point)))
+                   (nxml-token-after)
+                   (not (or (= xmltok-start (point))
+                            (eq xmltok-type 'data))))))
+        (setq ref (point))
+        ;; Now scan over tokens until the end of the line to be indented.
+        ;; Determine the context before and after the beginning of the
+        ;; line.
+        (while (< (point) eol)
+          (nxml-tokenize-forward)
+          (cond ((<= bol xmltok-start)
+                 (setq after-context
+                       (nxml-merge-indent-context-type after-context)))
+                ((and (<= (point) bol)
+                      (not (and (eq xmltok-type 'partial-start-tag)
+                                (= (point) bol))))
+                 (setq before-context
+                       (nxml-merge-indent-context-type before-context)))
+                ((eq xmltok-type 'data)
+                 (setq before-context
+                       (nxml-merge-indent-context-type before-context))
+                 (setq after-context
+                       (nxml-merge-indent-context-type after-context)))
+                ;; If in the middle of a token that looks inline,
+                ;; then indent relative to the previous non-blank line
+                ((eq (nxml-merge-indent-context-type before-context)
+                     'mixed)
+                 (goto-char prev-bol)
+                 (throw 'indent (current-column)))
+                (t
+                 (throw 'indent
+                        (nxml-compute-indent-in-token bol))))
+          (skip-chars-forward " \t\r\n"))
+        (goto-char ref)
+        (+ (current-column)
+           (* nxml-child-indent
+              (+ (if (eq before-context 'start-tag) 1 0)
+                 (if (eq after-context 'end-tag) -1 0))))))))
+
+(defun nxml-merge-indent-context-type (context)
+  "Merge the indent context type CONTEXT with the token in `xmltok-type'.
+Return the merged indent context type.  An indent context type is
+either nil or one of the symbols start-tag, end-tag, markup, comment,
+mixed."
+  (cond ((memq xmltok-type '(start-tag partial-start-tag))
+         (if (memq context '(nil start-tag comment))
+             'start-tag
+           'mixed))
+        ((memq xmltok-type '(end-tag partial-end-tag))
+         (if (memq context '(nil end-tag comment))
+             'end-tag
+           'mixed))
+        ((eq xmltok-type 'comment)
+         (cond ((memq context '(start-tag end-tag comment))
+                context)
+               (context 'mixed)
+               (t 'comment)))
+        (context 'mixed)
+        (t 'markup)))
+
+(defun nxml-compute-indent-in-token (pos)
+  "Return the indent for a line that starts inside a token.
+POS is the position of the first non-whitespace character of the line.
+This expects the xmltok-* variables to be set up as by `xmltok-forward'."
+  (cond ((memq xmltok-type '(start-tag
+                             partial-start-tag
+                             empty-element
+                             partial-empty-element))
+         (nxml-compute-indent-in-start-tag pos))
+        ((eq xmltok-type 'comment)
+         (nxml-compute-indent-in-delimited-token pos "<!--" "-->"))
+        ((eq xmltok-type 'cdata-section)
+         (nxml-compute-indent-in-delimited-token pos "<![CDATA[" "]]>"))
+        ((eq xmltok-type 'processing-instruction)
+         (nxml-compute-indent-in-delimited-token pos "<?" "?>"))
+        (t
+         (goto-char pos)
+         (if (and (= (forward-line -1) 0)
+                  (< xmltok-start (point)))
+             (back-to-indentation)
+           (goto-char xmltok-start))
+         (current-column))))
+
+(defun nxml-compute-indent-in-start-tag (pos)
+  "Return the indent for a line that starts inside a start-tag.
+Also for a line that starts inside an empty element.
+POS is the position of the first non-whitespace character of the line.
+This expects the xmltok-* variables to be set up as by `xmltok-forward'."
+  (let ((value-boundary (nxml-attribute-value-boundary pos))
+        (off 0))
+    (if value-boundary
+        ;; inside an attribute value
+        (let ((value-start (car value-boundary))
+              (value-end (cdr value-boundary)))
+          (goto-char pos)
+          (forward-line -1)
+          (if (< (point) value-start)
+              (goto-char value-start)
+            (back-to-indentation)))
+      ;; outside an attribute value
+      (goto-char pos)
+      (while (and (= (forward-line -1) 0)
+                  (nxml-attribute-value-boundary (point))))
+      (cond ((<= (point) xmltok-start)
+             (goto-char xmltok-start)
+             (setq off nxml-attribute-indent)
+             (let ((atts (xmltok-merge-attributes)))
+               (when atts
+                 (let* ((att (car atts))
+                        (start (xmltok-attribute-name-start att)))
+                   (when (< start pos)
+                     (goto-char start)
+                     (setq off 0))))))
+            (t
+             (back-to-indentation))))
+    (+ (current-column) off)))
+
+(defun nxml-attribute-value-boundary (pos)
+  "Return a pair (START . END) if POS is inside an attribute value.
+Otherwise return nil.  START and END are the positions of the start
+and end of the attribute value containing POS.  This expects the
+xmltok-* variables to be set up as by `xmltok-forward'."
+  (let ((atts (xmltok-merge-attributes))
+        att value-start value-end value-boundary)
+    (while atts
+      (setq att (car atts))
+      (setq value-start (xmltok-attribute-value-start att))
+      (setq value-end (xmltok-attribute-value-end att))
+      (cond ((and value-start (< pos value-start))
+             (setq atts nil))
+            ((and value-start value-end (<= pos value-end))
+             (setq value-boundary (cons value-start value-end))
+             (setq atts nil))
+            (t (setq atts (cdr atts)))))
+    value-boundary))
+             
+(defun nxml-compute-indent-in-delimited-token (pos open-delim close-delim)
+  "Return the indent for a line that starts inside a token with delimiters.
+OPEN-DELIM and CLOSE-DELIM are strings giving the opening and closing
+delimiters.  POS is the position of the first non-whitespace character
+of the line.  This expects the xmltok-* variables to be set up as by
+`xmltok-forward'."
+  (cond ((let ((end (+ pos (length close-delim))))
+           (and (<= end (point-max))
+                (string= (buffer-substring-no-properties pos end)
+                         close-delim)))
+         (goto-char xmltok-start))
+        ((progn
+           (goto-char pos)
+           (forward-line -1)
+           (<= (point) xmltok-start))
+         (goto-char (+ xmltok-start (length open-delim)))
+         (when (and (string= open-delim "<!--")
+                    (looking-at " "))
+           (goto-char (1+ (point)))))
+        (t (back-to-indentation)))
+  (current-column))
+
+;;; Completion
+
+(defun nxml-complete ()
+  "Perform completion on the symbol preceding point.
+
+Inserts as many characters as can be completed.  However, if not even
+one character can be completed, then a buffer with the possibilities
+is popped up and the symbol is read from the minibuffer with
+completion. If the symbol is complete, then any characters that must
+follow the symbol are also inserted.
+
+The name space used for completion and what is treated as a symbol
+depends on the context.  The contexts in which completion is performed
+depend on `nxml-completion-hook'."
+  (interactive)
+  (unless (run-hook-with-args-until-success 'nxml-completion-hook)
+    ;; Eventually we will complete on entity names here.
+    (ding)
+    (message "Cannot complete in this context")))
+
+;;; Movement
+
+(defun nxml-forward-balanced-item (&optional arg)
+  "Move forward across one balanced item.
+With ARG, do it that many times.  Negative arg -N means
+move backward across N balanced expressions.
+This is the equivalent of `forward-sexp' for XML.
+
+An element contains as items strings with no markup, tags, processing
+instructions, comments, CDATA sections, entity references and
+characters references. However, if the variable
+`nxml-sexp-element-flag' is non-nil, then an element is treated as a
+single markup item.  A start-tag contains an element name followed by
+one or more attributes.  An end-tag contains just an element name.  An
+attribute value literals contains strings with no markup, entity
+references and character references.  A processing instruction
+consists of a target and a content string.  A comment or a CDATA
+section contains a single string.  An entity reference contains a
+single name.  A character reference contains a character number."
+  (interactive "p")
+  (or arg (setq arg 1))
+  (cond ((> arg 0)
+         (while (progn
+                  (nxml-forward-single-balanced-item)
+                  (> (setq arg (1- arg)) 0))))
+        ((< arg 0)
+         (while (progn
+                  (nxml-backward-single-balanced-item)
+                  (< (setq arg (1+ arg)) 0))))))
+
+(defun nxml-forward-single-balanced-item ()
+  (condition-case err
+      (goto-char (let ((end (nxml-token-after)))
+                   (save-excursion
+                     (while (eq xmltok-type 'space)
+                       (goto-char end)
+                       (setq end (nxml-token-after)))
+                     (cond ((/= (point) xmltok-start)
+                            (nxml-scan-forward-within end))
+                           ((and nxml-sexp-element-flag
+                                 (eq xmltok-type 'start-tag))
+                            ;; can't ever return nil here
+                            (nxml-scan-element-forward xmltok-start))
+                           ((and nxml-sexp-element-flag
+                                 (memq xmltok-type
+                                       '(end-tag partial-end-tag)))
+                            (error "Already at end of element"))
+                           (t end)))))
+    (nxml-scan-error
+     (goto-char (cadr err))
+     (apply 'error (cddr err)))))
+
+(defun nxml-backward-single-balanced-item ()
+  (condition-case err
+      (goto-char (let ((end (nxml-token-before)))
+                   (save-excursion
+                     (while (eq xmltok-type 'space)
+                       (goto-char xmltok-start)
+                       (setq end (nxml-token-before)))
+                     (cond ((/= (point) end)
+                            (nxml-scan-backward-within end))
+                           ((and nxml-sexp-element-flag
+                                 (eq xmltok-type 'end-tag))
+                            ;; can't ever return nil here
+                            (nxml-scan-element-backward end)
+                            xmltok-start)
+                           ((and nxml-sexp-element-flag
+                                 (eq xmltok-type 'start-tag))
+                            (error "Already at start of element"))
+                           (t xmltok-start)))))
+    (nxml-scan-error
+     (goto-char (cadr err))
+     (apply 'error (cddr err)))))
+
+(defun nxml-scan-forward-within (end)
+  (setq end (- end (nxml-end-delimiter-length xmltok-type)))
+  (when (<= end (point))
+    (error "Already at end of %s"
+           (nxml-token-type-friendly-name xmltok-type)))
+  (cond ((memq xmltok-type '(start-tag
+                             empty-element
+                             partial-start-tag
+                             partial-empty-element))
+         (if (< (point) xmltok-name-end)
+             xmltok-name-end
+           (let ((att (nxml-find-following-attribute)))
+             (cond ((not att) end)
+                   ((and (xmltok-attribute-value-start att)
+                         (<= (xmltok-attribute-value-start att)
+                             (point)))
+                    (nxml-scan-forward-in-attribute-value att))
+                   ((xmltok-attribute-value-end att)
+                    (1+ (xmltok-attribute-value-end att)))
+                   ((save-excursion
+                      (goto-char (xmltok-attribute-name-end att))
+                      (looking-at "[ \t\r\n]*="))
+                    (match-end 0))
+                   (t (xmltok-attribute-name-end att))))))
+        ((and (eq xmltok-type 'processing-instruction)
+              (< (point) xmltok-name-end))
+         xmltok-name-end)
+        (t end)))
+
+(defun nxml-scan-backward-within (end)
+  (setq xmltok-start
+        (+ xmltok-start
+           (nxml-start-delimiter-length xmltok-type)))
+  (when (<= (point) xmltok-start)
+    (error "Already at start of %s"
+           (nxml-token-type-friendly-name xmltok-type)))
+  (cond ((memq xmltok-type '(start-tag
+                             empty-element
+                             partial-start-tag
+                             partial-empty-element))
+         (let ((att (nxml-find-preceding-attribute)))
+           (cond ((not att) xmltok-start)
+                 ((and (xmltok-attribute-value-start att)
+                       (<= (xmltok-attribute-value-start att)
+                           (point))
+                       (<= (point)
+                           (xmltok-attribute-value-end att)))
+                  (nxml-scan-backward-in-attribute-value att))
+                 (t (xmltok-attribute-name-start att)))))
+        ((and (eq xmltok-type 'processing-instruction)
+              (let ((content-start (save-excursion
+                                     (goto-char xmltok-name-end)
+                                     (skip-chars-forward " \r\t\n")
+                                     (point))))
+                (and (< content-start (point))
+                     content-start))))
+        (t xmltok-start)))
+
+(defun nxml-scan-forward-in-attribute-value (att)
+  (when (= (point) (xmltok-attribute-value-end att))
+    (error "Already at end of attribute value"))
+  (let ((refs (xmltok-attribute-refs att))
+        ref)
+    (while refs
+      (setq ref (car refs))
+      (if (< (point) (aref ref 2))
+          (setq refs nil)
+        (setq ref nil)
+        (setq refs (cdr refs))))
+    (cond ((not ref)
+           (xmltok-attribute-value-end att))
+          ((< (point) (aref ref 1))
+           (aref ref 1))
+          ((= (point) (aref ref 1))
+           (aref ref 2))
+          (t
+           (let ((end (- (aref ref 2)
+                         (nxml-end-delimiter-length (aref ref 0)))))
+             (if (< (point) end)
+                 end
+               (error "Already at end of %s"
+                      (nxml-token-type-friendly-name (aref ref 0)))))))))
+
+(defun nxml-scan-backward-in-attribute-value (att)
+  (when (= (point) (xmltok-attribute-value-start att))
+    (error "Already at start of attribute value"))
+  (let ((refs (reverse (xmltok-attribute-refs att)))
+        ref)
+    (while refs
+      (setq ref (car refs))
+      (if (< (aref ref 1) (point))
+          (setq refs nil)
+        (setq ref nil)
+        (setq refs (cdr refs))))
+    (cond ((not ref)
+           (xmltok-attribute-value-start att))
+          ((< (aref ref 2) (point))
+           (aref ref 2))
+          ((= (point) (aref ref 2))
+           (aref ref 1))
+          (t
+           (let ((start (+ (aref ref 1)
+                           (nxml-start-delimiter-length (aref ref 0)))))
+             (if (< start (point))
+                 start
+               (error "Already at start of %s"
+                      (nxml-token-type-friendly-name (aref ref 0)))))))))
+
+(defun nxml-find-following-attribute ()
+  (let ((ret nil)
+        (atts (or xmltok-attributes xmltok-namespace-attributes))
+        (more-atts (and xmltok-attributes xmltok-namespace-attributes)))
+    (while atts
+      (let* ((att (car atts))
+             (name-start (xmltok-attribute-name-start att)))
+        (cond ((and (<= name-start (point))
+                    (xmltok-attribute-value-end att)
+                    ;; <= because end is before quote
+                    (<= (point) (xmltok-attribute-value-end att)))
+               (setq atts nil)
+               (setq ret att))
+              ((and (< (point) name-start)
+                    (or (not ret)
+                        (< name-start
+                           (xmltok-attribute-name-start ret))))
+               (setq ret att))))
+      (setq atts (cdr atts))
+      (unless atts
+        (setq atts more-atts)
+        (setq more-atts nil)))
+    ret))
+
+(defun nxml-find-preceding-attribute ()
+  (let ((ret nil)
+        (atts (or xmltok-attributes xmltok-namespace-attributes))
+        (more-atts (and xmltok-attributes xmltok-namespace-attributes)))
+    (while atts
+      (let* ((att (car atts))
+             (name-start (xmltok-attribute-name-start att)))
+        (cond ((and (< name-start (point))
+                    (xmltok-attribute-value-end att)
+                    ;; <= because end is before quote
+                    (<= (point) (xmltok-attribute-value-end att)))
+               (setq atts nil)
+               (setq ret att))
+              ((and (< name-start (point))
+                    (or (not ret)
+                        (< (xmltok-attribute-name-start ret)
+                           name-start)))
+               (setq ret att))))
+      (setq atts (cdr atts))
+      (unless atts
+        (setq atts more-atts)
+        (setq more-atts nil)))
+    ret))
+
+(defun nxml-up-element (&optional arg)
+  (interactive "p")
+  (or arg (setq arg 1))
+  (if (< arg 0)
+      (nxml-backward-up-element (- arg))
+    (condition-case err
+        (while (and (> arg 0)
+                    (< (point) (point-max)))
+          (let ((token-end (nxml-token-after)))
+            (goto-char (cond ((or (memq xmltok-type '(end-tag
+                                                      partial-end-tag))
+                                  (and (memq xmltok-type
+                                             '(empty-element
+                                               partial-empty-element))
+                                       (< xmltok-start (point))))
+                              token-end)
+                             ((nxml-scan-element-forward
+                               (if (and (eq xmltok-type 'start-tag)
+                                        (= (point) xmltok-start))
+                                   xmltok-start
+                                 token-end)
+                               t))
+                             (t (error "No parent element")))))
+          (setq arg (1- arg)))
+      (nxml-scan-error
+       (goto-char (cadr err))
+       (apply 'error (cddr err))))))
+
+(defun nxml-backward-up-element (&optional arg)
+  (interactive "p")
+  (or arg (setq arg 1))
+  (if (< arg 0)
+      (nxml-up-element (- arg))
+    (condition-case err
+        (while (and (> arg 0)
+                    (< (point-min) (point)))
+          (let ((token-end (nxml-token-before)))
+            (goto-char (cond ((or (memq xmltok-type '(start-tag
+                                                      partial-start-tag))
+                                  (and (memq xmltok-type
+                                             '(empty-element
+                                               partial-empty-element))
+                                       (< (point) token-end)))
+                              xmltok-start)
+                             ((nxml-scan-element-backward
+                               (if (and (eq xmltok-type 'end-tag)
+                                        (= (point) token-end))
+                                   token-end
+                                 xmltok-start)
+                               t)
+                              xmltok-start)
+                             (t (error "No parent element")))))
+          (setq arg (1- arg)))
+      (nxml-scan-error
+       (goto-char (cadr err))
+       (apply 'error (cddr err))))))
+
+(defun nxml-down-element (&optional arg)
+  "Move forward down into the content of an element.
+With ARG, do this that many times.
+Negative ARG means move backward but still down."
+  (interactive "p")
+  (or arg (setq arg 1))
+  (if (< arg 0)
+      (nxml-backward-down-element (- arg))
+    (while (> arg 0)
+      (goto-char
+       (let ((token-end (nxml-token-after)))
+         (save-excursion
+           (goto-char token-end)
+           (while (progn
+                    (when (memq xmltok-type '(nil end-tag partial-end-tag))
+                      (error "No following start-tags in this element"))
+                    (not (memq xmltok-type '(start-tag partial-start-tag))))
+             (nxml-tokenize-forward))
+           (point))))
+      (setq arg (1- arg)))))
+
+(defun nxml-backward-down-element (&optional arg)
+  (interactive "p")
+  (or arg (setq arg 1))
+  (if (< arg 0)
+      (nxml-down-element (- arg))
+    (while (> arg 0)
+      (goto-char
+         (save-excursion
+           (nxml-token-before)
+           (goto-char xmltok-start)
+           (while (progn
+                    (when (memq xmltok-type '(start-tag
+                                              partial-start-tag
+                                              prolog
+                                              nil))
+                      (error "No preceding end-tags in this element"))
+                    (not (memq xmltok-type '(end-tag partial-end-tag))))
+             (if (or (<= (point) nxml-prolog-end)
+                     (not (search-backward "<" nxml-prolog-end t)))
+                 (setq xmltok-type nil)
+               (nxml-move-outside-backwards)
+               (xmltok-forward)))
+           xmltok-start))
+      (setq arg (1- arg)))))
+
+(defun nxml-forward-element (&optional arg)
+  "Move forward over one element.
+With ARG, do it that many times.
+Negative ARG means move backward."
+  (interactive "p")
+  (or arg (setq arg 1))
+  (if (< arg 0)
+      (nxml-backward-element (- arg))
+    (condition-case err
+        (while (and (> arg 0)
+                    (< (point) (point-max)))
+          (goto-char
+           (or (nxml-scan-element-forward (nxml-token-before))
+               (error "No more elements")))
+          (setq arg (1- arg)))
+    (nxml-scan-error
+     (goto-char (cadr err))
+     (apply 'error (cddr err))))))
+
+(defun nxml-backward-element (&optional arg)
+  "Move backward over one element.
+With ARG, do it that many times.
+Negative ARG means move forward."
+  (interactive "p")
+  (or arg (setq arg 1))
+  (if (< arg 0)
+      (nxml-forward-element (- arg))
+    (condition-case err
+        (while (and (> arg 0)
+                    (< (point-min) (point)))
+          (goto-char
+           (or (and (nxml-scan-element-backward (progn
+                                                  (nxml-token-after)
+                                                  xmltok-start))
+                    xmltok-start)
+               (error "No preceding elements")))
+          (setq arg (1- arg)))
+    (nxml-scan-error
+     (goto-char (cadr err))
+     (apply 'error (cddr err))))))
+
+(defun nxml-mark-token-after ()
+  (interactive)
+  (push-mark (nxml-token-after) nil t)
+  (goto-char xmltok-start)
+  (message "Marked %s" xmltok-type))
+
+;;; Paragraphs
+
+(defun nxml-mark-paragraph ()
+  "Put point at beginning of this paragraph, mark at end.
+The paragraph marked is the one that contains point or follows point."
+  (interactive)
+  (nxml-forward-paragraph)
+  (push-mark nil t t)
+  (nxml-backward-paragraph))
+
+(defun nxml-forward-paragraph (&optional arg)
+  (interactive "p")
+  (or arg (setq arg 1))
+  (cond ((< arg 0)
+         (nxml-backward-paragraph (- arg)))
+        ((> arg 0)
+         (forward-line 0)
+         (while (and (nxml-forward-single-paragraph)
+                     (> (setq arg (1- arg)) 0))))))
+
+(defun nxml-backward-paragraph (&optional arg)
+  (interactive "p")
+  (or arg (setq arg 1))
+  (cond ((< arg 0)
+         (nxml-forward-paragraph (- arg)))
+        ((> arg 0)
+         (unless (bolp)
+           (let ((inhibit-field-text-motion t))
+             (end-of-line)))
+         (while (and (nxml-backward-single-paragraph)
+                     (> (setq arg (1- arg)) 0))))))
+
+(defun nxml-forward-single-paragraph ()
+  "Move forward over a single paragraph.
+Return nil at end of buffer, t otherwise."
+  (let* ((token-end (nxml-token-after))
+         (offset (- (point) xmltok-start))
+         pos had-data)
+    (goto-char token-end)
+    (while (and (< (point) (point-max))
+                (not (setq pos
+                           (nxml-paragraph-end-pos had-data offset))))
+      (when (nxml-token-contains-data-p offset)
+        (setq had-data t))
+      (nxml-tokenize-forward)
+      (setq offset 0))
+    (when pos (goto-char pos))))
+
+(defun nxml-backward-single-paragraph ()
+  "Move backward over a single paragraph.
+Return nil at start of buffer, t otherwise."
+  (let* ((token-end (nxml-token-before))
+         (offset (- token-end (point)))
+         (last-tag-pos xmltok-start)
+         pos had-data last-data-pos)
+    (goto-char token-end)
+    (unless (setq pos (nxml-paragraph-start-pos nil offset))
+      (setq had-data (nxml-token-contains-data-p nil offset))
+      (goto-char xmltok-start)
+      (while (and (not pos) (< (point-min) (point)))
+        (cond ((search-backward "<" nxml-prolog-end t)
+               (nxml-move-outside-backwards)
+               (save-excursion
+                 (while (< (point) last-tag-pos)
+                   (xmltok-forward)
+                   (when (and (not had-data) (nxml-token-contains-data-p))
+                     (setq pos nil)
+                     (setq last-data-pos xmltok-start))
+                   (let ((tem (nxml-paragraph-start-pos had-data 0)))
+                     (when tem (setq pos tem)))))
+               (when (and (not had-data) last-data-pos (not pos))
+                 (setq had-data t)
+                 (save-excursion
+                   (while (< (point) last-data-pos)
+                     (xmltok-forward))
+                   (let ((tem (nxml-paragraph-start-pos had-data 0)))
+                     (when tem (setq pos tem)))))
+               (setq last-tag-pos (point)))
+              (t (goto-char (point-min))))))
+    (when pos (goto-char pos))))
+
+(defun nxml-token-contains-data-p (&optional start end)
+  (setq start (+ xmltok-start (or start 0)))
+  (setq end (- (point) (or end 0)))
+  (when (eq xmltok-type 'cdata-section)
+    (setq start (max start (+ xmltok-start 9)))
+    (setq end (min end (- (point) 3))))
+  (or (and (eq xmltok-type 'data)
+           (eq start xmltok-start)
+           (eq end (point)))
+      (eq xmltok-type 'char-ref)
+      (and (memq xmltok-type '(data cdata-section))
+           (< start end)
+           (save-excursion
+             (goto-char start)
+             (re-search-forward "[^ \t\r\n]" end t)))))
+
+(defun nxml-paragraph-end-pos (had-data offset)
+  "Return the position of the paragraph end if contained in the current token.
+Return nil if the current token does not contain the paragraph end.
+Only characters after OFFSET from the start of the token are eligible.
+HAD-DATA says whether there have been non-whitespace data characters yet."
+  (cond ((not had-data)
+         (cond ((memq xmltok-type '(data cdata-section))
+                (save-excursion
+                  (let ((end (point)))
+                    (goto-char (+ xmltok-start
+                                  (max (if (eq xmltok-type 'cdata-section)
+                                           9
+                                         0)
+                                       offset)))
+                    (and (re-search-forward "[^ \t\r\n]" end t)
+                         (re-search-forward "^[ \t]*$" end t)
+                         (match-beginning 0)))))
+               ((and (eq xmltok-type 'comment)
+                     (nxml-token-begins-line-p)
+                     (nxml-token-ends-line-p))
+                (save-excursion
+                  (let ((end (point)))
+                    (goto-char (+ xmltok-start (max 4 offset)))
+                    (when (re-search-forward "[^ \t\r\n]" (- end 3) t)
+                      (if (re-search-forward "^[ \t]*$" end t)
+                          (match-beginning 0)
+                        (goto-char (- end 3))
+                        (skip-chars-backward " \t")
+                        (unless (bolp)
+                          (beginning-of-line 2))
+                        (point))))))))
+        ((memq xmltok-type '(data space cdata-section))
+         (save-excursion
+           (let ((end (point)))
+             (goto-char (+ xmltok-start offset))
+             (and (re-search-forward "^[ \t]*$" end t)
+                  (match-beginning 0)))))
+        ((and (memq xmltok-type '(start-tag 
+                                  end-tag
+                                  empty-element
+                                  comment
+                                  processing-instruction
+                                  entity-ref))
+              (nxml-token-begins-line-p)
+              (nxml-token-ends-line-p))
+         (save-excursion
+           (goto-char xmltok-start)
+           (skip-chars-backward " \t")
+           (point)))
+        ((and (eq xmltok-type 'end-tag)
+              (looking-at "[ \t]*$")
+              (not (nxml-in-mixed-content-p t)))
+         (save-excursion
+           (or (search-forward "\n" nil t) 
+               (point-max))))))
+
+(defun nxml-paragraph-start-pos (had-data offset)
+  "Return the position of the paragraph start if contained in the current token.
+Return nil if the current token does not contain the paragraph start.
+Only characters before OFFSET from the end of the token are eligible.
+HAD-DATA says whether there have been non-whitespace data characters yet."
+  (cond ((not had-data)
+         (cond ((memq xmltok-type '(data cdata-section))
+                (save-excursion
+                  (goto-char (- (point)
+                                (max (if (eq xmltok-type 'cdata-section)
+                                         3
+                                       0)
+                                     offset)))
+                  (and (re-search-backward "[^ \t\r\n]" xmltok-start t)
+                       (re-search-backward "^[ \t]*$" xmltok-start t)
+                       (match-beginning 0))))
+               ((and (eq xmltok-type 'comment)
+                     (nxml-token-ends-line-p)
+                     (nxml-token-begins-line-p))
+                (save-excursion
+                  (goto-char (- (point) (max 3 offset)))
+                  (when (and (< (+ xmltok-start 4) (point))
+                             (re-search-backward "[^ \t\r\n]"
+                                                 (+ xmltok-start 4)
+                                                 t))
+                    (if (re-search-backward "^[ \t]*$" xmltok-start t)
+                        (match-beginning 0)
+                      (goto-char xmltok-start)
+                      (if (looking-at "<!--[ \t]*\n")
+                          (match-end 0)
+                        (skip-chars-backward " \t")
+                        (point))))))))
+        ((memq xmltok-type '(data space cdata-section))
+         (save-excursion
+           (goto-char (- (point) offset))
+           (and (re-search-backward "^[ \t]*$" xmltok-start t)
+                (match-beginning 0))))
+        ((and (memq xmltok-type '(start-tag 
+                                  end-tag
+                                  empty-element
+                                  comment
+                                  processing-instruction
+                                  entity-ref))
+              (nxml-token-ends-line-p)
+              (nxml-token-begins-line-p))
+         (or (search-forward "\n" nil t) 
+             (point-max)))
+        ((and (eq xmltok-type 'start-tag)
+              (nxml-token-begins-line-p)
+              (not (save-excursion
+                     (goto-char xmltok-start)
+                     (nxml-in-mixed-content-p nil))))
+         (save-excursion
+           (goto-char xmltok-start)
+           (skip-chars-backward " \t")
+           ;; include any blank line before
+           (or (and (eq (char-before) ?\n)
+                    (save-excursion
+                      (goto-char (1- (point)))
+                      (skip-chars-backward " \t")
+                      (and (bolp) (point))))
+               (point))))))
+
+(defun nxml-token-ends-line-p () (looking-at "[ \t]*$"))
+
+(defun nxml-token-begins-line-p ()
+  (save-excursion
+    (goto-char xmltok-start)
+    (skip-chars-backward " \t")
+    (bolp)))
+
+(defun nxml-in-mixed-content-p (endp)
+  "Return non-nil if point is in mixed content.
+Point must be after an end-tag or before a start-tag.
+ENDP is t in the former case, nil in the latter."
+  (let (matching-tag-pos)
+    (cond ((not (run-hook-with-args-until-failure
+                 'nxml-in-mixed-content-hook))
+           nil)
+          ;; See if the matching tag does not start or end a line.
+          ((condition-case err
+               (progn
+                 (setq matching-tag-pos
+                       (xmltok-save
+                         (if endp
+                             (and (nxml-scan-element-backward (point))
+                                  xmltok-start)
+                           (nxml-scan-element-forward (point)))))
+                 (and matching-tag-pos
+                      (save-excursion
+                        (goto-char matching-tag-pos)
+                        (not (if endp
+                                 (progn
+                                   (skip-chars-backward " \t")
+                                   (bolp))
+                               (looking-at "[ \t]*$"))))))
+             (nxml-scan-error nil))
+           t)
+          ;; See if there's data at the same level.
+          ((let (start end)
+             (if endp
+                 (setq start matching-tag-pos
+                       end (point))
+               (setq start (point)
+                     end matching-tag-pos))
+             (save-excursion
+               (or (when start
+                     (goto-char start)
+                     (nxml-preceding-sibling-data-p))
+                   (when end
+                     (goto-char end)
+                     (nxml-following-sibling-data-p)))))
+           t)
+          ;; Otherwise, treat as not mixed
+          (t nil))))
+
+(defun nxml-preceding-sibling-data-p ()
+  "Return non-nil if there is a previous sibling that is data."
+  (let ((lim (max (- (point) nxml-mixed-scan-distance)
+                  nxml-prolog-end))
+        (level 0)
+        found end)
+    (xmltok-save
+      (save-excursion
+        (while (and (< lim (point))
+                    (>= level 0)
+                    (not found)
+                    (progn
+                      (setq end (point))
+                      (search-backward "<" lim t)))
+          (nxml-move-outside-backwards)
+          (save-excursion
+            (xmltok-forward)
+            (let ((prev-level level))
+              (cond ((eq xmltok-type 'end-tag)
+                     (setq level (1+ level)))
+                    ((eq xmltok-type 'start-tag)
+                     (setq level (1- level))))
+              (when (eq prev-level 0)
+                (while (and (< (point) end) (not found))
+                  (xmltok-forward)
+                  (when (memq xmltok-type '(data cdata-section char-ref))
+                    (setq found t)))))))))
+    found))
+
+(defun nxml-following-sibling-data-p ()
+  (let ((lim (min (+ (point) nxml-mixed-scan-distance)
+                  (point-max)))
+        (level 0)
+        found)
+    (xmltok-save
+      (save-excursion
+        (while (and (< (point) lim)
+                    (>= level 0)
+                    (nxml-tokenize-forward)
+                    (not found))
+          (cond ((eq xmltok-type 'start-tag)
+                 (setq level (1+ level)))
+                ((eq xmltok-type 'end-tag)
+                 (setq level (1- level)))
+                ((and (eq level 0)
+                      (memq xmltok-type '(data cdata-section char-ref)))
+                 (setq found t))))))
+    found))
+
+;;; Filling
+
+(defun nxml-do-fill-paragraph (arg)
+  (let (fill-paragraph-function
+        fill-prefix
+        start end)
+    (save-excursion
+      (nxml-forward-paragraph)
+      (setq end (point))
+      (nxml-backward-paragraph)
+      (skip-chars-forward " \t\r\n")
+      (setq start (point))
+      (beginning-of-line)
+      (setq fill-prefix (buffer-substring-no-properties (point) start))
+      (when (and (not (nxml-get-inside (point)))
+                 (looking-at "[ \t]*<!--"))
+        (setq fill-prefix (concat fill-prefix "     ")))
+      (fill-region-as-paragraph start end arg))
+    (skip-line-prefix fill-prefix)
+    fill-prefix))
+    
+(defun nxml-newline-and-indent (soft)
+  (delete-horizontal-space)
+  (if soft (insert-and-inherit ?\n) (newline 1))
+  (nxml-indent-line))
+
+
+;;; Dynamic markup
+
+(defvar nxml-dynamic-markup-prev-pos nil)
+(defvar nxml-dynamic-markup-prev-lengths nil)
+(defvar nxml-dynamic-markup-prev-found-marker nil)
+(defvar nxml-dynamic-markup-prev-start-tags (make-hash-table :test 'equal))
+
+(defun nxml-dynamic-markup-word ()
+  "Dynamically markup the word before point.
+This attempts to find a tag to put around the word before point based
+on the contents of the current buffer. The end-tag will be inserted at
+point.  The start-tag will be inserted at or before the beginning of
+the word before point; the contents of the current buffer is used to
+decide where.
+
+It works in a similar way to \\[dabbrev-expand]. It searches first
+backwards from point, then forwards from point for an element whose
+content is a string which matches the contents of the buffer before
+point and which includes at least the word before point. It then
+copies the start- and end-tags from that element and uses them to
+surround the matching string before point.
+
+Repeating \\[nxml-dynamic-markup-word] immediately after successful
+\\[nxml-dynamic-markup-word] removes the previously inserted markup
+and attempts to find another possible way to do the markup."
+  (interactive "*")
+  (let (search-start-pos done)
+    (if (and (integerp nxml-dynamic-markup-prev-pos)
+             (= nxml-dynamic-markup-prev-pos (point))
+             (eq last-command this-command)
+             nxml-dynamic-markup-prev-lengths)
+        (let* ((end-tag-open-pos
+                (- nxml-dynamic-markup-prev-pos
+                   (nth 2 nxml-dynamic-markup-prev-lengths)))
+               (start-tag-close-pos
+                (- end-tag-open-pos
+                   (nth 1 nxml-dynamic-markup-prev-lengths)))
+               (start-tag-open-pos
+                (- start-tag-close-pos
+                   (nth 0 nxml-dynamic-markup-prev-lengths))))
+          (delete-region end-tag-open-pos nxml-dynamic-markup-prev-pos)
+          (delete-region start-tag-open-pos start-tag-close-pos)
+          (setq search-start-pos
+                (marker-position nxml-dynamic-markup-prev-found-marker)))
+      (clrhash nxml-dynamic-markup-prev-start-tags))
+    (setq nxml-dynamic-markup-prev-pos nil)
+    (setq nxml-dynamic-markup-prev-lengths nil)
+    (setq nxml-dynamic-markup-prev-found-marker nil)
+    (goto-char
+     (save-excursion
+       (let* ((pos (point))
+              (word (progn
+                      (backward-word 1)
+                      (unless (< (point) pos)
+                        (error "No word to markup"))
+                      (buffer-substring-no-properties (point) pos)))
+              (search (concat word "</"))
+              done)
+         (when search-start-pos
+           (goto-char search-start-pos))
+         (while (and (not done)
+                     (or (and (< (point) pos)
+                              (or (search-backward search nil t)
+                                  (progn (goto-char pos) nil)))
+                         (search-forward search nil t)))
+           (goto-char (- (match-end 0) 2))
+           (setq done (nxml-try-copy-markup pos)))
+         (or done
+             (error (if (zerop (hash-table-count
+                                nxml-dynamic-markup-prev-start-tags))
+                        "No possible markup found for `%s'"
+                      "No more markup possibilities found for `%s'")
+                    word)))))))
+
+(defun nxml-try-copy-markup (word-end-pos)
+  (save-excursion
+    (let ((end-tag-pos (point)))
+      (when (and (not (nxml-get-inside end-tag-pos))
+                 (search-backward "<" nil t)
+                 (not (nxml-get-inside (point))))
+        (xmltok-forward)
+        (when (and (eq xmltok-type 'start-tag)
+                   (< (point) end-tag-pos))
+          (let* ((start-tag-close-pos (point))
+                 (start-tag
+                  (buffer-substring-no-properties xmltok-start
+                                                  start-tag-close-pos))
+                 (words
+                  (nreverse
+                   (split-string
+                    (buffer-substring-no-properties start-tag-close-pos
+                                                    end-tag-pos)
+                    "[ \t\r\n]+"))))
+            (goto-char word-end-pos)
+            (while (and words
+                        (re-search-backward (concat
+                                             (regexp-quote (car words))
+                                             "\\=")
+                                            nil
+                                            t))
+              (setq words (cdr words))
+              (skip-chars-backward " \t\r\n"))
+            (when (and (not words)
+                       (progn
+                         (skip-chars-forward " \t\r\n")
+                         (not (gethash (cons (point) start-tag)
+                                       nxml-dynamic-markup-prev-start-tags)))
+                       (or (< end-tag-pos (point))
+                           (< word-end-pos xmltok-start)))
+              (setq nxml-dynamic-markup-prev-found-marker
+                    (copy-marker end-tag-pos t))
+              (puthash (cons (point) start-tag)
+                       t
+                       nxml-dynamic-markup-prev-start-tags)
+              (setq nxml-dynamic-markup-prev-lengths
+                    (list (- start-tag-close-pos xmltok-start)
+                          (-  word-end-pos (point))
+                          (+ (- xmltok-name-end xmltok-start) 2)))
+              (let ((name (xmltok-start-tag-qname)))
+                (insert start-tag)
+                (goto-char (+ word-end-pos
+                              (- start-tag-close-pos xmltok-start)))
+                (insert "</" name ">")
+                (setq nxml-dynamic-markup-prev-pos (point))))))))))
+                                                           
+
+;;; Character names
+
+(defvar nxml-char-name-ignore-case nil)
+
+(defvar nxml-char-name-alist nil
+  "Alist of character names.
+Each member of the list has the form (NAME CODE . NAMESET),
+where NAME is a string naming a character, NAMESET is a symbol
+identifying a set of names and CODE is an integer specifying the
+Unicode scalar value of the named character.
+The NAME will only be used for completion if NAMESET has
+a non-nil `nxml-char-name-set-enabled' property.
+If NAMESET does does not have `nxml-char-name-set-defined' property,
+then it must have a `nxml-char-name-set-file' property and `load'
+will be applied to the value of this property if the nameset
+is enabled.")
+
+(defvar nxml-char-name-table (make-hash-table :test 'eq)
+  "Hash table for mapping char codes to names.
+Each key is a Unicode scalar value.
+Each value is a list of pairs of the form (NAMESET . NAME),
+where NAMESET is a symbol identifying a set of names,
+and NAME is a string naming a character.")
+
+(defvar nxml-autoload-char-name-set-list nil
+  "List of char namesets that can be autoloaded.")
+
+(defun nxml-enable-char-name-set (nameset)    
+  (put nameset 'nxml-char-name-set-enabled t))
+
+(defun nxml-disable-char-name-set (nameset)    
+  (put nameset 'nxml-char-name-set-enabled nil))
+
+(defun nxml-char-name-set-enabled-p (nameset)
+  (get nameset 'nxml-char-name-set-enabled))
+
+(defun nxml-autoload-char-name-set (nameset file)
+  (unless (memq nameset nxml-autoload-char-name-set-list)
+    (setq nxml-autoload-char-name-set-list
+          (cons nameset nxml-autoload-char-name-set-list)))
+  (put nameset 'nxml-char-name-set-file file))
+
+(defun nxml-define-char-name-set (nameset alist)
+  "Define a set of character names.
+NAMESET is a symbol identifying the set.
+Alist is a list where each member has the form (NAME CODE),
+where NAME is a string naming a character and code
+is an integer giving the Unicode scalar value of the character."
+  (when (get nameset 'nxml-char-name-set-defined)
+    (error "Nameset `%s' already defined" nameset))
+  (let ((iter alist))
+    (while iter
+      (let* ((name-code (car iter))
+             (name (car name-code))
+             (code (cadr name-code)))
+        (puthash code
+                 (cons (cons nameset name)
+                       (gethash code nxml-char-name-table))
+                 nxml-char-name-table))
+      (setcdr (cdr (car iter)) nameset)
+      (setq iter (cdr iter))))
+  (setq nxml-char-name-alist
+        (nconc alist nxml-char-name-alist))
+  (put nameset 'nxml-char-name-set-defined t))
+
+(defun nxml-get-char-name (code)
+  (mapcar 'nxml-maybe-load-char-name-set nxml-autoload-char-name-set-list)
+  (let ((names (gethash code nxml-char-name-table))
+        name)
+    (while (and names (not name))
+      (if (nxml-char-name-set-enabled-p (caar names))
+          (setq name (cdar names))
+        (setq names (cdr names))))
+    name))
+
+(defvar nxml-named-char-history nil)
+
+(defun nxml-insert-named-char (arg)
+  "Insert a character using its name.
+The name is read from the minibuffer.
+Normally, inserts the character as a numeric character reference.
+With a prefix argument, inserts the character directly."
+  (interactive "*P")
+  (mapcar 'nxml-maybe-load-char-name-set nxml-autoload-char-name-set-list)
+  (let ((name
+         (let ((completion-ignore-case nxml-char-name-ignore-case))
+           (completing-read "Character name: "
+                            nxml-char-name-alist
+                            (lambda (member)
+                              (get (cddr member) 'nxml-char-name-set-enabled))
+                            t
+                            nil
+                            'nxml-named-char-history)))
+        (alist nxml-char-name-alist)
+        elt code)
+    (while (and alist (not code))
+      (setq elt (assoc name alist))
+      (if (get (cddr elt) 'nxml-char-name-set-enabled)
+          (setq code (cadr elt))
+        (setq alist (cdr (member elt alist)))))
+    (when code
+      (insert (if arg
+                  (or (decode-char 'ucs code)
+                      (error "Character %x is not supported by Emacs"
+                             code))
+                (format "&#x%X;" code))))))
+  
+(defun nxml-maybe-load-char-name-set (sym)
+  (when (and (get sym 'nxml-char-name-set-enabled)
+             (not (get sym 'nxml-char-name-set-defined))
+             (stringp (get sym 'nxml-char-name-set-file)))
+    (load (get sym 'nxml-char-name-set-file))))
+
+(defun nxml-toggle-char-ref-extra-display (arg)
+  "*Toggle the display of extra information for character references."
+  (interactive "P")
+  (let ((new (if (null arg)
+                 (not nxml-char-ref-extra-display)
+               (> (prefix-numeric-value arg) 0))))
+    (when (not (eq new nxml-char-ref-extra-display))
+      (setq nxml-char-ref-extra-display new)
+      (save-excursion
+        (save-restriction
+          (widen)
+          (if nxml-char-ref-extra-display
+              (nxml-with-unmodifying-text-property-changes
+                (nxml-clear-fontified (point-min) (point-max)))
+            (nxml-clear-char-ref-extra-display (point-min) (point-max))))))))
+
+(put 'nxml-char-ref 'evaporate t)
+
+(defun nxml-char-ref-display-extra (start end n)
+  (when nxml-char-ref-extra-display
+    (let ((name (nxml-get-char-name n))
+          (glyph-string (and nxml-char-ref-display-glyph-flag
+                             (nxml-glyph-display-string n 'nxml-glyph-face)))
+          ov)
+    (when (or name glyph-string)
+      (setq ov (make-overlay start end nil t))
+      (overlay-put ov 'category 'nxml-char-ref)
+      (when name
+        (overlay-put ov 'help-echo name))
+      (when glyph-string
+        (overlay-put ov
+                     'after-string
+                     (propertize glyph-string 'face 'nxml-glyph-face)))))))
+
+(defun nxml-clear-char-ref-extra-display (start end)
+  (let ((ov (overlays-in start end)))
+    (while ov
+      (when (eq (overlay-get (car ov) 'category) 'nxml-char-ref)
+        (delete-overlay (car ov)))
+      (setq ov (cdr ov)))))
+
+;;; Versioning
+
+(defun nxml-version ()
+  "Show the version of nXML mode that is being used."
+  (interactive)
+  (if nxml-version
+      (message "nXML mode version %s" nxml-version)
+    (message "nXML mode version unknown")))
+
+
+(defun nxml-start-delimiter-length (type)
+  (or (get type 'nxml-start-delimiter-length)
+      0))
+                        
+(put 'cdata-section 'nxml-start-delimiter-length 9)
+(put 'comment 'nxml-start-delimiter-length 4)
+(put 'processing-instruction 'nxml-start-delimiter-length 2)
+(put 'start-tag 'nxml-start-delimiter-length 1)
+(put 'empty-element 'nxml-start-delimiter-length 1)
+(put 'partial-empty-element 'nxml-start-delimiter-length 1)
+(put 'entity-ref 'nxml-start-delimiter-length 1)
+(put 'char-ref 'nxml-start-delimiter-length 2)
+
+(defun nxml-end-delimiter-length (type)
+  (or (get type 'nxml-end-delimiter-length)
+      0))
+                        
+(put 'cdata-section 'nxml-end-delimiter-length 3)
+(put 'comment 'nxml-end-delimiter-length 3)
+(put 'processing-instruction 'nxml-end-delimiter-length 2)
+(put 'start-tag 'nxml-end-delimiter-length 1)
+(put 'empty-element 'nxml-end-delimiter-length 2)
+(put 'partial-empty-element 'nxml-end-delimiter-length 1)
+(put 'entity-ref 'nxml-end-delimiter-length 1)
+(put 'char-ref 'nxml-end-delimiter-length 1)
+
+(defun nxml-token-type-friendly-name (type)
+  (or (get type 'nxml-friendly-name)
+      (symbol-name type)))
+
+(put 'cdata-section 'nxml-friendly-name "CDATA section")
+(put 'processing-instruction 'nxml-friendly-name "processing instruction")
+(put 'entity-ref 'nxml-friendly-name "entity reference")
+(put 'char-ref 'nxml-friendly-name "character reference")
+
+(provide 'nxml-mode)
+
+;;; nxml-mode.el ends here
diff --git a/lisp/nxml/nxml-ns.el b/lisp/nxml/nxml-ns.el
new file mode 100644
index 00000000000..6306d93713a
--- /dev/null
+++ b/lisp/nxml/nxml-ns.el
@@ -0,0 +1,148 @@
+;;; nxml-ns.el --- XML namespace processing
+
+;; Copyright (C) 2003 Free Software Foundation, Inc.
+
+;; Author: James Clark
+;; Keywords: XML
+
+;; This program is free software; you can redistribute it and/or
+;; modify it under the terms of the GNU General Public License as
+;; published by the Free Software Foundation; either version 2 of
+;; the License, or (at your option) any later version.
+
+;; This program is distributed in the hope that it will be
+;; useful, but WITHOUT ANY WARRANTY; without even the implied
+;; warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+;; PURPOSE.  See the GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public
+;; License along with this program; if not, write to the Free
+;; Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+;; MA 02111-1307 USA
+
+;;; Commentary:
+
+;; This file uses a prefix of `nxml-ns'.
+
+;;; Code:
+
+(require 'nxml-util)
+
+(defvar nxml-ns-state nil
+  "Contains the state of namespace processing.  The state
+is never modified destructively and so can be saved and restored
+without copying.
+
+The value is a stack represented by a list. The list has length N + 1
+where N is the number of open elements.  Each member of the list
+represents the bindings in effect for a particular element.  Each
+member is itself a list whose car is the default namespace
+\(a symbol or nil) and whose cdr is an alist of (PREFIX . NS) pairs
+where PREFIX is a string (never nil) and NS is the namespace URI
+symbol.")
+
+(defconst nxml-ns-initial-state
+  (list (list nil (cons "xml" nxml-xml-namespace-uri)))
+  "A list to be used as the initial value of nxml-ns-state.  This
+represents the state with no open elements and with the default
+namespace bindings (no default namespace and only the xml prefix bound).")
+
+(defsubst nxml-ns-state () nxml-ns-state)
+
+(defsubst nxml-ns-set-state (state)
+  (setq nxml-ns-state state))
+
+(defsubst nxml-ns-state-equal (state)
+  (equal nxml-ns-state state))
+
+(defmacro nxml-ns-save (&rest body)
+  `(let ((nxml-ns-state nxml-ns-initial-state))
+     ,@body))
+
+(put 'nxml-ns-save 'lisp-indent-function 0)
+(def-edebug-spec nxml-ns-save t)
+
+(defun nxml-ns-init ()
+  (setq nxml-ns-state nxml-ns-initial-state))
+
+(defun nxml-ns-push-state ()
+  "Change the state by starting a new element. Namespace declarations
+are inherited from the parent state."
+  (setq nxml-ns-state (cons (car nxml-ns-state) nxml-ns-state)))
+
+(defun nxml-ns-pop-state ()
+  "Change the state by ending an element.  The behaviour is undefined
+if there is no open element."
+  (setq nxml-ns-state (cdr nxml-ns-state)))
+
+(defun nxml-ns-get-prefix (prefix)
+  "Return the symbol for namespace bound to PREFIX, or nil if PREFIX
+is unbound. PREFIX is a string, never nil."
+  (let ((binding (assoc prefix (cdar nxml-ns-state))))
+    (and binding (cdr binding))))
+
+(defun nxml-ns-set-prefix (prefix ns)
+  "Change the binding of PREFIX. PREFIX is a string (never nil).  NS
+is a symbol (never nil). The change will be in effect until the end of
+the current element."
+  (setq nxml-ns-state
+        (let ((bindings (car nxml-ns-state)))
+          (cons (cons (car bindings)
+                      (cons (cons prefix ns) (cdr bindings)))
+                (cdr nxml-ns-state)))))
+
+(defun nxml-ns-get-default ()
+  "Return the current default namespace as a symbol, or nil
+if there is no default namespace."
+  (caar nxml-ns-state))
+
+(defun nxml-ns-set-default (ns)
+  "Changes the current default namespace.  The change
+will be in effect until the end of the current element.
+NS is a symbol or nil."
+  (setq nxml-ns-state
+        (cons (cons ns (cdar nxml-ns-state))
+              (cdr nxml-ns-state))))
+
+(defun nxml-ns-get-context ()
+  (car nxml-ns-state))
+
+(defun nxml-ns-prefixes-for (ns &optional attributep)
+  (let ((current (car nxml-ns-state))
+        prefixes)
+    (when (if attributep
+              (not ns)
+            (eq (car current) ns))
+      (setq prefixes '(nil)))
+    (setq current (cdr current))
+    (while (let ((binding (rassq ns current)))
+             (when binding
+               (when (eq (nxml-ns-get-prefix (car binding)) ns)
+                 (add-to-list 'prefixes
+                              (car binding)))
+               (setq current
+                     (cdr (member binding current))))))
+    prefixes))
+
+(defun nxml-ns-prefix-for (ns)
+  (car (rassq ns (cdar nxml-ns-state))))
+
+(defun nxml-ns-changed-prefixes ()
+  (let ((old (cadr nxml-ns-state))
+        (new (car nxml-ns-state))
+        changed)
+    (if (eq old new)
+        nil
+      (unless (eq (car new) (car old))
+        (setq changed '(nil)))
+      (setq new (cdr new))
+      (setq old (cdr old))
+      (while (not (eq new old))
+        (setq changed
+              (cons (caar new) changed))
+        (setq new (cdr new))))
+    changed))
+    
+(provide 'nxml-ns)
+
+;;; nxml-ns.el ends here
diff --git a/lisp/nxml/nxml-outln.el b/lisp/nxml/nxml-outln.el
new file mode 100644
index 00000000000..5bc39c86e83
--- /dev/null
+++ b/lisp/nxml/nxml-outln.el
@@ -0,0 +1,1040 @@
+;;; nxml-outln.el --- outline support for nXML mode
+
+;; Copyright (C) 2004 Free Software Foundation, Inc.
+
+;; Author: James Clark
+;; Keywords: XML
+
+;; This program is free software; you can redistribute it and/or
+;; modify it under the terms of the GNU General Public License as
+;; published by the Free Software Foundation; either version 2 of
+;; the License, or (at your option) any later version.
+
+;; This program is distributed in the hope that it will be
+;; useful, but WITHOUT ANY WARRANTY; without even the implied
+;; warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+;; PURPOSE.  See the GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public
+;; License along with this program; if not, write to the Free
+;; Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+;; MA 02111-1307 USA
+
+;;; Commentary:
+
+;; A section can be in one of three states
+;; 1. display normally; this displays each child section
+;; according to its state; anything not part of child sections is also
+;; displayed normally
+;; 2. display just the title specially; child sections are not displayed
+;; regardless of their state; anything not part of child sections is
+;; not displayed
+;; 3. display the title specially and display child sections
+;; according to their state; anything not part of the child section is
+;; not displayed
+;; The state of a section is determined by the value of the
+;; nxml-outline-state text property of the < character that starts
+;; the section.
+;; For state 1 the value is nil or absent.
+;; For state 2 it is the symbol hide-children.
+;; For state 3 it is t.
+;; The special display is achieved by using overlays.  The overlays
+;; are computed from the nxml-outline-state property by
+;; `nxml-refresh-outline'. There overlays all have a category property
+;; with an nxml-outline-display property with value t.
+;;
+;; For a section to be recognized as such, the following conditions must
+;; be satisfied:
+;; - its start-tag must occur at the start of a line (possibly indented)
+;; - its local name must match `nxml-section-element-name-regexp'
+;; - it must have a heading element; a heading element is an
+;; element whose name matches `nxml-heading-element-name-regexp',
+;; and that occurs as, or as a descendant of, the first child element
+;; of the section
+;;
+;; XXX What happens if an nxml-outline-state property is attached to a
+;; character that doesn't start a section element?
+;;
+;; An outlined section (an section with a non-nil nxml-outline-state
+;; property) can be displayed in either single-line or multi-line
+;; form.  Single-line form is used when the outline state is hide-children
+;; or there are no child sections; multi-line form is used otherwise.
+;; There are two flavors of single-line form: with children and without.
+;; The with-childen flavor is used when there are child sections.
+;; Single line with children looks like
+;;    <+section>A section title...</>
+;; Single line without children looks like
+;;    <-section>A section title...</>
+;; Multi line looks likes
+;;    <-section>A section title...
+;;    [child sections displayed here]
+;;    </-section>
+;; The indent of an outlined section is computed relative to the
+;; outermost containing outlined element.  The indent of the
+;; outermost containing element comes from the non-outlined
+;; indent of the section start-tag.
+
+;;; Code:
+
+(require 'xmltok)
+(require 'nxml-util)
+(require 'nxml-rap)
+
+(defcustom nxml-section-element-name-regexp
+  "article\\|\\(sub\\)*section\\|chapter\\|div\\|appendix\\|part\\|preface\\|reference\\|simplesect\\|bibliography\\|bibliodiv\\|glossary\\|glossdiv"
+  "*Regular expression matching the name of elements used as sections.
+An XML element is treated as a section if:
+
+- its local name (that is, the name without the prefix) matches
+this regexp;
+
+- either its first child element or a descendant of that first child
+element has a local name matching the variable
+`nxml-heading-element-name-regexp'; and
+
+- its start-tag occurs at the beginning of a line (possibly indented)."
+  :group 'nxml
+  :type 'regexp)
+
+(defcustom nxml-heading-element-name-regexp "title\\|head"
+  "*Regular expression matching the name of elements used as headings.
+An XML element is only recognized as a heading if it occurs as or
+within the first child of an element that is recognized as a section.
+See the variable `nxml-section-element-name-regexp' for more details."
+  :group 'nxml
+  :type 'regexp)
+
+(defcustom nxml-outline-child-indent 2
+  "*Indentation in an outline for child element relative to parent element."
+  :group 'nxml
+  :type 'integer)
+
+(defface nxml-heading-face
+  '((t (:weight bold)))
+  "Face used for the contents of abbreviated heading elements."
+  :group 'nxml-highlighting-faces)
+
+(defface nxml-outline-indicator-face
+  '((t (:inherit default)))
+  "Face used for `+' or `-' before element names in outlines."
+  :group 'nxml-highlighting-faces)
+
+(defface nxml-outline-active-indicator-face
+  '((t (:box t :inherit nxml-outline-indicator-face)))
+  "Face used for clickable `+' or `-' before element names in outlines."
+  :group 'nxml-highlighting-faces)
+
+(defface nxml-outline-ellipsis-face
+  '((t (:bold t :inherit default)))
+  "Face used for `...' in outlines."
+  :group 'nxml-highlighting-faces)
+
+(defvar nxml-heading-scan-distance 1000
+  "Maximum distance from section to scan for heading.")
+
+(defvar nxml-outline-prefix-map
+  (let ((map (make-sparse-keymap)))
+    (define-key map "\C-a" 'nxml-show-all)
+    (define-key map "\C-t" 'nxml-hide-all-text-content)
+    (define-key map "\C-r" 'nxml-refresh-outline)
+    (define-key map "\C-c" 'nxml-hide-direct-text-content)
+    (define-key map "\C-e" 'nxml-show-direct-text-content)
+    (define-key map "\C-d" 'nxml-hide-subheadings)
+    (define-key map "\C-s" 'nxml-show)
+    (define-key map "\C-k" 'nxml-show-subheadings)
+    (define-key map "\C-l" 'nxml-hide-text-content)
+    (define-key map "\C-i" 'nxml-show-direct-subheadings)
+    (define-key map "\C-o" 'nxml-hide-other)
+    map))
+
+;;; Commands for changing visibility
+
+(defun nxml-show-all ()
+  "Show all elements in the buffer normally."
+  (interactive)
+  (nxml-with-unmodifying-text-property-changes
+    (remove-text-properties (point-min)
+                            (point-max)
+                            '(nxml-outline-state nil)))
+  (nxml-outline-set-overlay nil (point-min) (point-max)))
+
+(defun nxml-hide-all-text-content ()
+  "Hide all text content in the buffer.
+Anything that is in a section but is not a heading will be hidden.
+The visibility of headings at any level will not be changed. See the
+variable `nxml-section-element-name-regexp' for more details on how to
+customize which elements are recognized as sections and headings."
+  (interactive)
+  (nxml-transform-buffer-outline '((nil . t))))
+
+(defun nxml-show-direct-text-content ()
+  "Show the text content that is directly part of the section containing point.
+Each subsection will be shown according to its individual state, which
+will not be changed. The section containing point is the innermost
+section that contains the character following point. See the variable
+`nxml-section-element-name-regexp' for more details on how to
+customize which elements are recognized as sections and headings."
+  (interactive)
+  (nxml-outline-pre-adjust-point)
+  (nxml-set-outline-state (nxml-section-start-position) nil)
+  (nxml-refresh-outline)
+  (nxml-outline-adjust-point))
+
+(defun nxml-show-direct-subheadings ()
+  "Show the immediate subheadings of the section containing point.
+The section containing point is the innermost section that contains
+the character following point. See the variable
+`nxml-section-element-name-regexp' for more details on how to
+customize which elements are recognized as sections and headings."
+  (interactive)
+  (let ((pos (nxml-section-start-position)))
+    (when (eq (nxml-get-outline-state pos) 'hide-children)
+      (nxml-set-outline-state pos t)))
+  (nxml-refresh-outline)
+  (nxml-outline-adjust-point))
+
+(defun nxml-hide-direct-text-content ()
+  "Hide the text content that is directly part of the section containing point.
+The heading of the section will remain visible.  The state of
+subsections will not be changed.  The section containing point is the
+innermost section that contains the character following point. See the
+variable `nxml-section-element-name-regexp' for more details on how to
+customize which elements are recognized as sections and headings."
+  (interactive)
+  (let ((pos (nxml-section-start-position)))
+    (when (null (nxml-get-outline-state pos))
+      (nxml-set-outline-state pos t)))
+  (nxml-refresh-outline)
+  (nxml-outline-adjust-point))
+
+(defun nxml-hide-subheadings ()
+  "Hide the subheadings that are part of the section containing point.
+The text content will also be hidden, leaving only the heading of the
+section itself visible.  The state of the subsections will also be
+changed to hide their headings, so that \\[nxml-show-direct-text-content]
+would show only the heading of the subsections. The section containing
+point is the innermost section that contains the character following
+point.  See the variable `nxml-section-element-name-regexp' for more
+details on how to customize which elements are recognized as sections
+and headings."
+  (interactive)
+  (nxml-transform-subtree-outline '((nil . hide-children)
+                                    (t . hide-children))))
+
+(defun nxml-show ()
+  "Show the section containing point normally, without hiding anything.
+This includes everything in the section at any level.  The section
+containing point is the innermost section that contains the character
+following point.  See the variable `nxml-section-element-name-regexp'
+for more details on how to customize which elements are recognized as
+sections and headings."
+  (interactive)
+  (nxml-transform-subtree-outline '((hide-children . nil)
+                                    (t . nil))))
+
+(defun nxml-hide-text-content ()
+  "Hide text content at all levels in the section containing point.
+The section containing point is the innermost section that contains
+the character following point. See the variable
+`nxml-section-element-name-regexp' for more details on how to
+customize which elements are recognized as sections and headings."
+  (interactive)
+  (nxml-transform-subtree-outline '((nil . t))))
+
+(defun nxml-show-subheadings ()
+  "Show the subheadings at all levels of the section containing point.
+The visibility of the text content at all levels in the section is not
+changed.  The section containing point is the innermost section that
+contains the character following point. See the variable
+`nxml-section-element-name-regexp' for more details on how to
+customize which elements are recognized as sections and headings."
+  (interactive)
+  (nxml-transform-subtree-outline '((hide-children . t))))
+
+(defun nxml-hide-other ()
+  "Hide text content other than that directly in the section containing point.
+Hide headings other than those of ancestors of that section and their
+immediate subheadings.  The section containing point is the innermost
+section that contains the character following point. See the variable
+`nxml-section-element-name-regexp' for more details on how to
+customize which elements are recognized as sections and headings."
+  (interactive)
+  (let ((nxml-outline-state-transform-exceptions nil))
+    (save-excursion
+      (while (and (condition-case err
+                      (nxml-back-to-section-start)
+                    (nxml-outline-error (nxml-report-outline-error
+                                         "Couldn't find containing section: %s"
+                                         err)))
+                  (progn
+                    (when (and nxml-outline-state-transform-exceptions
+                               (null (nxml-get-outline-state (point))))
+                      (nxml-set-outline-state (point) t))
+                    (setq nxml-outline-state-transform-exceptions
+                          (cons (point)
+                                nxml-outline-state-transform-exceptions))
+                    (< nxml-prolog-end (point))))
+        (goto-char (1- (point)))))
+    (nxml-transform-buffer-outline '((nil . hide-children)
+                                     (t . hide-children)))))
+
+;; These variables are dynamically bound.  They are use to pass information to
+;; nxml-section-tag-transform-outline-state.
+
+(defvar nxml-outline-state-transform-exceptions nil)
+(defvar nxml-target-section-pos nil)
+(defvar nxml-depth-in-target-section nil)
+(defvar nxml-outline-state-transform-alist nil)
+
+(defun nxml-transform-buffer-outline (alist)
+  (let ((nxml-target-section-pos nil)
+        (nxml-depth-in-target-section 0)
+        (nxml-outline-state-transform-alist alist)
+        (nxml-outline-display-section-tag-function
+         'nxml-section-tag-transform-outline-state))
+    (nxml-refresh-outline))
+  (nxml-outline-adjust-point))
+
+(defun nxml-transform-subtree-outline (alist)
+  (let ((nxml-target-section-pos (nxml-section-start-position))
+        (nxml-depth-in-target-section nil)
+        (nxml-outline-state-transform-alist alist)
+        (nxml-outline-display-section-tag-function
+         'nxml-section-tag-transform-outline-state))
+    (nxml-refresh-outline))
+  (nxml-outline-adjust-point))
+
+(defun nxml-outline-pre-adjust-point ()
+  (cond ((and (< (point-min) (point))
+              (get-char-property (1- (point)) 'invisible)
+              (not (get-char-property (point) 'invisible))
+              (let ((str (or (get-char-property (point) 'before-string)
+                             (get-char-property (point) 'display))))
+                (and (stringp str)
+                     (>= (length str) 3)
+                     (string= (substring str 0 3) "..."))))
+         ;; The ellipsis is a display property on a visible character
+         ;; following an invisible region. The position of the event
+         ;; will be the position before that character. We want to
+         ;; move point to the other side of the invisible region, i.e.
+         ;; following the last visible character before that invisible
+         ;; region.
+         (goto-char (previous-single-char-property-change (1- (point))
+                                                          'invisible)))
+        ((and (< (point) (point-max))
+              (get-char-property (point) 'display)
+              (get-char-property (1+ (point)) 'invisible))
+         (goto-char (next-single-char-property-change (1+ (point))
+                                                      'invisible)))
+        ((and (< (point) (point-max))
+              (get-char-property (point) 'invisible))
+         (goto-char (next-single-char-property-change (point)
+                                                      'invisible)))))
+
+(defun nxml-outline-adjust-point ()
+  "Adjust point after showing or hiding elements."
+  (when (and (get-char-property (point) 'invisible)
+             (< (point-min) (point))
+             (get-char-property (1- (point)) 'invisible))
+    (goto-char (previous-single-char-property-change (point)
+                                                     'invisible
+                                                     nil
+                                                     nxml-prolog-end))))
+
+(defun nxml-transform-outline-state (section-start-pos)
+  (let* ((old-state
+          (nxml-get-outline-state section-start-pos))
+         (change (assq old-state
+                       nxml-outline-state-transform-alist)))
+    (when change
+      (nxml-set-outline-state section-start-pos
+                              (cdr change)))))
+  
+(defun nxml-section-tag-transform-outline-state (startp
+                                                 section-start-pos
+                                                 &optional
+                                                 heading-start-pos)
+  (if (not startp)
+      (setq nxml-depth-in-target-section
+            (and nxml-depth-in-target-section
+                 (> nxml-depth-in-target-section 0)
+                 (1- nxml-depth-in-target-section)))
+    (cond (nxml-depth-in-target-section
+           (setq nxml-depth-in-target-section
+                 (1+ nxml-depth-in-target-section)))
+          ((= section-start-pos nxml-target-section-pos)
+           (setq nxml-depth-in-target-section 0)))
+    (when (and nxml-depth-in-target-section
+               (not (member section-start-pos
+                            nxml-outline-state-transform-exceptions)))
+      (nxml-transform-outline-state section-start-pos))))
+
+(defun nxml-get-outline-state (pos)
+  (get-text-property pos 'nxml-outline-state))
+
+(defun nxml-set-outline-state (pos state)
+  (nxml-with-unmodifying-text-property-changes
+    (if state
+        (put-text-property pos (1+ pos) 'nxml-outline-state state)
+      (remove-text-properties pos (1+ pos) '(nxml-outline-state nil)))))
+
+;;; Mouse interface
+
+(defun nxml-mouse-show-direct-text-content (event)
+  "Do the same as \\[nxml-show-direct-text-content] from a mouse click."
+  (interactive "e")
+  (and (nxml-mouse-set-point event)
+       (nxml-show-direct-text-content)))
+
+(defun nxml-mouse-hide-direct-text-content (event)
+  "Do the same as \\[nxml-hide-direct-text-content] from a mouse click."
+  (interactive "e")
+  (and (nxml-mouse-set-point event)
+       (nxml-hide-direct-text-content)))
+
+(defun nxml-mouse-hide-subheadings (event)
+  "Do the same as \\[nxml-hide-subheadings] from a mouse click."
+  (interactive "e")
+  (and (nxml-mouse-set-point event)
+       (nxml-hide-subheadings)))
+
+(defun nxml-mouse-show-direct-subheadings (event)
+  "Do the same as \\[nxml-show-direct-subheadings] from a mouse click."
+  (interactive "e")
+  (and (nxml-mouse-set-point event)
+       (nxml-show-direct-subheadings)))
+
+(defun nxml-mouse-set-point (event)
+  (mouse-set-point event)
+  (and nxml-prolog-end t))
+
+;; Display
+
+(defun nxml-refresh-outline () 
+  "Refresh the outline to correspond to the current XML element structure."
+  (interactive)
+  (save-excursion
+    (goto-char (point-min))
+    (kill-local-variable 'line-move-ignore-invisible)
+    (make-local-variable 'line-move-ignore-invisible)
+    (condition-case err
+        (nxml-outline-display-rest nil nil nil)
+      (nxml-outline-error
+       (nxml-report-outline-error "Cannot display outline: %s" err)))))
+
+(defvar nxml-outline-display-section-tag-function nil)
+
+(defun nxml-outline-display-rest (outline-state start-tag-indent tag-qnames)
+  "Display up to and including the end of the current element.
+OUTLINE-STATE can be nil, t, hide-children.  START-TAG-INDENT is the
+indent of the start-tag of the current element, or nil if no
+containing element has a non-nil OUTLINE-STATE.  TAG-QNAMES is a list
+of the qnames of the open elements.  Point is after the title content.
+Leave point after the closing end-tag Return t if we had a
+non-transparent child section."
+  (let ((last-pos (point))
+        (transparent-depth 0)
+        ;; don't want ellipsis before root element
+        (had-children (not tag-qnames)))
+    (while
+        (cond ((not (nxml-section-tag-forward))
+               (if (null tag-qnames)
+                   nil
+                 (nxml-outline-error "missing end-tag %s"
+                                     (car tag-qnames))))
+              ;; section end-tag
+              ((nxml-token-end-tag-p)
+               (when nxml-outline-display-section-tag-function
+                 (funcall nxml-outline-display-section-tag-function
+                          nil
+                          xmltok-start))
+               (let ((qname (xmltok-end-tag-qname)))
+                 (unless tag-qnames
+                   (nxml-outline-error "extra end-tag %s" qname))
+                 (unless (string= (car tag-qnames) qname)
+                   (nxml-outline-error "mismatched end-tag; expected %s, got %s"
+                                       (car tag-qnames)
+                                       qname)))
+               (cond ((> transparent-depth 0)
+                      (setq transparent-depth (1- transparent-depth))
+                      (setq tag-qnames (cdr tag-qnames))
+                      t)
+                     ((not outline-state)
+                      (nxml-outline-set-overlay nil last-pos (point))
+                      nil)
+                     ((or (not had-children)
+                          (eq outline-state 'hide-children))
+                      (nxml-outline-display-single-line-end-tag last-pos)
+                      nil)
+                     (t
+                      (nxml-outline-display-multi-line-end-tag last-pos
+                                                               start-tag-indent)
+                      nil)))
+              ;; section start-tag
+              (t
+               (let* ((qname (xmltok-start-tag-qname))
+                      (section-start-pos xmltok-start)
+                      (heading-start-pos
+                       (and (or nxml-outline-display-section-tag-function
+                                (not (eq outline-state 'had-children))
+                                (not had-children))
+                            (nxml-token-starts-line-p)
+                            (nxml-heading-start-position))))
+                 (when nxml-outline-display-section-tag-function
+                   (funcall nxml-outline-display-section-tag-function
+                            t
+                            section-start-pos
+                            heading-start-pos))
+                 (setq tag-qnames (cons qname tag-qnames))
+                 (if (or (not heading-start-pos)
+                         (and (eq outline-state 'hide-children)
+                              (setq had-children t)))
+                     (setq transparent-depth (1+ transparent-depth))
+                   (nxml-display-section last-pos
+                                         section-start-pos
+                                         heading-start-pos
+                                         start-tag-indent
+                                         outline-state
+                                         had-children
+                                         tag-qnames)
+                   (setq had-children t)
+                   (setq tag-qnames (cdr tag-qnames))
+                   (setq last-pos (point))))
+               t)))
+    had-children))
+
+(defconst nxml-highlighted-less-than
+  (propertize "<" 'face 'nxml-tag-delimiter-face))
+
+(defconst nxml-highlighted-greater-than
+  (propertize ">" 'face 'nxml-tag-delimiter-face))
+
+(defconst nxml-highlighted-colon
+  (propertize ":" 'face 'nxml-element-colon-face))
+
+(defconst nxml-highlighted-slash
+  (propertize "/" 'face 'nxml-tag-slash-face))
+
+(defconst nxml-highlighted-ellipsis
+  (propertize "..." 'face 'nxml-outline-ellipsis-face))
+
+(defconst nxml-highlighted-empty-end-tag
+  (concat nxml-highlighted-ellipsis
+          nxml-highlighted-less-than
+          nxml-highlighted-slash
+          nxml-highlighted-greater-than))
+
+(defconst nxml-highlighted-inactive-minus
+  (propertize "-" 'face 'nxml-outline-indicator-face))
+
+(defconst nxml-highlighted-active-minus
+  (propertize "-" 'face 'nxml-outline-active-indicator-face))
+
+(defconst nxml-highlighted-active-plus
+  (propertize "+" 'face 'nxml-outline-active-indicator-face))
+
+(defun nxml-display-section (last-pos
+                             section-start-pos
+                             heading-start-pos
+                             parent-indent
+                             parent-outline-state
+                             had-children
+                             tag-qnames)
+  (let* ((section-start-pos-bol
+          (save-excursion
+            (goto-char section-start-pos)
+            (skip-chars-backward " \t")
+            (point)))
+         (outline-state (nxml-get-outline-state section-start-pos))
+         (newline-before-section-start-category
+          (cond ((and (not had-children) parent-outline-state)
+                 'nxml-outline-display-ellipsis)
+                 (outline-state 'nxml-outline-display-show)
+                 (t nil))))
+    (nxml-outline-set-overlay (and parent-outline-state
+                                   'nxml-outline-display-hide)
+                              last-pos
+                              (1- section-start-pos-bol)
+                              nil
+                              t)
+    (if outline-state
+      (let* ((indent (if parent-indent
+                         (+ parent-indent nxml-outline-child-indent)
+                       (save-excursion
+                         (goto-char section-start-pos)
+                         (current-column))))
+             start-tag-overlay)
+        (nxml-outline-set-overlay newline-before-section-start-category
+                                  (1- section-start-pos-bol)
+                                  section-start-pos-bol
+                                  t)
+        (nxml-outline-set-overlay 'nxml-outline-display-hide
+                                  section-start-pos-bol
+                                  section-start-pos)
+        (setq start-tag-overlay
+            (nxml-outline-set-overlay 'nxml-outline-display-show
+                                      section-start-pos
+                                      (1+ section-start-pos)
+                                      t))
+        ;; line motion commands don't work right if start-tag-overlay
+        ;; covers multiple lines
+        (nxml-outline-set-overlay 'nxml-outline-display-hide
+                                  (1+ section-start-pos)
+                                  heading-start-pos)
+        (goto-char heading-start-pos)
+        (nxml-end-of-heading)
+        (nxml-outline-set-overlay 'nxml-outline-display-heading
+                                  heading-start-pos
+                                  (point))
+        (let* ((had-children
+                (nxml-outline-display-rest outline-state
+                                           indent
+                                           tag-qnames)))
+          (overlay-put start-tag-overlay
+                       'display
+                       (concat
+                        ;; indent
+                        (make-string indent ?\ )
+                        ;; <
+                        nxml-highlighted-less-than
+                        ;; + or - indicator
+                        (cond ((not had-children)
+                               nxml-highlighted-inactive-minus)
+                              ((eq outline-state 'hide-children)
+                               (overlay-put start-tag-overlay
+                                            'category
+                                            'nxml-outline-display-hiding-tag)
+                               nxml-highlighted-active-plus)
+                              (t
+                               (overlay-put start-tag-overlay
+                                            'category
+                                            'nxml-outline-display-showing-tag)
+                               nxml-highlighted-active-minus))
+                        ;; qname
+                        (nxml-highlighted-qname (car tag-qnames))
+                        ;; >
+                        nxml-highlighted-greater-than))))
+      ;; outline-state nil
+      (goto-char heading-start-pos)
+      (nxml-end-of-heading)
+      (nxml-outline-set-overlay newline-before-section-start-category
+                                (1- section-start-pos-bol)
+                                (point)
+                                t)
+      (nxml-outline-display-rest outline-state
+                                 (and parent-indent
+                                      (+ parent-indent
+                                         nxml-outline-child-indent))
+                                 tag-qnames))))
+
+(defun nxml-highlighted-qname (qname)
+  (let ((colon (string-match ":" qname)))
+    (if colon
+        (concat (propertize (substring qname 0 colon)
+                            'face
+                            'nxml-element-prefix-face)
+                nxml-highlighted-colon
+                (propertize (substring qname (1+ colon))
+                            'face
+                            'nxml-element-local-name-face))
+      (propertize qname
+                  'face
+                  'nxml-element-local-name-face))))
+
+(defun nxml-outline-display-single-line-end-tag (last-pos)
+  (nxml-outline-set-overlay 'nxml-outline-display-hide
+                            last-pos
+                            xmltok-start
+                            nil
+                            t)
+  (overlay-put (nxml-outline-set-overlay 'nxml-outline-display-show
+                                         xmltok-start
+                                         (point)
+                                         t)
+               'display
+               nxml-highlighted-empty-end-tag))
+    
+(defun nxml-outline-display-multi-line-end-tag (last-pos start-tag-indent)
+  (let ((indentp (save-excursion
+                   (goto-char last-pos)
+                   (skip-chars-forward " \t")
+                   (and (eq (char-after) ?\n)
+                        (progn
+                          (goto-char (1+ (point)))
+                          (nxml-outline-set-overlay nil last-pos (point))
+                          (setq last-pos (point))
+                          (goto-char xmltok-start)
+                          (beginning-of-line)
+                          t))))
+        end-tag-overlay)
+    (nxml-outline-set-overlay 'nxml-outline-display-hide
+                              last-pos
+                              xmltok-start
+                              nil
+                              t)
+    (setq end-tag-overlay
+          (nxml-outline-set-overlay 'nxml-outline-display-showing-tag
+                                    xmltok-start
+                                    (point)
+                                    t))
+    (overlay-put end-tag-overlay
+                 'display
+                 (concat (if indentp
+                             (make-string start-tag-indent ?\ )
+                           "")
+                         nxml-highlighted-less-than
+                         nxml-highlighted-slash
+                         nxml-highlighted-active-minus
+                         (nxml-highlighted-qname (xmltok-end-tag-qname))
+                         nxml-highlighted-greater-than))))
+
+(defvar nxml-outline-show-map
+  (let ((map (make-sparse-keymap)))
+    (define-key map "\C-m" 'nxml-show-direct-text-content)
+    (define-key map [mouse-2] 'nxml-mouse-show-direct-text-content)
+    map))
+
+(defvar nxml-outline-show-help "mouse-2: show")
+
+(put 'nxml-outline-display-show 'nxml-outline-display t)
+(put 'nxml-outline-display-show 'evaporate t)
+(put 'nxml-outline-display-show 'keymap nxml-outline-show-map)
+(put 'nxml-outline-display-show 'help-echo nxml-outline-show-help)
+
+(put 'nxml-outline-display-hide 'nxml-outline-display t)
+(put 'nxml-outline-display-hide 'evaporate t)
+(put 'nxml-outline-display-hide 'invisible t)
+(put 'nxml-outline-display-hide 'keymap nxml-outline-show-map)
+(put 'nxml-outline-display-hide 'help-echo nxml-outline-show-help)
+
+(put 'nxml-outline-display-ellipsis 'nxml-outline-display t)
+(put 'nxml-outline-display-ellipsis 'evaporate t)
+(put 'nxml-outline-display-ellipsis 'keymap nxml-outline-show-map)
+(put 'nxml-outline-display-ellipsis 'help-echo nxml-outline-show-help)
+(put 'nxml-outline-display-ellipsis 'before-string nxml-highlighted-ellipsis)
+
+(put 'nxml-outline-display-heading 'keymap nxml-outline-show-map)
+(put 'nxml-outline-display-heading 'help-echo nxml-outline-show-help)
+(put 'nxml-outline-display-heading 'nxml-outline-display t)
+(put 'nxml-outline-display-heading 'evaporate t)
+(put 'nxml-outline-display-heading 'face 'nxml-heading-face)
+
+(defvar nxml-outline-hiding-tag-map
+  (let ((map (make-sparse-keymap)))
+    (define-key map [mouse-1] 'nxml-mouse-show-direct-subheadings)
+    (define-key map [mouse-2] 'nxml-mouse-show-direct-text-content)
+    (define-key map "\C-m" 'nxml-show-direct-text-content)
+    map))
+
+(defvar nxml-outline-hiding-tag-help
+  "mouse-1: show subheadings, mouse-2: show text content")
+
+(put 'nxml-outline-display-hiding-tag 'nxml-outline-display t)
+(put 'nxml-outline-display-hiding-tag 'evaporate t)
+(put 'nxml-outline-display-hiding-tag 'keymap nxml-outline-hiding-tag-map)
+(put 'nxml-outline-display-hiding-tag 'help-echo nxml-outline-hiding-tag-help)
+
+(defvar nxml-outline-showing-tag-map
+  (let ((map (make-sparse-keymap)))
+    (define-key map [mouse-1] 'nxml-mouse-hide-subheadings)
+    (define-key map [mouse-2] 'nxml-mouse-show-direct-text-content)
+    (define-key map "\C-m" 'nxml-show-direct-text-content)
+    map))
+
+(defvar nxml-outline-showing-tag-help
+  "mouse-1: hide subheadings, mouse-2: show text content")
+
+(put 'nxml-outline-display-showing-tag 'nxml-outline-display t)
+(put 'nxml-outline-display-showing-tag 'evaporate t)
+(put 'nxml-outline-display-showing-tag 'keymap nxml-outline-showing-tag-map)
+(put 'nxml-outline-display-showing-tag
+     'help-echo
+     nxml-outline-showing-tag-help)
+
+(defun nxml-outline-set-overlay (category
+                                 start
+                                 end
+                                 &optional
+                                 front-advance
+                                 rear-advance)
+  "Replace any nxml-outline-display overlays between START and END.
+Overlays are removed if they overlay the region between START and END,
+and have a non-nil nxml-outline-display property (typically via their
+category). If CATEGORY is non-nil, they will be replaced with a new overlay
+with that category from START to END. If CATEGORY is nil, no new
+overlay will be created."
+  (when (< start end)
+    (let ((overlays (overlays-in start end))
+          overlay)
+      (while overlays
+        (setq overlay (car overlays))
+        (setq overlays (cdr overlays))
+        (when (overlay-get overlay 'nxml-outline-display)
+          (delete-overlay overlay))))
+    (and category
+         (let ((overlay (make-overlay start
+                                      end
+                                      nil
+                                      front-advance
+                                      rear-advance)))
+           (overlay-put overlay 'category category)
+           (setq line-move-ignore-invisible t)
+           overlay))))
+
+(defun nxml-end-of-heading ()
+  "Move from the start of the content of the heading to the end.
+Do not move past the end of the line."
+  (let ((pos (condition-case err
+                 (and (nxml-scan-element-forward (point) t)
+                      xmltok-start)
+               nil)))
+    (end-of-line)
+    (skip-chars-backward " \t")
+    (cond ((not pos)
+           (setq pos (nxml-token-before))
+           (when (eq xmltok-type 'end-tag)
+             (goto-char pos)))
+          ((< pos (point))
+           (goto-char pos)))
+    (skip-chars-backward " \t")
+    (point)))
+
+;;; Navigating section structure
+
+(defsubst nxml-token-start-tag-p ()
+  (or (eq xmltok-type 'start-tag)
+      (eq xmltok-type 'partial-start-tag)))
+
+(defsubst nxml-token-end-tag-p ()
+  (or (eq xmltok-type 'end-tag)
+      (eq xmltok-type 'partial-end-tag)))
+
+(defun nxml-token-starts-line-p ()
+  (save-excursion
+    (goto-char xmltok-start)
+    (skip-chars-backward " \t")
+    (bolp)))
+
+(defvar nxml-cached-section-tag-regexp nil)
+(defvar nxml-cached-section-element-name-regexp nil)
+
+(defsubst nxml-make-section-tag-regexp ()
+  (if (eq nxml-cached-section-element-name-regexp
+          nxml-section-element-name-regexp)
+      nxml-cached-section-tag-regexp
+    (nxml-make-section-tag-regexp-1)))
+
+(defun nxml-make-section-tag-regexp-1 ()
+  (setq nxml-cached-section-element-name-regexp nil)
+  (setq nxml-cached-section-tag-regexp
+        (concat "</?\\("
+                "\\(" xmltok-ncname-regexp ":\\)?"
+                nxml-section-element-name-regexp
+                "\\)[ \t\r\n>]"))
+  (setq nxml-cached-section-element-name-regexp
+        nxml-section-element-name-regexp)
+  nxml-cached-section-tag-regexp)
+
+(defun nxml-section-tag-forward ()
+  "Move forward past the first tag that is a section start- or end-tag.
+Return xmltok-type for tag.
+If no tag found, return nil and move to the end of the buffer."
+  (let ((case-fold-search nil)
+        (tag-regexp (nxml-make-section-tag-regexp))
+        match-end)
+    (when (< (point) nxml-prolog-end)
+      (goto-char nxml-prolog-end))
+    (while (cond ((not (re-search-forward tag-regexp nil 'move))
+                  (setq xmltok-type nil)
+                  nil)
+                 ((progn
+                    (goto-char (match-beginning 0))
+                    (setq match-end (match-end 0))
+                    (nxml-ensure-scan-up-to-date)
+                    (let ((end (nxml-inside-end (point))))
+                      (when end
+                        (goto-char end)
+                        t))))
+                 ((progn
+                    (xmltok-forward)
+                    (and (memq xmltok-type '(start-tag
+                                             partial-start-tag
+                                             end-tag
+                                             partial-end-tag))
+                         ;; just in case wildcard matched non-name chars
+                         (= xmltok-name-end (1- match-end))))
+                  nil)
+                 (t))))
+    xmltok-type)
+         
+(defun nxml-section-tag-backward ()
+  "Move backward to the end of a tag that is a section start- or end-tag.
+The position of the end of the tag must be <= point
+Point is at the end of the tag.  `xmltok-start' is the start."
+  (let ((case-fold-search nil)
+        (start (point))
+        (tag-regexp (nxml-make-section-tag-regexp))
+        match-end)
+    (if (< (point) nxml-prolog-end)
+        (progn
+          (goto-char (point-min))
+          nil)
+      (while (cond ((not (re-search-backward tag-regexp
+                                             nxml-prolog-end
+                                             'move))
+                    (setq xmltok-type nil)
+                    (goto-char (point-min))
+                    nil)
+                   ((progn
+                      (goto-char (match-beginning 0))
+                      (setq match-end (match-end 0))
+                      (nxml-ensure-scan-up-to-date)
+                      (let ((pos (nxml-inside-start (point))))
+                        (when pos
+                          (goto-char (1- pos))
+                          t))))
+                   ((progn
+                      (xmltok-forward)
+                      (and (<= (point) start)
+                           (memq xmltok-type '(start-tag
+                                               partial-start-tag
+                                               end-tag
+                                               partial-end-tag))
+                           ;; just in case wildcard matched non-name chars
+                           (= xmltok-name-end (1- match-end))))
+                    nil)
+                   (t (goto-char xmltok-start)
+                      t)))
+      xmltok-type)))
+
+(defun nxml-section-start-position ()
+  "Return the position of the start of the section containing point.
+Signal an error on failure."
+  (condition-case err
+      (save-excursion (if (nxml-back-to-section-start)
+                          (point)
+                        (error "Not in section")))
+    (nxml-outline-error
+     (nxml-report-outline-error "Couldn't determine containing section: %s"
+                                err))))
+
+(defun nxml-back-to-section-start (&optional invisible-ok)
+  "Try to move back to the start of the section containing point.
+The start of the section must be <= point.
+Only visible sections are included unless INVISIBLE-OK is non-nil.
+If found, return t.  Otherwise move to point-min and return nil.
+If unbalanced section tags are found, signal an `nxml-outline-error'."
+  (when (or (nxml-after-section-start-tag)
+            (nxml-section-tag-backward))
+    (let (open-tags found)
+      (while (let (section-start-pos)
+               (setq section-start-pos xmltok-start)
+               (if (nxml-token-end-tag-p)
+                   (setq open-tags (cons (xmltok-end-tag-qname)
+                                         open-tags))
+                 (if (not open-tags)
+                     (when (and (nxml-token-starts-line-p)
+                                (or invisible-ok
+                                    (not (get-char-property section-start-pos
+                                                            'invisible)))
+                                (nxml-heading-start-position))
+                       (setq found t))
+                   (let ((qname (xmltok-start-tag-qname)))
+                     (unless (string= (car open-tags) qname)
+                       (nxml-outline-error "mismatched end-tag"))
+                     (setq open-tags (cdr open-tags)))))
+               (goto-char section-start-pos)
+               (and (not found)
+                    (nxml-section-tag-backward))))
+      found)))
+
+(defun nxml-after-section-start-tag ()
+  "If the character after point is in a section start-tag, move after it.
+Return the token type.  Otherwise return nil.
+Set up variables like `xmltok-forward'."
+  (let ((pos (nxml-token-after))
+        (case-fold-search nil))
+   (when (and (memq xmltok-type '(start-tag partial-start-tag))
+              (save-excursion
+                (goto-char xmltok-start)
+                (looking-at (nxml-make-section-tag-regexp))))
+     (goto-char pos)
+     xmltok-type)))
+
+(defun nxml-heading-start-position ()
+  "Return the position of the start of the content of a heading element.
+Adjust the position to be after initial leading whitespace.
+Return nil if no heading element is found.  Requires point to be
+immediately after the section's start-tag."
+  (let ((depth 0)
+        (heading-regexp (concat "\\`\\("
+                                nxml-heading-element-name-regexp
+                                "\\)\\'"))
+        
+        (section-regexp (concat "\\`\\("
+                                nxml-section-element-name-regexp
+                                "\\)\\'"))
+        (start (point))
+        found)
+    (save-excursion
+      (while (and (xmltok-forward)
+                  (cond ((memq xmltok-type '(end-tag partial-end-tag))
+                         (and (not (string-match section-regexp
+                                                 (xmltok-end-tag-local-name)))
+                              (> depth 0)
+                              (setq depth (1- depth))))
+                        ;; XXX Not sure whether this is a good idea
+                        ;;((eq xmltok-type 'empty-element)
+                        ;; nil)
+                        ((not (memq xmltok-type
+                                    '(start-tag partial-start-tag)))
+                         t)
+                        ((string-match section-regexp
+                                       (xmltok-start-tag-local-name))
+                         nil)
+                        ((string-match heading-regexp
+                                       (xmltok-start-tag-local-name))
+                         (skip-chars-forward " \t\r\n")
+                         (setq found (point))
+                         nil)
+                        (t
+                         (setq depth (1+ depth))
+                         t))
+                  (<= (- (point) start) nxml-heading-scan-distance))))
+    found))
+
+;;; Error handling
+
+(defun nxml-report-outline-error (msg err)
+  (error msg (apply 'format (cdr err))))
+
+(defun nxml-outline-error (&rest args)
+  (signal 'nxml-outline-error args))
+
+(put 'nxml-outline-error
+     'error-conditions
+     '(error nxml-error nxml-outline-error))
+
+(put 'nxml-outline-error
+     'error-message
+     "Cannot create outline of buffer that is not well-formed")
+
+;;; Debugging
+
+(defun nxml-debug-overlays ()
+  (interactive)
+  (let ((overlays (nreverse (overlays-in (point-min) (point-max))))
+        overlay)
+    (while overlays
+      (setq overlay (car overlays))
+      (setq overlays (cdr overlays))
+      (when (overlay-get overlay 'nxml-outline-display)
+        (message "overlay %s: %s...%s (%s)"
+                 (overlay-get overlay 'category)
+                 (overlay-start overlay)
+                 (overlay-end overlay)
+                 (overlay-get overlay 'display))))))
+
+(provide 'nxml-outln)
+
+;;; nxml-outln.el ends here
diff --git a/lisp/nxml/nxml-parse.el b/lisp/nxml/nxml-parse.el
new file mode 100644
index 00000000000..0e93f10103a
--- /dev/null
+++ b/lisp/nxml/nxml-parse.el
@@ -0,0 +1,320 @@
+;;; nxml-parse.el --- XML parser, sharing infrastructure with nxml-mode
+
+;; Copyright (C) 2003 Free Software Foundation, Inc.
+
+;; Author: James Clark
+;; Keywords: XML
+
+;; This program is free software; you can redistribute it and/or
+;; modify it under the terms of the GNU General Public License as
+;; published by the Free Software Foundation; either version 2 of
+;; the License, or (at your option) any later version.
+
+;; This program is distributed in the hope that it will be
+;; useful, but WITHOUT ANY WARRANTY; without even the implied
+;; warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+;; PURPOSE.  See the GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public
+;; License along with this program; if not, write to the Free
+;; Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+;; MA 02111-1307 USA
+
+;;; Commentary:
+
+;; Entry point is `nxml-parse-file'.
+
+;;; Code:
+
+(require 'nxml-util)
+(require 'xmltok)
+(require 'nxml-enc)
+(require 'nxml-ns)
+
+(defvar nxml-parse-file-name nil)
+
+(defvar nxml-validate-function nil
+  "Nil or a function to be called by `nxml-parse-file' to perform validation.
+The function will be called once for each start-tag or end-tag.  The
+function is passed two arguments TEXT and START-TAG.  For a start-tag,
+START-TAG is a list (NAME ATTRIBUTES) where NAME and ATTRIBUTES are in
+the same form as returned by `nxml-parse-file.  For an end-tag,
+START-TAG is nil.  TEXT is a string containing the text immediately
+preceding the tag, or nil if there was no such text.  An empty element
+is treated as a start-tag followed by an end-tag.
+
+For a start-tag, the namespace state will be the state after
+processing the namespace declarations in the start-tag. For an
+end-tag, the namespace state will be the state before popping the
+namespace declarations for the corresponding start-tag.
+
+The function must return nil if no error is detected or a
+cons (MESSAGE . LOCATION) where MESSAGE is a string containing
+an error message and LOCATION indicates what caused the error
+as follows:
+
+- nil indicates the tag as whole caused it; this is always allowed;
+
+- text indicates the text caused it; this is allowed only if
+TEXT is non-nil;
+
+- tag-close indicates the close of the tag caused it; this is
+allowed only if START-TAG is non-nil;
+
+- (attribute-name . N) indicates that the name of the Nth attribute
+caused it; N counts from 0; this is allowed only if START-TAG is non-nil
+and N must be less than the number of attributes;
+
+- (attribute-value . N) indicates that the value of the Nth attribute
+caused it; N counts from 0; this is allowed only if START-TAG is non-nil
+and N must be less than the number of attributes.")
+
+(defun nxml-parse-file (file)
+  "Parse the XML document in FILE and return it as a list.
+An XML element is represented as a list (NAME ATTRIBUTES . CHILDREN).
+NAME is either a string, in the case where the name does not have a
+namespace, or a cons (NAMESPACE . LOCAL-NAME), where NAMESPACE is a
+symbol and LOCAL-NAME is a string, in the case where the name does
+have a namespace. NAMESPACE is a keyword whose name is `:URI', where
+URI is the namespace name.  ATTRIBUTES is an alist of attributes where
+each attribute has the form (NAME . VALUE), where NAME has the same
+form as an element name, and VALUE is a string.  A namespace
+declaration is represented as an attribute whose name is
+\(:http://www.w3.org/2000/xmlns/ . LOCAL-NAME).  CHILDREN is a list
+containing strings and child elements; CHILDREN never contains two
+consecutive strings and never contains an empty string.  Processing
+instructions and comments are not represented.  The return value is a
+list representing the document element.
+
+If the XML document is not well-formed, an error having the condition
+`nxml-file-parse-error' will be signaled; the error data will be a
+list of the \(FILE POSITION MESSAGE), where POSITION is an integer
+specifying the position where the error was detected, and MESSAGE is a
+string describing the error.
+
+The current contents of FILE will be parsed even if there is a
+modified buffer currently visiting FILE.
+
+If the variable `nxml-validation-function' is non-nil, it will be
+called twice for each element, and any reported error will be signaled
+in the same way as well-formedness error."
+  (save-excursion
+    (set-buffer (nxml-parse-find-file file))
+    (unwind-protect
+        (let ((nxml-parse-file-name file))
+          (nxml-parse-instance))
+      (kill-buffer nil))))
+
+(defun nxml-parse-find-file (file)
+  (save-excursion
+    (set-buffer (get-buffer-create " *nXML Parse*"))
+    (erase-buffer)
+    (let ((set-auto-coding-function 'nxml-set-xml-coding))
+      (insert-file-contents file))
+    (current-buffer)))
+      
+(defun nxml-parse-instance ()
+  (let (xmltok-dtd)
+    (xmltok-save
+      (xmltok-forward-prolog)
+      (nxml-check-xmltok-errors)
+      (nxml-ns-save
+        (nxml-parse-instance-1)))))
+
+(defun nxml-parse-instance-1 ()
+  (let* ((top (cons nil nil))
+         ;; tail is a cons cell, whose cdr is nil
+         ;; additional elements will destructively appended to tail
+         (tail top)
+         ;; stack of tails one for each open element
+         tail-stack
+         ;; list of QNames of open elements
+         open-element-tags
+         ;; list of strings buffering a text node, in reverse order
+         text
+         ;; position of beginning of first (in buffer) string in text
+         text-pos)
+    (while (xmltok-forward)
+      (nxml-check-xmltok-errors)
+      (cond ((memq xmltok-type '(start-tag end-tag empty-element))
+             (when text
+               (setq text (apply 'concat (nreverse text)))
+               (setcdr tail (cons text nil))
+               (setq tail (cdr tail)))
+             (when (not (eq xmltok-type 'end-tag))
+               (when (and (not open-element-tags)
+                          (not (eq tail top)))
+                 (nxml-parse-error nil "Multiple top-level elements"))
+               (setq open-element-tags
+                     (cons (xmltok-start-tag-qname)
+                           open-element-tags))
+               (nxml-ns-push-state)
+               (let ((tag (nxml-parse-start-tag)))
+                 (nxml-validate-tag text text-pos tag)
+                 (setq text nil)
+                 (setcdr tail (cons tag nil))
+                 (setq tail (cdr tail))
+                 (setq tail-stack (cons tail tail-stack))
+                 (setq tail (last tag))))
+             (when (not (eq xmltok-type 'start-tag))
+               (or (eq xmltok-type 'empty-element)
+                   (equal (car open-element-tags)
+                          (xmltok-end-tag-qname))
+                   (if open-element-tags
+                       (nxml-parse-error nil
+                                         "Unbalanced end-tag; expected </%s>"
+                                         (car open-element-tags))
+                     (nxml-parse-error nil "Extra end-tag")))
+               (nxml-validate-tag text text-pos nil)
+               (setq text nil)
+               (nxml-ns-pop-state)
+               (setq open-element-tags (cdr open-element-tags))
+               (setq tail (car tail-stack))
+               (setq tail-stack (cdr tail-stack)))
+             (setq text-pos nil))
+            ((memq xmltok-type '(space data entity-ref char-ref cdata-section))
+             (cond (open-element-tags
+                    (unless text-pos
+                      (setq text-pos xmltok-start))
+                    (setq text
+                          (cons (nxml-current-text-string) text)))
+                   ((not (eq xmltok-type 'space))
+                    (nxml-parse-error
+                     nil
+                     "%s at top-level"
+                     (cdr (assq xmltok-type
+                                '((data . "Text characters")
+                                  (entity-ref . "Entity reference")
+                                  (char-ref . "Character reference")
+                                  (cdata-section . "CDATA section"))))))))))
+    (unless (cdr top)
+      (nxml-parse-error (point-max) "Missing document element"))
+    (cadr top)))
+
+(defun nxml-parse-start-tag ()
+  (let (parsed-attributes
+        parsed-namespace-attributes
+        atts att prefixes prefix ns value name)
+    (setq atts xmltok-namespace-attributes)
+    (while atts
+      (setq att (car atts))
+      (setq value (or (xmltok-attribute-value att)
+                      (nxml-parse-error nil "Invalid attribute value")))
+      (setq ns (nxml-make-namespace value))
+      (setq prefix (and (xmltok-attribute-prefix att)
+                        (xmltok-attribute-local-name att)))
+      (cond ((member prefix prefixes)
+             (nxml-parse-error nil "Duplicate namespace declaration"))
+            ((not prefix)
+             (nxml-ns-set-default ns))
+            (ns
+             (nxml-ns-set-prefix prefix ns))
+            (t (nxml-parse-error nil "Cannot undeclare namespace prefix")))
+      (setq prefixes (cons prefix prefixes))
+      (setq parsed-namespace-attributes
+            (cons (cons (nxml-make-name nxml-xmlns-namespace-uri
+                                        (xmltok-attribute-local-name att))
+                        value)
+                  parsed-namespace-attributes))
+      (setq atts (cdr atts)))
+    (setq name
+          (nxml-make-name
+           (let ((prefix (xmltok-start-tag-prefix)))
+             (if prefix
+                 (or (nxml-ns-get-prefix prefix)
+                     (nxml-parse-error (1+ xmltok-start)
+                                       "Prefix `%s' undeclared"
+                                       prefix))
+               (nxml-ns-get-default)))
+           (xmltok-start-tag-local-name)))
+    (setq atts xmltok-attributes)
+    (while atts
+      (setq att (car atts))
+      (setq ns
+            (let ((prefix (xmltok-attribute-prefix att)))
+              (and prefix
+                   (or (nxml-ns-get-prefix prefix)
+                       (nxml-parse-error (xmltok-attribute-name-start att)
+                                         "Prefix `%s' undeclared"
+                                         prefix)))))
+      (setq parsed-attributes
+            (let ((nm (nxml-make-name ns
+                                      (xmltok-attribute-local-name att))))
+              (when (assoc nm parsed-attributes)
+                (nxml-parse-error (xmltok-attribute-name-start att)
+                                  "Duplicate attribute"))
+              (cons (cons nm (or (xmltok-attribute-value att)
+                                 (nxml-parse-error nil "Invalid attribute value")))
+                    parsed-attributes)))
+      (setq atts (cdr atts)))
+    ;; We want to end up with the attributes followed by the
+    ;; the namespace attributes in the same order as
+    ;; xmltok-attributes and xmltok-namespace-attributes respectively.
+    (when parsed-namespace-attributes
+      (setq parsed-attributes
+            (nconc parsed-namespace-attributes parsed-attributes)))
+    (list name (nreverse parsed-attributes))))
+
+(defun nxml-validate-tag (text text-pos tag)
+  (when nxml-validate-function
+    (let ((err (funcall nxml-validate-function text tag))
+          pos)
+      (when err
+        (setq pos (nxml-validate-error-position (cdr err)
+                                                (and text text-pos)
+                                                tag))
+        (or pos (error "Incorrect return value from %s"
+                       nxml-validate-function))
+        (nxml-parse-error pos (car err))))))
+
+(defun nxml-validate-error-position (location text-pos tag)
+  (cond ((null location) xmltok-start)
+        ((eq location 'text)  text-pos)
+        ((eq location 'tag-close)
+         (and tag (- (point) (if (eq xmltok-type 'empty-element ) 2 1))))
+        ((consp location)
+         (let ((att (nth (cdr location) xmltok-attributes)))
+           (when (not att)
+             (setq att (nth (- (cdr location) (length xmltok-attributes))
+                            xmltok-namespace-attributes)))
+           (cond ((not att))
+                 ((eq (car location) 'attribute-name)
+                  (xmltok-attribute-name-start att))
+                 ((eq (car location) 'attribute-value)
+                  (xmltok-attribute-value-start att)))))))
+
+(defun nxml-make-name (ns local-name)
+  (if ns
+      (cons ns local-name)
+    local-name))
+
+(defun nxml-current-text-string ()
+  (cond ((memq xmltok-type '(space data))
+         (buffer-substring-no-properties xmltok-start
+                                         (point)))
+        ((eq xmltok-type 'cdata-section)
+         (buffer-substring-no-properties (+ xmltok-start 9)
+                                         (- (point) 3)))
+        ((memq xmltok-type '(char-ref entity-ref))
+         (unless xmltok-replacement
+           (nxml-parse-error nil
+                             (if (eq xmltok-type 'char-ref)
+                                 "Reference to unsupported Unicode character"
+                               "Unresolvable entity reference")))
+         xmltok-replacement)))
+
+(defun nxml-parse-error (position &rest args)
+  (nxml-signal-file-parse-error nxml-parse-file-name
+                                (or position xmltok-start)
+                                (apply 'format args)))
+
+(defun nxml-check-xmltok-errors ()
+  (when xmltok-errors
+    (let ((err (car (last xmltok-errors))))
+      (nxml-signal-file-parse-error nxml-parse-file-name
+                                    (xmltok-error-start err)
+                                    (xmltok-error-message err)))))
+
+(provide 'nxml-parse)
+
+;;; nxml-parse.el ends here
diff --git a/lisp/nxml/nxml-rap.el b/lisp/nxml/nxml-rap.el
new file mode 100644
index 00000000000..8b0c55e573e
--- /dev/null
+++ b/lisp/nxml/nxml-rap.el
@@ -0,0 +1,467 @@
+;;; nxml-rap.el --- low-level support for random access parsing for nXML mode
+
+;; Copyright (C) 2003, 2004 Free Software Foundation, Inc.
+
+;; Author: James Clark
+;; Keywords: XML
+
+;; This program is free software; you can redistribute it and/or
+;; modify it under the terms of the GNU General Public License as
+;; published by the Free Software Foundation; either version 2 of
+;; the License, or (at your option) any later version.
+
+;; This program is distributed in the hope that it will be
+;; useful, but WITHOUT ANY WARRANTY; without even the implied
+;; warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+;; PURPOSE.  See the GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public
+;; License along with this program; if not, write to the Free
+;; Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+;; MA 02111-1307 USA
+
+;;; Commentary:
+
+;; This uses xmltok.el to do XML parsing. The fundamental problem is
+;; how to handle changes. We don't want to maintain a complete parse
+;; tree.  We also don't want to reparse from the start of the document
+;; on every keystroke.  However, it is not possible in general to
+;; parse an XML document correctly starting at a random point in the
+;; middle.  The main problems are comments, CDATA sections and
+;; processing instructions: these can all contain things that are
+;; indistinguishable from elements. Literals in the prolog are also a
+;; problem.  Attribute value literals are not a problem because
+;; attribute value literals cannot contain less-than signs.
+;;
+;; Our strategy is to keep track of just the problematic things.
+;; Specifically, we keep track of all comments, CDATA sections and
+;; processing instructions in the instance.  We do this by marking all
+;; except the first character of these with a non-nil nxml-inside text
+;; property. The value of the nxml-inside property is comment,
+;; cdata-section or processing-instruction.  The first character does
+;; not have the nxml-inside property so we can find the beginning of
+;; the construct by looking for a change in a text property value
+;; (Emacs provides primitives for this).  We use text properties
+;; rather than overlays, since the implementation of overlays doesn't
+;; look like it scales to large numbers of overlays in a buffer.
+;;
+;; We don't in fact track all these constructs, but only track them in
+;; some initial part of the instance. The variable `nxml-scan-end'
+;; contains the limit of where we have scanned up to for them.
+;;
+;; Thus to parse some random point in the file we first ensure that we
+;; have scanned up to that point.  Then we search backwards for a
+;; <. Then we check whether the < has an nxml-inside property. If it
+;; does we go backwards to first character that does not have an
+;; nxml-inside property (this character must be a <).  Then we start
+;; parsing forward from the < we have found.
+;;
+;; The prolog has to be parsed specially, so we also keep track of the
+;; end of the prolog in `nxml-prolog-end'. The prolog is reparsed on
+;; every change to the prolog.  This won't work well if people try to
+;; edit huge internal subsets. Hopefully that will be rare.
+;;
+;; We keep track of the changes by adding to the buffer's
+;; after-change-functions hook.  Scanning is also done as a
+;; prerequisite to fontification by adding to fontification-functions
+;; (in the same way as jit-lock).  This means that scanning for these
+;; constructs had better be quick.  Fortunately it is. Firstly, the
+;; typical proportion of comments, CDATA sections and processing
+;; instructions is small relative to other things.  Secondly, to scan
+;; we just search for the regexp <[!?].
+;;
+;; One problem is unclosed comments, processing instructions and CDATA
+;; sections.  Suppose, for example, we encounter a <!-- but there's no
+;; matching -->.  This is not an unexpected situation if the user is
+;; creating a comment. It is not helpful to treat the whole of the
+;; file starting from the <!-- onwards as a single unclosed comment
+;; token. Instead we treat just the <!-- as a piece of not well-formed
+;; markup and continue.  The problem is that if at some later stage a
+;; --> gets added to the buffer after the unclosed <!--, we will need
+;; to reparse the buffer starting from the <!--.  We need to keep
+;; track of these reparse dependencies; they are called dependent
+;; regions in the code.
+
+;;; Code:
+
+(require 'xmltok)
+(require 'nxml-util)
+
+(defvar nxml-prolog-end nil
+  "Integer giving position following end of the prolog.")
+(make-variable-buffer-local 'nxml-prolog-end)
+
+(defvar nxml-scan-end nil
+  "Marker giving position up to which we have scanned.
+nxml-scan-end must be >= nxml-prolog-end.  Furthermore, nxml-scan-end
+must not an inside position in the following sense. A position is
+inside if the following character is a part of, but not the first
+character of, a CDATA section, comment or processing instruction.
+Furthermore all positions >= nxml-prolog-end and < nxml-scan-end that
+are inside positions must have a non-nil nxml-inside property whose
+value is a symbol specifying what it is inside. Any characters with a
+non-nil fontified property must have position < nxml-scan-end and the
+correct face. Dependent regions must also be established for any
+unclosed constructs starting before nxml-scan-end.
+There must be no nxml-inside properties after nxml-scan-end.")
+(make-variable-buffer-local 'nxml-scan-end)
+
+(defsubst nxml-get-inside (pos)
+  (get-text-property pos 'nxml-inside))
+
+(defsubst nxml-clear-inside (start end)
+  (remove-text-properties start end '(nxml-inside nil)))
+
+(defsubst nxml-set-inside (start end type)
+  (put-text-property start end 'nxml-inside type))
+
+(defun nxml-inside-end (pos)
+  "Return the end of the inside region containing POS.
+Return nil if the character at POS is not inside."
+  (if (nxml-get-inside pos)
+      (or (next-single-property-change pos 'nxml-inside)
+          (point-max))
+    nil))
+
+(defun nxml-inside-start (pos)
+  "Return the start of the inside region containing POS.
+Return nil if the character at POS is not inside."
+  (if (nxml-get-inside pos)
+      (or (previous-single-property-change (1+ pos) 'nxml-inside)
+          (point-min))
+    nil))
+
+;;; Change management
+
+(defun nxml-scan-after-change (start end)
+  "Restore `nxml-scan-end' invariants after a change.
+The change happened between START and END.
+Return position after which lexical state is unchanged.
+END must be > nxml-prolog-end."
+  (if (>= start nxml-scan-end)
+      nxml-scan-end
+    (goto-char start)
+    (nxml-move-outside-backwards)
+    (setq start (point))
+    (let ((inside-remove-start start)
+          xmltok-errors
+          xmltok-dependent-regions)
+      (while (or (when (xmltok-forward-special (min end nxml-scan-end))
+                   (when (memq xmltok-type
+                               '(comment
+                                 cdata-section
+                                 processing-instruction))
+                     (nxml-clear-inside inside-remove-start
+                                        (1+ xmltok-start))
+                     (nxml-set-inside (1+ xmltok-start)
+                                      (point)
+                                      xmltok-type)
+                     (setq inside-remove-start (point)))
+                   (if (< (point) (min end nxml-scan-end))
+                       t
+                     (setq end (point))
+                     nil))
+                 ;; The end of the change was inside but is now outside.
+                 ;; Imagine something really weird like
+                 ;; <![CDATA[foo <!-- bar ]]> <![CDATA[ stuff --> <!-- ]]> -->
+                 ;; and suppose we deleted "<![CDATA[f"
+                 (let ((inside-end (nxml-inside-end end)))
+                   (when inside-end
+                     (setq end inside-end)
+                     t))))
+      (nxml-clear-inside inside-remove-start end)
+      (nxml-clear-dependent-regions start end)
+      (nxml-mark-parse-dependent-regions))
+    (when (> end nxml-scan-end)
+      (set-marker nxml-scan-end end))
+    end))
+
+(defun nxml-scan-prolog ()
+  (goto-char (point-min))
+  (let (xmltok-dtd
+        xmltok-errors
+        xmltok-dependent-regions)
+    (setq nxml-prolog-regions (xmltok-forward-prolog))
+    (setq nxml-prolog-end (point))
+    (nxml-clear-inside (point-min) nxml-prolog-end)
+    (nxml-clear-dependent-regions (point-min) nxml-prolog-end)
+    (nxml-mark-parse-dependent-regions))
+  (when (< nxml-scan-end nxml-prolog-end)
+    (set-marker nxml-scan-end nxml-prolog-end)))
+
+
+;;; Dependent regions
+
+(defun nxml-adjust-start-for-dependent-regions (start end pre-change-length)
+  (let ((overlays (overlays-in (1- start) start))
+        (adjusted-start start))
+    (while overlays
+      (let* ((overlay (car overlays))
+             (ostart (overlay-start overlay)))
+        (when (and (eq (overlay-get overlay 'category) 'nxml-dependent)
+                   (< ostart adjusted-start))
+          (let ((funargs (overlay-get overlay 'nxml-funargs)))
+            (when (apply (car funargs)
+                         (append (list start
+                                       end
+                                       pre-change-length
+                                       ostart
+                                       (overlay-end overlay))
+                                 (cdr funargs)))
+              (setq adjusted-start ostart)))))
+      (setq overlays (cdr overlays)))
+    adjusted-start))
+                  
+(defun nxml-mark-parse-dependent-regions ()
+  (while xmltok-dependent-regions
+    (apply 'nxml-mark-parse-dependent-region
+           (car xmltok-dependent-regions))
+    (setq xmltok-dependent-regions
+          (cdr xmltok-dependent-regions))))
+
+(defun nxml-mark-parse-dependent-region (fun start end &rest args)
+  (let ((overlay (make-overlay start end nil t t)))
+    (overlay-put overlay 'category 'nxml-dependent)
+    (overlay-put overlay 'nxml-funargs (cons fun args))))
+
+(put 'nxml-dependent 'evaporate t)
+
+(defun nxml-clear-dependent-regions (start end)
+  (let ((overlays (overlays-in start end)))
+    (while overlays
+      (let* ((overlay (car overlays))
+             (category (overlay-get overlay 'category)))
+        (when (and (eq category 'nxml-dependent)
+                   (<= start (overlay-start overlay)))
+          (delete-overlay overlay)))
+      (setq overlays (cdr overlays)))))
+
+;;; Random access parsing
+
+(defun nxml-token-after ()
+  "Return the position after the token containing the char after point.
+Sets up the variables `xmltok-type', `xmltok-start',
+`xmltok-name-end', `xmltok-name-colon', `xmltok-attributes',
+`xmltok-namespace-attributes' in the same was as does
+`xmltok-forward'.  The prolog will be treated as a single token with
+type `prolog'."
+  (let ((pos (point)))
+    (if (< pos nxml-prolog-end)
+        (progn
+          (setq xmltok-type 'prolog
+                xmltok-start (point-min))
+          (min nxml-prolog-end (point-max)))
+      (nxml-ensure-scan-up-to-date)
+      (if (nxml-get-inside pos)
+          (save-excursion
+            (nxml-move-outside-backwards)
+            (xmltok-forward)
+            (point))
+        (save-excursion
+          (if (or (eq (char-after) ?<)
+                      (search-backward "<"
+                                       (max (point-min) nxml-prolog-end)
+                                       t))
+              (nxml-move-outside-backwards)
+            (goto-char (if (<= (point-min) nxml-prolog-end)
+                           nxml-prolog-end
+                         (or (nxml-inside-end (point-min))
+                             (point-min)))))
+          (while (and (nxml-tokenize-forward)
+                      (<= (point) pos)))
+          (point))))))
+
+(defun nxml-token-before ()
+  "Return the position after the token containing the char before point.
+Sets variables like `nxml-token-after'."
+  (if (/= (point-min) (point))
+      (save-excursion
+        (goto-char (1- (point)))
+        (nxml-token-after))
+    (setq xmltok-start (point))
+    (setq xmltok-type nil)
+    (point)))
+
+(defun nxml-tokenize-forward ()
+  (let (xmltok-dependent-regions
+        xmltok-errors)
+    (when (and (xmltok-forward)
+               (> (point) nxml-scan-end))
+      (cond ((memq xmltok-type '(comment
+                                 cdata-section
+                                 processing-instruction))
+             (nxml-with-unmodifying-text-property-changes
+               (nxml-set-inside (1+ xmltok-start) (point) xmltok-type)))
+            (xmltok-dependent-regions
+             (nxml-mark-parse-dependent-regions)))
+      (set-marker nxml-scan-end (point)))
+    xmltok-type))
+
+(defun nxml-move-outside-backwards ()
+  "Move point to first character of the containing special thing.
+Leave point unmoved if it is not inside anything special."
+  (let ((start (nxml-inside-start (point))))
+    (when start
+      (goto-char (1- start))
+      (when (nxml-get-inside (point))
+        (error "Char before inside-start at %s had nxml-inside property %s"
+               (point)
+               (nxml-get-inside (point)))))))
+
+(defun nxml-ensure-scan-up-to-date ()
+  (let ((pos (point)))
+    (when (< nxml-scan-end pos)
+      (save-excursion
+        (goto-char nxml-scan-end)
+        (let (xmltok-errors
+              xmltok-dependent-regions)
+          (while (when (xmltok-forward-special pos)
+                   (when (memq xmltok-type
+                               '(comment
+                                 processing-instruction
+                                 cdata-section))
+                     (nxml-with-unmodifying-text-property-changes
+                       (nxml-set-inside (1+ xmltok-start)
+                                        (point)
+                                        xmltok-type)))
+                   (if (< (point) pos)
+                       t
+                     (setq pos (point))
+                     nil)))
+          (nxml-clear-dependent-regions nxml-scan-end pos)
+          (nxml-mark-parse-dependent-regions)
+          (set-marker nxml-scan-end pos))))))
+
+;;; Element scanning
+
+(defun nxml-scan-element-forward (from &optional up)
+  "Scan forward from FROM over a single balanced element.
+Point must between tokens.  Return the position of the end of the tag
+that ends the element. `xmltok-start' will contain the position of the
+start of the tag. If UP is non-nil, then scan past end-tag of element
+containing point.  If no element is found, return nil.  If a
+well-formedness error prevents scanning, signal an nxml-scan-error.
+Point is not moved."
+  (let ((open-tags (and up t))
+        found)
+    (save-excursion
+      (goto-char from)
+      (while (cond ((not (nxml-tokenize-forward))
+                    (when (consp open-tags)
+                      (nxml-scan-error (cadr open-tags)
+                                       "Start-tag has no end-tag"))
+                    nil)
+                   ((eq xmltok-type 'start-tag)
+                    (setq open-tags
+                          (cons (xmltok-start-tag-qname)
+                                (cons xmltok-start
+                                      open-tags)))
+                    t)
+                   ((eq xmltok-type 'end-tag)
+                    (cond ((not open-tags) nil)
+                          ((not (consp open-tags)) (setq found (point)) nil)
+                          ((not (string= (car open-tags)
+                                         (xmltok-end-tag-qname)))
+                           (nxml-scan-error (+ 2 xmltok-start)
+                                            "Mismatched end-tag; \
+expected `%s'"
+                                            (car open-tags)))
+                          ((setq open-tags (cddr open-tags)) t)
+                          (t (setq found (point)) nil)))
+                   ((memq xmltok-type '(empty-element
+                                        partial-empty-element))
+                    (if open-tags
+                        t
+                      (setq found (point))
+                      nil))
+                   ((eq xmltok-type 'partial-end-tag)
+                    (cond ((not open-tags) nil)
+                          ((not (consp open-tags)) (setq found (point)) nil)
+                          ((setq open-tags (cddr open-tags)) t)
+                          (t (setq found (point)) nil)))
+                   ((eq xmltok-type 'partial-start-tag)
+                    (nxml-scan-error xmltok-start
+                                     "Missing `>'"))
+                   (t t))))
+    found))
+
+(defun nxml-scan-element-backward (from &optional up bound)
+  "Scan backward from FROM over a single balanced element.
+Point must between tokens.  Return the position of the end of the tag
+that starts the element. `xmltok-start' will contain the position of
+the start of the tag.  If UP is non-nil, then scan past start-tag of
+element containing point.  If BOUND is non-nil, then don't scan back
+past BOUND.  If no element is found, return nil.  If a well-formedness
+error prevents scanning, signal an nxml-scan-error.  Point is not
+moved."
+  (let ((open-tags (and up t))
+        token-end found)
+    (save-excursion
+      (goto-char from)
+      (while (cond ((or (< (point) nxml-prolog-end)
+                        (not (search-backward "<"
+                                              (max (or bound 0)
+                                                   nxml-prolog-end)
+                                              t)))
+                    (when (and (consp open-tags) (not bound))
+                      (nxml-scan-error (cadr open-tags)
+                                       "End-tag has no start-tag"))
+                    nil)
+                   ((progn
+                      (nxml-move-outside-backwards)
+                      (save-excursion
+                        (nxml-tokenize-forward)
+                        (setq token-end (point)))
+                      (eq xmltok-type 'end-tag))
+                    (setq open-tags
+                          (cons (xmltok-end-tag-qname)
+                                (cons xmltok-start open-tags)))
+                    t)
+                   ((eq xmltok-type 'start-tag)
+                    (cond ((not open-tags) nil)
+                          ((not (consp open-tags))
+                           (setq found token-end)
+                           nil)
+                          ((and (car open-tags)
+                                (not (string= (car open-tags)
+                                              (xmltok-start-tag-qname))))
+                           (nxml-scan-error (1+ xmltok-start)
+                                            "Mismatched start-tag; \
+expected `%s'"
+                                            (car open-tags)))
+                          ((setq open-tags (cddr open-tags)) t)
+                          (t (setq found token-end) nil)))
+                   ((memq xmltok-type '(empty-element
+                                        partial-empty-element))
+                    (if open-tags
+                        t
+                      (setq found token-end)
+                      nil))
+                   ((eq xmltok-type 'partial-end-tag)
+                    (setq open-tags
+                          (cons nil (cons xmltok-start open-tags)))
+                    t)
+                   ((eq xmltok-type 'partial-start-tag)
+                    ;; if we have only a partial-start-tag
+                    ;; then it's unlikely that there's a matching
+                    ;; end-tag, so it's probably not helpful
+                    ;; to treat it as a complete start-tag
+                    (nxml-scan-error xmltok-start
+                                     "Missing `>'"))
+                   (t t))))
+    found))
+
+(defun nxml-scan-error (&rest args)
+  (signal 'nxml-scan-error args))
+
+(put 'nxml-scan-error
+     'error-conditions
+     '(error nxml-error nxml-scan-error))
+
+(put 'nxml-scan-error
+     'error-message
+     "Scan over element that is not well-formed")
+
+(provide 'nxml-rap)
+
+;;; nxml-rap.el ends here
diff --git a/lisp/nxml/nxml-uchnm.el b/lisp/nxml/nxml-uchnm.el
new file mode 100644
index 00000000000..fbb60745159
--- /dev/null
+++ b/lisp/nxml/nxml-uchnm.el
@@ -0,0 +1,257 @@
+;;; nxml-uchnm.el --- support for Unicode standard cha names in nxml-mode
+
+;; Copyright (C) 2003 Free Software Foundation, Inc.
+
+;; Author: James Clark
+;; Keywords: XML
+
+;; This program is free software; you can redistribute it and/or
+;; modify it under the terms of the GNU General Public License as
+;; published by the Free Software Foundation; either version 2 of
+;; the License, or (at your option) any later version.
+
+;; This program is distributed in the hope that it will be
+;; useful, but WITHOUT ANY WARRANTY; without even the implied
+;; warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+;; PURPOSE.  See the GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public
+;; License along with this program; if not, write to the Free
+;; Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+;; MA 02111-1307 USA
+
+;;; Commentary:
+
+;; This enables the use of the character names defined in the Unicode
+;; Standard.  The use of the names can be controlled on a per-block
+;; basis, so as both to reduce memory usage and loading time,
+;; and to make completion work better.
+;; The main entry point is `nxml-enable-unicode-char-name-sets'.  Typically,
+;; this is added to `nxml-mode-hook' (rng-auto.el does this already).
+;; To customize the blocks for which names are used
+
+;;; Code:
+
+(require 'nxml-mode)
+
+(defconst nxml-unicode-blocks
+  '(("Basic Latin" #x0000 #x007F)
+    ("Latin-1 Supplement" #x0080 #x00FF)
+    ("Latin Extended-A" #x0100 #x017F)
+    ("Latin Extended-B" #x0180 #x024F)
+    ("IPA Extensions" #x0250 #x02AF)
+    ("Spacing Modifier Letters" #x02B0 #x02FF)
+    ("Combining Diacritical Marks" #x0300 #x036F)
+    ("Greek and Coptic" #x0370 #x03FF)
+    ("Cyrillic" #x0400 #x04FF)
+    ("Cyrillic Supplementary" #x0500 #x052F)
+    ("Armenian" #x0530 #x058F)
+    ("Hebrew" #x0590 #x05FF)
+    ("Arabic" #x0600 #x06FF)
+    ("Syriac" #x0700 #x074F)
+    ("Thaana" #x0780 #x07BF)
+    ("Devanagari" #x0900 #x097F)
+    ("Bengali" #x0980 #x09FF)
+    ("Gurmukhi" #x0A00 #x0A7F)
+    ("Gujarati" #x0A80 #x0AFF)
+    ("Oriya" #x0B00 #x0B7F)
+    ("Tamil" #x0B80 #x0BFF)
+    ("Telugu" #x0C00 #x0C7F)
+    ("Kannada" #x0C80 #x0CFF)
+    ("Malayalam" #x0D00 #x0D7F)
+    ("Sinhala" #x0D80 #x0DFF)
+    ("Thai" #x0E00 #x0E7F)
+    ("Lao" #x0E80 #x0EFF)
+    ("Tibetan" #x0F00 #x0FFF)
+    ("Myanmar" #x1000 #x109F)
+    ("Georgian" #x10A0 #x10FF)
+    ("Hangul Jamo" #x1100 #x11FF)
+    ("Ethiopic" #x1200 #x137F)
+    ("Cherokee" #x13A0 #x13FF)
+    ("Unified Canadian Aboriginal Syllabics" #x1400 #x167F)
+    ("Ogham" #x1680 #x169F)
+    ("Runic" #x16A0 #x16FF)
+    ("Tagalog" #x1700 #x171F)
+    ("Hanunoo" #x1720 #x173F)
+    ("Buhid" #x1740 #x175F)
+    ("Tagbanwa" #x1760 #x177F)
+    ("Khmer" #x1780 #x17FF)
+    ("Mongolian" #x1800 #x18AF)
+    ("Latin Extended Additional" #x1E00 #x1EFF)
+    ("Greek Extended" #x1F00 #x1FFF)
+    ("General Punctuation" #x2000 #x206F)
+    ("Superscripts and Subscripts" #x2070 #x209F)
+    ("Currency Symbols" #x20A0 #x20CF)
+    ("Combining Diacritical Marks for Symbols" #x20D0 #x20FF)
+    ("Letterlike Symbols" #x2100 #x214F)
+    ("Number Forms" #x2150 #x218F)
+    ("Arrows" #x2190 #x21FF)
+    ("Mathematical Operators" #x2200 #x22FF)
+    ("Miscellaneous Technical" #x2300 #x23FF)
+    ("Control Pictures" #x2400 #x243F)
+    ("Optical Character Recognition" #x2440 #x245F)
+    ("Enclosed Alphanumerics" #x2460 #x24FF)
+    ("Box Drawing" #x2500 #x257F)
+    ("Block Elements" #x2580 #x259F)
+    ("Geometric Shapes" #x25A0 #x25FF)
+    ("Miscellaneous Symbols" #x2600 #x26FF)
+    ("Dingbats" #x2700 #x27BF)
+    ("Miscellaneous Mathematical Symbols-A" #x27C0 #x27EF)
+    ("Supplemental Arrows-A" #x27F0 #x27FF)
+    ("Braille Patterns" #x2800 #x28FF)
+    ("Supplemental Arrows-B" #x2900 #x297F)
+    ("Miscellaneous Mathematical Symbols-B" #x2980 #x29FF)
+    ("Supplemental Mathematical Operators" #x2A00 #x2AFF)
+    ("CJK Radicals Supplement" #x2E80 #x2EFF)
+    ("Kangxi Radicals" #x2F00 #x2FDF)
+    ("Ideographic Description Characters" #x2FF0 #x2FFF)
+    ("CJK Symbols and Punctuation" #x3000 #x303F)
+    ("Hiragana" #x3040 #x309F)
+    ("Katakana" #x30A0 #x30FF)
+    ("Bopomofo" #x3100 #x312F)
+    ("Hangul Compatibility Jamo" #x3130 #x318F)
+    ("Kanbun" #x3190 #x319F)
+    ("Bopomofo Extended" #x31A0 #x31BF)
+    ("Katakana Phonetic Extensions" #x31F0 #x31FF)
+    ("Enclosed CJK Letters and Months" #x3200 #x32FF)
+    ("CJK Compatibility" #x3300 #x33FF)
+    ("CJK Unified Ideographs Extension A" #x3400 #x4DBF)
+    ;;("CJK Unified Ideographs" #x4E00 #x9FFF)
+    ("Yi Syllables" #xA000 #xA48F)
+    ("Yi Radicals" #xA490 #xA4CF)
+    ;;("Hangul Syllables" #xAC00 #xD7AF)
+    ;;("High Surrogates" #xD800 #xDB7F)
+    ;;("High Private Use Surrogates" #xDB80 #xDBFF)
+    ;;("Low Surrogates" #xDC00 #xDFFF)
+    ;;("Private Use Area" #xE000 #xF8FF)
+    ;;("CJK Compatibility Ideographs" #xF900 #xFAFF)
+    ("Alphabetic Presentation Forms" #xFB00 #xFB4F)
+    ("Arabic Presentation Forms-A" #xFB50 #xFDFF)
+    ("Variation Selectors" #xFE00 #xFE0F)
+    ("Combining Half Marks" #xFE20 #xFE2F)
+    ("CJK Compatibility Forms" #xFE30 #xFE4F)
+    ("Small Form Variants" #xFE50 #xFE6F)
+    ("Arabic Presentation Forms-B" #xFE70 #xFEFF)
+    ("Halfwidth and Fullwidth Forms" #xFF00 #xFFEF)
+    ("Specials" #xFFF0 #xFFFF)
+    ("Old Italic" #x10300 #x1032F)
+    ("Gothic" #x10330 #x1034F)
+    ("Deseret" #x10400 #x1044F)
+    ("Byzantine Musical Symbols" #x1D000 #x1D0FF)
+    ("Musical Symbols" #x1D100 #x1D1FF)
+    ("Mathematical Alphanumeric Symbols" #x1D400 #x1D7FF)
+    ;;("CJK Unified Ideographs Extension B" #x20000 #x2A6DF)
+    ;;("CJK Compatibility Ideographs Supplement" #x2F800 #x2FA1F)
+    ("Tags" #xE0000 #xE007F)
+    ;;("Supplementary Private Use Area-A" #xF0000 #xFFFFF)
+    ;;("Supplementary Private Use Area-B" #x100000 #x10FFFF)
+    )
+  "List of Unicode blocks.
+For each block there is a list (NAME FIRST LAST), where
+NAME is a string giving the offical name of the block,
+FIRST is the first code-point and LAST is the last code-point.
+Blocks containing only characters with algorithmic names or no names
+are omitted.")
+
+(defun nxml-unicode-block-char-name-set (name)
+  "Return a symbol for a block whose offical Unicode name is NAME.
+The symbol is generated by downcasing and replacing each space
+by a hyphen."
+  (intern (replace-regexp-in-string " " "-" (downcase name))))
+
+;; This is intended to be a superset of the coverage
+;; of existing standard entity sets.
+(defvar nxml-enabled-unicode-blocks-default
+  '(basic-latin
+    latin-1-supplement
+    latin-extended-a
+    latin-extended-b
+    ipa-extensions
+    spacing-modifier-letters
+    combining-diacritical-marks
+    greek-and-coptic
+    cyrillic
+    general-punctuation
+    superscripts-and-subscripts
+    currency-symbols
+    combining-diacritical-marks-for-symbols
+    letterlike-symbols
+    number-forms
+    arrows
+    mathematical-operators
+    miscellaneous-technical
+    control-pictures
+    optical-character-recognition
+    enclosed-alphanumerics
+    box-drawing
+    block-elements
+    geometric-shapes
+    miscellaneous-symbols
+    dingbats
+    miscellaneous-mathematical-symbols-a
+    supplemental-arrows-a
+    supplemental-arrows-b
+    miscellaneous-mathematical-symbols-b
+    supplemental-mathematical-operators
+    cjk-symbols-and-punctuation
+    alphabetic-presentation-forms
+    variation-selectors
+    small-form-variants
+    specials
+    mathematical-alphanumeric-symbols)
+  "Default value for `nxml-enabled-unicode-blocks'.")
+
+(let ((dir (file-name-directory load-file-name)))
+  (mapcar (lambda (block)
+            (let ((sym (nxml-unicode-block-char-name-set (car block))))
+              (nxml-autoload-char-name-set
+               sym
+               (expand-file-name
+                (format "char-name/unicode/%05X-%05X"
+                        (nth 1 block)
+                        (nth 2 block))
+                dir))))
+          nxml-unicode-blocks))
+
+(defvar nxml-enable-unicode-char-name-sets-flag nil)
+
+(defcustom nxml-enabled-unicode-blocks nxml-enabled-unicode-blocks-default
+  "List of Unicode blocks for which Unicode character names are enabled.
+Each block is identified by a symbol derived from the name
+of the block by downcasing and replacing each space by a hyphen."
+  :set (lambda (sym value)
+         (set-default 'nxml-enabled-unicode-blocks value)
+         (when nxml-enable-unicode-char-name-sets-flag
+           (nxml-enable-unicode-char-name-sets-1)))
+  :type (cons 'set
+              (mapcar (lambda (block)
+                        `(const :tag ,(format "%s (%04X-%04X)"
+                                              (nth 0 block)
+                                              (nth 1 block)
+                                              (nth 2 block))
+                                ,(nxml-unicode-block-char-name-set
+                                  (nth 0 block))))
+                      nxml-unicode-blocks)))
+
+;;;###autoload
+(defun nxml-enable-unicode-char-name-sets ()
+  "Enable the use of Unicode standard names for characters.
+The Unicode blocks for which names are enabled is controlled by
+the variable `nxml-enabled-unicode-blocks'."
+  (interactive)
+  (setq nxml-char-name-ignore-case t)
+  (setq nxml-enable-unicode-char-name-sets-flag t)
+  (nxml-enable-unicode-char-name-sets-1))
+
+(defun nxml-enable-unicode-char-name-sets-1 ()
+  (mapcar (lambda (block)
+            (nxml-disable-char-name-set
+             (nxml-unicode-block-char-name-set (car block))))
+          nxml-unicode-blocks)
+  (mapcar (lambda (nameset)
+            (nxml-enable-char-name-set nameset))
+          nxml-enabled-unicode-blocks))
+
+(provide 'nxml-uchnm)
+
+;;; nxml-uchnm.el ends here
diff --git a/lisp/nxml/nxml-util.el b/lisp/nxml/nxml-util.el
new file mode 100644
index 00000000000..070bdf8ea99
--- /dev/null
+++ b/lisp/nxml/nxml-util.el
@@ -0,0 +1,100 @@
+;;; nxml-util.el --- utility functions for nxml-*.el
+
+;; Copyright (C) 2003 Free Software Foundation, Inc.
+
+;; Author: James Clark
+;; Keywords: XML
+
+;; This program is free software; you can redistribute it and/or
+;; modify it under the terms of the GNU General Public License as
+;; published by the Free Software Foundation; either version 2 of
+;; the License, or (at your option) any later version.
+
+;; This program is distributed in the hope that it will be
+;; useful, but WITHOUT ANY WARRANTY; without even the implied
+;; warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+;; PURPOSE.  See the GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public
+;; License along with this program; if not, write to the Free
+;; Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+;; MA 02111-1307 USA
+
+;;; Commentary:
+
+;;; Code:
+
+(defun nxml-make-namespace (str)
+  "Return a symbol for the namespace URI STR.
+STR must be a string. If STR is the empty string, return nil.
+Otherwise, return the symbol whose name is STR prefixed with a colon."
+  (if (string-equal str "")
+      nil
+    (intern (concat ":" str))))
+
+(defun nxml-namespace-name (ns)
+  "Return the namespace URI corresponding to the symbol NS.
+This is the inverse of `nxml-make-namespace'."
+  (and ns (substring (symbol-name ns) 1)))
+
+(defconst nxml-xml-namespace-uri 
+  (nxml-make-namespace "http://www.w3.org/XML/1998/namespace"))
+
+(defconst nxml-xmlns-namespace-uri
+  (nxml-make-namespace "http://www.w3.org/2000/xmlns/"))
+
+(defmacro nxml-with-unmodifying-text-property-changes (&rest body)
+  "Evaluate BODY without any text property changes modifying the buffer.
+Any text properties changes happen as usual but the changes are not treated as
+modifications to the buffer."
+  (let ((modified (make-symbol "modified")))
+    `(let ((,modified (buffer-modified-p))
+           (inhibit-read-only t)
+           (inhibit-modification-hooks t)
+           (buffer-undo-list t)
+           (deactivate-mark nil)
+           ;; Apparently these avoid file locking problems.
+           (buffer-file-name nil)
+           (buffer-file-truename nil))
+       (unwind-protect
+           (progn ,@body)
+         (unless ,modified
+           (restore-buffer-modified-p nil))))))
+
+(put 'nxml-with-unmodifying-text-property-changes 'lisp-indent-function 0)
+(def-edebug-spec nxml-with-unmodifying-text-property-changes t)
+
+(defmacro nxml-with-invisible-motion (&rest body)
+  "Evaluate body without calling any point motion hooks."
+  `(let ((inhibit-point-motion-hooks t))
+     ,@body))
+
+(put 'nxml-with-invisible-motion 'lisp-indent-function 0)
+(def-edebug-spec nxml-with-invisible-motion t)
+
+(defun nxml-display-file-parse-error (err)
+  (let* ((filename (nth 1 err))
+         (buffer (find-file-noselect filename))
+         (pos (nth 2 err))
+         (message (nth 3 err)))
+    (pop-to-buffer buffer)
+    ;; What's the right thing to do if the buffer's modified?
+    ;; The position in the saved file could be completely different.
+    (goto-char (if (buffer-modified-p) 1 pos))
+    (error "%s" message)))
+
+(defun nxml-signal-file-parse-error (file pos message &optional error-symbol)
+  (signal (or error-symbol 'nxml-file-parse-error)
+          (list file pos message)))
+
+(put 'nxml-file-parse-error
+     'error-conditions
+     '(error nxml-file-parse-error))
+
+(put 'nxml-parse-file-error
+     'error-message
+     "Error parsing file")
+
+(provide 'nxml-util)
+
+;;; nxml-util.el ends here
diff --git a/lisp/nxml/rng-auto.el b/lisp/nxml/rng-auto.el
new file mode 100644
index 00000000000..a0f95fc51a6
--- /dev/null
+++ b/lisp/nxml/rng-auto.el
@@ -0,0 +1,244 @@
+;;; rng-auto.el --- automatically extracted autoloads for RELAX NG
+
+;; Copyright (C) 2003 Free Software Foundation, Inc.
+
+;; Author: James Clark
+;; Keywords: XML, RelaxNG
+
+;; This program is free software; you can redistribute it and/or
+;; modify it under the terms of the GNU General Public License as
+;; published by the Free Software Foundation; either version 2 of
+;; the License, or (at your option) any later version.
+
+;; This program is distributed in the hope that it will be
+;; useful, but WITHOUT ANY WARRANTY; without even the implied
+;; warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+;; PURPOSE.  See the GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public
+;; License along with this program; if not, write to the Free
+;; Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+;; MA 02111-1307 USA
+
+(setq nxml-version "20041004")
+
+(when (featurep 'mucs)
+  (error "nxml-mode is not compatible with Mule-UCS"))
+
+(let* ((dir (file-name-directory load-file-name))
+       (schema-dir (file-name-as-directory
+                    (expand-file-name "schemas" data-directory))))
+  (unless (member dir load-path)
+    (setq load-path (cons dir load-path)))
+  (setq rng-schema-locating-files-default
+        (list "schemas.xml"
+              (abbreviate-file-name
+               (expand-file-name "schemas.xml" schema-dir))))
+  (setq rng-schema-locating-file-schema-file
+        (expand-file-name "locate.rnc" schema-dir)))
+
+;; Users shouldn't edit this.
+;; Instead they should customize `rng-preferred-prefix-alist'.
+
+(setq rng-preferred-prefix-alist-default
+      ;; For XHTML and RELAX NG, prefer no prefix
+      '(("http://www.w3.org/1999/XSL/Transform" . "xsl")
+        ("http://www.w3.org/1999/02/22-rdf-syntax-ns#" . "rdf")))
+
+(add-hook 'nxml-mode-hook 'rng-nxml-mode-init)
+(add-hook 'nxml-mode-hook 'nxml-enable-unicode-char-name-sets)
+
+(setq rng-schema-loader-alist '(("rnc" . rng-c-load-schema)))
+
+(require 'nxml-enc)
+;; Install our own `set-auto-coding-function'.
+(nxml-start-auto-coding)
+
+
+;;;### (autoloads (nxml-glyph-display-string) "nxml-glyph" "nxml-glyph.el"
+;;;;;;  (16278 18099))
+;;; Generated autoloads from nxml-glyph.el
+
+(autoload (quote nxml-glyph-display-string) "nxml-glyph" "\
+Return a string that can display a glyph for Unicode code-point N.
+FACE gives the face that will be used for displaying the string.
+Return nil if the face cannot display a glyph for N." nil nil)
+
+;;;***
+
+;;;### (autoloads (nxml-mode) "nxml-mode" "nxml-mode.el" (16702 54517))
+;;; Generated autoloads from nxml-mode.el
+
+(autoload (quote nxml-mode) "nxml-mode" "\
+Major mode for editing XML.
+
+Syntax highlighting is performed unless the variable
+`nxml-syntax-highlight-flag' is nil.
+
+\\[nxml-finish-element] finishes the current element by inserting an end-tag.
+C-c C-i closes a start-tag with `>' and then inserts a balancing end-tag
+leaving point between the start-tag and end-tag. 
+\\[nxml-balanced-close-start-tag-block] is similar but for block rather than inline elements:
+the start-tag, point, and end-tag are all left on separate lines.
+If `nxml-slash-auto-complete-flag' is non-nil, then inserting a `</'
+automatically inserts the rest of the end-tag.
+
+\\[nxml-complete] performs completion on the symbol preceding point.
+
+\\[nxml-dynamic-markup-word] uses the contents of the current buffer
+to choose a tag to put around the word preceding point.
+
+Validation is provided by the related minor-mode `rng-validate-mode'.
+This also makes completion schema- and context- sensitive.  Element
+names, attribute names, attribute values and namespace URIs can all be
+completed. By default, `rng-validate-mode' is automatically enabled by
+`rng-nxml-mode-init' which is normally added to `nxml-mode-hook'. You
+can toggle it using \\[rng-validate-mode].
+
+\\[indent-for-tab-command] indents the current line appropriately.
+This can be customized using the variable `nxml-child-indent'
+and the variable `nxml-attribute-indent'.
+
+\\[nxml-insert-named-char] inserts a character reference using
+the character's name (by default, the Unicode name). \\[universal-argument] \\[nxml-insert-named-char]
+inserts the character directly.
+
+The Emacs commands that normally operate on balanced expressions will
+operate on XML markup items.  Thus \\[forward-sexp] will move forward
+across one markup item; \\[backward-sexp] will move backward across
+one markup item; \\[kill-sexp] will kill the following markup item;
+\\[mark-sexp] will mark the following markup item.  By default, each
+tag each treated as a single markup item; to make the complete element
+be treated as a single markup item, set the variable
+`nxml-sexp-element-flag' to t.  For more details, see the function
+`nxml-forward-balanced-item'.
+
+\\[nxml-backward-up-element] and \\[nxml-down-element] move up and
+down the element structure.
+
+Many aspects this mode can be customized using
+\\[customize-group] nxml RET." t nil)
+
+;;;***
+
+;;;### (autoloads (nxml-enable-unicode-char-name-sets) "nxml-uchnm"
+;;;;;;  "nxml-uchnm.el" (16270 38352))
+;;; Generated autoloads from nxml-uchnm.el
+
+(autoload (quote nxml-enable-unicode-char-name-sets) "nxml-uchnm" "\
+Enable the use of Unicode standard names for characters.
+The Unicode blocks for which names are enabled is controlled by
+the variable `nxml-enabled-unicode-blocks'." t nil)
+
+;;;***
+
+;;;### (autoloads (rng-c-load-schema) "rng-cmpct" "rng-cmpct.el"
+;;;;;;  (16280 36493))
+;;; Generated autoloads from rng-cmpct.el
+
+(autoload (quote rng-c-load-schema) "rng-cmpct" "\
+Load a schema in RELAX NG compact syntax from FILENAME.
+Return a pattern." nil nil)
+
+;;;***
+
+;;;### (autoloads (rng-write-version rng-format-manual rng-byte-compile-load
+;;;;;;  rng-update-autoloads) "rng-maint" "rng-maint.el" (16279 23645))
+;;; Generated autoloads from rng-maint.el
+
+(autoload (quote rng-update-autoloads) "rng-maint" "\
+Update the autoloads in rng-auto.el." t nil)
+
+(autoload (quote rng-byte-compile-load) "rng-maint" "\
+Byte-compile and load all of the RELAX NG library in an appropriate order." t nil)
+
+(autoload (quote rng-format-manual) "rng-maint" "\
+Create manual.texi from manual.xml." t nil)
+
+(autoload (quote rng-write-version) "rng-maint" nil nil nil)
+
+;;;***
+
+;;;### (autoloads (rng-nxml-mode-init) "rng-nxml" "rng-nxml.el" (16294
+;;;;;;  8571))
+;;; Generated autoloads from rng-nxml.el
+
+(autoload (quote rng-nxml-mode-init) "rng-nxml" "\
+Initialize `nxml-mode' to take advantage of `rng-validate-mode'.
+This is typically called from `nxml-mode-hook'.
+Validation will be enabled if `rng-nxml-auto-validate-flag' is non-nil." t nil)
+
+;;;***
+
+;;;### (autoloads (rng-validate-mode) "rng-valid" "rng-valid.el"
+;;;;;;  (16664 9855))
+;;; Generated autoloads from rng-valid.el
+
+(autoload (quote rng-validate-mode) "rng-valid" "\
+Minor mode performing continual validation against a RELAX NG schema.
+
+Checks whether the buffer is a well-formed XML 1.0 document,
+conforming to the XML Namespaces Recommendation and valid against a
+RELAX NG schema. The mode-line indicates whether it is or not.  Any
+parts of the buffer that cause it not to be are considered errors and
+are highlighted with `rng-error-face'. A description of each error is
+available as a tooltip.  \\[rng-next-error] goes to the next error
+after point. Clicking mouse-1 on the word `Invalid' in the mode-line
+goes to the first error in the buffer. If the buffer changes, then it
+will be automatically rechecked when Emacs becomes idle; the
+rechecking will be paused whenever there is input pending..
+
+By default, uses a vacuous schema that allows any well-formed XML
+document. A schema can be specified explictly using
+\\[rng-set-schema-file-and-validate], or implicitly based on the buffer's
+file name or on the root element name.  In each case the schema must
+be a RELAX NG schema using the compact schema (such schemas
+conventionally have a suffix of `.rnc').  The variable
+`rng-schema-locating-files' specifies files containing rules
+to use for finding the schema." t nil)
+
+;;;***
+
+;;;### (autoloads (rng-xsd-compile) "rng-xsd" "rng-xsd.el" (16216
+;;;;;;  26672))
+;;; Generated autoloads from rng-xsd.el
+
+(put (quote http://www\.w3\.org/2001/XMLSchema-datatypes) (quote rng-dt-compile) (quote rng-xsd-compile))
+
+(autoload (quote rng-xsd-compile) "rng-xsd" "\
+Provides W3C XML Schema as a RELAX NG datatypes library. NAME is a
+symbol giving the local name of the datatype.  PARAMS is a list of
+pairs (PARAM-NAME . PARAM-VALUE) where PARAM-NAME is a symbol giving
+the name of the parameter and PARAM-VALUE is a string giving its
+value.  If NAME or PARAMS are invalid, it calls rng-dt-error passing
+it arguments in the same style as format; the value from rng-dt-error
+will be returned.  Otherwise, it returns a list.  The first member of
+the list is t if any string is a legal value for the datatype and nil
+otherwise.  The second argument is a symbol; this symbol will be
+called as a function passing it a string followed by the remaining
+members of the list.  The function must return an object representing
+the value of the datatype that was represented by the string, or nil
+if the string is not a representation of any value. The object
+returned can be any convenient non-nil value, provided that, if two
+strings represent the same value, the returned objects must be equal." nil nil)
+
+;;;***
+
+;;;### (autoloads (xmltok-get-declared-encoding-position) "xmltok"
+;;;;;;  "xmltok.el" (16664 8418))
+;;; Generated autoloads from xmltok.el
+
+(autoload (quote xmltok-get-declared-encoding-position) "xmltok" "\
+Return the position of the encoding in the XML declaration at point.
+If there is a well-formed XML declaration starting at point and it
+contains an encoding declaration, then return (START . END)
+where START and END are the positions of the start and the end
+of the encoding name; if there is no encoding declaration return
+the position where and encoding declaration could be inserted.
+If there is XML that is not well-formed that looks like an XML declaration,
+return nil.  Otherwise, return t.
+If LIMIT is non-nil, then do not consider characters beyond LIMIT." nil nil)
+
+;;;***
+
+;;; rng-auto.el ends here
diff --git a/lisp/nxml/rng-cmpct.el b/lisp/nxml/rng-cmpct.el
new file mode 100644
index 00000000000..29699b60122
--- /dev/null
+++ b/lisp/nxml/rng-cmpct.el
@@ -0,0 +1,937 @@
+;;; rng-cmpct.el --- parsing of RELAX NG Compact Syntax schemas
+
+;; Copyright (C) 2003 Free Software Foundation, Inc.
+
+;; Author: James Clark
+;; Keywords: XML, RelaxNG
+
+;; This program is free software; you can redistribute it and/or
+;; modify it under the terms of the GNU General Public License as
+;; published by the Free Software Foundation; either version 2 of
+;; the License, or (at your option) any later version.
+
+;; This program is distributed in the hope that it will be
+;; useful, but WITHOUT ANY WARRANTY; without even the implied
+;; warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+;; PURPOSE.  See the GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public
+;; License along with this program; if not, write to the Free
+;; Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+;; MA 02111-1307 USA
+
+;;; Commentary:
+
+;; This parses a RELAX NG Compact Syntax schema into the form
+;; specified in rng-pttrn.el.
+;;
+;; RELAX NG Compact Syntax is specified by
+;;    http://relaxng.org/compact.html
+;;
+;; This file uses the prefix "rng-c-".
+
+;;; Code:
+
+(require 'nxml-util)
+(require 'rng-util)
+(require 'rng-uri)
+(require 'rng-pttrn)
+
+;;;###autoload
+(defun rng-c-load-schema (filename)
+  "Load a schema in RELAX NG compact syntax from FILENAME.
+Return a pattern."
+  (rng-c-parse-file filename))
+
+;;; Error handling
+
+(put 'rng-c-incorrect-schema
+     'error-conditions
+     '(error rng-error nxml-file-parse-error rng-c-incorrect-schema))
+
+(put 'rng-c-incorrect-schema
+     'error-message
+     "Incorrect schema")
+
+(defun rng-c-signal-incorrect-schema (filename pos message)
+  (nxml-signal-file-parse-error filename
+                                pos
+                                message
+                                'rng-c-incorrect-schema))
+
+;;; Lexing
+
+(defconst rng-c-keywords
+  '("attribute"
+    "default"
+    "datatypes"
+    "div"
+    "element"
+    "empty"
+    "external"
+    "grammar"
+    "include"
+    "inherit"
+    "list"
+    "mixed"
+    "namespace"
+    "notAllowed"
+    "parent"
+    "start"
+    "string"
+    "text"
+    "token")
+  "List of strings that are keywords in the compact syntax.")
+
+(defconst rng-c-anchored-keyword-re
+  (concat "\\`\\(" (regexp-opt rng-c-keywords) "\\)\\'")
+  "Regular expression to match a keyword in the compact syntax.")
+
+(defvar rng-c-syntax-table nil
+  "Syntax table for parsing the compact syntax.")
+
+(if rng-c-syntax-table
+    ()
+  (setq rng-c-syntax-table (make-syntax-table))
+  (modify-syntax-entry ?# "<" rng-c-syntax-table)
+  (modify-syntax-entry ?\n ">" rng-c-syntax-table)
+  (modify-syntax-entry ?- "w" rng-c-syntax-table)
+  (modify-syntax-entry ?. "w" rng-c-syntax-table)
+  (modify-syntax-entry ?_ "w" rng-c-syntax-table)
+  (modify-syntax-entry ?: "_" rng-c-syntax-table))
+
+(defconst rng-c-literal-1-re
+  "'\\(''\\([^']\\|'[^']\\|''[^']\\)*''\\|[^'\n]*\\)'"
+  "Regular expression to match a single-quoted literal.")
+
+(defconst rng-c-literal-2-re
+  (replace-regexp-in-string "'" "\"" rng-c-literal-1-re)
+  "Regular expression to match a double-quoted literal.")
+
+(defconst rng-c-ncname-re "\\w+")
+
+(defconst rng-c-anchored-ncname-re
+  (concat "\\`" rng-c-ncname-re "\\'"))
+
+(defconst rng-c-token-re
+  (concat "[&|]=" "\\|"
+          "[][()|&,*+?{}~=-]" "\\|"
+          rng-c-literal-1-re "\\|"
+          rng-c-literal-2-re "\\|"
+          rng-c-ncname-re "\\(:\\(\\*\\|" rng-c-ncname-re "\\)\\)?" "\\|"
+          "\\\\" rng-c-ncname-re "\\|"
+          ">>")
+  "Regular expression to match a token in the compact syntax.")
+
+(defun rng-c-init-buffer ()
+  (setq case-fold-search nil) ; automatically becomes buffer-local when set
+  (set-buffer-multibyte t)
+  (set-syntax-table rng-c-syntax-table))
+
+(defvar rng-c-current-token nil)
+(make-variable-buffer-local 'rng-c-current-token)
+
+(defun rng-c-advance ()
+  (cond ((looking-at rng-c-token-re)
+         (setq rng-c-current-token (match-string 0))
+         (goto-char (match-end 0))
+         (forward-comment (point-max)))
+        ((= (point) (point-max))
+         (setq rng-c-current-token ""))
+        (t (rng-c-error "Invalid token"))))
+
+(defconst rng-c-anchored-datatype-name-re
+  (concat "\\`" rng-c-ncname-re ":"  rng-c-ncname-re "\\'"))
+
+(defsubst rng-c-current-token-keyword-p ()
+  (string-match rng-c-anchored-keyword-re rng-c-current-token))
+
+(defsubst rng-c-current-token-prefixed-name-p ()
+  (string-match rng-c-anchored-datatype-name-re rng-c-current-token))
+
+(defsubst rng-c-current-token-literal-p ()
+  (string-match "\\`['\"]" rng-c-current-token))
+
+(defsubst rng-c-current-token-quoted-identifier-p ()
+  (string-match "\\`\\\\" rng-c-current-token))
+
+(defsubst rng-c-current-token-ncname-p ()
+  (string-match rng-c-anchored-ncname-re rng-c-current-token))
+
+(defsubst rng-c-current-token-ns-name-p ()
+  (let ((len (length rng-c-current-token)))
+    (and (> len 0)
+         (= (aref rng-c-current-token (- len 1)) ?*))))
+
+;;; Namespaces
+
+(defvar rng-c-inherit-namespace nil)
+
+(defvar rng-c-default-namespace nil)
+
+(defvar rng-c-default-namespace-declared nil)
+
+(defvar rng-c-namespace-decls nil
+  "Alist of namespace declarations.")
+
+(defconst rng-c-no-namespace nil)
+
+(defun rng-c-declare-standard-namespaces ()
+  (setq rng-c-namespace-decls
+        (cons (cons "xml" nxml-xml-namespace-uri)
+              rng-c-namespace-decls))
+  (when (and (not rng-c-default-namespace-declared)
+             rng-c-inherit-namespace)
+    (setq rng-c-default-namespace rng-c-inherit-namespace)))
+
+(defun rng-c-expand-name (prefixed-name)
+  (let ((i (string-match ":" prefixed-name)))
+    (rng-make-name (rng-c-lookup-prefix (substring prefixed-name
+                                                   0
+                                                   i))
+                   (substring prefixed-name (+ i 1)))))
+
+(defun rng-c-lookup-prefix (prefix)
+  (let ((binding (assoc prefix rng-c-namespace-decls)))
+    (or binding (rng-c-error "Undefined prefix %s" prefix))
+    (cdr binding)))
+
+(defun rng-c-unqualified-namespace (attribute)
+  (if attribute
+      rng-c-no-namespace
+    rng-c-default-namespace))
+
+(defun rng-c-make-context ()
+  (cons rng-c-default-namespace rng-c-namespace-decls))
+
+;;; Datatypes
+
+(defconst rng-string-datatype
+  (rng-make-datatype rng-builtin-datatypes-uri "string"))
+
+(defconst rng-token-datatype
+  (rng-make-datatype rng-builtin-datatypes-uri "token"))
+
+(defvar rng-c-datatype-decls nil
+  "Alist of datatype declarations.
+Contains a list of pairs (PREFIX . URI) where PREFIX is a string
+and URI is a symbol.")
+
+(defun rng-c-declare-standard-datatypes ()
+  (setq rng-c-datatype-decls
+        (cons (cons "xsd" rng-xsd-datatypes-uri)
+              rng-c-datatype-decls)))
+
+(defun rng-c-lookup-datatype-prefix (prefix)
+  (let ((binding (assoc prefix rng-c-datatype-decls)))
+    (or binding (rng-c-error "Undefined prefix %s" prefix))
+    (cdr binding)))
+
+(defun rng-c-expand-datatype (prefixed-name)
+  (let ((i (string-match ":" prefixed-name)))
+    (rng-make-datatype
+     (rng-c-lookup-datatype-prefix (substring prefixed-name 0 i))
+     (substring prefixed-name (+ i 1)))))
+
+;;; Grammars
+
+(defvar rng-c-current-grammar nil)
+(defvar rng-c-parent-grammar nil)
+
+(defun rng-c-make-grammar ()
+  (make-hash-table :test 'equal))
+
+(defconst rng-c-about-override-slot 0)
+(defconst rng-c-about-combine-slot 1)
+
+(defun rng-c-lookup-create (name grammar)
+  "Return a def object for NAME.  A def object is a pair
+\(ABOUT . REF) where REF is returned by `rng-make-ref'.  ABOUT is a
+two-element vector [OVERRIDE COMBINE].  COMBINE is either nil, choice
+or interleave.  OVERRIDE is either nil, require or t."
+  (let ((def (gethash name grammar)))
+    (if def
+        def
+      (progn 
+        (setq def (cons (vector nil nil) (rng-make-ref name)))
+        (puthash name def grammar)
+        def))))
+
+(defun rng-c-make-ref (name)
+  (or rng-c-current-grammar
+      (rng-c-error "Reference not in a grammar"))
+  (cdr (rng-c-lookup-create name rng-c-current-grammar)))
+
+(defun rng-c-make-parent-ref (name)
+  (or rng-c-parent-grammar
+      (rng-c-error "Reference to non-existent parent grammar"))
+  (cdr (rng-c-lookup-create name rng-c-parent-grammar)))
+
+(defvar rng-c-overrides nil
+  "Contains a list of (NAME . DEF) pairs.")
+
+(defun rng-c-merge-combine (def combine name)
+  (let* ((about (car def))
+         (current-combine (aref about rng-c-about-combine-slot)))
+    (if combine
+        (if current-combine
+            (or (eq combine current-combine)
+                (rng-c-error "Inconsistent combine for %s" name))
+          (aset about rng-c-about-combine-slot combine))
+      current-combine)))
+
+(defun rng-c-prepare-define (name combine in-include)
+  (let* ((def (rng-c-lookup-create name rng-c-current-grammar))
+         (about (car def))
+         (overridden (aref about rng-c-about-override-slot)))
+    (and in-include
+         (setq rng-c-overrides (cons (cons name def) rng-c-overrides)))
+    (cond (overridden (and (eq overridden 'require)
+                           (aset about rng-c-about-override-slot t))
+                      nil)
+          (t (setq combine (rng-c-merge-combine def combine name))
+             (and (rng-ref-get (cdr def))
+                  (not combine)
+                  (rng-c-error "Duplicate definition of %s" name))
+             def))))
+
+(defun rng-c-start-include (overrides)
+  (mapcar (lambda (name-def)
+            (let* ((def (cdr name-def))
+                   (about (car def))
+                   (save (aref about rng-c-about-override-slot)))
+              (aset about rng-c-about-override-slot 'require)
+              (cons save name-def)))
+          overrides))
+
+(defun rng-c-end-include (overrides)
+  (mapcar (lambda (o)
+            (let* ((saved (car o))
+                   (name-def (cdr o))
+                   (name (car name-def))
+                   (def (cdr name-def))
+                   (about (car def)))
+              (and (eq (aref about rng-c-about-override-slot) 'require)
+                   (rng-c-error "Definition of %s in include did not override definition in included file" name))
+              (aset about rng-c-about-override-slot saved)))
+          overrides))
+
+(defun rng-c-define (def value)
+  (and def
+       (let ((current-value (rng-ref-get (cdr def))))
+         (rng-ref-set (cdr def)
+                      (if current-value
+                          (if (eq (aref (car def) rng-c-about-combine-slot)
+                                  'choice)
+                              (rng-make-choice (list current-value value))
+                            (rng-make-interleave (list current-value value)))
+                        value)))))
+
+(defun rng-c-finish-grammar ()
+  (maphash (lambda (key def)
+             (or (rng-ref-get (cdr def))
+                 (rng-c-error "Reference to undefined pattern %s" key)))
+           rng-c-current-grammar)
+  (rng-ref-get (cdr (or (gethash 'start rng-c-current-grammar)
+                        (rng-c-error "No definition of start")))))
+
+;;; Parsing
+
+(defvar rng-c-escape-positions nil)
+(make-variable-buffer-local 'rng-c-escape-positions)
+
+(defvar rng-c-file-name nil)
+(make-variable-buffer-local 'rng-c-file-name)
+
+(defvar rng-c-file-index nil)
+
+(defun rng-c-parse-file (filename &optional context)
+  (save-excursion
+    (set-buffer (get-buffer-create (rng-c-buffer-name context)))
+    (erase-buffer)
+    (rng-c-init-buffer)
+    (setq rng-c-file-name
+          (car (insert-file-contents filename)))
+    (setq rng-c-escape-positions nil)
+    (rng-c-process-escapes)
+    (rng-c-parse-top-level context)))
+
+(defun rng-c-buffer-name (context)
+  (concat " *RNC Input"
+          (if context
+              (concat "<"
+                      (number-to-string (setq rng-c-file-index
+                                              (1+ rng-c-file-index)))
+                      ">*")
+            (setq rng-c-file-index 1)
+            "*")))
+
+(defun rng-c-process-escapes ()
+  ;; Check for any nuls, since we will use nul chars
+  ;; for internal purposes.
+  (let ((pos (search-forward "\C-@" nil t)))
+    (and pos
+         (rng-c-error "Nul character found (binary file?)")))
+  (let ((offset 0))
+    (while (re-search-forward "\\\\x+{\\([0-9a-fA-F]+\\)}"
+                              (point-max)
+                              t)
+      (let* ((ch (decode-char 'ucs (string-to-number (match-string 1) 16))))
+        (if (and ch (> ch 0))
+            (let ((begin (match-beginning 0))
+                  (end (match-end 0)))
+              (delete-region begin end)
+              ;; Represent an escaped newline by nul, so
+              ;; that we can distinguish it from a literal newline.
+              ;; We will translate it back into a real newline later.
+              (insert (if (eq ch ?\n) 0 ch))
+              (setq offset (+ offset (- end begin 1)))
+              (setq rng-c-escape-positions
+                    (cons (cons (point) offset)
+                          rng-c-escape-positions)))
+          (rng-c-error "Invalid character escape")))))
+  (goto-char 1))
+
+(defun rng-c-translate-position (pos)
+  (let ((tem rng-c-escape-positions))
+    (while (and tem
+                (> (caar tem) pos))
+      (setq tem (cdr tem)))
+    (if tem
+        (+ pos (cdar tem))
+      pos)))
+
+(defun rng-c-error (&rest args)
+  (rng-c-signal-incorrect-schema rng-c-file-name
+                                 (rng-c-translate-position (point))
+                                 (apply 'format args)))
+
+(defun rng-c-parse-top-level (context)
+  (let ((rng-c-namespace-decls nil)
+        (rng-c-default-namespace nil)
+        (rng-c-datatype-decls nil))
+    (goto-char (point-min))
+    (forward-comment (point-max))
+    (rng-c-advance)
+    (rng-c-parse-decls)
+    (let ((p (if (eq context 'include)
+                 (if (rng-c-implicit-grammar-p)
+                     (rng-c-parse-grammar-body "")
+                   (rng-c-parse-included-grammar))
+               (if (rng-c-implicit-grammar-p)
+                   (rng-c-parse-implicit-grammar)
+                 (rng-c-parse-pattern)))))
+      (or (string-equal rng-c-current-token "")
+          (rng-c-error "Unexpected characters after pattern"))
+      p)))
+
+(defun rng-c-parse-included-grammar ()
+  (or (string-equal rng-c-current-token "grammar")
+      (rng-c-error "Included schema is not a grammar"))
+  (rng-c-advance)
+  (rng-c-expect "{")
+  (rng-c-parse-grammar-body "}"))
+
+(defun rng-c-implicit-grammar-p ()
+  (or (and (or (rng-c-current-token-prefixed-name-p)
+               (rng-c-current-token-quoted-identifier-p)
+               (and (rng-c-current-token-ncname-p)
+                    (not (rng-c-current-token-keyword-p))))
+           (looking-at "\\["))
+      (and (string-equal rng-c-current-token "[")
+           (rng-c-parse-lead-annotation)
+           nil)
+      (member rng-c-current-token '("div" "include" ""))
+      (looking-at "[|&]?=")))
+
+(defun rng-c-parse-decls ()
+  (setq rng-c-default-namespace-declared nil)
+  (while (progn
+           (let ((binding
+                  (assoc rng-c-current-token
+                         '(("namespace" . rng-c-parse-namespace)
+                           ("datatypes" . rng-c-parse-datatypes)
+                           ("default" . rng-c-parse-default)))))
+             (if binding
+                 (progn
+                   (rng-c-advance)
+                   (funcall (cdr binding))
+                   t)
+               nil))))
+  (rng-c-declare-standard-datatypes)
+  (rng-c-declare-standard-namespaces))
+
+(defun rng-c-parse-datatypes ()
+  (let ((prefix (rng-c-parse-identifier-or-keyword)))
+    (or (not (assoc prefix rng-c-datatype-decls))
+        (rng-c-error "Duplicate datatypes declaration for prefix %s" prefix))
+    (rng-c-expect "=")
+    (setq rng-c-datatype-decls
+          (cons (cons prefix
+                      (rng-make-datatypes-uri (rng-c-parse-literal)))
+                rng-c-datatype-decls))))
+    
+(defun rng-c-parse-namespace ()
+  (rng-c-declare-namespace nil
+                           (rng-c-parse-identifier-or-keyword)))
+
+(defun rng-c-parse-default ()
+  (rng-c-expect "namespace")
+  (rng-c-declare-namespace t 
+                           (if (string-equal rng-c-current-token "=")
+                               nil
+                             (rng-c-parse-identifier-or-keyword))))
+
+(defun rng-c-declare-namespace (declare-default prefix)
+  (rng-c-expect "=")
+  (let ((ns (cond ((string-equal rng-c-current-token "inherit")
+                   (rng-c-advance)
+                   rng-c-inherit-namespace)
+                  (t
+                   (nxml-make-namespace (rng-c-parse-literal))))))
+    (and prefix
+         (or (not (assoc prefix rng-c-namespace-decls))
+             (rng-c-error "Duplicate namespace declaration for prefix %s"
+                          prefix))
+         (setq rng-c-namespace-decls
+               (cons (cons prefix ns) rng-c-namespace-decls)))
+    (and declare-default
+         (or (not rng-c-default-namespace-declared)
+             (rng-c-error "Duplicate default namespace declaration"))
+         (setq rng-c-default-namespace-declared t)
+         (setq rng-c-default-namespace ns))))
+
+(defun rng-c-parse-implicit-grammar ()
+  (let* ((rng-c-parent-grammar rng-c-current-grammar)
+         (rng-c-current-grammar (rng-c-make-grammar)))
+    (rng-c-parse-grammar-body "")
+    (rng-c-finish-grammar)))
+
+(defun rng-c-parse-grammar-body (close-token &optional in-include)
+  (while (not (string-equal rng-c-current-token close-token))
+    (cond ((rng-c-current-token-keyword-p)
+           (let ((kw (intern rng-c-current-token)))
+             (cond ((eq kw 'start)
+                    (rng-c-parse-define 'start in-include))
+                   ((eq kw 'div)
+                    (rng-c-advance)
+                    (rng-c-parse-div in-include))
+                   ((eq kw 'include)
+                    (and in-include
+                         (rng-c-error "Nested include"))
+                    (rng-c-advance)
+                    (rng-c-parse-include))
+                   (t (rng-c-error "Invalid grammar keyword")))))
+          ((rng-c-current-token-ncname-p)
+           (if (looking-at "\\[")
+               (rng-c-parse-annotation-element)
+             (rng-c-parse-define rng-c-current-token
+                                 in-include)))
+          ((rng-c-current-token-quoted-identifier-p)
+           (if (looking-at "\\[")
+               (rng-c-parse-annotation-element)
+             (rng-c-parse-define (substring rng-c-current-token 1)
+                                 in-include)))
+          ((rng-c-current-token-prefixed-name-p)
+           (rng-c-parse-annotation-element))
+          ((string-equal rng-c-current-token "[")
+           (rng-c-parse-lead-annotation)
+           (and (string-equal rng-c-current-token close-token)
+                (rng-c-error "Missing annotation subject"))
+           (and (looking-at "\\[")
+                (rng-c-error "Leading annotation applied to annotation")))
+          (t (rng-c-error "Invalid grammar content"))))
+  (or (string-equal rng-c-current-token "")
+      (rng-c-advance)))
+
+(defun rng-c-parse-div (in-include)
+  (rng-c-expect "{")
+  (rng-c-parse-grammar-body "}" in-include))
+
+(defun rng-c-parse-include ()
+  (let* ((filename (rng-c-expand-file (rng-c-parse-literal)))
+         (rng-c-inherit-namespace (rng-c-parse-opt-inherit))
+         overrides)
+    (cond ((string-equal rng-c-current-token "{")
+           (rng-c-advance)
+           (let ((rng-c-overrides nil))
+             (rng-c-parse-grammar-body "}" t)
+             (setq overrides rng-c-overrides))
+           (setq overrides (rng-c-start-include overrides))
+           (rng-c-parse-file filename 'include)
+           (rng-c-end-include overrides))
+          (t (rng-c-parse-file filename 'include)))))
+
+(defun rng-c-parse-define (name in-include)
+  (rng-c-advance)
+  (let ((assign (assoc rng-c-current-token
+                       '(("=" . nil)
+                         ("|=" . choice)
+                         ("&=" . interleave)))))
+    (or assign
+        (rng-c-error "Expected assignment operator"))
+    (rng-c-advance)
+    (let ((ref (rng-c-prepare-define name (cdr assign) in-include)))
+      (rng-c-define ref (rng-c-parse-pattern)))))
+
+(defvar rng-c-had-except nil)
+
+(defun rng-c-parse-pattern ()
+  (let* ((rng-c-had-except nil)
+         (p (rng-c-parse-repeated))
+         (op (assoc rng-c-current-token
+                    '(("|" . rng-make-choice)
+                      ("," . rng-make-group)
+                      ("&" . rng-make-interleave)))))
+    (if op
+        (if rng-c-had-except
+            (rng-c-error "Parentheses required around pattern using -")
+          (let* ((patterns (cons p nil))
+                 (tail patterns)
+                 (connector rng-c-current-token))
+            (while (progn
+                     (rng-c-advance)
+                     (let ((newcdr (cons (rng-c-parse-repeated) nil)))
+                       (setcdr tail newcdr)
+                       (setq tail newcdr))
+                     (string-equal rng-c-current-token connector)))
+            (funcall (cdr op) patterns)))
+      p)))
+
+(defun rng-c-parse-repeated ()
+  (let ((p (rng-c-parse-follow-annotations
+            (rng-c-parse-primary)))
+        (op (assoc rng-c-current-token
+                   '(("*" . rng-make-zero-or-more)
+                     ("+" . rng-make-one-or-more)
+                     ("?" . rng-make-optional)))))
+    (if op
+        (if rng-c-had-except
+            (rng-c-error "Parentheses required around pattern using -")
+          (rng-c-parse-follow-annotations
+           (progn
+             (rng-c-advance)
+             (funcall (cdr op) p))))
+      p)))
+
+(defun rng-c-parse-primary ()
+  "Parse a primary expression.  The current token must be the first
+token of the expression.  After parsing the current token should be
+token following the primary expression."
+  (cond ((rng-c-current-token-keyword-p)
+         (let ((parse-function (get (intern rng-c-current-token)
+                                    'rng-c-pattern)))
+           (or parse-function
+               (rng-c-error "Keyword %s does not introduce a pattern"
+                            rng-c-current-token))
+           (rng-c-advance)
+           (funcall parse-function)))
+        ((rng-c-current-token-ncname-p)
+         (rng-c-advance-with (rng-c-make-ref rng-c-current-token)))
+        ((string-equal rng-c-current-token "(")
+         (rng-c-advance)
+         (let ((p (rng-c-parse-pattern)))
+           (rng-c-expect ")")
+           p))
+        ((rng-c-current-token-prefixed-name-p)
+         (let ((name (rng-c-expand-datatype rng-c-current-token)))
+           (rng-c-advance)
+           (rng-c-parse-data name)))
+        ((rng-c-current-token-literal-p)
+         (rng-make-value rng-token-datatype (rng-c-parse-literal) nil))
+        ((rng-c-current-token-quoted-identifier-p)
+         (rng-c-advance-with
+          (rng-c-make-ref (substring rng-c-current-token 1))))
+        ((string-equal rng-c-current-token "[")
+         (rng-c-parse-lead-annotation)
+         (rng-c-parse-primary))
+        (t (rng-c-error "Invalid pattern"))))
+
+(defun rng-c-parse-parent ()
+  (and (rng-c-current-token-keyword-p)
+       (rng-c-error "Keyword following parent was not quoted"
+                    rng-c-current-token))
+  (rng-c-make-parent-ref (rng-c-parse-identifier-or-keyword)))
+
+(defun rng-c-parse-literal ()
+  (rng-c-fix-escaped-newlines
+   (apply 'concat (rng-c-parse-literal-segments))))
+
+(defun rng-c-parse-literal-segments ()
+  (let ((str (rng-c-parse-literal-segment)))
+    (cons str
+          (cond ((string-equal rng-c-current-token "~")
+                 (rng-c-advance)
+                 (rng-c-parse-literal-segments))
+                (t nil)))))
+
+(defun rng-c-parse-literal-segment ()
+  (or (rng-c-current-token-literal-p)
+      (rng-c-error "Expected a literal"))
+  (rng-c-advance-with
+   (let ((n (if (and (>= (length rng-c-current-token) 6)
+                     (eq (aref rng-c-current-token 0)
+                         (aref rng-c-current-token 1)))
+                3
+              1)))
+     (substring rng-c-current-token n (- n)))))
+
+(defun rng-c-fix-escaped-newlines (str)
+  (let ((pos 0))
+    (while (progn
+             (let ((n (string-match "\C-@" str pos)))
+               (and n
+                    (aset str n ?\n)
+                    (setq pos (1+ n)))))))
+  str)
+
+(defun rng-c-parse-identifier-or-keyword ()
+  (cond ((rng-c-current-token-ncname-p)
+         (rng-c-advance-with rng-c-current-token))
+        ((rng-c-current-token-quoted-identifier-p)
+         (rng-c-advance-with (substring rng-c-current-token 1)))
+        (t (rng-c-error "Expected identifier or keyword"))))
+   
+(put 'string 'rng-c-pattern 'rng-c-parse-string)
+(put 'token 'rng-c-pattern 'rng-c-parse-token)
+(put 'element 'rng-c-pattern 'rng-c-parse-element)
+(put 'attribute 'rng-c-pattern 'rng-c-parse-attribute)
+(put 'list 'rng-c-pattern 'rng-c-parse-list)
+(put 'mixed 'rng-c-pattern 'rng-c-parse-mixed)
+(put 'text 'rng-c-pattern 'rng-c-parse-text)
+(put 'empty 'rng-c-pattern 'rng-c-parse-empty)
+(put 'notAllowed 'rng-c-pattern 'rng-c-parse-not-allowed)
+(put 'grammar 'rng-c-pattern 'rng-c-parse-grammar)
+(put 'parent 'rng-c-pattern 'rng-c-parse-parent)
+(put 'external 'rng-c-pattern 'rng-c-parse-external)
+
+(defun rng-c-parse-element ()
+  (let ((name-class (rng-c-parse-name-class nil)))
+    (rng-c-expect "{")
+    (let ((pattern (rng-c-parse-pattern)))
+      (rng-c-expect "}")
+      (rng-make-element name-class pattern))))
+
+(defun rng-c-parse-attribute ()
+  (let ((name-class (rng-c-parse-name-class 'attribute)))
+    (rng-c-expect "{")
+    (let ((pattern (rng-c-parse-pattern)))
+      (rng-c-expect "}")
+      (rng-make-attribute name-class pattern))))
+
+(defun rng-c-parse-name-class (attribute)
+  (let* ((rng-c-had-except nil)
+         (name-class
+          (rng-c-parse-follow-annotations
+           (rng-c-parse-primary-name-class attribute))))
+    (if (string-equal rng-c-current-token "|")
+        (let* ((name-classes (cons name-class nil))
+               (tail name-classes))
+          (or (not rng-c-had-except)
+              (rng-c-error "Parentheses required around name-class using - operator"))
+          (while (progn
+                   (rng-c-advance)
+                   (let ((newcdr
+                          (cons (rng-c-parse-follow-annotations
+                                 (rng-c-parse-primary-name-class attribute))
+                                nil)))
+                     (setcdr tail newcdr)
+                     (setq tail newcdr))
+                   (string-equal rng-c-current-token "|")))
+          (rng-make-choice-name-class name-classes))
+      name-class)))
+          
+(defun rng-c-parse-primary-name-class (attribute)
+  (cond ((rng-c-current-token-ncname-p)
+         (rng-c-advance-with
+          (rng-make-name-name-class
+           (rng-make-name (rng-c-unqualified-namespace attribute)
+                          rng-c-current-token))))
+        ((rng-c-current-token-prefixed-name-p)
+         (rng-c-advance-with
+          (rng-make-name-name-class
+           (rng-c-expand-name rng-c-current-token))))
+        ((string-equal rng-c-current-token "*")
+         (let ((except (rng-c-parse-opt-except-name-class attribute)))
+           (if except
+               (rng-make-any-name-except-name-class except)
+             (rng-make-any-name-name-class))))
+        ((rng-c-current-token-ns-name-p)
+         (let* ((ns
+                 (rng-c-lookup-prefix (substring rng-c-current-token
+                                                 0
+                                                 -2)))
+                (except (rng-c-parse-opt-except-name-class attribute)))
+           (if except
+               (rng-make-ns-name-except-name-class ns except)
+             (rng-make-ns-name-name-class ns))))
+        ((string-equal rng-c-current-token "(")
+         (rng-c-advance)
+         (let ((name-class (rng-c-parse-name-class attribute)))
+           (rng-c-expect ")")
+           name-class))
+        ((rng-c-current-token-quoted-identifier-p)
+         (rng-c-advance-with
+          (rng-make-name-name-class
+           (rng-make-name (rng-c-unqualified-namespace attribute)
+                          (substring rng-c-current-token 1)))))
+        ((string-equal rng-c-current-token "[")
+         (rng-c-parse-lead-annotation)
+         (rng-c-parse-primary-name-class attribute))
+        (t (rng-c-error "Bad name class"))))
+
+(defun rng-c-parse-opt-except-name-class (attribute)
+  (rng-c-advance)
+  (and (string-equal rng-c-current-token "-")
+       (or (not rng-c-had-except)
+           (rng-c-error "Parentheses required around name-class using - operator"))
+       (setq rng-c-had-except t)
+       (progn
+         (rng-c-advance)
+         (rng-c-parse-primary-name-class attribute))))
+
+(defun rng-c-parse-mixed ()
+  (rng-c-expect "{")
+  (let ((pattern (rng-make-mixed (rng-c-parse-pattern))))
+    (rng-c-expect "}")
+    pattern))
+
+(defun rng-c-parse-list ()
+  (rng-c-expect "{")
+  (let ((pattern (rng-make-list (rng-c-parse-pattern))))
+    (rng-c-expect "}")
+    pattern))
+
+(defun rng-c-parse-text ()
+  (rng-make-text))
+
+(defun rng-c-parse-empty ()
+  (rng-make-empty))
+
+(defun rng-c-parse-not-allowed ()
+  (rng-make-not-allowed))
+
+(defun rng-c-parse-string ()
+  (rng-c-parse-data rng-string-datatype))
+
+(defun rng-c-parse-token ()
+  (rng-c-parse-data rng-token-datatype))
+
+(defun rng-c-parse-data (name)
+  (if (rng-c-current-token-literal-p)
+      (rng-make-value name
+                      (rng-c-parse-literal)
+                      (and (car name)
+                           (rng-c-make-context)))
+    (let ((params (rng-c-parse-optional-params)))
+      (if (string-equal rng-c-current-token "-")
+          (progn
+            (if rng-c-had-except
+                (rng-c-error "Parentheses required around pattern using -")
+              (setq rng-c-had-except t))
+            (rng-c-advance)
+            (rng-make-data-except name
+                                  params
+                                  (rng-c-parse-primary)))
+        (rng-make-data name params)))))
+
+(defun rng-c-parse-optional-params ()
+  (and (string-equal rng-c-current-token "{")
+       (let* ((head (cons nil nil))
+              (tail head))
+         (rng-c-advance)
+         (while (not (string-equal rng-c-current-token "}"))
+           (and (string-equal rng-c-current-token "[")
+                (rng-c-parse-lead-annotation))
+           (let ((name (rng-c-parse-identifier-or-keyword)))
+             (rng-c-expect "=")
+             (let ((newcdr (cons (cons (intern name)
+                                       (rng-c-parse-literal))
+                                 nil)))
+               (setcdr tail newcdr)
+               (setq tail newcdr))))
+         (rng-c-advance)
+         (cdr head))))
+
+(defun rng-c-parse-external ()
+  (let* ((filename (rng-c-expand-file (rng-c-parse-literal)))
+         (rng-c-inherit-namespace (rng-c-parse-opt-inherit)))
+    (rng-c-parse-file filename 'external)))
+
+(defun rng-c-expand-file (uri)
+  (condition-case err
+      (rng-uri-file-name (rng-uri-resolve uri
+                                          (rng-file-name-uri rng-c-file-name)))
+    (rng-uri-error
+     (rng-c-error (cadr err)))))
+
+(defun rng-c-parse-opt-inherit ()
+  (cond ((string-equal rng-c-current-token "inherit")
+         (rng-c-advance)
+         (rng-c-expect "=")
+         (rng-c-lookup-prefix (rng-c-parse-identifier-or-keyword)))
+        (t rng-c-default-namespace)))
+
+(defun rng-c-parse-grammar ()
+  (rng-c-expect "{")
+  (let* ((rng-c-parent-grammar rng-c-current-grammar)
+         (rng-c-current-grammar (rng-c-make-grammar)))
+    (rng-c-parse-grammar-body "}")
+    (rng-c-finish-grammar)))
+
+(defun rng-c-parse-lead-annotation ()
+  (rng-c-parse-annotation-body)
+  (and (string-equal rng-c-current-token "[")
+       (rng-c-error "Multiple leading annotations")))
+
+(defun rng-c-parse-follow-annotations (obj)
+  (while (string-equal rng-c-current-token ">>")
+    (rng-c-advance)
+    (if (rng-c-current-token-prefixed-name-p)
+        (rng-c-advance)
+      (rng-c-parse-identifier-or-keyword))
+    (rng-c-parse-annotation-body t))
+  obj)
+
+(defun rng-c-parse-annotation-element ()
+  (rng-c-advance)
+  (rng-c-parse-annotation-body t))
+
+;; XXX need stricter checking of attribute names
+;; XXX don't allow attributes after text
+
+(defun rng-c-parse-annotation-body (&optional allow-text)
+  "Current token is [.  Parse up to matching ]. Current token after
+parse is token following ]."
+  (or (string-equal rng-c-current-token "[")
+      (rng-c-error "Expected ["))
+  (rng-c-advance)
+  (while (not (string-equal rng-c-current-token "]"))
+    (cond ((rng-c-current-token-literal-p)
+           (or allow-text
+               (rng-c-error "Out of place text within annotation"))
+           (rng-c-parse-literal))
+          (t
+           (if (rng-c-current-token-prefixed-name-p)
+               (rng-c-advance)
+             (rng-c-parse-identifier-or-keyword))
+           (cond ((string-equal rng-c-current-token "[")
+                  (rng-c-parse-annotation-body t))
+                 ((string-equal rng-c-current-token "=")
+                  (rng-c-advance)
+                  (rng-c-parse-literal))
+                 (t (rng-c-error "Expected = or ["))))))
+  (rng-c-advance))
+             
+(defun rng-c-advance-with (pattern)
+  (rng-c-advance)
+  pattern)
+
+(defun rng-c-expect (str)
+  (or (string-equal rng-c-current-token str)
+      (rng-c-error "Expected `%s' but got `%s'" str rng-c-current-token))
+  (rng-c-advance))
+
+(provide 'rng-cmpct)
+
+;;; rng-cmpct.el
diff --git a/lisp/nxml/rng-dt.el b/lisp/nxml/rng-dt.el
new file mode 100644
index 00000000000..ba0689130ce
--- /dev/null
+++ b/lisp/nxml/rng-dt.el
@@ -0,0 +1,64 @@
+;;; rng-dt.el --- datatype library interface for RELAX NG
+
+;; Copyright (C) 2003 Free Software Foundation, Inc.
+
+;; Author: James Clark
+;; Keywords: XML, RelaxNG
+
+;; This program is free software; you can redistribute it and/or
+;; modify it under the terms of the GNU General Public License as
+;; published by the Free Software Foundation; either version 2 of
+;; the License, or (at your option) any later version.
+
+;; This program is distributed in the hope that it will be
+;; useful, but WITHOUT ANY WARRANTY; without even the implied
+;; warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+;; PURPOSE.  See the GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public
+;; License along with this program; if not, write to the Free
+;; Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+;; MA 02111-1307 USA
+
+;;; Commentary:
+
+;;; Code:
+
+(require 'rng-util)
+
+(defvar rng-dt-error-reporter nil)
+
+(defun rng-dt-error (string &rest objs)
+  (if rng-dt-error-reporter
+      (apply rng-dt-error-reporter (cons string objs))
+    nil))
+
+(defvar rng-dt-namespace-context-getter nil
+  "A list used by datatype libraries to expand names.  The car of the
+list is a symbol which is the name of a function.  This function is
+applied to the cdr of the list.  The function must return a list whose
+car is the default namespace and whose cdr is an alist of (PREFIX
+. NAMESPACE) pairs, where PREFIX is a string and NAMESPACE is a
+symbol.  This must be dynamically bound before calling a datatype
+library.")
+
+(defsubst rng-dt-make-value (dt str)
+  (apply (car dt) (cons str (cdr dt))))
+
+(defun rng-dt-builtin-compile (name params)
+  (cond ((eq name 'string)
+         (if (null params)
+             '(t identity)
+           (rng-dt-error "The string datatype does not take any parameters")))
+        ((eq name 'token)
+         (if (null params)
+             '(t rng-collapse-space)
+           (rng-dt-error "The token datatype does not take any parameters")))
+        (t
+         (rng-dt-error "There is no built-in datatype %s" name))))
+
+(put (rng-make-datatypes-uri "") 'rng-dt-compile 'rng-dt-builtin-compile)
+
+(provide 'rng-dt)
+
+;;; rng-dt.el ends here
diff --git a/lisp/nxml/rng-loc.el b/lisp/nxml/rng-loc.el
new file mode 100644
index 00000000000..b81bfe009f8
--- /dev/null
+++ b/lisp/nxml/rng-loc.el
@@ -0,0 +1,548 @@
+;;; rng-loc.el --- locate the schema to use for validation
+
+;; Copyright (C) 2003 Free Software Foundation, Inc.
+
+;; Author: James Clark
+;; Keywords: XML, RelaxNG
+
+;; This program is free software; you can redistribute it and/or
+;; modify it under the terms of the GNU General Public License as
+;; published by the Free Software Foundation; either version 2 of
+;; the License, or (at your option) any later version.
+
+;; This program is distributed in the hope that it will be
+;; useful, but WITHOUT ANY WARRANTY; without even the implied
+;; warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+;; PURPOSE.  See the GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public
+;; License along with this program; if not, write to the Free
+;; Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+;; MA 02111-1307 USA
+
+;;; Commentary:
+
+;;; Code:
+
+(require 'nxml-util)
+(require 'nxml-parse)
+(require 'rng-parse)
+(require 'rng-uri)
+(require 'rng-util)
+(require 'xmltok)
+
+(defvar rng-current-schema-file-name nil
+  "Filename of schema being used for current buffer.
+Nil if using a vacuous schema.")
+(make-variable-buffer-local 'rng-current-schema-file-name)
+
+(defvar rng-schema-locating-files-default nil
+  "Default value for variable `rng-schema-locating-files'.")
+
+(defvar rng-schema-locating-file-schema-file nil
+  "File containing schema for schema locating files.")
+
+(defvar rng-schema-locating-file-schema nil
+  "Schema for schema locating files or nil if not yet loaded.")
+
+(defcustom rng-schema-locating-files rng-schema-locating-files-default
+  "*List of schema locating files."
+  :type '(repeat file)
+  :group 'relax-ng)
+
+(defvar rng-schema-loader-alist nil
+  "Alist of schema extensions vs schema loader functions.")
+
+(defvar rng-cached-document-element nil)
+
+(defvar rng-document-type-history nil)
+
+(defun rng-set-document-type (type-id)
+  (interactive (list (rng-read-type-id)))
+  (condition-case err
+      (when (not (string= type-id ""))
+        (let ((schema-file (rng-locate-schema-file type-id)))
+          (unless schema-file
+            (error "Could not locate schema for type id `%s'" type-id))
+          (rng-set-schema-file-1 schema-file))
+        (rng-save-schema-location-1 t type-id)
+        (rng-what-schema))
+    (nxml-file-parse-error
+     (nxml-display-file-parse-error err))))
+
+(defun rng-read-type-id ()
+  (condition-case err
+      (let ((type-ids (rng-possible-type-ids))
+            (completion-ignore-case nil))
+        (completing-read "Document type id: "
+                         (mapcar (lambda (x) (cons x nil))
+                                 type-ids)
+                         nil
+                         t
+                         nil
+                         'rng-document-type-history))
+    (nxml-file-parse-error
+     (nxml-display-file-parse-error err))))
+
+(defun rng-set-schema-file (filename)
+  "Set the schema for the current buffer to the schema in FILENAME.
+FILENAME must be the name of a file containing a schema.
+The extension of FILENAME is used to determine what kind of schema it
+is.  The variable `rng-schema-loader-alist' maps from schema
+extensions to schema loader functions. The function
+`rng-c-load-schema' is the loader for RELAX NG compact syntax.  The
+association is between the buffer and the schema: the association is
+lost when the buffer is killed."
+  (interactive "fSchema file: ")
+  (condition-case err
+      (progn
+        (rng-set-schema-file-1 filename)
+        (rng-save-schema-location-1 t))
+    (nxml-file-parse-error
+     (nxml-display-file-parse-error err))))
+
+(defun rng-set-vacuous-schema ()
+  "Set the schema for the current buffer to allow any well-formed XML."
+  (interactive)
+  (rng-set-schema-file-1 nil)
+  (rng-what-schema))
+
+(defun rng-set-schema-file-1 (filename)
+  (setq filename (and filename (expand-file-name filename)))
+  (setq rng-current-schema
+        (if filename
+            (rng-load-schema filename)
+          rng-any-element))
+  (setq rng-current-schema-file-name filename)
+  (run-hooks 'rng-schema-change-hook))
+  
+(defun rng-load-schema (filename)
+  (let* ((extension (file-name-extension filename))
+         (loader (cdr (assoc extension rng-schema-loader-alist))))
+    (or loader
+        (if extension
+            (error "No schema loader available for file extension `%s'"
+                   extension)
+          (error "No schema loader available for null file extension")))
+    (funcall loader filename)))
+
+(defun rng-what-schema ()
+  "Display a message saying what schema `rng-validate-mode' is using."
+  (interactive)
+  (if rng-current-schema-file-name
+      (message "Using schema %s" 
+               (abbreviate-file-name rng-current-schema-file-name))
+    (message "Using vacuous schema")))
+
+(defun rng-auto-set-schema (&optional no-display-error)
+  "Set the schema for this buffer based on the buffer's contents and file-name."
+  (interactive)
+  (condition-case err
+      (progn
+        (rng-set-schema-file-1 (rng-locate-schema-file))
+        (rng-what-schema))
+    (nxml-file-parse-error
+     (if no-display-error
+         (error "%s at position %s in %s"
+                (nth 3 err)
+                (nth 2 err)
+                (abbreviate-file-name (nth 1 err)))
+       (nxml-display-file-parse-error err)))))
+
+(defun rng-locate-schema-file (&optional type-id)
+  "Return the file-name of the schema to use for the current buffer.
+Return nil if no schema could be located.
+If TYPE-ID is non-nil, then locate the schema for this TYPE-ID."
+  (let* ((rng-cached-document-element nil)
+         (schema
+          (if type-id
+              (cons type-id nil)
+            (rng-locate-schema-file-using rng-schema-locating-files)))
+         files type-ids)
+    (while (consp schema)
+      (setq files rng-schema-locating-files)
+      (setq type-id (car schema))
+      (setq schema nil)
+      (when (member type-id type-ids)
+        (error "Type-id loop for type-id `%s'" type-id))
+      (setq type-ids (cons type-id type-ids))
+      (while (and files (not schema))
+        (setq schema
+              (rng-locate-schema-file-from-type-id type-id
+                                                   (car files)))
+        (setq files (cdr files))))
+    (and schema
+         (rng-uri-file-name schema))))
+
+(defun rng-possible-type-ids ()
+  "Return a list of the known type IDs."
+  (let ((files rng-schema-locating-files)
+        type-ids)
+    (while files
+      (setq type-ids (rng-possible-type-ids-using (car files) type-ids))
+      (setq files (cdr files)))
+    (rng-uniquify-equal (sort type-ids 'string<))))
+
+(defun rng-locate-schema-file-using (files)
+  "Locate a schema using the schema locating files FILES.
+FILES is a list of file-names.
+Return either a URI, a list (TYPE-ID) where TYPE-ID is a string
+or nil."
+  (let (rules
+        ;; List of types that override normal order-based
+        ;; priority, most important first
+        preferred-types
+        ;; Best result found so far; same form as return value.
+        best-so-far)
+    (while (and (progn
+                  (while (and (not rules) files)
+                    (setq rules (rng-get-parsed-schema-locating-file
+                                 (car files)))
+                    (setq files (cdr files)))
+                  rules)
+                (or (not best-so-far) preferred-types))
+      (let* ((rule (car rules))
+             (rule-type (car rule))
+             (rule-matcher (get rule-type 'rng-rule-matcher)))
+        (setq rules (cdr rules))
+        (cond (rule-matcher
+               (when (and (or (not best-so-far)
+                              (memq rule-type preferred-types)))
+                          (setq best-so-far
+                                (funcall rule-matcher (cdr rule)))
+                          preferred-types)
+                 (setq preferred-types
+                       (nbutlast preferred-types
+                                 (length (memq rule-type preferred-types)))))
+              ((eq rule-type 'applyFollowingRules)
+               (when (not best-so-far)
+                 (let ((prefer (cdr (assq 'ruleType (cdr rule)))))
+                   (when (and prefer
+                              (not (memq (setq prefer (intern prefer))
+                                         preferred-types)))
+                     (setq preferred-types
+                           (nconc preferred-types (list prefer)))))))
+              ((eq rule-type 'include)
+               (let ((uri (cdr (assq 'rules (cdr rule)))))
+                 (when uri
+                   (setq rules
+                         (append (rng-get-parsed-schema-locating-file
+                                  (rng-uri-file-name uri))
+                                 rules))))))))
+    best-so-far))
+
+(put 'documentElement 'rng-rule-matcher 'rng-match-document-element-rule)
+(put 'namespace 'rng-rule-matcher 'rng-match-namespace-rule)
+(put 'uri 'rng-rule-matcher 'rng-match-uri-rule)
+(put 'transformURI 'rng-rule-matcher 'rng-match-transform-uri-rule)
+(put 'default 'rng-rule-matcher 'rng-match-default-rule)
+
+(defun rng-match-document-element-rule (props)
+  (let ((document-element (rng-document-element))
+        (prefix (cdr (assq 'prefix props)))
+        (local-name (cdr (assq 'localName props))))
+    (and (or (not prefix)
+             (if (= (length prefix) 0)
+                 (not (nth 1 document-element))
+               (string= prefix (nth 1 document-element))))
+         (or (not local-name)
+             (string= local-name
+                      (nth 2 document-element)))
+         (rng-match-default-rule props))))
+
+(defun rng-match-namespace-rule (props)
+  (let ((document-element (rng-document-element))
+        (ns (cdr (assq 'ns props))))
+    (and document-element
+         ns
+         (eq (nth 0 document-element)
+             (if (string= ns "")
+                 nil
+               (nxml-make-namespace ns)))
+         (rng-match-default-rule props))))
+
+(defun rng-document-element ()
+  "Return a list (NS PREFIX LOCAL-NAME).
+NS is t if the document has a non-nil, but not otherwise known namespace."
+  (or rng-cached-document-element
+      (setq rng-cached-document-element
+            (save-excursion
+              (save-restriction
+                (widen)
+                (goto-char (point-min))
+                (let (xmltok-dtd)
+                  (xmltok-save
+                   (xmltok-forward-prolog)
+                   (xmltok-forward)
+                   (when (memq xmltok-type '(start-tag
+                                             partial-start-tag
+                                             empty-element
+                                             partial-empty-element))
+                     (list (rng-get-start-tag-namespace)
+                           (xmltok-start-tag-prefix)
+                           (xmltok-start-tag-local-name))))))))))
+
+(defun rng-get-start-tag-namespace ()
+  (let ((prefix (xmltok-start-tag-prefix))
+        namespace att value)
+    (while xmltok-namespace-attributes
+      (setq att (car xmltok-namespace-attributes))
+      (setq xmltok-namespace-attributes (cdr xmltok-namespace-attributes))
+      (when (if prefix
+                (and (xmltok-attribute-prefix att)
+                     (string= (xmltok-attribute-local-name att)
+                              prefix))
+              (not (xmltok-attribute-prefix att)))
+        (setq value (xmltok-attribute-value att))
+        (setq namespace (if value (nxml-make-namespace value) t))))
+    (if (and prefix (not namespace))
+        t
+      namespace)))
+
+(defun rng-match-transform-uri-rule (props)
+  (let ((from-pattern (cdr (assq 'fromPattern props)))
+        (to-pattern (cdr (assq 'toPattern props)))
+        (file-name (buffer-file-name)))
+    (and file-name
+         (setq file-name (expand-file-name file-name))
+         (rng-file-name-matches-uri-pattern-p file-name from-pattern)
+         (condition-case ()
+             (let ((new-file-name
+                    (replace-match
+                     (save-match-data
+                       (rng-uri-pattern-file-name-replace-match to-pattern))
+                     t
+                     nil
+                     file-name)))
+               (and (file-name-absolute-p new-file-name)
+                    (file-exists-p new-file-name)
+                    (rng-file-name-uri new-file-name)))
+             (rng-uri-error nil)))))
+
+(defun rng-match-uri-rule (props)
+  (let ((resource (cdr (assq 'resource props)))
+        (pattern (cdr (assq 'pattern props)))
+        (file-name (buffer-file-name)))
+    (and file-name
+         (setq file-name (expand-file-name file-name))
+         (cond (resource
+                (condition-case ()
+                    (eq (compare-strings (rng-uri-file-name resource)
+                                         0
+                                         nil
+                                         (expand-file-name file-name)
+                                         0
+                                         nil
+                                         nxml-file-name-ignore-case)
+                        t)
+                  (rng-uri-error nil)))
+               (pattern
+                (rng-file-name-matches-uri-pattern-p file-name
+                                                     pattern)))
+         (rng-match-default-rule props))))
+
+(defun rng-file-name-matches-uri-pattern-p (file-name pattern)
+  (condition-case ()
+      (and (let ((case-fold-search nxml-file-name-ignore-case))
+             (string-match (rng-uri-pattern-file-name-regexp pattern)
+                           file-name))
+           t)
+    (rng-uri-error nil)))
+
+(defun rng-match-default-rule (props)
+  (or (cdr (assq 'uri props))
+      (let ((type-id (cdr (assq 'typeId props))))
+        (and type-id
+             (cons (rng-collapse-space type-id) nil)))))
+
+(defun rng-possible-type-ids-using (file type-ids)
+  (let ((rules (rng-get-parsed-schema-locating-file file))
+        rule)
+    (while rules
+      (setq rule (car rules))
+      (setq rules (cdr rules))
+      (cond ((eq (car rule) 'typeId)
+             (let ((id (cdr (assq 'id (cdr rule)))))
+               (when id
+                 (setq type-ids
+                       (cons (rng-collapse-space id)
+                             type-ids)))))
+            ((eq (car rule) 'include)
+             (let ((uri (cdr (assq 'rules (cdr rule)))))
+               (when uri
+                 (setq type-ids
+                       (rng-possible-type-ids-using
+                        (rng-get-parsed-schema-locating-file
+                         (rng-uri-file-name uri))
+                        type-ids)))))))
+    type-ids))
+
+(defun rng-locate-schema-file-from-type-id (type-id file)
+  "Locate the schema for type id TYPE-ID using schema locating file FILE.
+Return either a URI, a list (TYPE-ID) where TYPE-ID is a string
+or nil."
+  (let ((rules (rng-get-parsed-schema-locating-file file))
+        schema rule)
+    (while (and rules (not schema))
+      (setq rule (car rules))
+      (setq rules (cdr rules))
+      (cond ((and (eq (car rule) 'typeId)
+                  (let ((id (assq 'id (cdr rule))))
+                    (and id
+                         (string= (rng-collapse-space (cdr id)) type-id))))
+             (setq schema (rng-match-default-rule (cdr rule))))
+            ((eq (car rule) 'include)
+             (let ((uri (cdr (assq 'rules (cdr rule)))))
+               (when uri
+                 (setq schema
+                       (rng-locate-schema-file-from-type-id
+                        type-id
+                        (rng-uri-file-name uri))))))))
+    schema))
+
+(defvar rng-schema-locating-file-alist nil)
+
+(defun rng-get-parsed-schema-locating-file (file)
+  "Return a list of rules for the schema locating file FILE."
+  (setq file (expand-file-name file))
+  (let ((cached (assoc file rng-schema-locating-file-alist))
+        (mtime (nth 5 (file-attributes file)))
+        parsed)
+    (cond ((not mtime)
+           (when cached
+             (setq rng-schema-locating-file-alist
+                   (delq cached rng-schema-locating-file-alist)))
+           nil)
+          ((and cached (equal (nth 1 cached) mtime))
+           (nth 2 cached))
+          (t
+           (setq parsed (rng-parse-schema-locating-file file))
+           (if cached
+               (setcdr cached (list mtime parsed))
+             (setq rng-schema-locating-file-alist
+                   (cons (list file mtime parsed)
+                         rng-schema-locating-file-alist)))
+           parsed))))
+  
+(defconst rng-locate-namespace-uri
+  (nxml-make-namespace "http://thaiopensource.com/ns/locating-rules/1.0"))
+
+(defun rng-parse-schema-locating-file (file)
+  "Return list of rules.
+Each rule has the form (TYPE (ATTR . VAL) ...), where
+TYPE is a symbol for the element name, ATTR is a symbol for the attribute
+and VAL is a string for the value.
+Attribute values representing URIs are made absolute and xml:base
+attributes are removed."
+  (when (and (not rng-schema-locating-file-schema)
+             rng-schema-locating-file-schema-file)
+    (setq rng-schema-locating-file-schema
+          (rng-load-schema rng-schema-locating-file-schema-file)))
+  (let* ((element
+          (if rng-schema-locating-file-schema
+              (rng-parse-validate-file rng-schema-locating-file-schema
+                                       file)
+            (nxml-parse-file file)))
+         (children (cddr element))
+         (base-uri (rng-file-name-uri file))
+         child name rules atts att props prop-name prop-value)
+    (when (equal (car element)
+                 (cons rng-locate-namespace-uri "locatingRules"))
+      (while children
+        (setq child (car children))
+        (setq children (cdr children))
+        (when (consp child)
+          (setq name (car child))
+          (when (eq (car name) rng-locate-namespace-uri)
+            (setq atts (cadr child))
+            (setq props nil)
+            (while atts
+              (setq att (car atts))
+              (when (stringp (car att))
+                (setq prop-name (intern (car att)))
+                (setq prop-value (cdr att))
+                (when (memq prop-name '(uri rules resource))
+                  (setq prop-value
+                        (rng-uri-resolve prop-value base-uri)))
+                (setq props (cons (cons prop-name prop-value)
+                                  props)))
+              (setq atts (cdr atts)))
+            (setq rules
+                  (cons (cons (intern (cdr name)) (nreverse props))
+                        rules))))))
+    (nreverse rules)))
+
+(defun rng-save-schema-location ()
+  "Save the association between the buffer's file and the current schema.
+This ensures that the schema that is currently being used will be used
+if the file is edited in a future session.  The association will be
+saved to the first writable file in `rng-schema-locating-files'."
+  (interactive)
+  (rng-save-schema-location-1 nil))
+
+(defun rng-save-schema-location-1 (prompt &optional type-id)
+  (unless (or rng-current-schema-file-name type-id)
+    (error "Buffer is using a vacuous schema"))
+  (let ((files rng-schema-locating-files)
+        (document-file-name (buffer-file-name))
+        (schema-file-name rng-current-schema-file-name)
+        file)
+    (while (and files (not file))
+      (if (file-writable-p (car files))
+          (setq file (expand-file-name (car files)))
+        (setq files (cdr files))))
+    (cond ((not file)
+           (if prompt
+               nil
+             (error "No writable schema locating file configured")))
+          ((not document-file-name)
+           (if prompt
+               nil
+             (error "Buffer does not have a filename")))
+          ((and prompt
+                (not (y-or-n-p (format "Save %s to %s "
+                                       (if type-id
+                                           "type identifier"
+                                         "schema location")
+                                       file)))))
+          (t
+           (save-excursion
+             (set-buffer (find-file-noselect file))
+             (let ((modified (buffer-modified-p)))
+               (if (> (buffer-size) 0)
+                   (let (xmltok-dtd)
+                     (goto-char (point-min))
+                     (xmltok-save
+                       (xmltok-forward-prolog)
+                       (xmltok-forward)
+                       (unless (eq xmltok-type 'start-tag)
+                         (error "Locating file `%s' invalid" file))))
+                 (insert "<?xml version=\"1.0\"?>\n"
+                         "<locatingRules xmlns=\""
+                         (nxml-namespace-name rng-locate-namespace-uri)
+                         "\">")
+                 (let ((pos (point)))
+                   (insert "\n</locatingRules>\n")
+                   (goto-char pos)))
+               (insert "\n")
+               (insert (let ((locating-file-uri (rng-file-name-uri file)))
+                         (format "<uri resource=\"%s\" %s=\"%s\"/>"
+                                 (rng-escape-string
+                                  (rng-relative-uri
+                                   (rng-file-name-uri document-file-name)
+                                   locating-file-uri))
+                                 (if type-id "typeId" "uri")
+                                 (rng-escape-string
+                                  (or type-id
+                                      (rng-relative-uri
+                                       (rng-file-name-uri schema-file-name)
+                                       locating-file-uri))))))
+               (indent-according-to-mode)
+               (when (or (not modified)
+                         (y-or-n-p (format "Save file %s "
+                                           (buffer-file-name))))
+                 (save-buffer))))))))
+
+(provide 'rng-loc)
+
+;;; rng-loc.el ends here
diff --git a/lisp/nxml/rng-maint.el b/lisp/nxml/rng-maint.el
new file mode 100644
index 00000000000..ecf1ff1bc99
--- /dev/null
+++ b/lisp/nxml/rng-maint.el
@@ -0,0 +1,343 @@
+;;; rng-maint.el --- commands for RELAX NG maintainers
+
+;; Copyright (C) 2003 Free Software Foundation, Inc.
+
+;; Author: James Clark
+;; Keywords: XML, RelaxNG
+
+;; This program is free software; you can redistribute it and/or
+;; modify it under the terms of the GNU General Public License as
+;; published by the Free Software Foundation; either version 2 of
+;; the License, or (at your option) any later version.
+
+;; This program is distributed in the hope that it will be
+;; useful, but WITHOUT ANY WARRANTY; without even the implied
+;; warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+;; PURPOSE.  See the GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public
+;; License along with this program; if not, write to the Free
+;; Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+;; MA 02111-1307 USA
+
+;;; Commentary:
+
+;;; Code:
+
+(require 'xmltok)
+(require 'nxml-mode)
+(require 'texnfo-upd)
+
+(defvar rng-dir (file-name-directory load-file-name))
+
+(defconst rng-autoload-modules
+  '(xmltok
+    nxml-mode
+    nxml-uchnm
+    nxml-glyph
+    rng-cmpct
+    rng-maint
+    rng-valid
+    rng-xsd
+    rng-nxml))
+
+;;;###autoload
+(defun rng-update-autoloads ()
+  "Update the autoloads in rng-auto.el."
+  (interactive)
+  (let* ((generated-autoload-file (expand-file-name "rng-auto.el"
+                                                    rng-dir)))
+    (mapcar (lambda (x)
+              (update-file-autoloads
+               (expand-file-name (concat (symbol-name x) ".el") rng-dir)))
+            rng-autoload-modules)))
+
+
+(defconst rng-compile-modules
+  '(xmltok
+    nxml-util
+    nxml-enc
+    nxml-glyph
+    nxml-rap
+    nxml-outln
+    nxml-mode
+    nxml-uchnm
+    nxml-ns
+    nxml-parse
+    nxml-maint
+    xsd-regexp
+    rng-util
+    rng-dt
+    rng-xsd
+    rng-uri
+    rng-pttrn
+    rng-cmpct
+    rng-match
+    rng-parse
+    rng-loc
+    rng-valid
+    rng-nxml
+    rng-maint))
+
+;;;###autoload
+(defun rng-byte-compile-load ()
+  "Byte-compile and load all of the RELAX NG library in an appropriate order."
+  (interactive)
+  (mapcar (lambda (x)
+            (byte-compile-file (expand-file-name (concat (symbol-name x) ".el")
+                                                 rng-dir)
+                               t))
+          rng-compile-modules))
+
+
+;;; Conversion from XML to texinfo.
+;; This is all a hack and is just enough to make the conversion work.
+;; It's not intended for public use.
+
+(defvar rng-manual-base "nxml-mode")
+(defvar rng-manual-xml (concat rng-manual-base ".xml"))
+(defvar rng-manual-texi (concat rng-manual-base ".texi"))
+(defvar rng-manual-info (concat rng-manual-base ".info"))
+
+;;;###autoload
+(defun rng-format-manual ()
+  "Create manual.texi from manual.xml."
+  (interactive)
+  (let ((xml-buf (find-file-noselect (expand-file-name rng-manual-xml
+                                                       rng-dir)))
+        (texi-buf (find-file-noselect (expand-file-name rng-manual-texi
+                                                        rng-dir))))
+    (save-excursion
+      (set-buffer texi-buf)
+      (erase-buffer)
+      (let ((standard-output texi-buf))
+        (princ (format "\\input texinfo @c -*- texinfo -*-\n\
+@c %%**start of header\n\
+@setfilename %s\n\
+@settitle \n\
+@c %%**end of header\n" rng-manual-info))
+        (set-buffer xml-buf)
+        (goto-char (point-min))
+        (xmltok-save
+          (xmltok-forward-prolog)
+          (rng-process-tokens))
+        (princ "\n@bye\n"))
+      (set-buffer texi-buf)
+      (rng-manual-fixup)
+      (texinfo-insert-node-lines (point-min) (point-max) t)
+      (texinfo-all-menus-update)
+      (save-buffer))))
+
+(defun rng-manual-fixup ()
+  (goto-char (point-min))
+  (search-forward "@top ")
+  (let ((pos (point)))
+    (search-forward "\n")
+    (let ((title (buffer-substring-no-properties pos (1- (point)))))
+      (goto-char (point-min))
+      (search-forward "@settitle ")
+      (insert title)
+      (search-forward "@node")
+      (goto-char (match-beginning 0))
+      (insert "@dircategory Emacs\n"
+              "@direntry\n* "
+              title
+              ": ("
+              rng-manual-info
+              ").\n@end direntry\n\n"))))
+
+(defvar rng-manual-inline-elements '(kbd key samp code var emph uref point))
+
+(defun rng-process-tokens ()
+  (let ((section-depth 0)
+        ;; stack of per-element space treatment
+        ;; t means keep, nil means discard, fill means no blank lines
+        (keep-space-stack (list nil))
+        (ignore-following-newline nil)
+        (want-blank-line nil)
+        name startp endp data keep-space-for-children)
+    (while (xmltok-forward)
+      (cond ((memq xmltok-type '(start-tag empty-element end-tag))
+             (setq startp (memq xmltok-type '(start-tag empty-element)))
+             (setq endp (memq xmltok-type '(end-tag empty-element)))
+             (setq name (intern (if startp
+                                    (xmltok-start-tag-qname)
+                                  (xmltok-end-tag-qname))))
+             (setq keep-space-for-children nil)
+             (setq ignore-following-newline nil)
+             (cond ((memq name rng-manual-inline-elements)
+                    (when startp
+                      (when want-blank-line
+                        (rng-manual-output-force-blank-line)
+                        (when (eq want-blank-line 'noindent)
+                          (princ "@noindent\n"))
+                        (setq want-blank-line nil))
+                      (setq keep-space-for-children t)
+                      (princ (format "@%s{" name)))
+                    (when endp (princ "}")))
+                   ((eq name 'ulist)
+                    (when startp
+                      (rng-manual-output-force-blank-line)
+                      (setq want-blank-line nil)
+                      (princ "@itemize @bullet\n"))
+                    (when endp
+                      (rng-manual-output-force-new-line)
+                      (setq want-blank-line 'noindent)
+                      (princ "@end itemize\n")))
+                   ((eq name 'item)
+                    (rng-manual-output-force-new-line)
+                    (setq want-blank-line endp)
+                    (when startp (princ "@item\n")))
+                   ((memq name '(example display))
+                    (when startp
+                      (setq ignore-following-newline t)
+                      (rng-manual-output-force-blank-line)
+                      (setq want-blank-line nil)
+                      (setq keep-space-for-children t)
+                      (princ (format "@%s\n" name)))
+                    (when endp
+                      (rng-manual-output-force-new-line)
+                      (setq want-blank-line 'noindent)
+                      (princ (format "@end %s\n" name))))
+                   ((eq name 'para)
+                    (rng-manual-output-force-new-line)
+                    (when startp
+                      (when want-blank-line
+                        (setq want-blank-line t))
+                      (setq keep-space-for-children 'fill))
+                    (when endp (setq want-blank-line t)))
+                   ((eq name 'section)
+                    (when startp
+                      (rng-manual-output-force-blank-line)
+                      (when (eq section-depth 0)
+                        (princ "@node Top\n"))
+                      (princ "@")
+                      (princ (nth section-depth '(top
+                                                  chapter
+                                                  section
+                                                  subsection
+                                                  subsubsection)))
+                      (princ " ")
+                      (setq want-blank-line nil)
+                      (setq section-depth (1+ section-depth)))
+                    (when endp
+                      (rng-manual-output-force-new-line)
+                      (setq want-blank-line nil)
+                      (setq section-depth (1- section-depth))))
+                   ((eq name 'title)
+                    (when startp
+                      (setq keep-space-for-children 'fill))
+                    (when endp
+                      (setq want-blank-line t)
+                      (princ "\n"))))
+             (when startp
+               (setq keep-space-stack (cons keep-space-for-children
+                                            keep-space-stack)))
+             (when endp
+               (setq keep-space-stack (cdr keep-space-stack))))
+            ((memq xmltok-type '(data
+                                 space
+                                 char-ref
+                                 entity-ref
+                                 cdata-section))
+             (setq data nil)
+             (cond ((memq xmltok-type '(data space))
+                    (setq data (buffer-substring-no-properties xmltok-start
+                                                               (point))))
+                   ((and (memq xmltok-type '(char-ref entity-ref))
+                         xmltok-replacement)
+                    (setq data xmltok-replacement))
+                   ((eq xmltok-type 'cdata-section)
+                    (setq data
+                          (buffer-substring-no-properties (+ xmltok-start 9)
+                                                          (- (point) 3)))))
+             (when (and data (car keep-space-stack))
+               (setq data (replace-regexp-in-string "[@{}]"
+                                                    "@\\&"
+                                                    data
+                                                    t))
+               (when ignore-following-newline
+                 (setq data (replace-regexp-in-string "\\`\n" "" data t)))
+               (setq ignore-following-newline nil)
+;;             (when (eq (car keep-space-stack) 'fill)
+;;               (setq data (replace-regexp-in-string "\n" " " data t)))
+               (when (eq want-blank-line 'noindent)
+                 (setq data (replace-regexp-in-string "\\`\n*" "" data t)))
+               (when (> (length data) 0)
+                 (when want-blank-line
+                   (rng-manual-output-force-blank-line)
+                   (when (eq want-blank-line 'noindent)
+                     (princ "@noindent\n"))
+                   (setq want-blank-line nil))
+                 (princ data))))
+             ))))
+
+(defun rng-manual-output-force-new-line ()
+  (save-excursion
+    (set-buffer standard-output)
+    (unless (eq (char-before) ?\n)
+      (insert ?\n))))
+
+(defun rng-manual-output-force-blank-line ()
+  (save-excursion
+    (set-buffer standard-output)
+    (if (eq (char-before) ?\n)
+        (unless (eq (char-before (1- (point))) ?\n)
+          (insert ?\n))
+      (insert "\n\n"))))
+
+;;; Versioning
+
+;;;###autoload
+(defun rng-write-version ()
+  (find-file "VERSION")
+  (erase-buffer)
+  (insert nxml-version "\n")
+  (save-buffer))
+
+;;; Timing
+
+(defun rng-time-to-float (time)
+  (+ (* (nth 0 time) 65536.0)
+     (nth 1 time)
+     (/ (nth 2 time) 1000000.0)))
+
+(defun rng-time-function (function &rest args)
+  (let* ((start (current-time))
+         (val (apply function args))
+         (end (current-time)))
+    (message "%s ran in %g seconds"
+             function
+             (- (rng-time-to-float end)
+                (rng-time-to-float start)))
+    val))
+
+(defun rng-time-tokenize-buffer ()
+  (interactive)
+  (rng-time-function 'rng-tokenize-buffer))
+
+(defun rng-tokenize-buffer ()
+  (save-excursion
+    (goto-char (point-min))
+    (xmltok-save
+      (xmltok-forward-prolog)
+      (while (xmltok-forward)))))
+
+(defun rng-time-validate-buffer ()
+  (interactive)
+  (rng-time-function 'rng-validate-buffer))
+
+(defun rng-validate-buffer ()
+  (save-restriction
+    (widen)
+    (nxml-with-unmodifying-text-property-changes
+      (rng-clear-cached-state (point-min) (point-max)))
+    ;; 1+ to clear empty overlays at (point-max)
+    (rng-clear-overlays (point-min) (1+ (point-max))))
+  (setq rng-validate-up-to-date-end 1)
+  (rng-clear-conditional-region)
+  (setq rng-error-count 0)
+  (while (rng-do-some-validation
+          (lambda () t))))
+
+;;; rng-maint.el ends here
diff --git a/lisp/nxml/rng-match.el b/lisp/nxml/rng-match.el
new file mode 100644
index 00000000000..d3692615549
--- /dev/null
+++ b/lisp/nxml/rng-match.el
@@ -0,0 +1,1739 @@
+;;; rng-match.el --- matching of RELAX NG patterns against XML events
+
+;; Copyright (C) 2003 Free Software Foundation, Inc.
+
+;; Author: James Clark
+;; Keywords: XML, RelaxNG
+
+;; This program is free software; you can redistribute it and/or
+;; modify it under the terms of the GNU General Public License as
+;; published by the Free Software Foundation; either version 2 of
+;; the License, or (at your option) any later version.
+
+;; This program is distributed in the hope that it will be
+;; useful, but WITHOUT ANY WARRANTY; without even the implied
+;; warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+;; PURPOSE.  See the GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public
+;; License along with this program; if not, write to the Free
+;; Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+;; MA 02111-1307 USA
+
+;;; Commentary:
+
+;; This uses the algorithm described in
+;;   http://www.thaiopensource.com/relaxng/derivative.html
+;;
+;; The schema to be used is contained in the variable
+;; rng-current-schema.  It has the form described in the file
+;; rng-pttrn.el.
+;;
+;;; Code:
+
+(require 'rng-pttrn)
+(require 'rng-util)
+(require 'rng-dt)
+
+(defvar rng-not-allowed-ipattern nil)
+(defvar rng-empty-ipattern nil)
+(defvar rng-text-ipattern nil)
+
+(defvar rng-compile-table nil)
+
+(defvar rng-being-compiled nil
+  "Contains a list of ref patterns currently being compiled.
+Used to detect illegal recursive references.")
+
+(defvar rng-ipattern-table nil)
+
+(defvar rng-last-ipattern-index nil)
+
+(defvar rng-match-state nil
+  "An ipattern representing the current state of validation.")
+
+;;; Inline functions
+
+(defsubst rng-update-match-state (new-state)
+  (if (and (eq new-state rng-not-allowed-ipattern)
+           (not (eq rng-match-state rng-not-allowed-ipattern)))
+      nil
+    (setq rng-match-state new-state)
+    t))
+
+;;; Interned patterns
+
+(eval-when-compile
+  (defun rng-ipattern-slot-accessor-name (slot-name)
+    (intern (concat "rng-ipattern-get-"
+                    (symbol-name slot-name))))
+  
+  (defun rng-ipattern-slot-setter-name (slot-name)
+    (intern (concat "rng-ipattern-set-"
+                    (symbol-name slot-name)))))
+
+(defmacro rng-ipattern-defslot (slot-name index)
+  `(progn
+     (defsubst ,(rng-ipattern-slot-accessor-name slot-name) (ipattern)
+       (aref ipattern ,index))
+     (defsubst ,(rng-ipattern-slot-setter-name slot-name) (ipattern value)
+       (aset ipattern ,index value))))
+
+(rng-ipattern-defslot type 0)
+(rng-ipattern-defslot index 1)
+(rng-ipattern-defslot name-class 2)
+(rng-ipattern-defslot datatype 2)
+(rng-ipattern-defslot after 2)
+(rng-ipattern-defslot child 3)
+(rng-ipattern-defslot value-object 3)
+(rng-ipattern-defslot nullable 4)
+(rng-ipattern-defslot memo-text-typed 5)
+(rng-ipattern-defslot memo-map-start-tag-open-deriv 6)
+(rng-ipattern-defslot memo-map-start-attribute-deriv 7)
+(rng-ipattern-defslot memo-start-tag-close-deriv 8)
+(rng-ipattern-defslot memo-text-only-deriv 9)
+(rng-ipattern-defslot memo-mixed-text-deriv 10)
+(rng-ipattern-defslot memo-map-data-deriv 11)
+(rng-ipattern-defslot memo-end-tag-deriv 12)
+
+(defconst rng-memo-map-alist-max 10)
+
+(defsubst rng-memo-map-get (key mm)
+  "Return the value associated with KEY in memo-map MM."
+  (let ((found (assoc key mm)))
+    (if found
+        (cdr found)
+      (and mm
+           (let ((head (car mm)))
+             (and (hash-table-p head)
+                  (gethash key head)))))))
+
+(defun rng-memo-map-add (key value mm &optional weakness)
+  "Associate KEY with VALUE in memo-map MM and return the new memo-map.
+The new memo-map may or may not be a different object from MM.
+
+Alists are better for small maps. Hash tables are better for large
+maps.  A memo-map therefore starts off as an alist and switches to a
+hash table for large memo-maps. A memo-map is always a list.  An empty
+memo-map is represented by nil. A large memo-map is represented by a
+list containing just a hash-table.  A small memo map is represented by
+a list whose cdr is an alist and whose car is the number of entries in
+the alist. The complete memo-map can be passed to assoc without
+problems: assoc ignores any members that are not cons cells.  There is
+therefore minimal overhead in successful lookups on small lists
+\(which is the most common case)."
+  (if (null mm)
+      (list 1 (cons key value))
+    (let ((head (car mm)))
+      (cond ((hash-table-p head)
+             (puthash key value head)
+             mm)
+            ((>= head rng-memo-map-alist-max)
+             (let ((ht (make-hash-table :test 'equal
+                                        :weakness weakness
+                                        :size (* 2 rng-memo-map-alist-max))))
+               (setq mm (cdr mm))
+               (while mm
+                 (setq head (car mm))
+                 (puthash (car head) (cdr head) ht)
+                 (setq mm (cdr mm)))
+               (cons ht nil)))
+            (t (cons (1+ head)
+                     (cons (cons key value)
+                           (cdr mm))))))))
+             
+(defsubst rng-make-ipattern (type index name-class child nullable)
+  (vector type index name-class child nullable
+          ;; 5 memo-text-typed
+          'unknown
+          ;; 6 memo-map-start-tag-open-deriv
+          nil
+          ;; 7 memo-map-start-attribute-deriv
+          nil
+          ;; 8 memo-start-tag-close-deriv
+          nil
+          ;; 9 memo-text-only-deriv
+          nil
+          ;; 10 memo-mixed-text-deriv
+          nil
+          ;; 11 memo-map-data-deriv
+          nil
+          ;; 12 memo-end-tag-deriv
+          nil))
+
+(defun rng-ipattern-maybe-init ()
+  (unless rng-ipattern-table
+    (setq rng-ipattern-table (make-hash-table :test 'equal))
+    (setq rng-last-ipattern-index -1)))
+
+(defun rng-ipattern-clear ()
+  (when rng-ipattern-table
+    (clrhash rng-ipattern-table))
+  (setq rng-last-ipattern-index -1))
+
+(defsubst rng-gen-ipattern-index ()
+  (setq rng-last-ipattern-index (1+ rng-last-ipattern-index)))
+
+(defun rng-put-ipattern (key type name-class child nullable)
+  (let ((ipattern
+         (rng-make-ipattern type
+                            (rng-gen-ipattern-index)
+                            name-class
+                            child
+                            nullable)))
+    (puthash key ipattern rng-ipattern-table)
+    ipattern))
+
+(defun rng-get-ipattern (key)
+  (gethash key rng-ipattern-table))
+
+(or rng-not-allowed-ipattern
+    (setq rng-not-allowed-ipattern
+          (rng-make-ipattern 'not-allowed -3 nil nil nil)))
+
+(or rng-empty-ipattern
+    (setq rng-empty-ipattern
+          (rng-make-ipattern 'empty -2 nil nil t)))
+
+(or rng-text-ipattern
+    (setq rng-text-ipattern
+          (rng-make-ipattern 'text -1 nil nil t)))
+
+(defconst rng-const-ipatterns
+  (list rng-not-allowed-ipattern
+        rng-empty-ipattern
+        rng-text-ipattern))
+
+(defun rng-intern-after (child after)
+  (if (eq child rng-not-allowed-ipattern)
+      rng-not-allowed-ipattern
+    (let ((key (list 'after
+                     (rng-ipattern-get-index child)
+                     (rng-ipattern-get-index after))))
+      (or (rng-get-ipattern key)
+          (rng-put-ipattern key
+                            'after
+                            after
+                            child
+                            nil)))))
+  
+(defun rng-intern-attribute (name-class ipattern)
+  (if (eq ipattern rng-not-allowed-ipattern)
+      rng-not-allowed-ipattern
+    (let ((key (list 'attribute
+                     name-class
+                     (rng-ipattern-get-index ipattern))))
+      (or (rng-get-ipattern key)
+          (rng-put-ipattern key
+                            'attribute
+                            name-class
+                            ipattern
+                            nil)))))
+
+(defun rng-intern-data (dt matches-anything)
+  (let ((key (list 'data dt)))
+    (or (rng-get-ipattern key)
+        (let ((ipattern (rng-put-ipattern key
+                                          'data
+                                          dt
+                                          nil
+                                          matches-anything)))
+          (rng-ipattern-set-memo-text-typed ipattern
+                                            (not matches-anything))
+          ipattern))))
+
+(defun rng-intern-data-except (dt ipattern)
+  (let ((key (list 'data-except dt ipattern)))
+    (or (rng-get-ipattern key)
+        (rng-put-ipattern key
+                          'data-except
+                          dt
+                          ipattern
+                          nil))))
+
+(defun rng-intern-value (dt obj)
+  (let ((key (list 'value dt obj)))
+    (or (rng-get-ipattern key)
+        (rng-put-ipattern key
+                          'value
+                          dt
+                          obj
+                          nil))))
+
+(defun rng-intern-one-or-more (ipattern)
+  (or (rng-intern-one-or-more-shortcut ipattern)
+      (let ((key (cons 'one-or-more
+                       (list (rng-ipattern-get-index ipattern)))))
+        (or (rng-get-ipattern key)
+            (rng-put-ipattern key
+                              'one-or-more
+                              nil
+                              ipattern
+                              (rng-ipattern-get-nullable ipattern))))))
+
+(defun rng-intern-one-or-more-shortcut (ipattern)
+  (cond ((eq ipattern rng-not-allowed-ipattern)
+         rng-not-allowed-ipattern)
+        ((eq ipattern rng-empty-ipattern)
+         rng-empty-ipattern)
+        ((eq (rng-ipattern-get-type ipattern) 'one-or-more)
+         ipattern)
+        (t nil)))
+
+(defun rng-intern-list (ipattern)
+  (if (eq ipattern rng-not-allowed-ipattern)
+      rng-not-allowed-ipattern
+    (let ((key (cons 'list
+                     (list (rng-ipattern-get-index ipattern)))))
+      (or (rng-get-ipattern key)
+          (rng-put-ipattern key
+                            'list
+                            nil
+                            ipattern
+                            nil)))))
+
+(defun rng-intern-group (ipatterns)
+  "Return a ipattern for the list of group members in IPATTERNS."
+  (or (rng-intern-group-shortcut ipatterns)
+      (let* ((tem (rng-normalize-group-list ipatterns))
+             (normalized (cdr tem)))
+        (or (rng-intern-group-shortcut normalized)
+            (let ((key (cons 'group
+                             (mapcar 'rng-ipattern-get-index normalized))))
+              (or (rng-get-ipattern key)
+                  (rng-put-ipattern key
+                                    'group
+                                    nil
+                                    normalized
+                                    (car tem))))))))
+
+(defun rng-intern-group-shortcut (ipatterns)
+  "Try to shortcut interning a group list.  If successful, return the
+interned pattern.  Otherwise return nil."
+  (while (and ipatterns
+              (eq (car ipatterns) rng-empty-ipattern))
+    (setq ipatterns (cdr ipatterns)))
+  (if ipatterns
+      (let ((ret (car ipatterns)))
+        (if (eq ret rng-not-allowed-ipattern)
+            rng-not-allowed-ipattern
+          (setq ipatterns (cdr ipatterns))
+          (while (and ipatterns ret)
+            (let ((tem (car ipatterns)))
+              (cond ((eq tem rng-not-allowed-ipattern)
+                     (setq ret tem)
+                     (setq ipatterns nil))
+                    ((eq tem rng-empty-ipattern)
+                     (setq ipatterns (cdr ipatterns)))
+                    (t
+                     ;; Stop here rather than continuing
+                     ;; looking for not-allowed patterns.
+                     ;; We do a complete scan elsewhere.
+                     (setq ret nil)))))
+          ret))
+    rng-empty-ipattern))
+
+(defun rng-normalize-group-list (ipatterns)
+  "Normalize a list containing members of a group.
+Expands nested groups, removes empty members, handles notAllowed.
+Returns a pair whose car says whether the list is nullable and whose
+cdr is the normalized list."
+  (let ((nullable t)
+        (result nil)
+        member)
+    (while ipatterns
+      (setq member (car ipatterns))
+      (setq ipatterns (cdr ipatterns))
+      (when nullable
+        (setq nullable (rng-ipattern-get-nullable member)))
+      (cond ((eq (rng-ipattern-get-type member) 'group)
+             (setq result
+                   (nconc (reverse (rng-ipattern-get-child member))
+                          result)))
+            ((eq member rng-not-allowed-ipattern)
+             (setq result (list rng-not-allowed-ipattern))
+             (setq ipatterns nil))
+            ((not (eq member rng-empty-ipattern))
+             (setq result (cons member result)))))
+    (cons nullable (nreverse result))))
+
+(defun rng-intern-interleave (ipatterns)
+  (or (rng-intern-group-shortcut ipatterns)
+      (let* ((tem (rng-normalize-interleave-list ipatterns))
+             (normalized (cdr tem)))
+        (or (rng-intern-group-shortcut normalized)
+            (let ((key (cons 'interleave
+                             (mapcar 'rng-ipattern-get-index normalized))))
+              (or (rng-get-ipattern key)
+                  (rng-put-ipattern key
+                                    'interleave
+                                    nil
+                                    normalized
+                                    (car tem))))))))
+
+(defun rng-normalize-interleave-list (ipatterns)
+  "Normalize a list containing members of an interleave.
+Expands nested groups, removes empty members, handles notAllowed.
+Returns a pair whose car says whether the list is nullable and whose
+cdr is the normalized list."
+  (let ((nullable t)
+        (result nil)
+        member)
+    (while ipatterns
+      (setq member (car ipatterns))
+      (setq ipatterns (cdr ipatterns))
+      (when nullable
+        (setq nullable (rng-ipattern-get-nullable member)))
+      (cond ((eq (rng-ipattern-get-type member) 'interleave)
+             (setq result
+                   (append (rng-ipattern-get-child member)
+                            result)))
+            ((eq member rng-not-allowed-ipattern)
+             (setq result (list rng-not-allowed-ipattern))
+             (setq ipatterns nil))
+            ((not (eq member rng-empty-ipattern))
+             (setq result (cons member result)))))
+    (cons nullable (sort result 'rng-compare-ipattern))))
+
+;; Would be cleaner if this didn't modify IPATTERNS.
+
+(defun rng-intern-choice (ipatterns)
+  "Return a choice ipattern for the list of choices in IPATTERNS.
+May alter IPATTERNS."
+  (or (rng-intern-choice-shortcut ipatterns)
+      (let* ((tem (rng-normalize-choice-list ipatterns))
+             (normalized (cdr tem)))
+        (or (rng-intern-choice-shortcut normalized)
+            (rng-intern-choice1 normalized (car tem))))))
+
+(defun rng-intern-optional (ipattern)
+  (cond ((rng-ipattern-get-nullable ipattern) ipattern)
+        ((eq ipattern rng-not-allowed-ipattern) rng-empty-ipattern)
+        (t (rng-intern-choice1
+            ;; This is sorted since the empty pattern
+            ;; is before everything except not allowed.
+            ;; It cannot have a duplicate empty pattern,
+            ;; since it is not nullable.
+            (cons rng-empty-ipattern
+                  (if (eq (rng-ipattern-get-type ipattern) 'choice)
+                      (rng-ipattern-get-child ipattern)
+                    (list ipattern)))
+            t))))
+
+
+(defun rng-intern-choice1 (normalized nullable)
+  (let ((key (cons 'choice
+                   (mapcar 'rng-ipattern-get-index normalized))))
+    (or (rng-get-ipattern key)
+        (rng-put-ipattern key
+                          'choice
+                          nil
+                          normalized
+                          nullable))))
+                                            
+(defun rng-intern-choice-shortcut (ipatterns)
+  "Try to shortcut interning a choice list.  If successful, return the
+interned pattern.  Otherwise return nil."
+  (while (and ipatterns
+              (eq (car ipatterns)
+                  rng-not-allowed-ipattern))
+    (setq ipatterns (cdr ipatterns)))
+  (if ipatterns
+      (let ((ret (car ipatterns)))
+        (setq ipatterns (cdr ipatterns))
+        (while (and ipatterns ret)
+          (or (eq (car ipatterns) rng-not-allowed-ipattern)
+              (eq (car ipatterns) ret)
+              (setq ret nil))
+          (setq ipatterns (cdr ipatterns)))
+        ret)
+    rng-not-allowed-ipattern))
+
+(defun rng-normalize-choice-list (ipatterns)
+  "Normalize a list of choices, expanding nested choices, removing
+not-allowed members, sorting by index and removing duplicates.  Return
+a pair whose car says whether the list is nullable and whose cdr is
+the normalized list."
+  (let ((sorted t)
+        (nullable nil)
+        (head (cons nil ipatterns)))
+    (let ((tail head)
+          (final-tail nil)
+          (prev-index -100)
+          (cur ipatterns)
+          member)
+      ;; the cdr of tail is always cur
+      (while cur
+        (setq member (car cur))
+        (or nullable
+            (setq nullable (rng-ipattern-get-nullable member)))
+        (cond ((eq (rng-ipattern-get-type member) 'choice)
+               (setq final-tail
+                     (append (rng-ipattern-get-child member)
+                             final-tail))
+               (setq cur (cdr cur))
+               (setq sorted nil)
+               (setcdr tail cur))
+              ((eq member rng-not-allowed-ipattern)
+               (setq cur (cdr cur))
+               (setcdr tail cur))
+              (t
+               (if (and sorted
+                        (let ((cur-index (rng-ipattern-get-index member)))
+                          (if (>= prev-index cur-index)
+                              (or (= prev-index cur-index) ; will remove it
+                                  (setq sorted nil)) ; won't remove it
+                            (setq prev-index cur-index)
+                            ;; won't remove it
+                            nil)))
+                   (progn
+                     ;; remove it
+                     (setq cur (cdr cur))
+                     (setcdr tail cur))
+                 ;; don't remove it
+                 (setq tail cur)
+                 (setq cur (cdr cur))))))
+      (setcdr tail final-tail))
+    (setq head (cdr head))
+    (cons nullable
+          (if sorted
+              head
+            (rng-uniquify-eq (sort head 'rng-compare-ipattern))))))
+
+(defun rng-compare-ipattern (p1 p2)
+  (< (rng-ipattern-get-index p1)
+     (rng-ipattern-get-index p2)))
+
+;;; Name classes
+
+(defsubst rng-name-class-contains (nc nm)
+  (if (consp nc)
+      (equal nm nc)
+    (rng-name-class-contains1 nc nm)))
+
+(defun rng-name-class-contains1 (nc nm)
+  (let ((type (aref nc 0)))
+    (cond ((eq type 'any-name) t)
+          ((eq type 'any-name-except)
+           (not (rng-name-class-contains (aref nc 1) nm)))
+          ((eq type 'ns-name)
+           (eq (car nm) (aref nc 1)))
+          ((eq type 'ns-name-except)
+           (and (eq (car nm) (aref nc 1))
+                (not (rng-name-class-contains (aref nc 2) nm))))
+          ((eq type 'choice)
+           (let ((choices (aref nc 1))
+                 (ret nil))
+             (while choices
+               (if (rng-name-class-contains (car choices) nm)
+                   (progn
+                     (setq choices nil)
+                     (setq ret t))
+                 (setq choices (cdr choices))))
+             ret)))))
+
+(defun rng-name-class-possible-names (nc accum)
+  "Return a list of possible names that nameclass NC can match.
+
+Each possible name should be returned as a (NAMESPACE . LOCAL-NAME)
+pair, where NAMESPACE is a symbol or nil and LOCAL-NAME is a string.
+nil for NAMESPACE matches the absent namespace.  ACCUM is a list of
+names which should be appended to the returned list. The returned list
+may contain duplicates."
+  (if (consp nc)
+      (cons nc accum)
+    (when (eq (aref nc 0) 'choice)
+      (let ((members (aref nc 1)) member)
+        (while members
+          (setq member (car members))
+          (setq accum
+                (if (consp member)
+                    (cons member accum)
+                  (rng-name-class-possible-names member
+                                                 accum)))
+          (setq members (cdr members)))))
+    accum))
+
+;;; Debugging utilities
+
+(defun rng-ipattern-to-string (ipattern)
+  (let ((type (rng-ipattern-get-type ipattern)))
+    (cond ((eq type 'after)
+           (concat (rng-ipattern-to-string
+                    (rng-ipattern-get-child ipattern))
+                   " </> "
+                   (rng-ipattern-to-string
+                    (rng-ipattern-get-after ipattern))))
+          ((eq type 'element)
+           (concat "element "
+                   (rng-name-class-to-string
+                    (rng-ipattern-get-name-class ipattern))
+                   ;; we can get cycles with elements so don't print it out
+                   " {...}"))
+          ((eq type 'attribute)
+           (concat "attribute "
+                   (rng-name-class-to-string
+                    (rng-ipattern-get-name-class ipattern))
+                   " { "
+                   (rng-ipattern-to-string
+                    (rng-ipattern-get-child ipattern))
+                   " } "))
+          ((eq type 'empty) "empty")
+          ((eq type 'text) "text")
+          ((eq type 'not-allowed) "notAllowed")
+          ((eq type 'one-or-more)
+           (concat (rng-ipattern-to-string
+                    (rng-ipattern-get-child ipattern))
+                   "+"))
+          ((eq type 'choice)
+           (concat "("
+                   (mapconcat 'rng-ipattern-to-string
+                              (rng-ipattern-get-child ipattern)
+                              " | ")
+                   ")"))
+          ((eq type 'group)
+           (concat "("
+                   (mapconcat 'rng-ipattern-to-string
+                              (rng-ipattern-get-child ipattern)
+                              ", ")
+                   ")"))
+          ((eq type 'interleave)
+           (concat "("
+                   (mapconcat 'rng-ipattern-to-string
+                              (rng-ipattern-get-child ipattern)
+                              " & ")
+                   ")"))
+          (t (symbol-name type)))))
+
+(defun rng-name-class-to-string (nc)
+  (if (consp nc)
+      (cdr nc)
+    (let ((type (aref nc 0)))
+      (cond ((eq type 'choice)
+             (mapconcat 'rng-name-class-to-string
+                        (aref nc 1)
+                        "|"))
+            (t (concat (symbol-name type) "*"))))))
+
+
+;;; Compiling
+
+(defun rng-compile-maybe-init ()
+  (unless rng-compile-table
+    (setq rng-compile-table (make-hash-table :test 'eq))))
+
+(defun rng-compile-clear ()
+  (when rng-compile-table
+    (clrhash rng-compile-table)))
+
+(defun rng-compile (pattern)
+  (or (gethash pattern rng-compile-table)
+      (let ((ipattern (apply (get (car pattern) 'rng-compile)
+                             (cdr pattern))))
+        (puthash pattern ipattern rng-compile-table)
+        ipattern)))
+
+(put 'empty 'rng-compile 'rng-compile-empty)
+(put 'text 'rng-compile 'rng-compile-text)
+(put 'not-allowed 'rng-compile 'rng-compile-not-allowed)
+(put 'element 'rng-compile 'rng-compile-element)
+(put 'attribute 'rng-compile 'rng-compile-attribute)
+(put 'choice 'rng-compile 'rng-compile-choice)
+(put 'optional 'rng-compile 'rng-compile-optional)
+(put 'group 'rng-compile 'rng-compile-group)
+(put 'interleave 'rng-compile 'rng-compile-interleave)
+(put 'ref 'rng-compile 'rng-compile-ref)
+(put 'one-or-more 'rng-compile 'rng-compile-one-or-more)
+(put 'zero-or-more 'rng-compile 'rng-compile-zero-or-more)
+(put 'mixed 'rng-compile 'rng-compile-mixed)
+(put 'data 'rng-compile 'rng-compile-data)
+(put 'data-except 'rng-compile 'rng-compile-data-except)
+(put 'value 'rng-compile 'rng-compile-value)
+(put 'list 'rng-compile 'rng-compile-list)
+
+(defun rng-compile-not-allowed () rng-not-allowed-ipattern)
+(defun rng-compile-empty () rng-empty-ipattern)
+(defun rng-compile-text () rng-text-ipattern)
+
+(defun rng-compile-element (name-class pattern)
+  ;; don't intern
+  (rng-make-ipattern 'element
+                     (rng-gen-ipattern-index)
+                     (rng-compile-name-class name-class)
+                     pattern            ; compile lazily
+                     nil))
+
+(defun rng-element-get-child (element)
+  (let ((tem (rng-ipattern-get-child element)))
+    (if (vectorp tem)
+        tem
+      (rng-ipattern-set-child element (rng-compile tem)))))
+
+(defun rng-compile-attribute (name-class pattern)
+  (rng-intern-attribute (rng-compile-name-class name-class)
+                        (rng-compile pattern)))
+
+(defun rng-compile-ref (pattern name)
+  (and (memq pattern rng-being-compiled)
+       (rng-compile-error "Reference loop on symbol %s" name))
+  (setq rng-being-compiled
+        (cons pattern rng-being-compiled))
+  (unwind-protect
+      (rng-compile pattern)
+    (setq rng-being-compiled
+          (cdr rng-being-compiled))))
+           
+(defun rng-compile-one-or-more (pattern)
+  (rng-intern-one-or-more (rng-compile pattern)))
+
+(defun rng-compile-zero-or-more (pattern)
+  (rng-intern-optional
+   (rng-intern-one-or-more (rng-compile pattern))))
+
+(defun rng-compile-optional (pattern)
+  (rng-intern-optional (rng-compile pattern)))
+
+(defun rng-compile-mixed (pattern)
+  (rng-intern-interleave (cons rng-text-ipattern
+                               (list (rng-compile pattern)))))
+
+(defun rng-compile-list (pattern)
+  (rng-intern-list (rng-compile pattern)))
+
+(defun rng-compile-choice (&rest patterns)
+  (rng-intern-choice (mapcar 'rng-compile patterns)))
+
+(defun rng-compile-group (&rest patterns)
+  (rng-intern-group (mapcar 'rng-compile patterns)))
+
+(defun rng-compile-interleave (&rest patterns)
+  (rng-intern-interleave (mapcar 'rng-compile patterns)))
+
+(defun rng-compile-dt (name params)
+  (let ((rng-dt-error-reporter 'rng-compile-error))
+    (funcall (let ((uri (car name)))
+               (or (get uri 'rng-dt-compile)
+                   (rng-compile-error "Unknown datatype library %s" uri)))
+             (cdr name)
+             params)))
+
+(defun rng-compile-data (name params)
+  (let ((dt (rng-compile-dt name params)))
+    (rng-intern-data (cdr dt) (car dt))))
+
+(defun rng-compile-data-except (name params pattern)
+  (rng-intern-data-except (cdr (rng-compile-dt name params))
+                          (rng-compile pattern)))
+
+(defun rng-compile-value (name str context)
+  (let* ((dt (cdr (rng-compile-dt name '())))
+         (rng-dt-namespace-context-getter (list 'identity context))
+         (obj (rng-dt-make-value dt str)))
+    (if obj
+        (rng-intern-value dt obj)
+      (rng-compile-error "Value %s is not a valid instance of the datatype %s"
+                         str
+                         name))))
+      
+(defun rng-compile-name-class (nc)
+  (let ((type (car nc)))
+    (cond ((eq type 'name) (nth 1 nc))
+          ((eq type 'any-name) [any-name])
+          ((eq type 'any-name-except)
+           (vector 'any-name-except
+                   (rng-compile-name-class (nth 1 nc))))
+          ((eq type 'ns-name)
+           (vector 'ns-name (nth 1 nc)))
+          ((eq type 'ns-name-except)
+           (vector 'ns-name-except
+                   (nth 1 nc)
+                   (rng-compile-name-class (nth 2 nc))))
+          ((eq type 'choice)
+           (vector 'choice
+                   (mapcar 'rng-compile-name-class (cdr nc))))
+          (t (error "Bad name-class type %s" type)))))
+
+;;; Searching patterns
+
+;; We write this non-recursively to avoid hitting max-lisp-eval-depth
+;; on large schemas.
+
+(defun rng-map-element-attribute (function pattern accum &rest args)
+  (let ((searched (make-hash-table :test 'eq))
+        type todo patterns)
+    (while (progn
+             (setq type (car pattern))
+             (cond ((memq type '(element attribute))
+                    (setq accum
+                          (apply function
+                                 (cons pattern
+                                       (cons accum args))))
+                    (setq pattern (nth 2 pattern)))
+                   ((eq type 'ref)
+                    (setq pattern (nth 1 pattern))
+                    (if (gethash pattern searched)
+                        (setq pattern nil)
+                      (puthash pattern t searched)))
+                   ((memq type '(choice group interleave))
+                    (setq todo (cons (cdr pattern) todo))
+                    (setq pattern nil))
+                   ((memq type '(one-or-more
+                                 zero-or-more
+                                 optional
+                                 mixed))
+                    (setq pattern (nth 1 pattern)))
+                   (t (setq pattern nil)))
+             (cond (pattern)
+                   (patterns
+                    (setq pattern (car patterns))
+                    (setq patterns (cdr patterns))
+                    t)
+                   (todo
+                    (setq patterns (car todo))
+                    (setq todo (cdr todo))
+                    (setq pattern (car patterns))
+                    (setq patterns (cdr patterns))
+                    t))))
+    accum))
+
+(defun rng-find-element-content-pattern (pattern accum name)
+  (if (and (eq (car pattern) 'element)
+           (rng-search-name name (nth 1 pattern)))
+      (cons (rng-compile (nth 2 pattern)) accum)
+    accum))
+
+(defun rng-search-name (name nc)
+  (let ((type (car nc)))
+    (cond ((eq type 'name)
+           (equal (cadr nc) name))
+          ((eq type 'choice)
+           (let ((choices (cdr nc))
+                 (found nil))
+             (while (and choices (not found))
+               (if (rng-search-name name (car choices))
+                   (setq found t)
+                 (setq choices (cdr choices))))
+             found))
+          (t nil))))
+
+(defun rng-find-name-class-uris (nc accum)
+  (let ((type (car nc)))
+    (cond ((eq type 'name)
+           (rng-accum-namespace-uri (car (nth 1 nc)) accum))
+          ((memq type '(ns-name ns-name-except))
+           (rng-accum-namespace-uri (nth 1 nc) accum))
+          ((eq type 'choice)
+           (let ((choices (cdr nc)))
+             (while choices
+               (setq accum
+                     (rng-find-name-class-uris (car choices) accum))
+               (setq choices (cdr choices))))
+           accum)
+          (t accum))))
+
+(defun rng-accum-namespace-uri (ns accum)
+  (if (and ns (not (memq ns accum)))
+      (cons ns accum)
+    accum))
+
+;;; Derivatives
+
+(defun rng-ipattern-text-typed-p (ipattern)
+  (let ((memo (rng-ipattern-get-memo-text-typed ipattern)))
+    (if (eq memo 'unknown)
+        (rng-ipattern-set-memo-text-typed
+         ipattern
+         (rng-ipattern-compute-text-typed-p ipattern))
+      memo)))
+
+(defun rng-ipattern-compute-text-typed-p (ipattern)
+  (let ((type (rng-ipattern-get-type ipattern)))
+    (cond ((eq type 'choice)
+           (let ((cur (rng-ipattern-get-child ipattern))
+                 (ret nil))
+             (while (and cur (not ret))
+               (if (rng-ipattern-text-typed-p (car cur))
+                   (setq ret t)
+                 (setq cur (cdr cur))))
+             ret))
+          ((eq type 'group)
+           (let ((cur (rng-ipattern-get-child ipattern))
+                 (ret nil)
+                 member)
+             (while (and cur (not ret))
+               (setq member (car cur))
+               (if (rng-ipattern-text-typed-p member)
+                   (setq ret t))
+               (setq cur
+                     (and (rng-ipattern-get-nullable member)
+                          (cdr cur))))
+             ret))
+          ((eq type 'after)
+           (rng-ipattern-text-typed-p (rng-ipattern-get-child ipattern)))
+          (t (and (memq type '(value list data data-except)) t)))))
+                                                   
+(defun rng-start-tag-open-deriv (ipattern nm)
+  (or (rng-memo-map-get
+       nm
+       (rng-ipattern-get-memo-map-start-tag-open-deriv ipattern))
+      (rng-ipattern-memo-start-tag-open-deriv
+       ipattern
+       nm 
+       (rng-compute-start-tag-open-deriv ipattern nm))))
+                                                             
+(defun rng-ipattern-memo-start-tag-open-deriv (ipattern nm deriv)
+  (or (memq ipattern rng-const-ipatterns)
+      (rng-ipattern-set-memo-map-start-tag-open-deriv
+       ipattern
+       (rng-memo-map-add nm
+                         deriv
+                         (rng-ipattern-get-memo-map-start-tag-open-deriv
+                          ipattern))))
+  deriv)
+
+(defun rng-compute-start-tag-open-deriv (ipattern nm)
+  (let ((type (rng-ipattern-get-type ipattern)))
+    (cond ((eq type 'choice)
+           (rng-transform-choice `(lambda (p)
+                                    (rng-start-tag-open-deriv p ',nm))
+                                 ipattern))
+          ((eq type 'element)
+           (if (rng-name-class-contains
+                (rng-ipattern-get-name-class ipattern)
+                nm)
+               (rng-intern-after (rng-element-get-child ipattern)
+                                 rng-empty-ipattern)
+             rng-not-allowed-ipattern))
+          ((eq type 'group)
+           (rng-transform-group-nullable
+            `(lambda (p) (rng-start-tag-open-deriv p ',nm))
+            'rng-cons-group-after 
+            ipattern))
+          ((eq type 'interleave)
+           (rng-transform-interleave-single
+            `(lambda (p) (rng-start-tag-open-deriv p ',nm))
+            'rng-subst-interleave-after
+            ipattern))
+          ((eq type 'one-or-more)
+           (rng-apply-after
+            `(lambda (p)
+               (rng-intern-group (list p ,(rng-intern-optional ipattern))))
+            (rng-start-tag-open-deriv (rng-ipattern-get-child ipattern)
+                                      nm)))
+          ((eq type 'after)
+           (rng-apply-after
+            `(lambda (p)
+               (rng-intern-after p
+                                 ,(rng-ipattern-get-after ipattern)))
+            (rng-start-tag-open-deriv (rng-ipattern-get-child ipattern)
+                                      nm)))
+          (t rng-not-allowed-ipattern))))
+
+(defun rng-start-attribute-deriv (ipattern nm)
+  (or (rng-memo-map-get
+       nm
+       (rng-ipattern-get-memo-map-start-attribute-deriv ipattern))
+      (rng-ipattern-memo-start-attribute-deriv
+       ipattern
+       nm 
+       (rng-compute-start-attribute-deriv ipattern nm))))
+                                                             
+(defun rng-ipattern-memo-start-attribute-deriv (ipattern nm deriv)
+  (or (memq ipattern rng-const-ipatterns)
+      (rng-ipattern-set-memo-map-start-attribute-deriv
+       ipattern
+       (rng-memo-map-add
+        nm
+        deriv
+        (rng-ipattern-get-memo-map-start-attribute-deriv ipattern))))
+  deriv)
+
+(defun rng-compute-start-attribute-deriv (ipattern nm)
+  (let ((type (rng-ipattern-get-type ipattern)))
+    (cond ((eq type 'choice)
+           (rng-transform-choice `(lambda (p)
+                                    (rng-start-attribute-deriv p ',nm))
+                                 ipattern))
+          ((eq type 'attribute)
+           (if (rng-name-class-contains
+                (rng-ipattern-get-name-class ipattern)
+                nm)
+               (rng-intern-after (rng-ipattern-get-child ipattern)
+                                 rng-empty-ipattern)
+             rng-not-allowed-ipattern))
+          ((eq type 'group)
+           (rng-transform-interleave-single
+            `(lambda (p) (rng-start-attribute-deriv p ',nm))
+            'rng-subst-group-after 
+            ipattern))
+          ((eq type 'interleave)
+           (rng-transform-interleave-single
+            `(lambda (p) (rng-start-attribute-deriv p ',nm))
+            'rng-subst-interleave-after
+            ipattern))
+          ((eq type 'one-or-more)
+           (rng-apply-after
+            `(lambda (p)
+               (rng-intern-group (list p ,(rng-intern-optional ipattern))))
+            (rng-start-attribute-deriv (rng-ipattern-get-child ipattern)
+                                       nm)))
+          ((eq type 'after)
+           (rng-apply-after
+            `(lambda (p)
+               (rng-intern-after p ,(rng-ipattern-get-after ipattern)))
+            (rng-start-attribute-deriv (rng-ipattern-get-child ipattern)
+                                       nm)))
+          (t rng-not-allowed-ipattern))))
+
+(defun rng-cons-group-after (x y)
+  (rng-apply-after `(lambda (p) (rng-intern-group (cons p ',y)))
+                   x))
+
+(defun rng-subst-group-after (new old list)
+  (rng-apply-after `(lambda (p)
+                      (rng-intern-group (rng-substq p ,old ',list)))
+                   new))
+
+(defun rng-subst-interleave-after (new old list)
+  (rng-apply-after `(lambda (p)
+                      (rng-intern-interleave (rng-substq p ,old ',list)))
+                   new))
+
+(defun rng-apply-after (f ipattern)
+  (let ((type (rng-ipattern-get-type ipattern)))
+    (cond ((eq type 'after)
+           (rng-intern-after
+            (rng-ipattern-get-child ipattern)
+            (funcall f
+                     (rng-ipattern-get-after ipattern))))
+          ((eq type 'choice)
+           (rng-transform-choice `(lambda (x) (rng-apply-after ,f x))
+                                 ipattern))
+          (t rng-not-allowed-ipattern))))
+
+(defun rng-start-tag-close-deriv (ipattern)
+  (or (rng-ipattern-get-memo-start-tag-close-deriv ipattern)
+      (rng-ipattern-set-memo-start-tag-close-deriv
+       ipattern
+       (rng-compute-start-tag-close-deriv ipattern))))
+
+(defconst rng-transform-map
+  '((choice . rng-transform-choice)
+    (group . rng-transform-group)
+    (interleave . rng-transform-interleave)
+    (one-or-more . rng-transform-one-or-more)
+    (after . rng-transform-after-child)))
+
+(defun rng-compute-start-tag-close-deriv (ipattern)
+  (let* ((type (rng-ipattern-get-type ipattern)))
+    (if (eq type 'attribute)
+        rng-not-allowed-ipattern
+      (let ((transform (assq type rng-transform-map)))
+        (if transform
+            (funcall (cdr transform)
+                     'rng-start-tag-close-deriv
+                     ipattern)
+          ipattern)))))
+
+(defun rng-ignore-attributes-deriv (ipattern)
+  (let* ((type (rng-ipattern-get-type ipattern)))
+    (if (eq type 'attribute)
+        rng-empty-ipattern
+      (let ((transform (assq type rng-transform-map)))
+        (if transform
+            (funcall (cdr transform)
+                     'rng-ignore-attributes-deriv
+                     ipattern)
+          ipattern)))))
+  
+(defun rng-text-only-deriv (ipattern)
+  (or (rng-ipattern-get-memo-text-only-deriv ipattern)
+      (rng-ipattern-set-memo-text-only-deriv
+       ipattern
+       (rng-compute-text-only-deriv ipattern))))
+
+(defun rng-compute-text-only-deriv (ipattern)
+  (let* ((type (rng-ipattern-get-type ipattern)))
+    (if (eq type 'element)
+        rng-not-allowed-ipattern
+      (let ((transform (assq type
+                             '((choice . rng-transform-choice)
+                               (group . rng-transform-group)
+                               (interleave . rng-transform-interleave)
+                               (one-or-more . rng-transform-one-or-more)
+                               (after . rng-transform-after-child)))))
+        (if transform
+            (funcall (cdr transform)
+                     'rng-text-only-deriv
+                     ipattern)
+          ipattern)))))
+
+(defun rng-mixed-text-deriv (ipattern)
+  (or (rng-ipattern-get-memo-mixed-text-deriv ipattern)
+      (rng-ipattern-set-memo-mixed-text-deriv
+       ipattern
+       (rng-compute-mixed-text-deriv ipattern))))
+
+(defun rng-compute-mixed-text-deriv (ipattern)
+  (let ((type (rng-ipattern-get-type ipattern)))
+    (cond ((eq type 'text) ipattern)
+          ((eq type 'after)
+           (rng-transform-after-child 'rng-mixed-text-deriv
+                                      ipattern))
+          ((eq type 'choice)
+           (rng-transform-choice 'rng-mixed-text-deriv
+                                 ipattern))
+          ((eq type 'one-or-more)
+           (rng-intern-group
+            (list (rng-mixed-text-deriv
+                   (rng-ipattern-get-child ipattern))
+                  (rng-intern-optional ipattern))))
+          ((eq type 'group)
+           (rng-transform-group-nullable
+            'rng-mixed-text-deriv
+            (lambda (x y) (rng-intern-group (cons x y)))
+            ipattern))
+          ((eq type 'interleave)
+           (rng-transform-interleave-single
+            'rng-mixed-text-deriv
+            (lambda (new old list) (rng-intern-interleave
+                                    (rng-substq new old list)))
+            ipattern))
+          ((and (eq type 'data)
+                (not (rng-ipattern-get-memo-text-typed ipattern)))
+           ipattern)
+          (t rng-not-allowed-ipattern))))
+
+(defun rng-end-tag-deriv (ipattern)
+  (or (rng-ipattern-get-memo-end-tag-deriv ipattern)
+      (rng-ipattern-set-memo-end-tag-deriv
+       ipattern
+       (rng-compute-end-tag-deriv ipattern))))
+
+(defun rng-compute-end-tag-deriv (ipattern)
+  (let ((type (rng-ipattern-get-type ipattern)))
+    (cond ((eq type 'choice)
+           (rng-intern-choice
+            (mapcar 'rng-end-tag-deriv
+                    (rng-ipattern-get-child ipattern))))
+          ((eq type 'after)
+           (if (rng-ipattern-get-nullable
+                (rng-ipattern-get-child ipattern))
+               (rng-ipattern-get-after ipattern)
+             rng-not-allowed-ipattern))
+          (t rng-not-allowed-ipattern))))
+
+(defun rng-data-deriv (ipattern value)
+  (or (rng-memo-map-get value
+                        (rng-ipattern-get-memo-map-data-deriv ipattern))
+      (and (rng-memo-map-get
+            (cons value (rng-namespace-context-get-no-trace))
+            (rng-ipattern-get-memo-map-data-deriv ipattern))
+           (rng-memo-map-get
+            (cons value (apply (car rng-dt-namespace-context-getter)
+                               (cdr rng-dt-namespace-context-getter)))
+            (rng-ipattern-get-memo-map-data-deriv ipattern)))
+      (let* ((used-context (vector nil))
+             (rng-dt-namespace-context-getter
+              (cons 'rng-namespace-context-tracer
+                    (cons used-context
+                          rng-dt-namespace-context-getter)))
+             (deriv (rng-compute-data-deriv ipattern value)))
+        (rng-ipattern-memo-data-deriv ipattern
+                                      value
+                                      (aref used-context 0)
+                                      deriv))))
+
+(defun rng-namespace-context-tracer (used getter &rest args)
+  (let ((context (apply getter args)))
+    (aset used 0 context)
+    context))
+
+(defun rng-namespace-context-get-no-trace ()
+  (let ((tem rng-dt-namespace-context-getter))
+    (while (and tem (eq (car tem) 'rng-namespace-context-tracer))
+      (setq tem (cddr tem)))
+    (apply (car tem) (cdr tem))))
+
+(defconst rng-memo-data-deriv-max-length 80
+  "Don't memoize data-derivs for values longer than this.")
+
+(defun rng-ipattern-memo-data-deriv (ipattern value context deriv)
+  (or (memq ipattern rng-const-ipatterns)
+      (> (length value) rng-memo-data-deriv-max-length)
+      (rng-ipattern-set-memo-map-data-deriv
+       ipattern
+       (rng-memo-map-add (if context (cons value context) value)
+                         deriv
+                         (rng-ipattern-get-memo-map-data-deriv ipattern)
+                         t)))
+  deriv)
+
+(defun rng-compute-data-deriv (ipattern value)
+  (let ((type (rng-ipattern-get-type ipattern)))
+    (cond ((eq type 'text) ipattern)
+          ((eq type 'choice)
+           (rng-transform-choice `(lambda (p) (rng-data-deriv p ,value))
+                                 ipattern))
+          ((eq type 'group)
+           (rng-transform-group-nullable
+            `(lambda (p) (rng-data-deriv p ,value))
+            (lambda (x y) (rng-intern-group (cons x y)))
+            ipattern))
+          ((eq type 'one-or-more)
+           (rng-intern-group (list (rng-data-deriv
+                                    (rng-ipattern-get-child ipattern)
+                                    value)
+                                   (rng-intern-optional ipattern))))
+          ((eq type 'after)
+           (let ((child (rng-ipattern-get-child ipattern)))
+             (if (or (rng-ipattern-get-nullable
+                      (rng-data-deriv child value))
+                     (and (rng-ipattern-get-nullable child)
+                          (rng-blank-p value)))
+                 (rng-ipattern-get-after ipattern)
+               rng-not-allowed-ipattern)))
+          ((eq type 'data)
+           (if (rng-dt-make-value (rng-ipattern-get-datatype ipattern)
+                                  value)
+               rng-empty-ipattern
+             rng-not-allowed-ipattern))
+          ((eq type 'data-except)
+           (if (and (rng-dt-make-value (rng-ipattern-get-datatype ipattern)
+                                       value)
+                    (not (rng-ipattern-get-nullable
+                          (rng-data-deriv
+                           (rng-ipattern-get-child ipattern)
+                           value))))
+               rng-empty-ipattern
+             rng-not-allowed-ipattern))
+          ((eq type 'value)
+           (if (equal (rng-dt-make-value (rng-ipattern-get-datatype ipattern)
+                                         value)
+                      (rng-ipattern-get-value-object ipattern))
+               rng-empty-ipattern
+             rng-not-allowed-ipattern))
+          ((eq type 'list)
+           (let ((tokens (split-string value))
+                 (state (rng-ipattern-get-child ipattern)))
+             (while (and tokens
+                         (not (eq state rng-not-allowed-ipattern)))
+               (setq state (rng-data-deriv state (car tokens)))
+               (setq tokens (cdr tokens)))
+             (if (rng-ipattern-get-nullable state)
+                 rng-empty-ipattern
+               rng-not-allowed-ipattern)))
+          ;; don't think interleave can occur
+          ;; since we do text-only-deriv first
+          (t rng-not-allowed-ipattern))))
+
+(defun rng-transform-multi (f ipattern interner)
+  (let* ((members (rng-ipattern-get-child ipattern))
+         (transformed (mapcar f members)))
+    (if (rng-members-eq members transformed)
+        ipattern
+      (funcall interner transformed))))
+
+(defun rng-transform-choice (f ipattern)
+  (rng-transform-multi f ipattern 'rng-intern-choice))
+
+(defun rng-transform-group (f ipattern)
+  (rng-transform-multi f ipattern 'rng-intern-group))
+
+(defun rng-transform-interleave (f ipattern)
+  (rng-transform-multi f ipattern 'rng-intern-interleave))
+
+(defun rng-transform-one-or-more (f ipattern)
+  (let* ((child (rng-ipattern-get-child ipattern))
+         (transformed (funcall f child)))
+    (if (eq child transformed)
+        ipattern
+      (rng-intern-one-or-more transformed))))
+
+(defun rng-transform-after-child (f ipattern)
+  (let* ((child (rng-ipattern-get-child ipattern))
+         (transformed (funcall f child)))
+    (if (eq child transformed)
+        ipattern
+      (rng-intern-after transformed
+                        (rng-ipattern-get-after ipattern)))))
+
+(defun rng-transform-interleave-single (f subster ipattern)
+  (let ((children (rng-ipattern-get-child ipattern))
+        found)
+    (while (and children (not found))
+      (let* ((child (car children))
+             (transformed (funcall f child)))
+        (if (eq transformed rng-not-allowed-ipattern)
+            (setq children (cdr children))
+          (setq found
+                (funcall subster
+                         transformed
+                         child
+                         (rng-ipattern-get-child ipattern))))))
+    (or found
+        rng-not-allowed-ipattern)))
+
+(defun rng-transform-group-nullable (f conser ipattern)
+  "Given a group x1,...,xn,y1,...,yn where the xs are all
+nullable and y1 isn't, return a choice
+  (conser f(x1) x2,...,xm,y1,...,yn)
+  |(conser f(x2) x3,...,xm,y1,...,yn)
+  |...
+  |(conser f(xm) y1,...,yn)
+  |(conser f(y1) y2,...,yn)"
+  (rng-intern-choice
+   (rng-transform-group-nullable-gen-choices
+    f
+    conser
+    (rng-ipattern-get-child ipattern))))
+
+(defun rng-transform-group-nullable-gen-choices (f conser members)
+  (let ((head (car members))
+        (tail (cdr members)))
+    (if tail
+        (cons (funcall conser (funcall f head) tail)
+              (if (rng-ipattern-get-nullable head)
+                  (rng-transform-group-nullable-gen-choices f conser tail)
+                nil))
+      (list (funcall f head)))))
+
+(defun rng-members-eq (list1 list2)
+  (while (and list1
+              list2
+              (eq (car list1) (car list2)))
+    (setq list1 (cdr list1))
+    (setq list2 (cdr list2)))
+  (and (null list1) (null list2)))
+    
+
+(defun rng-ipattern-after (ipattern)
+  (let ((type (rng-ipattern-get-type ipattern)))
+    (cond ((eq type 'choice)
+           (rng-transform-choice 'rng-ipattern-after ipattern))
+          ((eq type 'after)
+           (rng-ipattern-get-after ipattern))
+          ((eq  type 'not-allowed)
+           ipattern)
+          (t (error "Internal error in rng-ipattern-after: unexpected type %s" type)))))
+
+(defun rng-unknown-start-tag-open-deriv (ipattern)
+  (rng-intern-after (rng-compile rng-any-content) ipattern))
+
+(defun rng-ipattern-optionalize-elements (ipattern)
+  (let* ((type (rng-ipattern-get-type ipattern))
+         (transform (assq type rng-transform-map)))
+    (cond (transform
+           (funcall (cdr transform)
+                    'rng-ipattern-optionalize-elements
+                    ipattern))
+          ((eq type 'element)
+           (rng-intern-optional ipattern))
+          (t ipattern))))
+
+(defun rng-ipattern-empty-before-p (ipattern)
+  (let ((type (rng-ipattern-get-type ipattern)))
+    (cond ((eq type 'after)
+           (eq (rng-ipattern-get-child ipattern) rng-empty-ipattern))
+          ((eq type 'choice)
+           (let ((members (rng-ipattern-get-child ipattern))
+                 (ret t))
+             (while (and members ret)
+               (or (rng-ipattern-empty-before-p (car members))
+                   (setq ret nil))
+               (setq members (cdr members)))
+             ret))
+          (t nil))))
+
+(defun rng-ipattern-possible-start-tags (ipattern accum)
+  (let ((type (rng-ipattern-get-type ipattern)))
+    (cond ((eq type 'after)
+           (rng-ipattern-possible-start-tags
+            (rng-ipattern-get-child ipattern)
+            accum))
+          ((memq type '(choice interleave))
+           (let ((members (rng-ipattern-get-child ipattern)))
+             (while members
+               (setq accum
+                     (rng-ipattern-possible-start-tags (car members)
+                                                       accum))
+               (setq members (cdr members))))
+           accum)
+          ((eq type 'group)
+           (let ((members (rng-ipattern-get-child ipattern)))
+             (while members
+               (setq accum
+                     (rng-ipattern-possible-start-tags (car members)
+                                                       accum))
+               (setq members
+                     (and (rng-ipattern-get-nullable (car members))
+                          (cdr members)))))
+           accum)
+          ((eq type 'element)
+           (if (eq (rng-element-get-child ipattern) rng-not-allowed-ipattern)
+               accum
+             (rng-name-class-possible-names
+              (rng-ipattern-get-name-class ipattern)
+              accum)))
+          ((eq type 'one-or-more)
+           (rng-ipattern-possible-start-tags
+            (rng-ipattern-get-child ipattern)
+            accum))
+          (t accum))))
+
+(defun rng-ipattern-start-tag-possible-p (ipattern)
+  (let ((type (rng-ipattern-get-type ipattern)))
+    (cond ((memq type '(after one-or-more))
+           (rng-ipattern-start-tag-possible-p
+            (rng-ipattern-get-child ipattern)))
+          ((memq type '(choice interleave))
+           (let ((members (rng-ipattern-get-child ipattern))
+                 (possible nil))
+             (while (and members (not possible))
+               (setq possible
+                     (rng-ipattern-start-tag-possible-p (car members)))
+               (setq members (cdr members)))
+             possible))
+          ((eq type 'group)
+           (let ((members (rng-ipattern-get-child ipattern))
+                 (possible nil))
+             (while (and members (not possible))
+               (setq possible
+                     (rng-ipattern-start-tag-possible-p (car members)))
+               (setq members
+                     (and (rng-ipattern-get-nullable (car members))
+                          (cdr members))))
+             possible))
+          ((eq type 'element)
+           (not (eq (rng-element-get-child ipattern)
+                    rng-not-allowed-ipattern)))
+          (t nil))))
+
+(defun rng-ipattern-possible-attributes (ipattern accum)
+  (let ((type (rng-ipattern-get-type ipattern)))
+    (cond ((eq type 'after)
+           (rng-ipattern-possible-attributes (rng-ipattern-get-child ipattern)
+                                             accum))
+          ((memq type '(choice interleave group))
+           (let ((members (rng-ipattern-get-child ipattern)))
+             (while members
+               (setq accum
+                     (rng-ipattern-possible-attributes (car members)
+                                                       accum))
+               (setq members (cdr members))))
+           accum)
+          ((eq type 'attribute)
+           (rng-name-class-possible-names
+            (rng-ipattern-get-name-class ipattern)
+            accum))
+          ((eq type 'one-or-more)
+           (rng-ipattern-possible-attributes
+            (rng-ipattern-get-child ipattern)
+            accum))
+          (t accum))))
+
+(defun rng-ipattern-possible-values (ipattern accum)
+  (let ((type (rng-ipattern-get-type ipattern)))
+    (cond ((eq type 'after)
+           (rng-ipattern-possible-values (rng-ipattern-get-child ipattern)
+                                         accum))
+          ((eq type 'choice)
+           (let ((members (rng-ipattern-get-child ipattern)))
+             (while members
+               (setq accum
+                     (rng-ipattern-possible-values (car members)
+                                                   accum))
+               (setq members (cdr members))))
+           accum)
+          ((eq type 'value)
+           (let ((value-object (rng-ipattern-get-value-object ipattern)))
+             (if (stringp value-object)
+                 (cons value-object accum)
+               accum)))
+          (t accum))))
+
+(defun rng-ipattern-required-element (ipattern)
+  (let ((type (rng-ipattern-get-type ipattern)))
+    (cond ((memq type '(after one-or-more))
+           (rng-ipattern-required-element (rng-ipattern-get-child ipattern)))
+          ((eq type 'choice)
+           (let* ((members (rng-ipattern-get-child ipattern))
+                  (required (rng-ipattern-required-element (car members))))
+             (while (and required
+                         (setq members (cdr members)))
+               (unless (equal required
+                              (rng-ipattern-required-element (car members)))
+                   (setq required nil)))
+             required))
+          ((eq type 'group)
+           (let ((members (rng-ipattern-get-child ipattern))
+                 required)
+             (while (and (not (setq required
+                                    (rng-ipattern-required-element
+                                     (car members))))
+                         (rng-ipattern-get-nullable (car members))
+                         (setq members (cdr members))))
+             required))
+          ((eq type 'interleave)
+           (let ((members (rng-ipattern-get-child ipattern))
+                 required)
+             (while members
+               (let ((tem (rng-ipattern-required-element (car members))))
+                 (cond ((not tem)
+                        (setq members (cdr members)))
+                       ((not required)
+                        (setq required tem)
+                        (setq members (cdr members)))
+                       ((equal required tem)
+                        (setq members (cdr members)))
+                       (t
+                        (setq required nil)
+                        (setq members nil)))))
+             required))
+          ((eq type 'element)
+           (let ((nc (rng-ipattern-get-name-class ipattern)))
+             (and (consp nc)
+                  (not (eq (rng-element-get-child ipattern)
+                           rng-not-allowed-ipattern))
+                  nc))))))
+
+(defun rng-ipattern-required-attributes (ipattern accum)
+  (let ((type (rng-ipattern-get-type ipattern)))
+    (cond ((eq type 'after)
+           (rng-ipattern-required-attributes (rng-ipattern-get-child ipattern)
+                                             accum))
+          ((memq type '(interleave group))
+           (let ((members (rng-ipattern-get-child ipattern)))
+             (while members
+               (setq accum
+                     (rng-ipattern-required-attributes (car members)
+                                                       accum))
+               (setq members (cdr members))))
+           accum)
+          ((eq type 'choice)
+           (let ((members (rng-ipattern-get-child ipattern))
+                 in-all in-this new-in-all)
+             (setq in-all
+                   (rng-ipattern-required-attributes (car members)
+                                                     nil))
+             (while (and in-all (setq members (cdr members)))
+               (setq in-this
+                     (rng-ipattern-required-attributes (car members) nil))
+               (setq new-in-all nil)
+               (while in-this
+                 (when (member (car in-this) in-all)
+                   (setq new-in-all
+                         (cons (car in-this) new-in-all)))
+                 (setq in-this (cdr in-this)))
+               (setq in-all new-in-all))
+             (append in-all accum)))
+          ((eq type 'attribute)
+           (let ((nc (rng-ipattern-get-name-class ipattern)))
+             (if (consp nc)
+                 (cons nc accum)
+               accum)))
+          ((eq type 'one-or-more)
+           (rng-ipattern-required-attributes (rng-ipattern-get-child ipattern)
+                                             accum))
+          (t accum))))
+
+(defun rng-compile-error (&rest args)
+  (signal 'rng-compile-error
+          (list (apply 'format args))))
+
+(put 'rng-compile-error
+     'error-conditions
+     '(error rng-error rng-compile-error))
+
+(put 'rng-compile-error
+     'error-message
+     "Incorrect schema")
+
+
+;;; External API
+
+(defsubst rng-match-state () rng-match-state)
+
+(defsubst rng-set-match-state (state)
+  (setq rng-match-state state))
+      
+(defsubst rng-match-state-equal (state)
+  (eq state rng-match-state))
+
+(defun rng-schema-changed ()
+  (rng-ipattern-clear)
+  (rng-compile-clear))
+
+(defun rng-match-init-buffer ()
+  (make-local-variable 'rng-compile-table)
+  (make-local-variable 'rng-ipattern-table)
+  (make-local-variable 'rng-last-ipattern-index))
+
+(defun rng-match-start-document ()
+  (rng-ipattern-maybe-init)
+  (rng-compile-maybe-init)
+  (add-hook 'rng-schema-change-hook 'rng-schema-changed nil t)
+  (setq rng-match-state (rng-compile rng-current-schema)))
+
+(defun rng-match-start-tag-open (name)
+  (rng-update-match-state (rng-start-tag-open-deriv rng-match-state
+                                                    name)))
+
+(defun rng-match-attribute-name (name)
+  (rng-update-match-state (rng-start-attribute-deriv rng-match-state
+                                                     name)))
+
+(defun rng-match-attribute-value (value)
+  (rng-update-match-state (rng-data-deriv rng-match-state
+                                          value)))
+
+(defun rng-match-element-value (value)
+  (and (rng-update-match-state (rng-text-only-deriv rng-match-state))
+       (rng-update-match-state (rng-data-deriv rng-match-state
+                                               value))))
+
+(defun rng-match-start-tag-close ()
+  (rng-update-match-state (rng-start-tag-close-deriv rng-match-state)))
+
+(defun rng-match-mixed-text ()
+  (rng-update-match-state (rng-mixed-text-deriv rng-match-state)))
+
+(defun rng-match-end-tag ()
+  (rng-update-match-state (rng-end-tag-deriv rng-match-state)))
+
+(defun rng-match-after ()
+  (rng-update-match-state
+   (rng-ipattern-after rng-match-state)))
+
+(defun rng-match-out-of-context-start-tag-open (name)
+  (let* ((found (rng-map-element-attribute 'rng-find-element-content-pattern
+                                           rng-current-schema
+                                           nil
+                                           name))
+         (content-pattern (if found
+                              (rng-intern-choice found)
+                            rng-not-allowed-ipattern)))
+    (rng-update-match-state
+     (rng-intern-after content-pattern rng-match-state))))
+
+(defun rng-match-possible-namespace-uris ()
+  "Return a list of all the namespace URIs used in the current schema.
+The absent URI is not included, so the result is always list of symbols."
+  (rng-map-element-attribute (lambda (pattern accum)
+                               (rng-find-name-class-uris (nth 1 pattern)
+                                                         accum))
+                             rng-current-schema
+                             nil))
+
+(defun rng-match-unknown-start-tag-open ()
+  (rng-update-match-state
+   (rng-unknown-start-tag-open-deriv rng-match-state)))
+
+(defun rng-match-optionalize-elements ()
+  (rng-update-match-state
+   (rng-ipattern-optionalize-elements rng-match-state)))
+
+(defun rng-match-ignore-attributes ()
+  (rng-update-match-state
+   (rng-ignore-attributes-deriv rng-match-state)))
+
+(defun rng-match-text-typed-p ()
+  (rng-ipattern-text-typed-p rng-match-state))
+
+(defun rng-match-empty-content ()
+  (if (rng-match-text-typed-p)
+      (rng-match-element-value "")
+    (rng-match-end-tag)))
+
+(defun rng-match-empty-before-p ()
+  "Return non-nil if what can be matched before an end-tag is empty.
+In other words, return non-nil if the pattern for what can be matched
+for an end-tag is equivalent to empty."
+  (rng-ipattern-empty-before-p rng-match-state))
+
+(defun rng-match-infer-start-tag-namespace (local-name)
+  (let ((ncs (rng-ipattern-possible-start-tags rng-match-state nil))
+        (nc nil)
+        (ns nil))
+    (while ncs
+      (setq nc (car ncs))
+      (if (and (equal (cdr nc) local-name)
+               (symbolp (car nc)))
+          (cond ((not ns)
+                 ;; first possible namespace
+                 (setq ns (car nc))
+                 (setq ncs (cdr ncs)))
+                ((equal ns (car nc))
+                 ;; same as first namespace
+                 (setq ncs (cdr ncs)))
+                (t
+                 ;; more than one possible namespace
+                 (setq ns nil)
+                 (setq ncs nil)))
+        (setq ncs (cdr ncs))))
+    ns))
+
+(defun rng-match-nullable-p ()
+  (rng-ipattern-get-nullable rng-match-state))
+
+(defun rng-match-possible-start-tag-names ()
+  "Return a list of possible names that would be valid for start-tags.
+
+Each possible name is returned as a (NAMESPACE . LOCAL-NAME) pair,
+where NAMESPACE is a symbol or nil (meaning the absent namespace) and
+LOCAL-NAME is a string. The returned list may contain duplicates."
+  (rng-ipattern-possible-start-tags rng-match-state nil))
+
+;; This is no longer used.  It might be useful so leave it in for now.
+(defun rng-match-start-tag-possible-p ()
+  "Return non-nil if a start-tag is possible."
+  (rng-ipattern-start-tag-possible-p rng-match-state))
+
+(defun rng-match-possible-attribute-names ()
+  "Return a list of possible names that would be valid for attributes.
+
+See the function `rng-match-possible-start-tag-names' for
+more information."
+  (rng-ipattern-possible-attributes rng-match-state nil))
+
+(defun rng-match-possible-value-strings ()
+  "Return a list of strings that would be valid as content.
+The list may contain duplicates. Typically, the list will not
+be exhaustive."
+  (rng-ipattern-possible-values rng-match-state nil))
+
+(defun rng-match-required-element-name ()
+  "Return the name of an element which must occur, or nil if none."
+  (rng-ipattern-required-element rng-match-state))
+
+(defun rng-match-required-attribute-names ()
+  "Return a list of names of attributes which must all occur."
+  (rng-ipattern-required-attributes rng-match-state nil))
+
+(defmacro rng-match-save (&rest body)
+  (let ((state (make-symbol "state")))
+    `(let ((,state rng-match-state))
+       (unwind-protect
+           (progn ,@body)
+         (setq rng-match-state ,state)))))
+
+(put 'rng-match-save 'lisp-indent-function 0)
+(def-edebug-spec rng-match-save t)
+
+(defmacro rng-match-with-schema (schema &rest body)
+  `(let ((rng-current-schema ,schema)
+         rng-match-state
+         rng-compile-table
+         rng-ipattern-table
+         rng-last-ipattern-index)
+     (rng-ipattern-maybe-init)
+     (rng-compile-maybe-init)
+     (setq rng-match-state (rng-compile rng-current-schema))
+     ,@body))
+
+(put 'rng-match-with-schema 'lisp-indent-function 1)
+(def-edebug-spec rng-match-with-schema t)
+
+(provide 'rng-match)
+    
+;;; rng-match.el ends here
diff --git a/lisp/nxml/rng-nxml.el b/lisp/nxml/rng-nxml.el
new file mode 100644
index 00000000000..46867a62545
--- /dev/null
+++ b/lisp/nxml/rng-nxml.el
@@ -0,0 +1,591 @@
+;;; rng-nxml.el --- make nxml-mode take advantage of rng-validate-mode
+
+;; Copyright (C) 2003 Free Software Foundation, Inc.
+
+;; Author: James Clark
+;; Keywords: XML, RelaxNG
+
+;; This program is free software; you can redistribute it and/or
+;; modify it under the terms of the GNU General Public License as
+;; published by the Free Software Foundation; either version 2 of
+;; the License, or (at your option) any later version.
+
+;; This program is distributed in the hope that it will be
+;; useful, but WITHOUT ANY WARRANTY; without even the implied
+;; warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+;; PURPOSE.  See the GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public
+;; License along with this program; if not, write to the Free
+;; Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+;; MA 02111-1307 USA
+
+;;; Commentary:
+
+;;; Code:
+
+(require 'easymenu)
+(require 'xmltok)
+(require 'nxml-util)
+(require 'nxml-ns)
+(require 'rng-match)
+(require 'rng-util)
+(require 'rng-valid)
+(require 'nxml-mode)
+(require 'rng-loc)
+
+(defcustom rng-nxml-auto-validate-flag t
+  "*Non-nil means automatically turn on validation with nxml-mode."
+  :type 'boolean
+  :group 'relax-ng)
+
+(defvar rng-preferred-prefix-alist-default nil
+  "Default value for variable `rng-preferred-prefix-alist'.")
+
+(defcustom rng-preferred-prefix-alist rng-preferred-prefix-alist-default
+  "*Alist of namespaces vs preferred prefixes."
+  :type '(repeat (cons :tag "With"
+                       (string :tag "this namespace URI")
+                       (string :tag "use this prefix")))
+  :group 'relax-ng)
+
+(defvar rng-complete-end-tags-after-< t
+  "*Non-nil means immediately after < complete on end-tag names.
+Complete on start-tag names regardless.")
+
+(defvar rng-nxml-easy-menu
+  '("XML"
+    ["Show Outline Only" nxml-hide-all-text-content]
+    ["Show Everything" nxml-show-all]
+    "---"
+    ["Validation" rng-validate-mode
+     :style toggle
+     :selected rng-validate-mode]
+    "---"
+    ("Set Schema"
+     ["Automatically" rng-auto-set-schema]
+     ("For Document Type"
+      :filter (lambda (menu)
+                (mapcar (lambda (type-id)
+                          (vector type-id
+                                  (list 'rng-set-document-type
+                                        type-id)))
+                        (rng-possible-type-ids))))
+     ["Any Well-Formed XML" rng-set-vacuous-schema]
+     ["File..." rng-set-schema-file])
+    ["Show Schema Location" rng-what-schema]
+    ["Save Schema Location" rng-save-schema-location :help
+     "Save the location of the schema currently being used for this buffer"]
+    "---"
+    ["First Error" rng-first-error :active rng-validate-mode]
+    ["Next Error" rng-next-error :active rng-validate-mode]
+    "---"
+    ["Customize nXML" (customize-group 'nxml)]
+    "---"
+    ["Show nXML Version" nxml-version]))
+
+;;;###autoload
+(defun rng-nxml-mode-init ()
+  "Initialize `nxml-mode' to take advantage of `rng-validate-mode'.
+This is typically called from `nxml-mode-hook'.
+Validation will be enabled if `rng-nxml-auto-validate-flag' is non-nil."
+  (interactive)
+  (define-key nxml-mode-map "\C-c\C-v" 'rng-validate-mode)
+  (define-key nxml-mode-map "\C-c\C-s\C-w" 'rng-what-schema)
+  (define-key nxml-mode-map "\C-c\C-s\C-a" 'rng-auto-set-schema-and-validate)
+  (define-key nxml-mode-map "\C-c\C-s\C-f" 'rng-set-schema-file-and-validate)
+  (define-key nxml-mode-map "\C-c\C-s\C-l" 'rng-save-schema-location)
+  (define-key nxml-mode-map "\C-c\C-s\C-t" 'rng-set-document-type-and-validate)
+  (define-key nxml-mode-map "\C-c\C-n" 'rng-next-error)
+  (easy-menu-define rng-nxml-menu nxml-mode-map
+    "Menu for nxml-mode used with rng-validate-mode."
+    rng-nxml-easy-menu)
+  (setq mode-line-process
+        '(rng-validate-mode (:eval (rng-compute-mode-line-string))))
+  (cond (rng-nxml-auto-validate-flag
+         (rng-validate-mode 1)
+         (add-hook 'nxml-completion-hook 'rng-complete nil t)
+         (add-hook 'nxml-in-mixed-content-hook 'rng-in-mixed-content-p nil t))
+        (t
+         (rng-validate-mode 0)
+         (remove-hook 'nxml-completion-hook 'rng-complete t)
+         (remove-hook 'nxml-in-mixed-content-hook 'rng-in-mixed-content-p t))))
+
+(defvar rng-tag-history nil)
+(defvar rng-attribute-name-history nil)
+(defvar rng-attribute-value-history nil)
+
+(defvar rng-complete-target-names nil)
+(defvar rng-complete-name-attribute-flag nil)
+(defvar rng-complete-extra-strings nil)
+
+(defun rng-complete ()
+  "Complete the string before point using the current schema.
+Return non-nil if in a context it understands."
+  (interactive)
+  (and rng-validate-mode
+       (let ((lt-pos (save-excursion (search-backward "<" nil t)))
+             xmltok-dtd)
+         (and lt-pos
+              (= (rng-set-state-after lt-pos) lt-pos)
+              (or (rng-complete-tag lt-pos)
+                  (rng-complete-end-tag lt-pos)
+                  (rng-complete-attribute-name lt-pos)
+                  (rng-complete-attribute-value lt-pos))))))
+
+(defconst rng-in-start-tag-name-regex
+  (replace-regexp-in-string
+   "w"
+   xmltok-ncname-regexp
+   "<\\(?:w\\(?::w?\\)?\\)?\\="
+   t
+   t))
+
+(defun rng-complete-tag (lt-pos)
+  (let (rng-complete-extra-strings)
+    (when (and (= lt-pos (1- (point)))
+               rng-complete-end-tags-after-<
+               rng-open-elements
+               (not (eq (car rng-open-elements) t))
+               (or rng-collecting-text
+                   (rng-match-save
+                     (rng-match-end-tag))))
+      (setq rng-complete-extra-strings
+            (cons (concat "/"
+                          (if (caar rng-open-elements)
+                              (concat (caar rng-open-elements)
+                                      ":"
+                                      (cdar rng-open-elements))
+                            (cdar rng-open-elements)))
+                  rng-complete-extra-strings)))
+    (when (save-excursion
+            (re-search-backward rng-in-start-tag-name-regex
+                                lt-pos
+                                t))
+      (and rng-collecting-text (rng-flush-text))
+      (let ((completion
+             (let ((rng-complete-target-names
+                    (rng-match-possible-start-tag-names))
+                   (rng-complete-name-attribute-flag nil))
+               (rng-complete-before-point (1+ lt-pos)
+                                          'rng-complete-qname-function
+                                          "Tag: "
+                                          nil
+                                          'rng-tag-history)))
+            name)
+        (when completion
+          (cond ((rng-qname-p completion)
+                 (setq name (rng-expand-qname completion
+                                              t
+                                              'rng-start-tag-expand-recover))
+                 (when (and name
+                            (rng-match-start-tag-open name)
+                            (or (not (rng-match-start-tag-close))
+                                ;; need a namespace decl on the root element
+                                (and (car name)
+                                     (not rng-open-elements))))
+                   ;; attributes are required
+                   (insert " ")))
+                ((member completion rng-complete-extra-strings)
+                 (insert ">")))))
+      t)))
+
+(defconst rng-in-end-tag-name-regex
+  (replace-regexp-in-string
+   "w"
+   xmltok-ncname-regexp
+   "</\\(?:w\\(?::w?\\)?\\)?\\="
+   t
+   t))
+
+(defun rng-complete-end-tag (lt-pos)
+  (when (save-excursion
+          (re-search-backward rng-in-end-tag-name-regex
+                              lt-pos
+                              t))
+    (cond ((or (not rng-open-elements)
+               (eq (car rng-open-elements) t))
+           (message "No matching start-tag")
+           (ding))
+          (t
+           (let ((start-tag-name
+                  (if (caar rng-open-elements)
+                      (concat (caar rng-open-elements)
+                              ":"
+                              (cdar rng-open-elements))
+                    (cdar rng-open-elements)))
+                 (end-tag-name
+                  (buffer-substring-no-properties (+ (match-beginning 0) 2)
+                                                  (point))))
+             (cond ((or (> (length end-tag-name)
+                           (length start-tag-name))
+                        (not (string= (substring start-tag-name
+                                                 0
+                                                 (length end-tag-name))
+                                      end-tag-name)))
+                    (message "Expected end-tag %s"
+                             (rng-quote-string
+                              (concat "</" start-tag-name ">")))
+                    (ding))
+                   (t
+                    (delete-region (- (point) (length end-tag-name))
+                                   (point))
+                    (insert start-tag-name ">")
+                    (when (not (or rng-collecting-text
+                                   (rng-match-end-tag)))
+                      (message "Element %s is incomplete"
+                               (rng-quote-string start-tag-name))))))))
+    t))
+
+(defconst rng-in-attribute-regex
+  (replace-regexp-in-string
+   "w"
+   xmltok-ncname-regexp
+   "<w\\(?::w\\)?\
+\\(?:[ \t\r\n]+w\\(?::w\\)?[ \t\r\n]*=\
+[ \t\r\n]*\\(?:\"[^\"]*\"\\|'[^']*'\\)\\)*\
+[ \t\r\n]+\\(\\(?:w\\(?::w?\\)?\\)?\\)\\="
+   t
+   t))
+
+(defvar rng-undeclared-prefixes nil)
+
+(defun rng-complete-attribute-name (lt-pos)
+  (when (save-excursion
+          (re-search-backward rng-in-attribute-regex lt-pos t))
+    (let ((attribute-start (match-beginning 1))
+          rng-undeclared-prefixes)
+      (and (rng-adjust-state-for-attribute lt-pos
+                                           attribute-start)
+           (let ((rng-complete-target-names
+                  (rng-match-possible-attribute-names))
+                 (rng-complete-extra-strings
+                  (mapcar (lambda (prefix)
+                            (if prefix
+                                (concat "xmlns:" prefix)
+                              "xmlns"))
+                          rng-undeclared-prefixes))
+                 (rng-complete-name-attribute-flag t))
+             (rng-complete-before-point attribute-start
+                                        'rng-complete-qname-function
+                                        "Attribute: "
+                                        nil
+                                        'rng-attribute-name-history))
+           (insert "=\"")))
+    t))
+
+(defconst rng-in-attribute-value-regex
+  (replace-regexp-in-string
+   "w"
+   xmltok-ncname-regexp
+   "<w\\(?::w\\)?\
+\\(?:[ \t\r\n]+w\\(?::w\\)?[ \t\r\n]*=\
+[ \t\r\n]*\\(?:\"[^\"]*\"\\|'[^']*'\\)\\)*\
+[ \t\r\n]+\\(w\\(:w\\)?\\)[ \t\r\n]*=[ \t\r\n]*\
+\\(\"[^\"]*\\|'[^']*\\)\\="
+   t
+   t))
+
+(defun rng-complete-attribute-value (lt-pos)
+  (when (save-excursion
+          (re-search-backward rng-in-attribute-value-regex lt-pos t))
+    (let ((name-start (match-beginning 1))
+          (name-end (match-end 1))
+          (colon (match-beginning 2))
+          (value-start (1+ (match-beginning 3))))
+      (and (rng-adjust-state-for-attribute lt-pos
+                                           name-start)
+           (if (string= (buffer-substring-no-properties name-start
+                                                        (or colon name-end))
+                        "xmlns")
+               (rng-complete-before-point
+                value-start
+                (rng-strings-to-completion-alist
+                 (rng-possible-namespace-uris
+                  (and colon
+                       (buffer-substring-no-properties (1+ colon) name-end))))
+                "Namespace URI: "
+                nil
+                'rng-namespace-uri-history)
+             (rng-adjust-state-for-attribute-value name-start
+                                                   colon
+                                                   name-end)
+             (rng-complete-before-point
+              value-start
+              (rng-strings-to-completion-alist
+               (rng-match-possible-value-strings))
+              "Value: "
+              nil
+              'rng-attribute-value-history))
+           (insert (char-before value-start))))
+    t))
+
+(defun rng-possible-namespace-uris (prefix)
+  (let ((ns (if prefix (nxml-ns-get-prefix prefix)
+              (nxml-ns-get-default))))
+    (if (and ns (memq prefix (nxml-ns-changed-prefixes)))
+        (list (nxml-namespace-name ns))
+      (mapcar 'nxml-namespace-name
+              (delq nxml-xml-namespace-uri
+                    (rng-match-possible-namespace-uris))))))
+
+(defconst rng-qname-regexp
+  (concat "\\`"
+          xmltok-ncname-regexp
+          "\\(?:" ":" xmltok-ncname-regexp "\\)" "?" "\\'"))
+
+(defun rng-qname-p (string)
+  (and (string-match rng-qname-regexp string) t))
+
+(defun rng-expand-qname (qname &optional defaultp recover-fun)
+  (setq qname (rng-split-qname qname))
+  (let ((prefix (car qname)))
+    (if prefix
+        (let ((ns (nxml-ns-get-prefix qname)))
+          (cond (ns (cons ns (cdr qname)))
+                (recover-fun (funcall recover-fun prefix (cdr qname)))))
+      (cons (and defaultp (nxml-ns-get-default)) (cdr qname)))))
+
+(defun rng-start-tag-expand-recover (prefix local-name)
+  (let ((ns (rng-match-infer-start-tag-namespace local-name)))
+    (and ns
+         (cons ns local-name))))
+
+(defun rng-split-qname (qname)
+  (if (string-match ":" qname)
+      (cons (substring qname 0 (match-beginning 0))
+            (substring qname (match-end 0)))
+    (cons nil qname)))
+
+(defun rng-in-mixed-content-p ()
+  "Return non-nil if point is in mixed content.
+Return nil only if point is definitely not in mixed content.
+If unsure, return non-nil."
+  (if (eq rng-current-schema rng-any-element)
+      t
+    (rng-set-state-after)
+    (rng-match-mixed-text)))
+
+(defun rng-set-state-after (&optional pos)
+  "Set the state for after parsing the first token with endpoint >= POS.
+This does not change the xmltok state or point.  However, it does
+set `xmltok-dtd'. Returns the position of the end of the token."
+  (unless pos (setq pos (point)))
+  (when (< rng-validate-up-to-date-end pos)
+    (message "Parsing...")
+    (while (and (rng-do-some-validation)
+                (< rng-validate-up-to-date-end pos))
+      ;; Display percentage validated.
+      (force-mode-line-update)
+      ;; Force redisplay but don't allow idle timers to run.
+      (let ((timer-idle-list nil))
+        (sit-for 0)))
+    (message "Parsing...done"))
+  (save-excursion
+    (save-restriction
+      (widen)
+      (nxml-with-invisible-motion
+        (if (= pos 1)
+            (rng-set-initial-state)
+          (let ((state (get-text-property (1- pos) 'rng-state)))
+            (cond (state
+                   (rng-restore-state state)
+                   (goto-char pos))
+                  (t
+                   (let ((start (previous-single-property-change pos
+                                                                 'rng-state)))
+                     (cond (start
+                            (rng-restore-state (get-text-property (1- start)
+                                                                  'rng-state))
+                            (goto-char start))
+                           (t (rng-set-initial-state))))))))
+        (xmltok-save
+          (if (= (point) 1)
+              (xmltok-forward-prolog)
+            (setq xmltok-dtd rng-dtd))
+          (cond ((and (< pos (point))
+                      ;; This handles the case where the prolog ends
+                      ;; with a < without any following name-start
+                      ;; character. This will be treated by the parser
+                      ;; as part of the prolog, but we want to treat
+                      ;; it as the start of the instance.
+                      (eq (char-after pos) ?<)
+                      (<= (point)
+                          (save-excursion
+                            (goto-char (1+ pos))
+                            (skip-chars-forward " \t\r\n")
+                            (point))))
+                 pos)
+                ((< (point) pos)
+                 (let ((rng-dt-namespace-context-getter
+                        '(nxml-ns-get-context))
+                       (rng-parsing-for-state t))
+                   (rng-forward pos))
+                 (point))
+                (t pos)))))))
+
+(defun rng-adjust-state-for-attribute (lt-pos start)
+  (xmltok-save
+    (save-excursion
+      (goto-char lt-pos)
+      (when (memq (xmltok-forward)
+                  '(start-tag
+                    partial-start-tag
+                    empty-element
+                    partial-empty-element))
+        (when (< start (point))
+          (setq xmltok-namespace-attributes
+                (rng-prune-attribute-at start
+                                        xmltok-namespace-attributes))
+          (setq xmltok-attributes
+                (rng-prune-attribute-at start
+                                        xmltok-attributes)))
+        (let ((rng-parsing-for-state t)
+              (rng-dt-namespace-context-getter '(nxml-ns-get-context)))
+          (rng-process-start-tag 'stop)
+          (rng-find-undeclared-prefixes)
+          t)))))
+        
+(defun rng-find-undeclared-prefixes ()
+  ;; Start with the newly effective namespace declarations.
+  ;; (Includes declarations added during recovery.)
+  (setq rng-undeclared-prefixes (nxml-ns-changed-prefixes))
+  (let ((iter xmltok-attributes)
+        (ns-state (nxml-ns-state))
+        att)
+    ;; Add namespace prefixes used in this tag,
+    ;; but not declared in the parent.
+    (nxml-ns-pop-state)
+    (while iter
+      (setq att (car iter))
+      (let ((prefix (xmltok-attribute-prefix att)))
+        (when (and prefix
+                   (not (member prefix rng-undeclared-prefixes))
+                   (not (nxml-ns-get-prefix prefix)))
+          (setq rng-undeclared-prefixes
+                (cons prefix rng-undeclared-prefixes))))
+      (setq iter (cdr iter)))
+    (nxml-ns-set-state ns-state)
+    ;; Remove namespace prefixes explicitly declared.
+    (setq iter xmltok-namespace-attributes)
+    (while iter
+      (setq att (car iter))
+      (setq rng-undeclared-prefixes
+            (delete (and (xmltok-attribute-prefix att)
+                         (xmltok-attribute-local-name att))
+                  rng-undeclared-prefixes))
+      (setq iter (cdr iter)))))
+
+(defun rng-prune-attribute-at (start atts)
+  (when atts
+    (let ((cur atts))
+      (while (if (eq (xmltok-attribute-name-start (car cur)) start)
+                 (progn
+                   (setq atts (delq (car cur) atts))
+                   nil)
+               (setq cur (cdr cur)))))
+    atts))
+
+(defun rng-adjust-state-for-attribute-value (name-start
+                                             colon
+                                             name-end)
+  (let* ((prefix (if colon
+                     (buffer-substring-no-properties name-start colon)
+                   nil))
+         (local-name (buffer-substring-no-properties (if colon
+                                                         (1+ colon)
+                                                       name-start)
+                                                     name-end))
+         (ns (and prefix (nxml-ns-get-prefix prefix))))
+    (and (or (not prefix) ns)
+         (rng-match-attribute-name (cons ns local-name)))))
+
+(defun rng-complete-qname-function (string predicate flag)
+  (let ((alist (mapcar (lambda (name) (cons name nil))
+                       (rng-generate-qname-list string))))
+    (cond ((not flag)
+           (try-completion string alist predicate))
+          ((eq flag t)
+           (all-completions string alist predicate))
+          ((eq flag 'lambda)
+           (and (assoc string alist) t)))))
+
+(defun rng-generate-qname-list (&optional string)
+  (let ((forced-prefix (and string
+                            (string-match ":" string)
+                            (> (match-beginning 0) 0)
+                            (substring string
+                                       0
+                                       (match-beginning 0))))
+        (namespaces (mapcar 'car rng-complete-target-names))
+        ns-prefixes-alist ns-prefixes iter ns prefer)
+    (while namespaces
+      (setq ns (car namespaces))
+      (when ns
+        (setq ns-prefixes-alist
+              (cons (cons ns (nxml-ns-prefixes-for
+                              ns
+                              rng-complete-name-attribute-flag))
+                    ns-prefixes-alist)))
+      (setq namespaces (delq ns (cdr namespaces))))
+    (setq iter ns-prefixes-alist)
+    (while iter
+      (setq ns-prefixes (car iter))
+      (setq ns (car ns-prefixes))
+      (when (null (cdr ns-prefixes))
+        ;; No declared prefix for the namespace
+        (if forced-prefix
+            ;; If namespace non-nil and prefix undeclared,
+            ;; use forced prefix.
+            (when (and ns
+                       (not (nxml-ns-get-prefix forced-prefix)))
+              (setcdr ns-prefixes (list forced-prefix)))
+          (setq prefer (rng-get-preferred-unused-prefix ns))
+          (when prefer
+            (setcdr ns-prefixes (list prefer)))
+          ;; Unless it's an attribute with a non-nil namespace,
+          ;; allow no prefix for this namespace.
+          (unless rng-complete-name-attribute-flag
+            (setcdr ns-prefixes (cons nil (cdr ns-prefixes))))))
+      (setq iter (cdr iter)))
+    (rng-uniquify-equal
+     (sort (apply 'append
+                  (cons rng-complete-extra-strings
+                        (mapcar (lambda (name)
+                                  (if (car name)
+                                      (mapcar (lambda (prefix)
+                                                (if prefix
+                                                    (concat prefix
+                                                            ":"
+                                                            (cdr name))
+                                                  (cdr name)))
+                                        (cdr (assoc (car name)
+                                                    ns-prefixes-alist)))
+                                    (list (cdr name))))
+                                rng-complete-target-names)))
+           'string<))))
+        
+(defun rng-get-preferred-unused-prefix (ns)
+  (let ((ns-prefix (assoc (symbol-name ns) rng-preferred-prefix-alist))
+        iter prefix)
+    (when ns-prefix
+      (setq prefix (cdr ns-prefix))
+      (when (nxml-ns-get-prefix prefix)
+        ;; try to find an unused prefix
+        (setq iter (memq ns-prefix rng-preferred-prefix-alist))
+        (while (and iter
+                    (setq ns-prefix (assoc ns iter)))
+          (if (nxml-ns-get-prefix (cdr ns-prefix))
+              (setq iter (memq ns-prefix iter))
+            (setq prefix (cdr ns-prefix))
+            nil))))
+    prefix))
+
+(defun rng-strings-to-completion-alist (strings)
+  (mapcar (lambda (s) (cons s s))
+          (rng-uniquify-equal (sort (mapcar 'rng-escape-string strings)
+                                    'string<))))
+
+(provide 'rng-nxml)
+
+;;; rng-nxml.el ends here
diff --git a/lisp/nxml/rng-parse.el b/lisp/nxml/rng-parse.el
new file mode 100644
index 00000000000..f4a0a4cc4c6
--- /dev/null
+++ b/lisp/nxml/rng-parse.el
@@ -0,0 +1,104 @@
+;;; rng-parse.el --- parse an XML file and validate it against a schema
+
+;; Copyright (C) 2003 Free Software Foundation, Inc.
+
+;; Author: James Clark
+;; Keywords: XML, RelaxNG
+
+;; This program is free software; you can redistribute it and/or
+;; modify it under the terms of the GNU General Public License as
+;; published by the Free Software Foundation; either version 2 of
+;; the License, or (at your option) any later version.
+
+;; This program is distributed in the hope that it will be
+;; useful, but WITHOUT ANY WARRANTY; without even the implied
+;; warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+;; PURPOSE.  See the GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public
+;; License along with this program; if not, write to the Free
+;; Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+;; MA 02111-1307 USA
+
+;;; Commentary:
+
+;; This combines the validation machinery in rng-match.el with the
+;; parser in nxml-parse.el by using the `nxml-validate-function' hook.
+
+;;; Code:
+
+(require 'nxml-parse)
+(require 'rng-match)
+(require 'rng-dt)
+
+(defvar rng-parse-prev-was-start-tag nil)
+
+(defun rng-parse-validate-file (schema file)
+  "Parse and validate the XML document in FILE and return it as a list.
+The returned list has the same form as that returned by
+`nxml-parse-file'.  SCHEMA is a list representing the schema to use
+for validation, such as returned by the function `rng-c-load-schema'.
+If the XML document is invalid with respect to schema, an error will
+be signaled in the same way as when it is not well-formed."
+  (save-excursion
+    (set-buffer (nxml-parse-find-file file))
+    (unwind-protect
+        (let ((nxml-parse-file-name file)
+              (nxml-validate-function 'rng-parse-do-validate)
+              (rng-dt-namespace-context-getter '(nxml-ns-get-context))
+              rng-parse-prev-was-start-tag)
+          ;; We don't simply call nxml-parse-file, because
+          ;; we want to do rng-match-with-schema in the same
+          ;; buffer in which we will call the other rng-match-* functions.
+          (rng-match-with-schema schema
+            (nxml-parse-instance)))
+      (kill-buffer nil))))
+
+(defun rng-parse-do-validate (text start-tag)
+  (cond ((and (let ((tem rng-parse-prev-was-start-tag))
+                (setq rng-parse-prev-was-start-tag (and start-tag t))
+                tem)
+              (not start-tag)
+              (rng-match-text-typed-p))
+         (unless (rng-match-element-value (or text ""))
+           (cons "Invalid data" (and text 'text))))
+        ((and text
+              (not (rng-blank-p text))
+              (not (rng-match-mixed-text)))
+         (cons "Text not allowed" 'text))
+        ((not start-tag)
+         (unless (rng-match-end-tag)
+           (cons "Missing elements" nil)))
+        ((not (rng-match-start-tag-open
+               (rng-parse-to-match-name (car start-tag))))
+         (cons "Element not allowed" nil))
+        (t
+         (let ((atts (cadr start-tag))
+               (i 0)
+               att err)
+           (while (and atts (not err))
+             (setq att (car atts))
+             (when (not (and (consp (car att))
+                             (eq (caar att) nxml-xmlns-namespace-uri)))
+               (setq err
+                     (cond ((not (rng-match-attribute-name
+                                  (rng-parse-to-match-name (car att))))
+                            (cons "Attribute not allowed"
+                                  (cons 'attribute-name i)))
+                           ((not (rng-match-attribute-value (cdr att)))
+                            (cons "Invalid attribute value"
+                                  (cons 'attribute-value i))))))
+             (setq atts (cdr atts))
+             (setq i (1+ i)))
+           (or err
+               (unless (rng-match-start-tag-close)
+                 (cons "Missing attributes" 'tag-close)))))))
+
+(defun rng-parse-to-match-name (name)
+  (if (consp name)
+      name
+    (cons nil name)))
+
+(provide 'rng-parse)
+
+;;; rng-parse.el ends here
diff --git a/lisp/nxml/rng-pttrn.el b/lisp/nxml/rng-pttrn.el
new file mode 100644
index 00000000000..c3ae4c6812b
--- /dev/null
+++ b/lisp/nxml/rng-pttrn.el
@@ -0,0 +1,189 @@
+;;; rng-pttrn.el --- RELAX NG patterns
+
+;; Copyright (C) 2003 Free Software Foundation, Inc.
+
+;; Author: James Clark
+;; Keywords: XML, RelaxNG
+
+;; This program is free software; you can redistribute it and/or
+;; modify it under the terms of the GNU General Public License as
+;; published by the Free Software Foundation; either version 2 of
+;; the License, or (at your option) any later version.
+
+;; This program is distributed in the hope that it will be
+;; useful, but WITHOUT ANY WARRANTY; without even the implied
+;; warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+;; PURPOSE.  See the GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public
+;; License along with this program; if not, write to the Free
+;; Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+;; MA 02111-1307 USA
+
+;;; Commentary:
+
+;; pattern ::=
+;;   (ref <pattern> <local-name>)
+;;   | (choice <pattern> <pattern> ...)
+;;   | (group <pattern> <pattern> ...)
+;;   | (interleave <pattern> <pattern> ...)
+;;   | (zero-or-more <pattern>)
+;;   | (one-or-more <pattern>)
+;;   | (optional <pattern>)
+;;   | (mixed <pattern>)
+;;   | (value <datatype> <string> <context>)
+;;   | (data <datatype> <params>)
+;;   | (data-except <datatype> <params> <pattern>)
+;;   | (list <pattern>)
+;;   | (element <name-class> <pattern>)
+;;   | (attribute <name-class> <pattern>)
+;;   | (text)
+;;   | (empty)
+;;   | (not-allowed)
+;;
+;; params ::=
+;;   ((<param-name> . <param-value> ) ...)
+;; param-name ::= <symbol>
+;; param-value ::= <string>
+;;
+;; name-class ::=
+;;   (name <name>)
+;;   | (any-name)
+;;   | (any-name-except <name-class>)
+;;   | (ns-name <ns>)
+;;   | (ns-name-except <ns> <name-class>)
+;;   | (choice <name-class> <name-class> ...)
+;;
+;; name ::= (<ns> . <local-name>)
+;; ns ::= nil | <symbol>
+;; local-name ::= <string>
+;; datatype ::= (<datatype-uri> . <datatype-local-name>)
+;; datatype-uri ::= nil | <symbol>
+;; datatype-local-name ::= <symbol>
+
+;;; Code:
+
+(defvar rng-schema-change-hook nil
+  "Hook to be run after `rng-current-schema' changes.")
+
+(defvar rng-current-schema nil
+  "Pattern to be used as schema for the current buffer.")
+(make-variable-buffer-local 'rng-current-schema)
+
+(defun rng-make-ref (name)
+  (list 'ref nil name))
+
+(defun rng-ref-set (ref pattern)
+  (setcar (cdr ref) pattern))
+
+(defun rng-ref-get (ref) (cadr ref))
+
+(defun rng-make-choice (patterns)
+  (cons 'choice patterns))
+
+(defun rng-make-group (patterns)
+  (cons 'group patterns))
+
+(defun rng-make-interleave (patterns)
+  (cons 'interleave patterns))
+
+(defun rng-make-zero-or-more (pattern)
+  (list 'zero-or-more pattern))
+
+(defun rng-make-one-or-more (pattern)
+  (list 'one-or-more pattern))
+
+(defun rng-make-optional (pattern)
+  (list 'optional pattern))
+
+(defun rng-make-mixed (pattern)
+  (list 'mixed pattern))
+
+(defun rng-make-value (datatype str context)
+  (list 'value datatype str context))
+
+(defun rng-make-data (name params)
+  (list 'data name params))
+
+(defun rng-make-data-except (name params pattern)
+  (list 'data-except name params pattern))
+
+(defun rng-make-list (pattern)
+  (list 'list pattern))
+
+(defun rng-make-element (name-class pattern)
+  (list 'element name-class pattern))
+
+(defun rng-make-attribute (name-class pattern)
+  (list 'attribute name-class pattern))
+
+(defun rng-make-text ()
+  '(text))
+
+(defun rng-make-empty ()
+  '(empty))
+
+(defun rng-make-not-allowed ()
+  '(not-allowed))
+
+(defun rng-make-any-name-name-class ()
+  '(any-name))
+
+(defun rng-make-any-name-except-name-class (name-class)
+  (list 'any-name-except name-class))
+
+(defun rng-make-ns-name-name-class (ns)
+  (list 'ns-name ns))
+
+(defun rng-make-ns-name-except-name-class (ns name-class)
+  (list 'ns-name-except ns name-class))
+
+(defun rng-make-name-name-class (name)
+  (list 'name name))
+
+(defun rng-make-choice-name-class (name-classes)
+  (cons 'choice name-classes))
+
+(defconst rng-any-content
+  (let* ((ref (rng-make-ref "any-content"))
+         (pattern (rng-make-zero-or-more
+                    (rng-make-choice
+                     (list
+                      (rng-make-text)
+                      (rng-make-attribute (rng-make-any-name-name-class)
+                                          (rng-make-text))
+                      (rng-make-element (rng-make-any-name-name-class)
+                                        ref))))))
+    (rng-ref-set ref pattern)
+    pattern)
+  "A pattern that matches the attributes and content of any element.")
+
+(defconst rng-any-element
+  (let* ((ref (rng-make-ref "any-element"))
+         (pattern
+          (rng-make-element
+           (rng-make-any-name-name-class)
+           (rng-make-zero-or-more
+            (rng-make-choice
+             (list
+              (rng-make-text)
+              (rng-make-attribute (rng-make-any-name-name-class)
+                                  (rng-make-text))
+              ref))))))
+    (rng-ref-set ref pattern)
+    pattern)
+  "A pattern that matches any element.")
+
+;;; Names
+
+(defun rng-make-name (ns local-name)
+  (cons ns local-name))
+
+;;; Datatypes
+
+(defun rng-make-datatype (uri local-name)
+  (cons uri (intern local-name)))
+
+(provide 'rng-pttrn)
+
+;;; rng-pttrn.el ends here
diff --git a/lisp/nxml/rng-uri.el b/lisp/nxml/rng-uri.el
new file mode 100644
index 00000000000..7ed8befc90e
--- /dev/null
+++ b/lisp/nxml/rng-uri.el
@@ -0,0 +1,355 @@
+;;; rng-uri.el --- URI parsing and manipulation
+
+;; Copyright (C) 2003 Free Software Foundation, Inc.
+
+;; Author: James Clark
+;; Keywords: XML
+
+;; This program is free software; you can redistribute it and/or
+;; modify it under the terms of the GNU General Public License as
+;; published by the Free Software Foundation; either version 2 of
+;; the License, or (at your option) any later version.
+
+;; This program is distributed in the hope that it will be
+;; useful, but WITHOUT ANY WARRANTY; without even the implied
+;; warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+;; PURPOSE.  See the GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public
+;; License along with this program; if not, write to the Free
+;; Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+;; MA 02111-1307 USA
+
+;;; Commentary:
+
+;;; Code:
+
+(defun rng-file-name-uri (f)
+  "Return a URI for the filename F.
+Multibyte characters are left as is. Use `rng-uri-escape-multibyte' to
+escape them using %HH."
+  (setq f (expand-file-name f))
+  (let ((url
+         (replace-regexp-in-string "[\000-\032\177<>#%\"{}|\\^[]`%?;]"
+                                   'rng-percent-encode
+                                   f)))
+    (concat "file:"
+            (if (and (> (length url) 0)
+                     (= (aref url 0) ?/))
+                "//"
+              "///")
+            url)))
+
+(defun rng-uri-escape-multibyte (uri)
+  "Escape multibyte characters in URI."
+  (replace-regexp-in-string "[:nonascii:]"
+                            'rng-percent-encode
+                            (encode-coding-string uri 'utf-8)))
+
+(defun rng-percent-encode (str)
+  (apply 'concat
+         (mapcar (lambda (ch)
+                   (format "%%%x%x" (/ ch 16) (% ch 16)))
+                 (string-to-list str))))
+
+
+(defun rng-uri-file-name (uri)
+  "Return the filename represented by a URI.
+Signal an error if URI is not a valid file URL."
+  (rng-uri-file-name-1 uri nil))
+
+(defun rng-uri-pattern-file-name-regexp (pattern)
+  "Return a regexp for filenames represented by URIs that match PATTERN."
+  (rng-uri-file-name-1 pattern 'match))
+
+(defun rng-uri-pattern-file-name-replace-match (pattern)
+  (rng-uri-file-name-1 pattern 'replace))
+
+;; pattern is either nil or match or replace
+(defun rng-uri-file-name-1 (uri pattern)
+  (unless (string-match "\\`\\(?:[^%]\\|%[0-9a-fA-F]{2}\\)*\\'" uri)
+    (rng-uri-error "Bad escapes in URI `%s'" uri))
+  (setq uri (rng-uri-unescape-multibyte uri))
+  (let* ((components
+          (or (rng-uri-split uri)
+              (rng-uri-error "Cannot split URI `%s' into its components" uri)))
+         (scheme (nth 0 components))
+         (authority (nth 1 components))
+         (path (nth 2 components))
+         (absolutep (string-match "\\`/" path))
+         (query (nth 3 components))
+         (fragment-id (nth 4 components)))
+    (cond ((not scheme)
+           (unless pattern
+             (rng-uri-error "URI `%s' does not have a scheme" uri)))
+          ((not (string= (downcase scheme) "file"))
+           (rng-uri-error "URI `%s' does not use the `file:' scheme" uri)))
+    (when (not (member authority
+                       (cons system-name '(nil "" "localhost"))))
+      (rng-uri-error "URI `%s' does not start with `file:///' or `file://localhost/'"
+             uri))
+    (when query
+      (rng-uri-error "`?' not escaped in file URI `%s'" uri))
+    (when fragment-id
+      (rng-uri-error "URI `%s' has a fragment identifier" uri))
+    (when (string-match ";" path)
+      (rng-uri-error "`;' not escaped in URI `%s'" uri))
+    (when (string-match "%2[fF]" path) ;; 2f is hex code of slash
+      (rng-uri-error "Escaped slash in URI `%s'" uri))
+    (when (and (eq system-type 'windows-nt)
+               absolutep
+               (file-name-absolute-p (substring path 1)))
+      (setq path (substring path 1)))
+    (when (and pattern (string-match "\\`\\./" path))
+      (setq path (substring path 2)))
+    (setq path 
+          (cond ((eq pattern 'match)
+                 (rng-uri-unescape-unibyte-match path))
+                ((eq pattern 'replace)
+                 (rng-uri-unescape-unibyte-replace path 2))
+                (t
+                 (rng-uri-unescape-unibyte path))))
+    (when (string-match "\000" path)
+      (rng-uri-error "URI `%s' has NUL character in path" uri))
+    (when (eq pattern 'match)
+      (setq path
+            (concat (if absolutep
+                        "\\(\\)"
+                      "\\(\\(?:[^/]*/\\)*\\)")
+                    path)))
+    (cond ((eq pattern 'match)
+           (concat "\\`" path "\\'"))
+          ((and (eq pattern 'replace)
+                (not absolutep))
+           (concat "\\1" path))
+          (t path))))
+
+(defun rng-uri-error (&rest args)
+  (signal 'rng-uri-error (list (apply 'format args))))
+
+(put 'rng-uri-error 'error-conditions '(error rng-uri-error))
+(put 'rng-uri-error 'error-message "Invalid URI")
+
+(defun rng-uri-split (str)
+  (and (string-match "\\`\\(?:\\([^:/?#]+\\):\\)?\
+\\(?://\\([^/?#]*\\)\\)?\
+\\([^?#]*\\)\
+\\(?:\\?\\([^#]*\\)\\)?\
+\\(?:#\\(\\(?:.\\|\n\\)*\\)\\)?\\'"
+                     str)
+       (list (match-string 1 str)
+             (match-string 2 str)
+             (match-string 3 str)
+             (match-string 4 str)
+             (match-string 5 str))))
+
+(defun rng-uri-join (scheme authority path &optional query fragment-id)
+  (when path
+    (let (parts)
+      (when fragment-id
+        (setq parts (list "#" fragment-id)))
+      (when query
+        (setq parts
+              (cons "?"
+                    (cons query parts))))
+      (setq parts (cons path parts))
+      (when authority
+        (setq parts
+              (cons "//"
+                    (cons authority parts))))
+      (when scheme
+        (setq parts
+              (cons scheme
+                    (cons ":" parts))))
+      (apply 'concat parts))))
+                        
+(defun rng-uri-resolve (uri-ref base-uri)
+  "Resolve a possibly relative URI reference into absolute form.
+URI-REF is the URI reference to be resolved.
+BASE-URI is the base URI to use for resolving it.
+The algorithm is specified by RFC 2396.
+If there is some problem with URI-REF or BASE-URI, then
+URI-REF will be returned."
+  (let* ((components (rng-uri-split uri-ref))
+         (scheme (nth 0 components))
+         (authority (nth 1 components))
+         (path (nth 2 components))
+         (query (nth 3 components))
+         (fragment-id (nth 4 components))
+         (base-components (rng-uri-split base-uri)))
+    (if (or (not components)
+            scheme
+            (not base-components)
+            (not (nth 0 base-components)))
+        uri-ref
+      (setq scheme (nth 0 base-components))
+      (when (not authority)
+        (setq authority (nth 1 base-components))
+        (if (and (equal path "") (not query))
+            ;; Handle same document reference by returning
+            ;; same URI (RFC 2396bis does this too).
+            (setq path (nth 2 base-components)
+                  query (nth 3 base-components))
+          (setq path (rng-resolve-path path (nth 2 base-components)))))
+      (rng-uri-join scheme
+                    authority
+                    path
+                    query
+                    fragment-id))))
+
+;; See RFC 2396 5.2, steps 5 and 6
+(defun rng-resolve-path (path base-path)
+  ;; Step 5
+  (if (or (string-match "\\`/" path)
+          (not (string-match "\\`/" base-path)))
+      path
+    ;; Step 6
+    ;; (a), (b)
+    (let ((segments (rng-split-path path))
+          (base-segments (rng-split-path base-path)))
+      (if (> (length base-segments) 1)
+          (setq segments (nconc (nbutlast base-segments)
+                                segments))
+        (setcar segments
+                (concat (car base-segments) (car segments))))
+      ;; (d)
+      (let ((last-segment (last segments)))
+        (when (equal (car last-segment) ".")
+          (setcar last-segment "")))
+      ;; (c)
+      (setq segments (delete "." segments))
+      ;; (e)
+      (let (iter matched)
+        (while (progn
+                 (setq matched nil)
+                 (setq iter (cdr segments))
+                 (while (and iter (not matched))
+                   (if (or (not (equal (cadr iter) ".."))
+                           (equal (car iter) ".."))
+                       (setq iter (cdr iter))
+                     (setcar iter nil)
+                     (setcar (cdr iter)
+                             ;; (f)
+                             (if (cddr iter) nil ""))
+                     (setq matched t)
+                     (setq segments (delq nil segments))))
+                 matched)))
+      (rng-join-path segments))))
+
+(defun rng-relative-uri (full base)
+  "Return a URI that relative to BASE is equivalent to FULL.
+The returned URI will be relative if possible.
+Both FULL and BASE must be absolute URIs."
+  (let* ((components (rng-uri-split full))
+         (scheme (nth 0 components))
+         (authority (nth 1 components))
+         (path (nth 2 components))
+         (query (nth 3 components))
+         (fragment-id (nth 4 components))
+         (base-components (rng-uri-split base)))
+    (if (and components
+             base-components
+             scheme
+             (equal scheme
+                    (nth 0 base-components)))
+        (progn
+          (setq scheme nil)
+          (when (and authority
+                     (equal authority
+                            (nth 1 base-components)))
+            (setq authority nil)
+            (setq path (rng-relative-path path (nth 2 base-components))))
+          (rng-uri-join scheme authority path query fragment-id))
+      full)))
+
+(defun rng-relative-path (path base-path)
+  (let ((segments (rng-split-path path))
+        (base-segments (rng-split-path base-path)))
+    (when (> (length base-segments) 1)
+      (setq base-segments (nbutlast base-segments)))
+    (if (or (member "." segments)
+            (member ".." segments)
+            (member "." base-segments)
+            (member ".." base-segments))
+        path
+      (while (and segments
+                  base-segments
+                  (string= (car segments)
+                           (car base-segments)))
+        (setq segments (cdr segments))
+        (setq base-segments (cdr base-segments)))
+      (while base-segments
+        (setq base-segments (cdr base-segments))
+        (setq segments (cons ".." segments)))
+      (when (equal (car segments) "")
+        (setq segments (cons "." segments)))
+      (rng-join-path segments))))
+
+(defun rng-split-path (path)
+  (let ((start 0)
+        segments)
+    (while (string-match "/" path start)
+      (setq segments (cons (substring path start (match-beginning 0))
+                           segments))
+      (setq start (match-end 0)))
+    (nreverse (cons (substring path start) segments))))
+
+(defun rng-join-path (segments)
+  (and segments
+       (mapconcat 'identity segments "/")))
+
+(defun rng-uri-unescape-multibyte (str)
+  (replace-regexp-in-string "\\(?:%[89a-fA-F][0-9a-fA-F]\\)+"
+                            'rng-multibyte-percent-decode
+                            str))
+
+(defun rng-multibyte-percent-decode (str)
+  (decode-coding-string  (apply 'string
+                                (mapcar (lambda (h) (string-to-number h 16))
+                                        (split-string str "%")))
+                         'utf-8))
+    
+(defun rng-uri-unescape-unibyte (str)
+  (replace-regexp-in-string "%[0-7][0-9a-fA-F]"
+                            (lambda (h)
+                              (string-to-number (substring h 1) 16))
+                            str
+                            t
+                            t))
+
+(defun rng-uri-unescape-unibyte-match (str)
+  (replace-regexp-in-string "%[0-7][0-9a-fA-F]\\|[^%]"
+                            (lambda (match)
+                              (if (string= match "*")
+                                  "\\([^/]*\\)"
+                                (regexp-quote
+                                 (if (= (length match) 1)
+                                     match
+                                   (string-to-number (substring match 1)
+                                                     16)))))
+                            str
+                            t
+                            t))
+
+(defun rng-uri-unescape-unibyte-replace (str next-match-index)
+  (replace-regexp-in-string
+   "%[0-7][0-9a-fA-F]\\|[^%]"
+   (lambda (match)
+     (if (string= match "*")
+         (let ((n next-match-index))
+           (setq next-match-index (1+ n))
+           (format "\\%s" n))
+       (let ((ch (if (= (length match) 1)
+                     (aref match 0)
+                   (string-to-number (substring match 1)
+                                     16))))
+         (if (eq ch ?\\)
+             (string ?\\ ?\\)
+           (string ch)))))
+     str
+     t
+     t))
+
+(provide 'rng-uri)
+
+;;; rng-uri.el ends here
diff --git a/lisp/nxml/rng-util.el b/lisp/nxml/rng-util.el
new file mode 100644
index 00000000000..865da0ff70c
--- /dev/null
+++ b/lisp/nxml/rng-util.el
@@ -0,0 +1,172 @@
+;;; rng-util.el --- utility functions for RELAX NG library
+
+;; Copyright (C) 2003 Free Software Foundation, Inc.
+
+;; Author: James Clark
+;; Keywords: XML, RelaxNG
+
+;; This program is free software; you can redistribute it and/or
+;; modify it under the terms of the GNU General Public License as
+;; published by the Free Software Foundation; either version 2 of
+;; the License, or (at your option) any later version.
+
+;; This program is distributed in the hope that it will be
+;; useful, but WITHOUT ANY WARRANTY; without even the implied
+;; warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+;; PURPOSE.  See the GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public
+;; License along with this program; if not, write to the Free
+;; Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+;; MA 02111-1307 USA
+
+;;; Commentary:
+
+;;; Code:
+
+(defun rng-make-datatypes-uri (uri)
+  (if (string-equal uri "")
+      ;; The spec doesn't say to do this, but it's perfectly conformant
+      ;; and better than using nil, I think.
+      'http://relaxng.org/ns/structure/1.0
+    (intern uri)))
+
+(defconst rng-xsd-datatypes-uri
+  (rng-make-datatypes-uri "http://www.w3.org/2001/XMLSchema-datatypes"))
+
+(defconst rng-builtin-datatypes-uri (rng-make-datatypes-uri ""))
+
+(defun rng-uniquify-eq (list)
+  "Destructively remove any element from LIST that is eq to
+its predecessor."
+  (and list
+       (let ((head list))
+         (while (cdr head)
+           (if (eq (car head) (cadr head))
+               (setcdr head (cddr head)))
+           (setq head (cdr head)))
+         list)))
+
+(defun rng-uniquify-equal (list)
+  "Destructively remove any element from LIST that is equal to
+its predecessor."
+  (and list
+       (let ((head list))
+         (while (cdr head)
+           (if (equal (car head) (cadr head))
+               (setcdr head (cddr head)))
+           (setq head (cdr head)))
+         list)))
+
+(defun rng-blank-p (str) (string-match "\\`[ \t\n\r]*\\'" str))
+
+(defun rng-substq (new old list)
+  "Replace first member of LIST (if any) that is eq to OLD by NEW.
+LIST is not modified."
+  (cond ((null list) nil)
+        ((eq (car list) old)
+         (cons new (cdr list)))
+        (t
+         (let ((tail (cons (car list)
+                           nil))
+               (rest (cdr list)))
+           (setq list tail)
+           (while rest
+             (let ((item (car rest)))
+               (setq rest (cdr rest))
+               (cond ((eq item old)
+                      (setcdr tail
+                              (cons new rest))
+                      (setq rest nil))
+                     (t
+                      (setq tail
+                            (setcdr tail
+                                    (cons item nil))))))))
+         list)))
+
+(defun rng-complete-before-point (start table prompt &optional predicate hist)
+  "Complete text between START and point.
+Replaces the text between START and point with a string chosen using a
+completion table and, when needed, input read from the user with the
+minibuffer.
+Returns the new string if either a complete and unique completion was
+determined automatically or input was read from the user. Otherwise,
+returns nil.
+TABLE is an alist, a symbol bound to a function or an obarray as with
+the function `completing-read'.
+PROMPT is the string to prompt with if user input is needed.
+PREDICATE is nil or a function as with `completing-read'.
+HIST, if non-nil, specifies a history list as with `completing-read'."
+  (let* ((orig (buffer-substring-no-properties start (point)))
+         (completion (try-completion orig table predicate)))
+    (cond ((not completion)
+           (if (string= orig "")
+               (message "No completions available")
+             (message "No completion for %s" (rng-quote-string orig)))
+           (ding)
+           nil)
+          ((eq completion t) orig)
+          ((not (string= completion orig))
+           (delete-region start (point))
+           (insert completion)
+           (cond ((not (rng-completion-exact-p completion table predicate))
+                  (message "Incomplete")
+                  nil)
+                 ((eq (try-completion completion table predicate) t)
+                  completion)
+                 (t
+                  (message "Complete but not unique")
+                  nil)))
+          (t
+           (setq completion
+                 (let ((saved-minibuffer-setup-hook
+                        (default-value 'minibuffer-setup-hook)))
+                   (add-hook 'minibuffer-setup-hook
+                             'minibuffer-completion-help
+                             t)
+                   (unwind-protect
+                       (completing-read prompt
+                                        table
+                                        predicate
+                                        nil
+                                        orig
+                                        hist)
+                     (setq-default minibuffer-setup-hook
+                                   saved-minibuffer-setup-hook))))
+           (delete-region start (point))
+           (insert completion)
+           completion))))
+
+(defun rng-completion-exact-p (string table predicate)
+  (cond ((symbolp table)
+         (funcall table string predicate 'lambda))
+        ((vectorp table)
+         (intern-soft string table))
+        (t (assoc string table))))
+
+(defun rng-quote-string (s)
+  (concat "\"" s "\""))
+
+(defun rng-escape-string (s)
+  (replace-regexp-in-string "[&\"<>]"
+                            (lambda (match)
+                              (cdr (assoc match
+                                          '(("&" . "&amp;")
+                                            ("\"" . "&quot;")
+                                            (">" . "&gt;")
+                                            ("<" . "&lt;")))))
+                            s
+                            t))
+
+(defun rng-collapse-space (string)
+  (setq string
+        (replace-regexp-in-string "[ \t\r\n]+" " " string t t))
+  (when (string-match "\\` " string)
+    (setq string (substring string 1)))
+  (when (string-match " \\'" string)
+    (setq string (substring string 0 -1)))
+  string)
+
+(provide 'rng-util)
+
+;;; rng-util.el ends here
diff --git a/lisp/nxml/rng-valid.el b/lisp/nxml/rng-valid.el
new file mode 100644
index 00000000000..d5ecb3aae00
--- /dev/null
+++ b/lisp/nxml/rng-valid.el
@@ -0,0 +1,1467 @@
+;;; rng-valid.el --- real-time validation of XML using RELAX NG
+
+;; Copyright (C) 2003 Free Software Foundation, Inc.
+
+;; Author: James Clark
+;; Keywords: XML, RelaxNG
+
+;; This program is free software; you can redistribute it and/or
+;; modify it under the terms of the GNU General Public License as
+;; published by the Free Software Foundation; either version 2 of
+;; the License, or (at your option) any later version.
+
+;; This program is distributed in the hope that it will be
+;; useful, but WITHOUT ANY WARRANTY; without even the implied
+;; warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+;; PURPOSE.  See the GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public
+;; License along with this program; if not, write to the Free
+;; Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+;; MA 02111-1307 USA
+
+;;; Commentary:
+
+;; For usage information, see the documentation for rng-validate-mode.
+;;
+;; This file provides a minor mode that continually validates a buffer
+;; against a RELAX NG schema. The validation state is used to support
+;; schema-sensitive editing as well as validation. Validation is
+;; performed while Emacs is idle.  XML parsing is done using
+;; xmltok.el. This file is responsible for checking that end-tags
+;; match their start-tags.  Namespace processing is handled by
+;; nxml-ns.el. The RELAX NG Compact Syntax schema is parsed into
+;; internal form by rng-cmpct.el.  This internal form is described by
+;; rng-pttrn.el.  Validation of the document by matching against this
+;; internal form is done by rng-match.el. Handling of W3C XML Schema
+;; datatypes is delegated by rng-match.el to rng-xsd.el.  The minor
+;; mode is intended to be used in conjunction with the nxml major
+;; mode, but does not have to be.
+;;
+;; The major responsibility of this file is to allow validation to
+;; happen incrementally.  If a buffer has been validated and is then
+;; changed, we can often revalidate it without having to completely
+;; parse and validate it from start to end.  As we parse and validate
+;; the buffer, we periodically cache the state.  The state has three
+;; components: the stack of open elements, the namespace processing
+;; state and the RELAX NG validation state. The state is cached as the
+;; value of the rng-state text property on the closing greater-than of
+;; tags (but at intervals, not on every tag).  We keep track of the
+;; position up to which cached state is known to be correct by adding
+;; a function to the buffer's after-change-functions. This is stored
+;; in the rng-validate-up-to-date-end variable.  The first way in
+;; which we make validation incremental is obvious: we start
+;; validation from the first cached state before
+;; rng-validate-up-to-date-end.
+;;
+;; To make this work efficiently, we have to be able to copy the
+;; current parsing and validation state efficiently.  We do this by
+;; minimizing destructive changes to the objects storing the state.
+;; When state is changed, we use the old state to create new objects
+;; representing the new state rather than destructively modifying the
+;; objects representing the old state. Copying the state is just a
+;; matter of making a list of three objects, one for each component of
+;; the state; the three objects themselves can be shared and do not
+;; need to be copied.
+;;
+;; There's one other idea that is used to make validation incremental.
+;; Suppose we have a buffer that's 4000 bytes long and suppose we
+;; validated it, caching state at positions 1000, 2000 and 3000.  Now
+;; suppose we make a change at position 1500 inserting 100 characters.
+;; rng-validate-up-to-date-end will be changed to 1500.  When Emacs
+;; becomes idle and we revalidate, validation will restart using the
+;; cached state at position 1000.  However, we take advantage of the
+;; cached state beyond rng-validate-up-to-date-end as follows.  When
+;; our validation reaches position 2100 (the current position of the
+;; character that was at 2000), we compare our current state with the
+;; cached state.  If they are the same, then we can stop parsing
+;; immediately and set rng-validate-up-to-date-end to the end of the
+;; buffer: we already know that the state cached at position 3100 is
+;; correct.  If they are not the same, then we have to continue
+;; parsing.  After the change, but before revalidation, we call the
+;; region from 1600 to the end of the buffer "conditionally
+;; up-to-date".
+;;
+;; As well as the cached parsing and validation state, we also keep
+;; track of the errors in the file.  Errors are stored as overlays
+;; with a category of rng-error.  The number of such overlays in the
+;; buffer must always be equal to rng-error-count.
+
+;;; Code:
+
+(require 'xmltok)
+(require 'nxml-enc)
+(require 'nxml-util)
+(require 'nxml-ns)
+(require 'rng-match)
+(require 'rng-util)
+(require 'rng-loc)
+
+;;; Customizable variables
+
+(defgroup relax-ng nil
+  "Validation of XML using RELAX NG."
+  :group 'wp
+  :group 'nxml
+  :group 'languages)
+
+(defface rng-error-face '((t (:underline "red")))
+  "Face for highlighting XML errors."
+  :group 'relax-ng)
+
+(defcustom rng-state-cache-distance 2000
+  "*Distance in characters between each parsing and validation state cache."
+  :type 'integer
+  :group 'relax-ng)
+
+(defcustom rng-validate-chunk-size 8000
+  "*Number of characters in a RELAX NG validation chunk.
+A validation chunk will be the smallest chunk that is at least this
+size and ends with a tag.  After validating a chunk, validation will
+continue only if Emacs is still idle."
+  :type 'integer
+  :group 'relax-ng)
+
+(defcustom rng-validate-delay 1.5
+  "*Time in seconds that Emacs must be idle before starting a full validation.
+A full validation continues until either validation is up to date
+or Emacs is no longer idle."
+  :type 'number
+  :group 'relax-ng)
+
+(defcustom rng-validate-quick-delay 0.3
+  "*Time in seconds that Emacs must be idle before starting a quick validation.
+A quick validation validates at most one chunk."
+  :type 'number
+  :group 'relax-ng)
+
+;; Global variables
+
+(defvar rng-validate-timer nil)
+(make-variable-buffer-local 'rng-validate-timer)
+;; ensure that we can cancel the timer even after a kill-all-local-variables
+(put 'rng-validate-timer 'permanent-local t)
+
+(defvar rng-validate-quick-timer nil)
+(make-variable-buffer-local 'rng-validate-quick-timer)
+;; ensure that we can cancel the timer even after a kill-all-local-variables
+(put 'rng-validate-quick-timer 'permanent-local t)
+
+(defvar rng-error-count nil
+  "Number of errors in the current buffer.  Always equal to number of
+overlays with category rng-error.")
+(make-variable-buffer-local 'rng-error-count)
+
+(defvar rng-message-overlay nil
+  "Overlay in this buffer whose help-echo property was last printed.
+Nil if none.")
+(make-variable-buffer-local 'rng-message-overlay)
+
+(defvar rng-message-overlay-inhibit-point nil
+  "Position at which message from overlay should be inhibited.
+If point is equal to this and the error overlay around
+point is `rng-message-overlay', then the `help-echo' property
+of the error overlay should not be printed with `message'.")
+(make-variable-buffer-local 'rng-message-overlay-inhibit-point)
+
+(defvar rng-message-overlay-current nil
+  "Non-nil if `rng-message-overlay' is still the current message.")
+(make-variable-buffer-local 'rng-message-overlay-current)
+
+(defvar rng-open-elements nil
+  "Stack of names of open elements represented as a list.
+Each member of the list is either t or a (PREFIX . LOCAL-NAME) pair.
+\(PREFIX . LOCAL-NAME) is pushed for a start-tag; t is pushed
+for a mismatched end-tag.")
+
+(defvar rng-pending-contents nil
+  "Text content of current element that has yet to be processed.
+Value is a list of segments (VALUE START END) positions in reverse
+order.  VALUE is a string or nil.  If VALUE is nil, then the value is
+the string between START and END.  A segment can also be nil
+indicating an unresolvable entity or character reference.")
+
+(defvar rng-collecting-text nil)
+
+(defvar rng-validate-up-to-date-end nil
+  "Last position where validation is known to be up to date.")
+(make-variable-buffer-local 'rng-validate-up-to-date-end)
+
+(defvar rng-conditional-up-to-date-start nil
+  "Marker for the start of the conditionally up-to-date region.
+Nil if there is no conditionally up-to-date region.  The conditionally
+up-to-date region must be such that for any cached state S with
+position P in the conditionally up-to-date region, if at some point it
+is determined that S becomes correct for P, then all states with
+position >= P in the conditionally up to date region must also then be
+correct and all errors between P and the end of the region must then
+be correctly marked.")
+(make-variable-buffer-local 'rng-conditional-up-to-date-start)
+
+(defvar rng-conditional-up-to-date-end nil
+  "Marker for the end of the conditionally up-to-date region.
+Nil if there is no conditionally up-to-date region.  See the variable
+`rng-conditional-up-to-date-start'.")
+(make-variable-buffer-local 'rng-conditional-up-to-date-end)
+
+(defvar rng-parsing-for-state nil
+  "Non-nil means we are currently parsing just to compute the state.
+Should be dynamically bound.")
+
+(defvar rng-validate-mode nil)
+(make-variable-buffer-local 'rng-validate-mode)
+
+(defvar rng-dtd nil)
+(make-variable-buffer-local 'rng-dtd)
+
+;;;###autoload
+(defun rng-validate-mode (&optional arg no-change-schema)
+  "Minor mode performing continual validation against a RELAX NG schema.
+
+Checks whether the buffer is a well-formed XML 1.0 document,
+conforming to the XML Namespaces Recommendation and valid against a
+RELAX NG schema. The mode-line indicates whether it is or not.  Any
+parts of the buffer that cause it not to be are considered errors and
+are highlighted with `rng-error-face'. A description of each error is
+available as a tooltip.  \\[rng-next-error] goes to the next error
+after point. Clicking mouse-1 on the word `Invalid' in the mode-line
+goes to the first error in the buffer. If the buffer changes, then it
+will be automatically rechecked when Emacs becomes idle; the
+rechecking will be paused whenever there is input pending..
+
+By default, uses a vacuous schema that allows any well-formed XML
+document. A schema can be specified explictly using
+\\[rng-set-schema-file-and-validate], or implicitly based on the buffer's
+file name or on the root element name.  In each case the schema must
+be a RELAX NG schema using the compact schema \(such schemas
+conventionally have a suffix of `.rnc').  The variable
+`rng-schema-locating-files' specifies files containing rules
+to use for finding the schema."
+  (interactive "P")
+  (setq rng-validate-mode
+        (if (null arg)
+            (not rng-validate-mode)
+          (> (prefix-numeric-value arg) 0)))
+  (save-restriction
+    (widen)
+    (nxml-with-unmodifying-text-property-changes
+      (rng-clear-cached-state (point-min) (point-max)))
+    ;; 1+ to clear empty overlays at (point-max)
+    (rng-clear-overlays (point-min) (1+ (point-max))))
+  (setq rng-validate-up-to-date-end 1)
+  (rng-clear-conditional-region)
+  (setq rng-error-count 0)
+  ;; do this here to avoid infinite loop if we set the schema
+  (remove-hook 'rng-schema-change-hook 'rng-validate-clear t)
+  (cond (rng-validate-mode
+         (unwind-protect
+             (save-excursion
+               ;; An error can change the current buffer
+               (when (or (not rng-current-schema)
+                         (and (eq rng-current-schema rng-any-element)
+                              (not no-change-schema)))
+                 (rng-auto-set-schema t)))
+           (unless rng-current-schema (rng-set-schema-file-1 nil))
+           (add-hook 'rng-schema-change-hook 'rng-validate-clear nil t)
+           (add-hook 'after-change-functions 'rng-after-change-function nil t)
+           (add-hook 'kill-buffer-hook 'rng-kill-timers nil t)
+           (add-hook 'echo-area-clear-hook 'rng-echo-area-clear-function nil t)
+           (add-hook 'post-command-hook 'rng-maybe-echo-error-at-point nil t)
+           (rng-match-init-buffer)
+           (rng-activate-timers)
+           ;; Start validating right away if the buffer is visible.
+           ;; If it's not visible, don't do this, because the user
+           ;; won't get any progress indication. When the user finds
+           ;; a new file, then the buffer won't be visible
+           ;; when this is invoked.
+           (when (get-buffer-window (current-buffer) 'visible)
+             (rng-validate-while-idle (current-buffer)))))
+        (t
+         (rng-cancel-timers)
+         (force-mode-line-update)
+         (remove-hook 'kill-buffer-hook 'rng-cancel-timers t)
+         (remove-hook 'post-command-hook 'rng-maybe-echo-error-at-point t)
+         (remove-hook 'echo-area-clear-hook 'rng-echo-area-clear-function t)
+         (remove-hook 'after-change-functions 'rng-after-change-function t))))
+
+(defun rng-set-schema-file-and-validate (filename)
+  "Sets the schema and turns on `rng-validate-mode' if not already on.
+The schema is set like `rng-set-schema'."
+  (interactive "fSchema file: ")
+  (rng-set-schema-file filename)
+  (or rng-validate-mode (rng-validate-mode)))
+
+(defun rng-set-document-type-and-validate (type-id)
+  (interactive (list (rng-read-type-id)))
+  (and (rng-set-document-type type-id)
+       (or rng-validate-mode (rng-validate-mode))))
+    
+(defun rng-auto-set-schema-and-validate ()
+  "Set the schema for this buffer automatically and turn on `rng-validate-mode'.
+The schema is set like `rng-auto-set-schema'."
+  (interactive)
+  (rng-auto-set-schema)
+  (or rng-validate-mode (rng-validate-mode)))
+
+(defun rng-after-change-function (start end pre-change-len)
+  ;; Work around bug in insert-file-contents.
+  (when (> end (1+ (buffer-size)))
+    (setq start 1)
+    (setq end (1+ (buffer-size))))
+  (setq rng-message-overlay-inhibit-point nil)
+  (nxml-with-unmodifying-text-property-changes
+    (rng-clear-cached-state start end))
+  ;; rng-validate-up-to-date-end holds the position before the change
+  ;; Adjust it to reflect the change.
+  (if (< start rng-validate-up-to-date-end)
+      (setq rng-validate-up-to-date-end
+            (if (<= (+ start pre-change-len) rng-validate-up-to-date-end)
+                (+ rng-validate-up-to-date-end
+                   (- end start pre-change-len))
+              start)))
+  ;; Adjust the conditional zone
+  (cond (rng-conditional-up-to-date-start
+         (when (< rng-conditional-up-to-date-start end)
+           (if (< end rng-conditional-up-to-date-end)
+               (set-marker rng-conditional-up-to-date-start end)
+             (rng-clear-conditional-region))))
+        ((< end rng-validate-up-to-date-end)
+         (setq rng-conditional-up-to-date-end
+               (copy-marker rng-validate-up-to-date-end nil))
+         (setq rng-conditional-up-to-date-start
+               (copy-marker end t))))
+  ;; Adjust rng-validate-up-to-date-end
+  (if (< start rng-validate-up-to-date-end)
+      (setq rng-validate-up-to-date-end start))
+  ;; Must make rng-validate-up-to-date-end < point-max
+  ;; (unless the buffer is empty).
+  ;; otherwise validate-prepare will say there's nothing to do.
+  ;; Don't use (point-max) because we may be narrowed.
+  (if (> rng-validate-up-to-date-end (buffer-size))
+      (setq rng-validate-up-to-date-end
+            (max 1 (1- rng-validate-up-to-date-end))))
+  ;; Arrange to revalidate
+  (rng-activate-timers)
+  ;; Need to do this after activating the timer
+  (force-mode-line-update))
+
+(defun rng-compute-mode-line-string ()
+  (cond (rng-validate-timer
+         (concat " Validated:"
+                 (number-to-string
+                  ;; Use floor rather than round because we want
+                  ;; to show 99% rather than 100% for changes near
+                  ;; the end.
+                  (floor (if (eq (buffer-size) 0)
+                             0.0
+                           (/ (* (- rng-validate-up-to-date-end 1) 100.0)
+                              (buffer-size)))))
+                 "%%"))
+        ((> rng-error-count 0)
+         (concat " "
+                 (propertize "Invalid"
+                             'help-echo "mouse-1: go to first error"
+                             'local-map (make-mode-line-mouse-map
+                                         'mouse-1
+                                         'rng-mouse-first-error))))
+        (t " Valid")))
+   
+(defun rng-cancel-timers ()
+  (let ((inhibit-quit t))
+    (when rng-validate-timer
+      (cancel-timer rng-validate-timer)
+      (setq rng-validate-timer nil))
+    (when rng-validate-quick-timer
+      (cancel-timer rng-validate-quick-timer)
+      (setq rng-validate-quick-timer nil))))
+
+(defun rng-kill-timers ()
+  ;; rng-validate-timer and rng-validate-quick-timer have the
+  ;; permanent-local property, so that the timers can be
+  ;; cancelled even after changing mode.
+  ;; This function takes care of cancelling the timers and
+  ;; then killing the local variables.
+  (when (local-variable-p 'rng-validate-timer)
+    (when rng-validate-timer
+      (cancel-timer rng-validate-timer))
+    (kill-local-variable 'rng-validate-timer))
+  (when (local-variable-p 'rng-validate-quick-timer)
+    (when rng-validate-quick-timer
+      (cancel-timer rng-validate-quick-timer))
+    (kill-local-variable 'rng-validate-quick-timer)))
+      
+(defun rng-activate-timers ()
+  (unless rng-validate-timer
+    (let ((inhibit-quit t))
+      (setq rng-validate-timer
+            (run-with-idle-timer rng-validate-delay
+                                 t
+                                 'rng-validate-while-idle
+                                 (current-buffer)))
+      (setq rng-validate-quick-timer
+            (run-with-idle-timer rng-validate-quick-delay
+                                 t
+                                 'rng-validate-quick-while-idle
+                                 (current-buffer))))))
+
+(defun rng-validate-clear ()
+  (rng-validate-mode 1 t))
+
+;; These two variables are dynamically bound and used
+;; to pass information between rng-validate-while-idle
+;; and rng-validate-while-idle-continue-p.
+
+(defvar rng-validate-display-point nil)
+(defvar rng-validate-display-modified-p nil)
+
+(defun rng-validate-while-idle-continue-p ()
+  ;; input-pending-p and sit-for run timers that are
+  ;; ripe.  Binding timer-idle-list to nil prevents
+  ;; this.  If we don't do this, then any ripe timers
+  ;; will get run, and we won't get any chance to
+  ;; validate until Emacs becomes idle again or until
+  ;; the other lower priority timers finish (which
+  ;; can take a very long time in the case of
+  ;; jit-lock).
+  (let ((timer-idle-list nil))
+    (and (not (input-pending-p))
+         ;; Fake rng-validate-up-to-date-end so that the mode line
+         ;; shows progress.  Also use this to save point.
+         (let ((rng-validate-up-to-date-end (point)))
+           (goto-char rng-validate-display-point)
+           (when (not rng-validate-display-modified-p)
+             (restore-buffer-modified-p nil))
+           (force-mode-line-update)
+           (let ((continue (sit-for 0)))
+             (goto-char rng-validate-up-to-date-end)
+             continue)))))
+
+;; Calling rng-do-some-validation once with a continue-p function, as
+;; opposed to calling it repeatedly, helps on initial validation of a
+;; large buffer with lots of errors.  The overlays for errors will all
+;; get added when rng-do-some-validation returns and won't slow the
+;; validation process down.
+
+(defun rng-validate-while-idle (buffer)
+  (with-current-buffer buffer
+    (if rng-validate-mode
+        (if (let ((rng-validate-display-point (point))
+                  (rng-validate-display-modified-p (buffer-modified-p)))
+              (rng-do-some-validation 'rng-validate-while-idle-continue-p))
+            (force-mode-line-update)
+          (rng-validate-done))
+      ;; must have done kill-all-local-variables
+      (rng-kill-timers))))
+
+(defun rng-validate-quick-while-idle (buffer)
+  (with-current-buffer buffer
+    (if rng-validate-mode
+        (if (rng-do-some-validation)
+            (force-mode-line-update)
+          (rng-validate-done))
+      ;; must have done kill-all-local-variables
+      (rng-kill-timers))))
+
+(defun rng-validate-done ()
+  (when (or (not (current-message))
+            (rng-current-message-from-error-overlay-p))
+    (rng-error-overlay-message (or (rng-error-overlay-after (point)) 
+                                   (rng-error-overlay-after (1- (point))))))
+  (rng-cancel-timers)
+  (force-mode-line-update))
+
+(defun rng-do-some-validation (&optional continue-p-function)
+  "Do some validation work. Return t if more to do, nil otherwise."
+  (save-excursion
+    (save-restriction
+      (widen)
+      (nxml-with-invisible-motion
+        (condition-case err
+            (and (rng-validate-prepare)
+                 (let ((rng-dt-namespace-context-getter '(nxml-ns-get-context)))
+                   (nxml-with-unmodifying-text-property-changes
+                     (rng-do-some-validation-1 continue-p-function))))
+          ;; errors signalled from a function run by an idle timer
+          ;; are ignored; if we don't catch them, validation
+          ;; will get mysteriously stuck at a single place
+          (rng-compile-error
+           (message "Incorrect schema. %s" (nth 1 err))
+           (rng-validate-mode 0)
+           nil)
+          (error
+           (message "Internal error in rng-validate-mode triggered at buffer position %d. %s"
+                    (point)
+                    (error-message-string err))
+           (rng-validate-mode 0)
+           nil))))))
+
+(defun rng-validate-prepare ()
+  "Prepare to do some validation, initializing point and the state.
+Return t if there is work to do, nil otherwise."
+  (cond ((= rng-validate-up-to-date-end (point-min))
+         (rng-set-initial-state)
+         t)
+        ((= rng-validate-up-to-date-end (point-max))
+         nil)
+        (t (let ((state (get-text-property (1- rng-validate-up-to-date-end)
+                                           'rng-state)))
+             (cond (state
+                    (rng-restore-state state)
+                    (goto-char rng-validate-up-to-date-end))
+                   (t
+                    (let ((pos (previous-single-property-change
+                                rng-validate-up-to-date-end
+                                'rng-state)))
+                      (cond (pos
+                             (rng-restore-state
+                              (or (get-text-property (1- pos) 'rng-state)
+                                  (error "Internal error: state null")))
+                             (goto-char pos))
+                            (t (rng-set-initial-state))))))))))
+
+
+(defun rng-do-some-validation-1 (&optional continue-p-function)
+  (let ((limit (+ rng-validate-up-to-date-end
+                  rng-validate-chunk-size))
+        (remove-start rng-validate-up-to-date-end)
+        (next-cache-point (+ (point) rng-state-cache-distance))
+        (continue t)
+        (xmltok-dtd rng-dtd)
+        have-remaining-chars
+        xmltok-type
+        xmltok-start
+        xmltok-name-colon
+        xmltok-name-end
+        xmltok-replacement
+        xmltok-attributes
+        xmltok-namespace-attributes
+        xmltok-dependent-regions
+        xmltok-errors)
+    (when (= (point) 1)
+      (let ((regions (xmltok-forward-prolog)))
+        (rng-clear-overlays 1 (point))
+        (while regions
+          (when (eq (aref (car regions) 0) 'encoding-name)
+            (rng-process-encoding-name (aref (car regions) 1)
+                                       (aref (car regions) 2)))
+          (setq regions (cdr regions))))
+      (unless (equal rng-dtd xmltok-dtd)
+        (rng-clear-conditional-region))
+      (setq rng-dtd xmltok-dtd))
+    (while continue
+      (setq have-remaining-chars (rng-forward))
+      (let ((pos (point)))
+        (setq continue
+              (and have-remaining-chars
+                   (or (< pos limit)
+                       (and continue-p-function
+                            (funcall continue-p-function)
+                            (setq limit (+ limit rng-validate-chunk-size))
+                            t))))
+        (cond ((and rng-conditional-up-to-date-start
+                    ;; > because we are getting the state from (1- pos)
+                    (> pos rng-conditional-up-to-date-start)
+                    (< pos rng-conditional-up-to-date-end)
+                    (rng-state-matches-current (get-text-property (1- pos)
+                                                                  'rng-state)))
+               (when (< remove-start (1- pos))
+                 (rng-clear-cached-state remove-start (1- pos)))
+               ;; sync up with cached validation state
+               (setq continue nil)
+               ;; do this before settting rng-validate-up-to-date-end
+               ;; in case we get a quit
+               (rng-mark-xmltok-errors)
+               (rng-mark-xmltok-dependent-regions)
+               (setq rng-validate-up-to-date-end
+                     (marker-position rng-conditional-up-to-date-end))
+               (rng-clear-conditional-region)
+               (setq have-remaining-chars
+                     (< rng-validate-up-to-date-end (point-max))))
+              ((or (>= pos next-cache-point)
+                   (not continue))
+               (setq next-cache-point (+ pos rng-state-cache-distance))
+               (rng-clear-cached-state remove-start pos)
+               (when have-remaining-chars
+                 (rng-cache-state (1- pos)))
+               (setq remove-start pos)
+               (unless continue
+                 ;; if we have just blank chars skip to the end
+                 (when have-remaining-chars
+                   (skip-chars-forward " \t\r\n")
+                   (when (= (point) (point-max))
+                     (rng-clear-overlays pos (point))
+                     (rng-clear-cached-state pos (point))
+                     (setq have-remaining-chars nil)
+                     (setq pos (point))))
+                 (when (not have-remaining-chars)
+                   (rng-process-end-document))
+                 (rng-mark-xmltok-errors)
+                 (rng-mark-xmltok-dependent-regions)
+                 (setq rng-validate-up-to-date-end pos)
+                 (when rng-conditional-up-to-date-end
+                   (cond ((<= rng-conditional-up-to-date-end pos)
+                          (rng-clear-conditional-region))
+                         ((< rng-conditional-up-to-date-start pos)
+                          (set-marker rng-conditional-up-to-date-start
+                                      pos)))))))))
+    have-remaining-chars))
+    
+(defun rng-clear-conditional-region ()
+  (when rng-conditional-up-to-date-start
+    (set-marker rng-conditional-up-to-date-start nil)
+    (setq rng-conditional-up-to-date-start nil))
+  (when rng-conditional-up-to-date-end
+    (set-marker rng-conditional-up-to-date-end nil)
+    (setq rng-conditional-up-to-date-end nil)))
+
+(defun rng-clear-cached-state (start end)
+  "Clear cached state between START and END."
+  (remove-text-properties start end '(rng-state nil)))
+
+(defun rng-cache-state (pos)
+  "Save the current state in a text property on the character at pos."
+  (put-text-property pos
+                     (1+ pos)
+                     'rng-state
+                     (rng-get-state)))
+
+(defun rng-state-matches-current (state)
+  (and state
+       (rng-match-state-equal (car state))
+       (nxml-ns-state-equal (nth 1 state))
+       (equal (nth 2 state) rng-open-elements)))
+
+(defun rng-get-state ()
+  (list (rng-match-state)
+        (nxml-ns-state)
+        rng-open-elements))
+
+(defun rng-restore-state (state)
+  (rng-set-match-state (car state))
+  (setq state (cdr state))
+  (nxml-ns-set-state (car state))
+  (setq rng-open-elements (cadr state))
+  (setq rng-pending-contents nil)
+  (setq rng-collecting-text (rng-match-text-typed-p)))
+
+(defun rng-set-initial-state ()
+  (nxml-ns-init)
+  (rng-match-start-document)
+  (setq rng-open-elements nil)
+  (setq rng-pending-contents nil)
+  (goto-char (point-min)))
+
+(defun rng-clear-overlays (beg end)
+  (unless rng-parsing-for-state
+    (let ((overlays (overlays-in beg end)))
+      (while overlays
+        (let* ((overlay (car overlays))
+               (category (overlay-get overlay 'category)))
+          (cond ((eq category 'rng-error)
+                 (let ((inhibit-quit t))
+                   (when (eq overlay rng-message-overlay)
+                     (rng-error-overlay-message nil))
+                   (delete-overlay overlay)
+                   ;; rng-error-count could be nil
+                   ;; if overlays left over from a previous use
+                   ;; of rng-validate-mode that ended with a change of mode
+                   (when rng-error-count
+                     (setq rng-error-count (1- rng-error-count)))))
+                ((and (eq category 'rng-dependent)
+                      (<= beg (overlay-start overlay)))
+                 (delete-overlay overlay))))
+        (setq overlays (cdr overlays))))))
+
+;;; Dependent regions
+
+(defun rng-mark-xmltok-dependent-regions ()
+  (while xmltok-dependent-regions
+    (apply 'rng-mark-xmltok-dependent-region
+           (car xmltok-dependent-regions))
+    (setq xmltok-dependent-regions
+          (cdr xmltok-dependent-regions))))
+
+(defun rng-mark-xmltok-dependent-region (fun start end &rest args)
+  (let ((overlay (make-overlay start end nil t t)))
+    (overlay-put overlay 'category 'rng-dependent)
+    (overlay-put overlay 'rng-funargs (cons fun args))))
+
+(put 'rng-dependent 'evaporate t)
+(put 'rng-dependent 'modification-hooks '(rng-dependent-region-changed))
+(put 'rng-dependent 'insert-behind-hooks '(rng-dependent-region-changed))
+
+(defun rng-dependent-region-changed (overlay
+                                     after-p
+                                     change-start
+                                     change-end
+                                     &optional pre-change-length)
+  (when (and after-p
+             ;; Emacs sometimes appears to call deleted overlays
+             (overlay-start overlay)
+             (let ((funargs (overlay-get overlay 'rng-funargs)))
+               (save-match-data
+                 (save-excursion
+                   (save-restriction
+                     (widen)
+                     (apply (car funargs)
+                            (append (list change-start
+                                          change-end
+                                          pre-change-length
+                                          (overlay-start overlay)
+                                          (overlay-end overlay))
+                                    (cdr funargs))))))))
+    (rng-after-change-function (overlay-start overlay)
+                               change-end
+                               (+ pre-change-length
+                                  (- (overlay-start overlay)
+                                     change-start)))
+    (delete-overlay overlay)))
+
+;;; Error state
+
+(defun rng-mark-xmltok-errors ()
+  (while xmltok-errors
+    (let ((err (car xmltok-errors)))
+      (rng-mark-not-well-formed (xmltok-error-message err)
+                                (xmltok-error-start err)
+                                (xmltok-error-end err)))
+    (setq xmltok-errors (cdr xmltok-errors))))
+
+(defun rng-mark-invalid (message beg end)
+  (rng-mark-error message beg end))
+
+(defun rng-mark-not-well-formed (message beg end)
+  ;; Don't try to validate further
+  ;;(rng-set-match-state rng-not-allowed-ipattern)
+  (rng-mark-error message beg end))
+
+(defun rng-mark-error (message beg end)
+  (unless rng-parsing-for-state
+    (let ((overlays (overlays-in beg end)))
+      (while (and overlays message)
+        (let ((o (car overlays)))
+          (when (and (eq (overlay-get o 'category) 'rng-error)
+                     (= (overlay-start o) beg)
+                     (= (overlay-end o) end))
+            (overlay-put o
+                         'help-echo
+                         (concat (overlay-get o 'help-echo)
+                                 "\n"
+                                 message))
+            (setq message nil)))
+        (setq overlays (cdr overlays))))
+    (when message
+      (let ((inhibit-quit t))
+        (setq rng-error-count (1+ rng-error-count))
+        (let ((overlay
+               (make-overlay beg end nil t
+                             ;; Need to make the rear delimiter advance
+                             ;; with the front delimiter when the overlay
+                             ;; is empty, otherwise the front delimiter
+                             ;; will move past the rear delimiter.
+                             (= beg end))))
+          ;; Ensure when we have two overlapping messages, the help-echo
+          ;; of the one that starts first is shown
+          (overlay-put overlay 'priority beg)
+          (overlay-put overlay 'category 'rng-error)
+          (overlay-put overlay 'help-echo message))))))
+
+(put 'rng-error 'face 'rng-error-face)
+(put 'rng-error 'modification-hooks '(rng-error-modified))
+
+;; If we don't do this, then the front delimiter can move
+;; past the end delimiter.
+(defun rng-error-modified (overlay after-p beg end &optional pre-change-len)
+  (when (and after-p
+             (overlay-start overlay)    ; check not deleted
+             (>= (overlay-start overlay)
+                 (overlay-end overlay)))
+    (let ((inhibit-quit t))
+      (delete-overlay overlay)
+      (setq rng-error-count (1- rng-error-count)))))
+
+(defun rng-echo-area-clear-function ()
+  (setq rng-message-overlay-current nil))
+
+;;; Error navigation
+             
+(defun rng-maybe-echo-error-at-point ()
+  (when (or (not (current-message))
+            (rng-current-message-from-error-overlay-p))
+    (rng-error-overlay-message (rng-error-overlay-after (point)))))
+
+(defun rng-error-overlay-after (pos)
+  (let ((overlays (overlays-in pos (1+ pos)))
+        (best nil))
+    (while overlays
+      (let ((overlay (car overlays)))
+        (when (and (eq (overlay-get overlay 'category)
+                       'rng-error)
+                   (or (not best)
+                       (< (overlay-start best)
+                          (overlay-start overlay))))
+          (setq best overlay)))
+      (setq overlays (cdr overlays)))
+    best))
+
+(defun rng-first-error ()
+  "Go to the first validation error.
+Turn on `rng-validate-mode' if it is not already on."
+  (interactive)
+  (or rng-validate-mode (rng-validate-mode))
+  (when (and (eq rng-validate-up-to-date-end 1)
+             (< rng-validate-up-to-date-end (point-max)))
+    (rng-do-some-validation))
+  (let ((err (rng-find-next-error-overlay (1- (point-min)))))
+    (if err
+        (rng-goto-error-overlay err)
+      (let ((pos (save-excursion
+                   (goto-char (point-min))
+                   (rng-next-error 1))))
+        (when pos
+          (goto-char pos))))))
+
+(defun rng-mouse-first-error (event)
+  "Go to the first validation error from a mouse click."
+  (interactive "e")
+  (select-window (posn-window (event-start event)))
+  (rng-first-error))
+
+(defun rng-next-error (arg)
+  "Go to the next validation error after point.
+Turn on `rng-validate-mode' if it is not already on.
+A prefix ARG specifies how many errors to move. A negative ARG
+moves backwards. Just \\[universal-argument] as a prefix
+means goto the first error."
+  (interactive "P")
+  (if (consp arg)
+      (rng-first-error)
+    (or rng-validate-mode (rng-validate-mode))
+    (setq arg (prefix-numeric-value arg))
+    (if (< arg 0)
+        (rng-previous-error-1 (- arg))
+      (rng-next-error-1 arg))))
+
+(defun rng-previous-error (arg)
+  "Go to the previous validation error before point.
+Turn on `rng-validate-mode' if it is not already on.
+A prefix ARG specifies how many errors to move. A negative ARG
+moves forwards. Just \\[universal-argument] as a prefix
+means goto the first error."
+  (interactive "P")
+  (if (consp arg)
+      (rng-first-error)
+    (or rng-validate-mode (rng-validate-mode))
+    (setq arg (prefix-numeric-value arg))
+    (if (< arg 0)
+        (rng-next-error-1 (- arg))
+      (rng-previous-error-1 arg))))
+
+(defun rng-next-error-1 (arg)
+  (let* ((pos (point))
+         err last-err)
+    (while (and (> arg 0)
+                (setq err (rng-find-next-error-overlay pos)))
+      (setq arg (1- arg))
+      (setq last-err err)
+      (setq pos (overlay-start err)))
+    (when (> arg 0)
+      (setq pos (max pos (1- rng-validate-up-to-date-end)))      
+      (when (< rng-validate-up-to-date-end (point-max))
+        (message "Parsing...")
+        (while (let ((more-to-do (rng-do-some-validation)))
+                 (while (and (> arg 0)
+                             (setq err (rng-find-next-error-overlay pos)))
+                   (setq arg (1- arg))
+                   (setq last-err err)
+                   (setq pos (overlay-start err)))
+                 (when (and (> arg 0)
+                            more-to-do
+                            (< rng-validate-up-to-date-end (point-max)))
+                   ;; Display percentage validated.
+                   (force-mode-line-update)
+                   ;; Force redisplay but don't allow idle timers to run.
+                   (let ((timer-idle-list nil))
+                     (sit-for 0))
+                   (setq pos
+                         (max pos (1- rng-validate-up-to-date-end)))
+                   t)))))
+    (if last-err
+        (rng-goto-error-overlay last-err)
+      (message "No more errors")
+      nil)))
+
+(defun rng-previous-error-1 (arg)
+  (let* ((pos (point))
+         err last-err)
+    (while (and (> arg 0)
+                (setq err (rng-find-previous-error-overlay pos)))
+      (setq pos (overlay-start err))
+      (setq last-err err)
+      (setq arg (1- arg)))
+    (when (and (> arg 0)
+               (< rng-validate-up-to-date-end (min pos (point-max))))
+      (message "Parsing...")
+      (while (and (rng-do-some-validation)
+                  (< rng-validate-up-to-date-end (min pos (point-max))))
+        (force-mode-line-update)
+        ;; Force redisplay but don't allow idle timers to run.
+        (let ((timer-idle-list nil))
+          (sit-for 0)))
+      (while (and (> arg 0)
+                  (setq err (rng-find-previous-error-overlay pos)))
+        (setq pos (overlay-start err))
+        (setq last-err err)
+        (setq arg (1- arg))))
+    (if last-err
+        (rng-goto-error-overlay last-err)
+      (message "No previous errors")
+      nil)))
+      
+(defun rng-goto-error-overlay (err)
+  "Goto the start of error overlay ERR and print its message."
+  (goto-char (overlay-start err))
+  (setq rng-message-overlay-inhibit-point nil)
+  (rng-error-overlay-message err))
+
+(defun rng-error-overlay-message (err)
+  (if err
+      (unless (or (and (eq rng-message-overlay-inhibit-point (point))
+                       (eq rng-message-overlay err))
+                  (= (point-max) 1))
+        (message "%s" (overlay-get err 'help-echo))
+        (setq rng-message-overlay-current t)
+        (setq rng-message-overlay-inhibit-point (point)))
+    (when (rng-current-message-from-error-overlay-p)
+      (message nil))
+    (setq rng-message-overlay-inhibit-point nil))
+  (setq rng-message-overlay err))
+
+(defun rng-current-message-from-error-overlay-p ()
+  (and rng-message-overlay-current
+       rng-message-overlay
+       (equal (overlay-get rng-message-overlay 'help-echo)
+              (current-message))))
+
+(defun rng-find-next-error-overlay (pos)
+  "Return the overlay for the next error starting after POS.
+Return nil if there is no such overlay or it is out of date.
+Do not do any additional validation."
+  (when rng-error-count
+    (let (done found overlays)
+      (while (not done)
+        (cond (overlays
+               (let ((overlay (car overlays)))
+                 (setq overlays (cdr overlays))
+                 (when (and (eq (overlay-get overlay 'category) 'rng-error)
+                            ;; Is it the first?
+                            (= (overlay-start overlay) pos)
+                            ;; Is it up to date?
+                            (<= (overlay-end overlay)
+                                rng-validate-up-to-date-end))
+                   (setq done t)
+                   (setq found overlay))))
+              ((or (= pos (point-max))
+                   (> (setq pos (next-overlay-change pos))
+                      rng-validate-up-to-date-end))
+               (setq done t))
+              (t (setq overlays (overlays-in pos (1+ pos))))))
+      found)))
+
+(defun rng-find-previous-error-overlay (pos)
+  "Return the overlay for the last error starting before POS.
+Return nil if there is no such overlay or it is out of date.
+Do not do any additional validation."
+  (when (and rng-error-count
+             (<= pos rng-validate-up-to-date-end))
+    (let (done found overlays)
+      (while (not done)
+        (cond (overlays
+               (let ((overlay (car overlays)))
+                 (setq overlays (cdr overlays))
+                 (when (and (eq (overlay-get overlay 'category) 'rng-error)
+                            ;; Is it the first?
+                            (= (overlay-start overlay) pos))
+                   (setq done t)
+                   (setq found overlay))))
+              ((= pos (point-min))
+               (setq done t))
+              (t
+               (setq pos (previous-overlay-change pos))
+               (setq overlays (overlays-in pos (1+ pos))))))
+      found)))
+
+;;; Parsing
+
+(defun rng-forward (&optional limit)
+  "Move forward over one or more tokens updating the state.
+If LIMIT is nil, stop after tags.
+If LIMIT is non-nil, stop when end of last token parsed is >= LIMIT.
+Return nil at end of buffer, t otherwise."
+  (let (type)
+    (while (progn
+             (setq type (xmltok-forward))
+             (rng-clear-overlays xmltok-start (point))
+             (let ((continue
+                    (cond ((eq type 'start-tag)
+                           (rng-process-start-tag 'start-tag)
+                           nil)
+                          ((eq type 'end-tag)
+                           (rng-process-end-tag)
+                           nil)
+                          ((eq type 'empty-element)
+                           (rng-process-start-tag 'empty-element)
+                           nil)
+                          ((eq type 'space)
+                           (rng-process-text xmltok-start nil t)
+                           t)
+                          ((eq type 'data)
+                           (rng-process-text xmltok-start nil nil)
+                           t)
+                          ((memq type '(entity-ref char-ref))
+                           (cond (xmltok-replacement
+                                  (rng-process-text xmltok-start
+                                                    nil
+                                                    'maybe
+                                                    xmltok-replacement))
+                                 ((eq type 'char-ref)
+                                  (rng-process-unknown-char))
+                                 (t
+                                  (rng-process-unknown-entity)))
+                           t)
+                          ((eq type 'cdata-section)
+                           (rng-process-text (+ xmltok-start 9) ; "<![CDATA["
+                                             (- (point) 3) ; "]]>"
+                                             'maybe)
+                           t)
+                          ((eq type 'partial-start-tag)
+                           (rng-process-start-tag 'partial-start-tag)
+                           t)
+                          ((eq type 'partial-empty-element)
+                           (rng-process-start-tag 'empty-element)
+                           t)
+                          ((eq type 'partial-end-tag)
+                           (rng-process-end-tag 'partial)
+                           t)
+                          (t type))))
+               (if limit
+                   (< (point) limit)
+                 continue))))
+    (and type t)))
+
+(defun rng-process-start-tag (tag-type)
+  "TAG-TYPE is `start-tag' for a start-tag, `empty-element' for
+an empty element.  partial-empty-element should be passed
+as empty-element."
+  (and rng-collecting-text (rng-flush-text))
+  (setq rng-collecting-text nil)
+  (setq rng-pending-contents nil)
+  (rng-process-namespaces)
+  (let ((tag (rng-process-tag-name)))
+    (rng-process-attributes)
+    ;; set the state appropriately
+    (cond ((eq tag-type 'empty-element)
+           (rng-process-start-tag-close)
+           ;; deal with missing content with empty element
+           (when (not (rng-match-empty-content))
+             (rng-match-after)
+             (rng-mark-start-tag-close "Empty content not allowed"))
+           (nxml-ns-pop-state))
+          ((eq tag-type 'start-tag)
+           (rng-process-start-tag-close)
+           (setq rng-collecting-text (rng-match-text-typed-p))
+           (rng-push-tag tag))
+          ((eq tag-type 'partial-start-tag)
+           (rng-process-start-tag-close)
+           (rng-match-after)
+           (nxml-ns-pop-state)))))
+
+(defun rng-process-namespaces ()
+  (let ((nsatts xmltok-namespace-attributes)
+        prefixes)
+    (nxml-ns-push-state)
+    (while nsatts
+      (let* ((att (car nsatts))
+             (value (xmltok-attribute-value att)))
+        (when value
+          (let ((ns (nxml-make-namespace value))
+                (prefix (and (xmltok-attribute-prefix att)
+                             (xmltok-attribute-local-name att))))
+            (cond ((member prefix prefixes)
+                   (rng-mark-invalid "Duplicate namespace declaration"
+                                     (xmltok-attribute-name-start att)
+                                     (xmltok-attribute-name-end att)))
+                  ((not prefix)
+                   (nxml-ns-set-default ns))
+                  (ns
+                   (nxml-ns-set-prefix prefix ns))
+                  (t
+                   ;; cannot have xmlns:foo=""
+                   (rng-mark-invalid "Namespace prefix cannot be undeclared"
+                                     (1- (xmltok-attribute-value-start att))
+                                     (1+ (xmltok-attribute-value-end att)))))
+            (setq prefixes (cons prefix prefixes)))))
+      (setq nsatts (cdr nsatts)))))
+
+(defun rng-process-tag-name ()
+  (let* ((prefix (xmltok-start-tag-prefix))
+         (local-name (xmltok-start-tag-local-name))
+         (name
+          (if prefix
+              (let ((ns (nxml-ns-get-prefix prefix)))
+                (cond (ns (cons ns local-name))
+                      ((and (setq ns
+                                  (rng-match-infer-start-tag-namespace
+                                   local-name))
+                            (rng-match-start-tag-open (cons ns local-name)))
+                       (nxml-ns-set-prefix prefix ns)
+                       (rng-mark-start-tag-close "Missing xmlns:%s=\"%s\""
+                                                 prefix
+                                                 (nxml-namespace-name ns))
+                       nil)
+                      (t
+                       (rng-recover-bad-element-prefix)
+                       nil)))
+            (cons (nxml-ns-get-default) local-name))))
+    (when (and name
+               (not (rng-match-start-tag-open name)))
+      (unless (and (not (car name))
+                   (let ((ns (rng-match-infer-start-tag-namespace (cdr name))))
+                     (and ns
+                          (rng-match-start-tag-open (cons ns local-name))
+                          (progn
+                            (nxml-ns-set-default ns)
+                            ;; XXX need to check we don't have xmlns=""
+                            (rng-mark-start-tag-close "Missing xmlns=\"%s\""
+                                                      (nxml-namespace-name ns))
+                            t))))
+        (rng-recover-start-tag-open name)))
+    (cons prefix local-name)))
+
+(defun rng-process-attributes ()
+  (let ((atts xmltok-attributes)
+        names)
+    (while atts
+      (let* ((att (car atts))
+             (prefix (xmltok-attribute-prefix att))
+             (local-name (xmltok-attribute-local-name att))
+             (name
+              (if prefix
+                  (let ((ns (nxml-ns-get-prefix prefix)))
+                    (and ns
+                         (cons ns local-name)))
+                (cons nil local-name))))
+        (cond ((not name)
+               (rng-recover-bad-attribute-prefix att))
+              ((member name names)
+               (rng-recover-duplicate-attribute-name att))
+              ((not (rng-match-attribute-name name))
+               (rng-recover-attribute-name att))
+              ((rng-match-text-typed-p)
+               (let ((value (xmltok-attribute-value att)))
+                 (if value
+                     (or (rng-match-attribute-value value)
+                         (rng-recover-attribute-value att))
+                   (rng-match-after))))
+              (t (or (rng-match-end-tag)
+                     (error "Internal error:\
+ invalid on untyped attribute value"))))
+        (setq names (cons name names)))
+      (setq atts (cdr atts)))))
+
+(defun rng-process-start-tag-close ()
+  ;; deal with missing attributes
+  (unless (rng-match-start-tag-close)
+    (rng-mark-start-tag-close (rng-missing-attributes-message))
+    (rng-match-ignore-attributes)))
+
+(defun rng-mark-start-tag-close (&rest args)
+  (when (not (eq xmltok-type 'partial-start-tag))
+    (rng-mark-invalid (apply 'format args)
+                      (- (point)
+                         (if (eq xmltok-type 'empty-element)
+                             2
+                           1))
+                      (point))))
+
+(defun rng-recover-bad-element-prefix ()
+  (rng-mark-invalid "Prefix not declared"
+                    (1+ xmltok-start)
+                    xmltok-name-colon)
+  (rng-match-unknown-start-tag-open))
+
+(defun rng-recover-bad-attribute-prefix (att)
+  (rng-mark-invalid "Prefix not declared"
+                    (xmltok-attribute-name-start att)
+                    (xmltok-attribute-name-colon att)))
+
+(defun rng-recover-duplicate-attribute-name (att)
+  (rng-mark-invalid "Duplicate attribute"
+                    (xmltok-attribute-name-start att)
+                    (xmltok-attribute-name-end att)))
+
+(defun rng-recover-start-tag-open (name)
+  (let ((required (rng-match-required-element-name)))
+    (cond ((and required
+                (rng-match-start-tag-open required)
+                (rng-match-after)
+                (rng-match-start-tag-open name))
+           (rng-mark-invalid (concat "Missing element "
+                                     (rng-quote-string
+                                      (rng-name-to-string required)))
+                             xmltok-start
+                             (1+ xmltok-start)))
+          ((and (rng-match-optionalize-elements)
+                (rng-match-start-tag-open name))
+           (rng-mark-invalid "Required elements missing"
+                             xmltok-start
+                             (1+ xmltok-start)))
+          ((rng-match-out-of-context-start-tag-open name)
+           (rng-mark-invalid "Element not allowed in this context"
+                             (1+ xmltok-start)
+                             xmltok-name-end))
+          (t
+           (rng-match-unknown-start-tag-open)
+           (rng-mark-invalid "Unknown element"
+                             (1+ xmltok-start)
+                             xmltok-name-end)))))
+
+(defun rng-recover-attribute-value (att)
+  (let ((start (xmltok-attribute-value-start att))
+        (end (xmltok-attribute-value-end att)))
+    (if (= start end)
+        (rng-mark-invalid "Empty attribute value invalid" start (1+ end))
+      (rng-mark-invalid "Attribute value invalid" start end)))
+  (rng-match-after))
+
+(defun rng-recover-attribute-name (att)
+  (rng-mark-invalid "Attribute not allowed"
+                    (xmltok-attribute-name-start att)
+                    (xmltok-attribute-name-end att)))
+
+(defun rng-missing-attributes-message ()
+  (let ((required-attributes
+         (rng-match-required-attribute-names)))
+    (cond ((not required-attributes)
+           "Required attributes missing")
+          ((not (cdr required-attributes))
+           (concat "Missing attribute "
+                   (rng-quote-string
+                    (rng-name-to-string (car required-attributes) t))))
+          (t
+           (concat "Missing attributes "
+                   (mapconcat (lambda (nm)
+                                (rng-quote-string
+                                 (rng-name-to-string nm t)))
+                              required-attributes
+                              ", "))))))
+      
+(defun rng-process-end-tag (&optional partial)
+  (cond ((not rng-open-elements)
+         (rng-mark-not-well-formed "Extra end-tag"
+                                   xmltok-start
+                                   (point)))
+        ((or partial
+             (equal (cons (xmltok-end-tag-prefix)
+                          (xmltok-end-tag-local-name))
+                    (car rng-open-elements)))
+         (rng-end-element))
+        (t (rng-recover-mismatched-end-tag))))
+
+(defun rng-end-element ()
+  (if rng-collecting-text
+      (let ((contents (rng-contents-string)))
+        (cond ((not contents) (rng-match-after))
+              ((not (rng-match-element-value contents))
+               (let* ((region (rng-contents-region)))
+                 (if (not region)
+                     (rng-mark-invalid "Empty content not allowed"
+                                       xmltok-start
+                                       (+ xmltok-start 2))
+                   (rng-mark-invalid "Invalid data"
+                                     (car region)
+                                     (cdr region))))
+               (rng-match-after)))
+        (setq rng-collecting-text nil)
+        (setq rng-pending-contents nil))
+    (unless (rng-match-end-tag)
+       (rng-mark-invalid (rng-missing-element-message)
+                         xmltok-start
+                         (+ xmltok-start 2))
+       (rng-match-after)))
+  (nxml-ns-pop-state)
+  (when (eq (car rng-open-elements) t)
+    (rng-pop-tag))
+  (rng-pop-tag))
+
+(defun rng-missing-element-message ()
+  (let ((element (rng-match-required-element-name)))
+    (if element
+        (concat "Missing element "
+                (rng-quote-string (rng-name-to-string element)))
+      "Required child elements missing")))
+
+(defun rng-recover-mismatched-end-tag ()
+  (let* ((name (cons (xmltok-end-tag-prefix)
+                     (xmltok-end-tag-local-name))))
+    (cond ((member name (cdr rng-open-elements))
+           (let* ((suppress-error (eq (car rng-open-elements) t))
+                  missing top)
+             (while (progn
+                      (setq top (car rng-open-elements))
+                      (rng-pop-tag)
+                      (unless (eq top t)
+                        (setq missing (cons top missing))
+                        (nxml-ns-pop-state)
+                        (rng-match-after))
+                      (not (equal top name))))
+             (unless suppress-error
+               (rng-mark-missing-end-tags (cdr missing)))))
+          ((rng-match-empty-before-p)
+           (rng-mark-mismatched-end-tag)
+           (rng-end-element))
+          (t (rng-mark-mismatched-end-tag)
+             (setq rng-open-elements
+                   (cons t rng-open-elements))))))
+
+(defun rng-mark-missing-end-tags (missing)
+  (rng-mark-not-well-formed
+   (format "Missing end-tag%s %s"
+           (if (null (cdr missing)) "" "s")
+           (mapconcat (lambda (name)
+                        (rng-quote-string
+                         (if (car name)
+                             (concat (car name)
+                                     ":"
+                                     (cdr name))
+                           (cdr name))))
+                      missing
+                      ", "))
+   xmltok-start
+   (+ xmltok-start 2)))
+
+(defun rng-mark-mismatched-end-tag ()
+  (rng-mark-not-well-formed "Mismatched end-tag"
+                            (+ xmltok-start 2)
+                            xmltok-name-end))
+
+(defun rng-push-tag (prefix-local-name)
+  (setq rng-open-elements
+        (cons prefix-local-name rng-open-elements)))
+
+(defun rng-pop-tag ()
+  (setq rng-open-elements (cdr rng-open-elements)))
+
+(defun rng-contents-string ()
+  (let ((contents rng-pending-contents))
+    (cond ((not contents) "")
+          ((memq nil contents) nil)
+          ((not (cdr contents))
+           (rng-segment-string (car contents)))
+          (t (apply 'concat
+                    (nreverse (mapcar 'rng-segment-string
+                                      contents)))))))
+
+(defun rng-segment-string (segment)
+  (or (car segment)
+      (apply 'buffer-substring-no-properties
+             (cdr segment))))
+
+(defun rng-segment-blank-p (segment)
+  (if (car segment)
+      (rng-blank-p (car segment))
+    (apply 'rng-region-blank-p
+           (cdr segment))))
+
+(defun rng-contents-region ()
+  (if (null rng-pending-contents)
+      nil
+    (let* ((contents rng-pending-contents)
+           (head (cdar contents))
+           (start (car head))
+           (end (cadr head)))
+      (while (setq contents (cdr contents))
+        (setq start (car (cdar contents))))
+      (cons start end))))
+
+(defun rng-process-text (start end whitespace &optional value)
+  "Process characters between position START and END as text.
+END nil means point. WHITESPACE t means known to be whitespace, nil
+means known not to be, anything else means unknown whether whitespace
+or not. END must not be nil if WHITESPACE is neither t nor nil.
+VALUE is a string or nil; nil means the value is equal to the
+string between START and END."
+  (cond (rng-collecting-text
+         (setq rng-pending-contents (cons (list value start (or end (point)))
+                                          rng-pending-contents)))
+        ((not (or (and whitespace
+                       (or (eq whitespace t)
+                           (if value
+                               (rng-blank-p value)
+                             (rng-region-blank-p start end))))
+                  (rng-match-mixed-text)))
+         (rng-mark-invalid "Text not allowed" start (or end (point))))))
+
+(defun rng-process-unknown-char ()
+  (when rng-collecting-text
+    (setq rng-pending-contents
+          (cons nil rng-pending-contents))))
+
+(defun rng-process-unknown-entity ()
+  (rng-process-unknown-char)
+  (rng-match-optionalize-elements))
+
+(defun rng-region-blank-p (beg end)
+  (save-excursion
+    (goto-char beg)
+    (= (skip-chars-forward " \n\r\t" end)
+       (- end beg))))
+
+(defun rng-flush-text ()
+  (while rng-pending-contents
+    (let ((segment (car rng-pending-contents)))
+      (unless (or (rng-segment-blank-p segment)
+                  (rng-match-mixed-text))
+        (let ((region (cdr segment)))
+          (rng-mark-invalid "In this context text cannot be mixed with elements"
+                            (car region)
+                            (cadr region)))))
+    (setq rng-pending-contents (cdr rng-pending-contents))))
+
+(defun rng-process-end-document ()
+  ;; this is necessary to clear empty overlays at (point-max)
+  (rng-clear-overlays (point) (point))
+  (let ((start (save-excursion
+                 (skip-chars-backward " \t\r\n")
+                 (point))))
+    (cond (rng-open-elements
+           (unless (eq (car rng-open-elements) t)
+             (rng-mark-not-well-formed "Missing end-tag"
+                                       start
+                                       (point))))
+          ((not (rng-match-nullable-p))
+           (rng-mark-not-well-formed "No document element"
+                                     start
+                                     (point))))))
+
+(defun rng-process-encoding-name (beg end)
+  (unless (let ((charset (buffer-substring-no-properties beg end)))
+            (or (nxml-mime-charset-coding-system charset)
+                (string= (downcase charset) "utf-16")))
+    (rng-mark-not-well-formed "Unsupported encoding" beg end)))
+
+(defun rng-name-to-string (name &optional attributep)
+  (let ((ns (car name))
+        (local-name (cdr name)))
+    (if (or (not ns)
+            (and (not attributep)
+                 (eq (nxml-ns-get-default) ns)))
+        local-name
+      (let ((prefix (nxml-ns-prefix-for ns)))
+        (if prefix
+            (concat prefix ":" local-name)
+          (concat "{" (symbol-name ns) "}" local-name))))))
+
+(provide 'rng-valid)
+
+;;; rng-valid.el ends here
diff --git a/lisp/nxml/rng-xsd.el b/lisp/nxml/rng-xsd.el
new file mode 100644
index 00000000000..65091ef8795
--- /dev/null
+++ b/lisp/nxml/rng-xsd.el
@@ -0,0 +1,858 @@
+;;; rng-xsd.el --- W3C XML Schema datatypes library for RELAX NG
+
+;; Copyright (C) 2003 Free Software Foundation, Inc.
+
+;; Author: James Clark
+;; Keywords: XML, RelaxNG
+
+;; This program is free software; you can redistribute it and/or
+;; modify it under the terms of the GNU General Public License as
+;; published by the Free Software Foundation; either version 2 of
+;; the License, or (at your option) any later version.
+
+;; This program is distributed in the hope that it will be
+;; useful, but WITHOUT ANY WARRANTY; without even the implied
+;; warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+;; PURPOSE.  See the GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public
+;; License along with this program; if not, write to the Free
+;; Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+;; MA 02111-1307 USA
+
+;;; Commentary:
+
+;; The main entry point is `rng-xsd-compile'. The validator
+;; knows to use this for the datatype library with URI
+;; http://www.w3.org/2001/XMLSchema-datatypes because it
+;; is the value of the rng-dt-compile property on that URI
+;; as a symbol.
+;;
+;; W3C XML Schema Datatypes are specified by
+;;   http://www.w3.org/TR/xmlschema-2/
+;; Guidelines for using them with RELAX NG are described in
+;;   http://relaxng.org/xsd.html
+
+;;; Code:
+
+(require 'rng-dt)
+(require 'rng-util)
+(require 'xsd-regexp)
+
+;;;###autoload
+(put 'http://www.w3.org/2001/XMLSchema-datatypes
+     'rng-dt-compile
+     'rng-xsd-compile)
+
+;;;###autoload
+(defun rng-xsd-compile (name params)
+  "Provides W3C XML Schema as a RELAX NG datatypes library. NAME is a
+symbol giving the local name of the datatype.  PARAMS is a list of
+pairs (PARAM-NAME . PARAM-VALUE) where PARAM-NAME is a symbol giving
+the name of the parameter and PARAM-VALUE is a string giving its
+value.  If NAME or PARAMS are invalid, it calls rng-dt-error passing
+it arguments in the same style as format; the value from rng-dt-error
+will be returned.  Otherwise, it returns a list.  The first member of
+the list is t if any string is a legal value for the datatype and nil
+otherwise.  The second argument is a symbol; this symbol will be
+called as a function passing it a string followed by the remaining
+members of the list.  The function must return an object representing
+the value of the datatype that was represented by the string, or nil
+if the string is not a representation of any value. The object
+returned can be any convenient non-nil value, provided that, if two
+strings represent the same value, the returned objects must be equal."
+  (let ((convert (get name 'rng-xsd-convert)))
+    (if (not convert)
+        (rng-dt-error "There is no XSD datatype named %s" name)
+      (rng-xsd-compile1 name params convert))))
+
+;;; Parameters
+
+(defun rng-xsd-compile1 (name params convert)
+  (if (null params)
+      (cons (equal convert '(identity))
+            (cond ((eq name 'string) convert)
+                  ((eq name 'normalizedString)
+                   (cons 'rng-xsd-replace-space convert))
+                  ((and (not (eq name 'string))
+                        (or (memq 'identity convert)
+                            (memq 'rng-xsd-convert-any-uri convert)
+                            (memq 'rng-xsd-check-pattern convert)))
+                   (cons 'rng-xsd-collapse-space convert))
+                  (t convert)))
+    (let* ((param (car params))
+           (param-name (car param))
+           (param-value (cdr param)))
+      (cond ((memq param-name
+                   '(minExclusive maxExclusive minInclusive maxInclusive))
+             (let ((limit (apply (car convert)
+                                 (cons param-value
+                                       (cdr convert))))
+                   (less-than-fun (get name 'rng-xsd-less-than)))
+               (cond ((not limit)
+                      (rng-dt-error "Minimum value %s is not valid"
+                                    param-value))
+                     ((not less-than-fun)
+                      (rng-dt-error "Values of type %s are not ordered"
+                                    param-name))
+                     (t
+                      (rng-xsd-compile1 name
+                                        (cdr params)
+                                        (cons (get param-name
+                                                   'rng-xsd-check)
+                                              (cons less-than-fun
+                                                    (cons limit convert))))))))
+            ((memq param-name '(length minLength maxLength))
+             (let ((limit (rng-xsd-string-to-non-negative-integer param-value))
+                   (length-fun (get name 'rng-xsd-length)))
+               (cond ((not limit)
+                      (rng-dt-error "Length %s is not valid" param-value))
+                     ((not length-fun)
+                      (rng-dt-error "Values of type %s do not have a length"
+                                    param-name))
+                     (t
+                      (rng-xsd-compile1 name
+                                        (cdr params)
+                                        (cons (get param-name
+                                                   'rng-xsd-check)
+                                              (cons length-fun
+                                                    (cons limit convert))))))))
+            ((memq param-name '(fractionDigits totalDigits))
+             (let ((n (rng-xsd-string-to-non-negative-integer param-value)))
+               (cond ((not n)
+                      (rng-dt-error "Number of digits %s is not valid"
+                                    param-value))
+                     (t
+                      (rng-xsd-compile1 name
+                                        (cdr params)
+                                        (cons (get param-name
+                                                   'rng-xsd-check)
+                                              (cons n convert)))))))
+            ((eq param-name 'pattern)
+             (condition-case err
+                 (rng-xsd-compile1 name
+                                   (cdr params)
+                                   (cons 'rng-xsd-check-pattern
+                                         (cons (concat
+                                                "\\`"
+                                                (xsdre-translate param-value)
+                                                "\\'")
+                                               convert)))
+               (xsdre-invalid-regexp
+                (rng-dt-error "Invalid regular expression (%s)"
+                              (nth 1 err)))))
+            ((memq param-name '(enumeration whiteSpace))
+             (rng-dt-error "Facet %s cannot be used in RELAX NG" param-name))
+            (t (rng-dt-error "Unknown facet %s" param-name))))))
+          
+(defun rng-xsd-string-to-non-negative-integer (str)
+  (and (rng-xsd-convert-integer str)
+       (let ((n (string-to-number str)))
+         (and (integerp n)
+              (>= n 0)
+              n))))
+
+(defun rng-xsd-collapse-space (str convert &rest args)
+  (apply convert (cons (mapconcat 'identity (split-string str "[ \t\n\r]+")
+                                  " ")
+                       args)))
+
+(defun rng-xsd-replace-space (str convert &rest args)
+  (apply convert
+         (cons (let ((i 0)
+                     copied)
+                 (while (and (setq i (string-match "[\r\n\t]" str i))
+                             (or copied (setq copied (copy-sequence str)))
+                             (aset copied i 32)
+                             (setq i (1+ i))))
+                 (or copied str))
+               args)))
+
+(put 'minExclusive 'rng-xsd-check 'rng-xsd-check-min-exclusive)
+(put 'minInclusive 'rng-xsd-check 'rng-xsd-check-min-inclusive)
+(put 'maxExclusive 'rng-xsd-check 'rng-xsd-check-max-exclusive)
+(put 'maxInclusive 'rng-xsd-check 'rng-xsd-check-max-inclusive)
+(put 'length 'rng-xsd-check 'rng-xsd-check-length)
+(put 'minLength 'rng-xsd-check 'rng-xsd-check-min-length)
+(put 'maxLength 'rng-xsd-check 'rng-xsd-check-max-length)
+(put 'fractionDigits 'rng-xsd-check 'rng-xsd-check-fraction-digits)
+(put 'totalDigits 'rng-xsd-check 'rng-xsd-check-total-digits)
+
+(defun rng-xsd-check-min-exclusive (str less-than-fun limit convert &rest args)
+  (let ((obj (apply convert (cons str args))))
+    (and obj
+         (funcall less-than-fun limit obj)
+         obj)))
+
+(defun rng-xsd-check-min-inclusive (str less-than-fun limit convert &rest args)
+  (let ((obj (apply convert (cons str args))))
+    (and obj
+         (or (funcall less-than-fun limit obj)
+             (equal limit obj))
+         obj)))
+
+(defun rng-xsd-check-max-exclusive (str less-than-fun limit convert &rest args)
+  (let ((obj (apply convert (cons str args))))
+    (and obj
+         (funcall less-than-fun obj limit)
+         obj)))
+
+(defun rng-xsd-check-max-inclusive (str less-than-fun limit convert &rest args)
+  (let ((obj (apply convert (cons str args))))
+    (and obj
+         (or (funcall less-than-fun obj limit)
+             (equal obj limit))
+         obj)))
+
+(defun rng-xsd-check-min-length (str length-fun limit convert &rest args)
+  (let ((obj (apply convert (cons str args))))
+    (and obj
+         (>= (funcall length-fun obj) limit)
+         obj)))
+
+(defun rng-xsd-check-max-length (str length-fun limit convert &rest args)
+  (let ((obj (apply convert (cons str args))))
+    (and obj
+         (<= (funcall length-fun obj) limit)
+         obj)))
+
+(defun rng-xsd-check-length (str length-fun len convert &rest args)
+  (let ((obj (apply convert (cons str args))))
+    (and obj
+         (= (funcall length-fun obj) len)
+         obj)))
+
+(defun rng-xsd-check-fraction-digits (str n convert &rest args)
+  (let ((obj (apply convert (cons str args))))
+    (and obj
+         (<= (length (aref obj 2)) n)
+         obj)))
+
+(defun rng-xsd-check-total-digits (str n convert &rest args)
+  (let ((obj (apply convert (cons str args))))
+    (and obj
+         (<= (+ (length (aref obj 1))
+                (length (aref obj 2)))
+             n)
+         obj)))
+
+(defun rng-xsd-check-pattern (str regexp convert &rest args)
+  (and (string-match regexp str)
+       (apply convert (cons str args))))
+
+  
+(defun rng-xsd-convert-boolean (string)
+  (and (string-match "\\`[ \t\n\r]*\\(?:\\(true\\|1\\)\\|false\\|0\\)[ \t\n\r]*\\'" string)
+       (if (match-beginning 1) 'true 'false)))
+
+(defun rng-xsd-convert-decimal (string)
+  "Convert a string representing a decimal to an object representing
+its values.  A decimal value is represented by a vector [SIGN
+INTEGER-DIGITS FRACTION-DIGITS] where SIGN is 1 or -1, INTEGER-DIGITS
+is a string containing zero or more digits, with no leading zero, and
+FRACTION-DIGITS is a string containing zero or more digits with no
+trailing digits.  For example, -0021.0430 would be represented by [-1
+\"21\" \"043\"]."
+  (and (string-match "\\`[ \t\n\r]*\\([-+]\\)?\\(0*\\([1-9][0-9]*\\)?\\(\\.\\([0-9]*[1-9]\\)?0*\\)?\\)[ \t\n\r]*\\'" string)
+       (let ((digits (match-string 2 string)))
+         (and (not (string= digits "."))
+              (not (string= digits ""))))
+       (let ((integer-digits (match-string 3 string)))
+         (vector (if (and (equal (match-string 1 string) "-")
+                          ;; Normalize -0 to 0
+                          integer-digits)
+                     -1
+                   1)
+                 (or integer-digits "")
+                 (or (match-string 5 string) "")))))
+
+(defun rng-xsd-convert-integer (string)
+  (and (string-match "\\`[ \t\n\r]*\\([-+]\\)?\\(?:0*\\([1-9][0-9]*\\)\\|0+\\)[ \t\n\r]*\\'" string)
+       (let ((integer-digits (match-string 2 string)))
+         (vector (if (and (equal (match-string 1 string) "-")
+                          ;; Normalize -0 to 0
+                          integer-digits)
+                     -1
+                   1)
+                 (or integer-digits "")
+                 ""))))
+
+(defun rng-xsd-decimal< (n1 n2)
+  (< (rng-xsd-compare-decimal n1 n2) 0))
+
+(defun rng-xsd-compare-decimal (n1 n2)
+  "Return a < 0, 0, > 0 according as n1 < n2, n1 = n2 or n1 > n2."
+  (let* ((sign1 (aref n1 0))
+         (sign2 (aref n2 0))
+         (sign (- sign1 sign2)))
+    (if (= sign 0)
+        (* sign1
+           (let* ((int1 (aref n1 1))
+                  (int2 (aref n2 1))
+                  (len1 (length int1))
+                  (len2 (length int2))
+                  (lencmp (- len1 len2)))
+             (if (eq lencmp 0)
+                 (if (string= int1 int2)
+                     (rng-xsd-strcmp (aref n1 2) (aref n2 2))
+                   (rng-xsd-strcmp int1 int2))
+               lencmp)))
+      sign)))
+
+(defconst rng-xsd-float-regexp
+  (concat "\\`[ \r\n\t]*\\(?:"
+          "\\("
+          "[-+]?\\(?:[0-9]+\\(?:\\.[0-9]*\\)?\\|\\.[0-9]+\\)"
+          "\\(?:[eE][-+]?[0-9]+\\)?"
+          "\\)"
+          "\\|\\(INF\\)"
+          "\\|\\(-INF\\)"
+          "\\|\\(NaN\\)"
+          "\\)[ \r\n\t]*\\'"))
+
+(defun rng-xsd-convert-float (string)
+  (cond ((not (string-match rng-xsd-float-regexp string)) nil)
+        ((match-beginning 1)
+         (float (string-to-number (match-string 1 string))))
+        ((match-beginning 2) 1.0e+INF)
+        ((match-beginning 3) -1.0e+INF)
+        ;; Don't use a NaN float because we want NaN to be equal to NaN
+        ((match-beginning 4) 'NaN)))
+         
+(defun rng-xsd-float< (f1 f2)
+  (and (not (eq f1 'NaN))
+       (not (eq f2 'NaN))
+       (< f1 f2)))
+  
+(defun rng-xsd-convert-token (string regexp)
+  (and (string-match regexp string)
+       (match-string 1 string)))
+
+(defun rng-xsd-convert-hex-binary (string)
+  (and (string-match "\\`[ \r\n\t]*\\(\\(?:[0-9A-Fa-f][0-9A-Fa-f]\\)*\\)[ \r\n\t]*\\'"
+                     string)
+       (downcase (match-string 1 string))))
+
+(defun rng-xsd-hex-binary-length (obj)
+  (/ (length obj) 2))
+
+(defconst rng-xsd-base64-binary-regexp
+  (let ((S "[ \t\r\n]*")
+        (B04 "[AQgw]")
+        (B16 "[AEIMQUYcgkosw048]")
+        (B64 "[A-Za-z0-9+/]"))
+    (concat "\\`" S "\\(?:\\(?:" B64 S "\\)\\{4\\}\\)*"
+            "\\(?:" B64 S B64 S B16 S "=" S 
+            "\\|" B64 S B04 S "=" S "=" S "\\)?\\'")))
+
+(defun rng-xsd-convert-base64-binary (string)
+  (and (string-match rng-xsd-base64-binary-regexp string)
+       (replace-regexp-in-string "[ \t\r\n]+" "" string t t)))
+
+(defun rng-xsd-base64-binary-length (obj)
+  (let ((n (* (/ (length obj) 4) 3)))
+    (if (and (> n 0)
+             (string= (substring obj -1) "="))
+        (- n (if (string= (substring obj -2) "==")
+                 2
+               1))
+      n)))
+
+(defun rng-xsd-convert-any-uri (string)
+  (and (string-match "\\`\\(?:[^%]\\|%[0-9a-fA-F][0-9a-fA-F]\\)?*\\'" string)
+       (string-match "\\`[^#]*\\(?:#[^#]*\\)?\\'" string)
+       (string-match "\\`\\(?:[a-zA-Z][-+.A-Za-z0-9]*:.+\\|[^:]*\\(?:[#/?].*\\)?\\)\\'" string)
+       string))
+
+(defun rng-xsd-make-date-time-regexp (template)
+  "Returns a regular expression matching a ISO 8601 date/time. The
+template is a string with Y standing for years field, M standing for
+months, D standing for day of month, T standing for a literal T, t
+standing for time and - standing for a literal hyphen.  A time zone is
+always allowed at the end. Regardless of the fields appearing in the
+template, the regular expression will have twelve groups matching the
+year sign, year, month, day of month, hours, minutes, integer seconds,
+fractional seconds (including leading period), time zone, time zone
+sign, time zone hours, time zone minutes."
+  (let ((i 0)
+        (len (length template))
+        (parts nil)
+        first last c)
+    (while (< i len)
+      (setq c (aref template i))
+      (setq parts
+            (cons (cond ((eq c ?Y)
+                         (setq first 0)
+                         (setq last 1)
+                         "\\(-\\)?\\(\\(?:[1-9][0-9]*\\)?[0-9]\\{4\\}\\)")
+                        ((eq c ?M)
+                         (or first
+                             (setq first 2))
+                         (setq last 2)
+                         "\\([0-9][0-9]\\)")
+                        ((eq c ?D)
+                         (or first
+                             (setq first 3))
+                         (setq last 3)
+                         "\\([0-9][0-9]\\)")
+                        ((eq c ?t)
+                         (or first
+                             (setq first 4))
+                         (setq last 7)
+                         "\\([0-9][0-9]\\):\\([0-9][0-9]\\):\\([0-9][0-9]\\)\\(\\.[0-9]*\\)?")
+                        (t (string c)))
+                  parts))
+      (setq i (1+ i)))
+    (while (< last 7)
+      (setq last (1+ last))
+      ;; Add dummy fields that can never much but keep the group
+      ;; numbers uniform.
+      (setq parts (cons "\\(\\'X\\)?" parts)))
+    (setq parts (cons "\\(Z\\|\\([-+]\\)\\([0-9][0-9]\\):\\([0-5][0-9]\\)\\)?[ \t\n\r]*\\'"
+                      parts))
+    (setq parts (cons "\\`[ \t\n\r]*" (nreverse parts)))
+    (while (> first 0)
+      (setq first (1- first))
+      (setq parts (cons "\\(X\\)?" parts)))
+    (apply 'concat parts)))
+
+(defconst rng-xsd-seconds-per-day (* 24 60 60))
+(defconst rng-xsd-days-in-month [31 28 31 30 31 30 31 31 30 31 30 31])
+
+(defun rng-xsd-days-in-month (year month)
+  (if (and (= month 2) (rng-xsd-leap-year-p year))
+      29
+    (aref rng-xsd-days-in-month (1- month))))
+
+(defconst rng-xsd-months-to-days
+  (let ((v (make-vector 12 nil))
+        (total 0)
+        (i 0))
+    (while (< i 12)
+      (setq total (+ total (aref rng-xsd-days-in-month i)))
+      (aset v i total)
+      (setq i (1+ i)))
+    v))
+           
+(defun rng-xsd-convert-date-time (string regexp)
+  "Converts an XML Schema date/time to a list.  Returns nil if
+invalid.  REGEXP is a regexp for parsing the date time as returned by
+`rng-xsd-make-date-time-regexp'. The list has 4 members (HAS-TIME-ZONE
+DAY SECOND SECOND-FRACTION), where HAS-TIME-ZONE is t or nil depending
+on whether a time zone was specified, DAY is an integer giving a day
+number (with Jan 1 1AD being day 1), SECOND is the second within that
+day, and SECOND-FRACTION is a float giving the fractional part of the
+second."
+  (and (string-match regexp string)
+       (let ((year-sign (match-string 1 string))
+             (year (match-string 2 string))
+             (month (match-string 3 string))
+             (day (match-string 4 string))
+             (hour (match-string 5 string))
+             (minute (match-string 6 string))
+             (second (match-string 7 string))
+             (second-fraction (match-string 8 string))
+             (has-time-zone (match-string 9 string))
+             (time-zone-sign (match-string 10 string))
+             (time-zone-hour (match-string 11 string))
+             (time-zone-minute (match-string 12 string)))
+         (setq year-sign (if year-sign -1 1))
+         (setq year
+               (if year
+                   (* year-sign
+                      (string-to-number year))
+                 2000))
+         (setq month
+               (if month (string-to-number month) 1))
+         (setq day
+               (if day (string-to-number day) 1))
+         (setq hour
+               (if hour (string-to-number hour) 0))
+         (setq minute
+               (if minute (string-to-number minute) 0))
+         (setq second
+               (if second (string-to-number second) 0))
+         (setq second-fraction
+               (if second-fraction
+                   (float (string-to-number second-fraction))
+                 0.0))
+         (setq has-time-zone (and has-time-zone t))
+         (setq time-zone-sign
+               (if (equal time-zone-sign "-") -1 1))
+         (setq time-zone-hour
+               (if time-zone-hour (string-to-number time-zone-hour) 0))
+         (setq time-zone-minute
+               (if time-zone-minute (string-to-number time-zone-minute) 0))
+         (and (>= month 1)
+              (<= month 12)
+              (>= day 1)
+              (<= day (rng-xsd-days-in-month year month))
+              (<= hour 23)
+              (<= minute 59)
+              (<= second 60)            ; leap second
+              (<= time-zone-hour 23)
+              (<= time-zone-minute 59)
+              (cons has-time-zone
+                    (rng-xsd-add-seconds
+                     (list (rng-xsd-date-to-days year month day)
+                           (rng-xsd-time-to-seconds hour minute second)
+                           second-fraction)
+                     (* (rng-xsd-time-to-seconds time-zone-hour
+                                                 time-zone-minute
+                                                 0)
+                        (- time-zone-sign))))))))
+
+(defun rng-xsd-leap-year-p (year)
+  (and (= (% year 4) 0)
+       (or (/= (% year 100) 0)
+           (= (% year 400) 0))))
+
+(defun rng-xsd-time-to-seconds (hour minute second)
+  (+ (* (+ (* hour 60)
+           minute)
+        60)
+     second))
+
+(defconst rng-xsd-max-tz (rng-xsd-time-to-seconds 14 0 0))
+
+(defun rng-xsd-date-time< (dt1 dt2)
+  (cond ((eq (car dt1) (car dt2))
+         (rng-xsd-number-list< (cdr dt1) (cdr dt2)))
+        ((car dt1)
+         (rng-xsd-number-list< (cdr dt1)
+                               (rng-xsd-add-seconds (cdr dt2)
+                                                    (- rng-xsd-max-tz))))
+        (t
+         (rng-xsd-number-list< (rng-xsd-add-seconds (cdr dt1)
+                                                    rng-xsd-max-tz)
+                               (cdr dt2)))))
+
+(defun rng-xsd-add-seconds (date offset)
+  (let ((day (nth 0 date))
+        (second (+ (nth 1 date) offset))
+        (fraction (nth 2 date)))
+    (cond ((< second 0)
+           (list (1- day)
+                 (+ second rng-xsd-seconds-per-day)
+                 fraction))
+          ((>= second rng-xsd-seconds-per-day)
+           (list (1+ day)
+                 (- second rng-xsd-seconds-per-day)
+                 fraction))
+          (t (list day second fraction)))))
+
+(defun rng-xsd-number-list< (numbers1 numbers2)
+  (while (and numbers1 (= (car numbers1) (car numbers2)))
+    (setq numbers1 (cdr numbers1))
+    (setq numbers2 (cdr numbers2)))
+  (and numbers1
+       (< (car numbers1) (car numbers2))))
+        
+(defun rng-xsd-date-to-days (year month day)
+  "Return a unique day number where Jan 1 1 AD is day 1"
+  (if (> year 0)                        ; AD
+      (+ (rng-xsd-days-in-years (- year 1))
+         (rng-xsd-day-number-in-year year month day))
+    (- (+ (- (rng-xsd-days-in-years (- 3 year))
+             (rng-xsd-days-in-years 3))
+          (- (if (rng-xsd-leap-year-p year) 366 365)
+             (rng-xsd-day-number-in-year year month day))))))
+
+(defun rng-xsd-days-in-years (years)
+  "The number of days in YEARS years where the first year is 1AD."
+  (+ (* 365 years)
+     (/ years 4)
+     (- (/ years 100))
+     (/ years 400)))
+
+(defun rng-xsd-day-number-in-year (year month day)
+  (+ (if (= month 1)
+         0
+         (aref rng-xsd-months-to-days (- month 2)))
+     day
+     (if (and (> month 2)
+              (rng-xsd-leap-year-p year))
+         1
+       0)))
+
+(defconst rng-xsd-duration-regexp
+    "\\`[ \t\r\n]*\\(-\\)?P\
+\\([0-9]+Y\\)?\\([0-9]+M\\)?\\([0-9]+D\\)?\
+\\(?:T\\([0-9]+H\\)?\\([0-9]+M\\)?\
+\\(\\([0-9]+\\(?:\\.[0-9]*\\)?\\|\\.[0-9]+\\)S\\)?\\)?\
+[ \t\r\n]*\\'")
+
+
+(defun rng-xsd-convert-duration (string)
+  (and (string-match rng-xsd-duration-regexp string)
+       (let ((last (substring string -1)))
+         (not (or (string= last "P")
+                  (string= last "T"))))
+       ;; years months days hours minutes seconds
+       (let ((v (make-vector 6 0))
+             (sign (if (match-beginning 1) -1 1))
+             (i 0))
+         (while (< i 6)
+           (let ((start (match-beginning (+ i 2))))
+             (when start
+               (aset v i (* sign
+                            (string-to-number 
+                             (substring string
+                                        start
+                                        (1- (match-end (+ i 2)))))))))
+           (setq i (1+ i)))
+         ;; Force seconds to be float so that equal works properly.
+         (aset v 5 (float (aref v 5)))
+         v)))
+         
+(defconst rng-xsd-min-seconds-per-month (* 28 rng-xsd-seconds-per-day))
+
+(defun rng-xsd-duration< (d1 d2)
+  (let* ((months1 (rng-xsd-duration-months d1))
+         (months2 (rng-xsd-duration-months d2))
+         (seconds1 (rng-xsd-duration-seconds d1))
+         (seconds2 (rng-xsd-duration-seconds d2)))
+    (cond ((< months1 months2)
+           (if (< (- seconds1 seconds2) rng-xsd-min-seconds-per-month)
+               t
+             (rng-xsd-months-seconds< months1 seconds1 months2 seconds2)))
+          ((> months1 months2)
+           (if (< (- seconds2 seconds1) rng-xsd-min-seconds-per-month)
+               nil
+             (rng-xsd-months-seconds< months1 seconds1 months2 seconds2)))
+          (t (< seconds1 seconds2)))))
+
+(defconst xsd-duration-reference-dates
+  '((1696 . 9) (1697 . 2) (1903 . 3) (1903 . 7)))
+
+(defun rng-xsd-months-seconds< (months1 seconds1 months2 seconds2)
+  (let ((ret t)
+        (ref-dates xsd-duration-reference-dates))
+    (while (let* ((ref-date (car ref-dates))
+                  (ref-year (car ref-date))
+                  (ref-month (cdr ref-date)))
+             (unless (< (+ (rng-xsd-month-seconds months1
+                                                  ref-year
+                                                  ref-month)
+                           seconds1)
+                        (+ (rng-xsd-month-seconds months2
+                                                  ref-year
+                                                  ref-month)
+                           seconds2))
+                 (setq ret nil))
+             (and ret
+                  (setq ref-dates (cdr ref-dates)))))
+    ret))
+
+
+(defun rng-xsd-month-seconds (months ref-year ref-month)
+  "Return the seconds in a number of months starting on a reference date.
+Returns a floating point number."
+  (* (rng-xsd-month-days (abs months) ref-year ref-month)
+     (float rng-xsd-seconds-per-day)
+     (if (< months 0) -1.0 1.0)))
+
+(defconst rng-xsd-years-per-gregorian-cycle 400)
+(defconst rng-xsd-months-per-gregorian-cycle
+  (* rng-xsd-years-per-gregorian-cycle 12))
+(defconst rng-xsd-leap-years-per-gregorian-cycle (- 100 (- 4 1)))
+(defconst rng-xsd-days-per-gregorian-cycle
+  (+ (* 365 rng-xsd-years-per-gregorian-cycle)
+     rng-xsd-leap-years-per-gregorian-cycle))
+
+(defun rng-xsd-month-days (months ref-year ref-month)
+  "Return the days in a number of months starting on a reference date.
+MONTHS must be an integer >= 0."
+  (let ((days 0))
+    (setq months (mod months rng-xsd-months-per-gregorian-cycle))
+    ;; This may be rather slow, but it is highly unlikely
+    ;; ever to be used in real life.
+    (while (> months 0)
+      (setq days
+            (+ (rng-xsd-days-in-month ref-year ref-month)
+               days))
+      (setq ref-month
+            (if (eq ref-month 12)
+                (progn
+                  (setq ref-year (1+ ref-year))
+                  1)
+              (1+ ref-month)))
+      (setq months (1- months)))
+    (+ (* (/ months rng-xsd-months-per-gregorian-cycle)
+          rng-xsd-days-per-gregorian-cycle)
+       days)))
+    
+(defun rng-xsd-duration-months (d)
+  (+ (* (aref d 0) 12)
+     (aref d 1)))
+
+(defun rng-xsd-duration-seconds (d)
+  (+ (* (+ (* (+ (* (aref d 2)
+                    24.0)
+                 (aref d 3))
+              60.0)
+           (aref d 4))
+        60.0)
+     (aref d 5)))
+        
+(defun rng-xsd-convert-qname (string)
+  (and (string-match "\\`[ \r\n\t]*\\([_[:alpha:]][-._[:alnum:]]*\\(:[_[:alpha:]][-._[:alnum:]]*\\)?\\)[ \r\n\t]*\\'" string)
+       (let ((colon (match-beginning 2))
+             (context (apply (car rng-dt-namespace-context-getter)
+                             (cdr rng-dt-namespace-context-getter))))
+         (if colon
+             (let* ((prefix (substring string
+                                       (match-beginning 1)
+                                       colon))
+                    (binding (assoc prefix (cdr context))))
+               (and binding
+                    (cons (cdr binding)
+                          (substring string
+                                     (1+ colon)
+                                     (match-end 1)))))
+           (cons (car context)
+                 (match-string 1 string))))))
+                     
+(defun rng-xsd-convert-list (string convert &rest args)
+  (let* ((tokens (split-string string "[ \t\n\r]+"))
+         (tem tokens))
+    (while tem
+      (let ((obj (apply convert
+                        (cons (car tem) args))))
+        (cond (obj
+               (setcar tem obj)
+               (setq tem (cdr tem)))
+              (t
+               (setq tokens nil)
+               (setq tem nil)))))
+    ;; Fortuitously this returns nil if the list is empty
+    ;; which is what we want since the list types
+    ;; have to have one or more members.
+    tokens))
+
+(defun rng-xsd-strcmp (s1 s2)
+  (cond ((string= s1 s2) 0)
+        ((string< s1 s2) -1)
+        (t 1)))
+
+(put 'string 'rng-xsd-convert '(identity))
+(put 'string 'rng-xsd-length 'length)
+(put 'string 'rng-xsd-matches-anything t)
+
+(put 'normalizedString 'rng-xsd-convert '(identity))
+(put 'normalizedString 'rng-xsd-length 'length)
+(put 'normalizedString 'rng-xsd-matches-anything t)
+
+(put 'token 'rng-xsd-convert '(identity))
+(put 'token 'rng-xsd-length 'length)
+(put 'token 'rng-xsd-matches-anything t)
+
+(put 'hexBinary 'rng-xsd-convert '(rng-xsd-convert-hex-binary))
+(put 'hexBinary 'rng-xsd-length 'rng-xsd-hex-binary-length)
+
+(put 'base64Binary 'rng-xsd-convert '(rng-xsd-convert-base64-binary))
+(put 'base64Binary 'rng-xsd-length 'rng-xsd-base64-binary-length)
+
+(put 'boolean 'rng-xsd-convert '(rng-xsd-convert-boolean))
+
+(put 'float 'rng-xsd-convert '(rng-xsd-convert-float))
+(put 'float 'rng-xsd-less-than 'rng-xsd-float<)
+
+(put 'double 'rng-xsd-convert '(rng-xsd-convert-float))
+(put 'double 'rng-xsd-less-than 'rng-xsd-float<)
+
+(put 'decimal 'rng-xsd-convert '(rng-xsd-convert-decimal))
+(put 'decimal 'rng-xsd-less-than 'rng-xsd-decimal<)
+
+(put 'integer 'rng-xsd-convert '(rng-xsd-convert-integer))
+(put 'integer 'rng-xsd-less-than 'rng-xsd-decimal<)
+
+(defun rng-xsd-def-integer-type (name min max)
+  (put name 'rng-xsd-less-than 'rng-xsd-decimal<)
+  (put name
+       'rng-xsd-convert 
+       (cdr (rng-xsd-compile 'integer
+                             (append (and min `((minInclusive . ,min)))
+                                     (and max `((maxInclusive . ,max))))))))
+
+(defun rng-xsd-def-token-type (name regexp)
+  (put name 'rng-xsd-convert (list 'rng-xsd-convert-token
+                                   (concat "\\`[\r\n\t ]*\\("
+                                           regexp
+                                           "\\)[\r\n\t ]*\\'")))
+  (put name 'rng-xsd-length 'length))
+
+(rng-xsd-def-token-type 'NMTOKEN "[-.:_[:alnum:]]+")
+(rng-xsd-def-token-type 'Name "[:_[:alpha:]][-.:_[:alnum:]]*")
+(rng-xsd-def-token-type 'NCName "[_[:alpha:]][-._[:alnum:]]*")
+(rng-xsd-def-token-type 'language
+                        "[a-zA-Z]\\{1,8\\}\\(?:-[a-zA-Z0-9]\\{1,8\\}\\)*")
+
+(put 'ENTITY 'rng-xsd-convert (get 'NCName 'rng-xsd-convert))
+(put 'ENTITY 'rng-xsd-length 'length)
+(put 'ID 'rng-xsd-convert (get 'NCName 'rng-xsd-convert))
+(put 'ID 'rng-xsd-length 'length)
+(put 'IDREF 'rng-xsd-convert (get 'NCName 'rng-xsd-convert))
+(put 'IDREF 'rng-xsd-length 'length)
+
+(defun rng-xsd-def-list-type (name member-name)
+  (put name 'rng-xsd-convert (cons 'rng-xsd-convert-list
+                                   (get member-name 'rng-xsd-convert)))
+  (put name 'rng-xsd-length 'length))
+
+(rng-xsd-def-list-type 'NMTOKENS 'NMTOKEN)
+(rng-xsd-def-list-type 'IDREFS 'IDREF)
+(rng-xsd-def-list-type 'ENTITIES 'ENTITY)
+
+(put 'anyURI 'rng-xsd-convert '(rng-xsd-convert-any-uri))
+(put 'anyURI 'rng-xsd-length 'length)
+
+(put 'QName 'rng-xsd-convert '(rng-xsd-convert-qname))
+(put 'NOTATION 'rng-xsd-convert '(rng-xsd-convert-qname))
+
+(defconst rng-xsd-long-max "9223372036854775807")
+(defconst rng-xsd-long-min "-9223372036854775808")
+(defconst rng-xsd-int-max "2147483647")
+(defconst rng-xsd-int-min "-2147483648")
+(defconst rng-xsd-short-max "32767")
+(defconst rng-xsd-short-min "-32768")
+(defconst rng-xsd-byte-max "127")
+(defconst rng-xsd-byte-min "-128")
+(defconst rng-xsd-unsigned-long-max "18446744073709551615")
+(defconst rng-xsd-unsigned-int-max "4294967295")
+(defconst rng-xsd-unsigned-short-max "65535")
+(defconst rng-xsd-unsigned-byte-max "255")
+
+(rng-xsd-def-integer-type 'nonNegativeInteger "0" nil)
+(rng-xsd-def-integer-type 'positiveInteger "1" nil)
+(rng-xsd-def-integer-type 'nonPositiveInteger nil "0")
+(rng-xsd-def-integer-type 'negativeInteger nil "-1")
+(rng-xsd-def-integer-type 'long rng-xsd-long-min rng-xsd-long-max)
+(rng-xsd-def-integer-type 'int rng-xsd-int-min rng-xsd-int-max)
+(rng-xsd-def-integer-type 'short rng-xsd-short-min rng-xsd-short-max)
+(rng-xsd-def-integer-type 'byte rng-xsd-byte-min rng-xsd-byte-max)
+(rng-xsd-def-integer-type 'unsignedLong "0" rng-xsd-unsigned-long-max)
+(rng-xsd-def-integer-type 'unsignedInt "0" rng-xsd-unsigned-int-max)
+(rng-xsd-def-integer-type 'unsignedShort "0" rng-xsd-unsigned-short-max)
+(rng-xsd-def-integer-type 'unsignedByte "0" rng-xsd-unsigned-byte-max)
+
+(defun rng-xsd-def-date-time-type (name template)
+  (put name 'rng-xsd-convert (list 'rng-xsd-convert-date-time
+                                   (rng-xsd-make-date-time-regexp template)))
+  (put name 'rng-xsd-less-than 'rng-xsd-date-time<))
+
+(rng-xsd-def-date-time-type 'dateTime "Y-M-DTt")
+(rng-xsd-def-date-time-type 'time "t")
+(rng-xsd-def-date-time-type 'date "Y-M-D")
+(rng-xsd-def-date-time-type 'gYearMonth "Y-M")
+(rng-xsd-def-date-time-type 'gYear "Y")
+(rng-xsd-def-date-time-type 'gMonthDay "--M-D")
+(rng-xsd-def-date-time-type 'gDay "---D")
+(rng-xsd-def-date-time-type 'gMonth "--M")
+
+(put 'duration 'rng-xsd-convert '(rng-xsd-convert-duration))
+(put 'duration 'rng-xsd-less-than 'rng-xsd-duration<)
+
+(provide 'rng-xsd)
+
+;;; rng-xsd.el ends here
diff --git a/lisp/nxml/subdirs.el b/lisp/nxml/subdirs.el
new file mode 100644
index 00000000000..4103b568b45
--- /dev/null
+++ b/lisp/nxml/subdirs.el
@@ -0,0 +1,8 @@
+;; -*- no-byte-compile: t -*-
+;; In load-path, after this directory should come
+;; certain of its subdirectories.  Here we specify them.
+(normal-top-level-add-to-load-path '("char-name" ))
+;; Local Variables:
+;; version-control: never
+;; no-byte-compile: t
+;; End:
diff --git a/lisp/nxml/test.invalid.xml b/lisp/nxml/test.invalid.xml
new file mode 100644
index 00000000000..bdf6a2cb7ee
--- /dev/null
+++ b/lisp/nxml/test.invalid.xml
@@ -0,0 +1,8 @@
+<html xmlns="http://www.w3.org/1999/xhtml">
+  <head>
+    <title>An invalid document</title>
+  </head>
+  <body>
+    <p>This XHTML document is <span class="#foo">invalid</span>.</p>
+  </body>
+</html>
diff --git a/lisp/nxml/test.valid.xml b/lisp/nxml/test.valid.xml
new file mode 100644
index 00000000000..56a12800faa
--- /dev/null
+++ b/lisp/nxml/test.valid.xml
@@ -0,0 +1,8 @@
+<html xmlns="http://www.w3.org/1999/xhtml">
+  <head>
+    <title>A valid document</title>
+  </head>
+  <body>
+    <p>This is a valid, albeit boring, XHTML document.</p>
+  </body>
+</html>
diff --git a/lisp/nxml/xmltok.el b/lisp/nxml/xmltok.el
new file mode 100644
index 00000000000..ed381cd4cc9
--- /dev/null
+++ b/lisp/nxml/xmltok.el
@@ -0,0 +1,1925 @@
+;;; xmltok.el --- XML tokenization
+
+;; Copyright (C) 2003 Free Software Foundation, Inc.
+
+;; Author: James Clark
+;; Keywords: XML
+
+;; This program is free software; you can redistribute it and/or
+;; modify it under the terms of the GNU General Public License as
+;; published by the Free Software Foundation; either version 2 of
+;; the License, or (at your option) any later version.
+
+;; This program is distributed in the hope that it will be
+;; useful, but WITHOUT ANY WARRANTY; without even the implied
+;; warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+;; PURPOSE.  See the GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public
+;; License along with this program; if not, write to the Free
+;; Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+;; MA 02111-1307 USA
+
+;;; Commentary:
+
+;; This implements an XML 1.0 parser. It also implements the XML
+;; Namespaces Recommendation.  It is designed to be conforming, but it
+;; works a bit differently from a normal XML parser. An XML document
+;; consists of the prolog and an instance.  The prolog is parsed as a
+;; single unit using `xmltok-forward-prolog'.  The instance is
+;; considered as a sequence of tokens, where a token is something like
+;; a start-tag, a comment, a chunk of data or a CDATA section. The
+;; tokenization of the instance is stateless: the tokenization of one
+;; part of the instance does not depend on tokenization of the
+;; preceding part of the instance.  This allows the instance to be
+;; parsed incrementally.  The main entry point is `xmltok-forward':
+;; this can be called at any point in the instance provided it is
+;; between tokens.  The other entry point is `xmltok-forward-special'
+;; which skips over tokens other comments, processing instructions or
+;; CDATA sections (i.e. the constructs in an instance that can contain
+;; less than signs that don't start a token).
+;;
+;; This is a non-validating XML 1.0 processor.  It does not resolve
+;; parameter entities (including the external DTD subset) and it does
+;; not resolve external general entities.
+;;
+;; It is non-conformant by design in the following respects.
+;;
+;; 1. It expects the client to detect aspects of well-formedness that
+;; are not internal to a single token, specifically checking that
+;; end-tags match start-tags and that the instance contains exactly
+;; one element.
+;;
+;; 2. It expects the client to detect duplicate attributes.  Detection
+;; of duplicate attributes after expansion of namespace prefixes
+;; requires the namespace processing state.  Detection of duplicate
+;; attributes before expansion of namespace prefixes does not, but is
+;; redundant given that the client will do detection of duplicate
+;; attributes after expansion of namespace prefixes.
+;;
+;; 3. It allows the client to recover from well-formedness errors.
+;; This is essential for use in applications where the document is
+;; being parsed during the editing process.
+;;
+;; 4. It does not support documents that do not conform to the lexical
+;; requirements of the XML Namespaces Recommendation (e.g. a document
+;; with a colon in an entity name).
+;;
+;; There are also a number of things that have not yet been
+;; implemented that make it non-conformant.
+;;
+;; 1. It does not implement default attributes.  ATTLIST declarations
+;; are parsed, but no checking is done on the content of attribute
+;; value literals specifying default attribute values, and default
+;; attribute values are not reported to the client.
+;;
+;; 2. It does not implement internal entities containing elements. If
+;; an internal entity is referenced and parsing its replacement text
+;; yields one or more tags, then it will skip the reference and
+;; report this to the client.
+;;
+;; 3. It does not check the syntax of public identifiers in the DTD.
+;;
+;; 4. It allows some non-ASCII characters in certain situations where
+;; it should not.  For example, it only enforces XML 1.0's
+;; restrictions on name characters strictly for ASCII characters.  The
+;; problem here is XML's character model is based squarely on Unicode,
+;; whereas Emacs's is not (as of version 21).  It is not clear what
+;; the right thing to do is.
+
+;;; Code:
+
+(defvar xmltok-type nil)
+(defvar xmltok-start nil)
+(defvar xmltok-name-colon nil)
+(defvar xmltok-name-end nil)
+(defvar xmltok-replacement nil
+  "String containing replacement for a character or entity reference.")
+
+(defvar xmltok-attributes nil
+  "List containing attributes of last scanned element.
+Each member of the list is a vector representing an attribute, which
+can be accessed using the functions `xmltok-attribute-name-start',
+`xmltok-attribute-name-colon', `xmltok-attribute-name-end',
+`xmltok-attribute-value-start', `xmltok-attribute-value-end',
+`xmltok-attribute-raw-normalized-value', `xmltok-attribute-refs'.")
+
+(defvar xmltok-namespace-attributes nil
+  "List containing namespace declarations of last scanned element.
+List has same format as `xmltok-attributes'.")
+
+(defvar xmltok-dtd nil
+  "Information about the DTD used by `xmltok-forward'.
+`xmltok-forward-prolog' sets this up.
+
+It consists of an alist of general entity names vs definitions.  The
+first member of the alist is t if references to entities not in the
+alist are well-formed \(e.g. because there's an external subset that
+wasn't parsed).
+
+Each general entity name is a string. The definition is either nil, a
+symbol, a string, a cons cell.  If the definition is nil, then it
+means that it's an internal entity but the result of parsing it is
+unknown.  If it is a symbol, then the symbol is either `unparsed',
+meaning the entity is an unparsed entity, `external', meaning the
+entity is or references an external entity, `element', meaning the
+entity includes one or more elements, or `not-well-formed', meaning
+the replacement text is not well-formed.  If the definition is a
+string, then the replacement text of the entity is that string; this
+happens only during the parsing of the prolog. If the definition is a
+cons cell \(ER . AR), then ER specifies the string that results from
+referencing the entity in element content and AR is either nil,
+meaning the replacement text included a <, or a string which is the
+normalized attribute value.")
+
+(defvar xmltok-dependent-regions nil
+  "List of descriptors of regions that a parsed token depends on.
+
+A token depends on a region if the region occurs after the token and a
+change in the region may require the token to be reparsed.  This only
+happens with markup that is not well-formed.  For example, if a <?
+occurs without a matching ?>, then the <? is returned as a
+not-well-formed token.  However, this token is dependent on region
+from the end of the token to the end of the buffer: if this ever
+contains ?> then the buffer must be reparsed from the <?.
+
+A region descriptor is a list (FUN START END ARG ...), where FUN is a
+function to be called when the region changes, START and END are
+integers giving the start and end of the region, and ARG... are
+additional arguments to be passed to FUN.  FUN will be called with 5
+arguments followed by the additional arguments if any: the position of
+the start of the changed area in the region, the position of the end
+of the changed area in the region, the length of the changed area
+before the change, the position of the start of the region, the
+position of the end of the region. FUN must return non-nil if the
+region needs reparsing.  FUN will be called in a save-excursion with
+match-data saved.
+
+`xmltok-forward', `xmltok-forward-special' and `xmltok-forward-prolog'
+may add entries to the beginning of this list, but will not clear it.
+`xmltok-forward' and `xmltok-forward-special' will only add entries
+when returning tokens of type not-well-formed.")
+
+(defvar xmltok-errors nil
+  "List of errors detected by `xmltok-forward' and `xmltok-forward-prolog'.
+When `xmltok-forward' and `xmltok-forward-prolog' detect a
+well-formedness error, they will add an entry to the beginning of this
+list.  Each entry is a vector [MESSAGE START END], where MESSAGE is a
+string giving the error message and START and END are integers
+indicating the position of the error.")
+
+(defmacro xmltok-save (&rest body)
+  `(let (xmltok-type
+         xmltok-start
+         xmltok-name-colon
+         xmltok-name-end
+         xmltok-replacement
+         xmltok-attributes
+         xmltok-namespace-attributes
+         xmltok-dependent-regions
+         xmltok-errors)
+     ,@body))
+
+(put 'xmltok-save 'lisp-indent-function 0)
+(def-edebug-spec xmltok-save t)
+
+(defsubst xmltok-attribute-name-start (att)
+  (aref att 0))
+
+(defsubst xmltok-attribute-name-colon (att)
+  (aref att 1))
+
+(defsubst xmltok-attribute-name-end (att)
+  (aref att 2))
+
+(defsubst xmltok-attribute-value-start (att)
+  (aref att 3))
+
+(defsubst xmltok-attribute-value-end (att)
+  (aref att 4))
+
+(defsubst xmltok-attribute-raw-normalized-value (att)
+  "Return an object representing the normalized value of ATT.
+This can t indicating that the normalized value is the same as the
+buffer substring from the start to the end of the value or nil
+indicating that the value is not well-formed or a string."
+  (aref att 5))
+
+(defsubst xmltok-attribute-refs (att)
+  "Return a list of the entity and character references in ATT.
+Each member is a vector [TYPE START END] where TYPE is either char-ref
+or entity-ref and START and END are integers giving the start and end
+of the reference. Nested entity references are not included in the list."
+  (aref att 6))
+
+(defun xmltok-attribute-prefix (att)
+  (let ((colon (xmltok-attribute-name-colon att)))
+    (and colon
+         (buffer-substring-no-properties (xmltok-attribute-name-start att)
+                                         colon))))
+
+(defun xmltok-attribute-local-name (att)
+  (let ((colon (xmltok-attribute-name-colon att)))
+    (buffer-substring-no-properties (if colon
+                                        (1+ colon)
+                                      (xmltok-attribute-name-start att))
+                                    (xmltok-attribute-name-end att))))
+
+(defun xmltok-attribute-value (att)
+  (let ((rnv (xmltok-attribute-raw-normalized-value att)))
+    (and rnv
+         (if (stringp rnv)
+             rnv
+           (buffer-substring-no-properties (xmltok-attribute-value-start att)
+                                           (xmltok-attribute-value-end att))))))
+
+(defun xmltok-start-tag-prefix ()
+  (and xmltok-name-colon
+       (buffer-substring-no-properties (1+ xmltok-start)
+                                       xmltok-name-colon)))
+
+(defun xmltok-start-tag-local-name ()
+  (buffer-substring-no-properties (1+ (or xmltok-name-colon
+                                          xmltok-start))
+                                  xmltok-name-end))
+
+(defun xmltok-end-tag-prefix ()
+  (and xmltok-name-colon
+       (buffer-substring-no-properties (+ 2 xmltok-start)
+                                       xmltok-name-colon)))
+
+(defun xmltok-end-tag-local-name ()
+  (buffer-substring-no-properties (if xmltok-name-colon
+                                      (1+ xmltok-name-colon)
+                                    (+ 2 xmltok-start))
+                                  xmltok-name-end))
+
+(defun xmltok-start-tag-qname ()
+  (buffer-substring-no-properties (+ xmltok-start 1) xmltok-name-end))
+
+(defun xmltok-end-tag-qname ()
+  (buffer-substring-no-properties (+ xmltok-start 2) xmltok-name-end))
+
+(defsubst xmltok-make-attribute (name-begin
+                                 name-colon
+                                 name-end
+                                 &optional
+                                 value-begin
+                                 value-end
+                                 raw-normalized-value)
+  "Make an attribute.  RAW-NORMALIZED-VALUE is nil if the value is
+not well-formed, t if the normalized value is the string between
+VALUE-BEGIN and VALUE-END, otherwise a STRING giving the value."
+  (vector name-begin
+          name-colon
+          name-end
+          value-begin
+          value-end
+          raw-normalized-value
+          nil))
+
+(defsubst xmltok-error-message (err)
+  (aref err 0))
+
+(defsubst xmltok-error-start (err)
+  (aref err 1))
+
+(defsubst xmltok-error-end (err)
+  (aref err 2))
+
+(defsubst xmltok-make-error (message start end)
+  (vector message start end))
+
+(defun xmltok-add-error (message &optional start end)
+  (setq xmltok-errors
+        (cons (xmltok-make-error message
+                                 (or start xmltok-start)
+                                 (or end (point)))
+              xmltok-errors)))
+
+(defun xmltok-add-dependent (fun &optional start end &rest args)
+  (setq xmltok-dependent-regions
+        (cons (cons fun
+                    (cons (or start xmltok-start)
+                          (cons (or end (point-max))
+                                args)))
+              xmltok-dependent-regions)))
+
+(defun xmltok-forward ()
+  (setq xmltok-start (point))
+  (let* ((case-fold-search nil)
+         (space-count (skip-chars-forward " \t\r\n"))
+         (ch (char-after)))
+    (cond ((eq ch ?\<)
+           (cond ((> space-count 0)
+                  (setq xmltok-type 'space))
+                 (t
+                  (goto-char (1+ (point)))
+                  (xmltok-scan-after-lt))))
+          ((eq ch ?\&)
+           (cond ((> space-count 0)
+                  (setq xmltok-type 'space))
+                 (t
+                  (goto-char (1+ (point)))
+                  (xmltok-scan-after-amp
+                   (lambda (start end)
+                     (xmltok-handle-entity start end))))))
+          ((re-search-forward "[<&]\\|\\(]]>\\)" nil t)
+           (cond ((not (match-beginning 1))
+                  (goto-char (match-beginning 0))
+                  ;; must have got a non-space char
+                  (setq xmltok-type 'data))
+                 ((= (match-beginning 1) xmltok-start)
+                  (xmltok-add-error "Found `]]>' not closing a CDATA section")
+                  (setq xmltok-type 'not-well-formed))
+                 (t
+                  (goto-char (match-beginning 0))
+                  (setq xmltok-type
+                        (if (= (point) (+ xmltok-start space-count))
+                            'space
+                          'data)))))
+          ((eq ch nil)
+           (setq xmltok-type
+                 (if (> space-count 0)
+                     'space
+                   nil)))
+          (t
+           (goto-char (point-max))
+           (setq xmltok-type 'data)))))
+
+(defun xmltok-forward-special (bound)
+  "Scan forward past the first special token starting at or after point.
+Return nil if there is no special token that starts before BOUND.
+CDATA sections, processing instructions and comments (and indeed
+anything starting with < following by ? or !) count
+as special.  Return the type of the token."
+  (when (re-search-forward "<[?!]" (1+ bound) t)
+    (setq xmltok-start (match-beginning 0))
+    (goto-char (1+ xmltok-start))
+    (let ((case-fold-search nil))
+      (xmltok-scan-after-lt))))
+
+(eval-when-compile
+
+  ;; A symbolic regexp is represented by a list whose CAR is the string
+  ;; containing the regexp and whose cdr is a list of symbolic names
+  ;; for the groups in the string.
+
+  ;; Construct a symbolic regexp from a regexp.
+  (defun xmltok-r (str)
+    (cons str nil))
+
+  ;; Concatenate zero of more regexps and symbolic regexps.
+  (defun xmltok+ (&rest args)
+    (let (strs names)
+      (while args
+        (let ((arg (car args)))
+          (if (stringp arg)
+              (setq strs (cons arg strs))
+            (setq strs (cons (car arg) strs))
+            (setq names (cons (cdr arg) names)))
+          (setq args (cdr args))))
+      (cons (apply 'concat (nreverse strs))
+            (apply 'append (nreverse names))))))
+
+(eval-when-compile
+  ;; Make a symbolic group named NAME from the regexp R.
+  ;; R may be a symbolic regexp or an ordinary regexp.
+  (defmacro xmltok-g (name &rest r)
+    (let ((sym (make-symbol "r")))
+      `(let ((,sym (xmltok+ ,@r)))
+         (if (stringp ,sym)
+             (cons (concat "\\(" ,sym "\\)") (cons ',name nil))
+           (cons (concat "\\(" (car ,sym) "\\)") (cons ',name (cdr ,sym)))))))
+
+  (defun xmltok-p (&rest r) (xmltok+ "\\(?:" 
+                                     (apply 'xmltok+ r)
+                                     "\\)"))
+
+  ;; Get the group index of ELEM in a LIST of symbols.
+  (defun xmltok-get-index (elem list)
+    (or elem
+        (error "Missing group name"))
+    (let ((found nil)
+          (i 1))
+      (while list
+        (cond ((eq elem (car list))
+               (setq found i)
+               (setq list nil))
+              (t
+               (setq i (1+ i))
+               (setq list (cdr list)))))
+      (or found
+          (error "Bad group name %s" elem))))
+
+  ;; Define a macro SYM using a symbolic regexp R.
+  ;; SYM can be called in three ways:
+  ;; (SYM regexp)
+  ;;   expands to the regexp in R
+  ;; (SYM start G)
+  ;;   expands to
+  ;;   (match-beginning N)
+  ;;   where N is the group index of G in R.
+  ;; (SYM end G)
+  ;;   expands to
+  ;;   (match-end N)
+  ;;   where N is the group index of G in R.
+  (defmacro xmltok-defregexp (sym r)
+    `(defalias ',sym
+       (let ((r ,r))
+         `(macro lambda (action &optional group-name)
+                 (cond ((eq action 'regexp)
+                        ,(car r))
+                       ((or (eq action 'start) (eq action 'beginning))
+                        (list 'match-beginning (xmltok-get-index group-name
+                                                                 ',(cdr r))))
+                       ((eq action 'end)
+                        (list 'match-end (xmltok-get-index group-name
+                                                           ',(cdr r))))
+                       ((eq action 'string)
+                        (list 'match-string
+                              (xmltok-get-index group-name ',(cdr r))))
+                       ((eq action 'string-no-properties)
+                        (list 'match-string-no-properties
+                              (xmltok-get-index group-name ',(cdr r))))
+                       (t (error "Invalid action: %s" action))))))))
+  
+
+(eval-when-compile
+  (let* ((or "\\|")
+         (open "\\(?:")
+         (gopen "\\(")
+         (close "\\)")
+         (name-start-char "[_[:alpha:]]")
+         (name-continue-not-start-char "[-.[:digit:]]")
+         (name-continue-char "[-._[:alnum:]]")
+         (* "*")
+         (+ "+")
+         (opt "?")
+         (question "\\?")
+         (s "[ \r\t\n]")
+         (s+ (concat s +))
+         (s* (concat s *))
+         (ncname (concat name-start-char name-continue-char *))
+         (entity-ref
+          (xmltok+ (xmltok-g entity-name ncname)
+                   (xmltok-g entity-ref-close ";") opt))
+         (decimal-ref
+          (xmltok+ (xmltok-g decimal "[0-9]" +)
+                   (xmltok-g decimal-ref-close ";") opt))
+         (hex-ref
+          (xmltok+ "x" open
+                   (xmltok-g hex "[0-9a-fA-F]" +)
+                   (xmltok-g hex-ref-close ";") opt
+                   close opt))
+         (char-ref
+          (xmltok+ (xmltok-g number-sign "#")
+                   open decimal-ref or hex-ref close opt))
+         (start-tag-close
+          (xmltok+ open (xmltok-g start-tag-close s* ">")
+                   or open (xmltok-g empty-tag-slash s* "/")
+                   (xmltok-g empty-tag-close ">") opt close
+                   or (xmltok-g start-tag-s s+)
+                   close))
+         (start-tag
+          (xmltok+ (xmltok-g start-tag-name
+                             ncname (xmltok-g start-tag-colon ":" ncname) opt)
+                   start-tag-close opt))
+         (end-tag
+          (xmltok+ (xmltok-g end-tag-slash "/")
+                   open (xmltok-g end-tag-name
+                                  ncname
+                                  (xmltok-g end-tag-colon ":" ncname) opt)
+                   (xmltok-g end-tag-close s* ">") opt
+                   close opt))
+         (comment
+          (xmltok+ (xmltok-g markup-declaration "!")
+                   (xmltok-g comment-first-dash "-"
+                             (xmltok-g comment-open "-") opt) opt))
+         (cdata-section
+          (xmltok+ "!"
+                  (xmltok-g marked-section-open "\\[")
+                  open "C"
+                  open "D"
+                  open "A"
+                  open "T"
+                  open "A"
+                  (xmltok-g cdata-section-open "\\[" ) opt
+                  close opt             ; A
+                  close opt             ; T
+                  close opt             ; A
+                  close opt             ; D
+                  close opt))           ; C
+         (processing-instruction
+          (xmltok-g processing-instruction-question question)))
+
+    (xmltok-defregexp xmltok-ncname  (xmltok+ open ncname close))
+
+    (xmltok-defregexp xmltok-after-amp
+                      (xmltok+ entity-ref or char-ref))
+    (xmltok-defregexp xmltok-after-lt
+                      (xmltok+ start-tag
+                               or end-tag
+                               ;; cdata-section must come before comment
+                               ;; because we treat <! as a comment
+                               ;; and Emacs doesn't do fully greedy matching
+                               ;; by default
+                               or cdata-section
+                               or comment
+                               or processing-instruction))
+    (xmltok-defregexp
+     xmltok-attribute
+     (let* ((lit1
+             (xmltok+ "'"
+                      "[^<'&\r\n\t]*"
+                      (xmltok-g complex1 "[&\r\n\t][^<']*") opt
+                      "'"))
+            (lit2 (cons (replace-regexp-in-string "'" "\"" (car lit1))
+                        '(complex2)))
+            (literal (xmltok-g literal lit1 or lit2))
+            (name (xmltok+ open (xmltok-g xmlns "xmlns") or ncname close
+                           (xmltok-g colon ":" ncname) opt)))
+        (xmltok+ (xmltok-g name name)
+                 s* "="
+                 ;; If the literal isn't followed by what it should be,
+                 ;; then the closing delimiter is probably really the
+                 ;; opening delimiter of another literal, so don't
+                 ;; absorb the literal in this case.
+                 open s* literal start-tag-close close opt)))
+    (xmltok-defregexp
+     xmltok-xml-declaration
+     (let* ((literal-content "[-._:a-zA-Z0-9]+")
+            (literal
+             (concat open "\"" literal-content "\""
+                     or "'" literal-content "'" close))
+            (version-att
+             (xmltok+ open
+                      s+ (xmltok-g version-name "version")
+                      s* "="
+                      s* (xmltok-g version-value literal)
+                      close opt))
+            (encoding-att
+             (xmltok+ open
+                      s+ (xmltok-g encoding-name "encoding")
+                      s* "="
+                      s* (xmltok-g encoding-value literal)
+                      close opt))
+           (yes-no
+            (concat open "yes" or "no" close))
+           (standalone-att
+            (xmltok+ open
+                     s+ (xmltok-g standalone-name "standalone")
+                     s* "="
+                     s* (xmltok-g standalone-value
+                                  "\"" yes-no "\"" or "'" yes-no "'")
+                     close opt)))
+       (xmltok+ "<" question "xml"
+                version-att
+                encoding-att
+                standalone-att
+                s* question ">")))
+    (xmltok-defregexp
+     xmltok-prolog
+     (let* ((single-char (xmltok-g single-char "[[|,(\"'>]"))
+            (internal-subset-close (xmltok-g internal-subset-close
+                                             "][ \t\r\n]*>"))
+            (starts-with-close-paren
+             (xmltok-g close-paren
+                       ")"
+                       (xmltok-p
+                        (xmltok-g close-paren-occur "[+?]")
+                        or
+                        (xmltok-g close-paren-star "\\*"))
+                       opt))
+            (starts-with-percent
+             (xmltok-g percent
+                       "%" (xmltok-g param-entity-ref
+                                     ncname
+                                     (xmltok-g param-entity-ref-close
+                                               ";") opt) opt))
+            (starts-with-nmtoken-not-name
+             (xmltok-g nmtoken
+                       (xmltok-p name-continue-not-start-char or ":")
+                       (xmltok-p name-continue-char or ":") *))
+            (nmtoken-after-colon
+             (xmltok+
+              (xmltok-p name-continue-not-start-char or ":")
+              (xmltok-p name-continue-char or ":") *
+              or
+              name-start-char
+              name-continue-char *
+              ":"
+              (xmltok-p name-continue-char or ":") *))
+            (after-ncname
+             (xmltok+ (xmltok-g ncname-nmtoken
+                                ":" (xmltok-p nmtoken-after-colon))
+                      or (xmltok-p (xmltok-g colon ":" ncname)
+                                   (xmltok-g colon-name-occur "[?+*]") opt)
+                      or (xmltok-g ncname-occur "[?+*]")
+                      or (xmltok-g ncname-colon ":")))
+            (starts-with-name
+             (xmltok-g name ncname (xmltok-p after-ncname) opt))
+            (starts-with-hash
+             (xmltok-g pound
+                       "#" (xmltok-g hash-name ncname)))
+            (markup-declaration
+             (xmltok-g markup-declaration
+                       "!" (xmltok-p (xmltok-g comment-first-dash "-"
+                                               (xmltok-g comment-open "-") opt)
+                                     or (xmltok-g named-markup-declaration
+                                                 ncname)) opt))
+            (after-lt
+             (xmltok+ markup-declaration
+                      or (xmltok-g processing-instruction-question
+                                   question)
+                      or (xmltok-g instance-start
+                                   ncname)))
+            (starts-with-lt (xmltok-g less-than "<" (xmltok-p after-lt) opt)))
+       (xmltok+ starts-with-lt
+                or single-char
+                or starts-with-close-paren
+                or starts-with-percent
+                or starts-with-name
+                or starts-with-nmtoken-not-name
+                or starts-with-hash
+                or internal-subset-close)))))
+
+(defconst xmltok-ncname-regexp (xmltok-ncname regexp))
+
+(defun xmltok-scan-after-lt ()
+  (cond ((not (looking-at (xmltok-after-lt regexp)))
+         (xmltok-add-error "`<' that is not markup must be entered as `&lt;'")
+         (setq xmltok-type 'not-well-formed))
+        (t
+         (goto-char (match-end 0))
+         (cond ((xmltok-after-lt start start-tag-close)
+                (setq xmltok-name-end
+                      (xmltok-after-lt end start-tag-name))
+                (setq xmltok-name-colon
+                      (xmltok-after-lt start start-tag-colon))
+                (setq xmltok-attributes nil)
+                (setq xmltok-namespace-attributes nil)
+                (setq xmltok-type 'start-tag))
+               ((xmltok-after-lt start end-tag-close)
+                (setq xmltok-name-end
+                      (xmltok-after-lt end end-tag-name))
+                (setq xmltok-name-colon
+                      (xmltok-after-lt start end-tag-colon))
+                (setq xmltok-type 'end-tag))
+               ((xmltok-after-lt start start-tag-s)
+                (setq xmltok-name-end
+                      (xmltok-after-lt end start-tag-name))
+                (setq xmltok-name-colon
+                      (xmltok-after-lt start start-tag-colon))
+                (setq xmltok-namespace-attributes nil)
+                (setq xmltok-attributes nil)
+                (xmltok-scan-attributes)
+                xmltok-type)
+               ((xmltok-after-lt start empty-tag-close)
+                (setq xmltok-name-end
+                      (xmltok-after-lt end start-tag-name))
+                (setq xmltok-name-colon
+                      (xmltok-after-lt start start-tag-colon))
+                (setq xmltok-attributes nil)
+                (setq xmltok-namespace-attributes nil)
+                (setq xmltok-type 'empty-element))
+               ((xmltok-after-lt start cdata-section-open)
+                (setq xmltok-type
+                      (if (search-forward "]]>" nil t)
+                          'cdata-section
+                        (xmltok-add-error "No closing ]]>")
+                        (xmltok-add-dependent 'xmltok-unclosed-reparse-p
+                                              nil
+                                              nil
+                                              "]]>")
+                        'not-well-formed)))
+               ((xmltok-after-lt start processing-instruction-question)
+                (xmltok-scan-after-processing-instruction-open))
+               ((xmltok-after-lt start comment-open)
+                (xmltok-scan-after-comment-open))
+               ((xmltok-after-lt start empty-tag-slash)
+                (setq xmltok-name-end
+                      (xmltok-after-lt end start-tag-name))
+                (setq xmltok-name-colon
+                      (xmltok-after-lt start start-tag-colon))
+                (setq xmltok-attributes nil)
+                (setq xmltok-namespace-attributes nil)
+                (xmltok-add-error "Expected `/>'" (1- (point)))
+                (setq xmltok-type 'partial-empty-element))
+               ((xmltok-after-lt start start-tag-name)
+                (xmltok-add-error "Missing `>'"
+                                  nil
+                                  (1+ xmltok-start))
+                (setq xmltok-name-end
+                      (xmltok-after-lt end start-tag-name))
+                (setq xmltok-name-colon
+                      (xmltok-after-lt start start-tag-colon))
+                (setq xmltok-namespace-attributes nil)
+                (setq xmltok-attributes nil)
+                (setq xmltok-type 'partial-start-tag))
+               ((xmltok-after-lt start end-tag-name)
+                (setq xmltok-name-end (xmltok-after-lt end end-tag-name))
+                (setq xmltok-name-colon
+                      (xmltok-after-lt start end-tag-colon))
+                (cond ((and (not xmltok-name-colon)
+                            (eq (char-after) ?:))
+                       (goto-char (1+ (point)))
+                       (xmltok-add-error "Expected name following `:'"
+                                         (1- (point))))
+                      (t
+                       (xmltok-add-error "Missing `>'"
+                                         nil
+                                         (1+ xmltok-start))))
+                (setq xmltok-type 'partial-end-tag))
+               ((xmltok-after-lt start end-tag-slash)
+                (xmltok-add-error "Expected name following `</'")
+                (setq xmltok-name-end nil)
+                (setq xmltok-name-colon nil)
+                (setq xmltok-type 'partial-end-tag))
+               ((xmltok-after-lt start marked-section-open)
+                (xmltok-add-error "Expected `CDATA[' after `<!['"
+                                  xmltok-start
+                                  (+ 3 xmltok-start))
+                (setq xmltok-type 'not-well-formed))
+               ((xmltok-after-lt start comment-first-dash)
+                (xmltok-add-error "Expected `-' after `<!-'"
+                                  xmltok-start
+                                  (+ 3 xmltok-start))
+                (setq xmltok-type 'not-well-formed))
+               ((xmltok-after-lt start markup-declaration)
+                (xmltok-add-error "Expected `[CDATA[' or `--' after `<!'"
+                                  xmltok-start
+                                  (+ 2 xmltok-start))
+                (setq xmltok-type 'not-well-formed))
+               (t
+                (xmltok-add-error "Not well-formed")
+                (setq xmltok-type 'not-well-formed))))))
+
+;; XXX This should be unified with
+;; xmltok-scan-prolog-after-processing-instruction-open
+;; XXX maybe should include rest of line (up to any <,>) in unclosed PI
+(defun xmltok-scan-after-processing-instruction-open ()
+  (cond ((not (search-forward "?>" nil t))
+         (xmltok-add-error "No closing ?>"
+                           xmltok-start
+                           (+ xmltok-start 2))
+         (xmltok-add-dependent 'xmltok-unclosed-reparse-p
+                               nil
+                               nil
+                               "?>")
+         (setq xmltok-type 'not-well-formed))
+        (t
+         (cond ((not (save-excursion
+                       (goto-char (+ 2 xmltok-start))
+                       (and (looking-at (xmltok-ncname regexp))
+                            (setq xmltok-name-end (match-end 0)))))
+                (setq xmltok-name-end (+ xmltok-start 2))
+                (xmltok-add-error "<? not followed by name"
+                                  (+ xmltok-start 2)
+                                  (+ xmltok-start 3)))
+               ((not (or (memq (char-after xmltok-name-end)
+                               '(?\n ?\t ?\r ? ))
+                         (= xmltok-name-end (- (point) 2))))
+                (xmltok-add-error "Target not followed by whitespace"
+                                  xmltok-name-end
+                                  (1+ xmltok-name-end)))
+               ((and (= xmltok-name-end (+ xmltok-start 5))
+                     (save-excursion
+                       (goto-char (+ xmltok-start 2))
+                       (let ((case-fold-search t))
+                         (looking-at "xml"))))
+                (xmltok-add-error "Processing instruction target is xml"
+                                  (+ xmltok-start 2)
+                                  (+ xmltok-start 5))))
+         (setq xmltok-type 'processing-instruction))))
+                
+(defun xmltok-scan-after-comment-open ()
+  (setq xmltok-type
+        (cond ((not (search-forward "--" nil t))
+               (xmltok-add-error "No closing -->")
+               (xmltok-add-dependent 'xmltok-unclosed-reparse-p
+                                     nil
+                                     nil
+                                     ;; not --> because
+                                     ;; -- is not allowed
+                                     ;; in comments in XML
+                                     "--")
+               'not-well-formed)
+              ((eq (char-after) ?>)
+               (goto-char (1+ (point)))
+               'comment)
+              (t
+               (xmltok-add-dependent
+                'xmltok-semi-closed-reparse-p
+                nil
+                (point)
+                "--"
+                2)
+               ;; just include the <!-- in the token
+               (goto-char (+ xmltok-start 4))
+               ;; Need do this after the goto-char because
+               ;; marked error should just apply to <!--
+               (xmltok-add-error "First following `--' not followed by `>'")
+               'not-well-formed))))
+
+(defun xmltok-scan-attributes ()
+  (let ((recovering nil)
+        (atts-needing-normalization nil))
+    (while (cond ((or (looking-at (xmltok-attribute regexp))
+                      ;; use non-greedy group
+                      (when (looking-at (concat "[^<>\n]+?"
+                                                (xmltok-attribute regexp)))
+                        (unless recovering
+                          (xmltok-add-error "Malformed attribute"
+                                            (point)
+                                            (save-excursion
+                                              (goto-char (xmltok-attribute start
+                                                                           name))
+                                              (skip-chars-backward "\r\n\t ")
+                                              (point))))
+                        t))
+                  (setq recovering nil)
+                  (goto-char (match-end 0))
+                  (let ((att (xmltok-add-attribute)))
+                    (when att
+                      (setq atts-needing-normalization
+                            (cons att atts-needing-normalization))))
+                  (cond ((xmltok-attribute start start-tag-s) t)
+                        ((xmltok-attribute start start-tag-close)
+                         (setq xmltok-type 'start-tag)
+                         nil)
+                        ((xmltok-attribute start empty-tag-close)
+                         (setq xmltok-type 'empty-element)
+                         nil)
+                        ((xmltok-attribute start empty-tag-slash)
+                         (setq xmltok-type 'partial-empty-element)
+                         (xmltok-add-error "Expected `/>'"
+                                           (1- (point)))
+                         nil)
+                        ((looking-at "[ \t\r\n]*[\"']")
+                         (goto-char (match-end 0))
+                         (xmltok-add-error "Missing closing delimiter"
+                                           (1- (point)))
+                         (setq recovering t)
+                         t)
+                        ((looking-at "[ \t]*\\([^ \t\r\n\"'=<>/]+\\)[ \t\r\n/>]")
+                         (goto-char (match-end 1))
+                         (xmltok-add-error "Attribute value not quoted"
+                                           (match-beginning 1))
+                         (setq recovering t)
+                         t)
+                        (t
+                         (xmltok-add-error "Missing attribute value"
+                                           (1- (point)))
+                         (setq recovering t)
+                         t)))
+                 ((looking-at "[^<>\n]*/>")
+                  (let ((start (point)))
+                    (goto-char (match-end 0))
+                    (unless recovering
+                      (xmltok-add-error "Malformed empty-element"
+                                        start
+                                        (- (point) 2))))
+                  (setq xmltok-type 'empty-element)
+                  nil)
+                 ((looking-at "[^<>\n]*>")
+                  (let ((start (point)))
+                    (goto-char (match-end 0))
+                    (unless recovering
+                      (xmltok-add-error "Malformed start-tag"
+                                        start
+                                        (1- (point)))))
+                  (setq xmltok-type 'start-tag)
+                  nil)
+                 (t
+                  (when recovering
+                    (skip-chars-forward "^<>\n"))
+                  (xmltok-add-error "Missing `>'"
+                                    xmltok-start
+                                    (1+ xmltok-start))
+                  (setq xmltok-type 'partial-start-tag)
+                  nil)))
+    (while atts-needing-normalization
+      (xmltok-normalize-attribute (car atts-needing-normalization))
+      (setq atts-needing-normalization (cdr atts-needing-normalization))))
+  (setq xmltok-attributes
+        (nreverse xmltok-attributes))
+  (setq xmltok-namespace-attributes
+        (nreverse xmltok-namespace-attributes)))
+
+(defun xmltok-add-attribute ()
+  "Return the attribute if it needs normalizing, otherwise nil."
+  (let* ((needs-normalizing nil)
+         (att
+          (if (xmltok-attribute start literal)
+              (progn
+                (setq needs-normalizing
+                      (or (xmltok-attribute start complex1)
+                          (xmltok-attribute start complex2)))
+                (xmltok-make-attribute (xmltok-attribute start name)
+                                       (xmltok-attribute start colon)
+                                       (xmltok-attribute end name)
+                                       (1+ (xmltok-attribute start literal))
+                                       (1- (xmltok-attribute end literal))
+                                       (not needs-normalizing)))
+           (xmltok-make-attribute (xmltok-attribute start name)
+                                  (xmltok-attribute start colon)
+                                  (xmltok-attribute end name)))))
+    (if (xmltok-attribute start xmlns)
+        (setq xmltok-namespace-attributes
+              (cons att xmltok-namespace-attributes))
+      (setq xmltok-attributes
+            (cons att xmltok-attributes)))
+    (and needs-normalizing
+         att)))
+         
+(defun xmltok-normalize-attribute (att)
+  (let ((end (xmltok-attribute-value-end att))
+        (well-formed t)
+        (value-parts nil)
+        (refs nil))
+    (save-excursion
+      (goto-char (xmltok-attribute-value-start att))
+      (while (progn
+               (let ((n (skip-chars-forward "^\r\t\n&" end)))
+                 (when (> n 0)
+                   (setq value-parts
+                         (cons (buffer-substring-no-properties (- (point) n)
+                                                               (point))
+                               value-parts))))
+               (when (< (point) end)
+                 (goto-char (1+ (point)))
+                 (cond ((eq (char-before) ?\&)
+                        (let ((xmltok-start (1- (point)))
+                               xmltok-type xmltok-replacement)
+                          (xmltok-scan-after-amp
+                           (lambda (start end)
+                             (xmltok-handle-entity start end t)))
+                          (cond ((or (eq xmltok-type 'char-ref)
+                                     (eq xmltok-type 'entity-ref))
+                                 (setq refs
+                                       (cons (vector xmltok-type
+                                                     xmltok-start
+                                                     (point))
+                                             refs))
+                                 (if xmltok-replacement
+                                     (setq value-parts
+                                           (cons xmltok-replacement
+                                                 value-parts))
+                                   (setq well-formed nil)))
+                                (t (setq well-formed nil)))))
+                       (t (setq value-parts
+                                (cons " " value-parts)))))
+               (< (point) end))))
+    (when well-formed
+      (aset att 5 (apply 'concat (nreverse value-parts))))
+    (aset att 6 (nreverse refs))))
+
+(defun xmltok-scan-after-amp (entity-handler)
+  (cond ((not (looking-at (xmltok-after-amp regexp)))
+         (xmltok-add-error "`&' that is not markup must be entered as `&amp;'")
+         (setq xmltok-type 'not-well-formed))
+        (t
+         (goto-char (match-end 0))
+         (cond ((xmltok-after-amp start entity-ref-close)
+                (funcall entity-handler
+                         (xmltok-after-amp start entity-name)
+                         (xmltok-after-amp end entity-name))
+                (setq xmltok-type 'entity-ref))
+               ((xmltok-after-amp start decimal-ref-close)
+                (xmltok-scan-char-ref (xmltok-after-amp start decimal)
+                                      (xmltok-after-amp end decimal)
+                                      10))
+               ((xmltok-after-amp start hex-ref-close)
+                (xmltok-scan-char-ref (xmltok-after-amp start hex)
+                                      (xmltok-after-amp end hex)
+                                      16))
+               ((xmltok-after-amp start number-sign)
+                (xmltok-add-error "Missing character number")
+                (setq xmltok-type 'not-well-formed))
+               (t
+                (xmltok-add-error "Missing closing `;'")
+                (setq xmltok-type 'not-well-formed))))))
+
+(defconst xmltok-entity-error-messages
+  '((unparsed . "Referenced entity is unparsed")
+    (not-well-formed . "Referenced entity is not well-formed")
+    (external nil . "Referenced entity is external")
+    (element nil . "Referenced entity contains <")))
+
+(defun xmltok-handle-entity (start end &optional attributep)
+  (let* ((name (buffer-substring-no-properties start end))
+         (name-def (assoc name xmltok-dtd))
+         (def (cdr name-def)))
+    (cond ((setq xmltok-replacement (and (consp def)
+                                         (if attributep
+                                             (cdr def)
+                                           (car def)))))
+          ((null name-def)
+           (unless (eq (car xmltok-dtd) t)
+             (xmltok-add-error "Referenced entity has not been defined"
+                               start
+                               end)))
+          ((and attributep (consp def))
+           (xmltok-add-error "Referenced entity contains <"
+                             start
+                             end))
+          (t
+           (let ((err (cdr (assq def xmltok-entity-error-messages))))
+             (when (consp err)
+               (setq err (if attributep (cdr err) (car err))))
+             (when err
+               (xmltok-add-error err start end)))))))
+
+(defun xmltok-scan-char-ref (start end base)
+  (setq xmltok-replacement
+        (let ((n (string-to-int (buffer-substring-no-properties start end)
+                                base)))
+          (cond ((and (integerp n) (xmltok-valid-char-p n))
+                 (setq n (xmltok-unicode-to-char n))
+                 (and n (string n)))
+                (t
+                 (xmltok-add-error "Invalid character code" start end)
+                 nil))))
+  (setq xmltok-type 'char-ref))
+
+(defun xmltok-char-number (start end)
+  (let* ((base (if (eq (char-after (+ start 2)) ?x)
+                   16
+                 10))
+         (n (string-to-int
+             (buffer-substring-no-properties (+ start (if (= base 16) 3 2))
+                                             (1- end))
+             base)))
+    (and (integerp n)
+         (xmltok-valid-char-p n)
+         n)))
+
+(defun xmltok-unclosed-reparse-p (change-start
+                                  change-end
+                                  pre-change-length
+                                  start
+                                  end
+                                  delimiter)
+  (let ((len-1 (1- (length delimiter))))
+    (goto-char (max start (- change-start len-1)))
+    (search-forward delimiter (min end (+ change-end len-1)) t)))
+
+;; Handles a <!-- with the next -- not followed by >
+
+(defun xmltok-semi-closed-reparse-p (change-start
+                                     change-end
+                                     pre-change-length
+                                     start
+                                     end
+                                     delimiter
+                                     delimiter-length)
+  (or (<= (- end delimiter-length) change-end)
+      (xmltok-unclosed-reparse-p change-start
+                                 change-end
+                                 pre-change-length
+                                 start
+                                 end
+                                 delimiter)))
+
+(defun xmltok-valid-char-p (n)
+  "Return non-nil if n is the Unicode code of a valid XML character."
+  (cond ((< n #x20) (memq n '(#xA #xD #x9)))
+        ((< n #xD800) t)
+        ((< n #xE000) nil)
+        ((< n #xFFFE) t)
+        (t (and (> n #xFFFF)
+                (< n #x110000)))))
+
+(defun xmltok-unicode-to-char (n)
+  "Return the character corresponding to Unicode scalar value N.
+Return nil if unsupported in Emacs."
+  (decode-char 'ucs n))
+
+;;; Prolog parsing
+
+(defvar xmltok-contains-doctype nil)
+(defvar xmltok-doctype-external-subset-flag nil)
+(defvar xmltok-internal-subset-start nil)
+(defvar xmltok-had-param-entity-ref nil)
+(defvar xmltok-prolog-regions nil)
+(defvar xmltok-standalone nil
+  "Non-nil if there was an XML declaration specifying standalone=\"yes\",")
+(defvar xmltok-markup-declaration-doctype-flag nil)
+
+(defconst xmltok-predefined-entity-alist
+  '(("lt" "<" . "<")
+    ("gt" ">" . ">")
+    ("amp" "&" . "&")
+    ("apos" "'" . "'")
+    ("quot" "\"" . "\"")))
+
+(defun xmltok-forward-prolog ()
+  "Move forward to the end of the XML prolog.
+
+Returns a list of vectors [TYPE START END] where TYPE is a symbol and
+START and END are integers giving the start and end of the region of
+that type.  TYPE can be one of xml-declaration,
+xml-declaration-attribute-name, xml-declaration-attribute-value,
+comment, processing-instruction-left, processing-instruction-right,
+markup-declaration-open.  markup-declaration-close,
+internal-subset-open, internal-subset-close, hash-name, keyword,
+literal, encoding-name.
+Adds to `xmltok-errors' and `xmltok-dependent-regions' as appropriate."
+  (let ((case-fold-search nil)
+        xmltok-start
+        xmltok-type
+        xmltok-prolog-regions
+        xmltok-contains-doctype
+        xmltok-internal-subset-start
+        xmltok-had-param-entity-ref
+        xmltok-standalone
+        xmltok-doctype-external-subset-flag
+        xmltok-markup-declaration-doctype-flag)
+    (setq xmltok-dtd xmltok-predefined-entity-alist)
+    (xmltok-scan-xml-declaration)
+    (xmltok-next-prolog-token)
+    (while (condition-case err
+               (when (xmltok-parse-prolog-item)
+                 (xmltok-next-prolog-token))
+             (xmltok-markup-declaration-parse-error
+              (xmltok-skip-markup-declaration))))
+    (when xmltok-internal-subset-start
+      (xmltok-add-error "No closing ]"
+                        (1- xmltok-internal-subset-start)
+                        xmltok-internal-subset-start))
+    (xmltok-parse-entities)
+    ;; XXX prune dependent-regions for those entirely in prolog
+    (nreverse xmltok-prolog-regions)))
+
+(defconst xmltok-bad-xml-decl-regexp
+  "[ \t\r\n]*<\\?xml\\(?:[ \t\r\n]\\|\\?>\\)")
+
+;;;###autoload
+(defun xmltok-get-declared-encoding-position (&optional limit)
+  "Return the position of the encoding in the XML declaration at point.
+If there is a well-formed XML declaration starting at point and it
+contains an encoding declaration, then return (START . END)
+where START and END are the positions of the start and the end
+of the encoding name; if there is no encoding declaration return
+the position where and encoding declaration could be inserted.
+If there is XML that is not well-formed that looks like an XML declaration,
+return nil.  Otherwise, return t.
+If LIMIT is non-nil, then do not consider characters beyond LIMIT."
+  (cond ((let ((case-fold-search nil))
+           (and (looking-at (xmltok-xml-declaration regexp))
+                (or (not limit) (<= (match-end 0) limit))))
+         (let ((end (xmltok-xml-declaration end encoding-value)))
+           (if end
+               (cons (1+ (xmltok-xml-declaration start encoding-value))
+                     (1- end))
+             (or (xmltok-xml-declaration end version-value)
+                 (+ (point) 5)))))
+        ((not (let ((case-fold-search t))
+                (looking-at xmltok-bad-xml-decl-regexp))))))
+                
+(defun xmltok-scan-xml-declaration ()
+  (when (looking-at (xmltok-xml-declaration regexp))
+    (xmltok-add-prolog-region 'xml-declaration (point) (match-end 0))
+    (goto-char (match-end 0))
+    (when (xmltok-xml-declaration start version-name)
+      (xmltok-add-prolog-region 'xml-declaration-attribute-name
+                                (xmltok-xml-declaration start version-name)
+                                (xmltok-xml-declaration end version-name))
+      (let ((start (xmltok-xml-declaration start version-value))
+            (end (xmltok-xml-declaration end version-value)))
+        (xmltok-add-prolog-region 'xml-declaration-attribute-value
+                                  start
+                                  end)))
+    ;; XXX need to check encoding name
+    ;; Should start with letter, not contain colon
+    (when (xmltok-xml-declaration start encoding-name)
+      (xmltok-add-prolog-region 'xml-declaration-attribute-name
+                                (xmltok-xml-declaration start encoding-name)
+                                (xmltok-xml-declaration end encoding-name))
+      (let ((start (xmltok-xml-declaration start encoding-value))
+            (end (xmltok-xml-declaration end encoding-value)))
+        (xmltok-add-prolog-region 'encoding-name
+                                  (1+ start)
+                                  (1- end))
+        (xmltok-add-prolog-region 'xml-declaration-attribute-value
+                                  start
+                                  end)))
+    (when (xmltok-xml-declaration start standalone-name)
+      (xmltok-add-prolog-region 'xml-declaration-attribute-name
+                                (xmltok-xml-declaration start standalone-name)
+                                (xmltok-xml-declaration end standalone-name))
+      (let ((start (xmltok-xml-declaration start standalone-value))
+            (end (xmltok-xml-declaration end standalone-value)))
+        (xmltok-add-prolog-region 'xml-declaration-attribute-value
+                                  start
+                                  end)
+        (setq xmltok-standalone
+              (string= (buffer-substring-no-properties (1+ start) (1- end))
+                       "yes"))))
+    t))
+
+(defconst xmltok-markup-declaration-alist
+  '(("ELEMENT" . xmltok-parse-element-declaration)
+    ("ATTLIST" . xmltok-parse-attlist-declaration)
+    ("ENTITY" . xmltok-parse-entity-declaration)
+    ("NOTATION" . xmltok-parse-notation-declaration)))
+
+(defun xmltok-parse-prolog-item ()
+  (cond ((eq xmltok-type 'comment)
+         (xmltok-add-prolog-region 'comment
+                                   xmltok-start
+                                   (point))
+         t)
+        ((eq xmltok-type 'processing-instruction))
+        ((eq xmltok-type 'named-markup-declaration)
+         (setq xmltok-markup-declaration-doctype-flag nil)
+         (xmltok-add-prolog-region 'markup-declaration-open
+                                   xmltok-start
+                                   (point))
+         (let* ((name (buffer-substring-no-properties
+                       (+ xmltok-start 2)
+                       (point)))
+                (fun (cdr (assoc name xmltok-markup-declaration-alist))))
+           (cond (fun
+                  (unless xmltok-internal-subset-start
+                    (xmltok-add-error
+                     "Declaration allowed only in internal subset"))
+                  (funcall fun))
+                 ((string= name "DOCTYPE")
+                  (xmltok-parse-doctype))
+                 (t
+                  (xmltok-add-error "Unknown markup declaration"
+                                    (+ xmltok-start 2))
+                  (xmltok-next-prolog-token)
+                  (xmltok-markup-declaration-parse-error))))
+         t)
+        ((or (eq xmltok-type 'end-prolog)
+             (not xmltok-type))
+         nil)
+        ((eq xmltok-type 'internal-subset-close)
+         (xmltok-add-prolog-region 'internal-subset-close
+                                   xmltok-start
+                                   (1+ xmltok-start))
+         (xmltok-add-prolog-region 'markup-declaration-close
+                                   (1- (point))
+                                   (point))
+         (if xmltok-internal-subset-start
+             (setq xmltok-internal-subset-start nil)
+           (xmltok-add-error "]> outside internal subset"))
+         t)
+        ((eq xmltok-type 'param-entity-ref)
+         (if xmltok-internal-subset-start
+             (setq xmltok-had-param-entity-ref t)
+           (xmltok-add-error "Parameter entity reference outside document type declaration"))
+         t)
+        ;; If we don't do this, we can get thousands of errors when
+        ;; a plain text file is parsed.
+        ((not xmltok-internal-subset-start)
+         (when (let ((err (car xmltok-errors)))
+                 (or (not err)
+                     (<= (xmltok-error-end err) xmltok-start)))
+           (goto-char xmltok-start))
+         nil)
+        ((eq xmltok-type 'not-well-formed) t)
+        (t
+         (xmltok-add-error "Token allowed only inside markup declaration")
+         t)))
+
+(defun xmltok-parse-doctype ()
+  (setq xmltok-markup-declaration-doctype-flag t)
+  (xmltok-next-prolog-token)
+  (when xmltok-internal-subset-start
+    (xmltok-add-error "DOCTYPE declaration not allowed in internal subset")
+    (xmltok-markup-declaration-parse-error))
+  (when xmltok-contains-doctype
+    (xmltok-add-error "Duplicate DOCTYPE declaration")
+    (xmltok-markup-declaration-parse-error))
+  (setq xmltok-contains-doctype t)
+  (xmltok-require-token 'name 'prefixed-name)
+  (xmltok-require-next-token "SYSTEM" "PUBLIC" ?\[ ?>)
+  (cond ((eq xmltok-type ?\[)
+         (setq xmltok-internal-subset-start (point)))
+        ((eq xmltok-type ?>))
+        (t
+         (setq xmltok-doctype-external-subset-flag t)
+         (xmltok-parse-external-id)
+         (xmltok-require-token ?\[ ?>)
+         (when (eq xmltok-type ?\[)
+           (setq xmltok-internal-subset-start (point))))))
+
+(defun xmltok-parse-attlist-declaration ()
+  (xmltok-require-next-token 'prefixed-name 'name)
+  (while (progn
+           (xmltok-require-next-token ?> 'name 'prefixed-name)
+           (if (eq xmltok-type ?>)
+               nil
+             (xmltok-require-next-token ?\(
+                                        "CDATA"
+                                        "ID"
+                                        "IDREF"
+                                        "IDREFS"
+                                        "ENTITY"
+                                        "ENTITIES"
+                                        "NMTOKEN"
+                                        "NMTOKENS"
+                                        "NOTATION")
+             (cond ((eq xmltok-type ?\()
+                    (xmltok-parse-nmtoken-group))
+                   ((string= (xmltok-current-token-string)
+                             "NOTATION")
+                    (xmltok-require-next-token ?\()
+                    (xmltok-parse-nmtoken-group)))
+             (xmltok-require-next-token "#IMPLIED"
+                                        "#REQUIRED"
+                                        "#FIXED"
+                                        'literal)
+             (when (string= (xmltok-current-token-string) "#FIXED")
+               (xmltok-require-next-token 'literal))
+             t))))
+                   
+(defun xmltok-parse-nmtoken-group ()
+  (while (progn
+           (xmltok-require-next-token 'nmtoken 'prefixed-name 'name)
+           (xmltok-require-next-token ?| ?\))
+           (eq xmltok-type ?|))))
+
+(defun xmltok-parse-element-declaration ()
+  (xmltok-require-next-token 'name 'prefixed-name)
+  (xmltok-require-next-token "EMPTY" "ANY" ?\()
+  (when (eq xmltok-type ?\()
+    (xmltok-require-next-token "#PCDATA"
+                               'name
+                               'prefixed-name
+                               'name-occur
+                               ?\()
+    (cond ((eq xmltok-type 'hash-name)
+           (xmltok-require-next-token ?| ?\) 'close-paren-star)
+           (while (eq xmltok-type ?|)
+             (xmltok-require-next-token 'name 'prefixed-name)
+             (xmltok-require-next-token 'close-paren-star ?|)))
+          (t (xmltok-parse-model-group))))
+  (xmltok-require-next-token ?>))
+
+(defun xmltok-parse-model-group ()
+  (xmltok-parse-model-group-member)
+  (xmltok-require-next-token ?|
+                             ?,
+                             ?\)
+                             'close-paren-star
+                             'close-paren-occur)
+  (when (memq xmltok-type '(?, ?|))
+    (let ((connector xmltok-type))
+      (while (progn
+               (xmltok-next-prolog-token)
+               (xmltok-parse-model-group-member)
+               (xmltok-require-next-token connector
+                                          ?\)
+                                          'close-paren-star
+                                          'close-paren-occur)
+               (eq xmltok-type connector))))))
+                                          
+(defun xmltok-parse-model-group-member ()
+  (xmltok-require-token 'name
+                        'prefixed-name
+                        'name-occur
+                        ?\()
+  (when (eq xmltok-type ?\()
+    (xmltok-next-prolog-token)
+    (xmltok-parse-model-group)))
+    
+(defun xmltok-parse-entity-declaration ()
+  (let (paramp name)
+    (xmltok-require-next-token 'name ?%)
+    (when (eq xmltok-type ?%)
+      (setq paramp t)
+      (xmltok-require-next-token 'name))
+    (setq name (xmltok-current-token-string))
+    (xmltok-require-next-token 'literal "SYSTEM" "PUBLIC")
+    (cond ((eq xmltok-type 'literal)
+           (let ((replacement (xmltok-parse-entity-value)))
+             (unless paramp
+               (xmltok-define-entity name replacement)))
+           (xmltok-require-next-token ?>))
+          (t
+           (xmltok-parse-external-id)
+           (if paramp
+               (xmltok-require-token ?>)
+             (xmltok-require-token ?> "NDATA")
+             (if (eq xmltok-type ?>)
+                 (xmltok-define-entity name 'external)
+               (xmltok-require-next-token 'name)
+               (xmltok-require-next-token ?>)
+               (xmltok-define-entity name 'unparsed)))))))
+
+(defun xmltok-define-entity (name value)
+  (when (and (or (not xmltok-had-param-entity-ref)
+                 xmltok-standalone)
+             (not (assoc name xmltok-dtd)))
+    (setq xmltok-dtd
+          (cons (cons name value) xmltok-dtd))))
+  
+(defun xmltok-parse-entity-value ()
+  (let ((lim (1- (point)))
+        (well-formed t)
+        value-parts
+        start)
+    (save-excursion
+      (goto-char (1+ xmltok-start))
+      (setq start (point))
+      (while (progn
+               (skip-chars-forward "^%&" lim)
+               (when (< (point) lim)
+                 (goto-char (1+ (point)))
+                 (cond ((eq (char-before) ?%)
+                        (xmltok-add-error "Parameter entity references are not allowed in the internal subset"
+                                          (1- (point))
+                                          (point))
+                        (setq well-formed  nil))
+                       (t
+                        (let ((xmltok-start (1- (point)))
+                               xmltok-type xmltok-replacement)
+                          (xmltok-scan-after-amp (lambda (start end)))
+                          (cond ((eq xmltok-type 'char-ref)
+                                 (setq value-parts
+                                       (cons (buffer-substring-no-properties
+                                              start
+                                              xmltok-start)
+                                             value-parts))
+                                 (setq value-parts
+                                       (cons xmltok-replacement
+                                             value-parts))
+                                 (setq start (point)))
+                                ((eq xmltok-type 'not-well-formed)
+                                 (setq well-formed nil))))))
+                 t))))
+    (if (not well-formed)
+        nil
+      (apply 'concat
+             (nreverse (cons (buffer-substring-no-properties start lim)
+                             value-parts))))))
+                     
+(defun xmltok-parse-notation-declaration ()
+  (xmltok-require-next-token 'name)
+  (xmltok-require-next-token "SYSTEM" "PUBLIC")
+  (let ((publicp (string= (xmltok-current-token-string) "PUBLIC")))
+    (xmltok-require-next-token 'literal)
+    (cond (publicp
+           (xmltok-require-next-token 'literal ?>)
+           (unless (eq xmltok-type ?>)
+             (xmltok-require-next-token ?>)))
+          (t (xmltok-require-next-token ?>)))))
+
+(defun xmltok-parse-external-id ()
+  (xmltok-require-token "SYSTEM" "PUBLIC")
+  (let ((publicp (string= (xmltok-current-token-string) "PUBLIC")))
+    (xmltok-require-next-token 'literal)
+    (when publicp
+      (xmltok-require-next-token 'literal)))
+  (xmltok-next-prolog-token))
+
+(defun xmltok-require-next-token (&rest types)
+  (xmltok-next-prolog-token)
+  (apply 'xmltok-require-token types))
+
+(defun xmltok-require-token (&rest types)
+  ;; XXX Generate a more helpful error message
+  (while (and (not (let ((type (car types)))
+                     (if (stringp (car types))
+                         (string= (xmltok-current-token-string) type)
+                       (eq type xmltok-type))))
+              (setq types (cdr types))))
+  (unless types
+    (when (and xmltok-type
+               (not (eq xmltok-type 'not-well-formed)))
+      (xmltok-add-error "Unexpected token"))
+    (xmltok-markup-declaration-parse-error))
+  (let ((region-type (xmltok-prolog-region-type (car types))))
+    (when region-type
+      (xmltok-add-prolog-region region-type
+                                xmltok-start
+                                (point)))))
+
+(defun xmltok-current-token-string ()
+  (buffer-substring-no-properties xmltok-start (point)))
+
+(put 'xmltok-markup-declaration-parse-error
+     'error-conditions
+     '(error xmltok-markup-declaration-parse-error))
+
+(put 'xmltok-markup-declaration-parse-error
+     'error-message
+     "Syntax error in markup declaration")
+
+(defun xmltok-markup-declaration-parse-error ()
+  (signal 'xmltok-markup-declaration-parse-error nil))
+
+(defun xmltok-skip-markup-declaration ()
+  (while (cond ((eq xmltok-type ?>)
+                (xmltok-next-prolog-token)
+                nil)
+               ((and xmltok-markup-declaration-doctype-flag
+                     (eq xmltok-type ?\[))
+                (setq xmltok-internal-subset-start (point))
+                (xmltok-next-prolog-token)
+                nil)
+               ((memq xmltok-type '(nil
+                                    end-prolog
+                                    named-markup-declaration
+                                    comment
+                                    processing-instruction))
+                nil)
+               ((and xmltok-internal-subset-start
+                     (eq xmltok-type 'internal-subset-close))
+                nil)
+               (t (xmltok-next-prolog-token) t)))
+  xmltok-type)
+
+(defun xmltok-prolog-region-type (required)
+  (cond ((cdr (assq xmltok-type
+                    '((literal . literal)
+                      (?> . markup-declaration-close)
+                      (?\[ . internal-subset-open)
+                      (hash-name . hash-name)))))
+        ((and (stringp required) (eq xmltok-type 'name))
+         'keyword)))
+         
+;; Return new token type.
+                                    
+(defun xmltok-next-prolog-token ()
+  (skip-chars-forward " \t\r\n")
+  (setq xmltok-start (point))
+  (cond ((not (and (looking-at (xmltok-prolog regexp))
+                   (goto-char (match-end 0))))
+         (let ((ch (char-after)))
+           (cond (ch
+                  (goto-char (1+ (point)))
+                  (xmltok-add-error "Illegal char in prolog")
+                  (setq xmltok-type 'not-well-formed))
+                 (t (setq xmltok-type nil)))))
+        ((or (xmltok-prolog start ncname-occur)
+             (xmltok-prolog start colon-name-occur))
+         (setq xmltok-name-end (1- (point)))
+         (setq xmltok-name-colon (xmltok-prolog start colon))
+         (setq xmltok-type 'name-occur))
+        ((xmltok-prolog start colon)
+         (setq xmltok-name-end (point))
+         (setq xmltok-name-colon (xmltok-prolog start colon))
+         (unless (looking-at "[ \t\r\n>),|[%]")
+           (xmltok-add-error "Missing space after name"))
+         (setq xmltok-type 'prefixed-name))
+        ((or (xmltok-prolog start ncname-nmtoken)
+             (xmltok-prolog start ncname-colon))
+         (unless (looking-at "[ \t\r\n>),|[%]")
+           (xmltok-add-error "Missing space after name token"))
+         (setq xmltok-type 'nmtoken))
+        ((xmltok-prolog start name)     
+         (setq xmltok-name-end (point))
+         (setq xmltok-name-colon nil)
+         (unless (looking-at "[ \t\r\n>),|[%]")
+           (xmltok-add-error "Missing space after name"))
+         (setq xmltok-type 'name))
+        ((xmltok-prolog start hash-name)        
+         (setq xmltok-name-end (point))
+         (unless (looking-at "[ \t\r\n>)|%]")
+           (xmltok-add-error "Missing space after name"))
+         (setq xmltok-type 'hash-name))
+        ((xmltok-prolog start processing-instruction-question)
+         (xmltok-scan-prolog-after-processing-instruction-open))
+        ((xmltok-prolog start comment-open)
+         ;; XXX if not-well-formed, ignore some stuff
+         (xmltok-scan-after-comment-open))
+        ((xmltok-prolog start named-markup-declaration)
+         (setq xmltok-type 'named-markup-declaration))
+        ((xmltok-prolog start instance-start)
+         (goto-char xmltok-start)
+         (setq xmltok-type 'end-prolog))
+        ((xmltok-prolog start close-paren-star)
+         (setq xmltok-type 'close-paren-star))
+        ((xmltok-prolog start close-paren-occur)
+         (setq xmltok-type 'close-paren-occur))
+        ((xmltok-prolog start close-paren)
+         (unless (looking-at "[ \t\r\n>,|)]")
+           (xmltok-add-error "Missing space after )"))
+         (setq xmltok-type ?\)))
+        ((xmltok-prolog start single-char)
+         (let ((ch (char-before)))
+           (cond ((memq ch '(?\" ?\'))
+                  (xmltok-scan-prolog-literal))
+                 (t (setq xmltok-type ch)))))
+        ((xmltok-prolog start percent)
+         (cond ((xmltok-prolog start param-entity-ref-close)
+                (setq xmltok-name-end (1- (point)))
+                (setq xmltok-type 'param-entity-ref))
+               ((xmltok-prolog start param-entity-ref)
+                (xmltok-add-error "Missing ;")
+                (setq xmltok-name-end (point))
+                (setq xmltok-type 'param-entity-ref))
+               ((looking-at "[ \t\r\n%]")
+                (setq xmltok-type ?%))
+               (t
+                (xmltok-add-error "Expected name after %")
+                (setq xmltok-type 'not-well-formed))))
+        ((xmltok-prolog start nmtoken)
+         (unless (looking-at "[ \t\r\n>),|[%]")
+           (xmltok-add-error "Missing space after name token"))
+         (setq xmltok-type 'nmtoken))
+        ((xmltok-prolog start internal-subset-close)
+         (setq xmltok-type 'internal-subset-close))
+        ((xmltok-prolog start pound)
+         (xmltok-add-error "Expected name after #")
+         (setq xmltok-type 'not-well-formed))
+        ((xmltok-prolog start markup-declaration)
+         (xmltok-add-error "Expected name or -- after <!")
+         (setq xmltok-type 'not-well-formed))
+        ((xmltok-prolog start comment-first-dash)
+         (xmltok-add-error "Expected <!--")
+         (setq xmltok-type 'not-well-formed))
+        ((xmltok-prolog start less-than)
+         (xmltok-add-error "Incomplete markup")
+         (setq xmltok-type 'not-well-formed))
+        (t (error "Unhandled token in prolog %s"
+                  (match-string-no-properties 0)))))
+
+(defun xmltok-scan-prolog-literal ()
+  (let* ((delim (string (char-before)))
+         (safe-end (save-excursion
+                     (skip-chars-forward (concat "^<>[]" delim))
+                     (point)))
+         (end (save-excursion
+                (goto-char safe-end)
+                (search-forward delim nil t))))
+    (or (cond ((not end)
+               (xmltok-add-dependent 'xmltok-unclosed-reparse-p
+                                     nil
+                                     nil
+                                     delim)
+               nil)
+              ((save-excursion
+                 (goto-char end)
+                 (looking-at "[ \t\r\n>%[]"))
+               (goto-char end)
+               (setq xmltok-type 'literal))
+              ((eq (1+ safe-end) end)
+               (goto-char end)
+               (xmltok-add-error (format "Missing space after %s" delim)
+                                 safe-end)
+               (setq xmltok-type 'literal))
+              (t
+               (xmltok-add-dependent 'xmltok-semi-closed-reparse-p
+                                     xmltok-start
+                                     (1+ end)
+                                     delim
+                                     1)
+               nil))
+        (progn
+          (xmltok-add-error (format "Missing closing %s" delim))
+          (goto-char safe-end)
+          (skip-chars-backward " \t\r\n")
+          (setq xmltok-type 'not-well-formed)))))
+
+(defun xmltok-scan-prolog-after-processing-instruction-open ()
+  (cond ((not (search-forward "?>" nil t))
+         (xmltok-add-error "No closing ?>"
+                           xmltok-start
+                           (+ xmltok-start 2))
+         (xmltok-add-dependent 'xmltok-unclosed-reparse-p
+                               nil
+                               nil
+                               "?>")
+         (setq xmltok-type 'not-well-formed))
+        (t
+         (let* ((end (point))
+                (target
+                 (save-excursion
+                   (goto-char (+ xmltok-start 2))
+                   (and (looking-at (xmltok-ncname regexp))
+                        (or (memq (char-after (match-end 0))
+                                  '(?\n ?\t ?\r ? ))
+                            (= (match-end 0) (- end 2)))
+                        (match-string-no-properties 0)))))
+           (cond ((not target)
+                  (xmltok-add-error "\
+Processing instruction does not start with a name"
+                                    (+ xmltok-start 2)
+                                    (+ xmltok-start 3)))
+                 ((not (and (= (length target) 3)
+                            (let ((case-fold-search t))
+                              (string-match "xml" target)))))
+                 ((= xmltok-start 1)
+                  (xmltok-add-error "Invalid XML declaration"
+                                    xmltok-start
+                                    (point)))
+                 ((save-excursion
+                    (goto-char xmltok-start)
+                    (looking-at (xmltok-xml-declaration regexp)))
+                  (xmltok-add-error "XML declaration not at beginning of file"
+                                    xmltok-start
+                                    (point)))
+                 (t
+                  (xmltok-add-error "Processing instruction has target of xml"
+                                    (+ xmltok-start 2)
+                                    (+ xmltok-start 5))))
+           (xmltok-add-prolog-region 'processing-instruction-left
+                                     xmltok-start
+                                     (+ xmltok-start
+                                        2
+                                        (if target
+                                            (length target)
+                                          0)))
+           (xmltok-add-prolog-region 'processing-instruction-right
+                                     (if target
+                                         (save-excursion
+                                           (goto-char (+ xmltok-start
+                                                         (length target)
+                                                         2))
+                                           (skip-chars-forward " \t\r\n")
+                                           (point))
+                                       (+ xmltok-start 2))
+                                     (point)))
+         (setq xmltok-type 'processing-instruction))))
+
+(defun xmltok-parse-entities ()
+  (let ((todo xmltok-dtd))
+    (when (and (or xmltok-had-param-entity-ref
+                   xmltok-doctype-external-subset-flag)
+               (not xmltok-standalone))
+      (setq xmltok-dtd (cons t xmltok-dtd)))
+    (while todo
+      (xmltok-parse-entity (car todo))
+      (setq todo (cdr todo)))))
+  
+(defun xmltok-parse-entity (name-def)
+  (let ((def (cdr name-def))
+        ;; in case its value is buffer local 
+        (xmltok-dtd xmltok-dtd)
+        buf)
+    (when (stringp def)
+      (if (string-match "\\`[^&<\t\r\n]*\\'" def)
+          (setcdr name-def (cons def def))
+        (setcdr name-def 'not-well-formed) ; avoid infinite expansion loops
+        (setq buf (get-buffer-create
+                   (format " *Entity %s*" (car name-def))))
+        (save-excursion
+          (set-buffer buf)
+          (erase-buffer)
+          (insert def)
+          (goto-char (point-min))
+          (setcdr name-def
+                  (xmltok-parse-entity-replacement)))
+        (kill-buffer buf)))))
+
+(defun xmltok-parse-entity-replacement ()
+  (let ((def (cons "" "")))
+    (while (let* ((start (point))
+                  (found (re-search-forward "[<&\t\r\n]\\|]]>" nil t))
+                  (ch (and found (char-before)))
+                  (str (buffer-substring-no-properties
+                        start
+                        (if found
+                            (match-beginning 0)
+                          (point-max)))))
+             (setq def
+                   (xmltok-append-entity-def def
+                                             (cons str str)))
+             (cond ((not found) nil)
+                   ((eq ch ?>)
+                    (setq def 'not-well-formed)
+                    nil)
+                   ((eq ch ?<)
+                    (xmltok-save
+                      (setq xmltok-start (1- (point)))
+                      (xmltok-scan-after-lt)
+                      (setq def
+                            (xmltok-append-entity-def
+                             def
+                             (cond ((memq xmltok-type
+                                          '(start-tag
+                                            end-tag
+                                            empty-element))
+                                    'element)
+                                   ((memq xmltok-type
+                                          '(comment
+                                            processing-instruction))
+                                    (cons "" nil))
+                                   ((eq xmltok-type
+                                        'cdata-section)
+                                    (cons (buffer-substring-no-properties
+                                           (+ xmltok-start 9)
+                                           (- (point) 3))
+                                          nil))
+                                   (t 'not-well-formed)))))
+                    t)
+                   ((eq ch ?&)
+                    (let ((xmltok-start (1- (point)))
+                          xmltok-type
+                          xmltok-replacement
+                          xmltok-errors)
+                      (xmltok-scan-after-amp 'xmltok-handle-nested-entity)
+                      (cond ((eq xmltok-type 'entity-ref)
+                             (setq def
+                                   (xmltok-append-entity-def
+                                    def
+                                    xmltok-replacement)))
+                            ((eq xmltok-type 'char-ref)
+                             (setq def
+                                   (xmltok-append-entity-def
+                                    def
+                                    (if xmltok-replacement
+                                         (cons xmltok-replacement
+                                               xmltok-replacement)
+                                      (and xmltok-errors 'not-well-formed)))))
+                            (t
+                             (setq def 'not-well-formed))))
+                    t)
+                   (t
+                    (setq def
+                          (xmltok-append-entity-def
+                           def
+                           (cons (match-string-no-properties 0)
+                                 " ")))
+                    t))))
+    def))
+
+(defun xmltok-handle-nested-entity (start end)
+  (let* ((name-def (assoc (buffer-substring-no-properties start end)
+                          xmltok-dtd))
+         (def (cdr name-def)))
+    (when (stringp def)
+      (xmltok-parse-entity name-def)
+      (setq def (cdr name-def)))
+    (setq xmltok-replacement
+          (cond ((null name-def)
+                 (if (eq (car xmltok-dtd) t)
+                     nil
+                   'not-well-formed))
+                ((eq def 'unparsed) 'not-well-formed)
+                (t def)))))
+    
+(defun xmltok-append-entity-def (d1 d2)
+  (cond ((consp d1)
+         (if (consp d2)
+             (cons (concat (car d1) (car d2))
+                   (and (cdr d1)
+                        (cdr d2)
+                        (concat (cdr d1) (cdr d2))))
+           d2))
+        ((consp d2) d1)
+        (t
+         (let ((defs '(not-well-formed external element)))
+           (while (not (or (eq (car defs) d1)
+                           (eq (car defs) d2)))
+             (setq defs (cdr defs)))
+           (car defs)))))
+
+(defun xmltok-add-prolog-region (type start end)
+  (setq xmltok-prolog-regions
+        (cons (vector type start end)
+              xmltok-prolog-regions)))
+
+(defun xmltok-merge-attributes ()
+  "Return a list merging `xmltok-attributes' and 'xmltok-namespace-attributes'.
+The members of the merged list are in order of occurrence in the
+document.  The list may share list structure with `xmltok-attributes'
+and `xmltok-namespace-attributes'."
+  (cond ((not xmltok-namespace-attributes)
+         xmltok-attributes)
+        ((not xmltok-attributes)
+         xmltok-namespace-attributes)
+        (t
+         (let ((atts1 xmltok-attributes)
+               (atts2 xmltok-namespace-attributes)
+               merged)
+           (while (and atts1 atts2)
+             (cond ((< (xmltok-attribute-name-start (car atts1))
+                       (xmltok-attribute-name-start (car atts2)))
+                    (setq merged (cons (car atts1) merged))
+                    (setq atts1 (cdr atts1)))
+                   (t
+                    (setq merged (cons (car atts2) merged))
+                    (setq atts2 (cdr atts2)))))
+           (setq merged (nreverse merged))
+           (cond (atts1 (setq merged (nconc merged atts1)))
+                 (atts2 (setq merged (nconc merged atts2))))
+           merged))))
+
+;;; Testing
+
+(defun xmltok-forward-test ()
+  (interactive)
+  (if (xmltok-forward)
+      (message "Scanned %s" xmltok-type)
+    (message "Scanned nothing")))
+
+(defun xmltok-next-prolog-token-test ()
+  (interactive)
+  (if (xmltok-next-prolog-token)
+      (message "Scanned %s"
+               (if (integerp xmltok-type)
+                   (string xmltok-type)
+                 xmltok-type))
+    (message "Scanned end of file")))
+
+(provide 'xmltok)
+
+;;; xmltok.el ends here
diff --git a/lisp/nxml/xsd-regexp.el b/lisp/nxml/xsd-regexp.el
new file mode 100644
index 00000000000..3f12c5576a6
--- /dev/null
+++ b/lisp/nxml/xsd-regexp.el
@@ -0,0 +1,2121 @@
+;;; xsd-regexp.el --- translate W3C XML Schema regexps to Emacs regexps
+
+;; Copyright (C) 2003 Free Software Foundation, Inc.
+
+;; Author: James Clark
+;; Keywords: XML, regexp
+
+;; This program is free software; you can redistribute it and/or
+;; modify it under the terms of the GNU General Public License as
+;; published by the Free Software Foundation; either version 2 of
+;; the License, or (at your option) any later version.
+
+;; This program is distributed in the hope that it will be
+;; useful, but WITHOUT ANY WARRANTY; without even the implied
+;; warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+;; PURPOSE.  See the GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public
+;; License along with this program; if not, write to the Free
+;; Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+;; MA 02111-1307 USA
+
+;;; Commentary:
+
+;; This handles the regular expressions in the syntax defined by:
+;; W3C XML Schema Part 2: Datatypes
+;; <http://www.w3.org/TR/xmlschema-2/#regexs>
+;;
+;; The main entry point is `xsdre-translate'.
+;;
+;; The features of XSD regexps that make this non-trivial are:
+;;
+;; - \p{PROP} escape for matching characters that have various
+;;   Unicode-defined properties
+;; - character class subtraction:, e.g. [\p{L}-[abc]] matches
+;;   any character in the L category other than a, b and c.
+;;
+;; We compute the set of Unicode characters denoted by each XSD
+;; char-class as a list of ranges.  The regexp generated for a
+;; single escape can be large (several thousand characters).
+;;
+;; XSD has non-traditional rules about when characters must be
+;; and can be quoted with \.  These are quite different from
+;; the Emacs rules.
+;;
+;; The semantics of XSD regexps are defined in terms of Unicode.
+;; Non-Unicode characters are not allowed in regular expressions and
+;; will not match against the generated regular expressions.  A
+;; Unicode character means a character in one of the Mule charsets
+;; ascii, latin-iso8859-1, mule-unicode-0100-24ff,
+;; mule-unicode-2500-33ff, mule-unicode-e000-ffff, eight-bit-control
+;; or a character translateable to such a character (i.e a character
+;; for which `encode-char' will return non-nil).
+;;
+;; Using unify-8859-on-decoding-mode is probably a good idea here
+;; (and generally with XML and other Unicode-oriented formats).
+;;
+;; Unfortunately, this means that this package is currently useless
+;; for CJK characters, since there's no mule-unicode charset for the
+;; CJK ranges of Unicode.  We should devise a workaround for this
+;; until the fabled Unicode version of Emacs makes an appearance.
+
+;;; Code:
+
+(defun xsdre-translate (regexp)
+  "Translate a W3C XML Schema Datatypes regexp to an Emacs regexp.
+Returns a string.  REGEXP is a string. If REGEXP is not a valid XSD
+regexp, signal an `xsdre-invalid-regexp' condition."
+  (xsdre-from-symbolic
+   (xsdre-to-symbolic regexp)))
+
+(defvar xsdre-test-history nil)
+
+(defun xsdre-test-regexp ()
+  (interactive)
+  (while
+      (let* ((str (read-from-minibuffer "Regexp: "
+                                        nil
+                                        nil
+                                        nil
+                                        'xsdre-test-history))
+             (symbolic
+              (xsdre-to-symbolic str)))
+        (with-output-to-temp-buffer "*XSD Regexp Test*"
+          (princ "XSD regexp: ")
+          (princ str)
+          (princ "\n")
+          (princ "Symbolic: ")
+          (princ "\n")
+          (pp symbolic)
+          (princ "\n")
+          (princ "Emacs regexp: ")
+          (princ (xsdre-from-symbolic symbolic)))
+        t)))
+
+;;; Range lists
+
+(defsubst xsdre-make-range (first last)
+  "Return a representation of a range of integers.
+If the range contains a single integer, it is represented by that integer.
+Otherwise, it is represented by a (FIRST . LAST) pair."
+  (if (= first last)
+      first
+    (cons first last)))
+
+(defsubst xsdre-range-first (r)
+  "Return the first integer in a range."
+  (if (consp r) (car r) r))
+
+(defsubst xsdre-range-last (r)
+  "Return the last integer in a range."
+  (if (consp r) (cdr r) r))
+
+(defun xsdre-make-range-list (list)
+  "Make a range-list from a list of ranges.
+A range-list represents a set of integers by a list of ranges in a
+canonical form, in which ranges are in increasing order, and adjacent
+ranges are merged wherever possible."
+  (when list
+    (setq list 
+          (sort list 'xsdre-range-less-than))
+    (let* ((next (cdr list))
+           (tail list)
+           (head (car list))
+           (first (xsdre-range-first head))
+           (last (xsdre-range-last head)))
+      (while next
+        (setq head (car next))
+        (when (> (xsdre-range-last head) last)
+          (if (<= (xsdre-range-first head) (1+ last))
+              (setq last (xsdre-range-last head))
+            (setcar tail (xsdre-make-range first last))
+            (setcdr tail next)
+            (setq tail next)
+            (setq first (xsdre-range-first head))
+            (setq last (xsdre-range-last head))))
+        (setq next (cdr next)))
+      (setcar tail (xsdre-make-range first last))
+      (setcdr tail nil)
+      list)))
+    
+
+(defun xsdre-range-list-union (range-lists)
+  "Return a range-list the union of a list of range-lists."
+  (xsdre-make-range-list (apply 'append range-lists)))
+
+(defun xsdre-range-list-difference (orig subtract)
+  "Return a range-list for the difference of two range-lists."
+  (when orig
+    (let (new head next first last)
+      (while orig
+        (setq head (car orig))
+        (setq first (xsdre-range-first head))
+        (setq last (xsdre-range-last head))
+        (while (and subtract
+                    (< (xsdre-range-last (car subtract)) first))
+          (setq subtract (cdr subtract)))
+        (while (and subtract
+                    (<= first last)
+                    (<= (xsdre-range-first (car subtract)) last))
+          (when (< first (xsdre-range-first (car subtract)))
+            (setq new
+                  (cons (xsdre-make-range 
+                         first
+                         (1- (xsdre-range-first (car subtract))))
+                        new)))
+          (if (< (xsdre-range-last (car subtract)) last)
+              (progn
+                (setq first (1+ (xsdre-range-last (car subtract))))
+                (setq subtract (cdr subtract)))
+            (setq first (1+ last))))
+        (when (<= first last)
+          (setq new (cons (xsdre-make-range first last) new)))
+        (setq orig (cdr orig)))
+      (nreverse new))))
+
+(defun xsdre-range-less-than (r1 r2)
+  "Return non-nil if range R1 is less than range R2."
+  (or (< (xsdre-range-first r1) (xsdre-range-first r2))
+      (and (= (xsdre-range-first r1) (xsdre-range-first r2))
+           (< (xsdre-range-last r1) (xsdre-range-last r2)))))
+
+(defun xsdre-check-range-list (range-list)
+  "Check that range-list is a range-list.
+Signal an error if it is not."
+  (let ((last nil))
+    (while range-list
+      (unless (consp range-list)
+        (error "Range list not a list"))
+      (let ((head (car range-list)))
+        (unless (or (integerp head)
+                    (and (consp head)
+                         (integerp (car head))
+                         (integerp (cdr head))))
+          (error "Bad range %s" head))
+        (when (and last
+                   (not (< (1+ last) (xsdre-range-first head))))
+          (error "Ranges not strictly increasing"))
+        (setq last (xsdre-range-last head)))
+      (setq range-list (cdr range-list))))
+  t)
+        
+;;; Compiling symbolic regexps to Emacs regexps
+
+(defun xsdre-from-symbolic (re)
+  "Return an Emacs regexp for the symbolic regexp RE."
+  (apply 'concat
+         (nreverse (xsdre-compile-regexp re nil))))
+
+(defun xsdre-compile-regexp (re accum)
+  "Return a Emacs regular expression for the symbolic regexp RE.
+Returns a list of strings whose head is the regexp for RE
+and whose tail is ACCUM."
+  (cond ((not (consp re))
+         (xsdre-compile-char-class re accum))
+        ((eq (car re) 'choice)
+         (setq accum (cons "\\(?:" accum))
+         (let ((choices (cdr re)))
+           (while choices
+             (setq accum
+                   (xsdre-compile-regexp (car choices)
+                                         accum))
+             (setq choices (cdr choices))
+             (when choices
+               (setq accum
+                     (cons "\\|" accum)))))
+         (cons "\\)" accum))
+        ((eq (car re) 'sequence)
+         (let ((members (cdr re)))
+           (while members
+             (setq accum (xsdre-compile-regexp (car members)
+                                               accum))
+             (setq members (cdr members))))
+         accum)
+        ((eq (car re) 'repeat)
+         (let* ((sub (nth 1 re))
+                (lower (nth 2 re))
+                (upper (nth 3 re))
+                (need-paren (and (consp sub)
+                                 (eq (car sub) 'sequence))))
+           (when need-paren
+             (setq accum (cons "\\(?:" accum)))
+           (setq accum
+                 (xsdre-compile-regexp sub accum))
+           (when need-paren
+             (setq accum (cons "\\)" accum)))
+           (cond ((not upper)
+                  (cond ((eq lower 0)
+                         (cons "*" accum))
+                        ((eq lower 1)
+                         (cons "+" accum))
+                        (t
+                         (cons (concat "\\{"
+                                       (number-to-string lower)
+                                       ",\\}")
+                               accum))))
+                 ((eq lower upper)
+                  (cons (concat "\\{"
+                                (number-to-string lower)
+                                "\\}")
+                        accum))
+                 ((and (eq lower 0) (eq upper 1))
+                  (cons "?" accum))
+                 (t
+                  (cons (concat "\\{"
+                                (number-to-string lower)
+                                ","
+                                (number-to-string upper)
+                                "\\}")
+                        accum)))))
+        (t (xsdre-compile-char-class re accum))))
+
+(defun xsdre-compile-char-class (cc accum)
+  "Return a Emacs regular expression for the symbolic character class CC.
+Returns a list of strings whose head is the regexp for CC
+and whose tail is ACCUM."
+  (cons (if (integerp cc)
+            (xsdre-compile-single-char cc)
+          (let ((ranges (xsdre-range-list-mule-intersection
+                         (xsdre-char-class-to-range-list cc))))
+            (cond ((null ranges) "\001-\000")
+                  ((and (null (cdr ranges))
+                        (= (xsdre-range-first (car ranges))
+                           (xsdre-range-last (car ranges))))
+                   (xsdre-compile-single-char
+                    (xsdre-range-first (car ranges))))
+                  (t (xsdre-range-list-to-char-alternative ranges)))))
+        accum))
+              
+(defun xsdre-compile-single-char (ch)
+  (if (memq ch '(?. ?* ?+ ?? ?\[ ?\] ?^ ?$ ?\\))
+      (string ?\\ ch)
+    (string (decode-char 'ucs ch))))
+  
+(defun xsdre-char-class-to-range-list (cc)
+  "Return a range-list for a symbolic char-class."
+  (cond ((integerp cc) (list cc))
+        ((symbolp cc)
+         (or (get cc 'xsdre-ranges)
+             (xsdre-char-class-to-range-list (get cc 'xsdre-char-class))))
+        ((integerp (car cc))
+         (if (= (car cc) (cdr cc))
+             (car cc)
+           cc))
+        ((eq (car cc) 'union)
+         (xsdre-range-list-union (mapcar 'xsdre-char-class-to-range-list
+                                         (cdr cc))))
+        ((eq (car cc) 'difference)
+         (xsdre-range-list-difference
+          (xsdre-char-class-to-range-list (nth 1 cc))
+          (xsdre-char-class-to-range-list (nth 2 cc))))
+        ((eq (car cc) 'range)
+         (list (xsdre-make-range (nth 1 cc) (nth 2 cc))))
+        (t (error "Internal error in XSD regexp compilation: \
+unknown char-class %s" cc))))
+
+(defconst xsdre-mule-char-set-ranges
+  '((0 . 127)
+    (128 . 159)
+    (160 . 255)
+    (#x0100 . #x24ff)
+    (#x2500 . #x33ff)
+    (#xe000 . #xffff))
+  "List of ranges for the Mule character sets containing Unicode characters.")
+
+(defun xsdre-range-list-mule-intersection (range-list)
+  "Return the intersection of RANGE-LIST with the mule-supported ranges.
+Also split ranges so that no range spans more that one mule charset."
+  (when range-list
+    (let* ((char-set-ranges (cdr xsdre-mule-char-set-ranges))
+           (mule-ranges nil)
+           (char-set-first (caar xsdre-mule-char-set-ranges))
+           (char-set-last (cdar xsdre-mule-char-set-ranges))
+           (range (car range-list))
+           (first (xsdre-range-first range))
+           (last (xsdre-range-last range)))
+      (setq range-list (cdr range-list))
+      (while (progn
+               (cond ((> first last)
+                      (if (null range-list)
+                          nil
+                        (setq range (car range-list))
+                        (setq first (xsdre-range-first range))
+                        (setq last (xsdre-range-last range))
+                        (setq range-list (cdr range-list))
+                        t))
+                     ((< char-set-last first)
+                      (if (null char-set-ranges)
+                          nil
+                        (setq char-set-first (caar char-set-ranges))
+                        (setq char-set-last (cdar char-set-ranges))
+                        (setq char-set-ranges (cdr char-set-ranges))
+                        t))
+                     ((< first char-set-first)
+                      (setq first char-set-first))
+                     ;; Now we know that
+                     ;; first <= last
+                     ;; first <= char-set-last
+                     ;; first >= char-set-first
+                     ((<= last char-set-last)
+                      (setq mule-ranges
+                            (cons (xsdre-make-range first last)
+                                  mule-ranges))
+                      (setq first (1+ last))
+                      t)
+                     (t
+                      (setq mule-ranges
+                            (cons (xsdre-make-range first char-set-last)
+                                  mule-ranges))
+                      (setq first (1+ char-set-last))
+                      t))))
+      (nreverse mule-ranges))))
+
+(defun xsdre-range-list-to-char-alternative (range-list)
+  "Return a char alternative for a range-list.
+RANGE-LIST must contain more than integer.
+The char alternative is a string containing an Emacs regexp
+consisting of a single char alternative delimited with []."
+  (let (range caret close-bracket hyphen chars first last)
+    (while range-list
+      (setq range (car range-list))
+      (setq first (xsdre-range-first range))
+      (setq last (xsdre-range-last range))
+      (while (and (cond ((eq first ?^)
+                         (setq caret t)
+                         (setq first (1+ first)))
+                        ((eq first ?-)
+                         (setq hyphen t)
+                         (setq first (1+ first)))
+                        ((eq first ?\])
+                         (setq close-bracket t)
+                         (setq first (1+ first))))
+                  (<= first last)))
+      (when (<= first last)
+        (setq chars
+              (cons first chars))
+        (when (< first last)
+          (setq chars
+                (if (and (eq last (1+ first))
+                         (not (eq last ?-)))
+                    (cons last chars)
+                  (cons last (cons ?- chars))))))
+      (setq range-list (cdr range-list)))
+    (setq chars
+          (mapcar (lambda (c)
+                    (decode-char 'ucs c))
+                  chars))
+    (when caret
+      (setq chars (cons ?^ chars)))
+    (when hyphen
+      (setq chars (cons ?- chars)))
+    (setq chars (cons ?\] chars))
+    (setq chars (nreverse chars))
+    (when close-bracket
+      (setq chars (cons ?\] chars)))
+    (when (equal chars '(?^ ?- ?\]))
+      (setq chars '(?- ?^ ?\])))
+    (setq chars (cons ?\[ chars))
+    (apply 'string chars)))
+      
+;;; Parsing
+
+(defvar xsdre-current-regexp nil
+  "List of characters remaining to be parsed. Dynamically bound.")
+
+(defun xsdre-to-symbolic (str)
+  "Convert a W3C XML Schema datatypes regexp to a symbolic form.
+
+The symbolic form has the following structure:
+
+REGEXP ::=
+  (sequence REGEXP ...)
+  | (choice REGEXP ...)
+  | (repeat REGEXP MIN MAX)
+  | CHAR-CLASS
+
+CHAR-CLASS ::=
+  CHAR
+  | SYMBOLIC-CHAR-CLASS
+  | RANGE
+  | (union CHAR-CLASS ...)
+  | (difference CHAR-CLASS CHAR-CLASS)
+
+RANGE ::= (range LOWER UPPER)
+
+MIN ::= INTEGER
+MAX ::= INTEGER | nil
+CHAR ::= UNICODE
+LOWER ::= UNICODE
+UPPER ::= UNICODE
+SYMBOLIC-CHAR-CLASS ::= SYMBOL
+
+where UNICODE is a integer specifying a Unicode code-point and
+SYMBOLIC-CHAR-CLASS is a symbol which has either a `xsdre-char-class'
+property whose value is a CHAR-CLASS, or a `xsdre-ranges' property
+whose value is a range-list."
+  (let ((xsdre-current-regexp (string-to-list str)))
+    (condition-case err
+        (let ((symbolic (xsdre-parse-regexp)))
+          (if xsdre-current-regexp
+              (xsdre-parse-error "Unexpected %c" (car xsdre-current-regexp))
+            symbolic))
+      (xsdre-parse-error
+       (signal 'xsdre-invalid-regexp
+               (list (apply 'format (cdr err))
+                     (- (length str)
+                        (length xsdre-current-regexp))))))))
+
+(put 'xsdre-invalid-regexp
+     'error-conditions
+     '(error xsdre-invalid-regexp))
+
+(put 'xsdre-invalid-regexp
+     'error-message
+     "Invalid W3C XML Schema Datatypes regular expression")
+
+(defun xsdre-parse-regexp ()
+  (let ((branches nil))
+    (while (progn
+             (setq branches (cons (xsdre-parse-branch) branches))
+             (when (eq (car xsdre-current-regexp) ?|)
+               (xsdre-advance)
+               t)))
+    (if (null (cdr branches))
+        (car branches)
+      (cons 'choice (nreverse branches)))))
+
+(defun xsdre-parse-branch ()
+  (let (items)
+    (while (let ((item (xsdre-try-parse-atom)))
+             (when item
+               (let ((quantifier (xsdre-try-parse-quantifier)))
+                 (when quantifier
+                   (setq item
+                         (list 'repeat
+                               item
+                               (car quantifier)
+                               (cdr quantifier)))))
+               (setq items (cons item items)))))
+    (cond ((null items) '(sequence))
+          ((null (cdr items)) (car items))
+          (t (cons 'sequence (nreverse items))))))
+
+(defun xsdre-try-parse-quantifier ()
+  (let ((ch (car xsdre-current-regexp)))
+    (cond ((eq ch ?*) (xsdre-advance) '(0 . nil))
+          ((eq ch ?+) (xsdre-advance) '(1 . nil))
+          ((eq ch ??) (xsdre-advance) '(0 . 1))
+          ((eq ch ?{)
+           (xsdre-advance)
+           (let ((lower (xsdre-parse-bound)))
+             (setq ch (car xsdre-current-regexp))
+             (cond ((eq ch ?})
+                    (xsdre-advance)
+                    (cons lower lower))
+                   ((eq ch ?,)
+                    (xsdre-advance)
+                    (cond ((eq (car xsdre-current-regexp) ?})
+                           (xsdre-advance)
+                           (cons lower nil))
+                          (t
+                           (let ((upper (xsdre-parse-bound)))
+                             (xsdre-expect ?})
+                             (cons lower upper)))))
+                   (t (xsdre-parse-error "Expected , or }")))))
+          (t nil))))
+                        
+(defun xsdre-parse-bound ()
+  (let ((n 0))
+    (while (progn
+             (let* ((ch (car xsdre-current-regexp))
+                    (digit (memq ch '(?9 ?8 ?7 ?6 ?5 ?4 ?3 ?2 ?1 ?0))))
+               (unless digit
+                 (xsdre-parse-error "Expected a digit"))
+               (setq n (+ (* n 10)
+                          (length (cdr digit)))))
+             (xsdre-advance)
+             (not (memq (car xsdre-current-regexp) '(?} ?,)))))
+    n))
+        
+
+(defun xsdre-try-parse-atom ()
+  (let ((ch (car xsdre-current-regexp)))
+    (cond  ((memq ch '(nil ?? ?* ?+ ?\) ?\{ ?\} ?| ?\])) nil)
+           ((eq ch ?\\)
+            (xsdre-advance)
+            (xsdre-parse-escape))
+           ((eq ch ?\()
+            (xsdre-advance)
+            (let ((ret (xsdre-parse-regexp)))
+              (xsdre-expect ?\))
+              ret))
+           ((eq ch ?\[)
+            (xsdre-parse-char-class))
+           ((eq ch ?.)
+            (xsdre-advance)
+            'dot)
+           (t
+            (let ((uc (encode-char ch 'ucs)))
+              (unless uc
+                (xsdre-parse-error "%c is not a Unicode character" ch))
+              (xsdre-advance) uc)))))
+
+(defun xsdre-parse-char-class ()
+  (xsdre-advance)
+  (let (compl members ret)
+    (when (eq (car xsdre-current-regexp) ?^)
+      (setq compl t)
+      (xsdre-advance))
+    (while (let ((member (xsdre-parse-char-class-member))
+                 uc1 uc2)
+             (cond ((eq (car xsdre-current-regexp) ?\-)
+                    (xsdre-advance)
+                    (cond ((eq (car xsdre-current-regexp) ?\[)
+                           (setq members (cons member members))
+                           nil)
+                          ((not (integerp member))
+                           (xsdre-parse-error "Lower bound is not a single character"))
+                          ((not (setq uc1
+                                      (encode-char member 'ucs)))
+                           (xsdre-parse-error "Lower bound %c is not a Unicode character"
+                                  member))
+                          (t
+                           (let ((upper (xsdre-parse-char-class-member)))
+                             (unless (integerp upper)
+                               (xsdre-parse-error "Upper bound is not a single character"))
+                             (unless (setq uc2
+                                           (encode-char upper 'ucs))
+                               (xsdre-parse-error "Upper bound %c is not a Unicode character" upper))
+                             (setq members
+                                   (cons (list 'range uc1 uc2)
+                                         members)))
+                           (not (eq (car xsdre-current-regexp) ?\])))))
+                   (t (setq members (cons member members))
+                      (not (eq (car xsdre-current-regexp) ?\]))))))
+    (setq members (nreverse members))
+    (if (null (cdr members))
+        (setq ret (car members))
+      (setq ret (cons 'union members)))
+    (when compl
+      (setq ret (list 'difference 'any ret)))
+    (when (eq (car xsdre-current-regexp) ?\[)
+      (setq ret
+            (list 'difference ret (xsdre-parse-char-class))))
+    (xsdre-expect ?\])
+    ret))
+
+(defun xsdre-parse-char-class-member ()
+  (let ((ch (car xsdre-current-regexp)))
+    (cond ((null ch)
+           (xsdre-parse-error "Expected ]"))
+          ((eq ch ?\\)
+           (xsdre-advance)
+           (xsdre-parse-escape))
+          ((memq ch '(?\[ ?\] ?-))
+           (xsdre-parse-error "%c must be quoted in a character class" ch))
+          (t (xsdre-advance) ch))))
+
+(defconst xsdre-single-escape
+  '((?s . space)
+    (?i . name-initial)
+    (?c . name-continue)
+    (?d . digit)
+    (?w . word)))
+
+(defun xsdre-parse-escape ()
+  (let ((ch (car xsdre-current-regexp)))
+    (xsdre-advance)
+    (cond ((memq ch '(?\\ ?| ?. ?- ?^ ?* ?+ ?( ?) ?{ ?} ?[ ?])) ch)
+          ((eq ch ?r) ?\r)
+          ((eq ch ?n) ?\n)
+          ((eq ch ?t) ?\t)
+          ((cdr (assq ch xsdre-single-escape)))
+          ((let ((positive
+                  (cdr (assq (downcase ch) xsdre-single-escape))))
+             (and positive
+                  (list 'difference 'any positive))))
+          ((eq ch ?p) (xsdre-parse-prop))
+          ((eq ch ?P) (list 'difference 'any (xsdre-parse-prop)))
+          (t (if ch
+                 (xsdre-parse-error "Missing char after \\")
+               (xsdre-parse-error "Bad escape %c" ch))))))
+        
+(defun xsdre-parse-prop ()
+  (xsdre-expect ?{)
+  (let ((name nil))
+    (while (not (eq (car xsdre-current-regexp) ?\}))
+      (unless xsdre-current-regexp
+        (xsdre-parse-error "Expected ?"))
+      (setq name (cons (car xsdre-current-regexp)
+                       name))
+      (xsdre-advance))
+    (xsdre-advance)
+    (setq name (nreverse name))
+    (cond ((null name) (xsdre-parse-error "Empty property name"))
+          ((null (cdr name))
+           (let ((category (intern (string (car name)))))
+             (unless (get category 'xsdre-unicode-category)
+               (xsdre-parse-error "%s is not a category" category))
+             category))
+          ((null (cddr name))
+           (let ((category (intern (string (car name) (cadr name)))))
+             (unless (get category 'xsdre-unicode-category)
+               (xsdre-parse-error "%s is not a category" category))
+             category))
+          ((not (and (eq (car name) ?I)
+                     (eq (cadr name) ?s)))
+           (xsdre-parse-error "Block name does not start with Is"))
+          (t
+           (let ((block (intern (apply 'string (cddr name)))))
+             (unless (get block 'xsdre-unicode-block)
+               (xsdre-parse-error "%s is not a block name" block))
+             block)))))
+
+(defun xsdre-expect (ch)
+  (if (eq (car xsdre-current-regexp) ch)
+      (xsdre-advance)
+    (xsdre-parse-error "Expected %c" ch)))
+    
+(defun xsdre-advance ()
+  (setq xsdre-current-regexp
+        (cdr xsdre-current-regexp)))
+
+(defun xsdre-parse-error (&rest args)
+  (signal 'xsdre-parse-error args))
+
+;; This error condition is used only internally.
+
+(put 'xsdre-parse-error
+     'error-conditions
+     '(error xsdre-parse-error))
+
+(put 'xsdre-parse-error
+     'error-message
+     "Internal error in parsing XSD regexp")
+     
+;;; Character class data
+
+(put 'dot 'xsdre-char-class '(difference any (union #xA #xD)))
+(put 'digit 'xsdre-char-class 'Nd)
+(put 'word 'xsdre-char-class '(difference any (union P Z C)))
+(put 'space 'xsdre-char-class '(union #x9 #xA #xD #x20))
+(put 'any 'xsdre-ranges '((#x0 . #x10FFFF)))
+
+(defconst xsdre-gen-categories
+  '(Lu Ll Lt Lm Lo Mn Mc Me Nd Nl No Pc Pd
+       Ps Pe Pi Pf Po Zs Zl Zp Sm Sc Sk So Cc Cf Co))
+
+(defun xsdre-gen-categories (file)
+  "Use a UnicodeData file to generate code to initialize Unicode categories.
+Code is inserted into the current buffer."
+  (interactive "fUnicodeData file: ")
+  (save-excursion
+    (set-buffer (find-file-noselect file))
+    (goto-char (point-min))
+    (mapcar (lambda (x) (put x 'xsdre-ranges nil)) xsdre-gen-categories)
+    (while (re-search-forward "^\\([0-9A-Fa-f]*\\);[^;]*;\\([A-Z][a-z]\\);"
+                              nil
+                              t)
+      (let* ((sym (intern (match-string-no-properties 2)))
+             (code (string-to-number (match-string-no-properties 1)
+                                     16))
+             (ranges (get sym 'xsdre-ranges))
+             (last-range (car ranges))
+             (forced-range (string= (buffer-substring-no-properties
+                                     (- (match-beginning 2) 6)
+                                     (1- (match-beginning 2)))
+                                    "Last>")))
+        (cond ((and (integerp last-range)
+                    (or forced-range
+                        (eq code (1+ last-range))))
+               (put sym
+                    'xsdre-ranges
+                    (cons (cons last-range code)
+                          (cdr ranges))))
+              ((and (consp last-range)
+                    (or forced-range
+                        (eq code (1+ (cdr last-range)))))
+               (put sym
+                    'xsdre-ranges
+                    (cons (cons (car last-range) code)
+                          (cdr ranges))))
+              (t
+               (put sym 'xsdre-ranges (cons code ranges))))))
+    (mapcar (lambda (x)
+              (put x
+                   'xsdre-ranges
+                   (nreverse (get x 'xsdre-ranges)))
+              nil)
+            xsdre-gen-categories))
+  (mapcar (lambda (x)
+            (let ((start (point)))
+              (pp (list 'xsdre-def-primitive-category
+                        (list 'quote x)
+                        (list 'quote (get x 'xsdre-ranges)))
+                  (current-buffer))
+              (save-excursion
+                (goto-char start)
+                (down-list 2)
+                (while (condition-case err
+                           (progn 
+                             (forward-sexp)
+                             t)
+                         (error nil))
+                  (when (and (< 70 (current-column))
+                             (not (looking-at ")")))
+                    (insert "\n")
+                    (lisp-indent-line))))))
+          xsdre-gen-categories))
+
+(defun xsdre-def-primitive-category (sym ranges)
+  (put sym 'xsdre-ranges ranges)
+  (put sym 'xsdre-unicode-category t))
+
+;;; Blocks
+
+(defun xsdre-def-block (sym ranges)
+  (put sym 'xsdre-ranges ranges)
+  (put sym 'xsdre-unicode-block t))
+
+(xsdre-def-block 'BasicLatin '((#x0000 . #x007F)))
+(xsdre-def-block 'Latin-1Supplement '((#x0080 . #x00FF)))
+(xsdre-def-block 'LatinExtended-A '((#x0100 . #x017F)))
+(xsdre-def-block 'LatinExtended-B '((#x0180 . #x024F)))
+(xsdre-def-block 'IPAExtensions '((#x0250 . #x02AF)))
+(xsdre-def-block 'SpacingModifierLetters '((#x02B0 . #x02FF)))
+(xsdre-def-block 'CombiningDiacriticalMarks '((#x0300 . #x036F)))
+(xsdre-def-block 'Greek '((#x0370 . #x03FF)))
+(xsdre-def-block 'Cyrillic '((#x0400 . #x04FF)))
+(xsdre-def-block 'Armenian '((#x0530 . #x058F)))
+(xsdre-def-block 'Hebrew '((#x0590 . #x05FF)))
+(xsdre-def-block 'Arabic '((#x0600 . #x06FF)))
+(xsdre-def-block 'Syriac '((#x0700 . #x074F)))
+(xsdre-def-block 'Thaana '((#x0780 . #x07BF)))
+(xsdre-def-block 'Devanagari '((#x0900 . #x097F)))
+(xsdre-def-block 'Bengali '((#x0980 . #x09FF)))
+(xsdre-def-block 'Gurmukhi '((#x0A00 . #x0A7F)))
+(xsdre-def-block 'Gujarati '((#x0A80 . #x0AFF)))
+(xsdre-def-block 'Oriya '((#x0B00 . #x0B7F)))
+(xsdre-def-block 'Tamil '((#x0B80 . #x0BFF)))
+(xsdre-def-block 'Telugu '((#x0C00 . #x0C7F)))
+(xsdre-def-block 'Kannada '((#x0C80 . #x0CFF)))
+(xsdre-def-block 'Malayalam '((#x0D00 . #x0D7F)))
+(xsdre-def-block 'Sinhala '((#x0D80 . #x0DFF)))
+(xsdre-def-block 'Thai '((#x0E00 . #x0E7F)))
+(xsdre-def-block 'Lao '((#x0E80 . #x0EFF)))
+(xsdre-def-block 'Tibetan '((#x0F00 . #x0FFF)))
+(xsdre-def-block 'Myanmar '((#x1000 . #x109F)))
+(xsdre-def-block 'Georgian '((#x10A0 . #x10FF)))
+(xsdre-def-block 'HangulJamo '((#x1100 . #x11FF)))
+(xsdre-def-block 'Ethiopic '((#x1200 . #x137F)))
+(xsdre-def-block 'Cherokee '((#x13A0 . #x13FF)))
+(xsdre-def-block 'UnifiedCanadianAboriginalSyllabics '((#x1400 . #x167F)))
+(xsdre-def-block 'Ogham '((#x1680 . #x169F)))
+(xsdre-def-block 'Runic '((#x16A0 . #x16FF)))
+(xsdre-def-block 'Khmer '((#x1780 . #x17FF)))
+(xsdre-def-block 'Mongolian '((#x1800 . #x18AF)))
+(xsdre-def-block 'LatinExtendedAdditional '((#x1E00 . #x1EFF)))
+(xsdre-def-block 'GreekExtended '((#x1F00 . #x1FFF)))
+(xsdre-def-block 'GeneralPunctuation '((#x2000 . #x206F)))
+(xsdre-def-block 'SuperscriptsandSubscripts '((#x2070 . #x209F)))
+(xsdre-def-block 'CurrencySymbols '((#x20A0 . #x20CF)))
+(xsdre-def-block 'CombiningMarksforSymbols '((#x20D0 . #x20FF)))
+(xsdre-def-block 'LetterlikeSymbols '((#x2100 . #x214F)))
+(xsdre-def-block 'NumberForms '((#x2150 . #x218F)))
+(xsdre-def-block 'Arrows '((#x2190 . #x21FF)))
+(xsdre-def-block 'MathematicalOperators '((#x2200 . #x22FF)))
+(xsdre-def-block 'MiscellaneousTechnical '((#x2300 . #x23FF)))
+(xsdre-def-block 'ControlPictures '((#x2400 . #x243F)))
+(xsdre-def-block 'OpticalCharacterRecognition '((#x2440 . #x245F)))
+(xsdre-def-block 'EnclosedAlphanumerics '((#x2460 . #x24FF)))
+(xsdre-def-block 'BoxDrawing '((#x2500 . #x257F)))
+(xsdre-def-block 'BlockElements '((#x2580 . #x259F)))
+(xsdre-def-block 'GeometricShapes '((#x25A0 . #x25FF)))
+(xsdre-def-block 'MiscellaneousSymbols '((#x2600 . #x26FF)))
+(xsdre-def-block 'Dingbats '((#x2700 . #x27BF)))
+(xsdre-def-block 'BraillePatterns '((#x2800 . #x28FF)))
+(xsdre-def-block 'CJKRadicalsSupplement '((#x2E80 . #x2EFF)))
+(xsdre-def-block 'KangxiRadicals '((#x2F00 . #x2FDF)))
+(xsdre-def-block 'IdeographicDescriptionCharacters '((#x2FF0 . #x2FFF)))
+(xsdre-def-block 'CJKSymbolsandPunctuation '((#x3000 . #x303F)))
+(xsdre-def-block 'Hiragana '((#x3040 . #x309F)))
+(xsdre-def-block 'Katakana '((#x30A0 . #x30FF)))
+(xsdre-def-block 'Bopomofo '((#x3100 . #x312F)))
+(xsdre-def-block 'HangulCompatibilityJamo '((#x3130 . #x318F)))
+(xsdre-def-block 'Kanbun '((#x3190 . #x319F)))
+(xsdre-def-block 'BopomofoExtended '((#x31A0 . #x31BF)))
+(xsdre-def-block 'EnclosedCJKLettersandMonths '((#x3200 . #x32FF)))
+(xsdre-def-block 'CJKCompatibility '((#x3300 . #x33FF)))
+(xsdre-def-block 'CJKUnifiedIdeographsExtensionA '((#x3400 . #x4DB5)))
+(xsdre-def-block 'CJKUnifiedIdeographs '((#x4E00 . #x9FFF)))
+(xsdre-def-block 'YiSyllables '((#xA000 . #xA48F)))
+(xsdre-def-block 'YiRadicals '((#xA490 . #xA4CF)))
+(xsdre-def-block 'HangulSyllables '((#xAC00 . #xD7A3)))
+;;(xsdre-def-block 'HighSurrogates '((#xD800 . #xDB7F)))
+;;(xsdre-def-block 'HighPrivateUseSurrogates '((#xDB80 . #xDBFF)))
+;;(xsdre-def-block 'LowSurrogates '((#xDC00 . #xDFFF)))
+(xsdre-def-block 'CJKCompatibilityIdeographs '((#xF900 . #xFAFF)))
+(xsdre-def-block 'AlphabeticPresentationForms '((#xFB00 . #xFB4F)))
+(xsdre-def-block 'ArabicPresentationForms-A '((#xFB50 . #xFDFF)))
+(xsdre-def-block 'CombiningHalfMarks '((#xFE20 . #xFE2F)))
+(xsdre-def-block 'CJKCompatibilityForms '((#xFE30 . #xFE4F)))
+(xsdre-def-block 'SmallFormVariants '((#xFE50 . #xFE6F)))
+(xsdre-def-block 'ArabicPresentationForms-B '((#xFE70 . #xFEFE)))
+(xsdre-def-block 'Specials '((#xFEFF . #xFEFF)))
+(xsdre-def-block 'HalfwidthandFullwidthForms '((#xFF00 . #xFFEF)))
+(xsdre-def-block 'Specials '((#xFFF0 . #xFFFD)))
+(xsdre-def-block 'OldItalic '((#x10300 . #x1032F)))
+(xsdre-def-block 'Gothic '((#x10330 . #x1034F)))
+(xsdre-def-block 'Deseret '((#x10400 . #x1044F)))
+(xsdre-def-block 'ByzantineMusicalSymbols '((#x1D000 . #x1D0FF)))
+(xsdre-def-block 'MusicalSymbols '((#x1D100 . #x1D1FF)))
+(xsdre-def-block 'MathematicalAlphanumericSymbols '((#x1D400 . #x1D7FF)))
+(xsdre-def-block 'CJKUnifiedIdeographsExtensionB '((#x20000 . #x2A6D6)))
+(xsdre-def-block 'CJKCompatibilityIdeographsSupplement '((#x2F800 . #x2FA1F)))
+(xsdre-def-block 'Tags '((#xE0000 . #xE007F)))
+(xsdre-def-block 'PrivateUse '((#xE000 . #xF8FF)
+                               (#xF0000 . #xFFFFD)
+                               (#x100000 . #x10FFFD)))
+
+;;; Categories
+
+;;; Derived categories
+
+(defun xsdre-def-derived-category (sym char-class)
+  (put sym 'xsdre-char-class char-class)
+  (put sym 'xsdre-unicode-category t))
+
+(xsdre-def-derived-category 'L '(union Lu Ll Lt Lm Lo))
+(xsdre-def-derived-category 'M '(union Mn Mc Me))
+(xsdre-def-derived-category 'N '(union Nd Nl No))
+(xsdre-def-derived-category 'P '(union Pc Pd Ps Pe Pi Pf Po))
+(xsdre-def-derived-category 'Z '(union Zs Zl Zp))
+(xsdre-def-derived-category 'S '(union Sm Sc Sk So))
+(xsdre-def-derived-category 'C '(union Cc Cf Co Cn))
+(xsdre-def-derived-category 'Cn '(difference any
+                                             (union L M N P Z S Cc Cf Co)))
+
+(xsdre-def-primitive-category
+ 'name-initial
+ '(#x003a
+   (#x0041 . #x005a)
+   #x005f
+   (#x0061 . #x007a)
+   (#x00c0 . #x00d6)
+   (#x00d8 . #x00f6)
+   (#x00f8 . #x0131)
+   (#x0134 . #x013e)
+   (#x0141 . #x0148)
+   (#x014a . #x017e)
+   (#x0180 . #x01c3)
+   (#x01cd . #x01f0)
+   (#x01f4 . #x01f5)
+   (#x01fa . #x0217)
+   (#x0250 . #x02a8)
+   (#x02bb . #x02c1)
+   #x0386
+   (#x0388 . #x038a)
+   #x038c
+   (#x038e . #x03a1)
+   (#x03a3 . #x03ce)
+   (#x03d0 . #x03d6)
+   #x03da
+   #x03dc
+   #x03de
+   #x03e0
+   (#x03e2 . #x03f3)
+   (#x0401 . #x040c)
+   (#x040e . #x044f)
+   (#x0451 . #x045c)
+   (#x045e . #x0481)
+   (#x0490 . #x04c4)
+   (#x04c7 . #x04c8)
+   (#x04cb . #x04cc)
+   (#x04d0 . #x04eb)
+   (#x04ee . #x04f5)
+   (#x04f8 . #x04f9)
+   (#x0531 . #x0556)
+   #x0559
+   (#x0561 . #x0586)
+   (#x05d0 . #x05ea)
+   (#x05f0 . #x05f2)
+   (#x0621 . #x063a)
+   (#x0641 . #x064a)
+   (#x0671 . #x06b7)
+   (#x06ba . #x06be)
+   (#x06c0 . #x06ce)
+   (#x06d0 . #x06d3)
+   #x06d5
+   (#x06e5 . #x06e6)
+   (#x0905 . #x0939)
+   #x093d
+   (#x0958 . #x0961)
+   (#x0985 . #x098c)
+   (#x098f . #x0990)
+   (#x0993 . #x09a8)
+   (#x09aa . #x09b0)
+   #x09b2
+   (#x09b6 . #x09b9)
+   (#x09dc . #x09dd)
+   (#x09df . #x09e1)
+   (#x09f0 . #x09f1)
+   (#x0a05 . #x0a0a)
+   (#x0a0f . #x0a10)
+   (#x0a13 . #x0a28)
+   (#x0a2a . #x0a30)
+   (#x0a32 . #x0a33)
+   (#x0a35 . #x0a36)
+   (#x0a38 . #x0a39)
+   (#x0a59 . #x0a5c)
+   #x0a5e
+   (#x0a72 . #x0a74)
+   (#x0a85 . #x0a8b)
+   #x0a8d
+   (#x0a8f . #x0a91)
+   (#x0a93 . #x0aa8)
+   (#x0aaa . #x0ab0)
+   (#x0ab2 . #x0ab3)
+   (#x0ab5 . #x0ab9)
+   #x0abd
+   #x0ae0
+   (#x0b05 . #x0b0c)
+   (#x0b0f . #x0b10)
+   (#x0b13 . #x0b28)
+   (#x0b2a . #x0b30)
+   (#x0b32 . #x0b33)
+   (#x0b36 . #x0b39)
+   #x0b3d
+   (#x0b5c . #x0b5d)
+   (#x0b5f . #x0b61)
+   (#x0b85 . #x0b8a)
+   (#x0b8e . #x0b90)
+   (#x0b92 . #x0b95)
+   (#x0b99 . #x0b9a)
+   #x0b9c
+   (#x0b9e . #x0b9f)
+   (#x0ba3 . #x0ba4)
+   (#x0ba8 . #x0baa)
+   (#x0bae . #x0bb5)
+   (#x0bb7 . #x0bb9)
+   (#x0c05 . #x0c0c)
+   (#x0c0e . #x0c10)
+   (#x0c12 . #x0c28)
+   (#x0c2a . #x0c33)
+   (#x0c35 . #x0c39)
+   (#x0c60 . #x0c61)
+   (#x0c85 . #x0c8c)
+   (#x0c8e . #x0c90)
+   (#x0c92 . #x0ca8)
+   (#x0caa . #x0cb3)
+   (#x0cb5 . #x0cb9)
+   #x0cde
+   (#x0ce0 . #x0ce1)
+   (#x0d05 . #x0d0c)
+   (#x0d0e . #x0d10)
+   (#x0d12 . #x0d28)
+   (#x0d2a . #x0d39)
+   (#x0d60 . #x0d61)
+   (#x0e01 . #x0e2e)
+   #x0e30
+   (#x0e32 . #x0e33)
+   (#x0e40 . #x0e45)
+   (#x0e81 . #x0e82)
+   #x0e84
+   (#x0e87 . #x0e88)
+   #x0e8a
+   #x0e8d
+   (#x0e94 . #x0e97)
+   (#x0e99 . #x0e9f)
+   (#x0ea1 . #x0ea3)
+   #x0ea5
+   #x0ea7
+   (#x0eaa . #x0eab)
+   (#x0ead . #x0eae)
+   #x0eb0
+   (#x0eb2 . #x0eb3)
+   #x0ebd
+   (#x0ec0 . #x0ec4)
+   (#x0f40 . #x0f47)
+   (#x0f49 . #x0f69)
+   (#x10a0 . #x10c5)
+   (#x10d0 . #x10f6)
+   #x1100
+   (#x1102 . #x1103)
+   (#x1105 . #x1107)
+   #x1109
+   (#x110b . #x110c)
+   (#x110e . #x1112)
+   #x113c
+   #x113e
+   #x1140
+   #x114c
+   #x114e
+   #x1150
+   (#x1154 . #x1155)
+   #x1159
+   (#x115f . #x1161)
+   #x1163
+   #x1165
+   #x1167
+   #x1169
+   (#x116d . #x116e)
+   (#x1172 . #x1173)
+   #x1175
+   #x119e
+   #x11a8
+   #x11ab
+   (#x11ae . #x11af)
+   (#x11b7 . #x11b8)
+   #x11ba
+   (#x11bc . #x11c2)
+   #x11eb
+   #x11f0
+   #x11f9
+   (#x1e00 . #x1e9b)
+   (#x1ea0 . #x1ef9)
+   (#x1f00 . #x1f15)
+   (#x1f18 . #x1f1d)
+   (#x1f20 . #x1f45)
+   (#x1f48 . #x1f4d)
+   (#x1f50 . #x1f57)
+   #x1f59
+   #x1f5b
+   #x1f5d
+   (#x1f5f . #x1f7d)
+   (#x1f80 . #x1fb4)
+   (#x1fb6 . #x1fbc)
+   #x1fbe
+   (#x1fc2 . #x1fc4)
+   (#x1fc6 . #x1fcc)
+   (#x1fd0 . #x1fd3)
+   (#x1fd6 . #x1fdb)
+   (#x1fe0 . #x1fec)
+   (#x1ff2 . #x1ff4)
+   (#x1ff6 . #x1ffc)
+   #x2126
+   (#x212a . #x212b)
+   #x212e
+   (#x2180 . #x2182)
+   #x3007
+   (#x3021 . #x3029)
+   (#x3041 . #x3094)
+   (#x30a1 . #x30fa)
+   (#x3105 . #x312c)
+   (#x4e00 . #x9fa5)
+   (#xac00 . #xd7a3)))
+
+(xsdre-def-derived-category 'name-continue '(union name-initial
+                                                   name-continue-not-initial))
+                          
+(xsdre-def-primitive-category 
+ 'name-continue-not-initial
+ '((#x002d . #x002e)
+   (#x0030 . #x0039)
+   #x00b7
+   (#x02d0 . #x02d1)
+   (#x0300 . #x0345)
+   (#x0360 . #x0361)
+   #x0387
+   (#x0483 . #x0486)
+   (#x0591 . #x05a1)
+   (#x05a3 . #x05b9)
+   (#x05bb . #x05bd)
+   #x05bf
+   (#x05c1 . #x05c2)
+   #x05c4
+   #x0640
+   (#x064b . #x0652)
+   (#x0660 . #x0669)
+   #x0670
+   (#x06d6 . #x06dc)
+   (#x06dd . #x06df)
+   (#x06e0 . #x06e4)
+   (#x06e7 . #x06e8)
+   (#x06ea . #x06ed)
+   (#x06f0 . #x06f9)
+   (#x0901 . #x0903)
+   #x093c
+   (#x093e . #x094c)
+   #x094d
+   (#x0951 . #x0954)
+   (#x0962 . #x0963)
+   (#x0966 . #x096f)
+   (#x0981 . #x0983)
+   #x09bc
+   (#x09be . #x09bf)
+   (#x09c0 . #x09c4)
+   (#x09c7 . #x09c8)
+   (#x09cb . #x09cd)
+   #x09d7
+   (#x09e2 . #x09e3)
+   (#x09e6 . #x09ef)
+   #x0a02
+   #x0a3c
+   (#x0a3e . #x0a42)
+   (#x0a47 . #x0a48)
+   (#x0a4b . #x0a4d)
+   (#x0a66 . #x0a6f)
+   (#x0a70 . #x0a71)
+   (#x0a81 . #x0a83)
+   #x0abc
+   (#x0abe . #x0ac5)
+   (#x0ac7 . #x0ac9)
+   (#x0acb . #x0acd)
+   (#x0ae6 . #x0aef)
+   (#x0b01 . #x0b03)
+   #x0b3c
+   (#x0b3e . #x0b43)
+   (#x0b47 . #x0b48)
+   (#x0b4b . #x0b4d)
+   (#x0b56 . #x0b57)
+   (#x0b66 . #x0b6f)
+   (#x0b82 . #x0b83)
+   (#x0bbe . #x0bc2)
+   (#x0bc6 . #x0bc8)
+   (#x0bca . #x0bcd)
+   #x0bd7
+   (#x0be7 . #x0bef)
+   (#x0c01 . #x0c03)
+   (#x0c3e . #x0c44)
+   (#x0c46 . #x0c48)
+   (#x0c4a . #x0c4d)
+   (#x0c55 . #x0c56)
+   (#x0c66 . #x0c6f)
+   (#x0c82 . #x0c83)
+   (#x0cbe . #x0cc4)
+   (#x0cc6 . #x0cc8)
+   (#x0cca . #x0ccd)
+   (#x0cd5 . #x0cd6)
+   (#x0ce6 . #x0cef)
+   (#x0d02 . #x0d03)
+   (#x0d3e . #x0d43)
+   (#x0d46 . #x0d48)
+   (#x0d4a . #x0d4d)
+   #x0d57
+   (#x0d66 . #x0d6f)
+   #x0e31
+   (#x0e34 . #x0e3a)
+   (#x0e46 . #x0e4e)
+   (#x0e50 . #x0e59)
+   #x0eb1
+   (#x0eb4 . #x0eb9)
+   (#x0ebb . #x0ebc)
+   #x0ec6
+   (#x0ec8 . #x0ecd)
+   (#x0ed0 . #x0ed9)
+   (#x0f18 . #x0f19)
+   (#x0f20 . #x0f29)
+   #x0f35
+   #x0f37
+   #x0f39
+   (#x0f3e . #x0f3f)
+   (#x0f71 . #x0f84)
+   (#x0f86 . #x0f8b)
+   (#x0f90 . #x0f95)
+   #x0f97
+   (#x0f99 . #x0fad)
+   (#x0fb1 . #x0fb7)
+   #x0fb9
+   (#x20d0 . #x20dc)
+   #x20e1
+   #x3005
+   (#x302a . #x302f)
+   (#x3031 . #x3035)
+   #x3099
+   #x309a
+   (#x309d . #x309e)
+   (#x30fc . #x30fe)))
+
+;;; Auto-generated section.
+
+;; The rest of the file was auto-generated by doing M-x xsdre-gen-categories
+;; on UnicodeData-3.1.0.txt available from
+;; http://www.unicode.org/Public/3.1-Update/UnicodeData-3.1.0.txt
+
+(xsdre-def-primitive-category 'Lu
+                              '((65 . 90)
+                                (192 . 214)
+                                (216 . 222)
+                                256 258 260 262 264 266 268 270 272 274 276
+                                278 280 282 284 286 288 290 292 294 296 298
+                                300 302 304 306 308 310 313 315 317 319 321
+                                323 325 327 330 332 334 336 338 340 342 344
+                                346 348 350 352 354 356 358 360 362 364 366
+                                368 370 372 374
+                                (376 . 377)
+                                379 381
+                                (385 . 386)
+                                388
+                                (390 . 391)
+                                (393 . 395)
+                                (398 . 401)
+                                (403 . 404)
+                                (406 . 408)
+                                (412 . 413)
+                                (415 . 416)
+                                418 420
+                                (422 . 423)
+                                425 428
+                                (430 . 431)
+                                (433 . 435)
+                                437
+                                (439 . 440)
+                                444 452 455 458 461 463 465 467 469 471 473
+                                475 478 480 482 484 486 488 490 492 494 497
+                                500
+                                (502 . 504)
+                                506 508 510 512 514 516 518 520 522 524 526
+                                528 530 532 534 536 538 540 542 546 548 550
+                                552 554 556 558 560 562 902
+                                (904 . 906)
+                                908
+                                (910 . 911)
+                                (913 . 929)
+                                (931 . 939)
+                                (978 . 980)
+                                986 988 990 992 994 996 998 1000 1002 1004
+                                1006 1012
+                                (1024 . 1071)
+                                1120 1122 1124 1126 1128 1130 1132 1134 1136
+                                1138 1140 1142 1144 1146 1148 1150 1152 1164
+                                1166 1168 1170 1172 1174 1176 1178 1180 1182
+                                1184 1186 1188 1190 1192 1194 1196 1198 1200
+                                1202 1204 1206 1208 1210 1212 1214
+                                (1216 . 1217)
+                                1219 1223 1227 1232 1234 1236 1238 1240 1242
+                                1244 1246 1248 1250 1252 1254 1256 1258 1260
+                                1262 1264 1266 1268 1272
+                                (1329 . 1366)
+                                (4256 . 4293)
+                                7680 7682 7684 7686 7688 7690 7692 7694 7696
+                                7698 7700 7702 7704 7706 7708 7710 7712 7714
+                                7716 7718 7720 7722 7724 7726 7728 7730 7732
+                                7734 7736 7738 7740 7742 7744 7746 7748 7750
+                                7752 7754 7756 7758 7760 7762 7764 7766 7768
+                                7770 7772 7774 7776 7778 7780 7782 7784 7786
+                                7788 7790 7792 7794 7796 7798 7800 7802 7804
+                                7806 7808 7810 7812 7814 7816 7818 7820 7822
+                                7824 7826 7828 7840 7842 7844 7846 7848 7850
+                                7852 7854 7856 7858 7860 7862 7864 7866 7868
+                                7870 7872 7874 7876 7878 7880 7882 7884 7886
+                                7888 7890 7892 7894 7896 7898 7900 7902 7904
+                                7906 7908 7910 7912 7914 7916 7918 7920 7922
+                                7924 7926 7928
+                                (7944 . 7951)
+                                (7960 . 7965)
+                                (7976 . 7983)
+                                (7992 . 7999)
+                                (8008 . 8013)
+                                8025 8027 8029 8031
+                                (8040 . 8047)
+                                (8120 . 8123)
+                                (8136 . 8139)
+                                (8152 . 8155)
+                                (8168 . 8172)
+                                (8184 . 8187)
+                                8450 8455
+                                (8459 . 8461)
+                                (8464 . 8466)
+                                8469
+                                (8473 . 8477)
+                                8484 8486 8488
+                                (8490 . 8493)
+                                (8496 . 8497)
+                                8499
+                                (65313 . 65338)
+                                (66560 . 66597)
+                                (119808 . 119833)
+                                (119860 . 119885)
+                                (119912 . 119937)
+                                119964
+                                (119966 . 119967)
+                                119970
+                                (119973 . 119974)
+                                (119977 . 119980)
+                                (119982 . 119989)
+                                (120016 . 120041)
+                                (120068 . 120069)
+                                (120071 . 120074)
+                                (120077 . 120084)
+                                (120086 . 120092)
+                                (120120 . 120121)
+                                (120123 . 120126)
+                                (120128 . 120132)
+                                120134
+                                (120138 . 120144)
+                                (120172 . 120197)
+                                (120224 . 120249)
+                                (120276 . 120301)
+                                (120328 . 120353)
+                                (120380 . 120405)
+                                (120432 . 120457)
+                                (120488 . 120512)
+                                (120546 . 120570)
+                                (120604 . 120628)
+                                (120662 . 120686)
+                                (120720 . 120744)))
+(xsdre-def-primitive-category 'Ll
+                              '((97 . 122)
+                                170 181 186
+                                (223 . 246)
+                                (248 . 255)
+                                257 259 261 263 265 267 269 271 273 275 277
+                                279 281 283 285 287 289 291 293 295 297 299
+                                301 303 305 307 309
+                                (311 . 312)
+                                314 316 318 320 322 324 326
+                                (328 . 329)
+                                331 333 335 337 339 341 343 345 347 349 351
+                                353 355 357 359 361 363 365 367 369 371 373
+                                375 378 380
+                                (382 . 384)
+                                387 389 392
+                                (396 . 397)
+                                402 405
+                                (409 . 411)
+                                414 417 419 421 424
+                                (426 . 427)
+                                429 432 436 438
+                                (441 . 442)
+                                (445 . 447)
+                                454 457 460 462 464 466 468 470 472 474
+                                (476 . 477)
+                                479 481 483 485 487 489 491 493
+                                (495 . 496)
+                                499 501 505 507 509 511 513 515 517 519 521
+                                523 525 527 529 531 533 535 537 539 541 543
+                                547 549 551 553 555 557 559 561 563
+                                (592 . 685)
+                                912
+                                (940 . 974)
+                                (976 . 977)
+                                (981 . 983)
+                                987 989 991 993 995 997 999 1001 1003 1005
+                              
+                                (1007 . 1011)
+                                1013
+                                (1072 . 1119)
+                                1121 1123 1125 1127 1129 1131 1133 1135 1137
+                                1139 1141 1143 1145 1147 1149 1151 1153 1165
+                                1167 1169 1171 1173 1175 1177 1179 1181 1183
+                                1185 1187 1189 1191 1193 1195 1197 1199 1201
+                                1203 1205 1207 1209 1211 1213 1215 1218 1220
+                                1224 1228 1233 1235 1237 1239 1241 1243 1245
+                                1247 1249 1251 1253 1255 1257 1259 1261 1263
+                                1265 1267 1269 1273
+                                (1377 . 1415)
+                                7681 7683 7685 7687 7689 7691 7693 7695 7697
+                                7699 7701 7703 7705 7707 7709 7711 7713 7715
+                                7717 7719 7721 7723 7725 7727 7729 7731 7733
+                                7735 7737 7739 7741 7743 7745 7747 7749 7751
+                                7753 7755 7757 7759 7761 7763 7765 7767 7769
+                                7771 7773 7775 7777 7779 7781 7783 7785 7787
+                                7789 7791 7793 7795 7797 7799 7801 7803 7805
+                                7807 7809 7811 7813 7815 7817 7819 7821 7823
+                                7825 7827
+                                (7829 . 7835)
+                                7841 7843 7845 7847 7849 7851 7853 7855 7857
+                                7859 7861 7863 7865 7867 7869 7871 7873 7875
+                                7877 7879 7881 7883 7885 7887 7889 7891 7893
+                                7895 7897 7899 7901 7903 7905 7907 7909 7911
+                                7913 7915 7917 7919 7921 7923 7925 7927 7929
+                              
+                                (7936 . 7943)
+                                (7952 . 7957)
+                                (7968 . 7975)
+                                (7984 . 7991)
+                                (8000 . 8005)
+                                (8016 . 8023)
+                                (8032 . 8039)
+                                (8048 . 8061)
+                                (8064 . 8071)
+                                (8080 . 8087)
+                                (8096 . 8103)
+                                (8112 . 8116)
+                                (8118 . 8119)
+                                8126
+                                (8130 . 8132)
+                                (8134 . 8135)
+                                (8144 . 8147)
+                                (8150 . 8151)
+                                (8160 . 8167)
+                                (8178 . 8180)
+                                (8182 . 8183)
+                                8319 8458
+                                (8462 . 8463)
+                                8467 8495 8500 8505
+                                (64256 . 64262)
+                                (64275 . 64279)
+                                (65345 . 65370)
+                                (66600 . 66637)
+                                (119834 . 119859)
+                                (119886 . 119892)
+                                (119894 . 119911)
+                                (119938 . 119963)
+                                (119990 . 119993)
+                                119995
+                                (119997 . 120000)
+                                (120002 . 120003)
+                                (120005 . 120015)
+                                (120042 . 120067)
+                                (120094 . 120119)
+                                (120146 . 120171)
+                                (120198 . 120223)
+                                (120250 . 120275)
+                                (120302 . 120327)
+                                (120354 . 120379)
+                                (120406 . 120431)
+                                (120458 . 120483)
+                                (120514 . 120538)
+                                (120540 . 120545)
+                                (120572 . 120596)
+                                (120598 . 120603)
+                                (120630 . 120654)
+                                (120656 . 120661)
+                                (120688 . 120712)
+                                (120714 . 120719)
+                                (120746 . 120770)
+                                (120772 . 120777)))
+(xsdre-def-primitive-category 'Lt
+                              '(453 456 459 498
+                                    (8072 . 8079)
+                                    (8088 . 8095)
+                                    (8104 . 8111)
+                                    8124 8140 8188))
+(xsdre-def-primitive-category 'Lm
+                              '((688 . 696)
+                                (699 . 705)
+                                (720 . 721)
+                                (736 . 740)
+                                750 890 1369 1600
+                                (1765 . 1766)
+                                3654 3782 6211 12293
+                                (12337 . 12341)
+                                (12445 . 12446)
+                                (12540 . 12542)
+                                65392
+                                (65438 . 65439)))
+(xsdre-def-primitive-category 'Lo
+                              '(443
+                                (448 . 451)
+                                (1488 . 1514)
+                                (1520 . 1522)
+                                (1569 . 1594)
+                                (1601 . 1610)
+                                (1649 . 1747)
+                                1749
+                                (1786 . 1788)
+                                1808
+                                (1810 . 1836)
+                                (1920 . 1957)
+                                (2309 . 2361)
+                                2365 2384
+                                (2392 . 2401)
+                                (2437 . 2444)
+                                (2447 . 2448)
+                                (2451 . 2472)
+                                (2474 . 2480)
+                                2482
+                                (2486 . 2489)
+                                (2524 . 2525)
+                                (2527 . 2529)
+                                (2544 . 2545)
+                                (2565 . 2570)
+                                (2575 . 2576)
+                                (2579 . 2600)
+                                (2602 . 2608)
+                                (2610 . 2611)
+                                (2613 . 2614)
+                                (2616 . 2617)
+                                (2649 . 2652)
+                                2654
+                                (2674 . 2676)
+                                (2693 . 2699)
+                                2701
+                                (2703 . 2705)
+                                (2707 . 2728)
+                                (2730 . 2736)
+                                (2738 . 2739)
+                                (2741 . 2745)
+                                2749 2768 2784
+                                (2821 . 2828)
+                                (2831 . 2832)
+                                (2835 . 2856)
+                                (2858 . 2864)
+                                (2866 . 2867)
+                                (2870 . 2873)
+                                2877
+                                (2908 . 2909)
+                                (2911 . 2913)
+                                (2949 . 2954)
+                                (2958 . 2960)
+                                (2962 . 2965)
+                                (2969 . 2970)
+                                2972
+                                (2974 . 2975)
+                                (2979 . 2980)
+                                (2984 . 2986)
+                                (2990 . 2997)
+                                (2999 . 3001)
+                                (3077 . 3084)
+                                (3086 . 3088)
+                                (3090 . 3112)
+                                (3114 . 3123)
+                                (3125 . 3129)
+                                (3168 . 3169)
+                                (3205 . 3212)
+                                (3214 . 3216)
+                                (3218 . 3240)
+                                (3242 . 3251)
+                                (3253 . 3257)
+                                3294
+                                (3296 . 3297)
+                                (3333 . 3340)
+                                (3342 . 3344)
+                                (3346 . 3368)
+                                (3370 . 3385)
+                                (3424 . 3425)
+                                (3461 . 3478)
+                                (3482 . 3505)
+                                (3507 . 3515)
+                                3517
+                                (3520 . 3526)
+                                (3585 . 3632)
+                                (3634 . 3635)
+                                (3648 . 3653)
+                                (3713 . 3714)
+                                3716
+                                (3719 . 3720)
+                                3722 3725
+                                (3732 . 3735)
+                                (3737 . 3743)
+                                (3745 . 3747)
+                                3749 3751
+                                (3754 . 3755)
+                                (3757 . 3760)
+                                (3762 . 3763)
+                                3773
+                                (3776 . 3780)
+                                (3804 . 3805)
+                                3840
+                                (3904 . 3911)
+                                (3913 . 3946)
+                                (3976 . 3979)
+                                (4096 . 4129)
+                                (4131 . 4135)
+                                (4137 . 4138)
+                                (4176 . 4181)
+                                (4304 . 4342)
+                                (4352 . 4441)
+                                (4447 . 4514)
+                                (4520 . 4601)
+                                (4608 . 4614)
+                                (4616 . 4678)
+                                4680
+                                (4682 . 4685)
+                                (4688 . 4694)
+                                4696
+                                (4698 . 4701)
+                                (4704 . 4742)
+                                4744
+                                (4746 . 4749)
+                                (4752 . 4782)
+                                4784
+                                (4786 . 4789)
+                                (4792 . 4798)
+                                4800
+                                (4802 . 4805)
+                                (4808 . 4814)
+                                (4816 . 4822)
+                                (4824 . 4846)
+                                (4848 . 4878)
+                                4880
+                                (4882 . 4885)
+                                (4888 . 4894)
+                                (4896 . 4934)
+                                (4936 . 4954)
+                                (5024 . 5108)
+                                (5121 . 5740)
+                                (5743 . 5750)
+                                (5761 . 5786)
+                                (5792 . 5866)
+                                (6016 . 6067)
+                                (6176 . 6210)
+                                (6212 . 6263)
+                                (6272 . 6312)
+                                (8501 . 8504)
+                                12294
+                                (12353 . 12436)
+                                (12449 . 12538)
+                                (12549 . 12588)
+                                (12593 . 12686)
+                                (12704 . 12727)
+                                (13312 . 19893)
+                                (19968 . 40869)
+                                (40960 . 42124)
+                                (44032 . 55203)
+                                (63744 . 64045)
+                                64285
+                                (64287 . 64296)
+                                (64298 . 64310)
+                                (64312 . 64316)
+                                64318
+                                (64320 . 64321)
+                                (64323 . 64324)
+                                (64326 . 64433)
+                                (64467 . 64829)
+                                (64848 . 64911)
+                                (64914 . 64967)
+                                (65008 . 65019)
+                                (65136 . 65138)
+                                65140
+                                (65142 . 65276)
+                                (65382 . 65391)
+                                (65393 . 65437)
+                                (65440 . 65470)
+                                (65474 . 65479)
+                                (65482 . 65487)
+                                (65490 . 65495)
+                                (65498 . 65500)
+                                (66304 . 66334)
+                                (66352 . 66377)
+                                (131072 . 173782)
+                                (194560 . 195101)))
+(xsdre-def-primitive-category 'Mn
+                              '((768 . 846)
+                                (864 . 866)
+                                (1155 . 1158)
+                                (1425 . 1441)
+                                (1443 . 1465)
+                                (1467 . 1469)
+                                1471
+                                (1473 . 1474)
+                                1476
+                                (1611 . 1621)
+                                1648
+                                (1750 . 1756)
+                                (1759 . 1764)
+                                (1767 . 1768)
+                                (1770 . 1773)
+                                1809
+                                (1840 . 1866)
+                                (1958 . 1968)
+                                (2305 . 2306)
+                                2364
+                                (2369 . 2376)
+                                2381
+                                (2385 . 2388)
+                                (2402 . 2403)
+                                2433 2492
+                                (2497 . 2500)
+                                2509
+                                (2530 . 2531)
+                                2562 2620
+                                (2625 . 2626)
+                                (2631 . 2632)
+                                (2635 . 2637)
+                                (2672 . 2673)
+                                (2689 . 2690)
+                                2748
+                                (2753 . 2757)
+                                (2759 . 2760)
+                                2765 2817 2876 2879
+                                (2881 . 2883)
+                                2893 2902 2946 3008 3021
+                                (3134 . 3136)
+                                (3142 . 3144)
+                                (3146 . 3149)
+                                (3157 . 3158)
+                                3263 3270
+                                (3276 . 3277)
+                                (3393 . 3395)
+                                3405 3530
+                                (3538 . 3540)
+                                3542 3633
+                                (3636 . 3642)
+                                (3655 . 3662)
+                                3761
+                                (3764 . 3769)
+                                (3771 . 3772)
+                                (3784 . 3789)
+                                (3864 . 3865)
+                                3893 3895 3897
+                                (3953 . 3966)
+                                (3968 . 3972)
+                                (3974 . 3975)
+                                (3984 . 3991)
+                                (3993 . 4028)
+                                4038
+                                (4141 . 4144)
+                                4146
+                                (4150 . 4151)
+                                4153
+                                (4184 . 4185)
+                                (6071 . 6077)
+                                6086
+                                (6089 . 6099)
+                                6313
+                                (8400 . 8412)
+                                8417
+                                (12330 . 12335)
+                                (12441 . 12442)
+                                64286
+                                (65056 . 65059)
+                                (119143 . 119145)
+                                (119163 . 119170)
+                                (119173 . 119179)
+                                (119210 . 119213)))
+(xsdre-def-primitive-category 'Mc
+                              '(2307
+                                (2366 . 2368)
+                                (2377 . 2380)
+                                (2434 . 2435)
+                                (2494 . 2496)
+                                (2503 . 2504)
+                                (2507 . 2508)
+                                2519
+                                (2622 . 2624)
+                                2691
+                                (2750 . 2752)
+                                2761
+                                (2763 . 2764)
+                                (2818 . 2819)
+                                2878 2880
+                                (2887 . 2888)
+                                (2891 . 2892)
+                                2903 2947
+                                (3006 . 3007)
+                                (3009 . 3010)
+                                (3014 . 3016)
+                                (3018 . 3020)
+                                3031
+                                (3073 . 3075)
+                                (3137 . 3140)
+                                (3202 . 3203)
+                                3262
+                                (3264 . 3268)
+                                (3271 . 3272)
+                                (3274 . 3275)
+                                (3285 . 3286)
+                                (3330 . 3331)
+                                (3390 . 3392)
+                                (3398 . 3400)
+                                (3402 . 3404)
+                                3415
+                                (3458 . 3459)
+                                (3535 . 3537)
+                                (3544 . 3551)
+                                (3570 . 3571)
+                                (3902 . 3903)
+                                3967 4140 4145 4152
+                                (4182 . 4183)
+                                (6068 . 6070)
+                                (6078 . 6085)
+                                (6087 . 6088)
+                                (119141 . 119142)
+                                (119149 . 119154)))
+(xsdre-def-primitive-category 'Me
+                              '((1160 . 1161)
+                                (1757 . 1758)
+                                (8413 . 8416)
+                                (8418 . 8419)))
+(xsdre-def-primitive-category 'Nd
+                              '((48 . 57)
+                                (1632 . 1641)
+                                (1776 . 1785)
+                                (2406 . 2415)
+                                (2534 . 2543)
+                                (2662 . 2671)
+                                (2790 . 2799)
+                                (2918 . 2927)
+                                (3047 . 3055)
+                                (3174 . 3183)
+                                (3302 . 3311)
+                                (3430 . 3439)
+                                (3664 . 3673)
+                                (3792 . 3801)
+                                (3872 . 3881)
+                                (4160 . 4169)
+                                (4969 . 4977)
+                                (6112 . 6121)
+                                (6160 . 6169)
+                                (65296 . 65305)
+                                (120782 . 120831)))
+(xsdre-def-primitive-category 'Nl
+                              '((5870 . 5872)
+                                (8544 . 8579)
+                                12295
+                                (12321 . 12329)
+                                (12344 . 12346)
+                                66378))
+(xsdre-def-primitive-category 'No
+                              '((178 . 179)
+                                185
+                                (188 . 190)
+                                (2548 . 2553)
+                                (3056 . 3058)
+                                (3882 . 3891)
+                                (4978 . 4988)
+                                8304
+                                (8308 . 8313)
+                                (8320 . 8329)
+                                (8531 . 8543)
+                                (9312 . 9371)
+                                9450
+                                (10102 . 10131)
+                                (12690 . 12693)
+                                (12832 . 12841)
+                                (12928 . 12937)
+                                (66336 . 66339)))
+(xsdre-def-primitive-category 'Pc
+                              '(95
+                                (8255 . 8256)
+                                12539
+                                (65075 . 65076)
+                                (65101 . 65103)
+                                65343 65381))
+(xsdre-def-primitive-category 'Pd
+                              '(45 173 1418 6150
+                                   (8208 . 8213)
+                                   12316 12336
+                                   (65073 . 65074)
+                                   65112 65123 65293))
+(xsdre-def-primitive-category 'Ps
+                              '(40 91 123 3898 3900 5787 8218 8222 8261 8317
+                                   8333 9001 12296 12298 12300 12302 12304
+                                   12308 12310 12312 12314 12317 64830 65077
+                                   65079 65081 65083 65085 65087 65089 65091
+                                   65113 65115 65117 65288 65339 65371 65378))
+(xsdre-def-primitive-category 'Pe
+                              '(41 93 125 3899 3901 5788 8262 8318 8334 9002
+                                   12297 12299 12301 12303 12305 12309 12311
+                                   12313 12315
+                                   (12318 . 12319)
+                                   64831 65078 65080 65082 65084 65086 65088
+                                   65090 65092 65114 65116 65118 65289 65341
+                                   65373 65379))
+(xsdre-def-primitive-category 'Pi
+                              '(171 8216
+                                    (8219 . 8220)
+                                    8223 8249))
+(xsdre-def-primitive-category 'Pf
+                              '(187 8217 8221 8250))
+(xsdre-def-primitive-category 'Po
+                              '((33 . 35)
+                                (37 . 39)
+                                42 44
+                                (46 . 47)
+                                (58 . 59)
+                                (63 . 64)
+                                92 161 183 191 894 903
+                                (1370 . 1375)
+                                1417 1470 1472 1475
+                                (1523 . 1524)
+                                1548 1563 1567
+                                (1642 . 1645)
+                                1748
+                                (1792 . 1805)
+                                (2404 . 2405)
+                                2416 3572 3663
+                                (3674 . 3675)
+                                (3844 . 3858)
+                                3973
+                                (4170 . 4175)
+                                4347
+                                (4961 . 4968)
+                                (5741 . 5742)
+                                (5867 . 5869)
+                                (6100 . 6106)
+                                6108
+                                (6144 . 6149)
+                                (6151 . 6154)
+                                (8214 . 8215)
+                                (8224 . 8231)
+                                (8240 . 8248)
+                                (8251 . 8254)
+                                (8257 . 8259)
+                                (8264 . 8269)
+                                (12289 . 12291)
+                                65072
+                                (65097 . 65100)
+                                (65104 . 65106)
+                                (65108 . 65111)
+                                (65119 . 65121)
+                                65128
+                                (65130 . 65131)
+                                (65281 . 65283)
+                                (65285 . 65287)
+                                65290 65292
+                                (65294 . 65295)
+                                (65306 . 65307)
+                                (65311 . 65312)
+                                65340 65377 65380))
+(xsdre-def-primitive-category 'Zs
+                              '(32 160 5760
+                                   (8192 . 8203)
+                                   8239 12288))
+(xsdre-def-primitive-category 'Zl
+                              '(8232))
+(xsdre-def-primitive-category 'Zp
+                              '(8233))
+(xsdre-def-primitive-category 'Sm
+                              '(43
+                                (60 . 62)
+                                124 126 172 177 215 247 8260
+                                (8314 . 8316)
+                                (8330 . 8332)
+                                (8592 . 8596)
+                                (8602 . 8603)
+                                8608 8611 8614 8622
+                                (8654 . 8655)
+                                8658 8660
+                                (8704 . 8945)
+                                (8968 . 8971)
+                                (8992 . 8993)
+                                9655 9665 9839 64297 65122
+                                (65124 . 65126)
+                                65291
+                                (65308 . 65310)
+                                65372 65374 65506
+                                (65513 . 65516)
+                                120513 120539 120571 120597 120629 120655
+                                120687 120713 120745 120771))
+(xsdre-def-primitive-category 'Sc
+                              '(36
+                                (162 . 165)
+                                (2546 . 2547)
+                                3647 6107
+                                (8352 . 8367)
+                                65129 65284
+                                (65504 . 65505)
+                                (65509 . 65510)))
+(xsdre-def-primitive-category 'Sk
+                              '(94 96 168 175 180 184
+                                   (697 . 698)
+                                   (706 . 719)
+                                   (722 . 735)
+                                   (741 . 749)
+                                   (884 . 885)
+                                   (900 . 901)
+                                   8125
+                                   (8127 . 8129)
+                                   (8141 . 8143)
+                                   (8157 . 8159)
+                                   (8173 . 8175)
+                                   (8189 . 8190)
+                                   (12443 . 12444)
+                                   65342 65344 65507))
+(xsdre-def-primitive-category 'So
+                              '((166 . 167)
+                                169 174 176 182 1154 1769
+                                (1789 . 1790)
+                                2554 2928
+                                (3841 . 3843)
+                                (3859 . 3863)
+                                (3866 . 3871)
+                                3892 3894 3896
+                                (4030 . 4037)
+                                (4039 . 4044)
+                                4047
+                                (8448 . 8449)
+                                (8451 . 8454)
+                                (8456 . 8457)
+                                8468
+                                (8470 . 8472)
+                                (8478 . 8483)
+                                8485 8487 8489 8494 8498 8506
+                                (8597 . 8601)
+                                (8604 . 8607)
+                                (8609 . 8610)
+                                (8612 . 8613)
+                                (8615 . 8621)
+                                (8623 . 8653)
+                                (8656 . 8657)
+                                8659
+                                (8661 . 8691)
+                                (8960 . 8967)
+                                (8972 . 8991)
+                                (8994 . 9000)
+                                (9003 . 9083)
+                                (9085 . 9114)
+                                (9216 . 9254)
+                                (9280 . 9290)
+                                (9372 . 9449)
+                                (9472 . 9621)
+                                (9632 . 9654)
+                                (9656 . 9664)
+                                (9666 . 9719)
+                                (9728 . 9747)
+                                (9753 . 9838)
+                                (9840 . 9841)
+                                (9985 . 9988)
+                                (9990 . 9993)
+                                (9996 . 10023)
+                                (10025 . 10059)
+                                10061
+                                (10063 . 10066)
+                                10070
+                                (10072 . 10078)
+                                (10081 . 10087)
+                                10132
+                                (10136 . 10159)
+                                (10161 . 10174)
+                                (10240 . 10495)
+                                (11904 . 11929)
+                                (11931 . 12019)
+                                (12032 . 12245)
+                                (12272 . 12283)
+                                12292
+                                (12306 . 12307)
+                                12320
+                                (12342 . 12343)
+                                (12350 . 12351)
+                                (12688 . 12689)
+                                (12694 . 12703)
+                                (12800 . 12828)
+                                (12842 . 12867)
+                                (12896 . 12923)
+                                12927
+                                (12938 . 12976)
+                                (12992 . 13003)
+                                (13008 . 13054)
+                                (13056 . 13174)
+                                (13179 . 13277)
+                                (13280 . 13310)
+                                (42128 . 42145)
+                                (42148 . 42163)
+                                (42165 . 42176)
+                                (42178 . 42180)
+                                42182 65508 65512
+                                (65517 . 65518)
+                                (65532 . 65533)
+                                (118784 . 119029)
+                                (119040 . 119078)
+                                (119082 . 119140)
+                                (119146 . 119148)
+                                (119171 . 119172)
+                                (119180 . 119209)
+                                (119214 . 119261)))
+(xsdre-def-primitive-category 'Cc
+                              '((0 . 31)
+                                (127 . 159)))
+(xsdre-def-primitive-category 'Cf
+                              '(1807
+                                (6155 . 6158)
+                                (8204 . 8207)
+                                (8234 . 8238)
+                                (8298 . 8303)
+                                65279
+                                (65529 . 65531)
+                                (119155 . 119162)
+                                917505
+                                (917536 . 917631)))
+(xsdre-def-primitive-category 'Co
+                              '((57344 . 63743)
+                                (983040 . 1048573)
+                                (1048576 . 1114109)))
+
+(provide 'xsd-regexp)
+
+;;; xsd-regexp.el ends here