;ELC   
;;; Compiled by nelson@oikos.local on Sat Jul 23 20:32:08 2005
;;; from file /Users/nelson/Desktop/nxml-mode-20041004/nxml-mode.el
;;; in Emacs version 22.0.50.6
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.
(if (and (boundp 'emacs-version)
	 (< (aref emacs-version (1- (length emacs-version))) ?A)
	 (or (and (boundp 'epoch::version) epoch::version)
	     (string-lessp emacs-version "19.29")))
    (error "`nxml-mode.el' was compiled for Emacs 19.29 or later"))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


(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\315\316\317\320\317\321&\210\313\322\315\323\317\314\317\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 custom-declare-group nxml nil "New XML editing mode" :group languages wp nxml-highlighting-faces "Faces for XML syntax highlighting." font-lock-highlighting-faces] 8)
#@62 *Non-nil means nxml-mode should perform syntax highlighting.
(custom-declare-variable 'nxml-syntax-highlight-flag 't '(#$ . -1086) :group 'nxml :type 'boolean)
#@206 *Non-nil means display glyph following character reference.
The glyph is displayed in `nxml-glyph-face'.  The hook
`nxml-glyph-set-hook' can be used to customize for which characters
glyphs are displayed.
(custom-declare-variable 'nxml-char-ref-display-glyph-flag 't '(#$ . -1253) :group 'nxml :type 'boolean)
#@34 Hook run by command `nxml-mode'.
(custom-declare-variable 'nxml-mode-hook 'nil '(#$ . 1569) :group 'nxml :type 'hook)
#@71 *Non-nil means sexp commands treat an element as a single expression.
(custom-declare-variable 'nxml-sexp-element-flag 'nil '(#$ . -1693) :group 'nxml :type 'boolean)
#@107 *Non-nil means typing a slash automatically completes the end-tag.
This is used by `nxml-electric-slash'.
(custom-declare-variable 'nxml-slash-auto-complete-flag 'nil '(#$ . -1867) :group 'nxml :type 'boolean)
#@187 *Indentation for the children of an element relative to the start-tag.
This only applies when the line or lines containing the start-tag contains
nothing else other than that start-tag.
(custom-declare-variable 'nxml-child-indent '2 '(#$ . -2084) :group 'nxml :type 'integer)
#@255 *Indentation for the attributes of an element relative to the start-tag.
This only applies when the first attribute of a tag starts a line. In other
cases, the first attribute on one line is indented the same as the first
attribute on the previous line.
(custom-declare-variable 'nxml-attribute-indent '4 '(#$ . -2367) :group 'nxml :type 'integer)
(byte-code "\301B\302\301!\204 \303\301\304\"\210\301\207" [current-load-list nxml-fontify-chunk-size default-boundp set-default 500] 3)
#@337 *Non-nil means bind M-TAB in `nxml-mode-map' to `nxml-complete'.
C-return will be bound to `nxml-complete' in any case.
M-TAB gets swallowed by many window systems/managers, and
`documentation' will show M-TAB rather than C-return as the
binding `rng-complete' when both are bound.  So it's better
to bind M-TAB only when it will work.
(custom-declare-variable 'nxml-bind-meta-tab-to-complete-flag '(not window-system) '(#$ . -2862) :group 'nxml :set #[(sym flag) "\303	\"\210\304\302!\205 \n\205 \305\n\306	\205 \307#\207" [sym flag nxml-mode-map set-default boundp define-key "\211" nxml-complete] 4] :type 'boolean)
#@219 *Non-nil means prefer UTF-16 to UTF-8 when saving a buffer.
This is used only when a buffer does not contain an encoding declaration
and when its current `buffer-file-coding-system' specifies neither UTF-16
nor UTF-8.
(custom-declare-variable 'nxml-prefer-utf-16-to-utf-8-flag 'nil '(#$ . -3492) :group 'nxml :type 'boolean)
#@275 *Non-nil means prefer little-endian to big-endian byte-order for UTF-16.
This is used only for saving a buffer; when reading the byte-order is
auto-detected. It may be relevant both when there is no encoding declaration
and when the encoding declaration specifies `UTF-16'.
(custom-declare-variable 'nxml-prefer-utf-16-little-to-big-endian-flag '(eq system-type 'windows-nt) '(#$ . -3824) :group 'nxml :type 'boolean)
#@243 *Default value for `buffer-file-coding-system' for a buffer for a new file.
Nil means use the default value of `buffer-file-coding-system' as normal.
A buffer's `buffer-file-coding-system' affects what \[nxml-insert-xml-declaration] inserts.
(custom-declare-variable 'nxml-default-buffer-file-coding-system 'nil '(#$ . -4249) :group 'nxml :type 'coding-system)
#@140 *Non-nil means automatically insert an XML declaration in a new file.
The XML declaration is inserted using `nxml-insert-xml-declaration'.
(custom-declare-variable 'nxml-auto-insert-xml-declaration-flag 'nil '(#$ . -4617) :group 'nxml :type 'boolean)
(byte-code "\305B\306\307!\210\301B\310\311!\210\303B\312\313!\210\304B\314\315!\210\316B\317\320!\210\302B\321\322!\210\323\324\325\326	DD\327\326\nDDD\330\331\332%\210\323\333\334\326DD\335\326\fDDD\336\331\332%\210\323\337\340\326DD\341\326DDD\342\331\332%\210\323\343\344\326DD\345\326DD\346BB\347\331\332%\210\323\350\351\352\331\332%\210\323\353\354\355\331\332%\210\323\356\357\360\331\332%\210\323\361\362\363\331\332%\210\323\364\365\366\331\332%\210\323\367\370\371\331\332%\210\323\372\373\374\331\332%\210\323\375\376\377\331\332%\210\323\201@ \201A \201B \331\332%\210\323\201C \201D \201E \331\332%\210\323\201F \201G \201H \331\332%\210\323\201I \201J \201K \331\332%\210\323\201L \201M \201N \331\332%\210\323\201O \201P \201Q \331\332%\210\323\201R \201S \201T \331\332%\210\323\201U \201V \201W \331\332%\210\323\201X \201Y \201Z \331\332%\210\323\201[ \201\\ \201] \331\332%\210\323\201^ \201_ \201` \331\332%\210\323\201a \201b \201c \331\332%\210\323\201d \201e \201f \331\332%\210\323\201g \201h \201i \331\332%\210\323\201j \201k \201l \331\332%\210\323\201m \201n \201o \331\332%\210\323\201p \201q \201r \331\332%\210\323\201s \201t \201u \331\332%\210\323\201v \201w \201x \331\332%\210\323\201y \201z \201{ \331\332%\210\323\201| \201} \201~ \331\332%\210\323\201 \201\200 \201\201 \331\332%\210\323\201\202 \201\203 \201\204 \331\332%\210\323\201\205 \201\206 \201\207 \331\332%\210\323\201\210 \201\211 \201\212 \331\332%\210\323\201\213 \201\214 \201\215 \331\332%\207" [current-load-list nxml-dark-blue-color nxml-light-green-color nxml-green-color nxml-sky-blue-color nxml-light-blue-color (lambda (#1=#:defconst-tmp-var) (defconst nxml-light-blue-color #1#)) "#9292C9" (lambda (#2=#:defconst-tmp-var) (defconst nxml-dark-blue-color #2#)) "#3A3A7B" (lambda (#3=#:defconst-tmp-var) (defconst nxml-green-color #3#)) "#257A25" (lambda (#4=#:defconst-tmp-var) (defconst nxml-sky-blue-color #4#)) "#ACACFC" nxml-dark-green-color (lambda (#5=#:defconst-tmp-var) (defconst nxml-dark-green-color #5#)) "#00AD00" (lambda (#6=#:defconst-tmp-var) (defconst nxml-light-green-color #6#)) "#70F170" custom-declare-face nxml-delimited-data-face ((class color) (background light)) :foreground ((class color) (background dark)) "Face used to highlight data enclosed between delimiters.\nBy default, this is inherited by `nxml-attribute-value-face'\nand `nxml-processing-instruction-content-face'." :group nxml-highlighting-faces nxml-name-face ((class color) (background light)) ((class color) (background dark)) "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-face ((class color) (background light)) ((class color) (background dark)) "Face used to highlight character and entity references.\nThis is not used directly, but only via inheritance by other faces." nxml-delimiter-face ((class color) (background light)) ((class color) (background dark)) ((t (:bold t))) "Face used to highlight delimiters.\nThis is not used directly, but only via inheritance by other faces." nxml-text-face nil "Face used to highlight text." nxml-comment-content-face ((t (:italic t))) "Face used to highlight the content of comments." nxml-comment-delimiter-face ((t (:inherit nxml-delimiter-face))) "Face used for the delimiters of comments, i.e <!-- and -->." nxml-processing-instruction-delimiter-face ((t (:inherit nxml-delimiter-face))) "Face used for the delimiters of processing instructions, i.e <? and ?>." nxml-processing-instruction-target-face ((t (:inherit nxml-name-face))) "Face used for the target of processing instructions." nxml-processing-instruction-content-face ((t (:inherit nxml-delimited-data-face))) "Face used for the content of processing instructions." nxml-cdata-section-delimiter-face ((t (:inherit nxml-delimiter-face))) "Face used for the delimiters of CDATA sections, i.e <![, [, and ]]>." nxml-cdata-section-CDATA-face ((t (:inherit nxml-name-face))) "Face used for the CDATA keyword in CDATA sections." nxml-cdata-section-content-face ((t (:inherit nxml-text-face))) "Face used for the content of CDATA sections." nxml-char-ref-number-face ((t (:inherit nxml-ref-face))) "Face used for the number in character references.\nThis includes ths `x' in hex references." nxml-char-ref-delimiter-face ((t (:inherit nxml-ref-face))) "Face used for the delimiters of character references, i.e &# and ;." nxml-entity-ref-name-face ((t (:inherit nxml-ref-face))) "Face used for the entity name in general entity references." nxml-entity-ref-delimiter-face ((t (:inherit nxml-ref-face))) "Face used for the delimiters of entity references, i.e & and ;." nxml-tag-delimiter-face ((t (:inherit nxml-delimiter-face))) "Face used for the angle brackets delimiting tags.\n`nxml-tag-slash-face' is used for slashes." nxml-tag-slash-face ((t (:inherit nxml-name-face))) "Face used for slashes in tags, both in end-tags and empty-elements." nxml-element-prefix-face ((t (:inherit nxml-name-face))) "Face used for the prefix of elements." nxml-element-colon-face ((t (:inherit nxml-name-face))) "Face used for the colon in element names." nxml-element-local-name-face ((t (:inherit nxml-name-face))) "Face used for the local name of elements." nxml-attribute-prefix-face ((t (:inherit nxml-name-face))) "Face used for the prefix of attributes." nxml-attribute-colon-face ((t (:inherit nxml-name-face))) "Face used for the colon in attribute names." nxml-attribute-local-name-face ((t (:inherit nxml-name-face))) "Face used for the local name of attributes." nxml-namespace-attribute-xmlns-face ((t (:inherit nxml-name-face))) "Face used for `xmlns' in namespace attributes." nxml-namespace-attribute-colon-face ((t (:inherit nxml-name-face))) "Face used for the colon in namespace attributes." nxml-namespace-attribute-prefix-face ((t (:inherit nxml-name-face))) "Face used for the prefix declared in namespace attributes." nxml-attribute-value-face ((t (:inherit nxml-delimited-data-face))) "Face used for the value of attributes." nxml-attribute-value-delimiter-face ((t (:inherit nxml-delimiter-face))) "Face used for the delimiters of attribute values." nxml-namespace-attribute-value-face ((t (:inherit nxml-attribute-value-face))) "Face used for the value of namespace attributes." nxml-namespace-attribute-value-delimiter-face ((t (:inherit nxml-attribute-value-delimiter-face))) "Face used for the delimiters of namespace attribute values." nxml-prolog-literal-delimiter-face ((t (:inherit nxml-delimiter-face))) "Face used for the delimiters of literals in the prolog." nxml-prolog-literal-content-face ((t (:inherit nxml-delimited-data-face))) "Face used for the content of literals in the prolog." nxml-prolog-keyword-face ((t (:inherit nxml-name-face))) "Face used for keywords in the prolog." nxml-markup-declaration-delimiter-face ((t (:inherit nxml-delimiter-face))) "Face used for the delimiters of markup declarations in the prolog.\nThe delimiters are <! and >." nxml-hash-face ((t (:inherit nxml-name-face))) "Face used for # before a name in the prolog." nxml-glyph-face ((((type x)) (:family "misc-fixed" :background "light grey" :foreground "black" :weight normal :slant normal)) (t (:background "light grey" :foreground "black" :weight normal :slant normal))) "Face used for glyph for char references."] 6)
#@47 *The version of nxml-mode that is being used.
(defvar nxml-version nil (#$ . -12324))
#@111 List of regions in the prolog to be fontified.
See the function `xmltok-forward-prolog' for more information.
(defvar nxml-prolog-regions nil (#$ . 12417))
(make-variable-buffer-local 'nxml-prolog-regions)
#@98 Position where fontification last ended.
Nil if the buffer changed since the last fontification.
(defvar nxml-last-fontify-end nil (#$ . 12629))
(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 (#$ . 12833))
(make-variable-buffer-local 'nxml-degraded)
#@62 Hook run by `nxml-complete'.
This hook is run until success.
(defvar nxml-completion-hook nil (#$ . 13083))
#@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 (#$ . 13198))
#@70 Maximum distance from point to scan when checking for mixed content.
(defvar nxml-mixed-scan-distance 4000 (#$ . 13482))
#@71 Maximum distance from point to scan backwards when indenting end-tag.
(defvar nxml-end-tag-indent-scan-distance 4000 (#$ . 13609))
#@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 (#$ . 13747))
(make-variable-buffer-local 'nxml-char-ref-extra-display)
#@23 Keymap for nxml-mode.
(defvar nxml-mode-map (byte-code "\303 \304\305\306#\210\304\307\310#\210\304\311\312#\210\304\313\314#\210\304\315\316#\210\304\317\320#\210\304\321\322#\210\304\323\324#\210\304\325\326#\210\304\327\330#\210\304\331\332#\210\304\333\334#\210\304\335\336#\210\304\337\340#\210\304\341	#\210\304\342\343#\210\304\344\345#\210\304\346\347#\210\n\203y \304\350\347#\210)\207" [map nxml-outline-prefix-map nxml-bind-meta-tab-to-complete-flag 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 [C-return] nxml-complete "\211"] 4) (#$ . 14137))
(defalias 'nxml-set-face #[(start end face) "\205 	\nW\205 \303	\n\300$\207" [face start end put-text-property] 5])
(put 'nxml-set-face 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'nxml-clear-face #[(start end) "\302	\303#\210\304	\"\207" [start end remove-text-properties (face nil) nxml-clear-char-ref-extra-display] 4])
(defalias 'nxml-set-fontified #[(start end) "\302	\303\304$\207" [start end put-text-property fontified t] 5])
(put 'nxml-set-fontified 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'nxml-clear-fontified #[(start end) "\302	\303#\207" [start end remove-text-properties (fontified nil)] 4])
(put 'nxml-clear-fontified 'byte-optimizer 'byte-compile-inline-expand)
#@2570 Major mode for editing XML.

Syntax highlighting is performed unless the variable
`nxml-syntax-highlight-flag' is nil.

\[nxml-finish-element] finishes the current element by inserting an end-tag.
C-c C-i closes a start-tag with `>' and then inserts a balancing end-tag
leaving point between the start-tag and end-tag. 
\[nxml-balanced-close-start-tag-block] is similar but for block rather than inline elements:
the start-tag, point, and end-tag are all left on separate lines.
If `nxml-slash-auto-complete-flag' is non-nil, then inserting a `</'
automatically inserts the rest of the end-tag.

\[nxml-complete] performs completion on the symbol preceding point.

\[nxml-dynamic-markup-word] uses the contents of the current buffer
to choose a tag to put around the word preceding point.

Sections of the document can be displayed in outline form.  The
variable `nxml-section-element-name-regexp' controls when an element
is recognized as a section.  The same key sequences that change
visibility in outline mode are used except that they start with C-c C-o
instead of C-c.

Validation is provided by the related minor-mode `rng-validate-mode'.
This also makes completion schema- and context- sensitive.  Element
names, attribute names, attribute values and namespace URIs can all be
completed. By default, `rng-validate-mode' is automatically enabled by
`rng-nxml-mode-init' which is normally added to `nxml-mode-hook'. You
can toggle it using \[rng-validate-mode].

\[indent-for-tab-command] indents the current line appropriately.
This can be customized using the variable `nxml-child-indent'
and the variable `nxml-attribute-indent'.

\[nxml-insert-named-char] inserts a character reference using
the character's name (by default, the Unicode name). \[universal-argument] \[nxml-insert-named-char]
inserts the character directly.

The Emacs commands that normally operate on balanced expressions will
operate on XML markup items.  Thus \[forward-sexp] will move forward
across one markup item; \[backward-sexp] will move backward across
one markup item; \[kill-sexp] will kill the following markup item;
\[mark-sexp] will mark the following markup item.  By default, each
tag each treated as a single markup item; to make the complete element
be treated as a single markup item, set the variable
`nxml-sexp-element-flag' to t.  For more details, see the function
`nxml-forward-balanced-item'.

\[nxml-backward-up-element] and \[nxml-down-element] move up and down the element structure.

Many aspects this mode can be customized using
\[customize-group] nxml RET.
(defalias 'nxml-mode #[nil "\306 \210\307\310\311\302!\210\312\311\303!\210\313\311\304!\210\314\311\305!\210\315\311\316!\210\314\311\317!\210\320\311\321!\210\322\311\323!\210\324\311\325!\210\326\311\327!\210\330\3311!\210\212\214~\210\332ed\"\210\333e\312\"2\334 \335\211\211\312\211\2113*45678\336\2169\203\211 ed:;\337;:\340#\210*ed:;\337;:\341#\210*\335<\342 \210.9\203\254 \343\344\345\312\335$\210\343\346\347\312\335$\210\343\350\351\"\210\352 \203\304 \353\352 !\204\333 =\203\323 \354\355!\204\323 =->\203\333 \356 \210\357\360!\207" [major-mode mode-name adaptive-fill-mode forward-sexp-function indent-line-function fill-paragraph-function kill-all-local-variables nxml-mode "nXML" make-local-variable nil nxml-forward-balanced-item nxml-indent-line 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 use-local-map nxml-clear-dependent-regions copy-marker buffer-modified-p t ((byte-code "\204 \301\302!\210\302\207" [#1=#:modified restore-buffer-modified-p nil] 2)) remove-text-properties (fontified nil) (nxml-inside nil) nxml-scan-prolog add-hook fontification-functions nxml-fontify after-change-functions nxml-after-change write-contents-hooks nxml-prepare-to-save buffer-file-name file-exists-p local-variable-p buffer-file-coding-system nxml-insert-xml-declaration run-hooks nxml-mode-hook nxml-mode-map nxml-scan-end buffer-file-truename deactivate-mark buffer-undo-list inhibit-modification-hooks inhibit-read-only #1# nxml-syntax-highlight-flag end start inhibit-point-motion-hooks nxml-default-buffer-file-coding-system nxml-auto-insert-xml-declaration-flag] 7 (#$ . 15922) nil])
(defalias 'nxml-degrade #[(context err) "\306\307\310	!#\210\311 \210\312\313\212\214~\210\314 \312\211\211\315\211\211\316\216\317ed\"\210ed\320\321\312$\210*ed\322\323#\210.\n\324\211*\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)) nxml-clear-face put-text-property fontified remove-text-properties (nxml-inside nil) "nXML/degraded" deactivate-mark buffer-undo-list inhibit-modification-hooks inhibit-read-only #1# end start mode-name] 7])
(defalias 'nxml-after-change #[(start end pre-change-length) "\303 TV\203 \304\303 T\n?\205 \305\306\307\217\207" [end start nxml-degraded buffer-size 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" [#1=#:modified restore-buffer-modified-p nil] 2)) nxml-after-change1 inhibit-modification-hooks inhibit-read-only #1# start end pre-change-length] 7) ((error (byte-code "\301\302\"\207" [err nxml-degrade nxml-after-change] 3)))] 3])
(defalias 'nxml-after-change1 #[(start end pre-change-length) "\306	\n\\\307	\f\n#\211\310\\X\203% W\203\" d\fZ\\^\311 \210)\fX\2037 	b\210\312 \202r 	X\203e 	eV\203e 	S\313\314\")\203e 	Sb\210\315 \210\312 \316`\f\"\f]\202r 	b\210\312 \316	\f\"\f]\205\233 	\fY\203\221 	dW\203\211 	T\202\221 d\211b\210\312 	\f\317	\f\320#*\207" [nxml-last-fontify-end start pre-change-length pre-change-end end nxml-prolog-end nil nxml-adjust-start-for-dependent-regions 2 nxml-scan-prolog line-beginning-position get-text-property nxml-inside nxml-move-outside-backwards nxml-scan-after-change remove-text-properties (fontified nil) nxml-scan-end pos nxml-syntax-highlight-flag] 5])
#@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 (#$ . 22509) "*"])
(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\340\"\210\202\301 \323\316\341\327!\"P!\203\274 \331	\"\210\202\301 \332\333\334\"\210)\342$!\211%\203\330 %\250\203\330 \343%\"),\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 "%s" ". 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])
(byte-code "\301B\302\303\304!\205 \303\305!\205 \306!\210\307B\310\311	B!\207" [current-load-list nxml-utf-16-coding-systems (lambda (#1=#:defconst-tmp-var) (defconst nxml-utf-16-coding-systems #1#)) coding-system-p utf-16-be utf-16-le (utf-16-be utf-16-le) nxml-utf-coding-systems (lambda (#2=#:defconst-tmp-var) (defconst nxml-utf-coding-systems #2#)) utf-8] 3)
(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-fontify #[(start) "\300\301\302\217\207" [err (byte-code "\212\214~\210\306 \307\216\310\311 \310\211\211\312\211\211\313\216\204) \204< d\314\315\310$*\202@ \316!.\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" [#1=#:modified restore-buffer-modified-p nil] 2)) put-text-property fontified nxml-fontify1 inhibit-modification-hooks inhibit-read-only #1# nxml-degraded nxml-prolog-end start end] 7) ((error (byte-code "\301\302\"\207" [err nxml-degrade nxml-fontify] 3)))] 3])
(defalias 'nxml-fontify1 #[(start) "	W\203 \305 \210e	\306\n\307\310$*\207b\210=\2041 \311f\312\232\204+ \313\314	\310#\210\315 \210\316 \210`\317d\f\\^!\210`\306\n\307\310$+\207" [start nxml-prolog-end end nxml-last-fontify-end nxml-fontify-chunk-size nxml-fontify-prolog put-text-property fontified t nil 60 search-backward "<" nxml-ensure-scan-up-to-date nxml-move-outside-backwards nxml-do-fontify] 5])
(defalias 'nxml-fontify-buffer #[nil "\212\214~\210\306eb\210\307 \306\211\211\310\211\211\f\311\216\312 \210b\210\313 .\207" [inhibit-point-motion-hooks buffer-file-truename buffer-file-name deactivate-mark buffer-undo-list inhibit-modification-hooks t buffer-modified-p nil ((byte-code "\204 \301\302!\210\302\207" [#1=#:modified restore-buffer-modified-p nil] 2)) nxml-fontify-prolog nxml-do-fontify inhibit-read-only #1# nxml-prolog-end] 7 nil nil])
#@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 "\304e\n\"\210	\205# 	@\305\306H\307H\310H#\210)	A\211\204 \311)\207" [nxml-prolog-regions regions nxml-prolog-end region nxml-clear-face nxml-apply-fontify-rule 0 1 2 nil] 6 (#$ . 29000)])
#@78 Fontify at least as far as bound.
Leave point after last fontified position.
(defalias 'nxml-do-fontify #[(&optional bound) "\204 d\304\211`W\205  \305 \205  \306`\"\210\307 \210\202\n *\207" [bound xmltok-errors xmltok-dependent-regions xmltok-start nil nxml-tokenize-forward nxml-clear-face nxml-apply-fontify-rule] 3 (#$ . 29398)])
(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-face] [-1 nil nxml-tag-delimiter-face] (element-qname . 1) attributes) partial-start-tag ([nil 1 nxml-tag-delimiter-face] (element-qname . 1) attributes) end-tag ([nil 1 nxml-tag-delimiter-face] [1 2 nxml-tag-slash-face] [-1 nil nxml-tag-delimiter-face] (element-qname . 2)) partial-end-tag ([nil 1 nxml-tag-delimiter-face] [1 2 nxml-tag-slash-face] (element-qname . 2)) empty-element ([nil 1 nxml-tag-delimiter-face] [-2 -1 nxml-tag-slash-face] [-1 nil nxml-tag-delimiter-face] (element-qname . 1) attributes) partial-empty-element ([nil 1 nxml-tag-delimiter-face] [-1 nil nxml-tag-slash-face] (element-qname . 1) attributes) char-ref ([nil 2 nxml-char-ref-delimiter-face] [2 -1 nxml-char-ref-number-face] [-1 nil nxml-char-ref-delimiter-face] char-ref) entity-ref ([nil 1 nxml-entity-ref-delimiter-face] [1 -1 nxml-entity-ref-name-face] [-1 nil nxml-entity-ref-delimiter-face]) comment ([nil 4 nxml-comment-delimiter-face] [4 -3 nxml-comment-content-face] [-3 nil nxml-comment-delimiter-face]) processing-instruction ([nil 2 nxml-processing-instruction-delimiter-face] [-2 nil nxml-processing-instruction-delimiter-face] processing-instruction-content) cdata-section ([nil 3 nxml-cdata-section-delimiter-face] [3 8 nxml-cdata-section-CDATA-face] [8 9 nxml-cdata-section-delimiter-face] [9 -3 nxml-cdata-section-content-face] [-3 nil nxml-cdata-section-delimiter-face]) data ([nil nil nxml-text-face]) xml-declaration ([nil 2 nxml-processing-instruction-delimiter-face] [2 5 nxml-processing-instruction-target-face] [-2 nil nxml-processing-instruction-delimiter-face]) xml-declaration-attribute-name ([nil nil nxml-attribute-local-name-face]) xml-declaration-attribute-value ([nil 1 nxml-attribute-value-delimiter-face] [1 -1 nxml-attribute-value-face] [-1 nil nxml-attribute-value-delimiter-face]) processing-instruction-left ([nil 2 nxml-processing-instruction-delimiter-face] [2 nil nxml-processing-instruction-target-face]) processing-instruction-right ([nil -2 nxml-processing-instruction-content-face] [-2 nil nxml-processing-instruction-delimiter-face]) literal ([nil 1 nxml-prolog-literal-delimiter-face] [1 -1 nxml-prolog-literal-content-face] [-1 nil nxml-prolog-literal-delimiter-face]) keyword ([nil nil nxml-prolog-keyword-face]) markup-declaration-open ([0 2 nxml-markup-declaration-delimiter-face] [2 nil nxml-prolog-keyword-face]) markup-declaration-close ([nil nil nxml-markup-declaration-delimiter-face]) internal-subset-open ([nil nil nxml-markup-declaration-delimiter-face]) internal-subset-close ([nil 1 nxml-markup-declaration-delimiter-face] [-1 nil nxml-markup-declaration-delimiter-face]) hash-name ([nil 1 nxml-hash-face] [1 nil nxml-prolog-keyword-face])] 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\203\203 W\203\203 \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\203\336 W\203\336 \313\314\f$\210+\212 b\210\326\327w\210`)\312Z\330\f\f\203W\203\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 put-text-property face element-qname nxml-fontify-qname nxml-element-prefix-face nxml-element-colon-face nxml-element-local-name-face attributes nxml-fontify-attributes processing-instruction-content nxml-processing-instruction-target-face " 	\n" nil nxml-processing-instruction-content-face 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\"\210A\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\205S\203\210 W\203\210 \327\330$\210+\211T\203\247 W\203\247 \327\330$\210+\f\203\366 \f@\211\307H\310H\311H\n\203\340 W\203\340 \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-face nxml-namespace-attribute-colon-face nxml-namespace-attribute-prefix-face nxml-attribute-prefix-face nxml-attribute-colon-face nxml-attribute-local-name-face 3 4 6 nxml-namespace-attribute-value-delimiter-face nxml-attribute-value-delimiter-face nxml-namespace-attribute-value-face nxml-attribute-value-face put-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\203 	\fW\203 \306	\f\303$\210+\211T\2034 	\fW\2034 \306	\f\303$\210+T\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 put-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`\211Sf\307=\205 \310	\311\")?\212\312 \210`S)=\313\314\f!!\210\f?\205W \203M \n\203: \315\316\317\217\202W \320 `=\205W \321=\205W \322c\202W \n\205W \205W \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 err (byte-code "\304S\305\"\211\205, \306 \307\261\210\n\205, \212b\210\310 \210`)=\205, \212\311\212b\210i)!))\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 (#$ . 35910) "*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 (#$ . 37094) "*"])
#@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 (#$ . 37528) "*"])
(defalias 'nxml-balanced-close-start-tag #[(block-or-inline) "\306 `T\n\307=\204 \n\310>\203 	Y\204 \311\312!\210\313\314T\f`^\"\315\261\210\316=\2033 b\202` b\210\317 \210`U\203^ ib\210\320c\210\321!\210b\210\322c\210\321\\!)\202` b*\207" [pos token-end xmltok-type xmltok-start xmltok-name-end block-or-inline 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 "\n" 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 (#$ . 38393) "*"])
#@64 Position where `nxml-split-element' split the current element.
(defvar nxml-last-split-position nil (#$ . 38553))
#@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 (#$ . 38674) "*"])
#@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~ \330c\210\325!\210`\331\332\261\210\f\203\265 \203\265 \333c\210\325\212b\210\334y\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 "</" ">" "\n" "<" ">" "\n" 1 start-tag-indent qname inserted-start-tag-pos startp nxml-child-indent] 4 (#$ . 39099) "*"])
#@29 Indent current line as XML.
(defalias 'nxml-indent-line #[nil "\303 d`Z\211\205( \304 \210`\305\306w\210\n`|\210)	j\210dZ`V\205( dZb*\207" [from-end indent bol nxml-compute-indent beginning-of-line " 	" nil] 4 (#$ . 40259)])
#@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 (#$ . 40495)])
#@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 \212b\210\312 \210U)\2047 \n\313=\205Q \314\315\316\217\205Q W\205Q b\210\317\306x\210n\205Q \320 *\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 err (byte-code "\301`\302`Z#\207" [nxml-end-tag-indent-scan-distance nxml-scan-element-backward nil] 5) ((nxml-scan-error)) " 	" current-indentation] 3 (#$ . 40713)])
#@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 (#$ . 41612)])
#@215 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 (#$ . 42662)])
#@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 (#$ . 43303)])
#@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@\nAb\210\310y\210`\fW\203\" \fb\210\202% \311 \210*\202o b\210\310y\307U\2039 \306`!\204, `X\203l b\210\312 \211\f\203h \f@\211\211\307H)\211W\203g b\210\307*)\202o \311 \210i	\\*\207" [pos off value-boundary value-end value-start xmltok-start nxml-attribute-value-boundary 0 -1 back-to-indentation xmltok-merge-attributes nxml-attribute-indent atts att start] 3 (#$ . 44032)])
#@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 (#$ . 44774)])
#@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\\\211dX\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 (#$ . 45356)])
#@531 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 (#$ . 46031) nil])
#@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 \210S\211\302V\2050 \202\f \302W\2050 \304 \210T\211\302W\2050 \202! \207" [arg 1 0 nxml-forward-single-balanced-item nxml-backward-single-balanced-item] 2 (#$ . 46764) "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 "\211A@)b\210\302\303\211AA)\"\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 "\211A@)b\210\302\303\211AA)\"\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 "\211A@)b\210\302\303\211AA)\"\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 "\211A@)b\210\302\303\211AA)\"\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\210S\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 (#$ . 53092) "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\210S\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\210S\211\202 \207" [arg 0 nxml-scan-element-forward nxml-token-before error "No more elements"] 3) ((nxml-scan-error (byte-code "\211A@)b\210\302\303\211AA)\"\207" [err x apply error] 4)))] 3 (#$ . 54187) "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\210S\211\202 \207" [arg xmltok-start 0 nxml-scan-element-backward nxml-token-after error "No preceding elements"] 3) ((nxml-scan-error (byte-code "\211A@)b\210\302\303\211AA)\"\207" [err x apply error] 4)))] 3 (#$ . 54712) "p"])
(defalias 'nxml-mark-token-after #[nil "\302\303 \304\305#\210b\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 (#$ . 55445) 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 (#$ . 56239)])
#@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 (#$ . 56642)])
(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\321\n\322Z\313#\205u \311\323\n\313#\203c \310\224\202u \n\322Zb\210\324\325x\210n\204t \326\327!\210`*\207	\330>\203\221 \212`\f\\b\210\311\331\n\313#\205\217 \310\224*\207	\332>\203\254 \316 \203\254 \317 \203\254 \212b\210\333\325x\210`)\207	\334=\205\312 \335\336!\205\312 \337\313!?\205\312 \212\340\341\325\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 "[^ 	\n]" 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 (#$ . 57743)])
#@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\320\317\\\312#\205z \310\321\312#\203g \307\224\202z b\210\322\323!\203u \307\225\202z \324\325x\210`)\207	\326>\203\224 \212`\nZb\210\310\327\312#\205\222 \307\224)\207	\330>\203\256 \315 \203\256 \316 \203\256 \331\332\325\312#\206\351 d\207	\333=\205\351 \316 \205\351 \212b\210\334\325!)?\205\351 \212b\210\335\325x\210`Sf\336=\203\347 \212`Sb\210\337\325x\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 "[^ 	\n]" "^[ 	]*$" 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 (#$ . 59055)])
(defalias 'nxml-token-ends-line-p #[nil "\300\301!\207" [looking-at "[ 	]*$"] 2])
(defalias 'nxml-token-begins-line-p #[nil "\212b\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 \307\310\311\217\203 \312\202I \304\211\203& `\202* `\212\n\2037 \nb\210\313 \206@ 	\205@ 	b\210\314 +\203H \312\202I \304)\207" [matching-tag-pos end start endp nil run-hook-with-args-until-failure nxml-in-mixed-content-hook err (byte-code "\306\211\211\211\211\211\211\211\211\f\203% \307`!\205( \202( \310`!.	\211\205G \212b\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 (#$ . 60615)])
#@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 (#$ . 61623)])
(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\203^ `\322 ZGW\203^ \212\312 \210\316\323!!)\203^ \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])
(byte-code "\301B\302\301!\204 \303\301\304\"\210\305B\302\305!\204 \303\305\304\"\210\306B\302\306!\204- \303\306\304\"\210\307B\302\307!\204? \303\307\310\311\312\"\"\210\304\207" [current-load-list nxml-dynamic-markup-prev-pos default-boundp set-default nil nxml-dynamic-markup-prev-lengths nxml-dynamic-markup-prev-found-marker nxml-dynamic-markup-prev-start-tags make-hash-table :test equal] 5)
#@908 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\211\n\250\203A \n`U\203A \f=\203A \203A \n\3078Z\211A@Z\211@Z\n|\210|\210\310!+\202F \311!\210\306\211\306\212`\312v\210`W\204_ \313\314!\210\315`\"\211\316P\306	\203t 	b\210\204\244 `W\203\214 \317\306\320#\204\225 b\210\321\306\320#\203\244 \322\225\307Zb\210\323!\211\203x \206\272 \313\324\325!!\203\266 \326\202\267 \327\"-b*\207" [done search-start-pos nxml-dynamic-markup-prev-pos last-command this-command nxml-dynamic-markup-prev-lengths 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'" end-tag-open-pos start-tag-close-pos start-tag-open-pos nxml-dynamic-markup-prev-found-marker nxml-dynamic-markup-prev-start-tags pos word search] 5 (#$ . 64113) "*"])
(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 \324\312w\210\325`B\"?\205\300 `W\204\206 \fW\205\300 \326\313\"\327`B\313#\210\fZ`Z \fZ\330\\E!\331 \"c\210\fZ\\b\210\332\"\333\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" " 	\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])
(byte-code "\301B\302\301!\204 \303\301\304\"\210\304\207" [current-load-list nxml-char-name-ignore-case default-boundp set-default nil] 3)
#@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 (#$ . 67105))
#@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) (#$ . 67732))
#@47 List of char namesets that can be autoloaded.
(defvar nxml-autoload-char-name-set-list nil (#$ . 68044))
(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 (#$ . 68668)])
(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 mapcar nxml-maybe-load-char-name-set gethash nil nxml-char-name-set-enabled-p] 4])
(byte-code "\301B\302\301!\204 \303\301\304\"\210\304\207" [current-load-list nxml-named-char-history default-boundp set-default nil] 3)
#@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 mapcar nxml-maybe-load-char-name-set completing-read "Character name: " #[(member) "\211AA)\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 (#$ . 69756) "*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])
#@68 *Toggle the display of extra information for character references.
(defalias 'nxml-toggle-char-ref-extra-display #[(arg) "\204	 	?\202 \306!\307V\211	=?\205L \n\212\214~\210	\203G \310 \311\211\211\312\211\211\313\216ed\314\315#.\n\202K \316ed\"*)\207" [arg nxml-char-ref-extra-display new buffer-file-truename buffer-file-name deactivate-mark prefix-numeric-value 0 buffer-modified-p t nil ((byte-code "\204 \301\302!\210\302\207" [#1=#:modified restore-buffer-modified-p nil] 2)) remove-text-properties (fontified nil) nxml-clear-char-ref-extra-display buffer-undo-list inhibit-modification-hooks inhibit-read-only #1# end start] 8 (#$ . -70859) "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-face 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])
#@51 Show the version of nXML mode that is being used.
(defalias 'nxml-version #[nil "\203	 \301\302\"\207\301\303!\207" [nxml-version message "nXML mode version %s" "nXML mode version unknown"] 3 (#$ . 72269) nil])
(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!\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)