Merge from trunk.

11 files changed, 614 insertions, 709 deletions

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index f69e60e50a7..62424265d96 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,77 @@
+2013-04-25  Leo Liu  <sdl.web@gmail.com>
+
+        * progmodes/octave.el (octave-completion-at-point-function): Make
+        use of inferior octave process.
+        (octave-initialize-completions): Remove.
+        (inferior-octave-completion-table): New function.
+        (inferior-octave-completion-at-point): Use it.
+        (octave-completion-alist): Remove.
+
+2013-04-25  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * progmodes/opascal.el: Use font-lock and syntax-propertize.
+        (opascal-mode-syntax-table): New var.
+        (opascal-literal-kind, opascal-is-literal-end)
+        (opascal-literal-token-at): Rewrite.
+        (opascal--literal-start-re, opascal-font-lock-keywords)
+        (opascal--syntax-propertize): New constants.
+        (opascal-font-lock-defaults): Adjust.
+        (opascal-mode): Use them.  Set comment-<foo> variables as well.
+        (delphi-comment-face, opascal-comment-face, delphi-string-face)
+        (opascal-string-face, delphi-keyword-face, opascal-keyword-face)
+        (delphi-other-face, opascal-other-face): Remove face variables.
+        (opascal-save-state): Remove macro.
+        (opascal-fontifying-progress-step): Remove constant.
+        (opascal--ignore-changes): Remove var.
+        (opascal-set-token-property, opascal-parse-next-literal)
+        (opascal-is-stable-literal, opascal-complete-literal)
+        (opascal-is-literal-start, opascal-face-of)
+        (opascal-parse-region, opascal-parse-region-until-stable)
+        (opascal-fontify-region, opascal-after-change)
+        (opascal-debug-show-is-stable, opascal-debug-unparse-buffer)
+        (opascal-debug-parse-region, opascal-debug-parse-window)
+        (opascal-debug-parse-buffer, opascal-debug-fontify-window)
+        (opascal-debug-fontify-buffer): Remove.
+        (opascal-debug-mode-map): Adjust accordingly.
+
+2013-04-25  Leo Liu  <sdl.web@gmail.com>
+
+        Merge octave-mod.el and octave-inf.el into octave.el with some
+        cleanups.
+        * progmodes/octave.el: New file renamed from octave-mod.el.
+        * progmodes/octave-inf.el: Merged into octave.el.
+        * progmodes/octave-mod.el: Renamed to octave.el.
+
+2013-04-25  Tassilo Horn  <tsdh@gnu.org>
+
+        * textmodes/reftex-vars.el
+        (reftex-label-ignored-macros-and-environments): New defcustom.
+
+        * textmodes/reftex-parse.el (reftex-parse-from-file): Use it.
+
+2013-04-25  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * emacs-lisp/smie.el (smie-indent--hanging-p): Don't burp at EOB.
+        (smie-indent-keyword): Improve the check to ensure that the next
+        comment is really on the same line.
+        (smie-indent-comment): Don't align with a subsequent closer (or eob).
+
+        * progmodes/octave-mod.el (octave-smie-forward-token): Only emit
+        semi-colons if the line is not otherwise empty (bug#14218).
+
+2013-04-25  Glenn Morris  <rgm@gnu.org>
+
+        * vc/vc-bzr.el (vc-bzr-print-log): Tweak LIMIT = 1 case.
+
+2013-04-24  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * progmodes/opascal.el (opascal-set-token-property): Rename from
+        opascal-set-text-properties and only set `token' (bug#14134).
+        Suggested by Erik Knowles <eknowles@geosystemsoftware.com>.
+        (opascal-literal-text-properties): Remove.
+        (opascal-parse-next-literal, opascal-debug-unparse-buffer):
+        Adjust callers.
+
 2013-04-24  Reuben Thomas <rrt@sc3d.org>
 
         * textmodes/remember.el (remember-handler-functions): Add an
diff --git a/lisp/emacs-lisp/smie.el b/lisp/emacs-lisp/smie.el
index 18cc0e811ce..c59076974e0 100644
--- a/lisp/emacs-lisp/smie.el
+++ b/lisp/emacs-lisp/smie.el
@@ -1067,9 +1067,10 @@ the beginning of a line."
        (save-excursion
          (<= (line-end-position)
              (progn
-               (when (zerop (length (funcall smie-forward-token-function)))
-                 ;; Could be an open-paren.
-                 (forward-char 1))
+               (and (zerop (length (funcall smie-forward-token-function)))
+                    (not (eobp))
+                    ;; Could be an open-paren.
+                    (forward-char 1))
                (skip-chars-forward " \t")
                (or (eolp)
                    (and (looking-at comment-start-skip)
@@ -1350,8 +1351,11 @@ should not be computed on the basis of the following token."
                 (if (and (< pos (line-beginning-position))
                          ;; Make sure `token' also *starts* on another line.
                          (save-excursion
-                           (smie-indent-backward-token)
-                           (< pos (line-beginning-position))))
+                           (let ((endpos (point)))
+                             (goto-char pos)
+                             (forward-line 1)
+                             (and (equal res (smie-indent-forward-token))
+                                  (eq (point) endpos)))))
                     nil
                   (goto-char pos)
                   res)))))
