Skip to content

GitLab

emacs
emacs
Commit 4fa9f636 authored by Gerd Moellmann's avatar Gerd Moellmann
Browse files
Options

*** empty log message ***

parent d365421f
Hide whitespace changes
Inline Side-by-side
Showing with 1056 additions and 0 deletions
lisp/ChangeLog
View file @ 4fa9f636
2000-06-27 Gerd Moellmann <gerd@gnu.org> 2000-06-27 Gerd Moellmann <gerd@gnu.org>
* help.el (describe-variable): Don't insert a second `'s' in front
of the string `value is shown below'. Since the syntax-table is
set to emacs-lisp-mode-syntax-table, forward-sexp skips over
an existing `'s', so that this won't be deleted.
* pcmpl-cvs.el, pcmpl-gnu.el, pcmpl-linux.el, pcmpl-rpm.el: * pcmpl-cvs.el, pcmpl-gnu.el, pcmpl-linux.el, pcmpl-rpm.el:
* pcmpl-unix.el: New files. * pcmpl-unix.el: New files.
......
lisp/pcmpl-cvs.el 0 → 100644
View file @ 4fa9f636
;;; pcmpl-cvs --- functions for dealing with cvs completions
;; Copyright (C) 1999, 2000 Free Software Foundation
;; This file is part of GNU Emacs.
;; GNU Emacs is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 2, or (at your option)
;; any later version.
;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs; see the file COPYING. If not, write to the
;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
;; Boston, MA 02111-1307, USA.
;;; Commentary:
;; These functions provide completion rules for the `cvs' tool.
;;; Code:
(provide 'pcmpl-cvs)
(require 'pcomplete)
(require 'executable)
(defgroup pcmpl-cvs nil
"Functions for dealing with CVS completions"
:group 'pcomplete)
;; User Variables:
(defcustom pcmpl-cvs-binary (or (executable-find "cvs") "cvs")
"*The full path of the 'cvs' binary."
:type 'file
:group 'pcmpl-cvs)
;; Functions:
;;;###autoload
(defun pcomplete/cvs ()
"Completion rules for the `cvs' command."
(let ((pcomplete-help "(cvs)Invoking CVS"))
(pcomplete-opt "HQqrwlntvfab/T/e*d/z?s")
(pcomplete-here* (pcmpl-cvs-commands))
(cond ((pcomplete-test "add")
(setq pcomplete-help "(cvs)Adding files")
(pcomplete-opt "k?m?")
(while (pcomplete-here (pcmpl-cvs-entries '(??)))))
((pcomplete-test "remove")
(setq pcomplete-help "(cvs)Removing files")
(pcomplete-opt "flR")
(while (pcomplete-here (pcmpl-cvs-entries '(?U)))))
((pcomplete-test "init")
(setq pcomplete-help "(cvs)Creating a repository"))
((pcomplete-test '("login" "logout"))
(setq pcomplete-help "(cvs)Password authentication client"))
((pcomplete-test "import")
(setq pcomplete-help "(cvs)import")
(pcomplete-opt "dk?I(pcmpl-cvs-entries '(??))b?m?W?"))
((pcomplete-test "checkout")
(setq pcomplete-help "(cvs)checkout")
(pcomplete-opt "ANPRcflnpsr?D?d/k?j?")
(pcomplete-here (pcmpl-cvs-modules)))
((pcomplete-test "rtag")
(setq pcomplete-help "(cvs)Creating a branch")
(pcomplete-opt "aflRndbr?DF")
(pcomplete-here (pcmpl-cvs-modules)))
((pcomplete-test "release")
(setq pcomplete-help "(cvs)release")
(pcomplete-opt "d")
(while (pcomplete-here (pcomplete-dirs))))
((pcomplete-test "export")
(setq pcomplete-help "(cvs)export")
(pcomplete-opt "NflRnr?D?d/k?")
(pcomplete-here (pcmpl-cvs-modules)))
((pcomplete-test "commit")
(setq pcomplete-help "(cvs)commit files")
(pcomplete-opt "nRlfF.m?r(pcmpl-cvs-tags '(?M ?R ?A))")
(while (pcomplete-here (pcmpl-cvs-entries '(?M ?R ?A)))))
((pcomplete-test "diff")
(setq pcomplete-help "(cvs)Viewing differences")
(let ((opt-index pcomplete-index)
saw-backdate)
(pcomplete-opt "lRD?Nr(pcmpl-cvs-tags)")
(while (< opt-index pcomplete-index)
(if (pcomplete-match "^-[Dr]" (- pcomplete-index opt-index))
(setq saw-backdate t opt-index pcomplete-index)
(setq opt-index (1+ opt-index))))
(while (pcomplete-here
(pcmpl-cvs-entries (unless saw-backdate '(?M)))))))
((pcomplete-test "unedit")
(setq pcomplete-help "(cvs)Editing files")
(pcomplete-opt "lR")
(while (pcomplete-here (pcmpl-cvs-entries '(?M ?R ?A)))))
((pcomplete-test "update")
(setq pcomplete-help "(cvs)update")
(pcomplete-opt
(concat "APdflRpk?r(pcmpl-cvs-tags '(?U ?P))D?"
"j(pcmpl-cvs-tags '(?U ?P))"
"I(pcmpl-cvs-entries '(??))W?"))
(while (pcomplete-here (pcmpl-cvs-entries '(?U ?P)))))
(t
(while (pcomplete-here (pcmpl-cvs-entries)))))))
(defun pcmpl-cvs-commands ()
"Return a list of available CVS commands."
(with-temp-buffer
(call-process pcmpl-cvs-binary nil t nil "--help-commands")
(goto-char (point-min))
(let (cmds)
(while (re-search-forward "^\\s-+\\([a-z]+\\)" nil t)
(setq cmds (cons (match-string 1) cmds)))
(pcomplete-uniqify-list cmds))))
(defun pcmpl-cvs-modules ()
"Return a list of available modules under CVS."
(with-temp-buffer
(call-process pcmpl-cvs-binary nil t nil "checkout" "-c")
(goto-char (point-min))
(let (entries)
(while (re-search-forward "\\(\\S-+\\)$" nil t)
(setq entries (cons (match-string 1) entries)))
(pcomplete-uniqify-list entries))))
(defun pcmpl-cvs-tags (&optional opers)
"Return all the tags which could apply to the files related to OPERS."
(let ((entries (pcmpl-cvs-entries opers))
tags)
(with-temp-buffer
(apply 'call-process pcmpl-cvs-binary nil t nil
"status" "-v" entries)
(goto-char (point-min))
(while (re-search-forward "Existing Tags:" nil t)
(forward-line)
(while (not (looking-at "^$"))
(unless (looking-at "^\\s-+\\(\\S-+\\)\\s-+")
(error "Error in output from `cvs status -v'"))
(setq tags (cons (match-string 1) tags))
(forward-line))))
(pcomplete-uniqify-list tags)))
(defun pcmpl-cvs-entries (&optional opers)
"Return the Entries for the current directory.
If OPERS is a list of characters, return entries for which that
operation character applies, as displayed by 'cvs -n update'."
(let* ((arg (pcomplete-arg))
(dir (file-name-as-directory
(or (file-name-directory arg) "")))
(nondir (or (file-name-nondirectory arg) ""))
entries)
(if opers
(with-temp-buffer
(and dir (cd dir))
(call-process pcmpl-cvs-binary nil t nil
"-q" "-n" "-f" "update"); "-l")
(goto-char (point-min))
(while (re-search-forward "^\\(.\\) \\(.+\\)$" nil t)
(if (memq (string-to-char (match-string 1)) opers)
(setq entries (cons (match-string 2) entries)))))
(with-temp-buffer
(insert-file-contents (concat dir "CVS/Entries"))
(goto-char (point-min))
(while (not (eobp))
(let* ((line (buffer-substring (line-beginning-position)
(line-end-position)))
(fields (split-string line "/"))
text)
(if (eq (aref line 0) ?/)
(setq fields (cons "" fields)))
(setq text (nth 1 fields))
(when text
(if (string= (nth 0 fields) "D")
(setq text (file-name-as-directory text)))
(setq entries (cons text entries))))
(forward-line))))
(setq pcomplete-stub nondir)
(pcomplete-uniqify-list entries)))
;;; pcmpl-cvs.el ends here
lisp/pcmpl-gnu.el 0 → 100644
View file @ 4fa9f636
;;; pcmpl-gnu --- completions for GNU project tools
;; Copyright (C) 1999, 2000 Free Software Foundation
;; This file is part of GNU Emacs.
;; GNU Emacs is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 2, or (at your option)
;; any later version.
;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs; see the file COPYING. If not, write to the
;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
;; Boston, MA 02111-1307, USA.
;;; Code:
(provide 'pcmpl-gnu)
(require 'pcomplete)
(require 'pcmpl-unix)
(defgroup pcmpl-gnu nil
"Completions for GNU project tools."
:group 'pcomplete)
;; User Variables:
(defcustom pcmpl-gnu-makefile-regexps
'("\\`Makefile\\." "\\.mak\\'")
"*A list of regexps that will match Makefile names."
:type '(repeat regexp)
:group 'pcmpl-gnu)
;; Functions:
;;;###autoload
(defun pcomplete/gzip ()
"Completion for `gzip'."
(let ((pcomplete-help "(gzip)"))
(pcomplete-opt "cdfhlLnNqrStvV123456789")
(while (pcomplete-here
(pcmpl-gnu-zipped-files
(catch 'has-d-flag
(let ((args pcomplete-args))
(while args
(if (string-match "\\`-.*[dt]" (car args))
(throw 'has-d-flag t))
(setq args (cdr args))))))))))
(defun pcmpl-gnu-zipped-files (unzip-p)
"Find all zipped or unzipped files: the inverse of UNZIP-P."
(pcomplete-entries
nil
(function
(lambda (entry)
(when (and (file-readable-p entry)
(file-regular-p entry))
(let ((zipped (string-match "\\.\\(t?gz\\|\\(ta\\)?Z\\)\\'"
entry)))
(or (and unzip-p zipped)
(and (not unzip-p) (not zipped)))))))))
;;;###autoload
(defun pcomplete/bzip2 ()
"Completion for `bzip2'."
(pcomplete-opt "hdzkftcqvLVs123456789")
(while (pcomplete-here
(pcmpl-gnu-bzipped-files
(catch 'has-d-flag
(let ((args pcomplete-args))
(while args
(if (string-match "\\`-.*[dt]" (car args))
(throw 'has-d-flag t))
(setq args (cdr args)))))))))
(defun pcmpl-gnu-bzipped-files (unzip-p)
"Find all zipped or unzipped files: the inverse of UNZIP-P."
(pcomplete-entries
nil
(function
(lambda (entry)
(when (and (file-readable-p entry)
(file-regular-p entry))
(let ((zipped (string-match "\\.\\(t?z2\\|bz2\\)\\'" entry)))
(or (and unzip-p zipped)
(and (not unzip-p) (not zipped)))))))))
;;;###autoload
(defun pcomplete/make ()
"Completion for GNU `make'."
(let ((pcomplete-help "(make)Top"))
(pcomplete-opt "bmC/def(pcmpl-gnu-makefile-names)hiI/j?kl?no.pqrsStvwW.")
(while (pcomplete-here (pcmpl-gnu-make-rule-names) nil 'identity))))
(defun pcmpl-gnu-makefile-names ()
"Return a list of possible makefile names."
(let ((names (list t))
(reg pcmpl-gnu-makefile-regexps))
(while reg
(nconc names (pcomplete-entries (car reg)))
(setq reg (cdr reg)))
(cdr names)))
(defun pcmpl-gnu-make-rule-names ()
"Return a list of possible make rule names in MAKEFILE."
(let* ((minus-f (member "-f" pcomplete-args))
(makefile (or (cadr minus-f) "Makefile"))
rules)
(if (not (file-readable-p makefile))
(unless minus-f (list "-f"))
(with-temp-buffer
(insert-file-contents-literally makefile)
(while (re-search-forward
(concat "^\\s-*\\([^\n#%.$][^:=\n]*\\)\\s-*:[^=]") nil t)
(setq rules (append (split-string (match-string 1)) rules))))
(pcomplete-uniqify-list rules))))
(defcustom pcmpl-gnu-tarfile-regexp
"\\.t\\(ar\\(\\.\\(gz\\|bz2\\|Z\\)\\)?\\|gz\\|a[zZ]\\|z2\\)\\'"
"*A regexp which matches any tar archive."
:type 'regexp
:group 'pcmpl-gnu)
(defvar pcmpl-gnu-tar-buffer nil)
;;;###autoload
(defun pcomplete/tar ()
"Completion for the GNU tar utility."
;; options that end in an equal sign will want further completion...
(let (saw-option complete-within)
(setq pcomplete-suffix-list (cons ?= pcomplete-suffix-list))
(while (pcomplete-match "^-" 0)
(setq saw-option t)
(if (pcomplete-match "^--" 0)
(if (pcomplete-match "^--\\([^= \t\n\f]*\\)\\'" 0)
(pcomplete-here*
'("--absolute-names"
"--after-date="
"--append"
"--atime-preserve"
"--backup"
"--block-number"
"--blocking-factor="
"--catenate"
"--checkpoint"
"--compare"
"--compress"
"--concatenate"
"--confirmation"
"--create"
"--delete"
"--dereference"
"--diff"
"--directory="
"--exclude="
"--exclude-from="
"--extract"
"--file="
"--files-from="
"--force-local"
"--get"
"--group="
"--gzip"
"--help"
"--ignore-failed-read"
"--ignore-zeros"
"--incremental"
"--info-script="
"--interactive"
"--keep-old-files"
"--label="
"--list"
"--listed-incremental"
"--mode="
"--modification-time"
"--multi-volume"
"--new-volume-script="
"--newer="
"--newer-mtime"
"--no-recursion"
"--null"
"--numeric-owner"
"--old-archive"
"--one-file-system"
"--owner="
"--portability"
"--posix"
"--preserve"
"--preserve-order"
"--preserve-permissions"
"--read-full-records"
"--record-size="
"--recursive-unlink"
"--remove-files"
"--rsh-command="
"--same-order"
"--same-owner"
"--same-permissions"
"--sparse"
"--starting-file="
"--suffix="
"--tape-length="
"--to-stdout"
"--totals"
"--uncompress"
"--ungzip"
"--unlink-first"
"--update"
"--use-compress-program="
"--verbose"
"--verify"
"--version"
"--volno-file=")))
(pcomplete-opt "01234567ABCFGKLMNOPRSTUVWXZbcdfghiklmoprstuvwxz"))
(cond
((pcomplete-match "\\`--after-date=" 0)
(pcomplete-here*))
((pcomplete-match "\\`--backup=" 0)
(pcomplete-here*))
((pcomplete-match "\\`--blocking-factor=" 0)
(pcomplete-here*))
((pcomplete-match "\\`--directory=\\(.*\\)" 0)
(pcomplete-here* (pcomplete-dirs)
(pcomplete-match-string 1 0)))
((pcomplete-match "\\`--exclude-from=\\(.*\\)" 0)
(pcomplete-here* (pcomplete-entries)
(pcomplete-match-string 1 0)))
((pcomplete-match "\\`--exclude=" 0)
(pcomplete-here*))
((pcomplete-match "\\`--\\(extract\\|list\\)\\'" 0)
(setq complete-within t))
((pcomplete-match "\\`--file=\\(.*\\)" 0)
(pcomplete-here* (pcomplete-dirs-or-entries pcmpl-gnu-tarfile-regexp)
(pcomplete-match-string 1 0)))
((pcomplete-match "\\`--files-from=\\(.*\\)" 0)
(pcomplete-here* (pcomplete-entries)
(pcomplete-match-string 1 0)))
((pcomplete-match "\\`--group=\\(.*\\)" 0)
(pcomplete-here* (pcmpl-unix-group-names)
(pcomplete-match-string 1 0)))
((pcomplete-match "\\`--info-script=\\(.*\\)" 0)
(pcomplete-here* (pcomplete-entries)
(pcomplete-match-string 1 0)))
((pcomplete-match "\\`--label=" 0)
(pcomplete-here*))
((pcomplete-match "\\`--mode=" 0)
(pcomplete-here*))
((pcomplete-match "\\`--new-volume-script=\\(.*\\)" 0)
(pcomplete-here* (pcomplete-entries)
(pcomplete-match-string 1 0)))
((pcomplete-match "\\`--newer=" 0)
(pcomplete-here*))
((pcomplete-match "\\`--owner=\\(.*\\)" 0)
(pcomplete-here* (pcmpl-unix-user-names)
(pcomplete-match-string 1 0)))
((pcomplete-match "\\`--record-size=" 0)
(pcomplete-here*))
((pcomplete-match "\\`--rsh-command=\\(.*\\)" 0)
(pcomplete-here* (funcall pcomplete-command-completion-function)
(pcomplete-match-string 1 0)))
((pcomplete-match "\\`--starting-file=\\(.*\\)" 0)
(pcomplete-here* (pcomplete-entries)
(pcomplete-match-string 1 0)))
((pcomplete-match "\\`--suffix=" 0)
(pcomplete-here*))
((pcomplete-match "\\`--tape-length=" 0)
(pcomplete-here*))
((pcomplete-match "\\`--use-compress-program=\\(.*\\)" 0)
(pcomplete-here* (funcall pcomplete-command-completion-function)
(pcomplete-match-string 1 0)))
((pcomplete-match "\\`--volno-file=\\(.*\\)" 0)
(pcomplete-here* (pcomplete-entries)
(pcomplete-match-string 1 0)))))
(setq pcomplete-suffix-list (cdr pcomplete-suffix-list))
(unless saw-option
(pcomplete-here
(mapcar 'char-to-string
(string-to-list
"01234567ABCFGIKLMNOPRSTUVWXZbcdfghiklmoprstuvwxz")))
(if (pcomplete-match "[xt]" 'first 1)
(setq complete-within t)))
(pcomplete-here (pcomplete-dirs-or-entries pcmpl-gnu-tarfile-regexp))
(setq pcmpl-gnu-tar-buffer (find-file-noselect (pcomplete-arg 1)))
(while (pcomplete-here
(if complete-within
(with-current-buffer pcmpl-gnu-tar-buffer
(mapcar
(function
(lambda (entry)
(tar-header-name (cdr entry))))
tar-parse-info))
(pcomplete-entries))
nil 'identity))))
;;;###autoload
(defalias 'pcomplete/gdb 'pcomplete/xargs)
;;; pcmpl-gnu.el ends here
lisp/pcmpl-linux.el 0 → 100644
View file @ 4fa9f636
;;; pcmpl-linux --- functions for dealing with cvs completions
;; Copyright (C) 1999, 2000 Free Software Foundation
;; This file is part of GNU Emacs.
;; GNU Emacs is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 2, or (at your option)
;; any later version.
;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs; see the file COPYING. If not, write to the
;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
;; Boston, MA 02111-1307, USA.
;;; Commentary:
;; These functions are for use with GNU/Linux. Since they depend on a
;; certain knowledge of the layout of such systems, they probably
;; won't work very well on other operating systems.
;;; Code:
(provide 'pcmpl-linux)
(require 'pcomplete)
(defgroup pcmpl-linux nil
"Functions for dealing with GNU/Linux completions."
:group 'pcomplete)
;; Functions:
;;;###autoload
(defun pcomplete/kill ()
"Completion for GNU/Linux `kill', using /proc filesystem."
(if (pcomplete-match "^-\\(.*\\)" 0)
(pcomplete-here
(pcomplete-uniqify-list
(split-string
(pcomplete-process-result "kill" "-l")))
(pcomplete-match-string 1 0)))
(while (pcomplete-here
(if (file-directory-p "/proc")
(let ((default-directory "/proc/"))
(mapcar 'directory-file-name
(pcomplete-entries "[0-9]+/$"))))
nil 'identity)))
;;;###autoload
(defun pcomplete/umount ()
"Completion for GNU/Linux `umount'."
(pcomplete-opt "hVafrnvt(pcmpl-linux-fs-types)")
(while (pcomplete-here (pcmpl-linux-mounted-directories)
nil 'identity)))
;;;###autoload
(defun pcomplete/mount ()
"Completion for GNU/Linux `mount'."
(pcomplete-opt "hVanfFrsvwt(pcmpl-linux-fs-types)o?L?U?")
(while (pcomplete-here (pcomplete-entries) nil 'identity)))
(defun pcmpl-linux-fs-types ()
"Return a list of available fs modules on GNU/Linux systems."
(let ((kernel-ver (pcomplete-process-result "uname" "-r")))
(mapcar
(function
(lambda (fsobj)
(substring fsobj 0 (- (length fsobj) 2))))
(let ((default-directory
(concat "/lib/modules/" kernel-ver "/fs/")))
(pcomplete-entries "\\.o$")))))
(defun pcmpl-linux-mounted-directories ()
"Return a list of mounted directory names."
(let (points)
(when (file-readable-p "/etc/mtab")
(with-temp-buffer
(insert-file-contents-literally "/etc/mtab")
(while (not (eobp))
(let* ((line (buffer-substring (point) (line-end-position)))
(args (split-string line " ")))
(setq points (cons (nth 1 args) points)))
(forward-line)))
(pcomplete-uniqify-list points))))
(defun pcmpl-linux-mountable-directories ()
"Return a list of mountable directory names."
(let (points)
(when (file-readable-p "/etc/fstab")
(with-temp-buffer
(insert-file-contents-literally "/etc/fstab")
(while (not (eobp))
(let* ((line (buffer-substring (point) (line-end-position)))
(args (split-string line "\\s-+")))
(setq points (cons (nth 1 args) points)))
(forward-line)))
(pcomplete-pare-list
(pcomplete-uniqify-list points)
(cons "swap" (pcmpl-linux-mounted-directories))))))
;;; pcmpl-linux.el ends here
lisp/pcmpl-rpm.el 0 → 100644
View file @ 4fa9f636
;;; pcmpl-rpm --- functions for dealing with rpm completions
;; Copyright (C) 1999, 2000 Free Software Foundation
;; This file is part of GNU Emacs.
;; GNU Emacs is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 2, or (at your option)
;; any later version.
;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs; see the file COPYING. If not, write to the
;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
;; Boston, MA 02111-1307, USA.
;;; Commentary:
;; These functions provide completion rules for RedHat's `rpm' tool.
;;; Code:
(provide 'pcmpl-rpm)
(require 'pcomplete)
(defgroup pcmpl-rpm nil
"Functions for dealing with CVS completions"
:group 'pcomplete)
;; Functions:
(defsubst pcmpl-rpm-packages ()
(split-string (pcomplete-process-result "rpm" "-q" "-a")))
(defun pcmpl-rpm-all-query (flag)
(message "Querying all packages with `%s'..." flag)
(let ((pkgs (pcmpl-rpm-packages))
(provs (list t)))
(while pkgs
(nconc provs (split-string
(pcomplete-process-result
"rpm" "-q" (car pkgs) flag)))