|
Server IP : 111.118.215.189 / Your IP : 3.131.85.46 Web Server : Apache System : Linux md-in-83.webhostbox.net 4.19.286-203.ELK.el7.x86_64 #1 SMP Wed Jun 14 04:33:55 CDT 2023 x86_64 User : a1673wkz ( 2475) PHP Version : 8.2.25 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : ON Directory (0755) : /usr/share/emacs/24.3/lisp/nxml/ |
| [ Home ] | [ C0mmand ] | [ Upload File ] |
|---|
;ELC
;;; Compiled by mockbuild@buildfarm06-new.corp.cloudlinux.com on Fri Oct 11 10:08:31 2024
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/nxml/nxml-mode.el
;;; in Emacs version 24.3.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%\210\316\324\320\325\322\317%\210\326\327\330\331\322\317\332\333&\210\326\334\320\335\322\317\332\333&\210\326\336\320\337\322\317\332\333&\210\326\340\341\342\322\317\332\343&\210\326\344\345\346\322\317\332\343&\210\326\347\330\350\322\317\332\333&\210\326\351\320\352\322\317\332\333&\210\326\353\354\355\322\317\332\333&\210\326\356\320\357\322\317\332\360&\210\326\361\320\362\322\317\332\333&\210\363\364\365\366\322\324%\210\363\367\370\371\322\324%\210\363\372\373\374\322\324%\210\363\375\320\376\322\324%\210\363\377\320\201@ \322\324%\210\363\201A \201B \201C \322\324%\210\363\201D \201E \201F \322\324%\210\363\201G \201H \201I \322\324%\210\363\201J \201K \201L \322\324%\210\363\201M \201N \201O \322\324%\210\363\201P \201Q \201R \322\324%\210\363\201S \201T \201U \322\324%\210\363\201V \201W \201X \322\324%\210\363\201Y \201Z \201[ \322\324%\210\363\201\\ \201] \201^ \322\324%\210\363\201_ \201` \201a \322\324%\210\363\201b \201c \201d \322\324%\210\363\201e \201f \201g \322\324%\210\363\201h \201i \201j \322\324%\210\363\201k \201l \201m \322\324%\210\363\201n \320\201o \322\324%\210\363\201p \201q \201r \322\324%\210\363\201s \201t \201u \322\324%\210\363\201v \201w \201x \322\324%\210\363\201y \201z \201{ \322\324%\210\363\201| \201} \201~ \322\324%\210\363\201 \201\200 \201\201 \322\324%\210\363\201\202 \201\203 \201\204 \322\324%\210\363\201\205 \201\206 \201\207 \322\324%\210\363\201\210 \201\211 \201\212 \322\324%\210\363\201\213 \201\214 \201\215 \322\324%\210\363\201\216 \201\217 \201\220 \322\324%\210\363\201\221 \201\222 \201\223 \322\324%\210\363\201\224 \201\225 \201\226 \322\324%\210\363\201\227 \201\230 \201\231 \322\324%\210\363\201\232 \201\233 \201\234 \322\324%\210\363\201\235 \201\236 \201\237 \322\324%\210\363\307\201\240 \201\241 \322\324%\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." :group languages nxml-faces "Faces for XML syntax highlighting." custom-declare-variable nxml-char-ref-display-glyph-flag t "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 "Non-nil means sexp commands treat an element as a single expression." nxml-slash-auto-complete-flag "Non-nil means typing a slash automatically completes the end-tag.\nThis is used by `nxml-electric-slash'." nxml-child-indent 2 "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 4 "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 "Non-nil means to use nXML completion in \\[completion-at-point]." nxml-prefer-utf-16-to-utf-8-flag "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 (eq system-type 'windows-nt) "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 "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 "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 (#$ . 9887))
(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 (#$ . 10169))
(make-variable-buffer-local 'nxml-prolog-regions)
#@104 Position where fontification last ended.
It is nil if the buffer changed since the last fontification.
(defvar nxml-last-fontify-end nil (#$ . 10382))
(make-variable-buffer-local 'nxml-last-fontify-end)
#@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 (#$ . 10592))
(make-variable-buffer-local 'nxml-degraded)
#@62 Hook run by `nxml-complete'.
This hook is run until success.
(defvar nxml-completion-hook nil (#$ . 10842))
#@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 (#$ . 10957))
#@70 Maximum distance from point to scan when checking for mixed content.
(defvar nxml-mixed-scan-distance 4000 (#$ . 11241))
#@71 Maximum distance from point to scan backwards when indenting end-tag.
(defvar nxml-end-tag-indent-scan-distance 4000 (#$ . 11368))
#@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 (#$ . 11506))
(make-variable-buffer-local 'nxml-char-ref-extra-display)
#@23 Keymap for nxml-mode.
(defvar nxml-mode-map (byte-code "\302 \303\304\305#\210\303\306\307#\210\303\310\311#\210\303\312\313#\210\303\314\315#\210\303\316\317#\210\303\320\321#\210\303\322\323#\210\303\324\323#\210\303\325\323#\210\303\326\327#\210\303\330\331#\210\303\332\333#\210\303\334\335#\210\303\336\337#\210\303\340\341#\210\303\342 #\210\303\343\344#\210\303\345\346#\210\303\347\350#\210)\207" [map 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] 4) (#$ . 11896))
#@43 Default font lock keywords for nxml-mode.
(defvar nxml-font-lock-keywords '(nxml-fontify-matcher) (#$ . 12945))
(defalias 'nxml-set-face #[(start end face) "\205 \nW\205 \303 \n\300$\207" [face start end font-lock-append-text-property] 5])
(put 'nxml-set-face 'byte-optimizer 'byte-compile-inline-expand)
#@52 Set `nxml-parent-document' and inherit the DTD &c.
(defalias 'nxml-parent-document-set #[(parent-document) "\306\211\211\211\211\211 \307!\307!\230\203 \310\311!\210r\312!q\210)
\f \n \313\314\"\210\205^ \315p!.\207" [last-ipattern-index ipattern-table compile-table current-schema-file-name current-schema dtd 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 parent-document buffer-file-name rng-dtd rng-current-schema rng-current-schema-file-name rng-compile-table rng-ipattern-table rng-last-ipattern-index nxml-parent-document rng-validate-mode] 6 (#$ . 13261) "fParent document"])
(byte-code "\300\301N\204 \302\300\301\303\304!#\210\305\306!\204 \302\306\307\310#\210\300\207" [nxml-mode-hook variable-documentation put purecopy "Hook run when entering nXML mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it. (This is true for all hook variables.)" boundp nxml-mode-map definition-name nxml-mode] 5)
(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)
#@2636 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.
(defalias 'nxml-mode #[nil "\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 \2036
\321 =\203< \322\f\323 \"\210)\324@\325\"\204V @A=\204V \326@\325AC#\210\327 !\210\330\f!\210@A\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\356ed\"\210\357e\334\"B\360 \307\211\211\334\211\211 C < D E F G H\361\216ed I J\362JI\363#\210*\307 K\364 \210. \365\366\367\334\307$\210\365\370\371\334\307$\210\365\372\373\334\307$\210\374 \203\375\374 !\204+L\203!\376\377!\204!L?M\203+\201O \210\201P N\201Q \210\201R \210)\201S \201T !\207" [delay-mode-hooks major-mode mode-name nxml-mode-map nxml-mode-syntax-table parent 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 nxml-clear-dependent-regions copy-marker buffer-modified-p ((byte-code "\204 \301\302!\210\302\207" [#1=#:modified restore-buffer-modified-p nil] 2)) remove-text-properties (nxml-inside nil) nxml-scan-prolog add-hook completion-at-point-functions nxml-completion-at-point-function after-change-functions nxml-after-change change-major-mode-hook nxml-cleanup buffer-file-name file-exists-p local-variable-p buffer-file-coding-system nxml-mode-abbrev-table local-abbrev-table nxml-scan-end buffer-file-truename deactivate-mark buffer-undo-list inhibit-modification-hooks inhibit-read-only #1# end start inhibit-point-motion-hooks nxml-default-buffer-file-coding-system nxml-auto-insert-xml-declaration-flag font-lock-defaults nxml-insert-xml-declaration (nxml-font-lock-keywords t nil nil nil (font-lock-extend-after-change-region-function . nxml-extend-after-change-region) (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] 8 (#$ . 15261) nil])
#@27 Clean up after nxml-mode.
(defalias 'nxml-cleanup #[nil "\304\305!\210\212~\210\306\211\307 \306\310ed\311#\210)\312!\210,\313\314\315\306#\207" [modified buffer-undo-list inhibit-read-only inhibit-point-motion-hooks rng-validate-mode -1 t buffer-modified-p remove-text-properties (face) set-buffer-modified-p remove-hook change-major-mode-hook nxml-cleanup] 4 (#$ . 20562)])
(defalias 'nxml-degrade #[(context err) "\306\307\310 !#\210\311 \210\312\313\212\214~\210\314 \312\211\211\315\211\211 \316\216ed \317\320#.\f\207" [context err nxml-degraded nxml-prolog-end buffer-file-truename buffer-file-name message "Internal nXML mode error in %s (%s), degrading" error-message-string ding t 1 buffer-modified-p nil ((byte-code "\204 \301\302!\210\302\207" [#1=#:modified restore-buffer-modified-p nil] 2)) remove-text-properties (nxml-inside nil) deactivate-mark buffer-undo-list inhibit-modification-hooks inhibit-read-only #1# end start] 7])
(defalias 'nxml-debug-region #[(start end) " \304 \210 b\210\305\n!*\207" [start end font-lock-end font-lock-beg nxml-extend-region set-mark] 2 nil "r"])
(defalias 'nxml-after-change #[(start end pre-change-length) "\206 ?\205
\302\303\304\217\207" [font-lock-mode nxml-degraded #1=#:err (byte-code "\212\214~\210\306 \307\216\310\311 \310\211\211\312\211\211
\313\216\314#.
\207" [save-match-data-internal inhibit-point-motion-hooks buffer-file-truename buffer-file-name deactivate-mark buffer-undo-list match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) t buffer-modified-p nil ((byte-code "\204 \301\302!\210\302\207" [#2=#:modified restore-buffer-modified-p nil] 2)) nxml-after-change1 inhibit-modification-hooks inhibit-read-only #2# start end pre-change-length] 7) ((error (byte-code "\301\302\"\207" [#1# nxml-degrade nxml-after-change] 3)))] 3])
#@289 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.
(defalias 'nxml-after-change1 #[(start end pre-change-length) " \\\305 #\211\f\306\\X\203% \n\fW\203 d \f\nZ\\^\307 \210e) \fV\203< b\210\310e!\210`\311 \" ] B\207" [start pre-change-length pre-change-end end nxml-prolog-end nxml-adjust-start-for-dependent-regions 2 nxml-scan-prolog nxml-move-tag-backwards nxml-scan-after-change] 5 (#$ . 22468)])
#@155 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'.
(defalias 'nxml-insert-xml-declaration #[nil "\203 \302!\203 \303\304\"\203 \202 \305 eb\210\306\307\310 !\"c)\207" [buffer-file-coding-system 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] 4 (#$ . 23125) "*"])
(defalias 'nxml-prepare-to-save #[nil "\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])
(defalias 'nxml-select-coding-system #[nil "\306ed\"eb\210\307 \211:\205 \310 @ A\"\211\203- \n\227\311\230\203' \312 \2023 \313\n!\2023 \2053 \314 \211\204 \f?\205@ \315!\n\203L \316\317\n\"\202M \320 \204Z \321\322
\"\210\202~ \323
\324\316\n\203f \325\202g \326\327 !\"\330R!\203y \331 \"\210\202~ \332\333\334\"\210)\335 !>\204\302 \336\232\204\302 \337 \n\" \f?\205\232 \315!\211\204\247 \321\322
\"\210\202\301 \323
\316\340\327 !\"P!\203\274 \331 \"\210\202\301 \332\333\334\"\210)\341#!\211 $\203\330 $\250\203\330 \342 $\") ,\207" [suitable-coding-systems enc-pos enc-name coding-system buffer-read-only message 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 buffer-file-coding-system current-eol-type] 8])
(defalias 'nxml-unsuitable-coding-system-message #[(coding-system &optional enc-name) "\302!\203 \303\207\304\305 \206 \306!\"\207" [coding-system enc-name nxml-coding-system-unicode-p "Cannot translate some characters to Unicode" format "Cannot encode some characters with %s" nxml-coding-system-name] 4])
(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 #[(coding-system) "\302\303! \"\207" [coding-system nxml-utf-coding-systems nxml-coding-system-member coding-system-base] 3])
(defalias 'nxml-coding-system-name #[(coding-system) "\302!\303\304 \"\203 \305\202 \306\307\"\206 !\207" [coding-system nxml-utf-16-coding-systems coding-system-base symbol-name nxml-coding-system-member utf-16 coding-system-get mime-charset] 4])
(defalias 'nxml-fix-encoding-declaration #[(enc-pos coding-system) "\305!\n:\203 \n@\nA|\210\n@b\210 c\202C \n\250\203( \nb\210\306 \307\261\202C eb\210\310 \311\261\210\n?\205C \312\313\f!)\205C `\314\225|)\207" [coding-system charset enc-pos case-fold-search xmltok-bad-xml-decl-regexp nxml-coding-system-name " encoding=\"" 34 "<?xml version=\"1.0\" encoding=\"" "\"?>\n" t looking-at 0] 3])
(defalias 'nxml-choose-suitable-coding-system #[(suitable-coding-systems) "\304\211\n\203 \305\n! >\203 \n\2023 \2032 \2042 @\306\307\"\203+ \202 A\211\204 *\207" [coding-system ret buffer-file-coding-system suitable-coding-systems nil coding-system-base coding-system-get mime-charset] 4])
(defalias 'nxml-choose-utf-coding-system #[nil "\305\300!\205
\205
\306!\307 \n\"@\2063 \2032 \310\311!\2032 \310\312!\2032 \f\203. \311\2023 \312\2023 \313)\207" [buffer-file-coding-system cur 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] 3])
(defalias 'nxml-choose-utf-16-coding-system #[nil "\304\300!\205
\205
\305!\306 \n\"@\206+ \203$ \307\310!\205+ \310\202+ \307\311!\205+ \311)\207" [buffer-file-coding-system cur 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] 3])
(defalias 'nxml-coding-system-member #[(coding-system coding-systems) "\303 \203 \204 \304\n @\"\203 \202 A\211\204 )\207" [ret coding-systems coding-system nil coding-system-equal] 4])
(defalias 'nxml-unfontify-region #[(start end) "\302 \"\210\303 \"\207" [start end font-lock-default-unfontify-region nxml-clear-char-ref-extra-display] 3])
#@137 Extend the region to hold the minimum area we can fontify with nXML.
Called with `font-lock-beg' and `font-lock-end' dynamically bound.
(defalias 'nxml-extend-region #[nil " \211\fW\203\f e\n\fX\203 \f\202A b\210\305\306!\210\307f\310\232\204+ \311\312\f\313#\210\314 \210\315 \210``\nW\203? \316 \210\2023 ` W\204M \n V\205R \n\313*\207" [font-lock-beg font-lock-end end start nxml-prolog-end skip-syntax-forward " " nil 60 search-backward "<" t nxml-ensure-scan-up-to-date nxml-move-outside-backwards nxml-tokenize-forward] 5 (#$ . 27970)])
(defalias 'nxml-extend-after-change-region #[(start end pre-change-length) "?\205 \303\304\305\306\217\211:\205 \n)\207" [nxml-degraded nxml-last-fontify-end region nil #1=#:err (byte-code "\212\214~\210\306 \307\216\310\311 \310\211\211\312\211\211
\313\216\314#.
\207" [save-match-data-internal inhibit-point-motion-hooks buffer-file-truename buffer-file-name deactivate-mark buffer-undo-list match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) t buffer-modified-p nil ((byte-code "\204 \301\302!\210\302\207" [#2=#:modified restore-buffer-modified-p nil] 2)) nxml-extend-after-change-region1 inhibit-modification-hooks inhibit-read-only #2# start end pre-change-length] 7) ((error (byte-code "\301\302\"\207" [#1# nxml-degrade nxml-extend-after-change-region] 3)))] 4])
(defalias 'nxml-extend-after-change-region1 #[(start end pre-change-length) "\306 \n#\211@ A \307 \210\f
+B\207" [start end pre-change-length region font-lock-beg font-lock-end nxml-after-change1 nxml-extend-region] 5])
#@38 Called as font-lock keyword matcher.
(defalias 'nxml-fontify-matcher #[(bound) "\2042 ` W\203 o\204 \306\307\310C\"\210\311 \210 b\210\312\211\313 \203/ `\fX\203/ \314 \210\202 *`\312\207" [nxml-degraded nxml-prolog-end xmltok-errors xmltok-dependent-regions bound nxml-last-fontify-end signal cl-assertion-failed (bobp) nxml-fontify-prolog nil nxml-tokenize-forward nxml-apply-fontify-rule] 3 (#$ . 29598)])
#@158 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.
(defalias 'nxml-fontify-prolog #[nil "\211\205 @\303\n\304H\n\305H\n\306H#\210) A\211\204 \307)\207" [nxml-prolog-regions regions region nxml-apply-fontify-rule 0 1 2 nil] 6 (#$ . 30021)])
(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 #[(&optional type start end) "\206 \306N \204 \f
\204 `\n\205&\n@ \nA\307 !\203\207 \310H\211 \2044 \202F \310W\203B
\\\202F \\) \311H\211 \204U
\202g \310W\203c
\\\202g \\) \312H \f \f\205\202
W\205\202 \313
\314\f$+\210\202\" :\203\255 @\315=\203\255 \203\"\316 A\\! \317\320\321&\210\202\" \322=\203\272 \323 \210\202\" \324=\203 \312\\ \325 \f \f\205\335
W\205\335 \313
\314\f$+\210\212 b\210\326\327w\210`)
\312Z\330 \f \f\205
W\205\313
\314\f$+\210\202\" \331=\203 \332
\333
\"#\210\202\"\334\335 \"\210)\202 )\207" [type xmltok-type rule start xmltok-start end 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" action offset xmltok-name-end xmltok-name-colon] 8])
(defalias 'nxml-fontify-attributes #[nil "\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])
(defalias 'nxml-fontify-attribute #[(att &optional namespace-declaration) "\203! \306 \211\307H) \211\310H) \211\311H)\312\313\314\312&\210\202: \306 \211\307H) \211\310H) \211\311H)\315\316\317&\210 \211\320H) \211\321H) \211\322H)\203T \323\202U \324\203] \325\202^ \326 \211 \205S \205\207
W\205\207 \327
\330$+\210
\211T \205\246
W\205\246 \327
\330$+\210\f\203\366 \f@\211 \307H \310H \311H \n \205\337
W\205\337 \327
\330$+\210\331 #\210 ,\fA\211\204\254
\n \205
W\205\327
\330$+-\207" [namespace-declaration att value-face delimiter-face refs end 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 start ref ref-type ref-start ref-end] 9])
(defalias 'nxml-fontify-qname #[(start colon end prefix-face colon-face local-name-face &optional unprefixed-face) "\203O \n \205 \fW\205 \306 \f\303 $+\210\211T
\2053 \fW\2053 \306 \f\303 $+\210T\f \205M \fW\205M \306 \f\303 $+\207 \f\206X \205k \fW\205k \306 \f\303 $+\207" [colon start prefix-face face end colon-face font-lock-append-text-property local-name-face unprefixed-face] 5])
#@366 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.
(defalias 'nxml-electric-slash #[(arg) "\306 \210`\211Sf\307=\205 \310 \311\")?\212\312 \210`S)=\313\314\f!!\210\f?\205V
\203L \n\203; \315\316\317\217\210\202L \320 `=\203L \321=\203L \322c\210\n\205V \205V \323 +\207" [slash-pos pos end-tag-p at-indentation arg nxml-slash-auto-complete-flag nxml-ensure-scan-up-to-date 60 get-text-property nxml-inside back-to-indentation self-insert-command prefix-numeric-value nil (byte-code "\304S\305\"\211\203- \306 \307\261\210\n\203- \212 b\210\310 \210` )=\203- \212\311\212 b\210i)!\210))\304\207" [slash-pos start-tag-end at-indentation xmltok-start nxml-scan-element-backward t xmltok-start-tag-qname ">" back-to-indentation indent-line-to] 4) ((nxml-scan-error)) nxml-token-before partial-empty-element ">" nxml-indent-line xmltok-type] 4 (#$ . 36243) "*P"])
#@300 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.
(defalias 'nxml-balanced-close-start-tag-block #[nil "\300\301!\207" [nxml-balanced-close-start-tag block] 2 (#$ . 37437) "*"])
#@161 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.
(defalias 'nxml-balanced-close-start-tag-inline #[nil "\300\301!\207" [nxml-balanced-close-start-tag inline] 2 (#$ . 37871) "*"])
(defalias 'nxml-balanced-close-start-tag #[(block-or-inline) "\306 `T\f\307=\204 \f\310>\203 \nY\204 \311\312!\210\313\314T
`^\"\315\261\210\316=\2036 \nb\202c b\210\317 \210` U\203a i \nb\210\320c\210\321!\210\nb\210\320c\210\321\\!)\202c \nb+\207" [xmltok-start token-start pos token-end xmltok-type xmltok-name-end 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 block-or-inline indent nxml-child-indent] 5])
#@53 Finish the current element by inserting an end-tag.
(defalias 'nxml-finish-element #[nil "\300\301!\207" [nxml-finish-element-1 nil] 2 (#$ . 38750) "*"])
#@64 Position where `nxml-split-element' split the current element.
(defvar nxml-last-split-position nil (#$ . 38910))
#@220 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.
(defalias 'nxml-split-element #[nil " =\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 (#$ . 39031) "*"])
#@195 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.
(defalias 'nxml-finish-element-1 #[(startp) "\306 \212`W\203 \307>\203 \310\311\312 !\"\210\313\314\")\212 \315=\204( \310\316!\210 b\210\317 \210` )= \212\nb\210\320\321!) \212 b\210i) \322 \323 \f\203f
\203f `\212\317 \210`)X\204a \324c\210\325!\210\326\327\261\210 \203\265 \f\203~ \324c\210\325!\210` \330\327\261\210\f\203\265
\203\265 \324c\210\325\212 b\210\331y\210\317 \210i \\U\203\260 \\\202\262 )!\210 .\207" [token-end xmltok-type start-tag-end xmltok-start starts-line ends-line 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 start-tag-indent qname inserted-start-tag-pos startp nxml-child-indent] 4 (#$ . 39456) "*"])
#@29 Indent current line as XML.
(defalias 'nxml-indent-line #[nil "`\302\303\304\217\211\247\204 \202' \305W\203 \305\203$ \212\306 !)\202' \306 !*\207" [savep indent nil (byte-code "\212\301y\210\302\303w\210`Y\203 \303\304 \206 \301)\207" [savep 0 " " nil nxml-compute-indent] 2) ((error 0)) 0 indent-line-to] 4 (#$ . 40602)])
#@50 Return the indent for the line containing point.
(defalias 'nxml-compute-indent #[nil "\300 \206 \301 \207" [nxml-compute-indent-from-matching-start-tag nxml-compute-indent-from-previous-line] 1 (#$ . 40946)])
#@322 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.
(defalias 'nxml-compute-indent-from-matching-start-tag #[nil "\212\304 \210`\305\306\210)\307\306x\210\310 `U\205Q \n\311>\205Q U\2047 \212b\210\312 \210 U)\2047 \n\313=\205Q \306\314\315\217\205Q W\205Q b\210\307\306x\210n\205Q \316 *\207" [bol 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 (byte-code "\301`\302`Z#\207" [nxml-end-tag-indent-scan-distance nxml-scan-element-backward nil] 5) ((nxml-scan-error)) current-indentation] 3 (#$ . 41164)])
#@73 Compute the indent for a line using the indentation of a previous line.
(defalias 'nxml-compute-indent-from-previous-line #[nil "\212\306\210`\306\211\211\211\211 \307 \210`\310\311\215.\207" [after-context before-context ref prev-bol bol eol nil back-to-indentation indent (byte-code "\306y\306U\203\f \307\310\311\"\210\312 \210\313\314!\204 \204 `\315 \210 `U\204* \n\316=\203 ``\fW\203\226 \317 \210
X\203D \320!\202\217 `
X\203_ \n\321=\203V `
U\204_ \320!\202\217 \n\316=\203t \320!\320!\202\217 \320!\322=\203\210 b\210\307\310i\"\210\202\217 \307\310\323
!\"\210\324\325w\210\202, b\210i\326=\203\247 \327\202\250 \311\330=\203\263 \306\202\264 \311\\_\\\207" [prev-bol xmltok-start xmltok-type ref eol bol -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 after-context before-context nxml-child-indent] 5)] 6 (#$ . 42054)])
#@225 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'.
(defalias 'nxml-merge-indent-context-type #[(context) "\302>\203 \303>\203 \304\207\305\207\306>\203 \307>\203 \310\207\305\207\311=\2036 \312>\203. \207 \2034 \305\207\311\207 \203< \305\207\313\207" [xmltok-type context (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] 2 (#$ . 43104)])
#@202 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'.
(defalias 'nxml-compute-indent-in-token #[(pos) "\303>\203\n \304 !\207\305=\203 \306 \307\310#\207\311=\203\" \306 \312\313#\207\314=\203. \306 \315\316#\207 b\210\317y\320U\203D \n`W\203D \321 \210\202G \nb\210i\207" [xmltok-type pos 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] 4 (#$ . 43755)])
#@259 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'.
(defalias 'nxml-compute-indent-in-start-tag #[(pos) "\306!\307\211\203& \n@b\210\310y\210` W\203 b\210\202\" \311 \210)\202k b\210\310y\307U\2036 \306`!\204) `\fX\203h \fb\210
\312 \211 \203d @\211 \f\211 \f\307H)\211
W\203c
b\210\307*)\202k \311 \210i \\*\207" [pos off value-boundary value-start xmltok-start nxml-attribute-indent nxml-attribute-value-boundary 0 -1 back-to-indentation xmltok-merge-attributes atts att start] 3 (#$ . 44484)])
#@255 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'.
(defalias 'nxml-attribute-value-boundary #[(pos) "\306 \307\211\211\211\211 \203O \f@\211\211\310H) \211\311H)\n\2030
\nW\2030 \307\211\202\f \n\203H \203H
X\203H \n B\307\211\202\f \fA\211\204 -\207" [value-boundary value-end value-start att atts pos xmltok-merge-attributes nil 3 4] 6 (#$ . 45211)])
#@302 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'.
(defalias 'nxml-compute-indent-in-delimited-token #[(pos open-delim close-delim) " G\\\211dX\205 \305\n\" \230)\203 b\210\202C b\210\306y\210` X\203@ \fG\\b\210\f\307\230\203C \310\311!\203C `Tb\210\202C \312 \210i\207" [pos close-delim end xmltok-start open-delim buffer-substring-no-properties -1 "<!--" looking-at " " back-to-indentation] 4 (#$ . 45793)])
#@532 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'.
(defalias 'nxml-complete #[nil "\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 (#$ . 46468) nil])
#@54 Call `nxml-complete' to perform completion at point.
(defalias 'nxml-completion-at-point-function #[nil "\205 \301\207" [nxml-bind-meta-tab-to-complete-flag nxml-complete] 1 (#$ . 47201)])
#@906 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.
(defalias 'nxml-forward-balanced-item #[(&optional arg) "\204 \301\302V\203 \303 \210S\211\302V\2050 \202\f \302W\2050 \304 \210T\211\302W\2050 \202! \207" [arg 1 0 nxml-forward-single-balanced-item nxml-backward-single-balanced-item] 2 (#$ . 47399) "p"])
(defalias 'nxml-forward-single-balanced-item #[nil "\300\301\302\217\207" [err (byte-code "\304 \212 \305=\203 b\210\304 \202 `\nU\204 \306!\202@ \203/ \307=\203/ \310\n!\202@ \203? \311>\203? \312\313!\202@ *b\207" [end 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"] 2) ((nxml-scan-error (byte-code "\211A@)b\210\302\303\211AA)\"\207" [err x apply error] 4)))] 3])
(defalias 'nxml-backward-single-balanced-item #[nil "\300\301\302\217\207" [err (byte-code "\304 \212 \305=\203 \nb\210\304 \202 `U\204 \306!\202B \2031 \307=\2031 \310!\210\n\202B \203A \311=\203A \312\313!\202B \n*b\207" [end 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"] 2) ((nxml-scan-error (byte-code "\211A@)b\210\302\303\211AA)\"\207" [err x apply error] 4)))] 3])
(defalias 'nxml-scan-forward-within #[(end) "\304 !Z\211`X\203 \305\306\307 !\"\210 \310>\203v `\nW\203! \n\207\311 \211\204, \202t \211\312H)\203F \211\312H)`X\203F \313 !\202t \211\314H)\203Y \211\314H)T\202t \212 \211\315H)b\210\316\317!)\203n \320\225\202t \211\315H))\207 \321=\203\204 `\nW\203\204 \n\207\207" [end xmltok-type xmltok-name-end att 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])
(defalias 'nxml-scan-backward-within #[(_end) "\305 !\\`X\203 \306\307\310 !\"\210 \311>\203Q \312 \211\204$ \202O \n\211\313H)\203I \n\211\313H)`X\203I `\n\211\314H)X\203I \315\n!\202O \n\211\316H))\207 \317=\203m \212 b\210\320\321w\210`)\211 `W\205i \f)\206n \207" [xmltok-start xmltok-type att xmltok-name-end content-start 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] 5])
(defalias 'nxml-scan-forward-in-attribute-value #[(att) "`\211\304H)U\203 \305\306!\210\211\307H)\310\211\2036 \n@` \311HW\203- \310\211\202 \310\nA\211\204 \204C \211\304H)\202| ` \312HW\203Q \312H\202| ` \312HU\203_ \311H\202| \311H\313 \314H!Z` W\203s \202{ \305\315\316 \314H!\")*\207" [att ref refs end 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] 6])
(defalias 'nxml-scan-backward-in-attribute-value #[(att) "`\211\304H)U\203 \305\306!\210\307\211\310H)!\311\211\2038 \n@\211\312H`W\203/ \311\211\202 \311\nA\211\204 \204E \211\304H)\202~ \313H`W\203S \313H\202~ ` \313HU\203a \312H\202~ \312H\314 \315H!\\\211`W\203u \202} \305\316\317 \315H!\")*\207" [att ref refs start 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] 6])
(defalias 'nxml-find-following-attribute #[nil "\306\206 \205 \203f @\211 \211 \307H)\211 `X\203>
\211 \310H)\203> `
\211 \310H)X\203> \306
\202W ` W\203W \f\203U \f\211 \307H)W\203W
* A\211\204 \n\306\202 \f+\207" [xmltok-attributes xmltok-namespace-attributes more-atts atts ret att nil 0 4 name-start] 4])
(defalias 'nxml-find-preceding-attribute #[nil "\306\206 \205 \203f @\211 \211 \307H)\211 `W\203>
\211 \310H)\203> `
\211 \310H)X\203> \306
\202W `W\203W \f\203U \f\211 \307H) W\203W
* A\211\204 \n\306\202 \f+\207" [xmltok-attributes xmltok-namespace-attributes more-atts atts ret att nil 0 4 name-start] 4])
(defalias 'nxml-up-element #[(&optional arg) "\204 \301\302W\203 \303[!\207\304\305\306\217\207" [arg 1 0 nxml-backward-up-element err (byte-code "\304V\205I `dW\205I \305 \n\306>\204! \n\307>\203% `W\203% \202? \310\n\311=\2036 ` U\2036 \2027 \312\"\206? \313\314!b\210)S\211\202 \207" [arg token-end 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) ((nxml-scan-error (byte-code "\211A@)b\210\302\303\211AA)\"\207" [err x apply error] 4)))] 3 nil "p"])
(defalias 'nxml-backward-up-element #[(&optional arg) "\204 \301\302W\203 \303[!\207\304\305\306\217\207" [arg 1 0 nxml-up-element err (byte-code "\304V\205M e`W\205M \305 \n\306>\204! \n\307>\203% ` W\203% \202C \310\n\311=\2036 ` U\2036 \2027 \312\"\203@ \202C \313\314!b\210)S\211\202 \207" [arg token-end 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) ((nxml-scan-error (byte-code "\211A@)b\210\302\303\211AA)\"\207" [err x apply error] 4)))] 3 nil "p"])
#@135 Move forward down into the content of an element.
With ARG, do this that many times.
Negative ARG means move backward but still down.
(defalias 'nxml-down-element #[(&optional arg) "\204 \303\304W\203 \305[!\207\304V\205? \306 \212 b\210\n\307>\203( \310\311!\210\n\312>\2044 \313 \210\202 `*b\210S\211\202 \207" [arg token-end 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] 3 (#$ . 53728) "p"])
(defalias 'nxml-backward-down-element #[(&optional arg) "\204 \304\305W\203 \306[!\207\305V\205V \212\307 \210 b\210\n\310>\203( \311\312!\210\n\313>\204K ` X\204< \314\315 \316#\204B \317\211\202 \320 \210\321 \210\202 )b\210S\211\202 \207" [arg 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] 5 nil "p"])
#@99 Move forward over one element.
With ARG, do it that many times.
Negative ARG means move backward.
(defalias 'nxml-forward-element #[(&optional arg) "\204 \301\302W\203 \303[!\207\304\305\306\217\207" [arg 1 0 nxml-backward-element err (byte-code "\301V\205 `dW\205 \302\303 !\206 \304\305!b\210S\211\202 \207" [arg 0 nxml-scan-element-forward nxml-token-before error "No more elements"] 3) ((nxml-scan-error (byte-code "\211A@)b\210\302\303\211AA)\"\207" [err x apply error] 4)))] 3 (#$ . 54823) "p"])
#@99 Move backward over one element.
With ARG, do it that many times.
Negative ARG means move forward.
(defalias 'nxml-backward-element #[(&optional arg) "\204 \301\302W\203 \303[!\207\304\305\306\217\207" [arg 1 0 nxml-forward-element err (byte-code "\302V\205% e`W\205% \303\304 \210 !\203 \206 \305\306!b\210S\211\202 \207" [arg xmltok-start 0 nxml-scan-element-backward nxml-token-after error "No preceding elements"] 3) ((nxml-scan-error (byte-code "\211A@)b\210\302\303\211AA)\"\207" [err x apply error] 4)))] 3 (#$ . 55348) "p"])
(defalias 'nxml-mark-token-after #[nil "\302\303 \304\305#\210b\210\306\307 \"\207" [xmltok-start xmltok-type push-mark nxml-token-after nil t message "Marked %s"] 4 nil nil])
#@126 Put point at beginning of this paragraph, mark at end.
The paragraph marked is the one that contains point or follows point.
(defalias 'nxml-mark-paragraph #[nil "\300 \210\301\302\303\211#\210\304 \207" [nxml-forward-paragraph push-mark nil t nxml-backward-paragraph] 4 (#$ . 56081) nil])
(defalias 'nxml-forward-paragraph #[(&optional arg) "\204 \301\302W\203 \303[!\207\302V\205+ \302y\210\304 \205+ S\211\302V\205+ \202 \207" [arg 1 0 nxml-backward-paragraph nxml-forward-single-paragraph] 2 nil "p"])
(defalias 'nxml-backward-paragraph #[(&optional arg) "\204 \302\303W\203 \304[!\207\303V\2052 n\204! \305\306\210)\307 \2052 S\211\303V\2052 \202! \207" [arg inhibit-field-text-motion 1 0 nxml-forward-paragraph t nil nxml-backward-single-paragraph] 2 nil "p"])
#@81 Move forward over a single paragraph.
Return nil at end of buffer, t otherwise.
(defalias 'nxml-forward-single-paragraph #[nil "\305 ` Z\306\211 b\210`dW\203- \307\f\n\"\211\204- \310\n!\203% \311\312 \210\313\202 \2053 b,\207" [token-end xmltok-start offset pos had-data nxml-token-after nil nxml-paragraph-end-pos nxml-token-contains-data-p t nxml-tokenize-forward 0] 4 (#$ . 56875)])
#@84 Move backward over a single paragraph.
Return nil at start of buffer, t otherwise.
(defalias 'nxml-backward-single-paragraph #[nil "\306 \211`Z\n\307\211 \307 b\210\310\307 \"\211\204\232 \311\307 \"\nb\210\f\204\232 e`W\203\232 \312\313\314#\203\224 \315 \210\212` W\203c \316 \210
\204R \311 \203R \307\n\310
\317\"\211 \203_ )\202; )
\204\217 \203\217 \f\204\217 \314\212`W\203\201 \316 \210\202t \310
\317\"\211 \203\216 *`\202$ eb\210\202$ \f\205\240 \fb.\207" [token-end offset xmltok-start last-tag-pos pos had-data nxml-token-before nil nxml-paragraph-start-pos nxml-token-contains-data-p search-backward "<" t nxml-move-outside-backwards xmltok-forward 0 last-data-pos nxml-prolog-end tem] 5 (#$ . 57278)])
(defalias 'nxml-token-contains-data-p #[(&optional start end) " \206 \304\\`\n\206 \304Z \305=\203\" \306\\]\n`\307Z^ \310=\2034 =\2034 \n`=\206P \311=\206P \312>\205P \nW\205P \212 b\210\313\314\n\315#)\207" [xmltok-start start end xmltok-type 0 cdata-section 9 3 data char-ref (data cdata-section) re-search-forward "[^
\n]" t] 4])
#@290 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.
(defalias 'nxml-paragraph-end-pos #[(had-data offset) "\204w \305>\2032 \212` \306=\203 \307\202 \310\f]\\b\210\311\312\n\313#\2050 \311\314\n\313#\2050 \310\224*\207 \315=\205v \316 \205v \317 \205\312 \212` \320\f]\\b\210\311\312\n\321Z\313#\205u \311\314\n\313#\203c \310\224\202u \n\321Zb\210\322\323x\210n\204t \324\325!\210`*\207 \326>\203\221 \212` \f\\b\210\311\314\n\313#\205\217 \310\224*\207 \327>\203\254 \316 \203\254 \317 \203\254 \212 b\210\322\323x\210`)\207 \330=\205\312 \331\332!\205\312 \333\313!?\205\312 \212\334\335\323\313#\206\311 d)\207" [had-data xmltok-type end xmltok-start offset (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"] 4 (#$ . 58379)])
#@293 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.
(defalias 'nxml-paragraph-start-pos #[(had-data offset) "\204| \304>\2030 \212` \305=\203 \306\202 \307\n]Zb\210\310\311 \312#\205. \310\313 \312#\205. \307\224)\207 \314=\205{ \315 \205{ \316 \205\351 \212`\306\n]Zb\210 \317\\`W\205z \310\311 \317\\\312#\205z \310\313 \312#\203g \307\224\202z b\210\320\321!\203u \307\225\202z \322\323x\210`)\207 \324>\203\224 \212`\nZb\210\310\313 \312#\205\222 \307\224)\207 \325>\203\256 \315 \203\256 \316 \203\256 \326\327\323\312#\206\351 d\207 \330=\205\351 \316 \205\351 \212 b\210\331\323!)?\205\351 \212 b\210\322\323x\210`Sf\332=\203\347 \212`Sb\210\322\323x\210n\205\343 `)\206\350 `)\207" [had-data xmltok-type offset 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] 4 (#$ . 59655)])
(defalias 'nxml-token-ends-line-p #[nil "\300\301!\207" [looking-at "[ ]*$"] 2])
(defalias 'nxml-token-begins-line-p #[nil "\212b\210\301\302x\210n)\207" [xmltok-start " " nil] 2])
#@149 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.
(defalias 'nxml-in-mixed-content-p #[(endp) "\304\305\306!\204\f \304\202I \304\307\310\217\203 \311\202I \304\211 \203& `\202* `\212\n\2037 \nb\210\312 \206@ \205@ b\210\313 +\203H \311\202I \304)\207" [matching-tag-pos end start endp nil run-hook-with-args-until-failure nxml-in-mixed-content-hook (byte-code "\306\211\211\211\211\211\211\211\211 \f
\203% \307`!\205(
\202( \310`!. \211\205G \212b\210\203B \311\306x\210n\202E \312\313!)?\207" [xmltok-errors xmltok-dependent-regions xmltok-namespace-attributes xmltok-attributes xmltok-replacement xmltok-name-end nil nxml-scan-element-backward nxml-scan-element-forward " " looking-at "[ ]*$" xmltok-name-colon xmltok-start xmltok-type endp matching-tag-pos] 10) ((nxml-scan-error)) t nxml-preceding-sibling-data-p nxml-following-sibling-data-p] 3 (#$ . 61174)])
#@61 Return non-nil if there is a previous sibling that is data.
(defalias 'nxml-preceding-sibling-data-p #[nil "`Z ]\306\307\211 \307\211\211\211\211\211\211\211\211 \212
`W\203\207 \f\306Y\203\207 \204\207 `\310\311
\312#\203\207 \313 \210\212\314 \210\f \315=\203Y \fT\202c \316=\203c \fS\306=\203\203 `\nW\203\203 \204\203 \314 \210\317>\203j \312\202j *\202( .\n ,\207" [nxml-mixed-scan-distance nxml-prolog-end end found level lim 0 nil search-backward "<" t nxml-move-outside-backwards xmltok-forward end-tag start-tag (data cdata-section char-ref) xmltok-errors xmltok-dependent-regions xmltok-namespace-attributes xmltok-attributes xmltok-replacement xmltok-name-end xmltok-name-colon xmltok-start xmltok-type prev-level] 9 (#$ . 62178)])
(defalias 'nxml-following-sibling-data-p #[nil "`\\d^\306\307\307\211\211\211\211\211\211\211\211
\212` W\203e \n\306Y\203e \310 \203e \204e \311=\203F \nT\202$ \312=\203S \nS\202$ \n\306=\203$ \313>\203$ \314\202$ .\n +\207" [nxml-mixed-scan-distance found level lim xmltok-errors xmltok-dependent-regions 0 nil nxml-tokenize-forward start-tag end-tag (data cdata-section char-ref) t xmltok-namespace-attributes xmltok-attributes xmltok-replacement xmltok-name-end xmltok-name-colon xmltok-start xmltok-type] 9])
(defalias 'nxml-do-fill-paragraph #[(arg) "\306\211\211\211\212\307 \210`\310 \210\311\306w\210`\312 \210\313` \"` \314\f\315\")\2043 \316\317!\2033 \n\320P\321
#\210)\n\211 \205] `\322 ZGW\205] \212\312 \210\316\323!!)\205] \324\225b)\210\n,\207" [end start fill-prefix fill-paragraph-function pos arg 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 prefix] 5])
(defalias 'nxml-newline-and-indent #[(soft) "\301 \210\203 \302\303!\210\202 \304\305!\210\306 \207" [soft delete-horizontal-space insert-and-inherit 10 newline 1 nxml-indent-line] 2])
(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))
#@910 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.
(defalias 'nxml-dynamic-markup-word #[nil "\306 \250\203= `U\203= \n =\203= \f\203= \307\f8Z\211 \fA@Z\211 \f@Z
|\210|\210\310!+\202B \311!\210\306\211\306\212` \312v\210` W\204[ \313\314!\210\315` \"\211 \316P \306 \203q b\210 \204\243 ` W\203\212 \317 \306\320#\204\223 b\210\321 \306\320#\203\243 \322\225\307Zb\210\323 !\211 \203v \206\272 \313\324\325!!\203\266 \326\202\267 \327 \"-b)\207" [search-start-pos nxml-dynamic-markup-prev-pos last-command this-command nxml-dynamic-markup-prev-lengths end-tag-open-pos 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'" start-tag-close-pos start-tag-open-pos nxml-dynamic-markup-prev-found-marker nxml-dynamic-markup-prev-start-tags pos word search done] 5 (#$ . 64473) "*"])
(defalias 'nxml-try-copy-markup #[(word-end-pos) "\212`\211\306 \307\")?\205\301 \310\311\312\313#\205\301 `\306 \307\")?\205\301 \314 \210\n\305=\205\301 `W\205\301 `\315\f \" \316\315 \"\317\"\237 b\210\203d \320\321@!\322P\312\313#\203d A\323\312x\210\202E ?\205\300 \323\312w\210\324`
B \"?\205\300 `W\204\206 \fW\205\300 \325\313\" \326`
B\313 #\210 \fZ `Z \fZ\327\\E \330 !
c\210 \fZ\\b\210\331!\332\261\210`\211\")+*\207" [end-tag-pos pos xmltok-type start-tag-close-pos xmltok-start start-tag get-text-property nxml-inside search-backward "<" nil t xmltok-forward buffer-substring-no-properties split-string "[
\n]+" re-search-backward regexp-quote "\\=" "
\n" gethash copy-marker puthash 2 xmltok-start-tag-qname "</" ">" words word-end-pos nxml-dynamic-markup-prev-start-tags nxml-dynamic-markup-prev-found-marker xmltok-name-end nxml-dynamic-markup-prev-lengths name nxml-dynamic-markup-prev-pos] 5])
(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 (#$ . 67350))
#@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) (#$ . 67977))
#@47 List of char namesets that can be autoloaded.
(defvar nxml-autoload-char-name-set-list nil (#$ . 68289))
(defalias 'nxml-enable-char-name-set #[(nameset) "\301\302\303#\207" [nameset put nxml-char-name-set-enabled t] 4])
(defalias 'nxml-disable-char-name-set #[(nameset) "\301\302\303#\207" [nameset put nxml-char-name-set-enabled nil] 4])
(defalias 'nxml-char-name-set-enabled-p #[(nameset) "\301N\207" [nameset nxml-char-name-set-enabled] 2])
(defalias 'nxml-autoload-char-name-set #[(nameset file) " >\204\n B\303\304\n#\207" [nameset nxml-autoload-char-name-set-list file put nxml-char-name-set-file] 4])
#@250 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.
(defalias 'nxml-define-char-name-set #[(nameset alist) "\306N\203 \307\310\"\210 \211\203> \n@\211@ \211 A@)
\311
\fB\312
\"B#\210+\n@A\241\210\nA\211\204 ) \244\313\306\314#\207" [nameset alist iter name-code name x nxml-char-name-set-defined error "Nameset `%s' already defined" puthash gethash put t code nxml-char-name-table nxml-char-name-alist] 7 (#$ . 68913)])
(defalias 'nxml-get-char-name #[(code) "\306\307\"\210\310 \n\"\311 \f\2030 \2040 \312\f\211 @@)!\203) \f\211 @A)\202\f \fA\211\204 *\207" [nxml-autoload-char-name-set-list code nxml-char-name-table name names x mapc nxml-maybe-load-char-name-set gethash nil nxml-char-name-set-enabled-p] 4])
(defvar nxml-named-char-history nil)
#@196 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.
(defalias 'nxml-insert-named-char #[(arg) "\306\307\"\210 \310\311 \312\313\314\315&) \314\211 \203L \f\204L \316\"\211\211 AA)\317N\203A
\211 A@)\202
\235A\211\204 \f\205h \203c \320\321\f\"\206g \322\323\f\"\202g \324\325\f\"c,\207" [nxml-autoload-char-name-set-list nxml-char-name-ignore-case completion-ignore-case nxml-char-name-alist code elt mapc nxml-maybe-load-char-name-set completing-read "Character name: " #[(member) "\211AA)\302N\207" [member x nxml-char-name-set-enabled] 3] 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;" alist name x arg] 8 (#$ . 69896) "*P"])
(defalias 'nxml-maybe-load-char-name-set #[(sym) "\301N\205 \302N?\205 \303N;\205 \304\303N!\207" [sym nxml-char-name-set-enabled nxml-char-name-set-defined nxml-char-name-set-file load] 3])
#@67 Toggle the display of extra information for character references.
(defalias 'nxml-toggle-char-ref-extra-display #[(arg) "\204 ?\202 \303!\304V\211 =?\205 \n\305 )\207" [arg nxml-char-ref-extra-display new prefix-numeric-value 0 font-lock-fontify-buffer] 3 (#$ . 70997) "P"])
(put 'nxml-char-ref 'evaporate t)
(defalias 'nxml-char-ref-display-extra #[(start end n) "\205B \306 !\n\205 \307 \310\"\311 \211 \204 \f\205A \312\311\313$\314 \315\316#\210
\2034 \314 \317
#\210\f\205A \314 \320\321\f\322\310##+\207" [nxml-char-ref-extra-display n nxml-char-ref-display-glyph-flag ov glyph-string name 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 start end] 8])
(defalias 'nxml-clear-char-ref-extra-display #[(start end) "\303 \"\211\205 \304\n@\305\"\306=\203 \307\n@!\210\nA\211\204 \310)\207" [start end ov overlays-in overlay-get category nxml-char-ref delete-overlay nil] 4])
(defalias 'nxml-start-delimiter-length #[(type) "\301N\206 \302\207" [type nxml-start-delimiter-length 0] 2])
(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 #[(type) "\301N\206 \302\207" [type nxml-end-delimiter-length 0] 2])
(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 #[(type) "\301N\206 \302!\207" [type nxml-friendly-name symbol-name] 2])
(byte-code "\300\301\302\303#\210\300\304\302\305#\210\300\306\302\307#\210\300\310\302\311#\210\312\313\314\"\210\315\314!\207" [put cdata-section nxml-friendly-name "CDATA section" processing-instruction "processing instruction" entity-ref "entity reference" char-ref "character reference" defalias xml-mode nxml-mode provide] 4)