literals as extending to EOB.
(nxml-last-fontify-end): Remove unused variable.
(nxml-after-change1): Use with-silent-modifications.
(nxml-extend-after-change-region): Simplify.
(nxml-extend-after-change-region1): Remove function.
(nxml-after-change1): Don't adjust for dependent regions.
(nxml-fontify-matcher): Simplify.
* lisp/nxml/xmltok.el (xmltok-dependent-regions): Remove variable.
(xmltok-add-dependent): Remove function.
(xmltok-scan-after-lt, xmltok-scan-after-processing-instruction-open)
(xmltok-scan-after-comment-open, xmltok-scan-prolog-literal)
(xmltok-scan-prolog-after-processing-instruction-open): Treat
unclosed <[[, <?, comment, and other literals as extending to EOB.
* lisp/nxml/rng-valid.el (rng-mark-xmltok-dependent-regions)
(rng-mark-xmltok-dependent-region, rng-dependent-region-changed):
Remove functions.
(rng-do-some-validation-1): Don't mark dependent regions.
* lisp/nxml/nxml-rap.el (nxml-adjust-start-for-dependent-regions)
(nxml-mark-parse-dependent-regions, nxml-mark-parse-dependent-region)
(nxml-clear-dependent-regions): Remove functions.
(nxml-scan-after-change, nxml-scan-prolog, nxml-tokenize-forward)
(nxml-ensure-scan-up-to-date):
Don't clear&mark dependent regions.
+2013-05-15 Stefan Monnier <monnier@iro.umontreal.ca>
+
+ * nxml/nxml-mode.el: Treat unclosed <[[, <?, comment, and other
+ literals as extending to EOB.
+ (nxml-last-fontify-end): Remove unused variable.
+ (nxml-after-change1): Use with-silent-modifications.
+ (nxml-extend-after-change-region): Simplify.
+ (nxml-extend-after-change-region1): Remove function.
+ (nxml-after-change1): Don't adjust for dependent regions.
+ (nxml-fontify-matcher): Simplify.
+ * nxml/xmltok.el (xmltok-dependent-regions): Remove variable.
+ (xmltok-add-dependent): Remove function.
+ (xmltok-scan-after-lt, xmltok-scan-after-processing-instruction-open)
+ (xmltok-scan-after-comment-open, xmltok-scan-prolog-literal)
+ (xmltok-scan-prolog-after-processing-instruction-open): Treat
+ unclosed <[[, <?, comment, and other literals as extending to EOB.
+ * nxml/rng-valid.el (rng-mark-xmltok-dependent-regions)
+ (rng-mark-xmltok-dependent-region, rng-dependent-region-changed):
+ Remove functions.
+ (rng-do-some-validation-1): Don't mark dependent regions.
+ * nxml/nxml-rap.el (nxml-adjust-start-for-dependent-regions)
+ (nxml-mark-parse-dependent-regions, nxml-mark-parse-dependent-region)
+ (nxml-clear-dependent-regions): Remove functions.
+ (nxml-scan-after-change, nxml-scan-prolog, nxml-tokenize-forward)
+ (nxml-ensure-scan-up-to-date):
+ Don't clear&mark dependent regions.
+
2013-05-15 Leo Liu <sdl.web@gmail.com>
- * progmodes/octave.el (octave-goto-function-definition): Improve
- and fix callers.
+ * progmodes/octave.el (octave-goto-function-definition):
+ Improve and fix callers.
2013-05-15 Stefan Monnier <monnier@iro.umontreal.ca>
their declaration.
(vhdl-mode-syntax-table-init): Remove.
- * progmodes/m4-mode.el (m4-mode-syntax-table): Add comment on last change.
+ * progmodes/m4-mode.el (m4-mode-syntax-table): Add comment on
+ last change.
* progmodes/ld-script.el (ld-script-mode-syntax-table): Use symbol
syntax for "_".
Handle a _ with symbol syntax.
(autoconf-mode): Don't change the syntax-table for imenu and font-lock.
- * progmodes/ada-mode.el (ada-mode-abbrev-table): Consolidate declaration.
+ * progmodes/ada-mode.el (ada-mode-abbrev-table):
+ Consolidate declaration.
(ada-mode-syntax-table, ada-mode-symbol-syntax-table): Initialize in
the declaration.
(ada-create-syntax-table): Remove.
See the function `xmltok-forward-prolog' for more information.")
(make-variable-buffer-local 'nxml-prolog-regions)
-(defvar nxml-last-fontify-end nil
- "Position where fontification last ended.
-It is nil if the buffer changed since the last fontification.")
-(make-variable-buffer-local 'nxml-last-fontify-end)
-
(defvar nxml-degraded nil
"Non-nil if currently operating in degraded mode.
Degraded mode is enabled when an internal error is encountered in the
(save-excursion
(save-restriction
(widen)
- (nxml-clear-dependent-regions (point-min) (point-max))
(setq nxml-scan-end (copy-marker (point-min) nil))
(with-silent-modifications
(nxml-clear-inside (point-min) (point-max))
;; Clean up fontification.
(save-excursion
(widen)
- (let ((inhibit-read-only t)
- (buffer-undo-list t)
- (modified (buffer-modified-p)))
+ (with-silent-modifications
(nxml-with-invisible-motion
- (remove-text-properties (point-min) (point-max) '(face)))
- (set-buffer-modified-p modified)))
+ (remove-text-properties (point-min) (point-max) '(face)))))
(remove-hook 'change-major-mode-hook 'nxml-cleanup t))
(defun nxml-degrade (context err)
For bookkeeping, call this function even when fontification is
disabled."
(let ((pre-change-end (+ start pre-change-length)))
- (setq start
- (nxml-adjust-start-for-dependent-regions start
- end
- pre-change-length))
;; If the prolog might have changed, rescan the prolog
(when (<= start
;; Add 2 so as to include the < and following char that
(defun nxml-extend-after-change-region (start end pre-change-length)
(unless nxml-degraded
- (setq nxml-last-fontify-end nil)
- (let ((region (nxml-with-degradation-on-error
- 'nxml-extend-after-change-region
- (save-excursion
- (save-restriction
- (widen)
- (save-match-data
- (nxml-with-invisible-motion
- (with-silent-modifications
- (nxml-extend-after-change-region1
- start end pre-change-length)))))))))
- (if (consp region) region))))
-
-(defun nxml-extend-after-change-region1 (start end pre-change-length)
- (let* ((region (nxml-after-change1 start end pre-change-length))
- (font-lock-beg (car region))
- (font-lock-end (cdr region)))
-
- (nxml-extend-region)
- (cons font-lock-beg font-lock-end)))
+ (nxml-with-degradation-on-error
+ 'nxml-extend-after-change-region
+ (save-excursion
+ (save-restriction
+ (widen)
+ (save-match-data
+ (nxml-with-invisible-motion
+ (with-silent-modifications
+ (nxml-after-change1
+ start end pre-change-length)))))))))
(defun nxml-fontify-matcher (bound)
"Called as font-lock keyword matcher."
(nxml-fontify-prolog)
(goto-char nxml-prolog-end))
- (let (xmltok-dependent-regions
- xmltok-errors)
+ (let (xmltok-errors)
(while (and (nxml-tokenize-forward)
(<= (point) bound)) ; Intervals are open-ended.
(nxml-apply-fontify-rule)))
- (setq nxml-last-fontify-end (point)))
+ )
;; Since we did the fontification internally, tell font-lock to not
;; do anything itself.
;; typical proportion of comments, CDATA sections and processing
;; instructions is small relative to other things. Secondly, to scan
;; we just search for the regexp <[!?].
-;;
-;; One problem is unclosed comments, processing instructions and CDATA
-;; sections. Suppose, for example, we encounter a <!-- but there's no
-;; matching -->. This is not an unexpected situation if the user is
-;; creating a comment. It is not helpful to treat the whole of the
-;; file starting from the <!-- onwards as a single unclosed comment
-;; token. Instead we treat just the <!-- as a piece of not well-formed
-;; markup and continue. The problem is that if at some later stage a
-;; --> gets added to the buffer after the unclosed <!--, we will need
-;; to reparse the buffer starting from the <!--. We need to keep
-;; track of these reparse dependencies; they are called dependent
-;; regions in the code.
;;; Code:
(if (>= start nxml-scan-end)
nxml-scan-end
(let ((inside-remove-start start)
- xmltok-errors
- xmltok-dependent-regions)
+ xmltok-errors)
(while (or (when (xmltok-forward-special (min end nxml-scan-end))
(when (memq xmltok-type
'(comment
(when inside-end
(setq end inside-end)
t))))
- (nxml-clear-inside inside-remove-start end)
- (nxml-clear-dependent-regions start end)
- (nxml-mark-parse-dependent-regions))
+ (nxml-clear-inside inside-remove-start end))
(when (> end nxml-scan-end)
(set-marker nxml-scan-end end))
end))
(defun nxml-scan-prolog ()
(goto-char (point-min))
(let (xmltok-dtd
- xmltok-errors
- xmltok-dependent-regions)
+ xmltok-errors)
(setq nxml-prolog-regions (xmltok-forward-prolog))
(setq nxml-prolog-end (point))
- (nxml-clear-inside (point-min) nxml-prolog-end)
- (nxml-clear-dependent-regions (point-min) nxml-prolog-end)
- (nxml-mark-parse-dependent-regions))
+ (nxml-clear-inside (point-min) nxml-prolog-end))
(when (< nxml-scan-end nxml-prolog-end)
(set-marker nxml-scan-end nxml-prolog-end)))
-;;; Dependent regions
-
-(defun nxml-adjust-start-for-dependent-regions (start end pre-change-length)
- (let ((overlays (overlays-in (1- start) start))
- (adjusted-start start))
- (while overlays
- (let* ((overlay (car overlays))
- (ostart (overlay-start overlay)))
- (when (and (eq (overlay-get overlay 'category) 'nxml-dependent)
- (< ostart adjusted-start))
- (let ((funargs (overlay-get overlay 'nxml-funargs)))
- (when (apply (car funargs)
- (append (list start
- end
- pre-change-length
- ostart
- (overlay-end overlay))
- (cdr funargs)))
- (setq adjusted-start ostart)))))
- (setq overlays (cdr overlays)))
- adjusted-start))
-
-(defun nxml-mark-parse-dependent-regions ()
- (while xmltok-dependent-regions
- (apply 'nxml-mark-parse-dependent-region
- (car xmltok-dependent-regions))
- (setq xmltok-dependent-regions
- (cdr xmltok-dependent-regions))))
-
-(defun nxml-mark-parse-dependent-region (fun start end &rest args)
- (let ((overlay (make-overlay start end nil t t)))
- (overlay-put overlay 'category 'nxml-dependent)
- (overlay-put overlay 'nxml-funargs (cons fun args))))
-
-(put 'nxml-dependent 'evaporate t)
-
-(defun nxml-clear-dependent-regions (start end)
- (let ((overlays (overlays-in start end)))
- (while overlays
- (let* ((overlay (car overlays))
- (category (overlay-get overlay 'category)))
- (when (and (eq category 'nxml-dependent)
- (<= start (overlay-start overlay)))
- (delete-overlay overlay)))
- (setq overlays (cdr overlays)))))
-
;;; Random access parsing
(defun nxml-token-after ()
(point)))
(defun nxml-tokenize-forward ()
- (let (xmltok-dependent-regions
- xmltok-errors)
+ (let (xmltok-errors)
(when (and (xmltok-forward)
(> (point) nxml-scan-end))
(cond ((memq xmltok-type '(comment
cdata-section
processing-instruction))
(with-silent-modifications
- (nxml-set-inside (1+ xmltok-start) (point) xmltok-type)))
- (xmltok-dependent-regions
- (nxml-mark-parse-dependent-regions)))
+ (nxml-set-inside (1+ xmltok-start) (point) xmltok-type))))
(set-marker nxml-scan-end (point)))
xmltok-type))
"Move point backwards outside any 'inside' regions or tags.
Point will not move past `nxml-prolog-end'.
Point will either be at BOUND or a '<' character starting a tag
-outside any 'inside' regions. Ignores dependent regions.
+outside any 'inside' regions.
As a precondition, point must be >= BOUND."
(nxml-move-outside-backwards)
(when (not (equal (char-after) ?<))
(when (< nxml-scan-end pos)
(save-excursion
(goto-char nxml-scan-end)
- (let (xmltok-errors
- xmltok-dependent-regions)
+ (let (xmltok-errors)
(while (when (xmltok-forward-special pos)
(when (memq xmltok-type
'(comment
t
(setq pos (point))
nil)))
- (nxml-clear-dependent-regions nxml-scan-end pos)
- (nxml-mark-parse-dependent-regions)
(set-marker nxml-scan-end pos))))))
;;; Element scanning
xmltok-replacement
xmltok-attributes
xmltok-namespace-attributes
- xmltok-dependent-regions
xmltok-errors)
(when (= (point) 1)
(let ((regions (xmltok-forward-prolog)))
;; do this before setting rng-validate-up-to-date-end
;; in case we get a quit
(rng-mark-xmltok-errors)
- (rng-mark-xmltok-dependent-regions)
(setq rng-validate-up-to-date-end
(marker-position rng-conditional-up-to-date-end))
(rng-clear-conditional-region)
(when (not have-remaining-chars)
(rng-process-end-document))
(rng-mark-xmltok-errors)
- (rng-mark-xmltok-dependent-regions)
(setq rng-validate-up-to-date-end pos)
(when rng-conditional-up-to-date-end
(cond ((<= rng-conditional-up-to-date-end pos)
;; if overlays left over from a previous use
;; of rng-validate-mode that ended with a change of mode
(when rng-error-count
- (setq rng-error-count (1- rng-error-count)))))
- ((and (eq category 'rng-dependent)
- (<= beg (overlay-start overlay)))
- (delete-overlay overlay))))
+ (setq rng-error-count (1- rng-error-count)))))))
(setq overlays (cdr overlays))))))
-;;; Dependent regions
-
-(defun rng-mark-xmltok-dependent-regions ()
- (while xmltok-dependent-regions
- (apply 'rng-mark-xmltok-dependent-region
- (car xmltok-dependent-regions))
- (setq xmltok-dependent-regions
- (cdr xmltok-dependent-regions))))
-
-(defun rng-mark-xmltok-dependent-region (fun start end &rest args)
- (let ((overlay (make-overlay start end nil t t)))
- (overlay-put overlay 'category 'rng-dependent)
- (overlay-put overlay 'rng-funargs (cons fun args))))
-
-(put 'rng-dependent 'evaporate t)
-(put 'rng-dependent 'modification-hooks '(rng-dependent-region-changed))
-(put 'rng-dependent 'insert-behind-hooks '(rng-dependent-region-changed))
-
-(defun rng-dependent-region-changed (overlay
- after-p
- change-start
- change-end
- &optional pre-change-length)
- (when (and after-p
- ;; Emacs sometimes appears to call deleted overlays
- (overlay-start overlay)
- (let ((funargs (overlay-get overlay 'rng-funargs)))
- (save-match-data
- (save-excursion
- (save-restriction
- (widen)
- (apply (car funargs)
- (append (list change-start
- change-end
- pre-change-length
- (overlay-start overlay)
- (overlay-end overlay))
- (cdr funargs))))))))
- (rng-after-change-function (overlay-start overlay)
- change-end
- (+ pre-change-length
- (- (overlay-start overlay)
- change-start)))
- (delete-overlay overlay)))
-
;;; Error state
(defun rng-mark-xmltok-errors ()
meaning the replacement text included a <, or a string which is the
normalized attribute value.")
-(defvar xmltok-dependent-regions nil
- "List of descriptors of regions that a parsed token depends on.
-
-A token depends on a region if the region occurs after the token and a
-change in the region may require the token to be reparsed. This only
-happens with markup that is not well-formed. For example, if a <?
-occurs without a matching ?>, then the <? is returned as a
-not-well-formed token. However, this token is dependent on region
-from the end of the token to the end of the buffer: if this ever
-contains ?> then the buffer must be reparsed from the <?.
-
-A region descriptor is a list (FUN START END ARG ...), where FUN is a
-function to be called when the region changes, START and END are
-integers giving the start and end of the region, and ARG... are
-additional arguments to be passed to FUN. FUN will be called with 5
-arguments followed by the additional arguments if any: the position of
-the start of the changed area in the region, the position of the end
-of the changed area in the region, the length of the changed area
-before the change, the position of the start of the region, the
-position of the end of the region. FUN must return non-nil if the
-region needs reparsing. FUN will be called in a `save-excursion'
-with match-data saved.
-
-`xmltok-forward', `xmltok-forward-special' and `xmltok-forward-prolog'
-may add entries to the beginning of this list, but will not clear it.
-`xmltok-forward' and `xmltok-forward-special' will only add entries
-when returning tokens of type not-well-formed.")
(defvar xmltok-errors nil
"List of errors detected by `xmltok-forward' and `xmltok-forward-prolog'.
xmltok-replacement
xmltok-attributes
xmltok-namespace-attributes
- xmltok-dependent-regions
xmltok-errors)
,@body))
(or end (point)))
xmltok-errors)))
-(defun xmltok-add-dependent (fun &optional start end &rest args)
- (setq xmltok-dependent-regions
- (cons (cons fun
- (cons (or start xmltok-start)
- (cons (or end (point-max))
- args)))
- xmltok-dependent-regions)))
-
(defun xmltok-forward ()
(setq xmltok-start (point))
(let* ((case-fold-search nil)
(setq xmltok-type 'empty-element))
((xmltok-after-lt start cdata-section-open)
(setq xmltok-type
- (if (search-forward "]]>" nil t)
- 'cdata-section
- (xmltok-add-error "No closing ]]>")
- (xmltok-add-dependent 'xmltok-unclosed-reparse-p
- nil
- nil
- "]]>")
- 'not-well-formed)))
+ (progn (search-forward "]]>" nil 'move)
+ 'cdata-section)))
((xmltok-after-lt start processing-instruction-question)
(xmltok-scan-after-processing-instruction-open))
((xmltok-after-lt start comment-open)
;; xmltok-scan-prolog-after-processing-instruction-open
;; XXX maybe should include rest of line (up to any <,>) in unclosed PI
(defun xmltok-scan-after-processing-instruction-open ()
- (cond ((not (search-forward "?>" nil t))
- (xmltok-add-error "No closing ?>"
- xmltok-start
- (+ xmltok-start 2))
- (xmltok-add-dependent 'xmltok-unclosed-reparse-p
- nil
- nil
- "?>")
- (setq xmltok-type 'not-well-formed))
- (t
- (cond ((not (save-excursion
- (goto-char (+ 2 xmltok-start))
- (and (looking-at (xmltok-ncname regexp))
- (setq xmltok-name-end (match-end 0)))))
- (setq xmltok-name-end (+ xmltok-start 2))
- (xmltok-add-error "<? not followed by name"
- (+ xmltok-start 2)
- (+ xmltok-start 3)))
- ((not (or (memq (char-after xmltok-name-end)
- '(?\n ?\t ?\r ? ))
- (= xmltok-name-end (- (point) 2))))
- (xmltok-add-error "Target not followed by whitespace"
- xmltok-name-end
- (1+ xmltok-name-end)))
- ((and (= xmltok-name-end (+ xmltok-start 5))
- (save-excursion
- (goto-char (+ xmltok-start 2))
- (let ((case-fold-search t))
- (looking-at "xml"))))
- (xmltok-add-error "Processing instruction target is xml"
- (+ xmltok-start 2)
- (+ xmltok-start 5))))
- (setq xmltok-type 'processing-instruction))))
+ (search-forward "?>" nil 'move)
+ (cond ((not (save-excursion
+ (goto-char (+ 2 xmltok-start))
+ (and (looking-at (xmltok-ncname regexp))
+ (setq xmltok-name-end (match-end 0)))))
+ (setq xmltok-name-end (+ xmltok-start 2))
+ (xmltok-add-error "<? not followed by name"
+ (+ xmltok-start 2)
+ (+ xmltok-start 3)))
+ ((not (or (memq (char-after xmltok-name-end)
+ '(?\n ?\t ?\r ? ))
+ (= xmltok-name-end (- (point) 2))))
+ (xmltok-add-error "Target not followed by whitespace"
+ xmltok-name-end
+ (1+ xmltok-name-end)))
+ ((and (= xmltok-name-end (+ xmltok-start 5))
+ (save-excursion
+ (goto-char (+ xmltok-start 2))
+ (let ((case-fold-search t))
+ (looking-at "xml"))))
+ (xmltok-add-error "Processing instruction target is xml"
+ (+ xmltok-start 2)
+ (+ xmltok-start 5))))
+ (setq xmltok-type 'processing-instruction))
(defun xmltok-scan-after-comment-open ()
- (setq xmltok-type
- (cond ((not (search-forward "--" nil t))
- (xmltok-add-error "No closing -->")
- (xmltok-add-dependent 'xmltok-unclosed-reparse-p
- nil
- nil
- ;; not --> because
- ;; -- is not allowed
- ;; in comments in XML
- "--")
- 'not-well-formed)
- ((eq (char-after) ?>)
- (goto-char (1+ (point)))
- 'comment)
- (t
- (xmltok-add-dependent
- 'xmltok-semi-closed-reparse-p
- nil
- (point)
- "--"
- 2)
- ;; just include the <!-- in the token
- (goto-char (+ xmltok-start 4))
- ;; Need do this after the goto-char because
- ;; marked error should just apply to <!--
- (xmltok-add-error "First following `--' not followed by `>'")
- 'not-well-formed))))
+ (let ((found-- (search-forward "--" nil 'move)))
+ (setq xmltok-type
+ (cond ((or (eq (char-after) ?>) (not found--))
+ (goto-char (1+ (point)))
+ 'comment)
+ (t
+ ;; just include the <!-- in the token
+ (goto-char (+ xmltok-start 4))
+ ;; Need do this after the goto-char because
+ ;; marked error should just apply to <!--
+ (xmltok-add-error "First following `--' not followed by `>'")
+ 'not-well-formed)))))
(defun xmltok-scan-attributes ()
(let ((recovering nil)
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."
+Adds to `xmltok-errors' as appropriate."
(let ((case-fold-search nil)
xmltok-start
xmltok-type
(1- xmltok-internal-subset-start)
xmltok-internal-subset-start))
(xmltok-parse-entities)
- ;; XXX prune dependent-regions for those entirely in prolog
(nreverse xmltok-prolog-regions)))
(defconst xmltok-bad-xml-decl-regexp
(end (save-excursion
(goto-char safe-end)
(search-forward delim nil t))))
- (or (cond ((not end)
- (xmltok-add-dependent 'xmltok-unclosed-reparse-p
- nil
- nil
- delim)
- nil)
- ((save-excursion
- (goto-char end)
- (looking-at "[ \t\r\n>%[]"))
- (goto-char end)
- (setq xmltok-type 'literal))
- ((eq (1+ safe-end) end)
- (goto-char end)
- (xmltok-add-error (format "Missing space after %s" delim)
- safe-end)
- (setq xmltok-type 'literal))
- (t
- (xmltok-add-dependent 'xmltok-semi-closed-reparse-p
- xmltok-start
- (1+ end)
- delim
- 1)
- nil))
- (progn
- (xmltok-add-error (format "Missing closing %s" delim))
- (goto-char safe-end)
- (skip-chars-backward " \t\r\n")
- (setq xmltok-type 'not-well-formed)))))
+ (cond ((or (not end)
+ (save-excursion
+ (goto-char end)
+ (looking-at "[ \t\r\n>%[]")))
+ (goto-char end))
+ ((eq (1+ safe-end) end)
+ (goto-char end)
+ (xmltok-add-error (format "Missing space after %s" delim)
+ safe-end)))
+ (setq xmltok-type 'literal)))
(defun xmltok-scan-prolog-after-processing-instruction-open ()
- (cond ((not (search-forward "?>" nil t))
- (xmltok-add-error "No closing ?>"
- xmltok-start
- (+ xmltok-start 2))
- (xmltok-add-dependent 'xmltok-unclosed-reparse-p
- nil
- nil
- "?>")
- (setq xmltok-type 'not-well-formed))
- (t
- (let* ((end (point))
- (target
- (save-excursion
- (goto-char (+ xmltok-start 2))
- (and (looking-at (xmltok-ncname regexp))
- (or (memq (char-after (match-end 0))
- '(?\n ?\t ?\r ? ))
- (= (match-end 0) (- end 2)))
- (match-string-no-properties 0)))))
- (cond ((not target)
- (xmltok-add-error "\
+ (search-forward "?>" nil 'move)
+ (let* ((end (point))
+ (target
+ (save-excursion
+ (goto-char (+ xmltok-start 2))
+ (and (looking-at (xmltok-ncname regexp))
+ (or (memq (char-after (match-end 0))
+ '(?\n ?\t ?\r ? ))
+ (= (match-end 0) (- end 2)))
+ (match-string-no-properties 0)))))
+ (cond ((not target)
+ (xmltok-add-error "\
Processing instruction does not start with a name"
- (+ xmltok-start 2)
- (+ xmltok-start 3)))
- ((not (and (= (length target) 3)
- (let ((case-fold-search t))
- (string-match "xml" target)))))
- ((= xmltok-start 1)
- (xmltok-add-error "Invalid XML declaration"
- xmltok-start
- (point)))
- ((save-excursion
- (goto-char xmltok-start)
- (looking-at (xmltok-xml-declaration regexp)))
- (xmltok-add-error "XML declaration not at beginning of file"
- xmltok-start
- (point)))
- (t
- (xmltok-add-error "Processing instruction has target of xml"
- (+ xmltok-start 2)
- (+ xmltok-start 5))))
- (xmltok-add-prolog-region 'processing-instruction-left
- xmltok-start
- (+ xmltok-start
- 2
- (if target
- (length target)
- 0)))
- (xmltok-add-prolog-region 'processing-instruction-right
- (if target
- (save-excursion
- (goto-char (+ xmltok-start
- (length target)
- 2))
- (skip-chars-forward " \t\r\n")
- (point))
- (+ xmltok-start 2))
- (point)))
- (setq xmltok-type 'processing-instruction))))
+ (+ xmltok-start 2)
+ (+ xmltok-start 3)))
+ ((not (and (= (length target) 3)
+ (let ((case-fold-search t))
+ (string-match "xml" target)))))
+ ((= xmltok-start 1)
+ (xmltok-add-error "Invalid XML declaration"
+ xmltok-start
+ (point)))
+ ((save-excursion
+ (goto-char xmltok-start)
+ (looking-at (xmltok-xml-declaration regexp)))
+ (xmltok-add-error "XML declaration not at beginning of file"
+ xmltok-start
+ (point)))
+ (t
+ (xmltok-add-error "Processing instruction has target of xml"
+ (+ xmltok-start 2)
+ (+ xmltok-start 5))))
+ (xmltok-add-prolog-region 'processing-instruction-left
+ xmltok-start
+ (+ xmltok-start
+ 2
+ (if target
+ (length target)
+ 0)))
+ (xmltok-add-prolog-region 'processing-instruction-right
+ (if target
+ (save-excursion
+ (goto-char (+ xmltok-start
+ (length target)
+ 2))
+ (skip-chars-forward " \t\r\n")
+ (point))
+ (+ xmltok-start 2))
+ (point)))
+ (setq xmltok-type 'processing-instruction))
(defun xmltok-parse-entities ()
(let ((todo xmltok-dtd))
projects / emacs.git / commitdiff