@@ -1473,13 +1477,21 @@ should not be computed on the basis of the following token."
        (save-excursion
          (forward-comment (point-max))
          (skip-chars-forward " \t\r\n")
-         ;; FIXME: We assume here that smie-indent-calculate will compute the
-         ;; indentation of the next token based on text before the comment, but
-         ;; this is not guaranteed, so maybe we should let
-         ;; smie-indent-calculate return some info about which buffer position
-         ;; was used as the "indentation base" and check that this base is
-         ;; before `pos'.
-         (smie-indent-calculate))))
+         (unless
+             ;; Don't align with a closer, since the comment is "within" the
+             ;; closed element.  Don't align with EOB either.
+             (save-excursion
+               (let ((next (funcall smie-forward-token-function)))
+                 (or (if (zerop (length next))
+                         (or (eobp) (eq (car (syntax-after (point))) 5)))
+                     (rassoc next smie-closer-alist))))
+           ;; FIXME: We assume here that smie-indent-calculate will compute the
+           ;; indentation of the next token based on text before the comment,
+           ;; but this is not guaranteed, so maybe we should let
+           ;; smie-indent-calculate return some info about which buffer
+           ;; position was used as the "indentation base" and check that this
+           ;; base is before `pos'.
+           (smie-indent-calculate)))))
 
 (defun smie-indent-comment-continue ()
   ;; indentation of comment-continue lines.
diff --git a/lisp/gnus/ChangeLog b/lisp/gnus/ChangeLog
index 144b6482b9d..4cdc8a103bd 100644
--- a/lisp/gnus/ChangeLog
+++ b/lisp/gnus/ChangeLog
@@ -1,3 +1,10 @@
+2013-04-24  Andrew Cohen  <cohen@bu.edu>
+
+        * nnir.el (nnir-close-group): Make sure we are in the right group.
+
+        * gnus-sum.el (gnus-summary-insert-articles): Force updates to the
+        dependency table from all newly retrieved headers.
+
 2013-04-16  David Edmondson  <dme@dme.org>
 
         Support <img src="data:...">.
diff --git a/lisp/gnus/gnus-sum.el b/lisp/gnus/gnus-sum.el
index 93bc35af3bd..e6366e775df 100644
--- a/lisp/gnus/gnus-sum.el
+++ b/lisp/gnus/gnus-sum.el
@@ -12775,7 +12775,7 @@ returned."
     (setq gnus-newsgroup-headers
           (gnus-merge 'list
                       gnus-newsgroup-headers
-                      (gnus-fetch-headers articles)
+                      (gnus-fetch-headers articles nil t)
                       'gnus-article-sort-by-number))
     (setq gnus-newsgroup-articles
           (gnus-sorted-nunion gnus-newsgroup-articles articles))
diff --git a/lisp/gnus/nnir.el b/lisp/gnus/nnir.el
index 2fa6b600ac1..21f81dc664c 100644
--- a/lisp/gnus/nnir.el
+++ b/lisp/gnus/nnir.el
@@ -892,6 +892,7 @@ skips all prompting."
 
 
 (deffoo nnir-close-group (group &optional server)
+  (nnir-possibly-change-group group server)
   (let ((pgroup (gnus-group-guess-full-name-from-command-method group)))
     (when (and nnir-artlist (not (gnus-ephemeral-group-p pgroup)))
       (gnus-group-set-parameter  pgroup 'nnir-artlist nnir-artlist))
diff --git a/lisp/progmodes/octave-inf.el b/lisp/progmodes/octave-inf.el
deleted file mode 100644
index 4a227db7164..00000000000
--- a/lisp/progmodes/octave-inf.el
+++ /dev/null
@@ -1,387 +0,0 @@
-;;; octave-inf.el --- running Octave as an inferior Emacs process
-
-;; Copyright (C) 1997, 2001-2013 Free Software Foundation, Inc.
-
-;; Author: Kurt Hornik <Kurt.Hornik@wu-wien.ac.at>
-;;         John Eaton <jwe@bevo.che.wisc.edu>
-;; Maintainer: FSF
-;; Keywords: languages
-;; Package: octave-mod
-
-;; This file is part of GNU Emacs.
-
-;; GNU Emacs is free software: you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation, either version 3 of the License, or
-;; (at your option) any later version.
-
-;; GNU Emacs is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;; GNU General Public License for more details.
-
-;; You should have received a copy of the GNU General Public License
-;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
-
-;;; Commentary:
-
-;;; Code:
-
-(require 'octave-mod)
-(require 'comint)
-
-(defgroup octave-inferior nil
-  "Running Octave as an inferior Emacs process."
-  :group 'octave)
-
-(defcustom inferior-octave-program "octave"
-  "Program invoked by `inferior-octave'."
-  :type 'string
-  :group 'octave-inferior)
-
-(defcustom inferior-octave-prompt
-  "\\(^octave\\(\\|.bin\\|.exe\\)\\(-[.0-9]+\\)?\\(:[0-9]+\\)?\\|^debug\\|^\\)>+ "
-  "Regexp to match prompts for the inferior Octave process."
-  :type 'regexp
-  :group 'octave-inferior)
-
-(defcustom inferior-octave-startup-file nil
-  "Name of the inferior Octave startup file.
-The contents of this file are sent to the inferior Octave process on
-startup."
-  :type '(choice (const :tag "None" nil)
-                 file)
-  :group 'octave-inferior)
-
-(defcustom inferior-octave-startup-args nil
-  "List of command line arguments for the inferior Octave process.
-For example, for suppressing the startup message and using `traditional'
-mode, set this to (\"-q\" \"--traditional\")."
-  :type '(repeat string)
-  :group 'octave-inferior)
-
-(defvar inferior-octave-mode-map
-  (let ((map (make-sparse-keymap)))
-    (set-keymap-parent map comint-mode-map)
-    (define-key map "\t" 'comint-dynamic-complete)
-    (define-key map "\M-?" 'comint-dynamic-list-filename-completions)
-    (define-key map "\C-c\C-l" 'inferior-octave-dynamic-list-input-ring)
-    (define-key map [menu-bar inout list-history]
-      '("List Input History" . inferior-octave-dynamic-list-input-ring))
-    ;; FIXME: free C-h so it can do the describe-prefix-bindings.
-    (define-key map "\C-c\C-h" 'info-lookup-symbol)
-    map)
-  "Keymap used in Inferior Octave mode.")
-
-(defvar inferior-octave-mode-syntax-table
-  (let ((table (make-syntax-table octave-mode-syntax-table)))
-    table)
-  "Syntax table in use in inferior-octave-mode buffers.")
-
-(defcustom inferior-octave-mode-hook nil
-  "Hook to be run when Inferior Octave mode is started."
-  :type 'hook
-  :group 'octave-inferior)
-
-(defvar inferior-octave-font-lock-keywords
-  (list
-   (cons inferior-octave-prompt 'font-lock-type-face))
-  ;; Could certainly do more font locking in inferior Octave ...
-  "Additional expressions to highlight in Inferior Octave mode.")
-
-
-;;; Compatibility functions
-(if (not (fboundp 'comint-line-beginning-position))
-    ;; comint-line-beginning-position is defined in Emacs 21
-    (defun comint-line-beginning-position ()
-      "Returns the buffer position of the beginning of the line, after any prompt.
-The prompt is assumed to be any text at the beginning of the line matching
-the regular expression `comint-prompt-regexp', a buffer local variable."
-      (save-excursion (comint-bol nil) (point))))
-
-
-(defvar inferior-octave-output-list nil)
-(defvar inferior-octave-output-string nil)
-(defvar inferior-octave-receive-in-progress nil)
-
-(defvar inferior-octave-startup-hook nil)
-
-(defvar inferior-octave-complete-impossible nil
-  "Non-nil means that `inferior-octave-complete' is impossible.")
-
-(defvar inferior-octave-has-built-in-variables nil
-  "Non-nil means that Octave has built-in variables.")
-
-(defvar inferior-octave-dynamic-complete-functions
-  '(inferior-octave-completion-at-point comint-filename-completion)
-  "List of functions called to perform completion for inferior Octave.
-This variable is used to initialize `comint-dynamic-complete-functions'
-in the Inferior Octave buffer.")
-
-(defvar info-lookup-mode)
-
-(define-derived-mode inferior-octave-mode comint-mode "Inferior Octave"
-  "Major mode for interacting with an inferior Octave process.
-Runs Octave as a subprocess of Emacs, with Octave I/O through an Emacs
-buffer.
-
-Entry to this mode successively runs the hooks `comint-mode-hook' and
-`inferior-octave-mode-hook'."
-  (setq comint-prompt-regexp inferior-octave-prompt
-        mode-line-process '(":%s")
-        local-abbrev-table octave-abbrev-table)
-
-  (set (make-local-variable 'comment-start) octave-comment-start)
-  (set (make-local-variable 'comment-end) "")
-  (set (make-local-variable 'comment-column) 32)
-  (set (make-local-variable 'comment-start-skip) octave-comment-start-skip)
-
-  (set (make-local-variable 'font-lock-defaults)
-       '(inferior-octave-font-lock-keywords nil nil))
-
-  (set (make-local-variable 'info-lookup-mode) 'octave-mode)
-
-  (setq comint-input-ring-file-name
-        (or (getenv "OCTAVE_HISTFILE") "~/.octave_hist")
-        comint-input-ring-size (or (getenv "OCTAVE_HISTSIZE") 1024))
-  (set (make-local-variable 'comint-dynamic-complete-functions)
-       inferior-octave-dynamic-complete-functions)
-  (add-hook 'comint-input-filter-functions
-        'inferior-octave-directory-tracker nil t)
-  (comint-read-input-ring t))
-
-;;;###autoload
-(defun inferior-octave (&optional arg)
-  "Run an inferior Octave process, I/O via `inferior-octave-buffer'.
-This buffer is put in Inferior Octave mode.  See `inferior-octave-mode'.
-
-Unless ARG is non-nil, switches to this buffer.
-
-The elements of the list `inferior-octave-startup-args' are sent as
-command line arguments to the inferior Octave process on startup.
-
-Additional commands to be executed on startup can be provided either in
-the file specified by `inferior-octave-startup-file' or by the default
-startup file, `~/.emacs-octave'."
-  (interactive "P")
-  (let ((buffer inferior-octave-buffer))
-    (get-buffer-create buffer)
-    (if (comint-check-proc buffer)
-        ()
-      (with-current-buffer buffer
-        (comint-mode)
-        (inferior-octave-startup)
-        (inferior-octave-mode)))
-    (if (not arg)
-        (pop-to-buffer buffer))))
-
-;;;###autoload
-(defalias 'run-octave 'inferior-octave)
-
-(defun inferior-octave-startup ()
-  "Start an inferior Octave process."
-  (let ((proc (comint-exec-1
-               (substring inferior-octave-buffer 1 -1)
-               inferior-octave-buffer
-               inferior-octave-program
-               (append (list "-i" "--no-line-editing")
-                       inferior-octave-startup-args))))
-    (set-process-filter proc 'inferior-octave-output-digest)
-    (setq comint-ptyp process-connection-type
-          inferior-octave-process proc
-          inferior-octave-output-list nil
-          inferior-octave-output-string nil
-          inferior-octave-receive-in-progress t)
-
-    ;; This may look complicated ... However, we need to make sure that
-    ;; we additional startup code only AFTER Octave is ready (otherwise,
-    ;; output may be mixed up).  Hence, we need to digest the Octave
-    ;; output to see when it issues a prompt.
-    (while inferior-octave-receive-in-progress
-      (accept-process-output inferior-octave-process))
-    (goto-char (point-max))
-    (set-marker (process-mark proc) (point))
-    (insert-before-markers
-     (concat
-      (if (not (bobp)) "\n")
-      (if inferior-octave-output-list
-          (concat (mapconcat
-                   'identity inferior-octave-output-list "\n")
-                  "\n"))))
-
-     ;; Find out whether Octave has built-in variables.
-     (inferior-octave-send-list-and-digest
-      (list "exist \"LOADPATH\"\n"))
-     (setq inferior-octave-has-built-in-variables
-          (string-match "101$" (car inferior-octave-output-list)))
-
-    ;; An empty secondary prompt, as e.g. obtained by '--braindead',
-    ;; means trouble.
-    (inferior-octave-send-list-and-digest (list "PS2\n"))
-    (if (string-match "\\(PS2\\|ans\\) = *$" (car inferior-octave-output-list))
-        (inferior-octave-send-list-and-digest
-         (list (if inferior-octave-has-built-in-variables
-                   "PS2 = \"> \"\n"
-                 "PS2 (\"> \");\n"))))
-
-    ;; O.k., now we are ready for the Inferior Octave startup commands.
-    (let* (commands
-           (program (file-name-nondirectory inferior-octave-program))
-           (file (or inferior-octave-startup-file
-                          (concat "~/.emacs-" program))))
-      (setq commands
-            (list "more off;\n"
-                  (if (not (string-equal
-                            inferior-octave-output-string ">> "))
-                      (if inferior-octave-has-built-in-variables
-                          "PS1=\"\\\\s> \";\n"
-                        "PS1 (\"\\\\s> \");\n"))
-                  (if (file-exists-p file)
-                      (format "source (\"%s\");\n" file))))
-      (inferior-octave-send-list-and-digest commands))
-    (insert-before-markers
-     (concat
-      (if inferior-octave-output-list
-          (concat (mapconcat
-                   'identity inferior-octave-output-list "\n")
-                  "\n"))
-      inferior-octave-output-string))
-    ;; Next, we check whether Octave supports `completion_matches' ...
-    (inferior-octave-send-list-and-digest
-     (list "exist \"completion_matches\"\n"))
-    (setq inferior-octave-complete-impossible
-          (not (string-match "5$" (car inferior-octave-output-list))))
-
-    ;; And finally, everything is back to normal.
-    (set-process-filter proc 'inferior-octave-output-filter)
-    (run-hooks 'inferior-octave-startup-hook)
-    (run-hooks 'inferior-octave-startup-hook)
-    ;; Just in case, to be sure a cd in the startup file
-    ;; won't have detrimental effects.
-    (inferior-octave-resync-dirs)))
-
-
-(defun inferior-octave-completion-at-point ()
-  "Return the data to complete the Octave symbol at point."
-  (let* ((end (point))
-         (start
-          (save-excursion
-            (skip-syntax-backward "w_" (comint-line-beginning-position))
-            (point))))
-    (cond ((eq start end) nil)
-          (inferior-octave-complete-impossible
-           (message (concat
-                     "Your Octave does not have `completion_matches'.  "
-                     "Please upgrade to version 2.X."))
-           nil)
-          (t
-           (list
-            start end
-            (completion-table-dynamic
-             (lambda (command)
-               (inferior-octave-send-list-and-digest
-                (list (concat "completion_matches (\"" command "\");\n")))
-               (sort (delete-dups inferior-octave-output-list)
-                     'string-lessp))))))))
-
-(define-obsolete-function-alias 'inferior-octave-complete
-  'completion-at-point "24.1")
-
-(defun inferior-octave-dynamic-list-input-ring ()
-  "List the buffer's input history in a help buffer."
-  ;; We cannot use `comint-dynamic-list-input-ring', because it replaces
-  ;; "completion" by "history reference" ...
-  (interactive)
-  (if (or (not (ring-p comint-input-ring))
-          (ring-empty-p comint-input-ring))
-      (message "No history")
-    (let ((history nil)
-          (history-buffer " *Input History*")
-          (index (1- (ring-length comint-input-ring)))
-          (conf (current-window-configuration)))
-      ;; We have to build up a list ourselves from the ring vector.
-      (while (>= index 0)
-        (setq history (cons (ring-ref comint-input-ring index) history)
-              index (1- index)))
-      ;; Change "completion" to "history reference"
-      ;; to make the display accurate.
-      (with-output-to-temp-buffer history-buffer
-        (display-completion-list history)
-        (set-buffer history-buffer))
-      (message "Hit space to flush")
-      (let ((ch (read-event)))
-        (if (eq ch ?\ )
-            (set-window-configuration conf)
-          (setq unread-command-events (list ch)))))))
-
-(defun inferior-octave-strip-ctrl-g (string)
-  "Strip leading `^G' character.
-If STRING starts with a `^G', ring the bell and strip it."
-  (if (string-match "^\a" string)
-      (progn
-        (ding)
-        (setq string (substring string 1))))
-  string)
-
-(defun inferior-octave-output-filter (proc string)
-  "Standard output filter for the inferior Octave process.
-Ring Emacs bell if process output starts with an ASCII bell, and pass
-the rest to `comint-output-filter'."
-  (comint-output-filter proc (inferior-octave-strip-ctrl-g string)))
-
-(defun inferior-octave-output-digest (_proc string)
-  "Special output filter for the inferior Octave process.
-Save all output between newlines into `inferior-octave-output-list', and
-the rest to `inferior-octave-output-string'."
-  (setq string (concat inferior-octave-output-string string))
-  (while (string-match "\n" string)
-    (setq inferior-octave-output-list
-          (append inferior-octave-output-list
-                  (list (substring string 0 (match-beginning 0))))
-          string (substring string (match-end 0))))
-  (if (string-match inferior-octave-prompt string)
-      (setq inferior-octave-receive-in-progress nil))
-  (setq inferior-octave-output-string string))
-
-(defun inferior-octave-send-list-and-digest (list)
-  "Send LIST to the inferior Octave process and digest the output.
-The elements of LIST have to be strings and are sent one by one.  All
-output is passed to the filter `inferior-octave-output-digest'."
-  (let* ((proc inferior-octave-process)
-         string)
-    (add-function :override (process-filter proc)
-                  #'inferior-octave-output-digest)
-    (setq inferior-octave-output-list nil)
-    (unwind-protect
-        (while (setq string (car list))
-          (setq inferior-octave-output-string nil
-                inferior-octave-receive-in-progress t)
-          (comint-send-string proc string)
-          (while inferior-octave-receive-in-progress
-            (accept-process-output proc))
-          (setq list (cdr list)))
-      (remove-function (process-filter proc)
-                       #'inferior-octave-output-digest))))
-
-(defun inferior-octave-directory-tracker (string)
-  "Tracks `cd' commands issued to the inferior Octave process.
-Use \\[inferior-octave-resync-dirs] to resync if Emacs gets confused."
-  (cond
-   ((string-match "^[ \t]*cd[ \t;]*$" string)
-    (cd "~"))
-   ((string-match "^[ \t]*cd[ \t]+\\([^ \t\n;]*\\)[ \t\n;]*" string)
-    (cd (substring string (match-beginning 1) (match-end 1))))))
-
-(defun inferior-octave-resync-dirs ()
-  "Resync the buffer's idea of the current directory.
-This command queries the inferior Octave process about its current
-directory and makes this the current buffer's default directory."
-  (interactive)
-  (inferior-octave-send-list-and-digest '("disp (pwd ())\n"))
-  (cd (car inferior-octave-output-list)))
-
-;;; provide ourself
-
-(provide 'octave-inf)
-
-;;; octave-inf.el ends here
diff --git a/lisp/progmodes/octave-mod.el b/lisp/progmodes/octave.el
index 4683186e603..0e540ea348a 100644
--- a/lisp/progmodes/octave-mod.el
+++ b/lisp/progmodes/octave.el
@@ -1,4 +1,4 @@
-;;; octave-mod.el --- editing Octave source files under Emacs
+;;; octave.el --- editing octave source files under emacs
 
 ;; Copyright (C) 1997, 2001-2013 Free Software Foundation, Inc.
 
@@ -24,30 +24,21 @@
 
 ;;; Commentary:
 
-;; This package provides Emacs support for Octave.
-;; It defines Octave mode, a major mode for editing
-;; Octave code.
+;; This package provides emacs support for octave.  It defines a major
+;; mode for editing octave code and contains code for interacting with
+;; an inferior octave process using comint.
 
-;; The file octave-inf.el contains code for interacting with an inferior
-;; Octave process using comint.
-
-;; See the documentation of `octave-mode' and
-;; `run-octave' for further information on usage and customization.
+;; See the documentation of `octave-mode' and `run-octave' for further
+;; information on usage and customization.
 
 ;;; Code:
-(require 'custom)
+(require 'comint)
 
 (defgroup octave nil
-  "Major mode for editing Octave source files."
+  "Editing Octave code."
   :link '(custom-group-link :tag "Font Lock Faces group" font-lock-faces)
   :group 'languages)
 
-(defvar inferior-octave-output-list nil)
-(defvar inferior-octave-output-string nil)
-(defvar inferior-octave-receive-in-progress nil)
-
-(declare-function inferior-octave-send-list-and-digest "octave-inf" (list))
-
 (defconst octave-maintainer-address
   "Kurt Hornik <Kurt.Hornik@wu-wien.ac.at>, bug-gnu-emacs@gnu.org"
   "Current maintainer of the Emacs Octave package.")
@@ -84,7 +75,7 @@
             ("`upc" "unwind_protect_cleanup")
             ("`w" "while ()")))
   "Abbrev table for Octave's reserved words.
-Used in `octave-mode' and inferior-octave-mode buffers.
+Used in `octave-mode' and `inferior-octave-mode' buffers.
 All Octave abbrevs start with a grave accent (`)."
   :regexp "\\(?:[^`]\\|^\\)\\(\\(?:\\<\\|`\\)\\w+\\)\\W*")
 
@@ -156,6 +147,7 @@ All Octave abbrevs start with a grave accent (`)."
 The string `function' and its name are given by the first and third
 parenthetical grouping.")
 
+
 (defvar octave-font-lock-keywords
   (list
    ;; Fontify all builtin keywords.
@@ -201,12 +193,6 @@ parenthetical grouping.")
       (put-text-property (match-beginning 1) (match-end 1)
                          'syntax-table (string-to-syntax "\"'")))))
 
-(defcustom inferior-octave-buffer "*Inferior Octave*"
-  "Name of buffer for running an inferior Octave process."
-  :type 'string
-  :group 'octave-inferior)
-
-(defvar inferior-octave-process nil)
 
 (defvar octave-mode-map
   (let ((map (make-sparse-keymap)))
@@ -344,12 +330,6 @@ newline or semicolon after an else or end keyword."
   :type 'string
   :group 'octave)
 
-(defvar octave-completion-alist nil
-  "Alist of Octave symbols for completion in Octave mode.
-Each element looks like (VAR . VAR), where the car and cdr are the same
-symbol (an Octave command or variable name).
-Currently, only builtin variables can be completed.")
-
 (defvar octave-mode-imenu-generic-expression
   (list
    ;; Functions
@@ -482,6 +462,7 @@ Non-nil means always go to the next Octave code line after sending."
     (forward-comment 1))
   (cond
    ((and (looking-at "$\\|[%#]")
+         (not (smie-rule-bolp))
          ;; Ignore it if it's within parentheses.
          (prog1 (let ((ppss (syntax-ppss)))
                   (not (and (nth 1 ppss)
@@ -652,8 +633,359 @@ including a reproducible test case and send the message."
   (set (make-local-variable 'beginning-of-defun-function)
        'octave-beginning-of-defun)
 
-  (easy-menu-add octave-mode-menu)
-  (octave-initialize-completions))
+  (easy-menu-add octave-mode-menu))
+
+
+(defcustom inferior-octave-program "octave"
+  "Program invoked by `inferior-octave'."
+  :type 'string
+  :group 'octave)
+
+(defcustom inferior-octave-buffer "*Inferior Octave*"
+  "Name of buffer for running an inferior Octave process."
+  :type 'string
+  :group 'octave)
+
+(defcustom inferior-octave-prompt
+  "\\(^octave\\(\\|.bin\\|.exe\\)\\(-[.0-9]+\\)?\\(:[0-9]+\\)?\\|^debug\\|^\\)>+ "
+  "Regexp to match prompts for the inferior Octave process."
+  :type 'regexp
+  :group 'octave)
+
+(defcustom inferior-octave-startup-file nil
+  "Name of the inferior Octave startup file.
+The contents of this file are sent to the inferior Octave process on
+startup."
+  :type '(choice (const :tag "None" nil)
+                 file)
+  :group 'octave)
+
+(defcustom inferior-octave-startup-args nil
+  "List of command line arguments for the inferior Octave process.
+For example, for suppressing the startup message and using `traditional'
+mode, set this to (\"-q\" \"--traditional\")."
+  :type '(repeat string)
+  :group 'octave)
+
+(defcustom inferior-octave-mode-hook nil
+  "Hook to be run when Inferior Octave mode is started."
+  :type 'hook
+  :group 'octave)
+
+(defvar inferior-octave-process nil)
+
+(defvar inferior-octave-mode-map
+  (let ((map (make-sparse-keymap)))
+    (set-keymap-parent map comint-mode-map)
+    (define-key map "\t" 'comint-dynamic-complete)
+    (define-key map "\M-?" 'comint-dynamic-list-filename-completions)
+    (define-key map "\C-c\C-l" 'inferior-octave-dynamic-list-input-ring)
+    (define-key map [menu-bar inout list-history]
+      '("List Input History" . inferior-octave-dynamic-list-input-ring))
+    map)
+  "Keymap used in Inferior Octave mode.")
+
+(defvar inferior-octave-mode-syntax-table
+  (let ((table (make-syntax-table octave-mode-syntax-table)))
+    table)
+  "Syntax table in use in inferior-octave-mode buffers.")
+
+(defvar inferior-octave-font-lock-keywords
+  (list
+   (cons inferior-octave-prompt 'font-lock-type-face))
+  ;; Could certainly do more font locking in inferior Octave ...
+  "Additional expressions to highlight in Inferior Octave mode.")
+
+
+;;; Compatibility functions
+(if (not (fboundp 'comint-line-beginning-position))
+    ;; comint-line-beginning-position is defined in Emacs 21
+    (defun comint-line-beginning-position ()
+      "Returns the buffer position of the beginning of the line, after any prompt.
+The prompt is assumed to be any text at the beginning of the line matching
+the regular expression `comint-prompt-regexp', a buffer local variable."
+      (save-excursion (comint-bol nil) (point))))
+
+
+(defvar inferior-octave-output-list nil)
+(defvar inferior-octave-output-string nil)
+(defvar inferior-octave-receive-in-progress nil)
+
+(defvar inferior-octave-startup-hook nil)
+
+(defvar inferior-octave-complete-impossible nil
+  "Non-nil means that `inferior-octave-complete' is impossible.")
+
+(defvar inferior-octave-has-built-in-variables nil
+  "Non-nil means that Octave has built-in variables.")
+
+(defvar inferior-octave-dynamic-complete-functions
+  '(inferior-octave-completion-at-point comint-filename-completion)
+  "List of functions called to perform completion for inferior Octave.
+This variable is used to initialize `comint-dynamic-complete-functions'
+in the Inferior Octave buffer.")
+
+(defvar info-lookup-mode)
+
+(define-derived-mode inferior-octave-mode comint-mode "Inferior Octave"
+  "Major mode for interacting with an inferior Octave process.
+Runs Octave as a subprocess of Emacs, with Octave I/O through an Emacs
+buffer.
+
+Entry to this mode successively runs the hooks `comint-mode-hook' and
+`inferior-octave-mode-hook'."
+  (setq comint-prompt-regexp inferior-octave-prompt
+        mode-line-process '(":%s")
+        local-abbrev-table octave-abbrev-table)
+
+  (set (make-local-variable 'comment-start) octave-comment-start)
+  (set (make-local-variable 'comment-end) "")
+  (set (make-local-variable 'comment-column) 32)
+  (set (make-local-variable 'comment-start-skip) octave-comment-start-skip)
+
+  (set (make-local-variable 'font-lock-defaults)
+       '(inferior-octave-font-lock-keywords nil nil))
+
+  (set (make-local-variable 'info-lookup-mode) 'octave-mode)
+
+  (setq comint-input-ring-file-name
+        (or (getenv "OCTAVE_HISTFILE") "~/.octave_hist")
+        comint-input-ring-size (or (getenv "OCTAVE_HISTSIZE") 1024))
+  (set (make-local-variable 'comint-dynamic-complete-functions)
+       inferior-octave-dynamic-complete-functions)
+  (add-hook 'comint-input-filter-functions
+        'inferior-octave-directory-tracker nil t)
+  (comint-read-input-ring t))
+
+;;;###autoload
+(defun inferior-octave (&optional arg)
+  "Run an inferior Octave process, I/O via `inferior-octave-buffer'.
+This buffer is put in Inferior Octave mode.  See `inferior-octave-mode'.
+
+Unless ARG is non-nil, switches to this buffer.
+
+The elements of the list `inferior-octave-startup-args' are sent as
+command line arguments to the inferior Octave process on startup.
+
+Additional commands to be executed on startup can be provided either in
+the file specified by `inferior-octave-startup-file' or by the default
+startup file, `~/.emacs-octave'."
+  (interactive "P")
+  (let ((buffer inferior-octave-buffer))
+    (get-buffer-create buffer)
+    (if (comint-check-proc buffer)
+        ()
+      (with-current-buffer buffer
+        (comint-mode)
+        (inferior-octave-startup)
+        (inferior-octave-mode)))
+    (if (not arg)
+        (pop-to-buffer buffer))))
+
+;;;###autoload
+(defalias 'run-octave 'inferior-octave)
+
+(defun inferior-octave-startup ()
+  "Start an inferior Octave process."
+  (let ((proc (comint-exec-1
+               (substring inferior-octave-buffer 1 -1)
+               inferior-octave-buffer
+               inferior-octave-program
+               (append (list "-i" "--no-line-editing")
+                       inferior-octave-startup-args))))
+    (set-process-filter proc 'inferior-octave-output-digest)
+    (setq comint-ptyp process-connection-type
+          inferior-octave-process proc
+          inferior-octave-output-list nil
+          inferior-octave-output-string nil
+          inferior-octave-receive-in-progress t)
+
+    ;; This may look complicated ... However, we need to make sure that
+    ;; we additional startup code only AFTER Octave is ready (otherwise,
+    ;; output may be mixed up).  Hence, we need to digest the Octave
+    ;; output to see when it issues a prompt.
+    (while inferior-octave-receive-in-progress
+      (accept-process-output inferior-octave-process))
+    (goto-char (point-max))
+    (set-marker (process-mark proc) (point))
+    (insert-before-markers
+     (concat
+      (if (not (bobp)) "\n")
+      (if inferior-octave-output-list
+          (concat (mapconcat
+                   'identity inferior-octave-output-list "\n")
+                  "\n"))))
+
+     ;; Find out whether Octave has built-in variables.
+     (inferior-octave-send-list-and-digest
+      (list "exist \"LOADPATH\"\n"))
+     (setq inferior-octave-has-built-in-variables
+          (string-match "101$" (car inferior-octave-output-list)))
+
+    ;; An empty secondary prompt, as e.g. obtained by '--braindead',
+    ;; means trouble.
+    (inferior-octave-send-list-and-digest (list "PS2\n"))
+    (if (string-match "\\(PS2\\|ans\\) = *$" (car inferior-octave-output-list))
+        (inferior-octave-send-list-and-digest
+         (list (if inferior-octave-has-built-in-variables
+                   "PS2 = \"> \"\n"
+                 "PS2 (\"> \");\n"))))
+
+    ;; O.k., now we are ready for the Inferior Octave startup commands.
+    (let* (commands
+           (program (file-name-nondirectory inferior-octave-program))
+           (file (or inferior-octave-startup-file
+                          (concat "~/.emacs-" program))))
+      (setq commands
+            (list "more off;\n"
+                  (if (not (string-equal
+                            inferior-octave-output-string ">> "))
+                      (if inferior-octave-has-built-in-variables
+                          "PS1=\"\\\\s> \";\n"
+                        "PS1 (\"\\\\s> \");\n"))
+                  (if (file-exists-p file)
+                      (format "source (\"%s\");\n" file))))
+      (inferior-octave-send-list-and-digest commands))
+    (insert-before-markers
+     (concat
+      (if inferior-octave-output-list
+          (concat (mapconcat
+                   'identity inferior-octave-output-list "\n")
+                  "\n"))
+      inferior-octave-output-string))
+    ;; Next, we check whether Octave supports `completion_matches' ...
+    (inferior-octave-send-list-and-digest
+     (list "exist \"completion_matches\"\n"))
+    (setq inferior-octave-complete-impossible
+          (not (string-match "5$" (car inferior-octave-output-list))))
+
+    ;; And finally, everything is back to normal.
+    (set-process-filter proc 'inferior-octave-output-filter)
+    (run-hooks 'inferior-octave-startup-hook)
+    (run-hooks 'inferior-octave-startup-hook)
+    ;; Just in case, to be sure a cd in the startup file
+    ;; won't have detrimental effects.
+    (inferior-octave-resync-dirs)))
+
+(defun inferior-octave-completion-table ()
+  (unless inferior-octave-complete-impossible
+    (completion-table-dynamic
+     (lambda (command)
+       (inferior-octave-send-list-and-digest
+        (list (concat "completion_matches (\"" command "\");\n")))
+       (sort (delete-dups inferior-octave-output-list)
+             'string-lessp)))))
+
+(defun inferior-octave-completion-at-point ()
+  "Return the data to complete the Octave symbol at point."
+  (let* ((end (point))
+         (start
+          (save-excursion
+            (skip-syntax-backward "w_" (comint-line-beginning-position))
+            (point))))
+    (cond ((eq start end) nil)
+          (inferior-octave-complete-impossible
+           (message (concat
+                     "Your Octave does not have `completion_matches'.  "
+                     "Please upgrade to version 2.X."))
+           nil)
+          (t (list start end (inferior-octave-completion-table))))))
+
+(define-obsolete-function-alias 'inferior-octave-complete
+  'completion-at-point "24.1")
+
+(defun inferior-octave-dynamic-list-input-ring ()
+  "List the buffer's input history in a help buffer."
+  ;; We cannot use `comint-dynamic-list-input-ring', because it replaces
+  ;; "completion" by "history reference" ...
+  (interactive)
+  (if (or (not (ring-p comint-input-ring))
+          (ring-empty-p comint-input-ring))
+      (message "No history")
+    (let ((history nil)
+          (history-buffer " *Input History*")
+          (index (1- (ring-length comint-input-ring)))
+          (conf (current-window-configuration)))
+      ;; We have to build up a list ourselves from the ring vector.
+      (while (>= index 0)
+        (setq history (cons (ring-ref comint-input-ring index) history)
+              index (1- index)))
+      ;; Change "completion" to "history reference"
+      ;; to make the display accurate.
+      (with-output-to-temp-buffer history-buffer
+        (display-completion-list history)
+        (set-buffer history-buffer))
+      (message "Hit space to flush")
+      (let ((ch (read-event)))
+        (if (eq ch ?\ )
+            (set-window-configuration conf)
+          (setq unread-command-events (list ch)))))))
+
+(defun inferior-octave-strip-ctrl-g (string)
+  "Strip leading `^G' character.
+If STRING starts with a `^G', ring the bell and strip it."
+  (if (string-match "^\a" string)
+      (progn
+        (ding)
+        (setq string (substring string 1))))
+  string)
+
+(defun inferior-octave-output-filter (proc string)
+  "Standard output filter for the inferior Octave process.
+Ring Emacs bell if process output starts with an ASCII bell, and pass
+the rest to `comint-output-filter'."
+  (comint-output-filter proc (inferior-octave-strip-ctrl-g string)))
+
+(defun inferior-octave-output-digest (_proc string)
+  "Special output filter for the inferior Octave process.
+Save all output between newlines into `inferior-octave-output-list', and
+the rest to `inferior-octave-output-string'."
+  (setq string (concat inferior-octave-output-string string))
+  (while (string-match "\n" string)
+    (setq inferior-octave-output-list
+          (append inferior-octave-output-list
+                  (list (substring string 0 (match-beginning 0))))
+          string (substring string (match-end 0))))
+  (if (string-match inferior-octave-prompt string)
+      (setq inferior-octave-receive-in-progress nil))
+  (setq inferior-octave-output-string string))
+
+(defun inferior-octave-send-list-and-digest (list)
+  "Send LIST to the inferior Octave process and digest the output.
+The elements of LIST have to be strings and are sent one by one.  All
+output is passed to the filter `inferior-octave-output-digest'."
+  (let* ((proc inferior-octave-process)
+         (filter (process-filter proc))
+         string)
+    (set-process-filter proc 'inferior-octave-output-digest)
+    (setq inferior-octave-output-list nil)
+    (unwind-protect
+        (while (setq string (car list))
+          (setq inferior-octave-output-string nil
+                inferior-octave-receive-in-progress t)
+          (comint-send-string proc string)
+          (while inferior-octave-receive-in-progress
+            (accept-process-output proc))
+          (setq list (cdr list)))
+      (set-process-filter proc filter))))
+
+(defun inferior-octave-directory-tracker (string)
+  "Tracks `cd' commands issued to the inferior Octave process.
+Use \\[inferior-octave-resync-dirs] to resync if Emacs gets confused."
+  (cond
+   ((string-match "^[ \t]*cd[ \t;]*$" string)
+    (cd "~"))
+   ((string-match "^[ \t]*cd[ \t]+\\([^ \t\n;]*\\)[ \t\n;]*" string)
+    (cd (substring string (match-beginning 1) (match-end 1))))))
+
+(defun inferior-octave-resync-dirs ()
+  "Resync the buffer's idea of the current directory.
+This command queries the inferior Octave process about its current
+directory and makes this the current buffer's default directory."
+  (interactive)
+  (inferior-octave-send-list-and-digest '("disp (pwd ())\n"))
+  (cd (car inferior-octave-output-list)))
+
 
 ;;; Miscellaneous useful functions
 
@@ -958,14 +1290,6 @@ otherwise."
 
 
 ;;; Completions
-(defun octave-initialize-completions ()
-  "Create an alist for Octave completions."
-  (if octave-completion-alist
-      ()
-    (setq octave-completion-alist
-          (append octave-reserved-words
-                  octave-text-functions
-                  octave-variables))))
 
 (defun octave-completion-at-point-function ()
   "Find the text to complete and the corresponding table."
@@ -975,7 +1299,12 @@ otherwise."
         ;; Extend region past point, if applicable.
         (save-excursion (skip-syntax-forward "w_")
                         (setq end (point))))
-    (list beg end octave-completion-alist)))
+    (list beg end (or (and inferior-octave-process
+                           (process-live-p inferior-octave-process)
+                           (inferior-octave-completion-table))
+                      (append octave-reserved-words
+                              octave-text-functions
+                              octave-variables)))))
 
 (define-obsolete-function-alias 'octave-complete-symbol
   'completion-at-point "24.1")
@@ -1142,8 +1471,5 @@ code line."
      'octave-send-line-auto-forward
      'octave-send-show-buffer))))
 
-;; provide ourself
-
-(provide 'octave-mod)
-
-;;; octave-mod.el ends here
+(provide 'octave)
+;;; octave.el ends here
diff --git a/lisp/progmodes/opascal.el b/lisp/progmodes/opascal.el
index 5f78b770936..e608ea8af0e 100644
--- a/lisp/progmodes/opascal.el
+++ b/lisp/progmodes/opascal.el
@@ -110,29 +110,6 @@ end;                            end;"
 regardless of where in the line point is when the TAB command is used."
   :type 'boolean)
 
-(define-obsolete-variable-alias
-  'delphi-comment-face 'opascal-comment-face "24.4")
-(defcustom opascal-comment-face 'font-lock-comment-face
-  "Face used to color OPascal comments."
-  :type 'face)
-
-(define-obsolete-variable-alias
-  'delphi-string-face 'opascal-string-face "24.4")
-(defcustom opascal-string-face 'font-lock-string-face
-  "Face used to color OPascal strings."
-  :type 'face)
-
-(define-obsolete-variable-alias
-  'delphi-keyword-face 'opascal-keyword-face "24.4")
-(defcustom opascal-keyword-face 'font-lock-keyword-face
-  "Face used to color OPascal keywords."
-  :type 'face)
-
-(define-obsolete-variable-alias 'delphi-other-face 'opascal-other-face "24.4")
-(defcustom opascal-other-face nil
-  "Face used to color everything else."
-  :type '(choice (const :tag "None" nil) face))
-
 (defconst opascal-directives
   '(absolute abstract assembler automated cdecl default dispid dynamic
     export external far forward index inline message name near nodefault
@@ -274,6 +251,21 @@ routine.")
 (defconst opascal-leading-spaces-re (concat "^" opascal-spaces-re))
 (defconst opascal-word-chars "a-zA-Z0-9_")
 
+(defvar opascal-mode-syntax-table
+  (let ((st (make-syntax-table)))
+    ;; Strings.
+    (modify-syntax-entry ?\" "\"" st)
+    (modify-syntax-entry ?\' "\"" st)
+    ;; Comments.
+    (modify-syntax-entry ?\{ "<" st)
+    (modify-syntax-entry ?\} ">" st)
+    (modify-syntax-entry ?\( "()1" st)
+    (modify-syntax-entry ?\) ")(4" st)
+    (modify-syntax-entry ?*  ". 23b" st)
+    (modify-syntax-entry ?/  ". 12c" st)
+    (modify-syntax-entry ?\n "> c" st)
+    st))
+
 (defmacro opascal-save-excursion (&rest forms)
   ;; Executes the forms such that any movements have no effect, including
   ;; searches.
@@ -283,13 +275,6 @@ routine.")
             (deactivate-mark nil))
         (progn ,@forms)))))
 
-(defmacro opascal-save-state (&rest forms)
-  ;; Executes the forms such that any buffer modifications do not have any side
-  ;; effects beyond the buffer's actual content changes.
-  `(let ((opascal--ignore-changes t))
-     (with-silent-modifications
-       ,@forms)))
-
 (defsubst opascal-is (element in-set)
   ;; If the element is in the set, the element cdr is returned, otherwise nil.
   (memq element in-set))
@@ -347,13 +332,6 @@ routine.")
   ;; Returns the column of the point p.
   (save-excursion (goto-char p) (current-column)))
 
-(defun opascal-face-of (token-kind)
-  ;; Returns the face property appropriate for the token kind.
-  (cond ((opascal-is token-kind opascal-comments) opascal-comment-face)
-        ((opascal-is token-kind opascal-strings) opascal-string-face)
-        ((opascal-is token-kind opascal-keywords) opascal-keyword-face)
-        (opascal-other-face)))
-
 (defvar opascal-progress-last-reported-point nil
   "The last point at which progress was reported.")
 
@@ -361,8 +339,6 @@ routine.")
   "Number of chars to process before the next parsing progress report.")
 (defconst opascal-scanning-progress-step 2048
   "Number of chars to process before the next scanning progress report.")
-(defconst opascal-fontifying-progress-step opascal-scanning-progress-step
-  "Number of chars to process before the next fontification progress report.")
 
 (defun opascal-progress-start ()
   ;; Initializes progress reporting.
@@ -400,22 +376,30 @@ routine.")
     (goto-char curr-point)
     next))
 
-(defvar opascal--ignore-changes t
-  "Internal flag to control if the OPascal mode responds to buffer changes.
-Defaults to t in case the `opascal-after-change' function is called on a
-non-OPascal buffer.  Set to nil in OPascal buffers.  To override, just do:
- (let ((opascal--ignore-changes t)) ...)")
-
-(defun opascal-set-text-properties (from to properties)
-  ;; Like `set-text-properties', except we do not consider this to be a buffer
-  ;; modification.
-  (opascal-save-state
-   (set-text-properties from to properties)))
+(defconst opascal--literal-start-re (regexp-opt '("//" "{" "(*" "'" "\"")))
 
 (defun opascal-literal-kind (p)
   ;; Returns the literal kind the point p is in (or nil if not in a literal).
-  (if (and (<= (point-min) p) (<= p (point-max)))
-      (get-text-property p 'token)))
+  (when (and (<= (point-min) p) (<= p (point-max)))
+    (save-excursion
+      (let ((ppss (syntax-ppss p)))
+        ;; We want to return non-nil when right in front
+        ;; of a comment/string.
+        (if (null (nth 8 ppss))
+            (when (looking-at opascal--literal-start-re)
+              (pcase (char-after)
+                (`?/  'comment-single-line)
+                (`?\{ 'comment-multi-line-1)
+                (`?\( 'comment-multi-line-2)
+                (`?\' 'string)
+                (`?\" 'double-quoted-string)))
+          (if (nth 3 ppss)   ;String.
+              (if (eq (nth 3 ppss) ?\")
+                  'double-quoted-string 'string)
+            (pcase (nth 7 ppss)
+              (`2 'comment-single-line)
+              (`1 'comment-multi-line-2)
+              (_  'comment-multi-line-1))))))))
 
 (defun opascal-literal-start-pattern (literal-kind)
   ;; Returns the start pattern of the literal kind.
@@ -446,96 +430,27 @@ non-OPascal buffer.  Set to nil in OPascal buffers.  To override, just do:
                 (string . "['\n]")
                 (double-quoted-string . "[\"\n]")))))
 
-(defun opascal-is-literal-start (p)
-  ;; True if the point p is at the start point of a (completed) literal.
-  (let* ((kind (opascal-literal-kind p))
-         (pattern (opascal-literal-start-pattern kind)))
-    (or (null kind) ; Non-literals are considered as start points.
-        (opascal-looking-at-string p pattern))))
-
 (defun opascal-is-literal-end (p)
   ;; True if the point p is at the end point of a (completed) literal.
-  (let* ((kind (opascal-literal-kind (1- p)))
-         (pattern (opascal-literal-end-pattern kind)))
-    (or (null kind) ; Non-literals are considered as end points.
-
-        (and (opascal-looking-at-string (- p (length pattern)) pattern)
-             (or (not (opascal-is kind opascal-strings))
-                 ;; Special case: string delimiters are start/end ambiguous.
-                 ;; We have an end only if there is some string content (at
-                 ;; least a starting delimiter).
-                 (not (opascal-is-literal-end (1- p)))))
-
-        ;; Special case: strings cannot span lines.
-        (and (opascal-is kind opascal-strings) (eq ?\n (char-after (1- p)))))))
-
-(defun opascal-is-stable-literal (p)
-  ;; True if the point p marks a stable point. That is, a point outside of a
-  ;; literal region, inside of a literal region, or adjacent to completed
-  ;; literal regions.
-  (let ((at-start (opascal-is-literal-start p))
-        (at-end  (opascal-is-literal-end p)))
-    (or (>= p (point-max))
-        (and at-start at-end)
-        (and (not at-start) (not at-end)
-             (eq (opascal-literal-kind (1- p)) (opascal-literal-kind p))))))
-
-(defun opascal-complete-literal (literal-kind limit)
-  ;; Continues the search for a literal's true end point and returns the
-  ;; point past the end pattern (if found) or the limit (if not found).
-  (let ((pattern (opascal-literal-stop-pattern literal-kind)))
-    (if (not (stringp pattern))
-        (error "Invalid literal kind %S" literal-kind)
-      ;; Search up to the limit.
-      (re-search-forward pattern limit 'goto-limit-on-fail)
-      (point))))
-
-(defun opascal-literal-text-properties (kind)
-  ;; Creates a list of text properties for the literal kind.
-  (if (and (boundp 'font-lock-mode)
-           font-lock-mode)
-      (list 'token kind 'face (opascal-face-of kind) 'lazy-lock t)
-    (list 'token kind)))
-
-(defun opascal-parse-next-literal (limit)
-  ;; Searches for the next literal region (i.e. comment or string) and sets the
-  ;; the point to its end (or the limit, if not found). The literal region is
-  ;; marked as such with a text property, to speed up tokenizing during face
-  ;; coloring and indentation scanning.
-  (let ((search-start (point)))
-    (cond ((not (opascal-is-literal-end search-start))
-           ;; We are completing an incomplete literal.
-           (let ((kind (opascal-literal-kind (1- search-start))))
-             (opascal-complete-literal kind limit)
-             (opascal-set-text-properties
-              search-start (point) (opascal-literal-text-properties kind))))
-
-          ((re-search-forward
-            "\\(//\\)\\|\\({\\)\\|\\((\\*\\)\\|\\('\\)\\|\\(\"\\)"
-            limit 'goto-limit-on-fail)
-           ;; We found the start of a new literal. Find its end and mark it.
-           (let ((kind (cond ((match-beginning 1) 'comment-single-line)
-                             ((match-beginning 2) 'comment-multi-line-1)
-                             ((match-beginning 3) 'comment-multi-line-2)
-                             ((match-beginning 4) 'string)
-                             ((match-beginning 5) 'double-quoted-string)))
-                 (start (match-beginning 0)))
-             (opascal-set-text-properties search-start start nil)
-             (opascal-complete-literal kind limit)
-             (opascal-set-text-properties
-              start (point) (opascal-literal-text-properties kind))))
-
-          ;; Nothing found. Mark it as a non-literal.
-          ((opascal-set-text-properties search-start limit nil)))
-    (opascal-step-progress (point) "Parsing" opascal-parsing-progress-step)))
+  (save-excursion
+    (and (null (nth 8 (syntax-ppss p)))
+         (nth 8 (syntax-ppss (1- p))))))
 
 (defun opascal-literal-token-at (p)
-  ;; Returns the literal token surrounding the point p, or nil if none.
-  (let ((kind (opascal-literal-kind p)))
-    (when kind
-      (let ((start (previous-single-property-change (1+ p) 'token))
-            (end (next-single-property-change p 'token)))
-        (opascal-token-of kind (or start (point-min)) (or end (point-max)))))))
+  "Return the literal token surrounding the point P, or nil if none."
+  (save-excursion
+    (let ((ppss (syntax-ppss p)))
+      (when (or (nth 8 ppss) (looking-at opascal--literal-start-re))
+        (let* ((new-start (or (nth 8 ppss) p))
+               (new-end (progn
+                          (goto-char new-start)
+                          (condition-case nil
+                              (if (memq (char-after) '(?\' ?\"))
+                                  (forward-sexp 1)
+                                (forward-comment 1))
+                            (scan-error (goto-char (point-max))))
+                          (point))))
+          (opascal-token-of (opascal-literal-kind p) new-start new-end))))))
 
 (defun opascal-point-token-at (p kind)
   ;; Returns the single character token at the point p.
@@ -645,55 +560,6 @@ non-OPascal buffer.  Set to nil in OPascal buffers.  To override, just do:
              (opascal-is (opascal-token-kind next-token) '(space newline))))
     next-token))
 
-(defun opascal-parse-region (from to)
-  ;; Parses the literal tokens in the region. The point is set to "to".
-  (save-restriction
-    (widen)
-    (goto-char from)
-    (while (< (point) to)
-      (opascal-parse-next-literal to))))
-
-(defun opascal-parse-region-until-stable (from to)
-  ;; Parses at least the literal tokens in the region. After that, parsing
-  ;; continues as long as obsolete literal regions are encountered. The point
-  ;; is set to the encountered stable point.
-  (save-restriction
-    (widen)
-    (opascal-parse-region from to)
-    (while (not (opascal-is-stable-literal (point)))
-      (opascal-parse-next-literal (point-max)))))
-
-(defun opascal-fontify-region (from to &optional verbose)
-  ;; Colors the text in the region according to OPascal rules.
-  (opascal-save-excursion
-   (opascal-save-state
-    (let ((p from)
-          (opascal-verbose verbose)
-          (token nil))
-      (opascal-progress-start)
-      (while (< p to)
-        ;; Color the token and move past it.
-        (setq token (opascal-token-at p))
-        (add-text-properties
-         (opascal-token-start token) (opascal-token-end token)
-         (list 'face (opascal-face-of (opascal-token-kind token)) 'lazy-lock t))
-        (setq p (opascal-token-end token))
-        (opascal-step-progress p "Fontifying" opascal-fontifying-progress-step))
-      (opascal-progress-done)))))
-
-(defun opascal-after-change (change-start change-end _old-length)
-  ;; Called when the buffer has changed. Reparses the changed region.
-  (unless opascal--ignore-changes
-    (let ((opascal--ignore-changes t)) ; Prevent recursive calls.
-      (opascal-save-excursion
-       (opascal-progress-start)
-       ;; Reparse at least from the token previous to the change to the end of
-       ;; line after the change.
-       (opascal-parse-region-until-stable
-        (opascal-token-start (opascal-token-at (1- change-start)))
-        (progn (goto-char change-end) (end-of-line) (point)))
-       (opascal-progress-done)))))
-
 (defun opascal-group-start (from-token)
   ;; Returns the token that denotes the start of the ()/[] group.
   (let ((token (opascal-previous-token from-token))
@@ -1561,41 +1427,6 @@ If before the indent, the point is moved to the indent."
   (interactive "r")
   (opascal-debug-log "String: %S" (buffer-substring from to)))
 
-(defun opascal-debug-show-is-stable ()
-  (interactive)
-  (opascal-debug-log "stable: %S prev: %S next: %S"
-                    (opascal-is-stable-literal (point))
-                    (opascal-literal-kind (1- (point)))
-                    (opascal-literal-kind (point))))
-
-(defun opascal-debug-unparse-buffer ()
-  (interactive)
-  (opascal-set-text-properties (point-min) (point-max) nil))
-
-(defun opascal-debug-parse-region (from to)
-  (interactive "r")
-  (let ((opascal-verbose t))
-    (opascal-save-excursion
-     (opascal-progress-start)
-     (opascal-parse-region from to)
-     (opascal-progress-done "Parsing done"))))
-
-(defun opascal-debug-parse-window ()
-  (interactive)
-  (opascal-debug-parse-region (window-start) (window-end)))
-
-(defun opascal-debug-parse-buffer ()
-  (interactive)
-  (opascal-debug-parse-region (point-min) (point-max)))
-
-(defun opascal-debug-fontify-window ()
-  (interactive)
-  (opascal-fontify-region (window-start) (window-end) t))
-
-(defun opascal-debug-fontify-buffer ()
-  (interactive)
-  (opascal-fontify-region (point-min) (point-max) t))
-
 (defun opascal-debug-tokenize-region (from to)
   (interactive)
   (opascal-save-excursion
@@ -1747,6 +1578,7 @@ An error is raised if not in a comment."
           (error "Not in a comment")
         (let* ((start-comment (opascal-comment-block-start comment))
                (end-comment (opascal-comment-block-end comment))
+               ;; FIXME: Don't abuse global variables like `comment-end/start'.
                (comment-start (opascal-token-start start-comment))
                (comment-end (opascal-token-end end-comment))
                (content-start (opascal-comment-content-start start-comment))
@@ -1814,12 +1646,7 @@ An error is raised if not in a comment."
 
           ;; Restore our position
           (goto-char marked-point)
-          (set-marker marked-point nil)
-
-          ;; React to the entire fill change as a whole.
-          (opascal-progress-start)
-          (opascal-parse-region comment-start comment-end)
-            (opascal-progress-done)))))))
+          (set-marker marked-point nil)))))))
 
 (defun opascal-new-comment-line ()
   "If in a // comment, do a newline, indented such that one is still in the
@@ -1848,16 +1675,37 @@ comment block.  If not in a // comment, just does a normal newline."
         (goto-char end)
         token)))
 
+(defconst opascal-font-lock-keywords
+  `(("\\_<\\(function\\|pro\\(cedure\\|gram\\)\\)[ \t]+\\([[:alpha:]][[:alnum:]_]*\\)"
+     (1 font-lock-keyword-face) (3 font-lock-function-name-face))
+    ,(concat "\\_<" (regexp-opt (mapcar #'symbol-name opascal-keywords))
+              "\\_>")))
+
 (defconst opascal-font-lock-defaults
-  '(nil ; We have our own fontify routine, so keywords don't apply.
-    t ; Syntactic fontification doesn't apply.
+  '(opascal-font-lock-keywords
+    nil ; Syntactic fontification does apply.
     nil ; Don't care about case since we don't use regexps to find tokens.
     nil ; Syntax alists don't apply.
-    nil ; Syntax begin movement doesn't apply
-    (font-lock-fontify-region-function . opascal-fontify-region)
-    (font-lock-verbose . opascal-fontifying-progress-step))
+    nil ; Syntax begin movement doesn't apply.
+    )
   "OPascal mode font-lock defaults.  Syntactic fontification is ignored.")
 
+(defconst opascal--syntax-propertize
+  (syntax-propertize-rules
+   ;; The syntax-table settings are too coarse and end up treating /* and (/
+   ;; as comment starters.  Fix it here by removing the "2" from the syntax
+   ;; of the second char of such sequences.
+   ("/\\(\\*\\)" (1 ". 3b"))
+   ("(\\(\\/\\)" (1 (prog1 ". 1c" (forward-char -1) nil)))
+   ;; Pascal uses '' and "" rather than \' and \" to escape quotes.
+   ("''\\|\"\"" (0 (if (save-excursion
+                         (nth 3 (syntax-ppss (match-beginning 0))))
+                       (string-to-syntax ".")
+                     ;; In case of 3 or more quotes in a row, only advance
+                     ;; one quote at a time.
+                     (forward-char -1)
+                     nil)))))
+
 (defvar opascal-debug-mode-map
   (let ((kmap (make-sparse-keymap)))
     (dolist (binding '(("n" opascal-debug-goto-next-token)
@@ -1866,14 +1714,7 @@ comment block.  If not in a // comment, just does a normal newline."
                        ("T" opascal-debug-tokenize-buffer)
                        ("W" opascal-debug-tokenize-window)
                        ("g" opascal-debug-goto-point)
-                       ("s" opascal-debug-show-current-string)
-                       ("a" opascal-debug-parse-buffer)
-                       ("w" opascal-debug-parse-window)
-                       ("f" opascal-debug-fontify-window)
-                       ("F" opascal-debug-fontify-buffer)
-                       ("r" opascal-debug-parse-region)
-                       ("c" opascal-debug-unparse-buffer)
-                       ("x" opascal-debug-show-is-stable)))
+                       ("s" opascal-debug-show-current-string)))
       (define-key kmap (car binding) (cadr binding)))
     kmap)
   "Keystrokes for OPascal mode debug commands.")
@@ -1923,14 +1764,8 @@ Customization:
 
 Coloring:
 
- `opascal-comment-face'                (default font-lock-comment-face)
-    Face used to color OPascal comments.
- `opascal-string-face'                 (default font-lock-string-face)
-    Face used to color OPascal strings.
  `opascal-keyword-face'                (default font-lock-keyword-face)
     Face used to color OPascal keywords.
- `opascal-other-face'                  (default nil)
-    Face used to color everything else.
 
 Turning on OPascal mode calls the value of the variable `opascal-mode-hook'
 with no args, if that value is non-nil."
@@ -1940,21 +1775,13 @@ with no args, if that value is non-nil."
   (setq-local comment-indent-function #'opascal-indent-line)
   (setq-local case-fold-search t)
   (setq-local opascal-progress-last-reported-point nil)
-  (setq-local opascal--ignore-changes nil)
   (setq-local font-lock-defaults opascal-font-lock-defaults)
   (setq-local tab-always-indent opascal-tab-always-indents)
+  (setq-local syntax-propertize-function opascal--syntax-propertize)
 
-  ;; FIXME: Use syntax-propertize-function to tokenize, maybe?
-  
-  ;; We need to keep track of changes to the buffer to determine if we need
-  ;; to retokenize changed text.
-  (add-hook 'after-change-functions #'opascal-after-change nil t)
-
-  (opascal-save-excursion
-   (let ((opascal-verbose t))
-     (opascal-progress-start)
-     (opascal-parse-region (point-min) (point-max))
-     (opascal-progress-done))))
+  (setq-local comment-start "// ")
+  (setq-local comment-start-skip "\\(?://\\|(\\*\\|{\\)[ \t]*")
+  (setq-local comment-end-skip "[ \t]*\\(?:\n\\|\\*)\\|}\\)"))
 
 (provide 'opascal)
 ;;; opascal.el ends here
diff --git a/lisp/textmodes/reftex-parse.el b/lisp/textmodes/reftex-parse.el
index a86b10e21cc..6bfc70c5d44 100644
--- a/lisp/textmodes/reftex-parse.el
+++ b/lisp/textmodes/reftex-parse.el
@@ -234,8 +234,18 @@ of master file."
 
                 ((match-end 1)
                  ;; It is a label
-                 (push (reftex-label-info (reftex-match-string 1) file bound)
-                       docstruct))
+                 (when (or (null reftex-label-ignored-macros-and-environments)
+                           ;; \label{} defs should always be honored,
+                           ;; just no keyval style [label=foo] defs.
+                           (string-equal "\label{" (substring (reftex-match-string 0) 0 7))
+                           (not (fboundp 'TeX-current-macro))
+                           (not (fboundp 'LaTeX-current-environment))
+                           (not (or (member (save-match-data (TeX-current-macro))
+                                            reftex-label-ignored-macros-and-environments)
+                                    (member (save-match-data (LaTeX-current-environment))
+                                            reftex-label-ignored-macros-and-environments))))
+                   (push (reftex-label-info (reftex-match-string 1) file bound)
+                         docstruct)))
 
                 ((match-end 3)
                  ;; It is a section
diff --git a/lisp/textmodes/reftex-vars.el b/lisp/textmodes/reftex-vars.el
index 7343d86b06f..ab085a3085a 100644
--- a/lisp/textmodes/reftex-vars.el
+++ b/lisp/textmodes/reftex-vars.el
@@ -885,6 +885,25 @@ effective."
   :group 'reftex-defining-label-environments
   :type '(repeat (regexp :tag "Regular Expression")))
 
+(defcustom reftex-label-ignored-macros-and-environments nil
+  "List of macros and environments to be ignored when searching for labels.
+The purpose is to ignore environments and macros that use keyval
+style label=foo arguments, but the label has a different meaning
+than a \\label{foo}.  Standard \\label{...} definitions are never
+ignored.
+
+E.g., TikZ defines several macros/environments where [label=foo]
+defines the label to be printed at some node or edge, but it's
+not a label used for referencing.
+
+Note that this feature is only supported if you are using AUCTeX
+and the functions `TeX-current-macro' and
+`LaTeX-current-environment' are bound.  Also note that this
+feature might slow down the reftex parsing process for large TeX
+files."
+  :group 'reftex-defining-label-environments
+  :type '(repeat string))
+
 (defcustom reftex-label-illegal-re "[^-a-zA-Z0-9_+=:;,.]"
   "Regexp matching characters not valid in labels."
   :group 'reftex-making-and-inserting-labels
diff --git a/lisp/vc/vc-bzr.el b/lisp/vc/vc-bzr.el
index 06942ad283c..4a08403c93e 100644
--- a/lisp/vc/vc-bzr.el
+++ b/lisp/vc/vc-bzr.el
@@ -710,12 +710,28 @@ If LIMIT is non-nil, show no more than this many entries."
     (apply 'vc-bzr-command "log" buffer 'async files
            (append
             (when shortlog '("--line"))
-            (when start-revision (list (format "-r..%s" start-revision)))
+            ;; The extra complications here when start-revision and limit
+            ;; are set are due to bzr log's --forward argument, which
+            ;; could be enabled via an alias in bazaar.conf.
+            ;; Svn, for example, does not have this problem, because
+            ;; it doesn't have --forward.  Instead, you can use
+            ;; svn --log -r HEAD:0 or -r 0:HEAD as you prefer.
+            ;; Bzr, however, insists in -r X..Y that X come before Y.
+            (if start-revision
+                (list (format
+                       (if (and limit (= limit 1))
+                           ;; This means we don't have to use --no-aliases.
+                           ;; Is -c any different to -r in this case?
+                           "-r%s"
+                         "-r..%s") start-revision)))
             (when limit (list "-l" (format "%s" limit)))
-            ;; This is to remove --forward, if it has been added by an alias.
             ;; There is no sensible way to combine --limit and --forward,
             ;; and it breaks the meaning of START-REVISION as the
             ;; _newest_ revision.  See bug#14168.
+            ;; Eg bzr log --forward -r ..100 --limit 50 prints
+            ;; revisions 1-50 rather than 50-100.  There
+            ;; seems no way in general to get bzr to print revisions
+            ;; 50-100 in --forward order in that case.
             ;; FIXME There may be other alias stuff we want to keep.
             ;; Is there a way to just suppress --forward?
             ;; As of 2013/4 the only caller uses limit = 1, so it does