diff options
Diffstat (limited to 'lisp/nxml')
132 files changed, 31314 insertions, 0 deletions
diff --git a/lisp/nxml/Makefile b/lisp/nxml/Makefile new file mode 100644 index 0000000000..13eee93a0e --- /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 0000000000..cebbab82fd --- /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 0000000000..4f3fc96c0f --- /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 0000000000..3e7d5012b6 --- /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 0000000000..28d8936d89 --- /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 0000000000..122804fc47 --- /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 0000000000..1d7f463d56 --- /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 0000000000..7a97964a16 --- /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 0000000000..6a6a7ff3c1 --- /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 0000000000..84814214f5 --- /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 0000000000..4f74699d76 --- /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 0000000000..33e9627d92 --- /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 0000000000..031b58d877 --- /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 0000000000..9de27e0dc5 --- /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 0000000000..a59541150e --- /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 0000000000..0f5d0ed1e5 --- /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 0000000000..b33d5ea065 --- /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 0000000000..9009737528 --- /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 0000000000..434861cf2b --- /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 0000000000..bb572921dd --- /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 0000000000..c93dd4654b --- /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 0000000000..cfae10e095 --- /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 0000000000..5adfaed0ef --- /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 0000000000..35be7fa7a5 --- /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 0000000000..e0d08648c9 --- /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 0000000000..8e23e1341c --- /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 0000000000..ef70b35ee1 --- /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 0000000000..b94e194456 --- /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 0000000000..e9ea7e2aea --- /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 0000000000..d0278dd088 --- /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 0000000000..ef5a9bb949 --- /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 0000000000..f9842bc8cb --- /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 0000000000..7440269e0e --- /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 0000000000..4465de42dd --- /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 0000000000..26abf69d52 --- /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 0000000000..b89d01536f --- /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 0000000000..06f59a3d84 --- /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 0000000000..74111fb8b0 --- /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 0000000000..644b2552d0 --- /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 0000000000..827b70e6b0 --- /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 0000000000..ce67a4069e --- /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 0000000000..b30500639b --- /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 0000000000..09f61ea1b5 --- /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 0000000000..b507c90c26 --- /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 0000000000..e824c2bd43 --- /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 0000000000..e9671c943c --- /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 0000000000..fd3e2455a2 --- /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 0000000000..618b74cd3d --- /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 0000000000..56ce30a017 --- /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 0000000000..54f6207cd4 --- /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 0000000000..5d37880fd6 --- /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 0000000000..1cab37edcb --- /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 0000000000..e610d399d4 --- /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 0000000000..bdf929f654 --- /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 0000000000..4300c49780 --- /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 0000000000..88989ed7b6 --- /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 0000000000..a28f77853d --- /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 0000000000..a255894831 --- /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 0000000000..b4cc42640f --- /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 0000000000..332720d71f --- /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 0000000000..41152bff4a --- /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 0000000000..bf17039df2 --- /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 0000000000..89413a2e44 --- /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 0000000000..2313c781d6 --- /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 0000000000..eaae9bec08 --- /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 0000000000..e4361a3240 --- /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 0000000000..c68207cff7 --- /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 0000000000..3403ce4614 --- /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 0000000000..91876d840b --- /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 0000000000..a70eb7fe83 --- /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 0000000000..f1e368783a --- /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 0000000000..e6f9ca432b --- /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 0000000000..3cb901803b --- /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 0000000000..89c202709f --- /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 0000000000..9232af9cab --- /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 0000000000..0b481adb4c --- /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 0000000000..c19e541e0a --- /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 0000000000..52168c73ad --- /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 0000000000..ea0cc9ee5e --- /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 0000000000..5e7746f4a5 --- /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 0000000000..b8520da93a --- /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 0000000000..18392547c8 --- /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 0000000000..e637bf3c6d --- /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 0000000000..625ff5bdfd --- /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 0000000000..25a070fd6c --- /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 0000000000..14d5c4bff5 --- /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 0000000000..8d0727f6c1 --- /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 0000000000..16c8656b48 --- /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 0000000000..36818c1e13 --- /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 0000000000..a39ae4700b --- /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 0000000000..f1eb897599 --- /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 0000000000..2cc5ef2bb0 --- /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 0000000000..83893e4b93 --- /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 0000000000..d94cc453f4 --- /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 0000000000..d0e54b64ec --- /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 0000000000..004f043c19 --- /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 0000000000..f381a28e05 --- /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 0000000000..fbb5cb8f25 --- /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 0000000000..38ba2988a4 --- /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 0000000000..1637cf666b --- /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 0000000000..f1a6f36dff --- /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 0000000000..29803dd0a7 --- /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 0000000000..98e8c2382c --- /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 0000000000..b4aeb1fd2b --- /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 0000000000..ba75580301 --- /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 0000000000..b5a70b2694 --- /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 0000000000..015c0c7dad --- /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 0000000000..821b40621f --- /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 0000000000..6306d93713 --- /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 0000000000..5bc39c86e8 --- /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 0000000000..0e93f10103 --- /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 0000000000..8b0c55e573 --- /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 0000000000..fbb6074515 --- /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 0000000000..070bdf8ea9 --- /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 0000000000..a0f95fc51a --- /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 0000000000..29699b6012 --- /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 0000000000..ba0689130c --- /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 0000000000..b81bfe009f --- /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 0000000000..ecf1ff1bc9 --- /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 0000000000..d369261554 --- /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 0000000000..46867a6254 --- /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 0000000000..f4a0a4cc4c --- /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 0000000000..c3ae4c6812 --- /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 0000000000..7ed8befc90 --- /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 0000000000..865da0ff70 --- /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 + '(("&" . "&") + ("\"" . """) + (">" . ">") + ("<" . "<"))))) + 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 0000000000..d5ecb3aae0 --- /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 0000000000..65091ef879 --- /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 0000000000..4103b568b4 --- /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 0000000000..bdf6a2cb7e --- /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 0000000000..56a12800fa --- /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 0000000000..ed381cd4cc --- /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 `<'") + (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 `&'") + (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 0000000000..3f12c5576a --- /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 |