Your IP : 216.73.216.48
;ELC
;;; Compiled
;;; in Emacs version 24.5.1
;;; with all optimizations.
;;; This file uses dynamic docstrings, first added in Emacs 19.29.
;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(byte-code "\300\301!\203\n \302\303!\210\304\305!\210\304\306!\210\304\307!\210\304\310!\210\304\311!\210\304\312!\210\313\314!\210\304\315!\210\316\317\320\321\322\323\324\325&\210\316\326\320\327\324\317%\210\330\331\332\333\334DD\335\324\317\336\337&\210\330\340\332\333\341DD\342\324\317\336\337&\210\330\343\332\333\344DD\345\324\317\336\337&\210\330\346\332\333\347DD\350\324\317\336\351&\210\330\352\332\333\353DD\354\324\317\336\351&\210\330\355\332\333\356DD\357\324\317\336\337&\210\330\360\332\333\361DD\362\324\317\336\337&\210\330\363\332\333\364DD\365\324\317\336\337&\210\330\366\332\333\367DD\370\324\317\336\371&\210\330\372\332\333\373DD\374\324\317\336\337&\210\375\376\377\201@ \324\326%\210\375\201A \201B \201C \324\326%\210\375\201D \201E \201F \324\326%\210\375\201G \320\201H \324\326%\210\375\201I \320\201J \324\326%\210\375\201K \201L \201M \324\326%\210\375\201N \201O \201P \324\326%\210\375\201Q \201R \201S \324\326%\210\375\201T \201U \201V \324\326%\210\375\201W \201X \201Y \324\326%\210\375\201Z \201[ \201\\ \324\326%\210\375\201] \201^ \201_ \324\326%\210\375\201` \201a \201b \324\326%\210\375\201c \201d \201e \324\326%\210\375\201f \201g \201h \324\326%\210\375\201i \201j \201k \324\326%\210\375\201l \201m \201n \324\326%\210\375\201o \201p \201q \324\326%\210\375\201r \201s \201t \324\326%\210\375\201u \201v \201w \324\326%\210\375\201x \320\201y \324\326%\210\375\201z \201{ \201| \324\326%\210\375\201} \201~ \201 \324\326%\210\375\201\200 \201\201 \201\202 \324\326%\210\375\201\203 \201\204 \201\205 \324\326%\210\375\201\206 \201\207 \201\210 \324\326%\210\375\201\211 \201\212 \201\213 \324\326%\210\375\201\214 \201\215 \201\216 \324\326%\210\375\201\217 \201\220 \201\221 \324\326%\210\375\201\222 \201\223 \201\224 \324\326%\210\375\201\225 \201\226 \201\227 \324\326%\210\375\201\230 \201\231 \201\232 \324\326%\210\375\201\233 \201\234 \201\235 \324\326%\210\375\201\236 \201\237 \201\240 \324\326%\210\375\201\241 \201\242 \201\243 \324\326%\210\375\201\244 \201\245 \201\246 \324\326%\210\375\201\247 \201\250 \201\251 \324\326%\210\375\307\201\252 \201\253 \324\326%\207" [featurep mucs error "nxml-mode is not compatible with Mule-UCS" require xmltok nxml-enc nxml-glyph nxml-util nxml-rap nxml-outln provide nxml-mode rng-nxml custom-declare-group nxml nil "New XML editing mode." :link (custom-manual "(nxml-mode) Top") :group languages nxml-faces "Faces for XML syntax highlighting." custom-declare-variable nxml-char-ref-display-glyph-flag funcall function #[0 "\300\207" [t] 1 "\n\n(fn)"] "Non-nil means display glyph following character reference.\nThe glyph is displayed in face `nxml-glyph'. The abnormal hook\n`nxml-glyph-set-functions' can be used to change the characters\nfor which glyphs are displayed." :type boolean nxml-sexp-element-flag #[0 "\300\207" [nil] 1 "\n\n(fn)"] "Non-nil means sexp commands treat an element as a single expression." nxml-slash-auto-complete-flag #[0 "\300\207" [nil] 1 "\n\n(fn)"] "Non-nil means typing a slash automatically completes the end-tag.\nThis is used by `nxml-electric-slash'." nxml-child-indent #[0 "\300\207" [2] 1 "\n\n(fn)"] "Indentation for the children of an element relative to the start-tag.\nThis only applies when the line or lines containing the start-tag contains\nnothing else other than that start-tag." integer nxml-attribute-indent #[0 "\300\207" [4] 1 "\n\n(fn)"] "Indentation for the attributes of an element relative to the start-tag.\nThis only applies when the first attribute of a tag starts a line.\nIn other cases, the first attribute on one line is indented the same\nas the first attribute on the previous line." nxml-bind-meta-tab-to-complete-flag #[0 "\300\207" [t] 1 "\n\n(fn)"] "Non-nil means to use nXML completion in \\[completion-at-point]." nxml-prefer-utf-16-to-utf-8-flag #[0 "\300\207" [nil] 1 "\n\n(fn)"] "Non-nil means prefer UTF-16 to UTF-8 when saving a buffer.\nThis is used only when a buffer does not contain an encoding declaration\nand when its current `buffer-file-coding-system' specifies neither UTF-16\nnor UTF-8." nxml-prefer-utf-16-little-to-big-endian-flag #[0 "\301=\207" [system-type windows-nt] 2 "\n\n(fn)"] "Non-nil means prefer little-endian to big-endian byte-order for UTF-16.\nThis is used only for saving a buffer; when reading the byte-order is\nauto-detected. It may be relevant both when there is no encoding declaration\nand when the encoding declaration specifies `UTF-16'." nxml-default-buffer-file-coding-system #[0 "\300\207" [nil] 1 "\n\n(fn)"] "Default value for `buffer-file-coding-system' for a buffer for a new file.\nA value of nil means use the default value of `buffer-file-coding-system' as normal.\nA buffer's `buffer-file-coding-system' affects what \\[nxml-insert-xml-declaration] inserts." coding-system nxml-auto-insert-xml-declaration-flag #[0 "\300\207" [nil] 1 "\n\n(fn)"] "Non-nil means automatically insert an XML declaration in a new file.\nThe XML declaration is inserted using `nxml-insert-xml-declaration'." custom-declare-face nxml-delimited-data ((t (:inherit font-lock-doc-face))) "Face used to highlight data enclosed between delimiters.\nThis is not used directly, but only via inheritance by other faces." nxml-name ((t (:inherit font-lock-builtin-face))) "Face used to highlight various names.\nThis includes element and attribute names, processing\ninstruction targets and the CDATA keyword in a CDATA section.\nThis is not used directly, but only via inheritance by other faces." nxml-ref ((t (:inherit font-lock-constant-face))) "Face used to highlight character and entity references.\nThis is not used directly, but only via inheritance by other faces." nxml-delimiter "Face used to highlight delimiters.\nThis is not used directly, but only via inheritance by other faces." nxml-text "Face used to highlight text." nxml-comment-content ((t (:inherit font-lock-comment-face))) "Face used to highlight the content of comments." nxml-comment-delimiter ((t (:inherit font-lock-comment-delimiter-face))) "Face used for the delimiters of comments, i.e., <!-- and -->." nxml-processing-instruction-delimiter ((t (:inherit nxml-delimiter))) "Face used for the delimiters of processing instructions, i.e., <? and ?>." nxml-processing-instruction-target ((t (:inherit font-lock-keyword-face))) "Face used for the target of processing instructions." nxml-processing-instruction-content ((t (:inherit nxml-delimited-data))) "Face used for the content of processing instructions." nxml-cdata-section-delimiter ((t (:inherit nxml-delimiter))) "Face used for the delimiters of CDATA sections, i.e., <![, [, and ]]>." nxml-cdata-section-CDATA ((t (:inherit nxml-name))) "Face used for the CDATA keyword in CDATA sections." nxml-cdata-section-content ((t (:inherit nxml-text))) "Face used for the content of CDATA sections." nxml-char-ref-number ((t (:inherit nxml-ref))) "Face used for the number in character references.\nThis includes ths `x' in hex references." nxml-char-ref-delimiter ((t (:inherit nxml-ref))) "Face used for the delimiters of character references, i.e., &# and ;." nxml-entity-ref-name ((t (:inherit nxml-ref))) "Face used for the entity name in general entity references." nxml-entity-ref-delimiter ((t (:inherit nxml-ref))) "Face used for the delimiters of entity references, i.e., & and ;." nxml-tag-delimiter ((t (:inherit nxml-delimiter))) "Face used for the angle brackets delimiting tags.\n`nxml-tag-slash' is used for slashes." nxml-tag-slash ((t (:inherit nxml-tag-delimiter))) "Face used for slashes in tags, both in end-tags and empty-elements." nxml-element-prefix ((t (:inherit nxml-name))) "Face used for the prefix of elements." nxml-element-colon "Face used for the colon in element names." nxml-element-local-name ((t (:inherit font-lock-function-name-face))) "Face used for the local name of elements." nxml-attribute-prefix ((t (:inherit nxml-name))) "Face used for the prefix of attributes." nxml-attribute-colon ((t (:inherit nxml-delimiter))) "Face used for the colon in attribute names." nxml-attribute-local-name ((t (:inherit font-lock-variable-name-face))) "Face used for the local name of attributes." nxml-namespace-attribute-xmlns ((t (:inherit nxml-attribute-prefix))) "Face used for `xmlns' in namespace attributes." nxml-namespace-attribute-colon ((t (:inherit nxml-attribute-colon))) "Face used for the colon in namespace attributes." nxml-namespace-attribute-prefix ((t (:inherit nxml-attribute-local-name))) "Face used for the prefix declared in namespace attributes." nxml-attribute-value ((t (:inherit font-lock-string-face))) "Face used for the value of attributes." nxml-attribute-value-delimiter ((t (:inherit nxml-attribute-value))) "Face used for the delimiters of attribute values." nxml-namespace-attribute-value ((t (:inherit nxml-attribute-value))) "Face used for the value of namespace attributes." nxml-namespace-attribute-value-delimiter ((t (:inherit nxml-attribute-value-delimiter))) "Face used for the delimiters of namespace attribute values." nxml-prolog-literal-delimiter ((t (:inherit nxml-delimited-data))) "Face used for the delimiters of literals in the prolog." nxml-prolog-literal-content ((t (:inherit nxml-delimited-data))) "Face used for the content of literals in the prolog." nxml-prolog-keyword ((t (:inherit font-lock-keyword-face))) "Face used for keywords in the prolog." nxml-markup-declaration-delimiter ((t (:inherit nxml-delimiter))) "Face used for the delimiters of markup declarations in the prolog.\nThe delimiters are <! and >." nxml-hash ((t (:inherit nxml-name))) "Face used for # before a name in the prolog." ((((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."] 8)
#@97 The parent document for a part of a modular document.
Use `nxml-parent-document-set' to set it.
(defvar nxml-parent-document nil (#$ . 10284))
(byte-code "\300\301!\210\302\301\303\304#\207" [make-variable-buffer-local nxml-parent-document put safe-local-variable stringp] 4)
#@111 List of regions in the prolog to be fontified.
See the function `xmltok-forward-prolog' for more information.
(defvar nxml-prolog-regions nil (#$ . 10567))
(make-variable-buffer-local 'nxml-prolog-regions)
#@161 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.
(defvar nxml-degraded nil (#$ . 10780))
(make-variable-buffer-local 'nxml-degraded)
#@62 Hook run by `nxml-complete'.
This hook is run until success.
(defvar nxml-completion-hook nil (#$ . 11030))
#@226 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-in-mixed-content-hook nil (#$ . 11145))
#@70 Maximum distance from point to scan when checking for mixed content.
(defvar nxml-mixed-scan-distance 4000 (#$ . 11429))
#@71 Maximum distance from point to scan backwards when indenting end-tag.
(defvar nxml-end-tag-indent-scan-distance 4000 (#$ . 11556))
#@275 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.
(defvar nxml-char-ref-extra-display t (#$ . 11694))
(make-variable-buffer-local 'nxml-char-ref-extra-display)
#@23 Keymap for nxml-mode.
(defvar nxml-mode-map (byte-code "\301 \302\303\304#\210\302\305\306#\210\302\307\310#\210\302\311\312#\210\302\313\314#\210\302\315\316#\210\302\317\320#\210\302\321\322#\210\302\323\322#\210\302\324\322#\210\302\325\326#\210\302\327\330#\210\302\331\332#\210\302\333\334#\210\302\335\336#\210\302\337\340#\210\302\341#\210\302\342\343#\210\302\344\345#\210\302\346\347#\210\211\207" [nxml-outline-prefix-map make-sparse-keymap define-key "\225" nxml-backward-up-element "\204" nxml-down-element "\216" nxml-forward-element "\220" nxml-backward-element "\373" nxml-backward-paragraph "\375" nxml-forward-paragraph "\350" nxml-mark-paragraph "" nxml-finish-element "]" "/" "
" nxml-split-element "" nxml-balanced-close-start-tag-block " " nxml-balanced-close-start-tag-inline "" nxml-insert-xml-declaration "" nxml-dynamic-markup-word "" nxml-insert-named-char "" [S-mouse-2] nxml-mouse-hide-direct-text-content "/" nxml-electric-slash "\211" completion-at-point] 5) (#$ . 12084))
#@43 Default font lock keywords for nxml-mode.
(defvar nxml-font-lock-keywords '(nxml-fontify-matcher) (#$ . 13130))
(defalias 'nxml-set-face #[771 "\211\205 W\205 \300\301$\207" [font-lock-append-text-property face] 8 "\n\n(fn START END FACE)"])
(byte-code "\300\301\302\303#\207" [put nxml-set-face byte-optimizer byte-compile-inline-expand] 4)
#@74 Set `nxml-parent-document' and inherit the DTD &c.
(fn PARENT-DOCUMENT)
(defalias 'nxml-parent-document-set #[257 "\306\211\211\211\211\211\307!\307!\230\203 \310\311!\210r\312!q\210 \262\n\262 \262\f\262
\262\262\262)\211\313\314\"\210\205R \315p!\207" [buffer-file-name rng-dtd rng-current-schema rng-current-schema-file-name rng-compile-table rng-ipattern-table nil file-truename error "Parent document cannot be the same as the document" find-file-noselect message "Set parent document to %s" rng-validate-while-idle rng-last-ipattern-index nxml-parent-document rng-validate-mode] 10 (#$ . 13485) "fParent document"])
#@161 Hook run after entering nXML mode.
No problems result if this variable is not bound.
`add-hook' automatically binds it. (This is true for all hook variables.)
(defvar nxml-mode-hook nil (#$ . 14151))
(byte-code "\300\301!\204\f \302\301\303\304#\210\300\207" [boundp nxml-mode-map put definition-name nxml-mode] 4)
(defvar nxml-mode-map (make-sparse-keymap))
(byte-code "\300\301N\204 \302\300\301\303\304!#\210\305\306!\204 \302\306\307\310#\210\300\207" [nxml-mode-map variable-documentation put purecopy "Keymap for `nxml-mode'." boundp nxml-mode-syntax-table definition-name nxml-mode] 5)
(defvar nxml-mode-syntax-table (make-syntax-table))
(byte-code "\300\301N\204 \302\300\301\303\304!#\210\302\305\306\307#\207" [nxml-mode-syntax-table variable-documentation put purecopy "Syntax table for `nxml-mode'." nxml-mode-abbrev-table definition-name nxml-mode] 5)
(defvar nxml-mode-abbrev-table (progn (define-abbrev-table 'nxml-mode-abbrev-table nil) nxml-mode-abbrev-table))
(byte-code "\300\301N\204 \302\300\301\303\304!#\210\302\305\306\307#\207" [nxml-mode-abbrev-table variable-documentation put purecopy "Abbrev table for `nxml-mode'." nxml-mode derived-mode-parent text-mode] 5)
#@2642 Major mode for editing XML.
\[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.
\[completion-at-point] 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.
You can toggle it using \[rng-validate-mode] or change the default by
customizing `rng-nxml-auto-validate-flag'.
\[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.
In addition to any hooks its parent mode `text-mode' might have run,
this mode runs the hook `nxml-mode-hook', as the final step
during initialization.
(fn)
(defalias 'nxml-mode #[0 "\306\300!\210\307\310 \210\311\312\310\313N\203 \314\311\313\310\313N#\210\315 !\204' \316 \317 \"\210\320\f!\211\2035 \211\321 =\203; \322\f\323 \"\210\210\324
\325\"\204R
@=\204R \326
\325@C#\210\327 !\210\330\f!\210
@\306\331!\210\332\306\333!\210\334\306\335!\210\336 \306\337!\210\340 \306\341!\210\342!\306\343!\210\340#\306\344!\210\345$\306\346!\210\347&\306\350!\210\351(\306\352!\210\353*\306\354!\210\355,\327 !\210\212\214~\210\356e\334\"A\357 \307\211 B C\307 D\334\211 E F\334 G\360\361\362\363\364\365!\366\"\367\370%DC\216ed H I\371IH\372#*\210\307 J\373 \210.\210*\374\375\376\334\307$\210\306\377!\210\201O ?\374\201P \201Q \334\307$\210\201F \203#\201R \201F !\204@K\2036\201S \201L !\2046KLM\203@\201T \210\201U N\201V \210\201W \210)\201X \201Y !\207" [delay-mode-hooks major-mode mode-name nxml-mode-map nxml-mode-syntax-table nxml-mode-abbrev-table make-local-variable t text-mode nxml-mode "nXML" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table mode-line-process ((nxml-degraded "/degraded")) adaptive-fill-mode nil forward-sexp-function nxml-forward-balanced-item indent-line-function nxml-indent-line fill-paragraph-function nxml-do-fill-paragraph comment-indent-function comment-start "<!--" comment-start-skip "<!--[
\n]*" comment-end "-->" comment-end-skip "[
\n]*-->" comment-line-break-function nxml-newline-and-indent copy-marker buffer-modified-p funcall make-byte-code 0 "\300?\205 \301\302!\207" vconcat vector [restore-buffer-modified-p nil] 2 "\n\n(fn)" remove-text-properties (nxml-inside nil) nxml-scan-prolog add-hook completion-at-point-functions nxml-completion-at-point-function syntax-propertize-function local-abbrev-table nxml-scan-end buffer-undo-list inhibit-read-only inhibit-modification-hooks deactivate-mark buffer-file-name buffer-file-truename end start inhibit-point-motion-hooks nxml-default-buffer-file-coding-system buffer-file-coding-system nxml-auto-insert-xml-declaration-flag font-lock-defaults nxml-after-change change-major-mode-hook nxml-cleanup file-exists-p local-variable-p nxml-insert-xml-declaration (nxml-font-lock-keywords t nil nil nil (font-lock-extend-region-functions nxml-extend-region) (jit-lock-contextually . t) (font-lock-unfontify-region-function . nxml-unfontify-region)) rng-nxml-mode-init nxml-enable-unicode-char-name-sets run-mode-hooks nxml-mode-hook] 9 (#$ . 15353) nil])
#@33 Clean up after nxml-mode.
(fn)
(defalias 'nxml-cleanup #[0 "\306\307!\210\212~\210\310 \311\211\311\312\211 \312 \313\314\315\316\317\320!\321\"\322\323%DC\216\311 \324ed\325#\210.\210)\326\327\330\311#\207" [buffer-undo-list inhibit-read-only inhibit-modification-hooks deactivate-mark buffer-file-name buffer-file-truename rng-validate-mode -1 buffer-modified-p t nil funcall make-byte-code 0 "\300?\205 \301\302!\207" vconcat vector [restore-buffer-modified-p nil] 2 "\n\n(fn)" remove-text-properties (face) remove-hook change-major-mode-hook nxml-cleanup inhibit-point-motion-hooks] 9 (#$ . 20601)])
(defalias 'nxml-degrade #[514 "\306\307\310!#\210\311 \210\312\313\212\214~\210\314 \312\211\312 \315\211 \315 \316\317\320\321\322\323!\324\"\325\326%DC\216ed \327 \330#. \262*\207" [nxml-degraded nxml-prolog-end buffer-undo-list inhibit-read-only inhibit-modification-hooks deactivate-mark message "Internal nXML mode error in %s (%s), degrading" error-message-string ding t 1 buffer-modified-p nil funcall make-byte-code 0 "\300?\205 \301\302!\207" vconcat vector [restore-buffer-modified-p nil] 2 "\n\n(fn)" remove-text-properties (nxml-inside nil) buffer-file-name buffer-file-truename end start] 11 "\n\n(fn CONTEXT ERR)"])
(defalias 'nxml-debug-region #[514 "\302 \210 b\210\303!*\207" [font-lock-end font-lock-beg nxml-extend-region set-mark] 4 "\n\n(fn START END)" "r"])
(defalias 'nxml-after-change #[514 "?\205 \301\302\303\304\305\306\307\"\310\"\311\312%D\313\302\314\301EDC\217\207" [nxml-degraded #1=#:err funcall make-byte-code 0 "\214~\210\303\304\300\301\"*\207" vconcat vector [inhibit-point-motion-hooks t nxml-after-change1] 3 "\n\n(fn)" error #[257 "\300\301\"\207" [nxml-degrade nxml-after-change] 4 "\n\n(fn ERR)"]] 11 "\n\n(fn START END)"])
#@305 After-change bookkeeping.
Returns a cons cell containing a possibly-enlarged change region.
You must call `nxml-extend-region' on this expanded region to obtain
the full extent of the area needing refontification.
For bookkeeping, call this function even when fontification is
disabled.
(fn START END)
(defalias 'nxml-after-change1 #[514 "\301\\X\203 \302 \210e\262\211V\203& b\210\303e!\210`\262\304\"]\262\305\207" [nxml-prolog-end 2 nxml-scan-prolog nxml-move-tag-backwards nxml-scan-after-change nil] 5 (#$ . 22420)])
#@161 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'.
(fn)
(defalias 'nxml-insert-xml-declaration #[0 "\203 \301!\203 \302\303\"\203 \202 \304 eb\210\305\306\307!\"c\207" [buffer-file-coding-system coding-system-p coding-system-get mime-charset nxml-choose-utf-coding-system format "<?xml version=\"1.0\" encoding=\"%s\"?>\n" nxml-coding-system-name] 5 (#$ . 22962) "*"])
(defalias 'nxml-prepare-to-save #[0 "\204 \302\301!\203 \203 \303 !\304=\204! \305=\204! \212\306 )\307\207" [enable-multibyte-characters buffer-file-coding-system local-variable-p coding-system-type 5 no-conversion nxml-select-coding-system nil] 2 "\n\n(fn)"])
(defalias 'nxml-select-coding-system #[0 "\302ed\"eb\210\303 \211:\205 \304@A\"\211\203* \211\227\305\230\203$ \306 \2020 \307!\2020 \2050 \310 \211\204} ?\205< \311!\262\203I \312\313\"\202J \314\204V \315\316\"\210\202| \317\320\312\203c \321\202d \322\323!\"\324R!\203w \325\"\210\202| \326\327\330\"\210\210\331!>\204\301 \332\232\204\301 \333\"?\205\227 \311!\262\204\245 \315\316\"\210\202\300 \317\312\334\323!\"P!\203\273 \325\"\210\202\300 \326\327\330\"\210\210\335 !\211\203\323 \211\250\203\323 \336\"\262\210\207" [buffer-read-only buffer-file-coding-system find-coding-systems-region xmltok-get-declared-encoding-position buffer-substring-no-properties "utf-16" nxml-choose-utf-16-coding-system nxml-mime-charset-coding-system nxml-choose-utf-coding-system nxml-choose-suitable-coding-system format "Unknown encoding %s" "XML declaration is not well-formed" error "%s" y-or-n-p ". " "Save with %s" "Modify and save with encoding %s" nxml-coding-system-name " " nxml-fix-encoding-declaration signal quit nil coding-system-base (undecided) nxml-unsuitable-coding-system-message ". Save with %s " coding-system-eol-type coding-system-change-eol-conversion] 12 "\n\n(fn)"])
(defalias 'nxml-unsuitable-coding-system-message #[513 "\300!\203 \301\207\302\303\206 \304!\"\207" [nxml-coding-system-unicode-p "Cannot translate some characters to Unicode" format "Cannot encode some characters with %s" nxml-coding-system-name] 6 "\n\n(fn CODING-SYSTEM &optional ENC-NAME)"])
(defconst nxml-utf-16-coding-systems (byte-code "\300\301!\205
\300\302!\205
\303\207" [coding-system-p utf-16-be utf-16-le (utf-16-be utf-16-le)] 2))
(defconst nxml-utf-coding-systems (cons 'utf-8 nxml-utf-16-coding-systems))
(defalias 'nxml-coding-system-unicode-p #[257 "\301\302!\"\207" [nxml-utf-coding-systems nxml-coding-system-member coding-system-base] 4 "\n\n(fn CODING-SYSTEM)"])
(defalias 'nxml-coding-system-name #[257 "\301!\262\302\303\"\203 \304\202 \305\306\"\206 !\207" [nxml-utf-16-coding-systems coding-system-base symbol-name nxml-coding-system-member utf-16 coding-system-get mime-charset] 5 "\n\n(fn CODING-SYSTEM)"])
(defalias 'nxml-fix-encoding-declaration #[514 "\302!:\203 @A|\210@b\210\211c\202B \250\203' b\210\303\304\261\202B eb\210\305\306\261\210?\205B \307\310 !)\205B `\311\225|\207" [case-fold-search xmltok-bad-xml-decl-regexp nxml-coding-system-name " encoding=\"" 34 "<?xml version=\"1.0\" encoding=\"" "\"?>\n" t looking-at 0] 6 "\n\n(fn ENC-POS CODING-SYSTEM)"])
(defalias 'nxml-choose-suitable-coding-system #[257 "\301\211\203 \302!>\203 \2023 \2032 \2042 @\262\303\304\"\203+ \211\262\202 A\262\202 \207" [buffer-file-coding-system nil coding-system-base coding-system-get mime-charset] 6 "\n\n(fn SUITABLE-CODING-SYSTEMS)"])
(defalias 'nxml-choose-utf-coding-system #[0 "\304\300!\205
\205
\305!\306 \"@\2062 \n\2031 \307\310!\2031 \307\311!\2031 \203- \310\2022 \311\2022 \312\207" [buffer-file-coding-system nxml-utf-coding-systems nxml-prefer-utf-16-to-utf-8-flag nxml-prefer-utf-16-little-to-big-endian-flag local-variable-p coding-system-base nxml-coding-system-member coding-system-p utf-16-le utf-16-be utf-8] 4 "\n\n(fn)"])
(defalias 'nxml-choose-utf-16-coding-system #[0 "\303\300!\205
\205
\304!\305 \"@\206* \n\203# \306\307!\205* \307\202* \306\310!\205* \310\207" [buffer-file-coding-system nxml-utf-16-coding-systems nxml-prefer-utf-16-little-to-big-endian-flag local-variable-p coding-system-base nxml-coding-system-member coding-system-p utf-16-le utf-16-be] 4 "\n\n(fn)"])
(defalias 'nxml-coding-system-member #[514 "\300\203 \211\204 \301@\"\203 \262\202 A\262\202 \211\207" [nil coding-system-equal] 6 "\n\n(fn CODING-SYSTEM CODING-SYSTEMS)"])
(defalias 'nxml-unfontify-region #[514 "\300\"\210\301\"\207" [font-lock-default-unfontify-region nxml-clear-char-ref-extra-display] 5 "\n\n(fn START END)"])
#@143 Extend the region to hold the minimum area we can fontify with nXML.
Called with `font-lock-beg' and `font-lock-end' dynamically bound.
(fn)
(defalias 'nxml-extend-region #[0 " \nW\203 e\262\211\nX\203 \n\262\202C b\210\303\304!\210\305f\306\232\204+ \307\310\n\311#\210\312 \210\313 \210`\262`W\203@ \314 \210\2024 `\262W\204O \211 V\205T \211\311\207" [font-lock-beg font-lock-end nxml-prolog-end skip-syntax-forward " " nil 60 search-backward "<" t nxml-ensure-scan-up-to-date nxml-move-outside-backwards nxml-tokenize-forward] 6 (#$ . 27679)])
#@50 Called as font-lock keyword matcher.
(fn BOUND)
(defalias 'nxml-fontify-matcher #[257 "\303!\210\2042 ` W\203 o\204 \304\305\306C\"\210\307 \210 b\210\310\311 \2031 `X\2031 \312 \210\202 )\310\207" [nxml-degraded nxml-prolog-end xmltok-errors syntax-propertize signal cl-assertion-failed (bobp) nxml-fontify-prolog nil nxml-tokenize-forward nxml-apply-fontify-rule] 4 (#$ . 28249)])
#@164 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.
(fn)
(defalias 'nxml-fontify-prolog #[0 "\211\205 \211@\301\302H\303H\304H#\266\211A\262\202 \207" [nxml-prolog-regions nxml-apply-fontify-rule 0 1 2] 7 (#$ . 28647)])
(byte-code "\300\301\302\303#\210\300\304\302\305#\210\300\306\302\307#\210\300\310\302\311#\210\300\312\302\313#\210\300\314\302\315#\210\300\316\302\317#\210\300\320\302\321#\210\300\322\302\323#\210\300\324\302\325#\210\300\326\302\327#\210\300\330\302\331#\210\300\332\302\333#\210\300\334\302\335#\210\300\336\302\337#\210\300\340\302\341#\210\300\342\302\343#\210\300\344\302\345#\210\300\346\302\347#\210\300\350\302\351#\210\300\352\302\353#\210\300\354\302\355#\210\300\356\302\357#\210\300\360\302\361#\207" [put start-tag nxml-fontify-rule ([nil 1 nxml-tag-delimiter] [-1 nil nxml-tag-delimiter] (element-qname . 1) attributes) partial-start-tag ([nil 1 nxml-tag-delimiter] (element-qname . 1) attributes) end-tag ([nil 1 nxml-tag-delimiter] [1 2 nxml-tag-slash] [-1 nil nxml-tag-delimiter] (element-qname . 2)) partial-end-tag ([nil 1 nxml-tag-delimiter] [1 2 nxml-tag-slash] (element-qname . 2)) empty-element ([nil 1 nxml-tag-delimiter] [-2 -1 nxml-tag-slash] [-1 nil nxml-tag-delimiter] (element-qname . 1) attributes) partial-empty-element ([nil 1 nxml-tag-delimiter] [-1 nil nxml-tag-slash] (element-qname . 1) attributes) char-ref ([nil 2 nxml-char-ref-delimiter] [2 -1 nxml-char-ref-number] [-1 nil nxml-char-ref-delimiter] char-ref) entity-ref ([nil 1 nxml-entity-ref-delimiter] [1 -1 nxml-entity-ref-name] [-1 nil nxml-entity-ref-delimiter]) comment ([nil 4 nxml-comment-delimiter] [4 -3 nxml-comment-content] [-3 nil nxml-comment-delimiter]) processing-instruction ([nil 2 nxml-processing-instruction-delimiter] [-2 nil nxml-processing-instruction-delimiter] processing-instruction-content) cdata-section ([nil 3 nxml-cdata-section-delimiter] [3 8 nxml-cdata-section-CDATA] [8 9 nxml-cdata-section-delimiter] [9 -3 nxml-cdata-section-content] [-3 nil nxml-cdata-section-delimiter]) data ([nil nil nxml-text]) xml-declaration ([nil 2 nxml-processing-instruction-delimiter] [2 5 nxml-processing-instruction-target] [-2 nil nxml-processing-instruction-delimiter]) xml-declaration-attribute-name ([nil nil nxml-attribute-local-name]) xml-declaration-attribute-value ([nil 1 nxml-attribute-value-delimiter] [1 -1 nxml-attribute-value] [-1 nil nxml-attribute-value-delimiter]) processing-instruction-left ([nil 2 nxml-processing-instruction-delimiter] [2 nil nxml-processing-instruction-target]) processing-instruction-right ([nil -2 nxml-processing-instruction-content] [-2 nil nxml-processing-instruction-delimiter]) literal ([nil 1 nxml-prolog-literal-delimiter] [1 -1 nxml-prolog-literal-content] [-1 nil nxml-prolog-literal-delimiter]) keyword ([nil nil nxml-prolog-keyword]) markup-declaration-open ([0 2 nxml-markup-declaration-delimiter] [2 nil nxml-prolog-keyword]) markup-declaration-close ([nil nil nxml-markup-declaration-delimiter]) internal-subset-open ([nil nil nxml-markup-declaration-delimiter]) internal-subset-close ([nil 1 nxml-markup-declaration-delimiter] [-1 nil nxml-markup-declaration-delimiter]) hash-name ([nil 1 nxml-hash] [1 nil nxml-prolog-keyword])] 4)
(defalias 'nxml-apply-fontify-rule #[768 "\206 \304N\204 \262\204 `\262\211\205\376 \211@A\262\305!\203u \211\306H\211\2040 \202? \211\306W\203< \\\202? \\\262\307H\211\204L \202[ \211\306W\203X \\\202[ \\\262\310H\211\205p W\205p \311\312$\266\202\372 \211:\203\225 \211@\313=\203\225 \n\203\372 \314A\\ \n\315\316\317&\210\202\372 \211\320=\203\241 \321 \210\202\372 \211\322=\203\341 \310\\\n\323\211\205\274 W\205\274 \311\312$\266\212\nb\210\324\325w\210`)\310Z\326\211\205\334 W\205\334 \311\312$\266\202\372 \211\327=\203\365 \330\331\"#\210\202\372 \332\333\"\210\210\202 \207" [xmltok-type xmltok-start xmltok-name-end xmltok-name-colon nxml-fontify-rule vectorp 0 1 2 font-lock-append-text-property face element-qname nxml-fontify-qname nxml-element-prefix nxml-element-colon nxml-element-local-name attributes nxml-fontify-attributes processing-instruction-content nxml-processing-instruction-target "
\n" nil nxml-processing-instruction-content char-ref nxml-char-ref-display-extra xmltok-char-number error "Invalid nxml-fontify-rule action %s"] 13 "\n\n(fn &optional TYPE START END)"])
(defalias 'nxml-fontify-attributes #[0 "\203 \302@\303\"\210A\211\204 \205\" \302 @!\210 A\211\204 \304\207" [xmltok-namespace-attributes xmltok-attributes nxml-fontify-attribute namespace nil] 4 "\n\n(fn)"])
(defalias 'nxml-fontify-attribute #[513 "\211\203! \300\211\301H\262\211\302H\262\211\303H\262\304\305\306\304&\210\202: \300\211\301H\262\211\302H\262\211\303H\262\307\310\311&\210\211\312H\262\211\313H\262\211\314H\262\203T \315\202U \316\203] \317\202^ \320\205\332 S\211\205v W\205v \321\322$\266\211T\211\205\214 W\205\214 \321\322$\266\203\305 @\211\301H\302H\303H\211\205\262 W\205\262 \321\322$\266\323#\210\262\266A\262\202\216 \211\205\330 W\205\330 \321\322$\266\203\207" [nxml-fontify-qname 0 1 2 nxml-namespace-attribute-xmlns nxml-namespace-attribute-colon nxml-namespace-attribute-prefix nxml-attribute-prefix nxml-attribute-colon nxml-attribute-local-name 3 4 6 nxml-namespace-attribute-value-delimiter nxml-attribute-value-delimiter nxml-namespace-attribute-value nxml-attribute-value font-lock-append-text-property face nxml-apply-fontify-rule] 19 "\n\n(fn ATT &optional NAMESPACE-DECLARATION)"])
(defalias 'nxml-fontify-qname #[1798 "\203F \211\205 W\205 \300\301$\266\211T\211\205/ W\205/ \300\301$\266T\211\205E W\205E \300\301$\207\206N \211\205^ W\205^ \300\301$\207" [font-lock-append-text-property face] 15 "\n\n(fn START COLON END PREFIX-FACE COLON-FACE LOCAL-NAME-FACE &optional UNPREFIXED-FACE)"])
#@376 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.
(fn ARG)
(defalias 'nxml-electric-slash #[257 "\303 \210`\211\206 `Sf\304=\205 \211\305\306\")?\212\307 \210`S)=\310\311!!\210?\205l \203b \203R \312\313\314\315\316\317\320 \"\321\"\322\323%D\324\313\325\312EDC\217\210\202b \326 `=\203b \n\327=\203b \330c\210\205l \211\205l \331 \207" [pos nxml-slash-auto-complete-flag xmltok-type nxml-ensure-scan-up-to-date 60 get-text-property nxml-inside back-to-indentation self-insert-command prefix-numeric-value #1=#:err funcall make-byte-code 0 "\303\300S\304\"\211\205+ \305 \306\261\210\301\205+ \212\nb\210\307 \210`\n)=\205+ \212\310\212\nb\210i)!)\207" vconcat vector [xmltok-start nxml-scan-element-backward t xmltok-start-tag-qname ">" back-to-indentation indent-line-to] 3 "\n\n(fn)" nxml-scan-error #[257 "\300\207" [nil] 2 "\n\n(fn IGNORED)"] nxml-token-before partial-empty-element ">" nxml-indent-line] 13 (#$ . 34701) "*P"])
#@306 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.
(fn)
(defalias 'nxml-balanced-close-start-tag-block #[0 "\300\301!\207" [nxml-balanced-close-start-tag block] 2 (#$ . 35971) "*"])
#@167 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.
(fn)
(defalias 'nxml-balanced-close-start-tag-inline #[0 "\300\301!\207" [nxml-balanced-close-start-tag inline] 2 (#$ . 36409) "*"])
(defalias 'nxml-balanced-close-start-tag #[257 "\304 `T \305=\204 \306>\203 Y\204 \307\310!\210\311\312T\n`^\"\313\261\210\314=\2032 b\202[ \211b\210\315 \210`U\203Y ib\210\316c\210\317!\210b\210\316c\210\317 \\!\262\202[ b\207" [xmltok-start xmltok-type xmltok-name-end nxml-child-indent nxml-token-before partial-start-tag (start-tag empty-element partial-empty-element) error "Not in a start-tag" "></" buffer-substring-no-properties ">" inline back-to-indentation "\n" indent-line-to] 9 "\n\n(fn BLOCK-OR-INLINE)"])
#@59 Finish the current element by inserting an end-tag.
(fn)
(defalias 'nxml-finish-element #[0 "\300\301!\207" [nxml-finish-element-1 nil] 2 (#$ . 37247) "*"])
#@64 Position where `nxml-split-element' split the current element.
(defvar nxml-last-split-position nil (#$ . 37411))
#@226 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.
(fn)
(defalias 'nxml-split-element #[0 " =\203 \n\203 \212\nb\210\303\304!)\202 \303\304!\211\207" [last-command this-command nxml-last-split-position nxml-finish-element-1 t] 2 (#$ . 37532) "*"])
#@208 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.
(fn STARTP)
(defalias 'nxml-finish-element-1 #[257 "\303 \212`W\203 \304>\203 \305\306\307!\"\210\310\311\")\212\312=\204& \305\313!\210 b\210\314 \210` )=\212b\210\315\316!)\212 b\210i)\317 \320\203[ \203[ `\212\314 \210`)X\204W \321c\210\322!\210\323\324\261\210\203\242 \203q \321c\210\322!\210`\262\325\324\261\210\203\242 \203\242 \321c\210\322\212 b\210\326y\210\314 \210i\n\\U\203\236 \n\\\202\237 )!\210\207" [xmltok-type xmltok-start nxml-child-indent nxml-token-before (cdata-section processing-instruction comment start-tag end-tag empty-element) error "Point is inside a %s" nxml-token-type-friendly-name nxml-scan-element-backward t start-tag "No matching start-tag" back-to-indentation looking-at "[
\n]*$" xmltok-start-tag-qname nil "\n" indent-line-to "</" ">" "<" 1] 12 (#$ . 37961) "*"])
#@35 Indent current line as XML.
(fn)
(defalias 'nxml-indent-line #[0 "`C\300\301\302\303\304\305\306!\307\"\310\311%D\312\301\313\300EDC\217\211\247\204# \211\202< \211\303W\203, \303\262\242\2039 \212\314!)\202< \314!\207" [#1=#:err funcall make-byte-code 0 "\212\301y\210\302\303w\210`\300\242Y\203 \300\303\240\210\304 \206 \301)\207" vconcat vector [0 " " nil nxml-compute-indent] 2 "\n\n(fn)" error #[257 "\300\207" [0] 2 "\n\n(fn IGNORED)"] indent-line-to] 9 (#$ . 38995)])
#@56 Return the indent for the line containing point.
(fn)
(defalias 'nxml-compute-indent #[0 "\300 \206 \301 \207" [nxml-compute-indent-from-matching-start-tag nxml-compute-indent-from-previous-line] 1 (#$ . 39487)])
#@328 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.
(fn)
(defalias 'nxml-compute-indent-from-matching-start-tag #[0 "\212\303 \210`\304\305\210)\306\305x\210\307 `U\205X \310>\205X \nU\2046 \212\211b\210\311 \210\nU)\2046 \312=\205X \313\314\315D\316\314\317\313EDC\217\205X \nW\205X \nb\210\306\305x\210n\205X \320 \262)\207" [inhibit-field-text-motion xmltok-type xmltok-start back-to-indentation t nil " " nxml-token-before (end-tag partial-end-tag) nxml-token-after data #1=#:err funcall #[0 "\301`\302`Z#\207" [nxml-end-tag-indent-scan-distance nxml-scan-element-backward nil] 5 "\n\n(fn)"] nxml-scan-error #[257 "\300\207" [nil] 2 "\n\n(fn IGNORED)"] current-indentation] 7 (#$ . 39709)])
#@79 Compute the indent for a line using the indentation of a previous line.
(fn)
(defalias 'nxml-compute-indent-from-previous-line #[0 "\212\300\210`\300C\300C\300C\300C\300C\301 \210`\240\210\302\303\304\305\306\307\310\f\f\f\f\f\f&\311\"\312\313%D\215\266\206)\207" [nil back-to-indentation indent funcall make-byte-code 0 "\306y\306U\203\f \307\310\311\"\210\312 \210\313\314!\204 \302\242\204 \302`\240\210\315 \210`U\204/ \316=\203 \303`\240\210`\300W\203\251 \317 \210\301\242X\203N \305\320\305\242!\240\210\202\242 `\301\242X\203m \321=\203c `\301\242U\204m \304\320\304\242!\240\210\202\242 \316=\203\205 \304\320\304\242!\240\210\305\320\305\242!\240\210\202\242 \320\304\242!\322=\203\232 \302\242b\210\307\310i\"\210\202\242 \307\310\323\301\242!\"\210\324\325w\210\2023 \303\242b\210i\304\242\326=\203\273 \327\202\274 \311\305\242\330=\203\307 \306\202\310 \311\\_\\\207" vconcat vector [-1 throw indent 0 back-to-indentation looking-at "[ ]*$" nxml-token-after data nxml-tokenize-forward nxml-merge-indent-context-type partial-start-tag mixed nxml-compute-indent-in-token "
\n" nil start-tag 1 end-tag xmltok-start xmltok-type nxml-child-indent] 5 "\n\n(fn)"] 19 (#$ . 40690)])
#@239 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'.
(fn CONTEXT)
(defalias 'nxml-merge-indent-context-type #[257 "\301>\203 \211\302>\203 \303\207\304\207\305>\203 \211\306>\203 \307\207\304\207\310=\2035 \211\311>\203- \207\211\2033 \304\207\310\207\211\203; \304\207\312\207" [xmltok-type (start-tag partial-start-tag) (nil start-tag comment) start-tag mixed (end-tag partial-end-tag) (nil end-tag comment) end-tag comment (start-tag end-tag comment) markup] 3 (#$ . 41914)])
#@212 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'.
(fn POS)
(defalias 'nxml-compute-indent-in-token #[257 "\302>\203\n \303!\207\304=\203 \305\306\307#\207\310=\203\" \305\311\312#\207\313=\203. \305\314\315#\207\211b\210\316y\317U\203D `W\203D \320 \210\202G b\210i\207" [xmltok-type xmltok-start (start-tag partial-start-tag empty-element partial-empty-element) nxml-compute-indent-in-start-tag comment nxml-compute-indent-in-delimited-token "<!--" "-->" cdata-section "<![CDATA[" "]]>" processing-instruction "<?" "?>" -1 0 back-to-indentation] 5 (#$ . 42579)])
#@269 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'.
(fn POS)
(defalias 'nxml-compute-indent-in-start-tag #[257 "\302!\303\203# @b\210\304y\210`W\203 \211b\210\202 \305 \210\210\202c b\210\304y\303U\2033 \302`!\204& `X\203` b\210 \262\306 \211\203\\ \211@\211\211\303H\262\211W\203Z \211b\210\303\262\266\210\202c \305 \210i\\\207" [xmltok-start nxml-attribute-indent nxml-attribute-value-boundary 0 -1 back-to-indentation xmltok-merge-attributes] 8 (#$ . 43313)])
#@265 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'.
(fn POS)
(defalias 'nxml-attribute-value-boundary #[257 "\300 \301\211\211\211\203N @\262\211\302H\262\262\211\303H\262\262\203. W\203. \301\262\202 \203G \203G X\203G B\262\301\262\202 A\262\202 \207" [xmltok-merge-attributes nil 3 4] 9 (#$ . 44008)])
#@335 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'.
(fn POS OPEN-DELIM CLOSE-DELIM)
(defalias 'nxml-compute-indent-in-delimited-token #[771 "G\\\211dX\205 \301\"\230\262\203 b\210\202C b\210\302y\210`X\203@ G\\b\210\303\230\203C \304\305!\203C `Tb\210\202C \306 \210i\207" [xmltok-start buffer-substring-no-properties -1 "<!--" looking-at " " back-to-indentation] 7 (#$ . 44549)])
#@538 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'.
(fn)
(defalias 'nxml-complete #[0 "\300\301!?\205
\302 \210\303\304!\207" [run-hook-with-args-until-success nxml-completion-hook ding message "Cannot complete in this context"] 2 (#$ . 45201) nil])
#@60 Call `nxml-complete' to perform completion at point.
(fn)
(defalias 'nxml-completion-at-point-function #[0 "\205 \301\207" [nxml-bind-meta-tab-to-complete-flag nxml-complete] 1 (#$ . 45938)])
#@926 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.
(fn &optional ARG)
(defalias 'nxml-forward-balanced-item #[256 "\211\204 \300\262\211\301V\203 \302 \210\211S\211\262\301V\2053 \202
\211\301W\2053 \303 \210\211T\211\262\301W\2053 \202# \207" [1 0 nxml-forward-single-balanced-item nxml-backward-single-balanced-item] 3 (#$ . 46140) "p"])
(defalias 'nxml-forward-single-balanced-item #[0 "\300\301\302D\303\301\304\300EDC\217\207" [#1=#:err funcall #[0 "\303 \212\304=\203 \211b\210\303 \262\202 ` U\204 \305!\202@ \n\203/ \306=\203/ \307 !\202@ \n\203? \310>\203? \311\312!\202@ \211)\262b\207" [xmltok-type xmltok-start nxml-sexp-element-flag nxml-token-after space nxml-scan-forward-within start-tag nxml-scan-element-forward (end-tag partial-end-tag) error "Already at end of element"] 3 "\n\n(fn)"] nxml-scan-error #[257 "\211\211A@\262b\210\300\301\211AA\262\"\207" [apply error] 5 "\n\n(fn ERR)"]] 6 "\n\n(fn)"])
(defalias 'nxml-backward-single-balanced-item #[0 "\300\301\302D\303\301\304\300EDC\217\207" [#1=#:err funcall #[0 "\303 \212\304=\203 b\210\303 \262\202 `U\204 \305!\202B \n\2031 \306=\2031 \307!\210 \202B \n\203A \310=\203A \311\312!\202B )\262b\207" [xmltok-type xmltok-start nxml-sexp-element-flag nxml-token-before space nxml-scan-backward-within end-tag nxml-scan-element-backward start-tag error "Already at start of element"] 3 "\n\n(fn)"] nxml-scan-error #[257 "\211\211A@\262b\210\300\301\211AA\262\"\207" [apply error] 5 "\n\n(fn ERR)"]] 6 "\n\n(fn)"])
(defalias 'nxml-scan-forward-within #[257 "\211\302!Z\262\211`X\203 \303\304\305!\"\210\306>\203u ` W\203\" \207\307 \211\204, \202t \211\211\310H\262\203F \211\211\310H\262`X\203F \311!\202t \211\211\312H\262\203Y \211\211\312H\262T\202t \212\211\211\313H\262b\210\314\315!)\203n \316\225\202t \211\211\313H\262\207\317=\203\203 ` W\203\203 \207\207" [xmltok-type xmltok-name-end nxml-end-delimiter-length error "Already at end of %s" nxml-token-type-friendly-name (start-tag empty-element partial-start-tag partial-empty-element) nxml-find-following-attribute 3 nxml-scan-forward-in-attribute-value 4 2 looking-at "[
\n]*=" 0 processing-instruction] 5 "\n\n(fn END)"])
(defalias 'nxml-scan-backward-within #[257 "\303 !\\`X\203 \304\305\306 !\"\210 \307>\203O \310 \211\204# \202N \211\211\311H\262\203H \211\211\311H\262`X\203H `\211\312H\262X\203H \313!\202N \211\211\314H\262\207 \315=\203k \212\nb\210\316\317w\210`)\211`W\205f \211\262\206l \207" [xmltok-start xmltok-type xmltok-name-end nxml-start-delimiter-length error "Already at start of %s" nxml-token-type-friendly-name (start-tag empty-element partial-start-tag partial-empty-element) nxml-find-preceding-attribute 3 4 nxml-scan-backward-in-attribute-value 0 processing-instruction "
\n" nil] 6 "\n\n(fn END)"])
(defalias 'nxml-scan-forward-in-attribute-value #[257 "`\211\300H\262U\203 \301\302!\210\211\211\303H\262\304\2036 @\262`\305HW\203, \304\262\202 \304\262A\262\202 \211\204C \211\300H\262\202| `\306HW\203Q \211\306H\202| `\306HU\203_ \211\305H\202| \211\305H\307\310H!Z`W\203r \211\202z \301\311\312\310H!\"\262\207" [4 error "Already at end of attribute value" 6 nil 2 1 nxml-end-delimiter-length 0 "Already at end of %s" nxml-token-type-friendly-name] 9 "\n\n(fn ATT)"])
(defalias 'nxml-scan-backward-in-attribute-value #[257 "`\211\300H\262U\203 \301\302!\210\303\211\304H\262!\305\2038 @\262\211\306H`W\203. \305\262\202 \305\262A\262\202 \211\204E \211\300H\262\202~ \211\307H`W\203S \211\307H\202~ `\307HU\203a \211\306H\202~ \211\306H\310\311H!\\\211`W\203t \211\202| \301\312\313\311H!\"\262\207" [3 error "Already at start of attribute value" reverse 6 nil 1 2 nxml-start-delimiter-length 0 "Already at start of %s" nxml-token-type-friendly-name] 9 "\n\n(fn ATT)"])
(defalias 'nxml-find-following-attribute #[0 "\302\206 \205 \203e @\211\211\303H\262\211`X\203: \211\304H\262\203: `\211\304H\262X\203: \302\262\262\202R `W\203R \203O \211\211\303H\262W\203R \262\266A\262\204 \211\262\302\262\202 \207" [xmltok-attributes xmltok-namespace-attributes nil 0 4] 9 "\n\n(fn)"])
(defalias 'nxml-find-preceding-attribute #[0 "\302\206 \205 \203e @\211\211\303H\262\211`W\203: \211\304H\262\203: `\211\304H\262X\203: \302\262\262\202R \211`W\203R \203O \211\303H\262W\203R \262\266A\262\204 \211\262\302\262\202 \207" [xmltok-attributes xmltok-namespace-attributes nil 0 4] 9 "\n\n(fn)"])
(defalias 'nxml-up-element #[256 "\211C\211\242\204 \211\300\240\210\211\242\301W\203 \302\242[!\2022 \303\304\305\301\306\307\310!\311\"\312\313%D\314\304\315\303EDC\217\207" [1 0 nxml-backward-up-element #1=#:err funcall make-byte-code "\300\242\303V\205K `dW\205K \304 \305>\204! \306>\203% \n`W\203% \211\202? \307 \310=\2036 `\nU\2036 \n\2027 \311\"\206? \312\313!b\266\300\211\242S\240\210\202 \207" vconcat vector [xmltok-type xmltok-start 0 nxml-token-after (end-tag partial-end-tag) (empty-element partial-empty-element) nxml-scan-element-forward start-tag t error "No parent element"] 4 "\n\n(fn)" nxml-scan-error #[257 "\211\211A@\262b\210\300\301\211AA\262\"\207" [apply error] 5 "\n\n(fn ERR)"]] 10 "\n\n(fn &optional ARG)" "p"])
(defalias 'nxml-backward-up-element #[256 "\211C\211\242\204 \211\300\240\210\211\242\301W\203 \302\242[!\2022 \303\304\305\301\306\307\310!\311\"\312\313%D\314\304\315\303EDC\217\207" [1 0 nxml-up-element #1=#:err funcall make-byte-code "\300\242\303V\205O e`W\205O \304 \305>\204! \306>\203% `W\203% \n\202C \307 \310=\2036 `U\2036 \2027 \n\311\"\203@ \n\202C \312\313!b\266\300\211\242S\240\210\202 \207" vconcat vector [xmltok-type xmltok-start 0 nxml-token-before (start-tag partial-start-tag) (empty-element partial-empty-element) nxml-scan-element-backward end-tag t error "No parent element"] 4 "\n\n(fn)" nxml-scan-error #[257 "\211\211A@\262b\210\300\301\211AA\262\"\207" [apply error] 5 "\n\n(fn ERR)"]] 10 "\n\n(fn &optional ARG)" "p"])
#@155 Move forward down into the content of an element.
With ARG, do this that many times.
Negative ARG means move backward but still down.
(fn &optional ARG)
(defalias 'nxml-down-element #[256 "\211\204 \301\262\211\302W\203 \303[!\207\211\302V\205A \304 \212\211b\210\305>\203( \306\307!\210\310>\2044 \311 \210\202 `)\262b\210\211S\262\202 \207" [xmltok-type 1 0 nxml-backward-down-element nxml-token-after (nil end-tag partial-end-tag) error "No following start-tags in this element" (start-tag partial-start-tag) nxml-tokenize-forward] 4 (#$ . 53047) "p"])
(defalias 'nxml-backward-down-element #[256 "\211\204 \303\262\211\304W\203 \305[!\207\211\304V\205W \212\306 \210b\210 \307>\203) \310\311!\210 \312>\204L `\nX\204= \313\314\n\315#\204C \316\211\202 \317 \210\320 \210\202 )b\210\211S\262\202 \207" [xmltok-start xmltok-type nxml-prolog-end 1 0 nxml-down-element nxml-token-before (start-tag partial-start-tag prolog nil) error "No preceding end-tags in this element" (end-tag partial-end-tag) search-backward "<" t nil nxml-move-outside-backwards xmltok-forward] 6 "\n\n(fn &optional ARG)" "p"])
#@119 Move forward over one element.
With ARG, do it that many times.
Negative ARG means move backward.
(fn &optional ARG)
(defalias 'nxml-forward-element #[256 "\211C\211\242\204 \211\300\240\210\211\242\301W\203 \302\242[!\2022 \303\304\305\301\306\307\310!\311\"\312\313%D\314\304\315\303EDC\217\207" [1 0 nxml-backward-element #1=#:err funcall make-byte-code "\300\242\301V\205\" `dW\205\" \302\303 !\206 \304\305!b\210\300\211\242S\240\210\202 \207" vconcat vector [0 nxml-scan-element-forward nxml-token-before error "No more elements"] 2 "\n\n(fn)" nxml-scan-error #[257 "\211\211A@\262b\210\300\301\211AA\262\"\207" [apply error] 5 "\n\n(fn ERR)"]] 10 (#$ . 54179) "p"])
#@119 Move backward over one element.
With ARG, do it that many times.
Negative ARG means move forward.
(fn &optional ARG)
(defalias 'nxml-backward-element #[256 "\211C\211\242\204 \211\300\240\210\211\242\301W\203 \302\242[!\2022 \303\304\305\301\306\307\310!\311\"\312\313%D\314\304\315\303EDC\217\207" [1 0 nxml-forward-element #1=#:err funcall make-byte-code "\300\242\302V\205( e`W\205( \303\304 \210 !\203 \206 \305\306!b\210\300\211\242S\240\210\202 \207" vconcat vector [xmltok-start 0 nxml-scan-element-backward nxml-token-after error "No preceding elements"] 2 "\n\n(fn)" nxml-scan-error #[257 "\211\211A@\262b\210\300\301\211AA\262\"\207" [apply error] 5 "\n\n(fn ERR)"]] 10 (#$ . 54870) "p"])
(defalias 'nxml-mark-token-after #[0 "\302\303 \304\305#\210b\210\306\307 \"\207" [xmltok-start xmltok-type push-mark nxml-token-after nil t message "Marked %s"] 4 "\n\n(fn)" nil])
#@132 Put point at beginning of this paragraph, mark at end.
The paragraph marked is the one that contains point or follows point.
(fn)
(defalias 'nxml-mark-paragraph #[0 "\300 \210\301\302\303\211#\210\304 \207" [nxml-forward-paragraph push-mark nil t nxml-backward-paragraph] 4 (#$ . 55771) nil])
(defalias 'nxml-forward-paragraph #[256 "\211\204 \300\262\211\301W\203 \302[!\207\211\301V\205- \301y\210\303 \205- \211S\211\262\301V\205- \202 \207" [1 0 nxml-backward-paragraph nxml-forward-single-paragraph] 3 "\n\n(fn &optional ARG)" "p"])
(defalias 'nxml-backward-paragraph #[256 "\211\204 \301\262\211\302W\203 \303[!\207\211\302V\2054 n\204\" \304\305\210)\306 \2054 \211S\211\262\302V\2054 \202\" \207" [inhibit-field-text-motion 1 0 nxml-forward-paragraph t nil nxml-backward-single-paragraph] 3 "\n\n(fn &optional ARG)" "p"])
#@87 Move forward over a single paragraph.
Return nil at end of buffer, t otherwise.
(fn)
(defalias 'nxml-forward-single-paragraph #[0 "\301 `Z\302\211b\210`dW\203, \303\"\211\262\204, \304!\203# \305\262\306 \210\307\262\202\n \2052 b\207" [xmltok-start nxml-token-after nil nxml-paragraph-end-pos nxml-token-contains-data-p t nxml-tokenize-forward 0] 7 (#$ . 56621)])
#@90 Move backward over a single paragraph.
Return nil at start of buffer, t otherwise.
(fn)
(defalias 'nxml-backward-single-paragraph #[0 "\302 \211`Z\303\211\211b\210\304\303\"\211\262\204\224 \305\303\"\262b\210\204\224 e`W\203\224 \306\307 \310#\203\216 \311 \210\212`W\203^ \312 \210\204O \305 \203O \303\262\262\304\313\"\211\203Z \211\262\210\2027 )\204\210 \211\203\210 \204\210 \310\262\212`W\203{ \312 \210\202o \304\313\"\211\203\206 \211\262\210)`\262\202! eb\210\202! \205\232 b\207" [xmltok-start nxml-prolog-end nxml-token-before nil nxml-paragraph-start-pos nxml-token-contains-data-p search-backward "<" t nxml-move-outside-backwards xmltok-forward 0] 10 (#$ . 57003)])
(defalias 'nxml-token-contains-data-p #[512 "\206 \302\\\262`\206 \302Z\262 \303=\203& \304\\]\262\211`\305Z^\262 \306=\2038 =\2038 \211`=\206T \307=\206T \310>\205T W\205T \212b\210\311\312\313#)\207" [xmltok-start xmltok-type 0 cdata-section 9 3 data char-ref (data cdata-section) re-search-forward "[^
\n]" t] 6 "\n\n(fn &optional START END)"])
#@312 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.
(fn HAD-DATA OFFSET)
(defalias 'nxml-paragraph-end-pos #[514 "\204y \302>\2033 \212` \303=\203 \304\202 \305]\\b\210\306\307\310#\205/ \306\311\310#\205/ \305\224\262)\207\312=\205x \313 \205x \314 \205\315 \212` \315]\\b\210\306\307\316Z\310#\205u \306\311\310#\203c \305\224\202u \211\316Zb\210\317\320x\210n\204t \321\322!\210`\262)\207\323>\203\224 \212` \\b\210\306\311\310#\205\220 \305\224\262)\207\324>\203\257 \313 \203\257 \314 \203\257 \212 b\210\317\320x\210`)\207\325=\205\315 \326\327!\205\315 \330\310!?\205\315 \212\331\332\320\310#\206\314 d)\207" [xmltok-type xmltok-start (data cdata-section) cdata-section 9 0 re-search-forward "[^
\n]" t "^[ ]*$" comment nxml-token-begins-line-p nxml-token-ends-line-p 4 3 " " nil beginning-of-line 2 (data space cdata-section) (start-tag end-tag empty-element comment processing-instruction entity-ref) end-tag looking-at "[ ]*$" nxml-in-mixed-content-p search-forward "\n"] 7 (#$ . 58088)])
#@315 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.
(fn HAD-DATA OFFSET)
(defalias 'nxml-paragraph-start-pos #[514 "\204| \302>\2030 \212`\303=\203 \304\202 \305]Zb\210\306\307 \310#\205. \306\311 \310#\205. \305\224)\207\312=\205{ \313 \205{ \314 \205\351 \212`\304]Zb\210 \315\\`W\205z \306\307 \315\\\310#\205z \306\311 \310#\203g \305\224\202z b\210\316\317!\203u \305\225\202z \320\321x\210`)\207\322>\203\224 \212`Zb\210\306\311 \310#\205\222 \305\224)\207\323>\203\256 \313 \203\256 \314 \203\256 \324\325\321\310#\206\351 d\207\326=\205\351 \314 \205\351 \212 b\210\327\321!)?\205\351 \212 b\210\320\321x\210`Sf\330=\203\347 \212`Sb\210\320\321x\210n\205\343 `)\206\350 `)\207" [xmltok-type xmltok-start (data cdata-section) cdata-section 3 0 re-search-backward "[^
\n]" t "^[ ]*$" comment nxml-token-ends-line-p nxml-token-begins-line-p 4 looking-at "<!--[ ]*\n" " " nil (data space cdata-section) (start-tag end-tag empty-element comment processing-instruction entity-ref) search-forward "\n" start-tag nxml-in-mixed-content-p 10] 6 (#$ . 59358)])
(defalias 'nxml-token-ends-line-p #[0 "\300\301!\207" [looking-at "[ ]*$"] 2 "\n\n(fn)"])
(defalias 'nxml-token-begins-line-p #[0 "\212b\210\301\302x\210n)\207" [xmltok-start " " nil] 2 "\n\n(fn)"])
#@160 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.
(fn ENDP)
(defalias 'nxml-in-mixed-content-p #[257 "\300C\301\302!\204\f \300\202e \303\304\305\306\307\310\311\"\312\"\313\314%D\315\304\316\303EDC\217\203- \317\202e \300\211\203= \242\262`\262\202D `\262\242\262\212\203Q b\210\320 \206Z \211\205Z \211b\210\321 )\266\202\203d \317\202e \300\207" [nil run-hook-with-args-until-failure nxml-in-mixed-content-hook #1=#:err funcall make-byte-code 0 "\301\306\211\211\211\211\211\211\211 \f
\300\203$ \307`!\205' \202' \310`!.\240\210\301\242\205F \212\301\242b\210\300\203A \311\306x\210n\202D \312\313!)?\207" vconcat vector [xmltok-errors xmltok-namespace-attributes xmltok-attributes xmltok-replacement nil nxml-scan-element-backward nxml-scan-element-forward " " looking-at "[ ]*$" xmltok-name-end xmltok-name-colon xmltok-start xmltok-type] 9 "\n\n(fn)" nxml-scan-error #[257 "\300\207" [nil] 2 "\n\n(fn IGNORED)"] t nxml-preceding-sibling-data-p nxml-following-sibling-data-p] 11 (#$ . 60884)])
#@67 Return non-nil if there is a previous sibling that is data.
(fn)
(defalias 'nxml-preceding-sibling-data-p #[0 "`Z ]\306\307\211\211\211\211\211\211\211\211\211 \212`W\203~ \306Y\203~ \204~ `\262\310\311\312#\203~ \313 \210\212\314 \210\315=\203N T\262\202Y \316=\203Y S\262\211\306=\203y `W\203y \204y \314 \210\317>\203_ \312\262\202_ \210)\202 . \207" [nxml-mixed-scan-distance nxml-prolog-end xmltok-errors xmltok-namespace-attributes xmltok-attributes xmltok-replacement 0 nil search-backward "<" t nxml-move-outside-backwards xmltok-forward end-tag start-tag (data cdata-section char-ref) xmltok-name-end xmltok-name-colon xmltok-start xmltok-type] 12 (#$ . 62016)])
(defalias 'nxml-following-sibling-data-p #[0 "`\\d^\306\307\211\211\211\211\211\211\211\211
\212`W\203_ \306Y\203_ \310 \203_ \211\204_ \311=\203> T\262\202 \312=\203L S\262\202 \306=\203 \313>\203 \314\262\202 . \207" [nxml-mixed-scan-distance xmltok-errors xmltok-namespace-attributes xmltok-attributes xmltok-replacement xmltok-name-end 0 nil nxml-tokenize-forward start-tag end-tag (data cdata-section char-ref) t xmltok-name-colon xmltok-start xmltok-type] 11 "\n\n(fn)"])
(defalias 'nxml-do-fill-paragraph #[257 "\304\211\211\211\212\305 \210`\262\306 \210\307\304w\210`\262\310 \210\311`\"`\312\n\313\")\2045 \314\315!\2035 \316P\317#\210)\211\205] `\320 Z GW\205] \212\310 \210\314\321 !!)\205] \322\225b)\210*\207" [fill-prefix fill-paragraph-function pos prefix nil nxml-forward-paragraph nxml-backward-paragraph "
\n" beginning-of-line buffer-substring-no-properties get-text-property nxml-inside looking-at "[ ]*<!--" " " fill-region-as-paragraph line-beginning-position regexp-quote 0] 10 "\n\n(fn ARG)"])
(defalias 'nxml-newline-and-indent #[257 "\300 \210\211\203 \301\302!\210\202 \303\304!\210\305 \207" [delete-horizontal-space insert-and-inherit 10 newline 1 nxml-indent-line] 3 "\n\n(fn SOFT)"])
(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))
#@916 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.
(fn)
(defalias 'nxml-dynamic-markup-word #[0 "\306\250\2034 `U\2034 \n=\2034 \2034 \307 8Z\211 A@Z\211 @Z|\210\211|\210\310\f!\266\204\2028 \311
!\210\306\211\306\212`\312v\210`W\204M \313\314!\210\315`\"\211\316P\306\203\\ b\210\211\204\207 `W\203q \317\306\320#\204y b\210\321\306\320#\203\207 \322\225\307Zb\210\323!\262\202\\ \211\206\233 \313\324\325
!!\203\230 \326\202\231 \327\"\266\204)b\207" [nxml-dynamic-markup-prev-pos last-command this-command nxml-dynamic-markup-prev-lengths nxml-dynamic-markup-prev-found-marker nxml-dynamic-markup-prev-start-tags nil 2 marker-position clrhash -1 error "No word to markup" buffer-substring-no-properties "</" search-backward t search-forward 0 nxml-try-copy-markup zerop hash-table-count "No possible markup found for `%s'" "No more markup possibilities found for `%s'"] 10 (#$ . 64217) "*"])
(defalias 'nxml-try-copy-markup #[257 "\212`\211\306\307\")?\205\257 \310\311\312\313#\205\257 `\306\307\")?\205\257 \314 \210 \315=\205\257 `W\205\257 `\316\n\"\317\316\"\320\"\237b\210\211\203[ \321\322@!\323P\312\313#\203[ \211A\262\324\312x\210\202? \211?\205\255 \324\312w\210\325`B \"?\205\255 `W\204z \nW\205\255 \326\313\"\327`B\313 #\210\nZ`Z
\nZ\330\\E \331 c\210\nZ\\b\210\332\333\261\210`\211 \262\266\203\262)\207" [pos xmltok-type xmltok-start nxml-dynamic-markup-prev-start-tags nxml-dynamic-markup-prev-found-marker xmltok-name-end get-text-property nxml-inside search-backward "<" nil t xmltok-forward start-tag buffer-substring-no-properties split-string "[
\n]+" re-search-backward regexp-quote "\\=" "
\n" gethash copy-marker puthash 2 xmltok-start-tag-qname "</" ">" nxml-dynamic-markup-prev-lengths nxml-dynamic-markup-prev-pos] 9 "\n\n(fn WORD-END-POS)"])
(defvar nxml-char-name-ignore-case t)
#@574 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-alist nil (#$ . 66949))
#@236 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-char-name-table (make-hash-table :test 'eq) (#$ . 67576))
#@47 List of char namesets that can be autoloaded.
(defvar nxml-autoload-char-name-set-list nil (#$ . 67888))
(defalias 'nxml-enable-char-name-set #[257 "\300\301\302#\207" [put nxml-char-name-set-enabled t] 5 "\n\n(fn NAMESET)"])
(defalias 'nxml-disable-char-name-set #[257 "\300\301\302#\207" [put nxml-char-name-set-enabled nil] 5 "\n\n(fn NAMESET)"])
(defalias 'nxml-char-name-set-enabled-p #[257 "\211\300N\207" [nxml-char-name-set-enabled] 3 "\n\n(fn NAMESET)"])
(defalias 'nxml-autoload-char-name-set #[514 ">\204\n B\301\302#\207" [nxml-autoload-char-name-set-list put nxml-char-name-set-file] 6 "\n\n(fn NAMESET FILE)"])
#@270 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.
(fn NAMESET ALIST)
(defalias 'nxml-define-char-name-set #[514 "\302N\203 \303\304\"\210\211\211\2036 \211@\211@\211A@\262\305B\306\"B#\266\211@A\241\210\211A\262\202\f \210\211 \244\307\302\310#\207" [nxml-char-name-table nxml-char-name-alist nxml-char-name-set-defined error "Nameset `%s' already defined" puthash gethash put t] 12 (#$ . 68529)])
(defalias 'nxml-get-char-name #[257 "\302\303\"\210\304 \"\305\203/ \211\204/ \306\211@@\262!\203( \211@A\262\262\202\n A\262\202\n \207" [nxml-autoload-char-name-set-list nxml-char-name-table mapc nxml-maybe-load-char-name-set gethash nil nxml-char-name-set-enabled-p] 6 "\n\n(fn CODE)"])
(defvar nxml-named-char-history nil)
#@206 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.
(fn ARG)
(defalias 'nxml-insert-named-char #[257 "\304\305\"\210 \306\307 \310\311\312\313&) \312\211\203A \211\204A \314\"\262\211AA\262\315N\2038 \211A@\262\262\202 \235A\262\202 \211\205\\ \203W \316\317\"\206[ \320\321\"\202[ \322\323\"c\207" [nxml-autoload-char-name-set-list nxml-char-name-ignore-case completion-ignore-case nxml-char-name-alist mapc nxml-maybe-load-char-name-set completing-read "Character name: " #[257 "\211\211AA\262\300N\207" [nxml-char-name-set-enabled] 3 "\n\n(fn MEMBER)"] t nil nxml-named-char-history assoc nxml-char-name-set-enabled decode-char ucs error "Character %x is not supported by Emacs" format "&#x%X;"] 8 (#$ . 69488) "*P"])
(defalias 'nxml-maybe-load-char-name-set #[257 "\211\300N\205 \211\301N?\205 \211\302N;\205 \303\302N!\207" [nxml-char-name-set-enabled nxml-char-name-set-defined nxml-char-name-set-file load] 4 "\n\n(fn SYM)"])
#@77 Toggle the display of extra information for character references.
(fn ARG)
(defalias 'nxml-toggle-char-ref-extra-display #[257 "\211\204 ?\202 \301!\302V\211=?\205 \211\303 \207" [nxml-char-ref-extra-display prefix-numeric-value 0 font-lock-fontify-buffer] 4 (#$ . 70597) "P"])
(put 'nxml-char-ref 'evaporate t)
(defalias 'nxml-char-ref-display-extra #[771 "\205A \302! \205 \303\304\"\305\204 \205? \306\305\307$\262\310\311\312#\210\2032 \310\313#\210\205? \310\314\315\316\304##\266\203\207" [nxml-char-ref-extra-display nxml-char-ref-display-glyph-flag nxml-get-char-name nxml-glyph-display-string nxml-glyph nil make-overlay t overlay-put category nxml-char-ref help-echo after-string propertize face] 13 "\n\n(fn START END N)"])
(defalias 'nxml-clear-char-ref-extra-display #[514 "\300\"\211\205 \301@\302\"\303=\203 \304@!\210\211A\262\202 \207" [overlays-in overlay-get category nxml-char-ref delete-overlay] 6 "\n\n(fn START END)"])
(defalias 'nxml-start-delimiter-length #[257 "\211\300N\206 \301\207" [nxml-start-delimiter-length 0] 3 "\n\n(fn TYPE)"])
(byte-code "\300\301\302\303#\210\300\304\302\305#\210\300\306\302\307#\210\300\310\302\311#\210\300\312\302\311#\210\300\313\302\311#\210\300\314\302\311#\210\300\315\302\307#\207" [put cdata-section nxml-start-delimiter-length 9 comment 4 processing-instruction 2 start-tag 1 empty-element partial-empty-element entity-ref char-ref] 4)
(defalias 'nxml-end-delimiter-length #[257 "\211\300N\206 \301\207" [nxml-end-delimiter-length 0] 3 "\n\n(fn TYPE)"])
(byte-code "\300\301\302\303#\210\300\304\302\303#\210\300\305\302\306#\210\300\307\302\310#\210\300\311\302\306#\210\300\312\302\310#\210\300\313\302\310#\210\300\314\302\310#\207" [put cdata-section nxml-end-delimiter-length 3 comment processing-instruction 2 start-tag 1 empty-element partial-empty-element entity-ref char-ref] 4)
(defalias 'nxml-token-type-friendly-name #[257 "\211\300N\206 \301!\207" [nxml-friendly-name symbol-name] 3 "\n\n(fn TYPE)"])
(byte-code "\300\301\302\303#\210\300\304\302\305#\210\300\306\302\307#\210\300\310\302\311#\210\312\313!\207" [put cdata-section nxml-friendly-name "CDATA section" processing-instruction "processing instruction" entity-ref "entity reference" char-ref "character reference" provide nxml-mode] 4)