|
0
|
1 ; Lisp Interface code between GNU Emacs and gnuserv.
|
|
|
2 ;
|
|
|
3 ; This file is part of GNU Emacs.
|
|
|
4 ;
|
|
|
5 ; Copying is permitted under those conditions described by the GNU
|
|
|
6 ; General Public License.
|
|
|
7 ;
|
|
114
|
8 ; Copyright (C) 1989-1996 Free Software Foundation, Inc.
|
|
0
|
9 ;
|
|
|
10 ; Author: Andy Norman (ange@hplb.hpl.hp.com) based on
|
|
|
11 ; 'lisp/server.el' from the 18.52 GNU Emacs distribution.
|
|
|
12 ;
|
|
|
13 ; Please mail bugs and suggestions to the author at the above address.
|
|
|
14 ;
|
|
|
15 ;;; Synched up with: Not in FSF.
|
|
|
16
|
|
|
17 ; Updated for XEmacs, GNU Emacs 19 and Epoch V4 to use multiple frames
|
|
|
18 ; by Bob Weiner, <weiner@mot.com>, 1/20/94. (Still works with Emacs V18, too.)
|
|
|
19 ; Modified 'server-process-filter' to use \^D as end of request terminator
|
|
|
20 ; as gnuclient and gnudoit have been modified to send. This permits
|
|
|
21 ; multi-line requests.
|
|
|
22 ; Modified 'server-make-window-visible' to work with multiple frames.
|
|
|
23 ; Modified 'server-find-file' to display in a separate frame when possible.
|
|
|
24 ; Modified 'server-edit' to delete newly created frame when used to
|
|
|
25 ; terminate an edit and to signal an error if called within a
|
|
|
26 ; non-server-edit buffer.
|
|
|
27 ; Bob Weiner, <weiner@mot.com>, 5/9/94.
|
|
|
28 ; Added 'server-done-function' variable. Made default value 'kill-buffer'
|
|
|
29 ; instead of 'bury-buffer' as in original gnuserv.el.
|
|
|
30 ;
|
|
|
31 ; Darrell Kindred <dkindred+@cmu.edu> May/1994
|
|
|
32 ; Updated to allow multi-line return values:
|
|
|
33 ; - output to gnuserv is "m/n:xxx" where m is the client number,
|
|
|
34 ; n is the length of the data, and xxx is the data itself, followed
|
|
|
35 ; by newline
|
|
|
36 ;
|
|
|
37 ; Arup Mukherjee <arup+@cmu.edu> May/1994
|
|
|
38 ; Updated for XEmacs 19.10, and others:
|
|
|
39 ; - use find-file-other-screen if present
|
|
2
|
40 ; - new variable gnuserv-frame can be set to a frame or screen which
|
|
0
|
41 ; is used for all edited files.
|
|
|
42 ; - check to see if server.el is already loaded and complain if it is, since
|
|
|
43 ; gnuserv.el can't coexist with server.el
|
|
|
44 ; - rename server-start to gnuserv-start, although server-start remains as
|
|
|
45 ; an alias. This allows gnuserv-start to be autoloaded from gnuserv.el
|
|
|
46 ; - changed server-get-buffer to take into account that in newer emacsen,
|
|
|
47 ; get buffer returns nil on deleted buffers.
|
|
|
48 ; - only try to create/delete frames or screens if window-system is non-nil
|
|
|
49 ; (otherwise things don't work w/ emacs19 on a dumb terminal)
|
|
|
50 ;
|
|
|
51 ; Ben Wing <wing@666.com> sometime in 1995
|
|
|
52 ; Updated to allow `gnuattach'-type connections to the existing TTY
|
|
|
53 ;
|
|
|
54 ; Ben Wing <wing@666.com> May/1996
|
|
|
55 ; patch to get TTY terminal type correct.
|
|
114
|
56 ;
|
|
|
57 ; Jan Vroonhof <vroonhof@math.ethz.ch> July/1996
|
|
|
58 ; ported the server-temp-file-regexp feature from server.el
|
|
|
59 ; ported server hooks from server.el
|
|
|
60 ; ported kill-*-query functions from server.el (and made it optional)
|
|
|
61 ; synced other behaviour with server.el
|
|
0
|
62
|
|
|
63
|
|
|
64
|
|
|
65 (defconst gnuserv-rcs-header-id "!Header: gnuserv.el,v 2.1 95/02/16 12:00:16 arup alpha !")
|
|
|
66
|
|
|
67
|
|
|
68 ;; server.el and gnuserv.el can't coexist because of conflicting defvar's and
|
|
|
69 ;; function names.
|
|
|
70
|
|
|
71 (if (and (boundp 'server-buffer-clients)
|
|
|
72 (not (featurep 'gnuserv)))
|
|
|
73 (error "Can't run gnuserv because server.el appears to be loaded already"))
|
|
|
74
|
|
78
|
75 ;;;###autoload
|
|
0
|
76 (defvar gnuserv-frame nil
|
|
|
77 "*If non-nil, the frame to be used to display all edited files.
|
|
|
78 If nil, then a new frame is created for each file edited.
|
|
|
79 This variable has no effect in XEmacs versions older than 19.9.")
|
|
|
80
|
|
|
81 (defvar server-done-function 'kill-buffer
|
|
|
82 "*A function of one argument, a buffer, which removes the buffer after editing.
|
|
114
|
83 Functions such as 'kill-buffer' and 'bury-buffer' are good values. See also
|
|
|
84 `server-done-temp-file-function'")
|
|
|
85
|
|
|
86 (defvar server-done-temp-file-function 'kill-buffer
|
|
|
87 "*A function of one argument, a buffer, which removes the buffer after editing a
|
|
|
88 temporary file. Functions such as 'kill-buffer' and 'bury-buffer' are
|
|
|
89 good values. See also `server-done-function'")
|
|
0
|
90
|
|
|
91 (defvar server-program "gnuserv"
|
|
|
92 "*The program to use as the edit server")
|
|
|
93
|
|
114
|
94
|
|
|
95 (defvar server-visit-hook nil
|
|
|
96 "*List of hooks to call when visiting a file for the Emacs server.")
|
|
|
97
|
|
|
98 ;; defined by server.el but obsolete?
|
|
|
99 ;; (defvar server-switch-hook nil
|
|
|
100 ;; "*List of hooks to call when switching to a buffer for the Emacs server.")
|
|
|
101
|
|
|
102 (defvar server-done-hook nil
|
|
|
103 "*List of hooks to call when done editing a buffer for the Emacs server.")
|
|
|
104
|
|
|
105
|
|
0
|
106 (defvar server-process nil
|
|
|
107 "The current server process")
|
|
|
108
|
|
|
109 (defvar server-string ""
|
|
|
110 "The last input string from the server")
|
|
|
111
|
|
78
|
112 (defvar server-kill-last-frame nil
|
|
|
113 "set to t to kill last frame")
|
|
|
114
|
|
0
|
115 (defvar current-client nil
|
|
|
116 "The client we are currently talking to")
|
|
|
117
|
|
|
118 (defvar server-clients nil
|
|
|
119 "List of current server clients.
|
|
|
120 Each element is (CLIENTID BUFFER...) where CLIENTID is an integer
|
|
|
121 that can be given to the server process to identify a client.
|
|
|
122 When a buffer is killed, it is removed from this list.")
|
|
|
123
|
|
114
|
124 (defvar server-kill-quietly nil
|
|
|
125 "If this variable is set then don't confirm kills of buffers with
|
|
|
126 clients attached")
|
|
|
127
|
|
|
128
|
|
0
|
129 (defvar server-buffer-clients nil
|
|
|
130 "List of client ids for clients requesting editing of the current buffer.")
|
|
|
131
|
|
114
|
132 (defvar server-temp-file-regexp "^/tmp/Re\\|/draft$"
|
|
|
133 "*Regexp which should match filenames of temporary files
|
|
|
134 which are deleted and reused after each edit
|
|
|
135 by the programs that invoke the emacs server.")
|
|
|
136
|
|
|
137 (defvar server-make-temp-file-backup nil
|
|
|
138 "Non-nil makes the server backup temporary files also")
|
|
|
139
|
|
0
|
140 (make-variable-buffer-local 'server-buffer-clients)
|
|
|
141 (setq-default server-buffer-clients nil)
|
|
|
142 (or (assq 'server-buffer-clients minor-mode-alist)
|
|
|
143 (setq minor-mode-alist (cons '(server-buffer-clients " Server")
|
|
|
144 minor-mode-alist)))
|
|
|
145
|
|
114
|
146 (defun server-temp-file-p (buffer)
|
|
|
147 "Return non-nil if BUFFER contains a file considered temporary.
|
|
|
148 These are files whose names suggest they are repeatedly
|
|
|
149 reused to pass information to another program.
|
|
|
150
|
|
|
151 The variable `server-temp-file-regexp' controls which filenames
|
|
|
152 are considered temporary."
|
|
|
153 (and (buffer-file-name buffer)
|
|
|
154 (string-match server-temp-file-regexp (buffer-file-name buffer))))
|
|
|
155
|
|
|
156
|
|
0
|
157 (defun server-log (string)
|
|
|
158 "If a *server* buffer exists, write STRING to it for logging purposes."
|
|
|
159 (if (get-buffer "*server*")
|
|
|
160 (save-excursion
|
|
|
161 (set-buffer "*server*")
|
|
|
162 (goto-char (point-max))
|
|
|
163 (insert string)
|
|
|
164 (or (bolp) (newline)))))
|
|
|
165
|
|
|
166
|
|
|
167 (defun server-sentinel (proc msg)
|
|
|
168 (cond ((eq (process-status proc) 'exit)
|
|
|
169 (server-log (message "Server subprocess exited")))
|
|
|
170 ((eq (process-status proc) 'signal)
|
|
|
171 (server-log (message "Server subprocess killed")))))
|
|
|
172
|
|
|
173
|
|
|
174 (defun server-process-display-error (string)
|
|
|
175 "Whenever a gnuserv error is reported, display it in a pop-up window."
|
|
|
176 (let ((cur (selected-window))
|
|
|
177 (pop-up-windows t))
|
|
|
178 (pop-to-buffer (get-buffer-create "*server*"))
|
|
|
179 (set-window-start (selected-window) (point))
|
|
|
180 (server-log string)
|
|
|
181 (select-window cur)))
|
|
|
182
|
|
|
183
|
|
|
184 (defun server-process-filter (proc string)
|
|
|
185 "Process client gnuserv requests to execute Emacs commands."
|
|
|
186 (setq server-string (concat server-string string))
|
|
|
187 (if (string-match "\^D$" server-string) ; requests end with ctrl-D
|
|
|
188 (if (string-match "^[0-9]+" server-string) ; client request id
|
|
|
189 (progn
|
|
|
190 (server-log server-string)
|
|
|
191 (let ((header (read-from-string server-string)))
|
|
|
192 (setq current-client (car header))
|
|
|
193 (condition-case oops
|
|
|
194 (eval (car (read-from-string server-string
|
|
|
195 (cdr header))))
|
|
|
196 (error (setq server-string "")
|
|
|
197 (server-write-to-client current-client oops)
|
|
|
198 (setq current-client nil)
|
|
|
199 (signal (car oops) (cdr oops)))
|
|
|
200 (quit (setq server-string "")
|
|
|
201 (server-write-to-client current-client oops)
|
|
|
202 (setq current-client nil)
|
|
|
203 (signal 'quit nil)))
|
|
|
204 (setq server-string "")))
|
|
|
205 (progn ;error string from server
|
|
|
206 (server-process-display-error server-string)
|
|
|
207 (setq server-string "")))))
|
|
|
208
|
|
|
209
|
|
|
210 (defun server-release-outstanding-buffers ()
|
|
|
211 "Release all buffers that have clients waiting for them to be finished."
|
|
|
212 (interactive)
|
|
|
213 (while server-clients
|
|
|
214 (let ((buffer (nth 1 (car server-clients)))) ; for all buffers...
|
|
|
215 (server-buffer-done buffer)))) ; destructively modifies server-clients
|
|
|
216
|
|
|
217 ;;;###autoload
|
|
|
218 (defun gnuserv-start (&optional leave-dead)
|
|
|
219 "Allow this Emacs process to be a server for client processes.
|
|
|
220 This starts a server communications subprocess through which
|
|
|
221 client \"editors\" (gnuclient and gnudoit) can send editing commands to
|
|
|
222 this Emacs job. See the gnuserv(1) manual page for more details.
|
|
|
223
|
|
|
224 Prefix arg means just kill any existing server communications subprocess."
|
|
|
225 (interactive "P")
|
|
|
226 ;; kill it dead!
|
|
|
227 (if server-process
|
|
|
228 (progn
|
|
|
229 (server-release-outstanding-buffers)
|
|
|
230 (set-process-sentinel server-process nil)
|
|
|
231 (condition-case ()
|
|
|
232 (delete-process server-process)
|
|
|
233 (error nil))))
|
|
|
234 ;; If we already had a server, clear out associated status.
|
|
|
235 (if leave-dead
|
|
|
236 nil
|
|
|
237 (if server-process
|
|
|
238 (server-log (message "Restarting server")))
|
|
|
239 (setq server-string "")
|
|
|
240 (setq current-client nil)
|
|
|
241 (let ((process-connection-type t))
|
|
|
242 (setq server-process
|
|
|
243 (start-process "server" nil server-program)))
|
|
|
244 (set-process-sentinel server-process 'server-sentinel)
|
|
|
245 (set-process-filter server-process 'server-process-filter)
|
|
|
246 (process-kill-without-query server-process)))
|
|
|
247
|
|
|
248 ;; make gnuserv-start an alias to server-start, for backward compatibility
|
|
|
249 (fset 'server-start (function gnuserv-start))
|
|
|
250
|
|
114
|
251 ; Can gnuserv handle commands in close succesion? (See server.el line 283) JV
|
|
0
|
252 (defun server-write-to-client (client form)
|
|
|
253 "Write the given form to the given client via the server process."
|
|
|
254 (if (and client
|
|
|
255 (eq (process-status server-process) 'run))
|
|
|
256 (let* ((result (format "%s" form))
|
|
|
257 (s (format "%s/%d:%s\n" client (length result) result)))
|
|
|
258 (process-send-string server-process s)
|
|
|
259 (server-log s))))
|
|
|
260
|
|
|
261 (defun server-eval (form)
|
|
|
262 "Evaluate form and return result to client."
|
|
|
263 (server-write-to-client current-client (eval form))
|
|
|
264 (setq current-client nil))
|
|
|
265
|
|
|
266
|
|
|
267 (defun server-eval-quickly (form)
|
|
|
268 "Let client know that we've received the request, but eval the form
|
|
|
269 afterwards in order to not keep the client waiting."
|
|
|
270 (server-write-to-client current-client nil)
|
|
|
271 (setq current-client nil)
|
|
|
272 (eval form))
|
|
|
273
|
|
|
274 (defun server-make-window-visible ()
|
|
|
275 "Try to make this window even more visible."
|
|
70
|
276 (cond
|
|
|
277 ;; XEmacs can (in theory) raise any kind of frame
|
|
|
278 ((fboundp 'raise-frame)
|
|
|
279 (raise-frame (selected-frame)))
|
|
|
280 ((not (and (boundp 'window-system) window-system))
|
|
|
281 nil)
|
|
|
282 ((fboundp 'deiconify-screen)
|
|
|
283 (deiconify-screen (selected-screen))
|
|
|
284 (raise-screen (selected-screen)))
|
|
|
285 ((fboundp 'mapraised-screen)
|
|
|
286 (mapraised-screen))
|
|
|
287 ((fboundp 'x-remap-window)
|
|
|
288 (x-remap-window)
|
|
|
289 ;; give window chance to re-display text
|
|
|
290 (accept-process-output))))
|
|
0
|
291
|
|
108
|
292 (defun server-tty-find-file (tty termtype pid file)
|
|
|
293 (let ((device (make-tty-device tty termtype pid )))
|
|
0
|
294 (select-frame (make-frame nil device))
|
|
|
295 (if (not file)
|
|
|
296 (switch-to-buffer (get-buffer-create "*scratch*"))
|
|
114
|
297 (find-file file)))
|
|
|
298 (run-hooks 'server-visit-hook))
|
|
0
|
299
|
|
|
300 (defun server-find-file (file)
|
|
|
301 "Edit file FILENAME.
|
|
|
302 Switch to a buffer visiting file FILENAME,
|
|
|
303 creating one if none already exists."
|
|
|
304 (let ((obuf (get-file-buffer file))
|
|
|
305 ;; XEmacs addition.
|
|
|
306 (force-dialog-box-use t))
|
|
|
307 (if (and obuf (set-buffer obuf))
|
|
|
308 (if (file-exists-p file)
|
|
|
309 (if (or (not (verify-visited-file-modtime obuf))
|
|
|
310 (buffer-modified-p obuf))
|
|
|
311 (revert-buffer t nil))
|
|
|
312 (if (y-or-n-p
|
|
|
313 (concat "File no longer exists: "
|
|
|
314 file
|
|
|
315 ", write buffer to file? "))
|
|
|
316 (write-file file))))
|
|
|
317 (cond ((and window-system
|
|
|
318 gnuserv-frame (fboundp 'frame-live-p) ;; v19 & XEmacs 19.12+
|
|
|
319 (frame-live-p gnuserv-frame))
|
|
|
320 (select-frame gnuserv-frame)
|
|
|
321 (find-file file))
|
|
|
322
|
|
|
323 ((and window-system
|
|
|
324 gnuserv-frame (fboundp 'live-screen-p) ;; XEmacs 19.9+
|
|
|
325 (live-screen-p gnuserv-frame))
|
|
|
326 (select-screen gnuserv-frame)
|
|
|
327 (find-file file))
|
|
|
328
|
|
|
329 ((and window-system
|
|
|
330 (fboundp 'select-frame)) ;; v19 & XEmacs 19.12+
|
|
|
331 (select-frame (make-frame))
|
|
|
332 (find-file file))
|
|
|
333
|
|
|
334 ((and window-system
|
|
|
335 (fboundp 'select-screen) ;; XEmacs 19.10+
|
|
|
336 (fboundp 'make-screen))
|
|
|
337 (select-screen (make-screen))
|
|
|
338 (find-file file))
|
|
|
339
|
|
|
340 ((and (eq window-system 'x) ;; XEmacs 19.9-
|
|
|
341 (fboundp 'select-screen)
|
|
|
342 (fboundp 'x-create-screen))
|
|
|
343 (select-screen (x-create-screen nil))
|
|
|
344 (find-file file))
|
|
|
345
|
|
|
346 ((and window-system
|
|
|
347 (fboundp 'create-screen)) ;; epoch
|
|
|
348 (if (screenp gnuserv-frame)
|
|
|
349 (progn (select-screen gnuserv-frame)
|
|
|
350 (find-file file))
|
|
|
351 (select-screen (create-screen (find-file-noselect file)))))
|
|
|
352
|
|
114
|
353 (t (find-file file)))) ;; emacs18+
|
|
|
354 (run-hooks 'server-visit-hook))
|
|
0
|
355
|
|
|
356
|
|
|
357 (defun server-edit-files-quickly (list)
|
|
|
358 "For each (line-number . file) pair in LIST, edit the file at line-number.
|
|
|
359 Unlike (server-edit-files), no information is saved about clients waiting on
|
|
|
360 edits to this buffer."
|
|
|
361 (server-write-to-client current-client nil)
|
|
|
362 (setq current-client nil)
|
|
|
363 (while list
|
|
|
364 (let ((line (car (car list)))
|
|
|
365 (path (cdr (car list))))
|
|
|
366 (server-find-file path)
|
|
|
367 (server-make-window-visible)
|
|
|
368 (goto-line line))
|
|
|
369 (setq list (cdr list))))
|
|
|
370
|
|
|
371
|
|
|
372 (defun server-edit-files (list)
|
|
|
373 "For each (line-number . file) pair in LIST, edit the file at line-number.
|
|
|
374 Save enough information for (server-kill-buffer) to inform the client when
|
|
|
375 the edit is finished."
|
|
|
376 (while list
|
|
|
377 (let ((line (car (car list)))
|
|
|
378 (path (cdr (car list))))
|
|
|
379 (server-find-file path)
|
|
|
380 (server-make-window-visible)
|
|
|
381 (let ((old-clients (assq current-client server-clients))
|
|
|
382 (buffer (current-buffer)))
|
|
|
383 (goto-line line)
|
|
|
384 (setq server-buffer-clients
|
|
|
385 (cons current-client server-buffer-clients))
|
|
|
386 (if old-clients ;client already waiting for buffers?
|
|
|
387 (nconc old-clients (list buffer)) ;yes -- append this one as well
|
|
|
388 (setq server-clients ;nope -- make a new record
|
|
|
389 (cons (list current-client buffer)
|
|
|
390 server-clients)))))
|
|
|
391 (setq list (cdr list)))
|
|
|
392 (message (substitute-command-keys
|
|
|
393 (if (and (boundp 'infodock-version) window-system)
|
|
|
394 "Type {\\[server-edit]} or select Frame/Delete to finish edit."
|
|
|
395 "When done with a buffer, type \\[server-edit]."))))
|
|
|
396
|
|
108
|
397 (defun server-tty-edit-files (tty termtype pid list)
|
|
0
|
398 "For each (line-number . file) pair in LIST, edit the file at line-number.
|
|
|
399 Save enough information for (server-kill-buffer) to inform the client when
|
|
|
400 the edit is finished."
|
|
|
401 (or list (setq list '((1 . nil))))
|
|
|
402 (while list
|
|
|
403 (let ((line (car (car list)))
|
|
|
404 (path (cdr (car list))))
|
|
108
|
405 (server-tty-find-file tty termtype pid path)
|
|
0
|
406 (server-make-window-visible)
|
|
|
407 (let ((old-clients (assq current-client server-clients))
|
|
|
408 (buffer (current-buffer)))
|
|
|
409 (goto-line line)
|
|
|
410 (setq server-buffer-clients
|
|
|
411 (cons current-client server-buffer-clients))
|
|
|
412 (if old-clients ;client already waiting for buffers?
|
|
|
413 (nconc old-clients (list buffer)) ;yes -- append this one as well
|
|
|
414 (setq server-clients ;nope -- make a new record
|
|
|
415 (cons (list current-client buffer)
|
|
|
416 server-clients)))))
|
|
|
417 (setq list (cdr list)))
|
|
|
418 (message (substitute-command-keys
|
|
|
419 (if (and (boundp 'infodock-version) window-system)
|
|
|
420 "Type {\\[server-edit]} or select Frame/Delete to finish edit."
|
|
|
421 "When done with a buffer, type \\[server-edit]."))))
|
|
|
422
|
|
|
423 (defun server-get-buffer (buffer)
|
|
|
424 "One arg, a BUFFER or a buffer name. Return the buffer object even if killed.
|
|
|
425 Signal an error if there is no record of BUFFER."
|
|
|
426 (if (null buffer)
|
|
|
427 (current-buffer)
|
|
|
428 (let ((buf (get-buffer buffer)))
|
|
|
429 (if (null buf)
|
|
|
430 (if (bufferp buffer)
|
|
|
431 buffer
|
|
|
432 (if (stringp buffer)
|
|
|
433 (error "No buffer named %s" buffer)
|
|
|
434 (error "Invalid buffer argument")))
|
|
|
435 buf))))
|
|
|
436
|
|
|
437 (defun server-kill-buffer (buffer)
|
|
|
438 "Kill the BUFFER. The argument may be a buffer object or buffer name.
|
|
|
439 NOTE: This function has been enhanced to allow for remote editing
|
|
|
440 in the following way:
|
|
|
441
|
|
|
442 If the buffer is waited upon by one or more clients, and a client is
|
|
|
443 not waiting for other buffers to be killed, then the client is told
|
|
|
444 that the buffer has been killed."
|
|
|
445 (interactive "bKill buffer ")
|
|
|
446 (setq buffer (server-get-buffer buffer))
|
|
|
447 (if (buffer-name buffer)
|
|
|
448 (save-excursion
|
|
|
449 (set-buffer buffer)
|
|
|
450 (let ((old-clients server-clients))
|
|
|
451 (server-real-kill-buffer buffer) ;try to kill it
|
|
|
452 (if (buffer-name buffer) ;succeeded in killing?
|
|
|
453 nil ;nope
|
|
|
454 (while old-clients
|
|
|
455 (let ((client (car old-clients)))
|
|
|
456 (delq buffer client)
|
|
|
457 (if (cdr client) ;pending buffers?
|
|
|
458 nil ;yep
|
|
|
459 (server-write-to-client (car client) nil) ;nope, tell client
|
|
|
460 (setq server-clients (delq client server-clients))))
|
|
70
|
461 (setq old-clients (cdr old-clients))))))))
|
|
36
|
462
|
|
|
463
|
|
114
|
464 ;; Ask before killing a server buffer.
|
|
|
465 ;; It was suggested to release its client instead,
|
|
|
466 ;; but I think that is dangerous--the client would proceed
|
|
|
467 ;; using whatever is on disk in that file. -- rms.
|
|
|
468 (defun server-kill-buffer-query-function ()
|
|
|
469 (or server-kill-quietly
|
|
|
470 (not server-buffer-clients)
|
|
|
471 (yes-or-no-p (format "Buffer `%s' still has clients; kill it? "
|
|
|
472 (buffer-name (current-buffer))))))
|
|
|
473
|
|
|
474 (add-hook 'kill-buffer-query-functions
|
|
|
475 'server-kill-buffer-query-function)
|
|
|
476
|
|
|
477 (defun server-kill-emacs-query-function ()
|
|
|
478 (let (live-client
|
|
|
479 (tail server-clients))
|
|
|
480 ;; See if any clients have any buffers that are still alive.
|
|
|
481 (while tail
|
|
|
482 (if (memq t (mapcar 'stringp (mapcar 'buffer-name (cdr (car tail)))))
|
|
|
483 (setq live-client t))
|
|
|
484 (setq tail (cdr tail)))
|
|
|
485 (or server-kill-quietly
|
|
|
486 (not live-client)
|
|
|
487 (yes-or-no-p "Server buffers still have clients; exit anyway? "))))
|
|
|
488
|
|
|
489 (add-hook 'kill-emacs-query-functions 'server-kill-emacs-query-function)
|
|
|
490
|
|
|
491
|
|
0
|
492 (defun server-kill-all-local-variables ()
|
|
|
493 "Eliminate all the buffer-local variable values of the current buffer.
|
|
|
494 This buffer will then see the default values of all variables.
|
|
|
495 NOTE: This function has been modified to ignore the variable
|
|
|
496 server-buffer-clients."
|
|
|
497 (let ((clients server-buffer-clients))
|
|
|
498 (server-real-kill-all-local-variables)
|
|
|
499 (if clients
|
|
|
500 (setq server-buffer-clients clients))))
|
|
|
501
|
|
|
502
|
|
|
503 (or (fboundp 'server-real-kill-buffer)
|
|
|
504 (fset 'server-real-kill-buffer (symbol-function 'kill-buffer)))
|
|
|
505
|
|
|
506 (fset 'kill-buffer 'server-kill-buffer)
|
|
|
507
|
|
|
508 (or (fboundp 'server-real-kill-all-local-variables)
|
|
|
509 (fset 'server-real-kill-all-local-variables
|
|
|
510 (symbol-function 'kill-all-local-variables)))
|
|
|
511
|
|
|
512 (fset 'kill-all-local-variables 'server-kill-all-local-variables)
|
|
|
513
|
|
|
514
|
|
|
515 (defun server-buffer-done (buffer)
|
|
|
516 "Mark BUFFER as \"done\" for its client(s).
|
|
|
517 Buries the buffer, and returns another server buffer as a suggestion for the
|
|
|
518 new current buffer."
|
|
114
|
519 ; Note we do NOT return a list with a killed flag, doesn't seem usefull to me. JV
|
|
0
|
520 (let ((next-buffer nil)
|
|
|
521 (old-clients server-clients))
|
|
|
522 (while old-clients
|
|
|
523 (let ((client (car old-clients)))
|
|
|
524 (or next-buffer
|
|
|
525 (setq next-buffer (nth 1 (memq buffer client))))
|
|
|
526 (delq buffer client)
|
|
114
|
527 ;; Delete all dead buffers from CLIENT. (Why? JV , copyed from server.el)
|
|
|
528 (let ((tail client))
|
|
|
529 (while tail
|
|
|
530 (and (bufferp (car tail))
|
|
|
531 (null (buffer-name (car tail)))
|
|
|
532 (delq (car tail) client))
|
|
|
533 (setq tail (cdr tail))))
|
|
0
|
534 ;; If client now has no pending buffers,
|
|
|
535 ;; tell it that it is done, and forget it entirely.
|
|
|
536 (if (cdr client)
|
|
|
537 nil
|
|
108
|
538 (if (buffer-name buffer)
|
|
|
539 (save-excursion
|
|
|
540 (set-buffer buffer)
|
|
114
|
541 (setq server-buffer-clients nil)
|
|
|
542 (run-hooks 'server-done-hook)))
|
|
108
|
543 ; Order is important here --
|
|
|
544 ; server-kill-buffer tries to notify clients that
|
|
|
545 ; they are done, too, but if we try and notify twice,
|
|
|
546 ; we are h0zed -- Hunter Kelly 3/3/97
|
|
|
547 (setq server-clients (delq client server-clients))
|
|
114
|
548 (if (server-temp-file-p buffer)
|
|
|
549 (funcall server-done-temp-file-function buffer)
|
|
|
550 (funcall server-done-function buffer))
|
|
108
|
551 (server-write-to-client (car client) nil)))
|
|
0
|
552 (setq old-clients (cdr old-clients)))
|
|
|
553 next-buffer))
|
|
|
554
|
|
|
555
|
|
|
556 (defun mh-draft-p (buffer)
|
|
|
557 "Return non-nil if this BUFFER is an mh <draft> file. Since MH deletes
|
|
|
558 draft *BEFORE* it is edited, the server treats them specially."
|
|
|
559 ;; This may not be appropriately robust for all cases.
|
|
|
560 (string= (buffer-name buffer) "draft"))
|
|
|
561
|
|
|
562
|
|
|
563 (defun server-done ()
|
|
|
564 "Offer to save current buffer and mark it as \"done\" for clients.
|
|
|
565 Also bury it, and return a suggested new current buffer."
|
|
|
566 (let ((buffer (current-buffer)))
|
|
|
567 (if server-buffer-clients
|
|
|
568 (progn
|
|
114
|
569 (if (mh-draft-p buffer);; Does this comflict with temp-file ? JV
|
|
0
|
570 (progn (save-buffer)
|
|
|
571 (write-region (point-min) (point-max)
|
|
|
572 (concat buffer-file-name "~"))
|
|
|
573 (kill-buffer buffer))
|
|
114
|
574 (if (server-temp-file-p buffer)
|
|
|
575 ;; For a temp file, save, and do NOT make a non-numeric backup
|
|
|
576 ;; Why does server.el explicitly back up temporary files?
|
|
|
577 (let ((version-control nil)
|
|
|
578 (buffer-backed-up (not server-make-temp-file-backup)))
|
|
|
579 (save-buffer))
|
|
|
580 (if (and (buffer-modified-p)
|
|
|
581 (y-or-n-p (concat "Save file " buffer-file-name "? ")))
|
|
|
582 (save-buffer buffer))))
|
|
0
|
583 (server-buffer-done buffer)))))
|
|
|
584
|
|
|
585
|
|
|
586 (defun server-edit (&optional arg)
|
|
114
|
587 "Switch to next server editing
|
|
|
588 buffer and mark current one as \"done\". If a server buffer is
|
|
|
589 current, it is marked \"done\" and optionally saved. MH <draft> files
|
|
|
590 are always saved and backed up, no questions asked. Files that match
|
|
|
591 server-temp-file-regexp are considered temporary and are saved
|
|
|
592 unconditionally and
|
|
|
593 backed up if server-make-temp-file-backup is non-nil. When all of a
|
|
|
594 client's buffers are marked as \"done\", the client is notified.
|
|
0
|
595
|
|
|
596 If invoked with a prefix argument, or if there is no server process running,
|
|
78
|
597 starts server process and that is all. Invoked by \\[server-edit].
|
|
|
598
|
|
|
599 If `server-kill-last-frame' is t, then the final frame will be killed."
|
|
0
|
600 (interactive "P")
|
|
|
601 (if (or arg
|
|
|
602 (not server-process)
|
|
|
603 (memq (process-status server-process) '(signal exit)))
|
|
|
604 (server-start nil)
|
|
|
605 (if server-buffer-clients
|
|
114
|
606 (progn (server-done-and-switch)
|
|
2
|
607 (cond ((fboundp 'console-type) ;; XEmacs 19.14+
|
|
|
608 (or (and (equal (console-type) 'x)
|
|
|
609 gnuserv-frame
|
|
|
610 (frame-live-p gnuserv-frame))
|
|
|
611 (condition-case ()
|
|
78
|
612 (delete-frame (selected-frame)
|
|
|
613 server-kill-last-frame)
|
|
2
|
614 (error
|
|
|
615 (message "Not deleting last visible frame...")))))
|
|
|
616 ((or (not window-system)
|
|
0
|
617 (and gnuserv-frame
|
|
|
618 (or (and (fboundp 'frame-live-p)
|
|
|
619 (frame-live-p gnuserv-frame))
|
|
|
620 (and (fboundp 'live-screen-p)
|
|
|
621 (live-screen-p gnuserv-frame))
|
|
|
622 (and (fboundp 'create-screen)
|
|
|
623 (screenp gnuserv-frame)))))
|
|
|
624 ()) ;; do nothing
|
|
|
625 ((fboundp 'delete-frame)
|
|
|
626 (delete-frame (selected-frame) t))
|
|
|
627 ((fboundp 'delete-screen)
|
|
|
628 (delete-screen))))
|
|
|
629 (error
|
|
|
630 "(server-edit): Use only on buffers created by external programs.")
|
|
|
631 )))
|
|
|
632
|
|
114
|
633 (defun server-switch-buffer-internal (next-buffer always)
|
|
0
|
634 "Switch to NEXT-BUFFER if a live buffer, otherwise switch to another buffer
|
|
114
|
635 with gnuserv clients. If no such buffer is available, we switch to
|
|
|
636 another normal buffer if `always' is non-nil!"
|
|
|
637 ;; switching
|
|
0
|
638 (if next-buffer
|
|
|
639 (if (and (bufferp next-buffer)
|
|
|
640 (buffer-name next-buffer))
|
|
|
641 (switch-to-buffer next-buffer)
|
|
|
642 ;; If NEXT-BUFFER is a dead buffer,
|
|
|
643 ;; remove the server records for it
|
|
|
644 ;; and try the next surviving server buffer.
|
|
114
|
645 (server-switch-buffer-internal
|
|
|
646 (server-buffer-done next-buffer) always))
|
|
|
647 (if server-clients
|
|
|
648 (server-switch-buffer-internal (nth 1 (car server-clients)) always)
|
|
|
649 (if always
|
|
|
650 (switch-to-buffer (other-buffer))))))
|
|
|
651
|
|
|
652 ;; For compatability
|
|
|
653 (defun server-switch-buffer (next-buffer)
|
|
|
654 (server-switch-buffer-internal next-buffer t))
|
|
|
655
|
|
|
656 ;; The below function calles server-done and switches to the next
|
|
|
657 ;; sensible buffer. This implementation works regardless of the values
|
|
|
658 ;; of server-*-function and doens't need the tail recursion
|
|
|
659 ;; variable passing of server.el. It is more transparant too. JV
|
|
|
660 (defun server-done-and-switch ()
|
|
|
661 "Be done with the current buffer and switch to another server buffer
|
|
|
662 if there is one, otherwise just switch buffer"
|
|
|
663 (let ((old-current (current-buffer)))
|
|
|
664 (server-switch-buffer-internal (server-done) nil)
|
|
|
665 (if (eq old-current (current-buffer))
|
|
|
666 (switch-to-buffer (other-buffer)))))
|
|
0
|
667
|
|
|
668 (global-set-key "\C-x#" 'server-edit)
|
|
|
669
|
|
|
670 (provide 'gnuserv)
|
|
|
671
|
|
78
|
672 ;;; gnuserv.el ends here
|
