;;; server.el --- Lisp code for GNU Emacs running as server process.
-;; Copyright (C) 1986, 1987, 1992 Free Software Foundation, Inc.
+;; Copyright (C) 1986, 1987, 1992, 1994, 1995 Free Software Foundation, Inc.
;; Author: William Sommerfeld <wesommer@athena.mit.edu>
;; Keywords: processes
(defvar server-switch-hook nil
"*List of hooks to call when switching to a buffer for the Emacs server.")
+(defvar server-done-hook nil
+ "*List of hooks to call when done editing a buffer for the Emacs server.")
+
(defvar server-process nil
"the current server process")
(defvar server-clients nil
"List of current server clients.
-Each element is (CLIENTID FILES...) where CLIENTID is a string
+Each element is (CLIENTID BUFFERS...) where CLIENTID is a string
that can be given to the server process to identify a client.
When a buffer is marked as \"done\", it is removed from this list.")
(save-excursion
(set-buffer "*server*")
(goto-char (point-max))
- (insert string)
- (or (bobp) (newline)))))
+ (insert (current-time-string) " " string)
+ (or (bolp) (newline)))))
(defun server-sentinel (proc msg)
(cond ((eq (process-status proc) 'exit)
"Allow this Emacs process to be a server for client processes.
This starts a server communications subprocess through which
client \"editors\" can send your editing commands to this Emacs job.
-To use the server, set up the program `etc/emacsclient' in the
+To use the server, set up the program `emacsclient' in the
Emacs distribution as your standard \"editor\".
Prefix arg means just kill any existing server communications subprocess."
(set-process-sentinel server-process nil)
(condition-case () (delete-process server-process) (error nil))))
(condition-case () (delete-file "~/.emacs_server") (error nil))
+ (let* ((sysname (system-name))
+ (dot-index (string-match "\\." sysname)))
+ (condition-case ()
+ (delete-file (format "/tmp/esrv%d-%s" (user-uid) sysname))
+ (error nil))
+ ;; In case the server file name was made with a domainless hostname,
+ ;; try deleting that name too.
+ (if dot-index
+ (condition-case ()
+ (delete-file (format "/tmp/esrv%d-%s" (user-uid)
+ (substring sysname 0 dot-index)))
+ (error nil))))
;; If we already had a server, clear out associated status.
(while server-clients
(let ((buffer (nth 1 (car server-clients))))
nil
(if server-process
(server-log (message "Restarting server")))
- (setq server-process (start-process "server" nil server-program))
+ ;; Using a pty is wasteful, and the separate session causes
+ ;; annoyance sometimes (some systems kill idle sessions).
+ (let ((process-connection-type nil))
+ (setq server-process (start-process "server" nil server-program)))
(set-process-sentinel server-process 'server-sentinel)
(set-process-filter server-process 'server-process-filter)
(process-kill-without-query server-process)))
(defun server-process-filter (proc string)
(server-log string)
(setq string (concat server-previous-string string))
- (if (not (and (eq ?\n (aref string (1- (length string))))
- (eq 0 (string-match "Client: " string))))
- ;; If input is not complete, save it for later.
- (setq server-previous-string string)
- ;; If it is complete, process it now, and discard what was saved.
- (setq string (substring string (match-end 0)))
- (setq server-previous-string "")
- (let ((client (list (substring string 0 (string-match " " string))))
+ ;; If the input is multiple lines,
+ ;; process each line individually.
+ (while (string-match "\n" string)
+ (let ((request (substring string 0 (match-beginning 0)))
+ client
(files nil)
(lineno 1))
- (setq string (substring string (match-end 0)))
- (while (string-match "[^ ]+ " string)
- (let ((arg
- (substring string (match-beginning 0) (1- (match-end 0)))))
- (setq string (substring string (match-end 0)))
- (if (string-match "\\`\\+[0-9]+\\'" arg)
- (setq lineno (read (substring arg 1)))
- (setq files
- (cons (list arg lineno)
- files))
- (setq lineno 1))))
- (server-visit-files files client)
- ;; CLIENT is now a list (CLIENTNUM BUFFERS...)
- (setq server-clients (cons client server-clients))
- (server-switch-buffer (nth 1 client))
- (run-hooks 'server-switch-hook)
- (message (substitute-command-keys
- "When done with a buffer, type \\[server-edit].")))))
+ ;; Remove this line from STRING.
+ (setq string (substring string (match-end 0)))
+ (if (string-match "^Error: " request)
+ (message (concat "Server error: " (substring request (match-end 0))))
+ (if (string-match "^Client: " request)
+ (progn
+ (setq request (substring request (match-end 0)))
+ (setq client (list (substring request 0 (string-match " " request))))
+ (setq request (substring request (match-end 0)))
+ (while (string-match "[^ ]+ " request)
+ (let ((arg
+ (substring request (match-beginning 0) (1- (match-end 0)))))
+ (setq request (substring request (match-end 0)))
+ (if (string-match "\\`\\+[0-9]+\\'" arg)
+ (setq lineno (read (substring arg 1)))
+ (setq files
+ (cons (list arg lineno)
+ files))
+ (setq lineno 1))))
+ (server-visit-files files client)
+ ;; CLIENT is now a list (CLIENTNUM BUFFERS...)
+ (setq server-clients (cons client server-clients))
+ (server-switch-buffer (nth 1 client))
+ (run-hooks 'server-switch-hook)
+ (message (substitute-command-keys
+ "When done with a buffer, type \\[server-edit]")))))))
+ ;; Save for later any partial line that remains.
+ (setq server-previous-string string))
(defun server-visit-files (files client)
"Finds FILES and returns the list CLIENT with the buffers nconc'd.
FILES is an alist whose elements are (FILENAME LINENUMBER)."
- (let (client-record (obuf (current-buffer)))
+ ;; Bind last-nonmenu-event to force use of keyboard, not mouse, for queries.
+ (let (client-record (last-nonmenu-event t) (obuf (current-buffer)))
;; Restore the current buffer afterward, but not using save-excursion,
;; because we don't want to save point in this buffer
;; if it happens to be one of those specified by the server.
\f
(defun server-buffer-done (buffer)
"Mark BUFFER as \"done\" for its client(s).
-Buries the buffer, and returns another server buffer
-as a suggestion for what to select next."
+This buries the buffer, then returns a list of the form (NEXT-BUFFER KILLED).
+NEXT-BUFFER is another server buffer, as a suggestion for what to select next,
+or nil. KILLED is t if we killed BUFFER (because it was a temp file)."
(let ((running (eq (process-status server-process) 'run))
(next-buffer nil)
+ (killed nil)
+ (first t)
(old-clients server-clients))
(while old-clients
(let ((client (car old-clients)))
(or next-buffer
(setq next-buffer (nth 1 (memq buffer client))))
(delq buffer client)
+ ;; Delete all dead buffers from CLIENT.
+ (let ((tail client))
+ (while tail
+ (and (bufferp (car tail))
+ (null (buffer-name (car tail)))
+ (delq (car tail) client))
+ (setq tail (cdr tail))))
;; If client now has no pending buffers,
;; tell it that it is done, and forget it entirely.
(if (cdr client) nil
(if running
(progn
+ ;; Don't send emacsserver two commands in close succession.
+ ;; It cannot handle that.
+ (or first (sit-for 1))
+ (setq first nil)
(send-string server-process
(format "Close: %s Done\n" (car client)))
(server-log (format "Close: %s Done\n" (car client)))))
(setq server-clients (delq client server-clients))))
(setq old-clients (cdr old-clients)))
- (if (buffer-name buffer)
+ (if (and (bufferp buffer) (buffer-name buffer))
(progn
(save-excursion
(set-buffer buffer)
- (setq server-buffer-clients nil))
- (bury-buffer buffer)))
- next-buffer))
+ (setq server-buffer-clients nil)
+ (run-hooks 'server-done-hook))
+ (if (server-temp-file-p buffer)
+ (progn (kill-buffer buffer)
+ (setq killed t))
+ (bury-buffer buffer))))
+ (list next-buffer killed)))
(defun server-temp-file-p (buffer)
"Return non-nil if BUFFER contains a file considered temporary.
(defun server-done ()
"Offer to save current buffer, mark it as \"done\" for clients.
-Then bury it, and return a suggested buffer to select next."
+This buries the buffer, then returns a list of the form (NEXT-BUFFER KILLED).
+NEXT-BUFFER is another server buffer, as a suggestion for what to select next,
+or nil. KILLED is t if we killed the BUFFER (because it was a temp file)."
(let ((buffer (current-buffer)))
(if server-buffer-clients
- (let (suggested-buffer)
+ (progn
(if (server-temp-file-p buffer)
;; For a temp file, save, and do make a non-numeric backup
;; (unless make-backup-files is nil).
(let ((version-control nil)
(buffer-backed-up nil))
- (save-buffer)
- (kill-buffer buffer)
- (setq suggested-buffer (current-buffer)))
+ (save-buffer))
(if (and (buffer-modified-p)
(y-or-n-p (concat "Save file " buffer-file-name "? ")))
(save-buffer buffer)))
- (or (server-buffer-done buffer) suggested-buffer)))))
+ (server-buffer-done buffer)))))
+
+;; Ask before killing a server buffer.
+;; It was suggested to release its client instead,
+;; but I think that is dangerous--the client would proceed
+;; using whatever is on disk in that file. -- rms.
+(defun server-kill-buffer-query-function ()
+ (or (not server-buffer-clients)
+ (yes-or-no-p (format "Buffer `%s' still has clients; kill it? "
+ (buffer-name (current-buffer))))))
-;; If a server buffer is killed, release its client.
-;; I'm not sure this is really a good idea--do you want the client
-;; to proceed using whatever is on disk in that file?
(add-hook 'kill-buffer-query-functions
- (function
- (lambda ()
- (or (not server-buffer-clients)
- (yes-or-no-p (format "Buffer `%s' still has clients; kill it? "
- (buffer-name (current-buffer))))))))
-
-(add-hook 'kill-emacs-query-functions
- (function
- (lambda ()
- (or (not server-clients)
- (yes-or-no-p "Server buffers are still have clients; exit anyway? ")))))
+ 'server-kill-buffer-query-function)
+
+(defun server-kill-emacs-query-function ()
+ (let (live-client
+ (tail server-clients))
+ ;; See if any clients have any buffers that are still alive.
+ (while tail
+ (if (memq t (mapcar 'stringp (mapcar 'buffer-name (cdr (car tail)))))
+ (setq live-client t))
+ (setq tail (cdr tail)))
+ (or (not live-client)
+ (yes-or-no-p "Server buffers still have clients; exit anyway? "))))
+
+(add-hook 'kill-emacs-query-functions 'server-kill-emacs-query-function)
\f
(defun server-edit (&optional arg)
"Switch to next server editing buffer; say \"Done\" for current buffer.
If invoked with a prefix argument, or if there is no server process running,
starts server process and that is all. Invoked by \\[server-edit]."
-
(interactive "P")
(if (or arg
(not server-process)
(memq (process-status server-process) '(signal exit)))
(server-start nil)
- (server-switch-buffer (server-done))))
+ (apply 'server-switch-buffer (server-done))))
-(defun server-switch-buffer (next-buffer)
+(defun server-switch-buffer (&optional next-buffer killed-one)
"Switch to another buffer, preferably one that has a client.
Arg NEXT-BUFFER is a suggestion; if it is a live buffer, use it."
- (cond ((windowp server-window)
+ ;; KILLED-ONE is t in a recursive call
+ ;; if we have already killed one temp-file server buffer.
+ ;; This means we should avoid the final "switch to some other buffer"
+ ;; since we've already effectively done that.
+ (cond ((and (windowp server-window)
+ (window-live-p server-window))
(select-window server-window))
((framep server-window)
+ (if (not (frame-live-p server-window))
+ (setq server-window (make-frame)))
(select-window (frame-selected-window server-window))))
(if (window-minibuffer-p (selected-window))
- (select-window (next-window nil 'nomini t)))
+ (select-window (next-window nil 'nomini 0)))
+ ;; Move to a non-dedicated window, if we have one.
+ (let ((last-window (previous-window nil 'nomini 0)))
+ (while (and (window-dedicated-p (selected-window))
+ (not (eq last-window (selected-window))))
+ (select-window (next-window nil 'nomini 0))))
+ (set-window-dedicated-p (selected-window) nil)
(if next-buffer
(if (and (bufferp next-buffer)
(buffer-name next-buffer))
;; If NEXT-BUFFER is a dead buffer,
;; remove the server records for it
;; and try the next surviving server buffer.
- (server-switch-buffer
- (server-buffer-done next-buffer)))
+ (apply 'server-switch-buffer
+ (server-buffer-done next-buffer)))
(if server-clients
- (server-switch-buffer (nth 1 (car server-clients)))
- (switch-to-buffer (other-buffer)))))
+ (server-switch-buffer (nth 1 (car server-clients)) killed-one)
+ (if (not killed-one)
+ (switch-to-buffer (other-buffer))))))
(global-set-key "\C-x#" 'server-edit)
\f