+2013-04-22 Paul Eggert <eggert@cs.ucla.edu>
+
+ * make-dist: Do not distribute admin/unidata/Makefile.
+ It is generated by 'configure'.
+
+ * build-aux/update-subdirs: Don't leave subdirs.el~ behind.
+ It messes up 'make distclean', and contains no useful information
+ because it's a copy of subdirs.el.
+
2013-04-18 John Marino <gnugcc@marino.st> (tiny change)
* configure.ac: Add DragonFly BSD, mostly same as FreeBSD. (Bug#14068)
;; no-byte-compile: t
;; End:" > subdirs.el~
if cmp "subdirs.el" "subdirs.el~" >/dev/null 2>&1; then
- :; # echo "subdirs.el unchanged";
+ rm subdirs.el~
else
- mv subdirs.el~ subdirs.el
+ mv subdirs.el~ subdirs.el
fi
fi
+2013-04-23 Xue Fuqiao <xfq.free@gmail.com>
+
+ * emacs-lisp-intro.texi (Complications, defvar): Refine the doc
+ about Lisp macros. (http://lists.gnu.org/archive/html/emacs-devel/2013-04/msg00618.html)
+
+2013-04-21 Xue Fuqiao <xfq.free@gmail.com>
+
+ * emacs-lisp-intro.texi (defcustom, defun)
+ (simplified-beginning-of-buffer, defvar, Building Robots, Review)
+ (save-excursion): `defun' and `defcustom' are now macros rather
+ than special forms. (Bug#13853)
+
2013-03-16 Glenn Morris <rgm@gnu.org>
* emacs-lisp-intro.texi: Add some stuff specific to www.gnu.org.
@set edition-number 3.10
@set update-date 28 October 2009
+@c FIXME can this be updated? -- xfq
@ignore
## Summary of shell commands to create various output formats:
How To Write Function Definitions
* Primitive Functions::
-* defun:: The @code{defun} special form.
+* defun:: The @code{defun} macro.
* Install:: Install a function definition.
* Interactive:: Making a function interactive.
* Interactive Options:: Different options for @code{interactive}.
in the section on variables. (@xref{Variables}.)
@cindex Special form
-The second complication occurs because some functions are unusual and do
-not work in the usual manner. Those that don't are called @dfn{special
-forms}. They are used for special jobs, like defining a function, and
-there are not many of them. In the next few chapters, you will be
-introduced to several of the more important special forms.
+The second complication occurs because some functions are unusual and
+do not work in the usual manner. Those that don't are called
+@dfn{special forms}. They are used for special jobs, like defining a
+function, and there are not many of them. In the next few chapters,
+you will be introduced to several of the more important special forms.
+And there are also @dfn{macros}. Macro is a construct defined in
+Lisp, which differs from a function in that it translates a Lisp
+expression into another expression which is to be evaluated instead of
+the original expression. (@xref{Lisp macro}.)
+
The third and final complication is this: if the function that the
Lisp interpreter is looking at is not a special form, and if it is part
function is written in Emacs Lisp or C.
@node defun
-@section The @code{defun} Special Form
+@section The @code{defun} Macro
@findex defun
-@cindex Special form of @code{defun}
@cindex @samp{function definition} defined
In Lisp, a symbol such as @code{mark-whole-buffer} has code attached to
it that tells the computer what to do when the function is called.
This code is called the @dfn{function definition} and is created by
evaluating a Lisp expression that starts with the symbol @code{defun}
-(which is an abbreviation for @emph{define function}). Because
-@code{defun} does not evaluate its arguments in the usual way, it is
-called a @dfn{special form}.
+(which is an abbreviation for @emph{define function}).
In subsequent sections, we will look at function definitions from the
Emacs source code, such as @code{mark-whole-buffer}. In this section,
@findex point
@findex mark
-The @code{save-excursion} function is the fourth and final special form
+The @code{save-excursion} function is the third and final special form
that we will discuss in this chapter.
In Emacs Lisp programs used for editing, the @code{save-excursion}
@node Review
@section Review
-In the last few chapters we have introduced a fair number of functions
-and special forms. Here they are described in brief, along with a few
-similar functions that have not been mentioned yet.
+In the last few chapters we have introduced a macro and a fair number
+of functions and special forms. Here they are described in brief,
+along with a few similar functions that have not been mentioned yet.
@table @code
@item eval-last-sexp
current buffer. This command is normally bound to @kbd{C-x C-e}.
@item defun
-Define function. This special form has up to five parts: the name,
-a template for the arguments that will be passed to the function,
-documentation, an optional interactive declaration, and the body of the
-definition.
+Define function. This macro has up to five parts: the name, a
+template for the arguments that will be passed to the function,
+documentation, an optional interactive declaration, and the body of
+the definition.
@need 1250
For example, in an early version of Emacs, the function definition was
@end smallexample
Like all function definitions, this definition has five parts following
-the special form @code{defun}:
+the macro @code{defun}:
@enumerate
@item
not override the existing value. Second, @code{defvar} has a
documentation string.
-(Another special form, @code{defcustom}, is designed for variables
+(There is a related macro, @code{defcustom}, designed for variables
that people customize. It has more features than @code{defvar}.
(@xref{defcustom, , Setting Variables with @code{defcustom}}.)
A function definition provides the blueprints for a robot. When you
install a function definition, that is, when you evaluate a
-@code{defun} special form, you install the necessary equipment to
-build robots. It is as if you were in a factory, setting up an
-assembly line. Robots with the same name are built according to the
-same blueprints. So they have, as it were, the same `model number',
-but a different `serial number'.
+@code{defun} macro, you install the necessary equipment to build
+robots. It is as if you were in a factory, setting up an assembly
+line. Robots with the same name are built according to the same
+blueprints. So they have, as it were, the same `model number', but a
+different `serial number'.
We often say that a recursive function `calls itself'. What we mean
is that the instructions in a recursive function cause the Lisp
file. Indeed, you can write any Lisp expression in your @file{.emacs}
file.)
-The @code{customize} feature depends on the @code{defcustom} special
-form. Although you can use @code{defvar} or @code{setq} for variables
-that users set, the @code{defcustom} special form is designed for the
-job.
+The @code{customize} feature depends on the @code{defcustom} macro.
+Although you can use @code{defvar} or @code{setq} for variables that
+users set, the @code{defcustom} macro is designed for the job.
You can use your knowledge of @code{defvar} for writing the
first three arguments for @code{defcustom}. The first argument to
+2013-04-21 Xue Fuqiao <xfq.free@gmail.com>
+
+ * internals.texi (Writing Emacs Primitives): Remove unnecessary
+ references to the sources. (Bug#13800)
+
+ * searching.texi (Regexp Backslash): Doc fix for backslash
+ constructs in regular expressions.
+
2013-04-15 Christopher Schmidt <christopher@ch.ristopher.com>
* tips.texi (Coding Conventions): Mention separation of package
macros. If @var{max} is a number, it must be more than @var{min} but
less than 8.
+@cindex interactive specification in primitives
@item interactive
-This is an interactive specification, a string such as might be used as
-the argument of @code{interactive} in a Lisp function. In the case of
-@code{or}, it is 0 (a null pointer), indicating that @code{or} cannot be
-called interactively. A value of @code{""} indicates a function that
-should receive no arguments when called interactively. If the value
-begins with a @samp{(}, the string is evaluated as a Lisp form.
-For examples of the last two forms, see @code{widen} and
-@code{narrow-to-region} in @file{editfns.c}.
+This is an interactive specification, a string such as might be used
+as the argument of @code{interactive} in a Lisp function. In the case
+of @code{or}, it is 0 (a null pointer), indicating that @code{or}
+cannot be called interactively. A value of @code{""} indicates a function that should receive no
+arguments when called interactively. For example:
+
+@smallexample
+@group
+DEFUN ("baz", Fbaz, Sbaz, 0, 0, "",
+ doc: /* @dots{} */)
+@end group
+@end smallexample
+
+If the value begins with a @samp{"(}, the string is evaluated as a
+Lisp form. For example:
+
+@smallexample
+@group
+DEFUN ("foo", Ffoo, Sfoo, 0, UNEVALLED, "(list
+ (read-char-by-name \"Insert character (Unicode name or hex): \")\
+ (prefix-numeric-value current-prefix-arg)\
+ t))",
+ doc: /* @dots{} /*)
+@end group
+@end smallexample
@item doc
This is the documentation string. It uses C comment syntax rather
For the most part, @samp{\} followed by any character matches only
that character. However, there are several exceptions: certain
-two-character sequences starting with @samp{\} that have special
-meanings. (The character after the @samp{\} in such a sequence is
-always ordinary when used on its own.) Here is a table of the special
-@samp{\} constructs.
+sequences starting with @samp{\} that have special meanings. Here is
+a table of the special @samp{\} constructs.
@table @samp
@item \|
+2013-04-20 Petr Hracek <phracek@redhat.com> (tiny change)
+
+ * emacs.1: Add some more command-line options. (Bug#14165)
+
2012-12-02 Kevin Ryde <user42@zip.com.au>
* etags.1: Mention effect of --declarations in Lisp.
and
.IR column .
.TP
+.BI \-\-chdir " directory"
+Change to
+.IR directory .
+.TP
.BR \-q ", " \-\-no\-init\-file
Do not load an init file.
.TP
+.BR \-nl ", " \-\-no\-shared\-memory
+Do not use shared memory.
+.TP
.B \-\-no\-site\-file
Do not load the site-wide startup file.
.TP
+.BR \-nsl ", " \-\-no\-site\-lisp
+Do not add site-lisp directories to load-path.
+.TP
.B \-\-no\-desktop
Do not load a saved desktop.
.TP
.BR \-nbc ", " \-\-no\-blinking\-cursor
Disable blinking cursor.
.TP
+.BI \-\-parent-id " xid"
+Set parent window.
+.TP
.BR \-nw ", " \-\-no\-window\-system
Tell
.I Emacs
using the scroll bar (i.e. dragging the thumb down even when the end
of the buffer is visible).
+** In compiled Lisp files, the header no longer includes a timestamp.
+
\f
* Editing Changes in Emacs 24.4
+2013-04-23 Tassilo Horn <tsdh@gnu.org>
+
+ * textmodes/reftex.el (reftex-compile-variables): Add autoload
+ cookie.
+
+ * textmodes/reftex-vars.el (reftex-label-regexps): Call
+ `reftex-compile-variables' after changes to this variable.
+
+2013-04-23 Stefan Monnier <monnier@iro.umontreal.ca>
+
+ * jit-lock.el: Fix signals in jit-lock-force-redisplay.
+ Use lexical-binding.
+ (jit-lock-force-redisplay): Use markers, check buffer's continued
+ existence and beware narrowed buffers.
+ (jit-lock-fontify-now): Adjust call accordingly.
+
+2013-04-22 Stefan Monnier <monnier@iro.umontreal.ca>
+
+ * minibuffer.el (minibuffer-completion-contents): Fix obsolescence info
+ to avoid misleading the user.
+
+2013-04-22 Leo Liu <sdl.web@gmail.com>
+
+ * info-look.el: Prefer latex2e.info. (Bug#14240)
+
+2013-04-22 Michael Albinus <michael.albinus@gmx.de>
+
+ Fix pack/unpack coding. Reported by David Smith <davidsmith@acm.org>.
+
+ * net/tramp-compat.el (tramp-compat-call-process): Move function ...
+ * net/tramp.el (tramp-call-process): ... here
+ (tramp-set-completion-function, tramp-parse-putty):
+ * net/tramp-adb.el (tramp-adb-execute-adb-command):
+ * net/tramp-gvfs.el (tramp-gvfs-send-command):
+ * net/tramp-sh.el (tramp-sh-handle-set-file-times)
+ (tramp-set-file-uid-gid, tramp-sh-handle-write-region)
+ (tramp-call-local-coding-command): Use `tramp-call-process'
+ instead of `tramp-compat-call-process'.
+
+ * net/tramp-sh.el (tramp-perl-pack, tramp-perl-unpack): New defconst.
+ (tramp-local-coding-commands, tramp-remote-coding-commands): Use them.
+ (tramp-sh-handle-file-local-copy, tramp-sh-handle-write-region):
+ (tramp-find-inline-compress):Improve traces.
+ (tramp-maybe-send-script): Check for Perl binary.
+ (tramp-get-inline-coding): Do not redirect STDOUT for local decoding.
+
+2013-04-22 Daiki Ueno <ueno@gnu.org>
+
+ * epg.el (epg-context-pinentry-mode): New function.
+ (epg-context-set-pinentry-mode): New function.
+ (epg--start): Pass --pinentry-mode option to gpg command.
+
+2013-04-21 Xue Fuqiao <xfq.free@gmail.com>
+
+ * comint.el: (comint-dynamic-complete-functions, comint-mode-map):
+ `comint-dynamic-complete' is obsolete since 24.1, replaced by
+ `completion-at-point'. (Bug#13774)
+
+ * startup.el (normal-no-mouse-startup-screen): Bug fix, the
+ default key binding for `describe-distribution' has been moved to
+ `C-h C-o'. (Bug#13970)
+
+2013-04-21 Glenn Morris <rgm@gnu.org>
+
+ * vc/vc.el (vc-print-log-setup-buttons, vc-print-log-internal):
+ Add doc strings.
+ (vc-print-log): Clarify interactive prompt.
+
+2013-04-20 Glenn Morris <rgm@gnu.org>
+
+ * emacs-lisp/bytecomp.el (byte-compile-insert-header):
+ No longer include timestamp etc information.
+
+2013-04-20 Roland Winkler <winkler@gnu.org>
+
+ * faces.el (read-face-name): Bug fix, return just one face if arg
+ multiple is nil. (Bug#14209)
+
+2013-04-20 Stefan Monnier <monnier@iro.umontreal.ca>
+
+ * emacs-lisp/nadvice.el (advice--where-alist): Add :override.
+ (remove-function): Autoload.
+
+ * comint.el (comint-redirect-original-filter-function): Remove.
+ (comint-redirect-cleanup, comint-redirect-send-command-to-process):
+ * vc/vc-cvs.el (vc-cvs-annotate-process-filter,vc-cvs-annotate-command):
+ * progmodes/octave-inf.el (inferior-octave-send-list-and-digest):
+ * progmodes/prolog.el (prolog-consult-compile):
+ * progmodes/gdb-mi.el (gdb, gdb--check-interpreter):
+ Use add/remove-function instead.
+ * progmodes/gud.el (gud-tooltip-original-filter): Remove.
+ (gud-tooltip-process-output, gud-tooltip-tips):
+ Use add/remove-function instead.
+ * progmodes/xscheme.el (xscheme-previous-process-state): Remove.
+ (scheme-interaction-mode, exit-scheme-interaction-mode):
+ Use add/remove-function instead.
+
+ * vc/vc-dispatcher.el: Use lexical-binding.
+ (vc--process-sentinel): Rename from vc-process-sentinel.
+ Change last arg to be the code to run. Don't use vc-previous-sentinel
+ and vc-sentinel-commands any more.
+ (vc-exec-after): Allow code to be a function. Use add/remove-function.
+ (compilation-error-regexp-alist, view-old-buffer-read-only): Declare.
+
2013-04-19 Masatake YAMATO <yamato@redhat.com>
- * progmodes/sh-script.el (sh-imenu-generic-expression): Handle
- function names with a single character. (Bug#11182)
+ * progmodes/sh-script.el (sh-imenu-generic-expression):
+ Handle function names with a single character. (Bug#14111)
2013-04-19 Dima Kogan <dima@secretsauce.net> (tiny change)
If the value is `input', then the expansion is seen on input.
If the value is `history', then the expansion is only when inserting
into the buffer's input ring. See also `comint-magic-space' and
-`comint-dynamic-complete'.
+`completion-at-point'.
This variable is buffer-local."
:type '(choice (const :tag "off" nil)
'(comint-c-a-p-replace-by-expanded-history comint-filename-completion)
"List of functions called to perform completion.
Works like `completion-at-point-functions'.
-See also `comint-dynamic-complete'.
+See also `completion-at-point'.
This is a good thing to set in mode hooks.")
and addition is controlled by the variable `comint-input-ignoredups'.
Commands with no default key bindings include `send-invisible',
-`comint-dynamic-complete', `comint-dynamic-list-filename-completions', and
+`completion-at-point', `comint-dynamic-list-filename-completions', and
`comint-magic-space'.
Input to, and output from, the subprocess can cause the window to scroll to
;; Useful completion functions, courtesy of the Ergo group.
;; Six commands:
-;; comint-dynamic-complete Complete or expand command, filename,
+;; completion-at-point Complete or expand command, filename,
;; history at point.
;; comint-dynamic-complete-filename Complete filename at point.
;; comint-dynamic-list-filename-completions List completions in help buffer.
;; These are not installed in the comint-mode keymap. But they are
;; available for people who want them. Shell-mode installs them:
-;; (define-key shell-mode-map "\t" 'comint-dynamic-complete)
+;; (define-key shell-mode-map "\t" 'completion-at-point)
;; (define-key shell-mode-map "\M-?"
;; 'comint-dynamic-list-filename-completions)))
;;
string, and that there ought to be at least one copy of your prompt string
in the process buffer already.")
-(defvar comint-redirect-original-filter-function nil
- "The process filter that was in place when redirection is started.
-When redirection is completed, the process filter is restored to
-this value.")
-
(defvar comint-redirect-subvert-readonly nil
"Non-nil means `comint-redirect' can insert into read-only buffers.
This works by binding `inhibit-read-only' around the insertion.
;; Release the last redirected string
(setq comint-redirect-previous-input-string nil)
;; Restore the process filter
- (set-process-filter (get-buffer-process (current-buffer))
- comint-redirect-original-filter-function)
+ (remove-function (process-filter (get-buffer-process (current-buffer)))
+ #'comint-redirect-filter)
;; Restore the mode line
(setq mode-line-process comint-redirect-original-mode-line-process)
;; Set the completed flag
comint-prompt-regexp ; Finished Regexp
echo) ; Echo input
- ;; Set the filter
- (setq comint-redirect-original-filter-function ; Save the old filter
- (process-filter proc))
- (set-process-filter proc 'comint-redirect-filter)
+ ;; Set the filter.
+ (add-function :override (process-filter proc) #'comint-redirect-filter)
;; Send the command
(process-send-string (current-buffer) (concat command "\n"))
;; (setq shell-mode-map (copy-keymap comint-mode-map))
;; (define-key shell-mode-map "\C-c\C-f" 'shell-forward-command)
;; (define-key shell-mode-map "\C-c\C-b" 'shell-backward-command)
-;; (define-key shell-mode-map "\t" 'comint-dynamic-complete)
+;; (define-key shell-mode-map "\t" 'completion-at-point)
;; (define-key shell-mode-map "\M-?"
;; 'comint-dynamic-list-filename-completions)))
;;
;; >4 byte x version %d
(insert
";ELC" 23 "\000\000\000\n"
- ";;; Compiled by "
- (or (and (boundp 'user-mail-address) user-mail-address)
- (concat (user-login-name) "@" (system-name)))
- " on " (current-time-string) "\n"
- ";;; from file " filename "\n"
+ ";;; Compiled\n"
";;; in Emacs version " emacs-version "\n"
";;; with"
(cond
'((:around "\300\301\302\003#\207" 5)
(:before "\300\301\002\"\210\300\302\002\"\207" 4)
(:after "\300\302\002\"\300\301\003\"\210\207" 5)
+ (:override "\300\301\ 2\"\207" 4)
(:after-until "\300\302\002\"\206\013\000\300\301\002\"\207" 4)
(:after-while "\300\302\002\"\205\013\000\300\301\002\"\207" 4)
(:before-until "\300\301\002\"\206\013\000\300\302\002\"\207" 4)
`:before' (lambda (&rest r) (apply FUNCTION r) (apply OLDFUN r))
`:after' (lambda (&rest r) (prog1 (apply OLDFUN r) (apply FUNCTION r)))
`:around' (lambda (&rest r) (apply FUNCTION OLDFUN r))
+`:override' (lambda (&rest r) (apply FUNCTION r))
`:before-while' (lambda (&rest r) (and (apply FUNCTION r) (apply OLDFUN r)))
`:before-until' (lambda (&rest r) (or (apply FUNCTION r) (apply OLDFUN r)))
`:after-while' (lambda (&rest r) (and (apply OLDFUN r) (apply FUNCTION r)))
(setf (gv-deref ref)
(advice--make where function (gv-deref ref) props))))
+;;;###autoload
(defmacro remove-function (place function)
"Remove the FUNCTION piece of advice from PLACE.
If FUNCTION was not added to PLACE, do nothing.
cipher-algorithm digest-algorithm compress-algorithm
(list #'epg-passphrase-callback-function)
nil
- nil nil nil nil nil nil)))
+ nil nil nil nil nil nil nil)))
(defun epg-context-protocol (context)
"Return the protocol used within CONTEXT."
(signal 'wrong-type-argument (list 'epg-context-p context)))
(aref (cdr context) 14))
+(defun epg-context-pinentry-mode (context)
+ "Return the mode of pinentry invocation."
+ (unless (eq (car-safe context) 'epg-context)
+ (signal 'wrong-type-argument (list 'epg-context-p context)))
+ (aref (cdr context) 15))
+
(defun epg-context-set-protocol (context protocol)
"Set the protocol used within CONTEXT."
(unless (eq (car-safe context) 'epg-context)
(signal 'wrong-type-argument (list 'epg-context-p context)))
(aset (cdr context) 14 operation))
+(defun epg-context-set-pinentry-mode (context mode)
+ "Set the mode of pinentry invocation."
+ (unless (eq (car-safe context) 'epg-context)
+ (signal 'wrong-type-argument (list 'epg-context-p context)))
+ (unless (memq mode '(nil ask cancel error loopback))
+ (signal 'epg-error (list "Unknown pinentry mode" mode)))
+ (aset (cdr context) 15 mode))
+
(defun epg-make-signature (status &optional key-id)
"Return a signature object."
(cons 'epg-signature (vector status key-id nil nil nil nil nil nil nil nil
(if (epg-context-textmode context) '("--textmode"))
(if (epg-context-output-file context)
(list "--output" (epg-context-output-file context)))
+ (if (epg-context-pinentry-mode context)
+ (list "--pinentry-mode"
+ (symbol-name (epg-context-pinentry-mode
+ context))))
args))
(coding-system-for-write 'binary)
(coding-system-for-read 'binary)
;; (for example, because DEFAULT was "all faces")
(if (facep face) (push (intern face) faces)))
;; Return either a list of faces or just one face.
- (if multiple
- (nreverse faces)
- (last faces))))
+ (setq faces (nreverse faces))
+ (if multiple faces (car faces))))
;; Not defined without X, but behind window-system test.
(defvar x-bitmap-file-path)
(info-lookup-maybe-add-help
:mode 'latex-mode
:regexp "\\\\\\([a-zA-Z]+\\|[^a-zA-Z]\\)"
- :doc-spec '(("(latex)Command Index" nil
- "`" "\\({[^}]*}\\)?'")))
+ :doc-spec `((,(if (Info-find-file "latex2e" t)
+ ;; From http://home.gna.org/latexrefman
+ "(latex2e)Command Index"
+ "(latex)Command Index")
+ nil "`" "\\({[^}]*}\\)?'")))
(info-lookup-maybe-add-help
:mode 'emacs-lisp-mode
-;;; jit-lock.el --- just-in-time fontification
+;;; jit-lock.el --- just-in-time fontification -*- lexical-binding: t -*-
;; Copyright (C) 1998, 2000-2013 Free Software Foundation, Inc.
;; eagerly extend the refontified region with
;; jit-lock-after-change-extend-region-functions.
(when (< start orig-start)
- (run-with-timer 0 nil 'jit-lock-force-redisplay
- (current-buffer) start orig-start))
+ (run-with-timer 0 nil #'jit-lock-force-redisplay
+ (copy-marker start) (copy-marker orig-start)))
;; Find the start of the next chunk, if any.
(setq start (text-property-any next end 'fontified nil))))))))
-(defun jit-lock-force-redisplay (buf start end)
+(defun jit-lock-force-redisplay (start end)
"Force the display engine to re-render buffer BUF from START to END."
- (with-current-buffer buf
- (with-buffer-prepared-for-jit-lock
- ;; Don't cause refontification (it's already been done), but just do
- ;; some random buffer change, so as to force redisplay.
- (put-text-property start end 'fontified t))))
-
-
+ (when (marker-buffer start)
+ (with-current-buffer (marker-buffer start)
+ (with-buffer-prepared-for-jit-lock
+ (when (> end (point-max))
+ (setq end (point-max) start (min start end)))
+ (when (< start (point-min))
+ (setq start (point-min) end (max start end)))
+ ;; Don't cause refontification (it's already been done), but just do
+ ;; some random buffer change, so as to force redisplay.
+ (put-text-property start end 'fontified t)))))
\f
;;; Stealth fontification.
(defun minibuffer-completion-contents ()
"Return the user input in a minibuffer before point as a string.
-That used to be what completion commands operate on."
- (declare (obsolete minibuffer-contents "24.4"))
+In Emacs-22, that was what completion commands operated on."
+ (declare (obsolete nil "24.4"))
(buffer-substring (field-beginning) (point)))
(defun delete-minibuffer-contents ()
(setq args (append (list "-s" (tramp-file-name-host vec)) args)))
(with-temp-buffer
(prog1
- (unless (zerop (apply 'call-process tramp-adb-program nil t nil args))
+ (unless
+ (zerop (apply 'tramp-call-process tramp-adb-program nil t nil args))
(buffer-string))
- (tramp-message
- vec 6 "%s %s\n%s"
- tramp-adb-program (mapconcat 'identity args " ") (buffer-string)))))
+ (tramp-message vec 6 "%s" (buffer-string)))))
(defun tramp-adb-find-test-command (vec)
"Checks, whether the ash has a builtin \"test\" command.
element is not omitted."
(delete "" (split-string string pattern)))
-(defun tramp-compat-call-process
- (program &optional infile destination display &rest args)
- "Calls `call-process' on the local host.
-This is needed because for some Emacs flavors Tramp has
-defadvised `call-process' to behave like `process-file'. The
-Lisp error raised when PROGRAM is nil is trapped also, returning 1."
- (let ((default-directory
- (if (file-remote-p default-directory)
- (tramp-compat-temporary-file-directory)
- default-directory)))
- (if (executable-find program)
- (apply 'call-process program infile destination display args)
- 1)))
-
(defun tramp-compat-process-running-p (process-name)
"Returns `t' if system process PROCESS-NAME is running for `user-login-name'."
(when (stringp process-name)
(tramp-gvfs-maybe-open-connection vec)
(erase-buffer)
(tramp-message vec 6 "%s %s" command (mapconcat 'identity args " "))
- (setq result (apply 'tramp-compat-call-process command nil t nil args))
+ (setq result (apply 'tramp-call-process command nil t nil args))
(tramp-message vec 6 "\n%s" (buffer-string))
(zerop result))))
Escape sequence %s is replaced with name of Perl binary.
This string is passed to `format', so percent characters need to be doubled.")
+(defconst tramp-perl-pack
+ "%s -e 'binmode STDIN; binmode STDOUT; print pack(q{u*}, join q{}, <>)'"
+ "Perl program to use for encoding a file.
+Escape sequence %s is replaced with name of Perl binary.")
+
+(defconst tramp-perl-unpack
+ "%s -e 'binmode STDIN; binmode STDOUT; print unpack(q{u*}, join q{}, <>)'"
+ "Perl program to use for decoding a file.
+Escape sequence %s is replaced with name of Perl binary.")
+
(defconst tramp-vc-registered-read-file-names
"echo \"(\"
while read file; do
;; without `set-file-times', this function is an alias for this.
;; We are local, so we don't need the UTC settings.
(zerop
- (tramp-compat-call-process
+ (tramp-call-process
"touch" nil nil nil "-t"
(format-time-string "%Y%m%d%H%M.%S" time)
(tramp-shell-quote-argument filename)))))
;; `set-file-uid-gid'. On W32 "chown" might not work.
(let ((uid (or (and (natnump uid) uid) (tramp-get-local-uid 'integer)))
(gid (or (and (natnump gid) gid) (tramp-get-local-gid 'integer))))
- (tramp-compat-call-process
+ (tramp-call-process
"chown" nil nil nil
(format "%d:%d" uid gid) (tramp-shell-quote-argument filename))))))
(rem-enc
(save-excursion
(with-tramp-progress-reporter
- v 3 (format "Encoding remote file %s" filename)
+ v 3
+ (format "Encoding remote file `%s' with `%s'" filename rem-enc)
(tramp-barf-unless-okay
v (format rem-enc (tramp-shell-quote-argument localname))
"Encoding remote file failed"))
- (if (functionp loc-dec)
- ;; If local decoding is a function, we call it. We
- ;; must disable multibyte, because
- ;; `uudecode-decode-region' doesn't handle it
- ;; correctly.
- (with-temp-buffer
- (set-buffer-multibyte nil)
- (insert-buffer-substring (tramp-get-buffer v))
- (with-tramp-progress-reporter
- v 3 (format "Decoding remote file %s with function %s"
- filename loc-dec)
+ (with-tramp-progress-reporter
+ v 3 (format "Decoding local file `%s' with `%s'"
+ tmpfile loc-dec)
+ (if (functionp loc-dec)
+ ;; If local decoding is a function, we call it.
+ ;; We must disable multibyte, because
+ ;; `uudecode-decode-region' doesn't handle it
+ ;; correctly.
+ (with-temp-buffer
+ (set-buffer-multibyte nil)
+ (insert-buffer-substring (tramp-get-buffer v))
(funcall loc-dec (point-min) (point-max))
;; Unset `file-name-handler-alist'. Otherwise,
;; epa-file gets confused.
(let (file-name-handler-alist
(coding-system-for-write 'binary))
- (write-region (point-min) (point-max) tmpfile))))
-
- ;; If tramp-decoding-function is not defined for this
- ;; method, we invoke tramp-decoding-command instead.
- (let ((tmpfile2 (tramp-compat-make-temp-file filename)))
- ;; Unset `file-name-handler-alist'. Otherwise,
- ;; epa-file gets confused.
- (let (file-name-handler-alist
- (coding-system-for-write 'binary))
- (write-region (point-min) (point-max) tmpfile2))
- (with-tramp-progress-reporter
- v 3 (format "Decoding remote file %s with command %s"
- filename loc-dec)
+ (write-region (point-min) (point-max) tmpfile)))
+
+ ;; If tramp-decoding-function is not defined for this
+ ;; method, we invoke tramp-decoding-command instead.
+ (let ((tmpfile2 (tramp-compat-make-temp-file filename)))
+ ;; Unset `file-name-handler-alist'. Otherwise,
+ ;; epa-file gets confused.
+ (let (file-name-handler-alist
+ (coding-system-for-write 'binary))
+ (with-current-buffer (tramp-get-buffer v)
+ (write-region (point-min) (point-max) tmpfile2)))
(unwind-protect
(tramp-call-local-coding-command
loc-dec tmpfile2 tmpfile)
(with-temp-buffer
(set-buffer-multibyte nil)
;; Use encoding function or command.
- (if (functionp loc-enc)
- (with-tramp-progress-reporter
- v 3 (format "Encoding region using function `%s'"
- loc-enc)
- (let ((coding-system-for-read 'binary))
- (insert-file-contents-literally tmpfile))
- ;; The following `let' is a workaround for the
- ;; base64.el that comes with pgnus-0.84. If
- ;; both of the following conditions are
+ (with-tramp-progress-reporter
+ v 3 (format "Encoding local file `%s' using `%s'"
+ tmpfile loc-enc)
+ (if (functionp loc-enc)
+ ;; The following `let' is a workaround for
+ ;; the base64.el that comes with pgnus-0.84.
+ ;; If both of the following conditions are
;; satisfied, it tries to write to a local
;; file in default-directory, but at this
;; point, default-directory is remote.
;; (`call-process-region' can't write to
;; remote files, it seems.) The file in
;; question is a tmp file anyway.
- (let ((default-directory
+ (let ((coding-system-for-read 'binary)
+ (default-directory
(tramp-compat-temporary-file-directory)))
- (funcall loc-enc (point-min) (point-max))))
+ (insert-file-contents-literally tmpfile)
+ (funcall loc-enc (point-min) (point-max)))
- (with-tramp-progress-reporter
- v 3 (format "Encoding region using command `%s'"
- loc-enc)
(unless (zerop (tramp-call-local-coding-command
loc-enc tmpfile t))
(tramp-error
;; writes to remote file. Because this happens on
;; the remote host, we cannot use the function.
(with-tramp-progress-reporter
- v 3
- (format "Decoding region into remote file %s" filename)
+ v 3 (format "Decoding remote file `%s' using `%s'"
+ filename rem-dec)
(goto-char (point-max))
(unless (bolp) (newline))
(tramp-send-command
(erase-buffer)
(and
;; cksum runs locally, if possible.
- (zerop (tramp-compat-call-process "cksum" tmpfile t))
+ (zerop (tramp-call-process "cksum" tmpfile t))
;; cksum runs remotely.
(tramp-send-command-and-check
v
(unless (member name scripts)
(with-tramp-progress-reporter vec 5 (format "Sending script `%s'" name)
;; The script could contain a call of Perl. This is masked with `%s'.
+ (when (and (string-match "%s" script)
+ (not (tramp-get-remote-perl vec)))
+ (tramp-error vec 'file-error "No Perl available on remote host"))
(tramp-barf-unless-okay
vec
(format "%s () {\n%s\n}" name
(tramp-send-command
vec (format "unset %s" (mapconcat 'identity unset " ")) t))))
-;; CCC: We should either implement a Perl version of base64 encoding
-;; and decoding. Then we just use that in the last item. The other
-;; alternative is to use the Perl version of UU encoding. But then
-;; we need a Lisp version of uuencode.
-;;
;; Old text from documentation of tramp-methods:
;; Using a uuencode/uudecode inline method is discouraged, please use one
;; of the base64 methods instead since base64 encoding is much more
(autoload 'uudecode-decode-region "uudecode")
(defconst tramp-local-coding-commands
- '((b64 base64-encode-region base64-decode-region)
+ `((b64 base64-encode-region base64-decode-region)
(uu tramp-uuencode-region uudecode-decode-region)
- (pack
- "perl -e 'binmode STDIN; binmode STDOUT; print pack(q{u*}, join q{}, <>)'"
- "perl -e 'binmode STDIN; binmode STDOUT; print unpack(q{u*}, join q{}, <>)'"))
+ (pack ,(format tramp-perl-pack "perl") ,(format tramp-perl-unpack "perl")))
"List of local coding commands for inline transfer.
Each item is a list that looks like this:
(uu "uuencode xxx" "uudecode -o -")
(uu "uuencode xxx" "uudecode -p")
(uu "uuencode xxx" tramp-uudecode)
- (pack
- "perl -e 'binmode STDIN; binmode STDOUT; print pack(q{u*}, join q{}, <>)'"
- "perl -e 'binmode STDIN; binmode STDOUT; print unpack(q{u*}, join q{}, <>)'"))
+ (pack tramp-perl-pack tramp-perl-unpack))
"List of remote coding commands for inline transfer.
Each item is a list that looks like this:
OUTPUT can be a string (which specifies a filename), or t (which
means standard output and thus the current buffer), or nil (which
means discard it)."
- (tramp-compat-call-process
+ (tramp-call-process
tramp-encoding-shell
(when (and input (not (string-match "%s" cmd))) input)
(if (eq output t) t nil)
tramp-encoding-command-switch
(concat
(if (string-match "%s" cmd) (format cmd input) cmd)
- (if (stringp output) (concat "> " output) ""))))
+ (if (stringp output) (concat " >" output) ""))))
(defconst tramp-inline-compress-commands
'(("gzip" "gzip -d")
decompress (nth 1 item))
(tramp-message
vec 5
- "Checking local compress command `%s', `%s' for sanity"
+ "Checking local compress commands `%s', `%s' for sanity"
compress decompress)
(unless
(zerop
(throw 'next nil))
(tramp-message
vec 5
- "Checking remote compress command `%s', `%s' for sanity"
+ "Checking remote compress commands `%s', `%s' for sanity"
compress decompress)
(unless (tramp-send-command-and-check
vec (format "echo %s | %s | %s" magic compress decompress) t)
;; Windows shells need the program file name after
;; the pipe symbol be quoted if they use forward
;; slashes as directory separators.
- (if (and (string-match "local" prop)
- (memq system-type '(windows-nt)))
- "(%s | \"%s\" >%%s)"
- "(%s | %s >%%s)")
+ (cond
+ ((and (string-match "local" prop)
+ (memq system-type '(windows-nt)))
+ "(%s | \"%s\")")
+ ((string-match "local" prop) "(%s | %s)")
+ (t "(%s | %s >%%s)"))
coding compress))
(compress
(format
"(%s <%%s | %s)")
compress coding))
((string-match "decoding" prop)
- (format "%s >%%s" coding))
+ (cond
+ ((string-match "local" prop) (format "%s" coding))
+ (t (format "%s >%%s" coding))))
(t
(format "%s <%%s" coding)))))))
;; Windows registry.
(and (memq system-type '(cygwin windows-nt))
(zerop
- (tramp-compat-call-process
+ (tramp-call-process
"reg" nil nil nil "query" (nth 1 (car v)))))
;; Configuration file.
(file-exists-p (nth 1 (car v)))))
User is always nil."
(if (memq system-type '(windows-nt))
(with-temp-buffer
- (when (zerop (tramp-compat-call-process
+ (when (zerop (tramp-call-process
"reg" nil t nil "query" registry-or-dirname))
(goto-char (point-min))
(loop while (not (eobp)) collect
;;; Compatibility functions section:
+(defun tramp-call-process
+ (program &optional infile destination display &rest args)
+ "Calls `call-process' on the local host.
+This is needed because for some Emacs flavors Tramp has
+defadvised `call-process' to behave like `process-file'. The
+Lisp error raised when PROGRAM is nil is trapped also, returning 1.
+Furthermore, traces are written with verbosity of 6."
+ (let ((default-directory
+ (if (file-remote-p default-directory)
+ (tramp-compat-temporary-file-directory)
+ default-directory)))
+ (tramp-message
+ (vector tramp-current-method tramp-current-user tramp-current-host nil nil)
+ 6 "%s %s %s" program infile args)
+ (if (executable-find program)
+ (apply 'call-process program infile destination display args)
+ 1)))
+
;;;###tramp-autoload
(defun tramp-read-passwd (proc &optional prompt)
"Read a password from user (compat function).
(concat (gdb-gud-context-command ,cmd1 ,noall) " " ,cmd2)
,(when (not noarg) 'arg)))
-(defun gdb--check-interpreter (proc string)
+(defun gdb--check-interpreter (filter proc string)
(unless (zerop (length string))
- (let ((filter (process-get proc 'gud-normal-filter)))
- (set-process-filter proc filter)
- (unless (memq (aref string 0) '(?^ ?~ ?@ ?& ?* ?=))
- ;; Apparently we're not running with -i=mi.
- (let ((msg "Error: you did not specify -i=mi on GDB's command line!"))
- (message msg)
- (setq string (concat (propertize msg 'font-lock-face 'error)
- "\n" string)))
- ;; Use the old gud-gbd filter, not because it works, but because it
- ;; will properly display GDB's answers rather than hanging waiting for
- ;; answers that aren't coming.
- (set (make-local-variable 'gud-marker-filter) #'gud-gdb-marker-filter))
- (funcall filter proc string))))
+ (remove-function (process-filter proc) #'gdb--check-interpreter)
+ (unless (memq (aref string 0) '(?^ ?~ ?@ ?& ?* ?=))
+ ;; Apparently we're not running with -i=mi.
+ (let ((msg "Error: you did not specify -i=mi on GDB's command line!"))
+ (message msg)
+ (setq string (concat (propertize msg 'font-lock-face 'error)
+ "\n" string)))
+ ;; Use the old gud-gbd filter, not because it works, but because it
+ ;; will properly display GDB's answers rather than hanging waiting for
+ ;; answers that aren't coming.
+ (set (make-local-variable 'gud-marker-filter) #'gud-gdb-marker-filter))
+ (funcall filter proc string)))
(defvar gdb-control-level 0)
;; Setup a temporary process filter to warn when GDB was not started
;; with -i=mi.
(let ((proc (get-buffer-process gud-comint-buffer)))
- (process-put proc 'gud-normal-filter (process-filter proc))
- (set-process-filter proc #'gdb--check-interpreter))
+ (add-function :around (process-filter proc) #'gdb--check-interpreter))
(set (make-local-variable 'gud-minor-mode) 'gdbmi)
(set (make-local-variable 'gdb-control-level) 0)
;;; Tips for `gud'
-(defvar gud-tooltip-original-filter nil
- "Process filter to restore after GUD output has been received.")
-
(defvar gud-tooltip-dereference nil
"Non-nil means print expressions with a `*' in front of them.
For C this would dereference a pointer expression.")
; gdb-mi.el gets round this problem.
(defun gud-tooltip-process-output (process output)
"Process debugger output and show it in a tooltip window."
- (set-process-filter process gud-tooltip-original-filter)
+ (remove-function (process-filter process) #'gud-tooltip-process-output)
(tooltip-show (tooltip-strip-prompt process output)
(or gud-tooltip-echo-area tooltip-use-echo-area)))
(gdb-input
(concat cmd "\n")
`(lambda () (gdb-tooltip-print ,expr))))
- (setq gud-tooltip-original-filter (process-filter process))
- (set-process-filter process 'gud-tooltip-process-output)
+ (add-function :override (process-filter process)
+ #'gud-tooltip-process-output)
(gud-basic-call cmd))
expr))))))))
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)
+ (add-function :override (process-filter proc)
+ #'inferior-octave-output-digest)
(setq inferior-octave-output-list nil)
(unwind-protect
(while (setq string (car list))
(while inferior-octave-receive-in-progress
(accept-process-output proc))
(setq list (cdr list)))
- (set-process-filter proc filter))))
+ (remove-function (process-filter proc)
+ #'inferior-octave-output-digest))))
(defun inferior-octave-directory-tracker (string)
"Tracks `cd' commands issued to the inferior Octave process.
real-file))
(with-current-buffer buffer
(goto-char (point-max))
- (set-process-filter process 'prolog-consult-compile-filter)
+ (add-function :override (process-filter process)
+ #'prolog-consult-compile-filter)
(process-send-string "prolog" command-string)
;; (prolog-build-prolog-command compilep file real-file first-line))
(while (and prolog-process-flag
(insert (if compilep
"\nCompilation finished.\n"
"\nConsulted.\n"))
- (set-process-filter process old-filter))))
+ (remove-function (process-filter process)
+ #'prolog-consult-compile-filter))))
(defvar compilation-error-list)
;;;; Internal Variables
(defvar xscheme-previous-mode)
-(defvar xscheme-previous-process-state)
(defvar xscheme-last-input-end)
(defvar xscheme-process-command-line nil
(if (not preserve)
(let ((previous-mode major-mode))
(kill-all-local-variables)
- (make-local-variable 'xscheme-process-name)
- (make-local-variable 'xscheme-previous-process-state)
(make-local-variable 'xscheme-runlight-string)
(make-local-variable 'xscheme-runlight)
(set (make-local-variable 'xscheme-previous-mode) previous-mode)
(set (make-local-variable 'xscheme-buffer-name) (buffer-name buffer))
(set (make-local-variable 'xscheme-last-input-end) (make-marker))
(let ((process (get-buffer-process buffer)))
- (if process
- (progn
- (setq xscheme-process-name (process-name process))
- (setq xscheme-previous-process-state
- (cons (process-filter process)
- (process-sentinel process)))
- (xscheme-process-filter-initialize t)
- (xscheme-mode-line-initialize xscheme-buffer-name)
- (set-process-sentinel process 'xscheme-process-sentinel)
- (set-process-filter process 'xscheme-process-filter))
- (setq xscheme-previous-process-state (cons nil nil)))))))
+ (when process
+ (setq-local xscheme-process-name (process-name process))
+ ;; FIXME: Use add-function!
+ (xscheme-process-filter-initialize t)
+ (xscheme-mode-line-initialize xscheme-buffer-name)
+ (add-function :override (process-sentinel process)
+ #'xscheme-process-sentinel)
+ (add-function :override (process-filter process)
+ #'xscheme-process-filter))))))
(scheme-interaction-mode-initialize)
(scheme-mode-variables)
(run-mode-hooks 'scheme-mode-hook 'scheme-interaction-mode-hook))
(defun exit-scheme-interaction-mode ()
- "Take buffer out of scheme interaction mode"
+ "Take buffer out of scheme interaction mode."
(interactive)
(if (not (derived-mode-p 'scheme-interaction-mode))
(error "Buffer not in scheme interaction mode"))
- (let ((previous-state xscheme-previous-process-state))
- (funcall xscheme-previous-mode)
- (let ((process (get-buffer-process (current-buffer))))
- (if process
- (progn
- (if (eq (process-filter process) 'xscheme-process-filter)
- (set-process-filter process (car previous-state)))
- (if (eq (process-sentinel process) 'xscheme-process-sentinel)
- (set-process-sentinel process (cdr previous-state))))))))
+ (funcall xscheme-previous-mode)
+ (let ((process (get-buffer-process (current-buffer))))
+ (when process
+ (remove-function (process-sentinel process) #'xscheme-process-sentinel)
+ (remove-function (process-filter process) #'xscheme-process-filter))))
(defvar scheme-interaction-mode-commands-alist nil)
(defvar scheme-interaction-mode-map nil)
(insert "\n" (emacs-version) "\n" emacs-copyright "\n")
(if (and (eq (key-binding "\C-h\C-c") 'describe-copying)
- (eq (key-binding "\C-h\C-d") 'describe-distribution)
+ (eq (key-binding "\C-h\C-o") 'describe-distribution)
(eq (key-binding "\C-h\C-w") 'describe-no-warranty))
(progn
(insert
The default value matches usual \\label{...} definitions and
keyval style [..., label = {...}, ...] label definitions. It is
assumed that the regexp group 1 matches the label text, so you
-have to define it using \\(?1:...\\) when adding new regexps."
+have to define it using \\(?1:...\\) when adding new regexps.
+
+When changed from Lisp, make sure to call
+`reftex-compile-variables' afterwards to make the change
+effective."
+ :set (lambda (symbol value)
+ (set symbol value)
+ (reftex-compile-variables))
:group 'reftex-defining-label-environments
:type '(repeat (regexp :tag "Regular Expression")))
(reftex-kill-buffer (reftex-make-index-buffer-name tag)))
(cdr (assoc 'index-tags (symbol-value reftex-docstruct-symbol)))))
+;;;###autoload
(defun reftex-compile-variables ()
;; Compile the information in reftex-label-alist & Co.
(defconst vc-cvs-annotate-first-line-re "^[0-9]")
-(defun vc-cvs-annotate-process-filter (process string)
+(defun vc-cvs-annotate-process-filter (filter process string)
(setq string (concat (process-get process 'output) string))
(if (not (string-match vc-cvs-annotate-first-line-re string))
;; Still waiting for the first real line.
(process-put process 'output string)
- (let ((vc-filter (process-get process 'vc-filter)))
- (set-process-filter process vc-filter)
- (funcall vc-filter process (substring string (match-beginning 0))))))
+ (remove-function (process-filter process) #'vc-cvs-annotate-process-filter)
+ (funcall filter process (substring string (match-beginning 0)))))
(defun vc-cvs-annotate-command (file buffer &optional revision)
"Execute \"cvs annotate\" on FILE, inserting the contents in BUFFER.
(let ((proc (get-buffer-process buffer)))
(if proc
;; If running asynchronously, use a process filter.
- (progn
- (process-put proc 'vc-filter (process-filter proc))
- (set-process-filter proc 'vc-cvs-annotate-process-filter))
+ (add-function :around (process-filter proc)
+ #'vc-cvs-annotate-process-filter)
(with-current-buffer buffer
(goto-char (point-min))
(re-search-forward vc-cvs-annotate-first-line-re)
-;;; vc-dispatcher.el -- generic command-dispatcher facility.
+;;; vc-dispatcher.el -- generic command-dispatcher facility. -*- lexical-binding: t -*-
;; Copyright (C) 2008-2013 Free Software Foundation, Inc.
(defvar vc-sentinel-movepoint) ;Dynamically scoped.
-(defun vc-process-sentinel (p s)
- (let ((previous (process-get p 'vc-previous-sentinel))
- (buf (process-buffer p)))
+(defun vc--process-sentinel (p code)
+ (let ((buf (process-buffer p)))
;; Impatient users sometime kill "slow" buffers; check liveness
;; to avoid "error in process sentinel: Selecting deleted buffer".
(when (buffer-live-p buf)
- (when previous (funcall previous p s))
(with-current-buffer buf
(setq mode-line-process
(let ((status (process-status p)))
;; Leave mode-line uncluttered, normally.
(unless (eq 'exit status)
(format " (%s)" status))))
- (let (vc-sentinel-movepoint)
+ (let (vc-sentinel-movepoint
+ (m (process-mark p)))
;; Normally, we want async code such as sentinels to not move point.
(save-excursion
- (goto-char (process-mark p))
- (let ((cmds (process-get p 'vc-sentinel-commands)))
- (process-put p 'vc-sentinel-commands nil)
- (dolist (cmd cmds)
+ (goto-char m)
;; Each sentinel may move point and the next one should be run
;; at that new point. We could get the same result by having
;; each sentinel read&set process-mark, but since `cmd' needs
;; to work both for async and sync processes, this would be
;; difficult to achieve.
- (vc-exec-after cmd))))
+ (vc-exec-after code)
+ (move-marker m (point)))
;; But sometimes the sentinels really want to move point.
(when vc-sentinel-movepoint
(let ((win (get-buffer-window (current-buffer) 0)))
(defun vc-exec-after (code)
"Eval CODE when the current buffer's process is done.
If the current buffer has no process, just evaluate CODE.
-Else, add CODE to the process' sentinel."
+Else, add CODE to the process' sentinel.
+CODE can be either a function of no arguments, or an expression
+to evaluate."
(let ((proc (get-buffer-process (current-buffer))))
(cond
;; If there's no background process, just execute the code.
((or (null proc) (eq (process-status proc) 'exit))
;; Make sure we've read the process's output before going further.
(when proc (accept-process-output proc))
- (eval code))
+ (if (functionp code) (funcall code) (eval code)))
;; If a process is running, add CODE to the sentinel
((eq (process-status proc) 'run)
(vc-set-mode-line-busy-indicator)
- (let ((previous (process-sentinel proc)))
- (unless (eq previous 'vc-process-sentinel)
- (process-put proc 'vc-previous-sentinel previous))
- (set-process-sentinel proc 'vc-process-sentinel))
- (process-put proc 'vc-sentinel-commands
- ;; We keep the code fragments in the order given
- ;; so that vc-diff-finish's message shows up in
- ;; the presence of non-nil vc-command-messages.
- (append (process-get proc 'vc-sentinel-commands)
- (list code))))
+ (letrec ((fun (lambda (p _msg)
+ (remove-function (process-sentinel p) fun)
+ (vc--process-sentinel p code))))
+ (add-function :after (process-sentinel proc) fun)))
(t (error "Unexpected process state"))))
nil)
(set-window-start window new-window-start))
buffer))
+(defvar compilation-error-regexp-alist)
+
(defun vc-compilation-mode (backend)
"Setup `compilation-mode' after with the appropriate `compilation-error-regexp-alist'."
(let* ((error-regexp-alist
(vc-position-context (mark-marker))))
;; Make the right thing happen in transient-mark-mode.
(mark-active nil))
- (list point-context mark-context nil)))
+ (list point-context mark-context)))
(defun vc-restore-buffer-context (context)
"Restore point/mark, and reparse any affected compilation buffers.
(make-variable-buffer-local 'vc-mode-line-hook)
(put 'vc-mode-line-hook 'permanent-local t)
+(defvar view-old-buffer-read-only)
+
(defun vc-resynch-window (file &optional keep noquery reset-vc-info)
"If FILE is in the current buffer, either revert or unvisit it.
The choice between revert (to see expanded keywords) and unvisit
(defvar log-view-vc-fileset)
(defun vc-print-log-setup-buttons (working-revision is-start-revision limit pl-return)
+ "Insert at the end of the current buffer buttons to show more log entries.
+In the new log, leave point at WORKING-REVISION (if non-nil).
+LIMIT is the number of entries currently shown.
+Does nothing if IS-START-REVISION is non-nil, or if LIMIT is nil,
+or if PL-RETURN is 'limit-unsupported."
(when (and limit (not (eq 'limit-unsupported pl-return))
(not is-start-revision))
(goto-char (point-max))
(defun vc-print-log-internal (backend files working-revision
&optional is-start-revision limit)
+ "For specified BACKEND and FILES, show the VC log.
+Leave point at WORKING-REVISION, if it is non-nil.
+If IS-START-REVISION is non-nil, start the log from WORKING-REVISION.
+Show up to LIMIT entries (non-nil means unlimited).
+\(IS-START-REVISION non-nil might not work correctly if LIMIT is not 1.)"
+ ;; The parenthetical remark is based on the commentary of vc.el for
+ ;; "print log": "At this point START-REVISION is only required to work
+ ;; in conjunction with LIMIT = 1." The only thing that passes
+ ;; IS-START-REVISION non-nil is vc-annotate-show-log-revision-at-line,
+ ;; which sets LIMIT = 1.
+
;; Don't switch to the output buffer before running the command,
;; so that any buffer-local settings in the vc-controlled
;; buffer can be accessed by the command.
(interactive
(cond
(current-prefix-arg
- (let ((rev (read-from-minibuffer "Log from revision (default: last revision): " nil
+ (let ((rev (read-from-minibuffer "Leave point at revision (default: last revision): " nil
nil nil nil))
(lim (string-to-number
(read-from-minibuffer
echo "Making links to \`admin' and its subdirectories"
for f in `find admin -type f`; do
+ case $f in
+ admin/unidata/Makefile) continue ;;
+ esac
ln $f $tempdir/$f
done
+2013-04-22 Paul Eggert <eggert@cs.ucla.edu>
+
+ * Makefile.in (bootstrap-clean): Remove stamp-h1 too.
+ Without this fix, "make distclean" leaves stamp-h1 behind.
+
2013-04-20 Erik Charlebois <erikcharlebois@gmail.com>
* w32fns.c (w32_fullscreen_rect): New function to compute the
## It should remove all files generated during a compilation/bootstrap,
## but not things like config.status or TAGS.
bootstrap-clean: clean
- rm -f epaths.h config.h config.stamp stamp-oldxmenu ../etc/DOC-*
+ rm -f epaths.h config.h config.stamp stamp-h1 stamp-oldxmenu ../etc/DOC-*
if test -f ./.gdbinit; then \
mv ./.gdbinit ./.gdbinit.save; \
if test -f "$(srcdir)/.gdbinit"; then rm -f ./.gdbinit.save; \
HCoop / bpt / emacs.git / commitdiff