emacs: lisp/emulation/viper-ex.el comparison

comparison lisp/emulation/viper-ex.el @ 49598:0d8b17d428b5

Trailing whitepace deleted.

author	Juanma Barranquero <lekktu@gmail.com>
date	Tue, 04 Feb 2003 13:24:35 +0000
parents	4884a0e6069c
children	695cf19ef79e d7ddb3e565de

comparison

equal deleted inserted replaced

-:e88404e8f2cf
+:0d8b17d428b5
 	("su"			"substitute")
 	("sub"			"substitute")
 	("set"			(ex-set))
 	("shell"		(ex-shell))
 	("source"		(ex-source))
 	("stop"			(suspend-emacs))
 	("sr"			(ex-substitute t t))
 	("submitReport"	    	(viper-submit-report))
 	("substitute"	    	(ex-substitute) is-mashed)
 	("suspend"		(suspend-emacs))
 	("t"			"transfer")
 	("undo"			(viper-undo))
 	("unmap"		(ex-unmap))
 	("v"			"vglobal")
 	("version"		(viper-version))
 	("vglobal"		(ex-global t) is-mashed)
 	("visual"		(ex-edit))
 	("w"			"write")
 	("wq"			(ex-write t))
 	("write"		(ex-write nil))
 	("xit"			(ex-write t))
 	("yank"			(ex-yank))
 result
 ))
 ;; A-list of Ex variables that can be set using the :set command.
 (defconst ex-variable-alist
 '(("wrapscan") ("ws") ("wrapmargin") ("wm")
 ("tabstop-global") ("ts-g") ("tabstop") ("ts")
 ("showmatch") ("sm") ("shiftwidth") ("sw") ("shell") ("sh")
 ("readonly") ("ro")
 ("nowrapscan") ("nows") ("noshowmatch") ("nosm")
 ("noreadonly") ("noro") ("nomagic") ("noma")
 ("noignorecase") ("noic")
 ("noautoindent-global") ("noai-g") ("noautoindent") ("noai")
 ("magic") ("ma") ("ignorecase") ("ic")
 ("autoindent-global") ("ai-g") ("autoindent") ("ai")
 ("all")
 ))
 ;; Token recognized during parsing of Ex commands (e.g., "read", "comma")
 (defvar ex-token nil)
 ;; Type of token.
 ;; If non-nil, gives type of address; if nil, it is a command.
 (defvar ex-token-type nil)
 ;; List of addresses passed to Ex command
 (defvar ex-addresses nil)
 	(cond ((string-match "\\(csh$\\|csh.exe$\\)" shell-file-name)
 	       "-f") ; csh: do it fast
 	      ((string-match "\\(bash$\\|bash.exe$\\)" shell-file-name)
 	       "-noprofile") ; bash: ignore .profile
 	      )))
 "Options to pass to the Unix-style shell.
 Don't put `-c' here, as it is added automatically."
 :type '(choice (const nil) string)
 :group 'viper-ex)
 (defcustom ex-compile-command "make"
 	)
 "Expand the file spec containing wildcard symbols.
 The default tries to set this variable to work with Unix, Windows,
 OS/2, and VMS.
 However, if it doesn't work right for some types of Unix shells or some OS,
 the user should supply the appropriate function and set this variable to the
 corresponding function symbol."
 :type 'symbol
 :group 'viper-ex)
 ;; File containing the shell command to be executed at Ex prompt,
 ;; e.g., :r !date
 (defvar ex-cmdfile nil)
 (defvar ex-cmdfile-args "")
 ;; flag used in viper-ex-read-file-name to indicate that we may be reading
 ;; multiple file names.  Used for :edit and :next
 (defvar viper-keep-reading-filename nil)
 (defcustom ex-cycle-other-window t
 :type 'boolean
 :group 'viper-ex)
 ;; Last shell command executed with :! command.
 (defvar viper-ex-last-shell-com nil)
 ;; Indicates if Minibuffer was exited temporarily in Ex-command.
 (defvar viper-incomplete-ex-cmd nil)
 ;; Remembers the last ex-command prompt.
 (defvar viper-last-ex-prompt "")
 ;; Get a complete ex command
 ;; Get an ex-token which is either an address or a command.
 ;; A token has a type, \(command, address, end-mark\), and a value
 (defun viper-get-ex-token ()
 (save-window-excursion
 (setq viper-ex-work-buf (get-buffer-create viper-ex-work-buf-name))
 (set-buffer viper-ex-work-buf)
 (skip-chars-forward " \t|")
 (let ((case-fold-search t))
 (cond ((looking-at "#")
 	     (setq ex-token-type 'command)
 		     ;; w ! assumes that the next one is a shell command
 		     "\\|" "\\(w\\|wr\\|wri\\|writ.?\\)[ \t]+!"
 		     "\\|" "![ \t]*[a-zA-Z].*"
 		     "\\)"
 		     "!*")))
 (save-window-excursion ;; put cursor at the end of the Ex working buffer
 (setq viper-ex-work-buf (get-buffer-create viper-ex-work-buf-name))
 (set-buffer viper-ex-work-buf)
 (goto-char (point-max)))
 (cond ((viper-looking-back quit-regex1) (exit-minibuffer))
 	  ((viper-looking-back stay-regex)  (insert " "))
 	  ((viper-looking-back quit-regex2) (exit-minibuffer))
 	  (t (insert " ")))))
 ;; complete Ex command
 (defun ex-cmd-complete ()
 (interactive)
 (let (save-pos dist compl-list string-to-complete completion-result)
 (save-excursion
 (setq dist (skip-chars-backward "[a-zA-Z!=>&~]")
 	    save-pos (point)))
 (if (or (= dist 0)
 	    (viper-looking-back "\\([ \t]*['`][ \t]*[a-z]*\\)")
 	    (viper-looking-back
 	     "^[ \t]*[a-zA-Z!=>&~][ \t]*[/?]*[ \t]+[a-zA-Z!=>&~]+"))
 	;; Preceding characters are not the ones allowed in an Ex command
 	;; Note: we didn't do parsing, so there can be surprises.
 	(if (or (viper-looking-back "[a-zA-Z!=>&~][ \t]*[/?]*[ \t]*")
 		(viper-looking-back "\\([ \t]*['`][ \t]*[a-z]*\\)")
 		(looking-at "[^ \t\n\C-m]"))
 	    nil
 	  (with-output-to-temp-buffer "*Completions*"
 	    (display-completion-list
 	     (viper-alist-to-list ex-token-alist))))
 ;; Preceding chars may be part of a command name
 (setq string-to-complete (buffer-substring save-pos (point)))
 (setq completion-result
 	    (try-completion string-to-complete ex-token-alist))
 (cond ((eq completion-result t)  ; exact match--do nothing
 	     (viper-tmp-insert-at-eob " (Sole completion)"))
 	    ((eq completion-result nil)
 	     (viper-tmp-insert-at-eob " (No match)"))
 	    (t  ;; partial completion
 	     (let (case-fold-search)
 	       (setq compl-list
 		     (viper-filter-alist (concat "^" completion-result)
 				       ex-token-alist)))
 	     (if (> (length compl-list) 1)
 		 (with-output-to-temp-buffer "*Completions*"
 		   (display-completion-list
 		    (viper-alist-to-list (reverse compl-list)))))))
 )))
 ;; Read Ex commands
 ;; ARG is a prefix argument. If given, the ex command runs on the region
 ;;(without the user having to specify the address :a,b
 ;; STRING is the command to execute. If nil, then Viper asks you to enter the
 ;; command.
 (defun viper-ex (arg &optional string)
 (interactive "P")
 (or string
 (setq ex-g-flag nil
 	    ex-g-variant nil))
 	    (setq reg-beg-line (1+ (count-lines (point-min) (point)))
 		  reg-end-line
 		  (+ reg-beg-line (count-lines reg-beg reg-end) -1)))))
 (if reg-beg-line
 	(setq initial-str (format "%d,%d" reg-beg-line reg-end-line)))
 (setq com-str
 	  (or string (viper-read-string-with-history
 		      ":"
 		      initial-str
 		      'viper-ex-history
 		      ;; no default when working on region
 		      (if initial-str
 			  nil
 		      map
 		      (if initial-str
 			  " [Type command to execute on current region]"))))
 (save-window-excursion
 ;; just a precaution
 (setq viper-ex-work-buf (get-buffer-create viper-ex-work-buf-name))
 (set-buffer viper-ex-work-buf)
 (delete-region (point-min) (point-max))
 (insert com-str "\n")
 (goto-char (point-min)))
 (setq ex-token-type nil
 	     (setq ex-addresses
 		   (cons (if (null address) (point) address) ex-addresses)))
 	    (t (let ((ans (viper-get-ex-address-subr address dot)))
 		 (if ans (setq address ans)))))
 (setq prev-token-type ex-token-type))))
 ;; Get a regular expression and set `ex-variant', if found
 ;; Viper doesn't parse the substitution or search patterns.
 ;; In particular, it doesn't expand ~ into the last substitution.
 (defun viper-get-ex-pat ()
 c)))
 ;; Get an Ex option g or c
 (defun viper-get-ex-opt-gc (c)
 (save-window-excursion
 (setq viper-ex-work-buf (get-buffer-create viper-ex-work-buf-name))
 (set-buffer viper-ex-work-buf)
 (if (looking-at (format "%c" c)) (forward-char 1))
 (skip-chars-forward " \t")
 (cond ((looking-at "g")
 	   (setq ex-token "g")
 	     (setq address (point-marker))))
 	  ((eq ex-token-type 'goto-mark)
 	   (save-excursion
 	     (if (null ex-token)
 		 (exchange-point-and-mark)
 	       (goto-char
 		(viper-register-to-point
 		 (viper-int-to-char (1+ (- ex-token ?a))) 'enforce-buffer)))
 	     (setq address (point-marker)))))
 address))
 (defun viper-get-ex-buffer ()
 (setq ex-buffer nil)
 (setq ex-count nil)
 (setq ex-flag nil)
 (save-window-excursion
 (setq viper-ex-work-buf (get-buffer-create viper-ex-work-buf-name))
 (set-buffer viper-ex-work-buf)
 (skip-chars-forward " \t")
 (if (looking-at "[a-zA-Z]")
 	(progn
 	  (setq ex-buffer (following-char))
 (defun viper-get-ex-count ()
 (setq ex-variant nil
 	ex-count nil
 	ex-flag nil)
 (save-window-excursion
 (setq viper-ex-work-buf (get-buffer-create viper-ex-work-buf-name))
 (set-buffer viper-ex-work-buf)
 (skip-chars-forward " \t")
 (if (looking-at "!")
 	(progn
 	  (setq ex-variant t)
 		(point-min) (1- (point-max))) viper-BadExCommand))))
 ;; Expand \% and \# in ex command
 (defun ex-expand-filsyms (cmd buf)
 (let (cf pf ret)
 (save-excursion
 (set-buffer buf)
 (setq cf buffer-file-name)
 (setq pf (ex-next nil t))) ; this finds alternative file name
 (if (and (null cf) (string-match "[^\\]%\\|\\`%" cmd))
 	(error "No current file to substitute for `%%'"))
 (set-buffer (get-buffer-create viper-ex-tmp-buf-name))
 (erase-buffer)
 (insert cmd)
 (goto-char (point-min))
 (while (re-search-forward "%\\|#" nil t)
 	(let ((data (match-data))
 	      (char (buffer-substring (match-beginning 0) (match-end 0))))
 	  (if (viper-looking-back (concat "\\\\" char))
 	      (replace-match char)
 	    (store-match-data data)
 	    (if (string= char "%")
 	  ex-offset nil
 	  ex-cmdfile nil
 	  ex-cmdfile-args "")
 (save-excursion
 (save-window-excursion
 	(setq viper-ex-work-buf (get-buffer-create viper-ex-work-buf-name))
 	(set-buffer viper-ex-work-buf)
 	(skip-chars-forward " \t")
 	(if (looking-at "!")
 	    (if (and (not (viper-looking-back "[ \t]"))
 		     ;; read doesn't have a corresponding :r! form, so ! is
 	      ))
 	(goto-char (point-max))
 	(skip-chars-backward " \t\n")
 	(setq prompt (buffer-substring (point-min) (point)))
 	))
 (setq viper-last-ex-prompt prompt)
 ;; If we just finished reading command, redisplay prompt
 (if viper-incomplete-ex-cmd
 	(setq ex-file (viper-ex-read-file-name (format ":%s " prompt)))
 ;; file was typed in-line
 (setq ex-file (or ex-file "")))
 ;; Completes file name or exits minibuffer.  If Ex command accepts multiple
 ;; file names, arranges to re-enter the minibuffer.
 (defun viper-complete-filename-or-exit ()
 (interactive)
 (setq viper-keep-reading-filename t)
 ;; don't exit if directory---ex-commands don't
 (cond ((ex-cmd-accepts-multiple-files-p ex-token) (exit-minibuffer))
 	;; apparently the argument to an Ex command is
 	;; supposed to be a shell command
 	((viper-looking-back "^[ \t]*!.*")
 	 (setq ex-cmdfile t)
 (defun viper-ex-read-file-name (prompt)
 (let* ((str "")
 	 (minibuffer-local-completion-map
 	  (copy-keymap minibuffer-local-completion-map))
 	 beg end cont val)
 (viper-add-keymap ex-read-filename-map
 		    (if viper-emacs-p
 			minibuffer-local-completion-map
 		      read-file-name-map))
 (setq cont (setq viper-keep-reading-filename t))
 (while cont
 (setq viper-keep-reading-filename nil
 	    val (read-file-name (concat prompt str) nil default-directory))
 (setq val (expand-file-name val))
 (if (and (string-match " " val)
 	       (ex-cmd-accepts-multiple-files-p ex-token))
 	  (setq val (concat "\"" val "\"")))
 (setq str  (concat str (if (equal val "") "" " ")
 			 val (if (equal val "") "" " ")))
 ;; Only edit, next, and Next commands accept multiple files.
 ;; viper-keep-reading-filename is set in the anonymous function that is
 ;; bound to " " in ex-read-filename-map.
 (setq cont (and viper-keep-reading-filename
 		      (ex-cmd-accepts-multiple-files-p ex-token)))
 )
 (setq beg (string-match "[^ \t]" str)   ; delete leading blanks
 	  end (string-match "[ \t]*$" str)) ; delete trailing blanks
 (if (member ex-token '("read" "write"))
 	  (if (string-match "[\t ]*!" str)
 	      ;; this is actually a shell command
 (substring str (or beg 0) end)))
 (defun viper-undisplayed-files ()
 (mapcar
 (lambda (b)
 (if (null (get-buffer-window b))
 	 (let ((f (buffer-file-name b)))
 	   (if f f
 	     (if ex-cycle-through-non-files
 		 (let ((s (buffer-name b)))
 		   (if (string= " " (substring s 0 1))
 		       nil
 		     s))
 	       nil)))
 (defun ex-args ()
 (let ((l (viper-undisplayed-files))
 	(args "")
 	(file-count 1))
 (while (not (null l))
 (if (car l)
 	  (setq args (format "%s %d) %s\n" args file-count (car l))
 		file-count (1+ file-count)))
 (setq l (cdr l)))
 (if (string= args "")
 	(message "All files are already displayed")
 (viper-get-ex-file))
 (cond ((and (string= ex-file "") buffer-file-name)
 	 (setq ex-file  (viper-abbreviate-file-name (buffer-file-name))))
 	((string= ex-file "")
 	 (error viper-NoFileSpecified)))
 (let (msg do-edit)
 (if buffer-file-name
 	(cond ((buffer-modified-p)
 	       (setq msg
 		     (format "Buffer %s is modified.  Discard changes? "
 	       (setq msg
 		     (format "File %s changed on disk.  Reread from disk? "
 			     buffer-file-name)
 		     do-edit t))
 	      (t (setq do-edit nil))))
 (if do-edit
 	(if (yes-or-no-p msg)
 	    (progn
 	      (set-buffer-modified-p nil)
 	      (kill-buffer (current-buffer)))
 	  (message "Buffer %s was left intact" (buffer-name))))
 ) ; let
 (if (null (setq file (get-file-buffer ex-file)))
 (progn
 	;; this also does shell-style globbing
 	(ex-find-file
 	 ;; replace # and % with the previous/current file
 	 (ex-expand-filsyms ex-file (current-buffer)))
 	(or (eq major-mode 'dired-mode)
 	(goto-char (point-min)))
 (switch-to-buffer file))
 (if ex-offset
 (progn
 	(save-window-excursion
 	  (setq viper-ex-work-buf (get-buffer-create viper-ex-work-buf-name))
 	  (set-buffer viper-ex-work-buf)
 	  (delete-region (point-min) (point-max))
 	  (insert ex-offset "\n")
 	  (goto-char (point-min)))
 	(goto-char (viper-get-ex-address))
 	(setq ex-g-flag t
 	      ex-g-variant nil)))
 (viper-get-ex-pat)
 (if (null ex-token)
 	(error "`%s': Missing regular expression" gcommand)))
 (if (string= ex-token "")
 (if (null viper-s-string)
 	  (error viper-NoPrevSearch)
 	(setq ex-g-pat viper-s-string))
 (setq ex-g-pat ex-token
 	  (beginning-of-line)
 	  (if (bobp) (setq cont nil)
 	    (forward-line -1)
 	    (end-of-line)))))
 (save-window-excursion
 (setq viper-ex-work-buf (get-buffer-create viper-ex-work-buf-name))
 (set-buffer viper-ex-work-buf)
 ;; com-str is the command string, i.e., g/pattern/ or v/pattern'
 (setq com-str (buffer-substring (1+ (point)) (1- (point-max)))))
 (while ex-g-marks
 (goto-char (car ex-g-marks))
 	(if (eq 1 (length name))
 	    (setq char (string-to-char name))
 	  (error "`%s': Spurious text \"%s\" after mark name"
 		 name (substring name 1) viper-SpuriousText))
 (save-window-excursion
 (setq viper-ex-work-buf (get-buffer-create viper-ex-work-buf-name))
 (set-buffer viper-ex-work-buf)
 (skip-chars-forward " \t")
 (if (looking-at "[a-z]")
 	  (progn
 	    (setq char (following-char))
 	(error "`%s' requires a following letter" ex-token))))
 (save-excursion
 (goto-char (car ex-addresses))
 (point-to-register (viper-int-to-char (1+ (- char ?a)))))))
 ;; Alternate file is the file next to the first one in the buffer ring
 (defun ex-next (cycle-other-window &optional find-alt-file)
 (catch 'ex-edit
 (let (count l)
 (if (not find-alt-file)
 	  (progn
 	    (viper-get-ex-file)
 	    (if (or (char-or-string-p ex-offset)
 		    (and (not (string= "" ex-file))
 		         (not (string-match "^[0-9]+$" ex-file))))
 		(progn
 		  (ex-edit t)
 		  (throw 'ex-edit nil))
 	      (setq count (string-to-int ex-file))
 		(ex-fixup-history viper-last-ex-prompt ex-file))
 	    (error "Not that many undisplayed files")))))))
 (defun ex-next-related-buffer (direction &optional no-recursion)
 (viper-ring-rotate1 viper-related-files-and-buffers-ring direction)
 (let ((file-or-buffer-name
 	 (viper-current-ring-item viper-related-files-and-buffers-ring))
 	(old-ring viper-related-files-and-buffers-ring)
 	(old-win (selected-window))
 	skip-rest buf wind)
 (or (and (ring-p viper-related-files-and-buffers-ring)
 	     (> (ring-length viper-related-files-and-buffers-ring) 0))
 	(error "This buffer has no related files or buffers"))
 (or (stringp file-or-buffer-name)
 	(error
 	 "File and buffer names must be strings, %S" file-or-buffer-name))
 (setq buf (cond ((get-buffer file-or-buffer-name))
 		    ((file-exists-p file-or-buffer-name)
 		     (find-file-noselect file-or-buffer-name))
 		    ))
 (if (not (viper-buffer-live-p buf))
 	(error "Didn't find buffer %S or file %S"
 	       file-or-buffer-name
 	       (viper-abbreviate-file-name
 		(expand-file-name file-or-buffer-name))))
 (if (equal buf (current-buffer))
 	(or no-recursion
 	    ;; try again
 	    (progn
 	      (setq skip-rest t)
 	      (ex-next-related-buffer direction 'norecursion))))
 (if skip-rest
 	()
 ;; setup buffer
 (if (setq wind (viper-get-visible-buffer-window buf))
 	  ()
 	(setq wind (get-lru-window (if viper-xemacs-p nil 'visible)))
 	(set-window-buffer wind buf))
 (if (viper-window-display-p)
 	  (progn
 	    (raise-frame (window-frame wind))
 	    (if (equal (window-frame wind) (window-frame old-win))
 		(save-window-excursion (select-window wind) (sit-for 1))
 	      (select-window wind)))
 	(save-window-excursion (select-window wind) (sit-for 1)))
 (save-excursion
 	(set-buffer buf)
 	(setq viper-related-files-and-buffers-ring old-ring))
 (setq viper-local-search-start-marker (point-marker))
 )))
 ;; Force auto save
 (defun ex-preserve ()
 (message "Autosaving all buffers that need to be saved...")
 (do-auto-save t))
 ;; Ex quit command
 (defun ex-quit ()
 ;; skip "!", if it is q!.  In Viper q!, w!, etc., behave as q, w, etc.
 (save-excursion
 (setq viper-ex-work-buf (get-buffer-create viper-ex-work-buf-name))
 (set-buffer viper-ex-work-buf)
 (if (looking-at "!") (forward-char 1)))
 (if (< viper-expert-level 3)
 (save-buffers-kill-emacs)
 (kill-buffer (current-buffer))))
 	  (if (null buffer-file-name)
 	      (error viper-NoFileSpecified))
 	  (setq ex-file buffer-file-name)))
 (if ex-cmdfile
 	(progn
 	  (setq command
 		;; replace # and % with the previous/current file
 		(ex-expand-filsyms (concat ex-file ex-cmdfile-args)
 				   (current-buffer)))
 	  (shell-command command t))
 (insert-file-contents ex-file)))
 (ex-fixup-history viper-last-ex-prompt ex-file ex-cmdfile-args))
 ;; this function fixes ex-history for some commands like ex-read, ex-edit
 (defun ex-fixup-history (&rest args)
 (setq viper-ex-history
 	(cons (mapconcat 'identity args " ") (cdr viper-ex-history))))
 ;; Ex recover from emacs \#file\#
 (defun ex-recover ()
 (viper-get-ex-file)
 (if (or ex-append ex-offset)
 	(progn
 	  (setq batch t)
 	  (viper-set-unread-command-events ?\C-m)))
 (message ":set  <Variable> [= <Value>]")
 (or batch (sit-for 2))
 (while (string-match "^[ \\t\\n]*$"
 			 (setq str
 			       (completing-read ":set " ex-variable-alist)))
 (message ":set <Variable> [= <Value>]")
 ;; if there are unread events, don't wait
 	  (message ":set %s = <Value>" var)
 	  ;; if there are unread events, don't wait
 	  (or (viper-set-unread-command-events "") (sit-for 2))
 	  (setq val (read-string (format ":set %s = " var)))
 	  (ex-fixup-history "set" orig-var val)
 	  ;; check numerical values
 	  (if (member var
 		      '("sw" "shiftwidth"
 			"ts" "tabstop"
 			"ts-g" "tabstop-global"
 			"wm" "wrapmargin"))
 	      (condition-case nil
 		  (or (numberp (setq val2 (car (read-from-string val))))
 		      (error "%s: Invalid value, numberp, %S" var val))
 		(error
 		 (error "%s: Invalid value, numberp, %S" var val))))
 	  (cond
 	   ((member var '("sw" "shiftwidth"))
 	    (setq var "viper-shift-width"))
 	   ((member var '("ts" "tabstop"))
 	    ;; make it take effect in curr buff and new bufs
 	    (kill-local-variable 'tab-width)
 	    (setq var "tab-width"
 		  set-cmd "setq-default"))
 	   ((member var '("wm" "wrapmargin"))
 	    ;; make it take effect in curr buff and new bufs
 	    (kill-local-variable 'fill-column)
 	    (setq var "fill-column"
 		  val (format "(- (window-width) %s)" val)
 		  set-cmd "setq-default"))
 	   ((member var '("sh" "shell"))
 	    (setq var "explicit-shell-file-name"
 		  val (format "\"%s\"" val)))))
 (ex-fixup-history "set" orig-var))
 (if set-cmd
 	(setq actual-lisp-cmd
 	      (format "\n(%s %s %s) %s" set-cmd var val auto-cmd-label)
 	      lisp-cmd-del-pattern
 	      (format "^\n?[ \t]*([ \t]*%s[ \t]+%s[ \t].*)[ \t]*%s"
 		      set-cmd var auto-cmd-label)))
 (if (and ask-if-save
 	     (y-or-n-p (format "Do you want to save this setting in %s "
 			       viper-custom-file-name)))
 	(progn
 	  (viper-save-string-in-file
 	   actual-lisp-cmd viper-custom-file-name
 	   ;; del pattern
 	   lisp-cmd-del-pattern)
 	  (if (string= var "fill-column")
 	      (if (> val2 0)
 		 nil viper-custom-file-name
 		 ;; del pattern
 		 lisp-cmd-del-pattern)
 		))
 	  ))
 (if set-cmd
 	(message "%s %s %s"
 		 set-cmd var
 		 (if (string-match "^[ \t]*$" val)
 		     (format "%S" val)
 ;; In inline args, skip regex-forw and (optionally) chars-back.
 ;; Optional 3d arg is a string that should replace ' ' to prevent its
 ;; special meaning
 (defun ex-get-inline-cmd-args (regex-forw &optional chars-back replace-str)
 (save-excursion
 (setq viper-ex-work-buf (get-buffer-create viper-ex-work-buf-name))
 (set-buffer viper-ex-work-buf)
 (goto-char (point-min))
 (re-search-forward regex-forw nil t)
 (let ((beg (point))
 	  end)
 ;; Ex shell command
 (defun ex-shell ()
 (shell))
 ;; Viper help.  Invokes Info
 (defun ex-help ()
 (condition-case nil
 (progn
 	(pop-to-buffer (get-buffer-create "*info*"))
 (load viper-custom-file-name)
 (load ex-file)))
 ;; Ex substitute command
 ;; If REPEAT use previous regexp which is ex-reg-exp or viper-s-string
 (defun ex-substitute (&optional repeat r-flag)
 (let ((opt-g nil)
 	(opt-c nil)
 	(matched-pos nil)
 	(case-fold-search viper-case-fold-search)
 	delim pat repl)
 ;; Ex tag command
 (defun ex-tag ()
 (let (tag)
 (save-window-excursion
 (setq viper-ex-work-buf (get-buffer-create viper-ex-work-buf-name))
 (set-buffer viper-ex-work-buf)
 (skip-chars-forward " \t")
 (set-mark (point))
 (skip-chars-forward "^ |\t\n")
 (setq tag (buffer-substring (mark t) (point))))
 (viper-change-state-to-vi)
 (viper-message-conditions conds)))))
 ;; Ex write command
 ;; ex-write doesn't support wildcards, because file completion is a better
 ;; mechanism. We also don't support # and %
 ;; because file history is a better mechanism.
 (defun ex-write (q-flag)
 (viper-default-ex-addresses t)
 (viper-get-ex-file)
 (let ((end (car ex-addresses))
 	(beg (car (cdr ex-addresses)))
 	(orig-buf (current-buffer))
 	;;(orig-buf-file-name (buffer-file-name))
 	;;(orig-buf-name (buffer-name))
 	;;(buff-changed-p (buffer-modified-p))
 	temp-buf writing-same-file region
 	file-exists writing-whole-file)
 (if (> beg end) (error viper-FirstAddrExceedsSecond))
 (if ex-cmdfile
 	(progn
 	  (viper-enlarge-region beg end)
 	  (shell-command-on-region (point) (mark t)
 				   (concat ex-file ex-cmdfile-args)))
 (if (and (string= ex-file "") (not (buffer-file-name)))
 	  (setq ex-file
 		(read-file-name
 		 (format "Buffer %s isn't visiting any file.  File to save in: "
 			 (buffer-name)))))
 (setq writing-whole-file (and (= (point-min) beg) (= (point-max) end))
 	    ex-file (if (string= ex-file "")
 			(buffer-file-name)
 		      (expand-file-name ex-file)))
 ;; if ex-file is a directory use the file portion of the buffer file name
 	       buffer-file-name
 	       (not (file-directory-p buffer-file-name)))
 	  (setq ex-file
 		(concat (file-name-as-directory ex-file)
 			(file-name-nondirectory buffer-file-name))))
 (setq file-exists (file-exists-p ex-file)
 	    writing-same-file (string= ex-file (buffer-file-name)))
 ;; do actual writing
 (if (and writing-whole-file writing-same-file)
 	(if (and file-exists (not writing-same-file)
 		 (not (yes-or-no-p
 		       (format "File %s exists.  Overwrite? " ex-file))))
 	    (error "Quit"))
 	;; writing a region or whole buffer to non-visited file
 	(unwind-protect
 	    (save-excursion
 	      (viper-enlarge-region beg end)
 	      (setq region (buffer-substring (point) (mark t)))
 	      ;; create temp buffer for the region
 	      (setq temp-buf (get-buffer-create " *ex-write*"))
 	  (set-buffer orig-buf)))
 ;; set the right file modification time
 (if (and (buffer-file-name) writing-same-file)
 	  (set-visited-file-modtime))
 ;; prevent loss of data if saving part of the buffer in visited file
 (or writing-whole-file
 	  (not writing-same-file)
 	  (progn
 	    (sit-for 2)
 	    (message "Warning: you have saved only part of the buffer!")
 	    (set-buffer-modified-p t)))
 (if q-flag
 	  (if (< viper-expert-level 2)
 	      (save-buffers-kill-emacs)
 	    (kill-buffer (current-buffer))))
 )))
 (defun ex-write-info (exists file-name beg end)
 (message "`%s'%s %d lines, %d characters"
 	   (viper-abbreviate-file-name file-name)
 	   (if exists "" " [New file]")
 ;; Execute shell command
 (defun ex-command ()
 (let (command)
 (save-window-excursion
 (setq viper-ex-work-buf (get-buffer-create viper-ex-work-buf-name))
 (set-buffer viper-ex-work-buf)
 (skip-chars-forward " \t")
 (setq command (buffer-substring (point) (point-max)))
 (end-of-line))
 ;; replace # and % with the previous/current file
 ;; display all variables set through :set
 (defun ex-show-vars ()
 (with-output-to-temp-buffer " *viper-info*"
 (princ (if viper-auto-indent
 	       "autoindent (local)\n" "noautoindent (local)\n"))
 (princ (if (default-value 'viper-auto-indent)
 	       "autoindent (global) \n" "noautoindent (global) \n"))
 (princ (if viper-case-fold-search "ignorecase\n" "noignorecase\n"))
 (princ (if viper-re-search "magic\n" "nomagic\n"))
 (princ (if buffer-read-only "readonly\n" "noreadonly\n"))
 (princ (if blink-matching-paren "showmatch\n" "noshowmatch\n"))

Mercurial > emacs

comparison lisp/emulation/viper-ex.el @ 49598:0d8b17d428b5