;ELC
;;; Compiled by mockbuild@buildfarm06-new.corp.cloudlinux.com on Fri Oct 11 10:08:33 2024
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/nxml/xmltok.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.

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


(defvar xmltok-type nil)
(defvar xmltok-start nil)
(defvar xmltok-name-colon nil)
(defvar xmltok-name-end nil)
#@68 String containing replacement for a character or entity reference.
(defvar xmltok-replacement nil (#$ . 665))
#@377 List containing attributes of last scanned element.
Each member of the list is a vector representing an attribute, which
can be accessed using the functions `xmltok-attribute-name-start',
`xmltok-attribute-name-colon', `xmltok-attribute-name-end',
`xmltok-attribute-value-start', `xmltok-attribute-value-end',
`xmltok-attribute-raw-normalized-value', `xmltok-attribute-refs'.
(defvar xmltok-attributes nil (#$ . 782))
#@110 List containing namespace declarations of last scanned element.
List has same format as `xmltok-attributes'.
(defvar xmltok-namespace-attributes nil (#$ . 1207))
#@1219 Information about the DTD used by `xmltok-forward'.
`xmltok-forward-prolog' sets this up.

It consists of an alist of general entity names vs definitions.  The
first member of the alist is t if references to entities not in the
alist are well-formed (e.g. because there's an external subset that
wasn't parsed).

Each general entity name is a string.  The definition is either nil,
a symbol, a string, a cons cell.  If the definition is nil, then it
means that it's an internal entity but the result of parsing it is
unknown.  If it is a symbol, then the symbol is either `unparsed',
meaning the entity is an unparsed entity, `external', meaning the
entity is or references an external entity, `element', meaning the
entity includes one or more elements, or `not-well-formed', meaning
the replacement text is not well-formed.  If the definition is a
string, then the replacement text of the entity is that string; this
happens only during the parsing of the prolog.  If the definition is
a cons cell (ER . AR), then ER specifies the string that results
from referencing the entity in element content and AR is either nil,
meaning the replacement text included a <, or a string which is the
normalized attribute value.
(defvar xmltok-dtd nil (#$ . 1377))
#@1474 List of descriptors of regions that a parsed token depends on.

A token depends on a region if the region occurs after the token and a
change in the region may require the token to be reparsed.  This only
happens with markup that is not well-formed.  For example, if a <?
occurs without a matching ?>, then the <? is returned as a
not-well-formed token.  However, this token is dependent on region
from the end of the token to the end of the buffer: if this ever
contains ?> then the buffer must be reparsed from the <?.

A region descriptor is a list (FUN START END ARG ...), where FUN is a
function to be called when the region changes, START and END are
integers giving the start and end of the region, and ARG... are
additional arguments to be passed to FUN.  FUN will be called with 5
arguments followed by the additional arguments if any: the position of
the start of the changed area in the region, the position of the end
of the changed area in the region, the length of the changed area
before the change, the position of the start of the region, the
position of the end of the region.  FUN must return non-nil if the
region needs reparsing.  FUN will be called in a `save-excursion'
with match-data saved.

`xmltok-forward', `xmltok-forward-special' and `xmltok-forward-prolog'
may add entries to the beginning of this list, but will not clear it.
`xmltok-forward' and `xmltok-forward-special' will only add entries
when returning tokens of type not-well-formed.
(defvar xmltok-dependent-regions nil (#$ . 2639))
#@375 List of errors detected by `xmltok-forward' and `xmltok-forward-prolog'.
When `xmltok-forward' and `xmltok-forward-prolog' detect a
well-formedness error, they will add an entry to the beginning of this
list.  Each entry is a vector [MESSAGE START END], where MESSAGE is a
string giving the error message and START and END are integers
indicating the position of the error.
(defvar xmltok-errors nil (#$ . 4169))
(defalias 'xmltok-save '(macro . #[(&rest body) "\301\302BB\207" [body let (xmltok-type xmltok-start xmltok-name-colon xmltok-name-end xmltok-replacement xmltok-attributes xmltok-namespace-attributes xmltok-dependent-regions xmltok-errors)] 3]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put xmltok-save lisp-indent-function 0 edebug-form-spec t] 4)
(defalias 'xmltok-attribute-name-start #[(att) "\301H\207" [att 0] 2])
(put 'xmltok-attribute-name-start 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'xmltok-attribute-name-colon #[(att) "\301H\207" [att 1] 2])
(put 'xmltok-attribute-name-colon 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'xmltok-attribute-name-end #[(att) "\301H\207" [att 2] 2])
(put 'xmltok-attribute-name-end 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'xmltok-attribute-value-start #[(att) "\301H\207" [att 3] 2])
(put 'xmltok-attribute-value-start 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'xmltok-attribute-value-end #[(att) "\301H\207" [att 4] 2])
(put 'xmltok-attribute-value-end 'byte-optimizer 'byte-compile-inline-expand)
#@252 Return an object representing the normalized value of ATT.
This can be t indicating that the normalized value is the same as
the buffer substring from the start to the end of the value, or nil
indicating that the value is not well-formed or a string.
(defalias 'xmltok-attribute-raw-normalized-value #[(att) "\301H\207" [att 5] 2 (#$ . 5706)])
(put 'xmltok-attribute-raw-normalized-value 'byte-optimizer 'byte-compile-inline-expand)
#@277 Return a list of the entity and character references in ATT.
Each member is a vector [TYPE START END] where TYPE is either char-ref
or entity-ref and START and END are integers giving the start and end of
the reference.  Nested entity references are not included in the list.
(defalias 'xmltok-attribute-refs #[(att) "\301H\207" [att 6] 2 (#$ . 6147)])
(put 'xmltok-attribute-refs 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'xmltok-attribute-prefix #[(att) "\211\302H)\211\205\303\211\304H)	\")\207" [att colon 1 buffer-substring-no-properties 0] 4])
(defalias 'xmltok-attribute-local-name #[(att) "\211\302H)\303	\203	T\202\211\304H)\211\305H)\")\207" [att colon 1 buffer-substring-no-properties 0 2] 5])
(defalias 'xmltok-attribute-value #[(att) "\211\302H)\211\205\"	;\203	\202\"\303\211\304H)\211\305H)\")\207" [att rnv 5 buffer-substring-no-properties 3 4] 5])
(defalias 'xmltok-start-tag-prefix #[nil "\205	\302	T\"\207" [xmltok-name-colon xmltok-start buffer-substring-no-properties] 3])
(defalias 'xmltok-start-tag-local-name #[nil "\303\206	T\n\"\207" [xmltok-name-colon xmltok-start xmltok-name-end buffer-substring-no-properties] 3])
(defalias 'xmltok-end-tag-prefix #[nil "\205\n\302\303	\\\"\207" [xmltok-name-colon xmltok-start buffer-substring-no-properties 2] 3])
(defalias 'xmltok-end-tag-local-name #[nil "\303\203\nT\202
\304	\\\n\"\207" [xmltok-name-colon xmltok-start xmltok-name-end buffer-substring-no-properties 2] 3])
(defalias 'xmltok-start-tag-qname #[nil "\302T	\"\207" [xmltok-start xmltok-name-end buffer-substring-no-properties] 3])
(defalias 'xmltok-end-tag-qname #[nil "\302\303\\	\"\207" [xmltok-start xmltok-name-end buffer-substring-no-properties 2] 3])
#@193 Make an attribute.
RAW-NORMALIZED-VALUE is nil if the value is not well-formed,
t if the normalized value is the string between VALUE-BEGIN
and VALUE-END, otherwise a STRING giving the value.
(defalias 'xmltok-make-attribute #[(name-begin name-colon name-end &optional value-begin value-end raw-normalized-value) "\306	\n\f
\307&\207" [name-begin name-colon name-end value-begin value-end raw-normalized-value vector nil] 8 (#$ . 7901)])
(put 'xmltok-make-attribute 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'xmltok-error-message #[(err) "\301H\207" [err 0] 2])
(put 'xmltok-error-message 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'xmltok-error-start #[(err) "\301H\207" [err 1] 2])
(put 'xmltok-error-start 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'xmltok-error-end #[(err) "\301H\207" [err 2] 2])
(put 'xmltok-error-end 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'xmltok-make-error #[(message start end) "\303	\n#\207" [message start end vector] 4])
(put 'xmltok-make-error 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'xmltok-add-error #[(message &optional start end) "	\206\n\206`\305	#+\fB\211\207" [message start xmltok-start end xmltok-errors vector] 4])
(defalias 'xmltok-add-dependent #[(fun &optional start end &rest args) "	\206\n\206d\fBBB
B\211\207" [fun start xmltok-start end args xmltok-dependent-regions] 4])
(defalias 'xmltok-forward #[nil "`\305\306\305w\305f\211\307=\203%\n\310V\203\311\211\202\226\312u\210\313 \202\226\314=\203@\n\310V\2037\311\211\202\226\312u\210\315\316!\202\226\317\320\305\321#\203~\312\224\204W\310\224b\210\322\211\202\226\312\224U\203h\323\324!\210\325\211\202\226\310\224b\210`\n\\U\203x\311\202y\322\211\202\226\305=\203\220\n\310V\205\213\311\211\202\226db\210\322\211+\207" [xmltok-start case-fold-search space-count ch xmltok-type nil " 	
\n" 60 0 space 1 xmltok-scan-after-lt 38 xmltok-scan-after-amp xmltok-handle-entity re-search-forward "[<&]\\|\\(]]>\\)" t data xmltok-add-error "Found `]]>' not closing a CDATA section" not-well-formed] 5])
#@296 Scan forward past the first special token starting at or after point.
Return nil if there is no special token that starts before BOUND.
CDATA sections, processing instructions and comments (and indeed
anything starting with < following by ? or !) count as special.
Return the type of the token.
(defalias 'xmltok-forward-special #[(bound) "\303\304T\305#\205\306\224\211Tb\210\307\310 )\207" [bound xmltok-start case-fold-search re-search-forward "<[?!]" t 0 nil xmltok-scan-after-lt] 5 (#$ . 10031)])
(defconst xmltok-ncname-regexp "\\(?:[_[:alpha:]][-._[:alnum:]]*\\)")
(defalias 'xmltok-scan-after-lt #[nil "\306\307!\204\310\311!\210\312\211\207\313\225b\210\314\224\203%\315\225\316\224\317\211\320\211\207\321\224\2034\322\225\323\224\324\211\207\325\224\203H\315\225\316\224\317\211\326 \210\207\327\224\203[\315\225\316\224\317\211\330\211\207\331\224\203{\332\333\317\334#\203l\335\202x\310\336!\210\337\340\317\211\333$\210\312\211\207\341\224\203\203\342 \207\343\224\203\213\344 \207\345\224\203\244\315\225\316\224\317\211\310\346`S\"\210\347\211\207\315\224\203\276\310\350\317
T#\210\315\225\316\224\317\211\351\211\207\322\224\203\354\322\225\323\224\211\204\341\317f\352=\203\341`Tb\210\310\353`S\"\210\202\350\310\350\317
T#\210\354\211\207\355\224\203\375\310\356!\210\317\211\354\211\207\357\224\203
\310\360
\314
\\#\210\312\211\207\361\224\203
\310\362
\314
\\#\210\312\211\207\363\224\2030
\310\364
\316
\\#\210\312\211\207\310\365!\210\312\211\207" [xmltok-type xmltok-name-end xmltok-name-colon xmltok-attributes xmltok-namespace-attributes xmltok-start looking-at "\\([_[:alpha:]][-._[:alnum:]]*\\(:[_[:alpha:]][-._[:alnum:]]*\\)?\\)\\(?:\\([ 
	\n]*>\\)\\|\\(?:\\([ 
	\n]*/\\)\\(>\\)?\\)\\|\\([ 
	\n]+\\)\\)?\\|\\(/\\)\\(?:\\([_[:alpha:]][-._[:alnum:]]*\\(:[_[:alpha:]][-._[:alnum:]]*\\)?\\)\\([ 
	\n]*>\\)?\\)?\\|!\\(\\[\\)\\(?:C\\(?:D\\(?:A\\(?:T\\(?:A\\(\\[\\)?\\)?\\)?\\)?\\)?\\)?\\|\\(!\\)\\(-\\(-\\)?\\)?\\|\\(\\?\\)" xmltok-add-error "`<' that is not markup must be entered as `&lt;'" not-well-formed 0 3 1 2 nil start-tag 10 8 9 end-tag 6 xmltok-scan-attributes 5 empty-element 12 search-forward "]]>" t cdata-section "No closing ]]>" xmltok-add-dependent xmltok-unclosed-reparse-p 16 xmltok-scan-after-processing-instruction-open 15 xmltok-scan-after-comment-open 4 "Expected `/>'" partial-empty-element "Missing `>'" partial-start-tag 58 "Expected name following `:'" partial-end-tag 7 "Expected name following `</'" 11 "Expected `CDATA[' after `<!['" 14 "Expected `-' after `<!-'" 13 "Expected `[CDATA[' or `--' after `<!'" "Not well-formed"] 6])
(defalias 'xmltok-scan-after-processing-instruction-open #[nil "\304\305\306\307#\204\310\311\211\312\\#\210\313\314\306\211\305$\210\315\211\207\212\312\\b\210\316\317!\205+\320\225\211)\204@\312\\\310\321\312\\\322\\#\210\202z\nf\323>\204Y\n`\312ZU\204Y\310\324\n\211T#\210\202z\n\325\\U\203z\212\312\\b\210\307\316\326!*\203z\310\327\312\\\325\\#\210\330\211\207" [xmltok-start xmltok-type xmltok-name-end case-fold-search search-forward "?>" nil t xmltok-add-error "No closing ?>" 2 xmltok-add-dependent xmltok-unclosed-reparse-p not-well-formed looking-at "\\(?:[_[:alpha:]][-._[:alnum:]]*\\)" 0 "<? not followed by name" 3 (10 9 13 32) "Target not followed by whitespace" 5 "xml" "Processing instruction target is xml" processing-instruction] 5])
(defalias 'xmltok-scan-after-comment-open #[nil "\302\303\304\305#\204\306\307!\210\310\311\304\211\303$\210\312\2028\304f\313=\203&`Tb\210\314\2028\310\315\304`\303\316%\210\317\\b\210\306\320!\210\312\211\207" [xmltok-start xmltok-type search-forward "--" nil t xmltok-add-error "No closing -->" xmltok-add-dependent xmltok-unclosed-reparse-p not-well-formed 62 comment xmltok-semi-closed-reparse-p 2 4 "First following `--' not followed by `>'"] 6])
(defalias 'xmltok-scan-attributes #[nil "\306\211\307\310!\204$\307\311!\203\224	\204$\312\313`\212\314\224b\210\315\306x\210`)#\210\306\316\225b\210\317 \211\2035\nB)\320\224\204\321\224\203E\322\202\340\323\224\203O\324\202\340\325\224\203_\326\312\327`S\"\210\202\340\307\330!\203t\316\225b\210\312\331`S\"\210\332\202\307\333!\203\211\314\225b\210\312\334\314\224\"\210\332\202\312\335`S\"\210\332\202\307\336!\203\262`\316\225b\210	\204\254\312\337\f`\340Z#\210)\324\202\340\307\341!\203\317`\316\225b\210	\204\311\312\342\f`S#\210)\322\202\340	\203\327\343\306w\210\312\344
\211T#\210\345\203\360\346@!\210A\211\204\344*'\237'(\237\211(\207" [atts-needing-normalization recovering att xmltok-type start xmltok-start nil looking-at "\\(\\(?:\\(xmlns\\)\\|[_[:alpha:]][-._[:alnum:]]*\\)\\(:[_[:alpha:]][-._[:alnum:]]*\\)?\\)[ 
	\n]*=\\(?:[ 
	\n]*\\('[^<'&
\n	]*\\([&
\n	][^<']*\\)?'\\|\"[^<\"&
\n	]*\\([&
\n	][^<\"]*\\)?\"\\)\\(?:\\([ 
	\n]*>\\)\\|\\(?:\\([ 
	\n]*/\\)\\(>\\)?\\)\\|\\([ 
	\n]+\\)\\)\\)?" "[^<>\n]+?\\(\\(?:\\(xmlns\\)\\|[_[:alpha:]][-._[:alnum:]]*\\)\\(:[_[:alpha:]][-._[:alnum:]]*\\)?\\)[ 
	\n]*=\\(?:[ 
	\n]*\\('[^<'&
\n	]*\\([&
\n	][^<']*\\)?'\\|\"[^<\"&
\n	]*\\([&
\n	][^<\"]*\\)?\"\\)\\(?:\\([ 
	\n]*>\\)\\|\\(?:\\([ 
	\n]*/\\)\\(>\\)?\\)\\|\\([ 
	\n]+\\)\\)\\)?" xmltok-add-error "Malformed attribute" 1 "
\n	 " 0 xmltok-add-attribute 10 7 start-tag 9 empty-element 8 partial-empty-element "Expected `/>'" "[ 	
\n]*[\"']" "Missing closing delimiter" t "[ 	]*\\([^ 	
\n\"'=<>/]+\\)[ 	
\n/>]" "Attribute value not quoted" "Missing attribute value" "[^<>\n]*/>" "Malformed empty-element" 2 "[^<>\n]*>" "Malformed start-tag" "^<>\n" "Missing `>'" partial-start-tag xmltok-normalize-attribute xmltok-attributes xmltok-namespace-attributes] 6])
#@62 Return the attribute if it needs normalizing, otherwise nil.
(defalias 'xmltok-add-attribute #[nil "\306\307\224\2034\310\224\206\311\224\312\224\313\224\312\225\307\224T\307\225S?\314
\f\n	\306&.\202Q\312\224\313\224\312\225\306\211\211\314
\f\n	\306&.\315\224\203bB\202iB\205o*\207" [needs-normalizing raw-normalized-value value-end value-begin name-end name-colon nil 4 5 6 1 3 vector 2 name-begin att xmltok-namespace-attributes xmltok-attributes] 8 (#$ . 15743)])
(defalias 'xmltok-normalize-attribute #[(att) "\211\306H)\307\310\211\212\211\311H)b\210\312\fw\211\313V\203)\314`
Z`\"\nB)`\fW\203~`Tb\210`Sf\315=\203z`S\310\211\316\317!\210\320=\204X\321=\203t\322`#	B\203o\nB\202v\310\202v\310+\202~\323\nB`\fW\204)\203\222\324\325\326\n\237\"I\210\327	\237I,\207" [att refs value-parts well-formed end n 4 t nil 3 "^
	\n&" 0 buffer-substring-no-properties 38 xmltok-scan-after-amp #[(start end) "\302	\303#\207" [start end xmltok-handle-entity t] 4] char-ref entity-ref vector " " 5 apply concat 6 xmltok-replacement xmltok-type xmltok-start] 6])
(defalias 'xmltok-scan-after-amp #[(entity-handler) "\302\303!\204\304\305!\210\306\211\207\307\225b\210\310\224\203\"	\311\224\311\225\"\210\312\211\207\313\224\203/\314\315\224\315\225\316#\207\317\224\203<\314\320\224\320\225\321#\207\322\224\203I\304\323!\210\306\211\207\304\324!\210\306\211\207" [xmltok-type entity-handler looking-at "\\([_[:alpha:]][-._[:alnum:]]*\\)\\(;\\)?\\|\\(#\\)\\(?:\\([0-9]+\\)\\(;\\)?\\|x\\(?:\\([0-9a-fA-F]+\\)\\(;\\)?\\)?\\)?" xmltok-add-error "`&' that is not markup must be entered as `&amp;'" not-well-formed 0 2 1 entity-ref 5 xmltok-scan-char-ref 4 10 7 6 16 3 "Missing character number" "Missing closing `;'"] 4])
(defconst xmltok-entity-error-messages '((unparsed . "Referenced entity is unparsed") (not-well-formed . "Referenced entity is not well-formed") (external nil . "Referenced entity is external") (element nil . "Referenced entity contains <")))
(defalias 'xmltok-handle-entity #[(start end &optional attributep) "\306	\"\307\n\"\211A\211:\205\f\203
A\202
@\211
\206r\f\2048@\310=?\205r\311\312	#\202r\f\203J
:\203J\311\313	#\202r
\236A\211:\203f\f\203aA\202d@\205q\311	#)+\207" [start end name xmltok-dtd name-def def buffer-substring-no-properties assoc t xmltok-add-error "Referenced entity has not been defined" "Referenced entity contains <" attributep xmltok-replacement xmltok-entity-error-messages err] 5])
(defalias 'xmltok-scan-char-ref #[(start end base) "\306\307	\"\n\"\211\250\203!\310!\203!\311!\211\205(\312!\202(\313\314	#\210\315)\316\211\207" [start end base n xmltok-replacement xmltok-type string-to-number buffer-substring-no-properties xmltok-valid-char-p xmltok-unicode-to-char string xmltok-add-error "Invalid character code" nil char-ref] 5])
(defalias 'xmltok-char-number #[(start end) "\304\\f\305=\203
\306\202\307\310\311	\306U\203\312\202\304\\\nS\"	\"\211\250\2050\313!\2050*\207" [start base end n 2 120 16 10 string-to-number buffer-substring-no-properties 3 xmltok-valid-char-p] 6])
(defalias 'xmltok-unclosed-reparse-p #[(change-start change-end pre-change-length start end delimiter) "GS\n	Z]b\210\306\f
	\\^\307#)\207" [delimiter len-1 start change-start end change-end search-forward t] 5])
(defalias 'xmltok-semi-closed-reparse-p #[(change-start change-end pre-change-length start end delimiter delimiter-length) "	Z\nX\206\306\n\f
&\207" [end delimiter-length change-end change-start pre-change-length start xmltok-unclosed-reparse-p delimiter] 7])
#@67 Return non-nil if N is the Unicode code of a valid XML character.
(defalias 'xmltok-valid-char-p #[(n) "\301W\203\n\302>\207\303W\203\304\207\305W\203\306\207\307W\203\"\304\207\310V\205+\311W\207" [n 32 (10 13 9) 55296 t 57344 nil 65534 65535 1114112] 2 (#$ . 19439)])
#@99 Return the character corresponding to Unicode scalar value N.
Return nil if unsupported in Emacs.
(defalias 'xmltok-unicode-to-char #[(n) "\301\302\"\207" [n decode-char ucs] 3 (#$ . 19729)])
(defvar xmltok-contains-doctype nil)
(defvar xmltok-doctype-external-subset-flag nil)
(defvar xmltok-internal-subset-start nil)
(defvar xmltok-had-param-entity-ref nil)
(defvar xmltok-prolog-regions nil)
#@70 Non-nil if there was an XML declaration specifying standalone="yes".
(defvar xmltok-standalone nil (#$ . 20132))
(defvar xmltok-markup-declaration-doctype-flag nil)
(defconst xmltok-predefined-entity-alist '(("lt" "<" . "<") ("gt" ">" . ">") ("amp" "&" . "&") ("apos" "'" . "'") ("quot" "\"" . "\"")))
#@576 Move forward to the end of the XML prolog.

Returns a list of vectors [TYPE START END] where TYPE is a symbol and
START and END are integers giving the start and end of the region of
that type.  TYPE can be one of xml-declaration,
xml-declaration-attribute-name, xml-declaration-attribute-value,
comment, processing-instruction-left, processing-instruction-right,
markup-declaration-open, markup-declaration-close,
internal-subset-open, internal-subset-close, hash-name, keyword,
literal, encoding-name.
Adds to `xmltok-errors' and `xmltok-dependent-regions' as appropriate.
(defalias 'xmltok-forward-prolog #[nil "\306\211\211\211\211\211\211\211\211\211\307 \210\310 \210\311\312\313\217\204\"\f\2034\314\315\fS\f#\210\316 \210\237.\n\207" [xmltok-markup-declaration-doctype-flag xmltok-doctype-external-subset-flag xmltok-standalone xmltok-had-param-entity-ref xmltok-internal-subset-start xmltok-contains-doctype nil xmltok-scan-xml-declaration xmltok-next-prolog-token err (byte-code "\300 \205\301 \207" [xmltok-parse-prolog-item xmltok-next-prolog-token] 1) ((xmltok-markup-declaration-parse-error (xmltok-skip-markup-declaration))) xmltok-add-error "No closing ]" xmltok-parse-entities xmltok-prolog-regions xmltok-type xmltok-start case-fold-search xmltok-predefined-entity-alist xmltok-dtd] 10 (#$ . 20441)])
(defconst xmltok-bad-xml-decl-regexp "[ 	
\n]*<\\?xml\\(?:[ 	
\n]\\|\\?>\\)")
#@565 Return the position of the encoding in the XML declaration at point.
If there is a well-formed XML declaration starting at point and it
contains an encoding declaration, then return (START . END)
where START and END are the positions of the start and the end
of the encoding name; if there is no encoding declaration return
the position where and encoding declaration could be inserted.
If there is XML that is not well-formed that looks like an XML
declaration, return nil.  Otherwise, return t.
If LIMIT is non-nil, then do not consider characters beyond LIMIT.
(defalias 'xmltok-get-declared-encoding-position #[(&optional limit) "\304\305\306!\205	?\206\307\225	X)\203/\310\225\211\203%\310\224T\nSB\202-\311\225\206-`\312\\)\207\313\305!)?\207" [case-fold-search limit end xmltok-bad-xml-decl-regexp nil looking-at "<\\?xml\\(?:[ 
	\n]+\\(version\\)[ 
	\n]*=[ 
	\n]*\\(\\(?:\"[-._:a-zA-Z0-9]+\"\\|'[-._:a-zA-Z0-9]+'\\)\\)\\)?\\(?:[ 
	\n]+\\(encoding\\)[ 
	\n]*=[ 
	\n]*\\(\\(?:\"[-._:a-zA-Z0-9]+\"\\|'[-._:a-zA-Z0-9]+'\\)\\)\\)?\\(?:[ 
	\n]+\\(standalone\\)[ 
	\n]*=[ 
	\n]*\\(\"\\(?:yes\\|no\\)\"\\|'\\(?:yes\\|no\\)'\\)\\)?[ 
	\n]*\\?>" 0 4 2 5 t] 3 (#$ . 21869)])
(defalias 'xmltok-scan-xml-declaration #[nil "\303\304!\205q\305\306`\307\225#\210\307\225b\210\310\224\203+\305\311\310\224\310\225#\210\312\224\312\225\305\313	#\210*\314\224\203M\305\311\314\224\314\225#\210\315\224\315\225\305\316	TS#\210\305\313	#\210*\317\224\203p\305\311\317\224\317\225#\210\320\224\320\225\305\313	#\210\321	TS\"\322\230*\323\207" [end start xmltok-standalone looking-at "<\\?xml\\(?:[ 
	\n]+\\(version\\)[ 
	\n]*=[ 
	\n]*\\(\\(?:\"[-._:a-zA-Z0-9]+\"\\|'[-._:a-zA-Z0-9]+'\\)\\)\\)?\\(?:[ 
	\n]+\\(encoding\\)[ 
	\n]*=[ 
	\n]*\\(\\(?:\"[-._:a-zA-Z0-9]+\"\\|'[-._:a-zA-Z0-9]+'\\)\\)\\)?\\(?:[ 
	\n]+\\(standalone\\)[ 
	\n]*=[ 
	\n]*\\(\"\\(?:yes\\|no\\)\"\\|'\\(?:yes\\|no\\)'\\)\\)?[ 
	\n]*\\?>" xmltok-add-prolog-region xml-declaration 0 1 xml-declaration-attribute-name 2 xml-declaration-attribute-value 3 4 encoding-name 5 6 buffer-substring-no-properties "yes" t] 4])
(defconst xmltok-markup-declaration-alist '(("ELEMENT" . xmltok-parse-element-declaration) ("ATTLIST" . xmltok-parse-attlist-declaration) ("ENTITY" . xmltok-parse-entity-declaration) ("NOTATION" . xmltok-parse-notation-declaration)))
(defalias 'xmltok-parse-prolog-item #[nil "\306=\203\307\306	`#\210\310\207\311=\206\325\312=\203^\313\307\314	`#\210\315	\316\\`\"\317\f\"A\211\203B\204<\320\321!\210
 \210\202[\322\230\203N\323 \210\202[\320\324	\316\\\"\210\325 \210\326 \210*\310\207\327=\204h\204j\313\207\330=\203\217\307\330	\211T#\210\307\331`S`#\210\203\211\313\202\215\320\332!\210\310\207\333=\203\246\203\240\310 \202\244\320\334!\210\310\207\204\310!@\211\"?\206\277\"\211\"\316H)	X)\203\306	b\210\313\207\335=\203\320\310\207\320\336!\210\310\207" [xmltok-type xmltok-start xmltok-markup-declaration-doctype-flag name xmltok-markup-declaration-alist fun comment xmltok-add-prolog-region t processing-instruction named-markup-declaration nil markup-declaration-open buffer-substring-no-properties 2 assoc xmltok-add-error "Declaration allowed only in internal subset" "DOCTYPE" xmltok-parse-doctype "Unknown markup declaration" xmltok-next-prolog-token xmltok-markup-declaration-parse-error end-prolog internal-subset-close markup-declaration-close "]> outside internal subset" param-entity-ref "Parameter entity reference outside document type declaration" not-well-formed "Token allowed only inside markup declaration" xmltok-internal-subset-start xmltok-had-param-entity-ref xmltok-errors err] 5])
(defalias 'xmltok-parse-doctype #[nil "\305\306 \210	\203\307\310!\210\311 \210\n\203\307\312!\210\311 \210\305\313\314\315\"\210\316\317\320\321\322$\210\321=\2033`\211\207\322=\206L\305\323 \210\313\321\322\"\210\321=\205L`\211\207" [xmltok-markup-declaration-doctype-flag xmltok-internal-subset-start xmltok-contains-doctype xmltok-type xmltok-doctype-external-subset-flag t xmltok-next-prolog-token xmltok-add-error "DOCTYPE declaration not allowed in internal subset" xmltok-markup-declaration-parse-error "Duplicate DOCTYPE declaration" xmltok-require-token name prefixed-name xmltok-require-next-token "SYSTEM" "PUBLIC" 91 62 xmltok-parse-external-id] 5])
(defalias 'xmltok-parse-attlist-declaration #[nil "\301\302\303\"\210\301\304\303\302#\210\304=?\205O\301\305\306\307\310\311\312\313\314\315\316&\n\210\305=\203,\317 \210\202:\320 \316\230\203:\301\305!\210\317 \210\301\321\322\323\324$\210\320 \323\230\203\301\324!\210\202\207" [xmltok-type xmltok-require-next-token prefixed-name name 62 40 "CDATA" "ID" "IDREF" "IDREFS" "ENTITY" "ENTITIES" "NMTOKEN" "NMTOKENS" "NOTATION" xmltok-parse-nmtoken-group xmltok-current-token-string "#IMPLIED" "#REQUIRED" "#FIXED" literal] 11])
(defalias 'xmltok-parse-nmtoken-group #[nil "\301\302\303\304#\210\301\305\306\"\210\305=\205\202\207" [xmltok-type xmltok-require-next-token nmtoken prefixed-name name 124 41] 4])
(defalias 'xmltok-parse-element-declaration #[nil "\301\302\303\"\210\301\304\305\306#\210\306=\203;\301\307\302\303\310\306%\210\311=\2038\301\312\313\314#\210\312=\203;\301\302\303\"\210\301\314\312\"\210\202%\315 \210\301\316!\207" [xmltok-type xmltok-require-next-token name prefixed-name "EMPTY" "ANY" 40 "#PCDATA" name-occur hash-name 124 41 close-paren-star xmltok-parse-model-group 62] 6])
(defalias 'xmltok-parse-model-group #[nil "\302 \210\303\304\305\306\307\310%\210\311>\205*\312 \210\302 \210\303	\306\307\310$\210	=\205)\202)\207" [xmltok-type connector xmltok-parse-model-group-member xmltok-require-next-token 124 44 41 close-paren-star close-paren-occur (44 124) xmltok-next-prolog-token] 6])
(defalias 'xmltok-parse-model-group-member #[nil "\301\302\303\304\305$\210\305=\205\306 \210\307 \207" [xmltok-type xmltok-require-token name prefixed-name name-occur 40 xmltok-next-prolog-token xmltok-parse-model-group] 5])
(defalias 'xmltok-parse-entity-declaration #[nil "\304\211\305\300\306\"\210\n\306=\203\307\305\300!\210\310 \305\311\312\313#\210\n\311=\2037\314 	\2040\315\"\210)\305\316!\202b\317 \210	\203D\320\316!\202b\320\316\321\"\210\n\316=\203V\315\322\"\202b\305\300!\210\305\316!\210\315\323\"*\207" [name paramp xmltok-type replacement nil xmltok-require-next-token 37 t xmltok-current-token-string literal "SYSTEM" "PUBLIC" xmltok-parse-entity-value xmltok-define-entity 62 xmltok-parse-external-id xmltok-require-token "NDATA" external unparsed] 4])
(defalias 'xmltok-define-entity #[(name value) "\203	\205\305\n\"?\205\n\fBB\211\207" [xmltok-had-param-entity-ref xmltok-standalone name xmltok-dtd value assoc] 3])
(defalias 'xmltok-parse-entity-value #[nil "`S\306\307\211\212\fTb\210`\310w\210`W\203b`Tb\210`Sf\311=\2032\312\313`S`#\210\307\202`S\307\211\314\315!\210\316=\203U\317\f\"	B
	B`\202^\320=\203^\307+\202)\n\205q\321\322\317\"	B\237\",\207" [start value-parts well-formed lim xmltok-start xmltok-replacement t nil "^%&" 37 xmltok-add-error "Parameter entity references are not allowed in the internal subset" xmltok-scan-after-amp #[(start end) "\300\207" [nil] 1] char-ref buffer-substring-no-properties not-well-formed apply concat xmltok-type] 5])
(defalias 'xmltok-parse-notation-declaration #[nil "\302\303!\210\302\304\305\"\210\306 \305\230\302\307!\210\203(\302\307\310\"\210	\310=?\205+\302\310!\202+\302\310!)\207" [publicp xmltok-type xmltok-require-next-token name "SYSTEM" "PUBLIC" xmltok-current-token-string literal 62] 3])
(defalias 'xmltok-parse-external-id #[nil "\301\302\303\"\210\304 \303\230\305\306!\210\203\305\306!\210)\307 \207" [publicp xmltok-require-token "SYSTEM" "PUBLIC" xmltok-current-token-string xmltok-require-next-token literal xmltok-next-prolog-token] 3])
(defalias 'xmltok-require-next-token #[(&rest types) "\301 \210\302\303\"\207" [types xmltok-next-prolog-token apply xmltok-require-token] 3])
(defalias 'xmltok-require-token #[(&rest types) "@@;\203\305 	\230\202	\n=)\204A\211\204\2043\n\2030\n\306=\2040\307\310!\210\311 \210\312@!\211\205A\313\f`#)\207" [types type xmltok-type region-type xmltok-start xmltok-current-token-string not-well-formed xmltok-add-error "Unexpected token" xmltok-markup-declaration-parse-error xmltok-prolog-region-type xmltok-add-prolog-region] 5])
(defalias 'xmltok-current-token-string #[nil "\301`\"\207" [xmltok-start buffer-substring-no-properties] 3])
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put xmltok-markup-declaration-parse-error error-conditions (error xmltok-markup-declaration-parse-error) error-message "Syntax error in markup declaration"] 4)
(defalias 'xmltok-markup-declaration-parse-error #[nil "\300\301\302\"\207" [signal xmltok-markup-declaration-parse-error nil] 3])
(defalias 'xmltok-skip-markup-declaration #[nil "\303=\203\f\304 \210\2024	\203\305=\203`\304 \210\2024\306>\2044\n\203.\307=\2044\304 \210\202\207" [xmltok-type xmltok-markup-declaration-doctype-flag xmltok-internal-subset-start 62 xmltok-next-prolog-token 91 (nil end-prolog named-markup-declaration comment processing-instruction) internal-subset-close] 2])
(defalias 'xmltok-prolog-region-type #[(required) "\302\236A\206	;\205\303=\205\304\207" [xmltok-type required ((literal . literal) (62 . markup-declaration-close) (91 . internal-subset-open) (hash-name . hash-name)) name keyword] 2])
(defalias 'xmltok-next-prolog-token #[nil "\305\306w\210`\307\310!\203\311\225b\204,\306f\211\203'`Tb\210\312\313!\210\314\211\202*\306\211)\207\315\224\2046\316\224\203@`S\317\224\320\211\207\317\224\203X`\317\224\307\321!\204T\312\322!\210\323\211\207\324\224\204b\325\224\203p\307\321!\204l\312\326!\210\327\211\207\330\224\203\207`\306\307\321!\204\203\312\322!\210\331\211\207\332\224\203\234`\307\333!\204\230\312\322!\210\334\211\207\335\224\203\244\336 \207\337\224\203\254\340 \207\341\224\203\265\342\211\207\343\224\203\301b\210\344\211\207\345\224\203\312\346\211\207\347\224\203\323\350\211\207\351\224\203\346\307\352!\204\342\312\353!\210\354\211\207\355\224\203\377`Sf\211\356>\203\372\357 \202\375	\211)\207\360\224\2031
\361\224\203
`S\362\211\207\363\224\203
\312\364!\210`\362\211\207\307\365!\203)
\366\211\207\312\367!\210\314\211\207\370\224\203D
\307\321!\204@
\312\326!\210\327\211\207\371\224\203M
\372\211\207\373\224\203Z
\312\374!\210\314\211\207\375\224\203g
\312\376!\210\314\211\207\377\224\203v
\312\201@!\210\314\211\207\201A\224\203\207
\312\201B!\210\314\211\207\201C\201D\201E\311!\"\207" [xmltok-start ch xmltok-type xmltok-name-end xmltok-name-colon " 	
\n" nil looking-at "\\(<\\(?:\\(!\\(?:\\(-\\(-\\)?\\)\\|\\([_[:alpha:]][-._[:alnum:]]*\\)\\)?\\)\\|\\(\\?\\)\\|\\([_[:alpha:]][-._[:alnum:]]*\\)\\)?\\)\\|\\([[|,(\"'>]\\)\\|\\()\\(?:\\([+?]\\)\\|\\(\\*\\)\\)?\\)\\|\\(%\\([_[:alpha:]][-._[:alnum:]]*\\(;\\)?\\)?\\)\\|\\([_[:alpha:]][-._[:alnum:]]*\\(?:\\(:\\(?:\\(?:[-.[:digit:]]\\|:\\)\\(?:[-._[:alnum:]]\\|:\\)*\\|[_[:alpha:]][-._[:alnum:]]*:\\(?:[-._[:alnum:]]\\|:\\)*\\)\\)\\|\\(?:\\(:[_[:alpha:]][-._[:alnum:]]*\\)\\([?+*]\\)?\\)\\|\\([?+*]\\)\\|\\(:\\)\\)?\\)\\|\\(\\(?:[-.[:digit:]]\\|:\\)\\(?:[-._[:alnum:]]\\|:\\)*\\)\\|\\(#\\([_[:alpha:]][-._[:alnum:]]*\\)\\)\\|\\(][ 	
\n]*>\\)" 0 xmltok-add-error "Illegal char in prolog" not-well-formed 19 18 17 name-occur "[ 	
\n>),|[%]" "Missing space after name" prefixed-name 16 20 "Missing space after name token" nmtoken 15 name 23 "[ 	
\n>)|%]" hash-name 6 xmltok-scan-prolog-after-processing-instruction-open 4 xmltok-scan-after-comment-open 5 named-markup-declaration 7 end-prolog 11 close-paren-star 10 close-paren-occur 9 "[ 	
\n>,|)]" "Missing space after )" 41 8 (34 39) xmltok-scan-prolog-literal 12 14 param-entity-ref 13 "Missing ;" "[ 	
\n%]" 37 "Expected name after %" 21 24 internal-subset-close 22 "Expected name after #" 2 "Expected name or -- after <!" 3 "Expected <!--" 1 "Incomplete markup" error "Unhandled token in prolog %s" match-string-no-properties] 5])
(defalias 'xmltok-scan-prolog-literal #[nil "\305`Sf!\212\306P\307w\210`)\212	b\210\310\307\311#)\211\204)\312\313\307\211$\210\202b\212\nb\210\314\315!)\203=\nb\210\316\211\202_	T\n=\203U\nb\210\317\320\321\"	\"\210\316\211\202_\312\322\f\nT\323%\210\307\206s\317\320\324\"!\210	b\210\325\307x\210\326\211+\207" [delim safe-end end xmltok-type xmltok-start string "^<>[]" nil search-forward t xmltok-add-dependent xmltok-unclosed-reparse-p looking-at "[ 	
\n>%[]" literal xmltok-add-error format "Missing space after %s" xmltok-semi-closed-reparse-p 1 "Missing closing %s" " 	
\n" not-well-formed] 7])
(defalias 'xmltok-scan-prolog-after-processing-instruction-open #[nil "\305\306\307\310#\204\311\312\211\313\\#\210\314\315\307\211\306$\210\316\211\207`\212\313\\b\210\317\320!\205=\321\225f\322>\204:\321\225\n\313ZU\205=\323\321!)\211\204P\311\324\313\\\325\\#\210\202\216G\325U\203\216\310\326\327\")\203\216\330U\203p\311\331`#\210\202\216\212b\210\317\332!)\203\204\311\333`#\210\202\216\311\334\313\\\335\\#\210\336\337\340\313\203\235G\202\236\321##\210\336\341\203\271\212\340G\313#b\210\342\307w\210`)\202\274\313\\`#\210*\343\211\207" [xmltok-start xmltok-type end target case-fold-search search-forward "?>" nil t xmltok-add-error "No closing ?>" 2 xmltok-add-dependent xmltok-unclosed-reparse-p not-well-formed looking-at "\\(?:[_[:alpha:]][-._[:alnum:]]*\\)" 0 (10 9 13 32) match-string-no-properties "Processing instruction does not start with a name" 3 string-match "xml" 1 "Invalid XML declaration" "<\\?xml\\(?:[ 
	\n]+\\(version\\)[ 
	\n]*=[ 
	\n]*\\(\\(?:\"[-._:a-zA-Z0-9]+\"\\|'[-._:a-zA-Z0-9]+'\\)\\)\\)?\\(?:[ 
	\n]+\\(encoding\\)[ 
	\n]*=[ 
	\n]*\\(\\(?:\"[-._:a-zA-Z0-9]+\"\\|'[-._:a-zA-Z0-9]+'\\)\\)\\)?\\(?:[ 
	\n]+\\(standalone\\)[ 
	\n]*=[ 
	\n]*\\(\"\\(?:yes\\|no\\)\"\\|'\\(?:yes\\|no\\)'\\)\\)?[ 
	\n]*\\?>" "XML declaration not at beginning of file" "Processing instruction has target of xml" 5 xmltok-add-prolog-region processing-instruction-left + processing-instruction-right " 	
\n" processing-instruction] 8])
(defalias 'xmltok-parse-entities #[nil "\n\204\n\203\f\204\305B	\205#\306	@!\210	A\211\204\307)\207" [xmltok-dtd todo xmltok-had-param-entity-ref xmltok-doctype-external-subset-flag xmltok-standalone t xmltok-parse-entity nil] 3])
(defalias 'xmltok-parse-entity #[(name-def) "A	\304\211;\205=\305\306\"\203\211B\241\202=\307\241\210\310\311\312@\"!r\nq\210\313 \210c\210eb\210\314 \241\210)\315\n!+\207" [name-def xmltok-dtd buf def nil string-match "\\`[^&<	
\n]*\\'" not-well-formed get-buffer-create format " *Entity %s*" erase-buffer xmltok-parse-entity-replacement kill-buffer] 5])
(defalias 'xmltok-parse-entity-replacement #[nil "\306\211B`\307\310\311\312#\211\205`Sf\313	\n\203\314\224\202 d\"\315\f\211B\"\n\2041\311\202\362\316=\203=\317\311\202\362\320=\203\234\311\211\211\211\211\211\211\211\211 !\"#$%&`S%\321 \210\315&\322>\203q\323\202\224&\324>\203~\306\311B\202\224&\325=\203\223\313%\326\\`\327Z\"\311B\202\224\317\".	\312\202\362\330=\203\350`S\311\211\211\"&%\331\332!\210&\333=\203\302\315\"\"\202\343&\334=\203\341\315\"\203\327\"\211B\202\334
\205\334\317\"\202\343\317,\312\202\362\315\335\314!\336B\"\312,\204)\207" [def start found ch str xmltok-errors "" re-search-forward "[<&	
\n]\\|]]>" nil t buffer-substring-no-properties 0 xmltok-append-entity-def 62 not-well-formed 60 xmltok-scan-after-lt (start-tag end-tag empty-element) element (comment processing-instruction) cdata-section 9 3 38 xmltok-scan-after-amp xmltok-handle-nested-entity entity-ref char-ref match-string-no-properties " " xmltok-dependent-regions xmltok-namespace-attributes xmltok-attributes xmltok-replacement xmltok-name-end xmltok-name-colon xmltok-start xmltok-type] 10])
(defalias 'xmltok-handle-nested-entity #[(start end) "\306\307	\"\n\"\211A\211;\203\310!\210A\204'\n@\311=?\2052\312\2022\f\313=\2031\312\2022\f\211*\207" [start end xmltok-dtd name-def def xmltok-replacement assoc buffer-substring-no-properties xmltok-parse-entity t not-well-formed unparsed] 5])
(defalias 'xmltok-append-entity-def #[(d1 d2) ":\203\"	:\203 @	@PA\205	A\205A	APB\207	\207	:\203)\207\303\211@=\204@\n@	=\204@\nA\211\202,\n@)\207" [d1 d2 defs (not-well-formed external element)] 4])
(defalias 'xmltok-add-prolog-region #[(type start end) "\304	\n#B\211\207" [type start end xmltok-prolog-regions vector] 4])
#@248 Return a list merging `xmltok-attributes' and `xmltok-namespace-attributes'.
The members of the merged list are in order of occurrence in the
document.  The list may share list structure with `xmltok-attributes'
and `xmltok-namespace-attributes'.
(defalias 'xmltok-merge-attributes #[nil "\204	\207	\204\f\207	\306\f\203C\203C\f@\211\307H)@\211\307H)W\2038\f@\nB\fA\211\202@\nBA\202\n\237\f\203Q\n\f\244\202Y\203Y\n\244\n+\207" [xmltok-namespace-attributes xmltok-attributes merged atts2 atts1 att nil 0] 4 (#$ . 38598)])
(defalias 'xmltok-forward-test #[nil "\301 \203\n\302\303\"\207\302\304!\207" [xmltok-type xmltok-forward message "Scanned %s" "Scanned nothing"] 3 nil nil])
(defalias 'xmltok-next-prolog-token-test #[nil "\301 \203\302\303\250\203\304!\202\"\207\302\305!\207" [xmltok-type xmltok-next-prolog-token message "Scanned %s" string "Scanned end of file"] 4 nil nil])
(provide 'xmltok)