2011-02-21 20:31:07 +00:00
|
|
|
|
;;; minibuffer.el --- Minibuffer completion functions -*- lexical-binding: t -*-
|
2008-04-09 03:34:19 +00:00
|
|
|
|
|
2013-01-01 09:11:05 +00:00
|
|
|
|
;; Copyright (C) 2008-2013 Free Software Foundation, Inc.
|
2008-04-09 03:34:19 +00:00
|
|
|
|
|
|
|
|
|
;; Author: Stefan Monnier <monnier@iro.umontreal.ca>
|
2010-08-29 16:17:13 +00:00
|
|
|
|
;; Package: emacs
|
2008-04-09 03:34:19 +00:00
|
|
|
|
|
|
|
|
|
;; This file is part of GNU Emacs.
|
|
|
|
|
|
2008-05-06 08:06:51 +00:00
|
|
|
|
;; GNU Emacs is free software: you can redistribute it and/or modify
|
2008-04-09 03:34:19 +00:00
|
|
|
|
;; it under the terms of the GNU General Public License as published by
|
|
|
|
|
;; the Free Software Foundation, either version 3 of the License, or
|
|
|
|
|
;; (at your option) any later version.
|
|
|
|
|
|
2008-05-06 08:06:51 +00:00
|
|
|
|
;; GNU Emacs is distributed in the hope that it will be useful,
|
2008-04-09 03:34:19 +00:00
|
|
|
|
;; 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
|
2008-05-06 08:06:51 +00:00
|
|
|
|
;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
|
2008-04-09 03:34:19 +00:00
|
|
|
|
|
|
|
|
|
;;; Commentary:
|
|
|
|
|
|
2008-05-20 17:03:30 +00:00
|
|
|
|
;; Names with "--" are for functions and variables that are meant to be for
|
|
|
|
|
;; internal use only.
|
|
|
|
|
|
|
|
|
|
;; Functional completion tables have an extended calling conventions:
|
2011-05-31 21:40:30 +00:00
|
|
|
|
;; The `action' can be (additionally to nil, t, and lambda) of the form
|
|
|
|
|
;; - (boundaries . SUFFIX) in which case it should return
|
2008-05-23 01:58:15 +00:00
|
|
|
|
;; (boundaries START . END). See `completion-boundaries'.
|
2008-05-20 17:03:30 +00:00
|
|
|
|
;; Any other return value should be ignored (so we ignore values returned
|
|
|
|
|
;; from completion tables that don't know about this new `action' form).
|
2011-05-31 21:40:30 +00:00
|
|
|
|
;; - `metadata' in which case it should return (metadata . ALIST) where
|
|
|
|
|
;; ALIST is the metadata of this table. See `completion-metadata'.
|
|
|
|
|
;; Any other return value should be ignored (so we ignore values returned
|
|
|
|
|
;; from completion tables that don't know about this new `action' form).
|
2008-05-20 17:03:30 +00:00
|
|
|
|
|
|
|
|
|
;;; Bugs:
|
|
|
|
|
|
2013-09-06 22:46:44 +00:00
|
|
|
|
;; - completion-all-sorted-completions lists all the completions, whereas
|
2008-06-10 22:01:59 +00:00
|
|
|
|
;; it should only lists the ones that `try-completion' would consider.
|
|
|
|
|
;; E.g. it should honor completion-ignored-extensions.
|
2008-05-20 17:03:30 +00:00
|
|
|
|
;; - choose-completion can't automatically figure out the boundaries
|
2009-10-21 20:03:57 +00:00
|
|
|
|
;; corresponding to the displayed completions because we only
|
|
|
|
|
;; provide the start info but not the end info in
|
|
|
|
|
;; completion-base-position.
|
|
|
|
|
;; - C-x C-f ~/*/sr ? should not list "~/./src".
|
|
|
|
|
;; - minibuffer-force-complete completes ~/src/emacs/t<!>/lisp/minibuffer.el
|
|
|
|
|
;; to ~/src/emacs/trunk/ and throws away lisp/minibuffer.el.
|
2008-04-09 19:33:56 +00:00
|
|
|
|
|
2008-04-21 19:02:54 +00:00
|
|
|
|
;;; Todo:
|
|
|
|
|
|
2012-11-08 15:10:08 +00:00
|
|
|
|
;; - Make *Completions* readable even if some of the completion
|
|
|
|
|
;; entries have LF chars or spaces in them (including at
|
|
|
|
|
;; beginning/end) or are very long.
|
2011-05-24 02:45:50 +00:00
|
|
|
|
;; - for M-x, cycle-sort commands that have no key binding first.
|
2011-04-20 19:05:50 +00:00
|
|
|
|
;; - Make things like icomplete-mode or lightning-completion work with
|
|
|
|
|
;; completion-in-region-mode.
|
2011-05-31 03:03:38 +00:00
|
|
|
|
;; - extend `metadata':
|
2009-12-06 01:25:41 +00:00
|
|
|
|
;; - indicate how to turn all-completion's output into
|
|
|
|
|
;; try-completion's output: e.g. completion-ignored-extensions.
|
2012-04-25 18:40:42 +00:00
|
|
|
|
;; maybe that could be merged with the "quote" operation.
|
2009-12-06 01:25:41 +00:00
|
|
|
|
;; - indicate that `all-completions' doesn't do prefix-completion
|
|
|
|
|
;; but just returns some list that relates in some other way to
|
|
|
|
|
;; the provided string (as is the case in filecache.el), in which
|
|
|
|
|
;; case partial-completion (for example) doesn't make any sense
|
|
|
|
|
;; and neither does the completions-first-difference highlight.
|
2010-05-12 00:39:46 +00:00
|
|
|
|
;; - indicate how to display the completions in *Completions* (turn
|
|
|
|
|
;; \n into something else, add special boundaries between
|
|
|
|
|
;; completions). E.g. when completing from the kill-ring.
|
2009-12-06 01:25:41 +00:00
|
|
|
|
|
2009-10-21 20:03:57 +00:00
|
|
|
|
;; - case-sensitivity currently confuses two issues:
|
2009-08-30 03:45:30 +00:00
|
|
|
|
;; - whether or not a particular completion table should be case-sensitive
|
2009-10-21 20:03:57 +00:00
|
|
|
|
;; (i.e. whether strings that differ only by case are semantically
|
2009-08-30 03:45:30 +00:00
|
|
|
|
;; equivalent)
|
|
|
|
|
;; - whether the user wants completion to pay attention to case.
|
|
|
|
|
;; e.g. we may want to make it possible for the user to say "first try
|
|
|
|
|
;; completion case-sensitively, and if that fails, try to ignore case".
|
2012-11-08 15:10:08 +00:00
|
|
|
|
;; Maybe the trick is that we should distinguish completion-ignore-case in
|
|
|
|
|
;; try/all-completions (obey user's preference) from its use in
|
|
|
|
|
;; test-completion (obey the underlying object's semantics).
|
2009-08-30 03:45:30 +00:00
|
|
|
|
|
2008-05-20 17:03:30 +00:00
|
|
|
|
;; - add support for ** to pcm.
|
2008-04-21 19:02:54 +00:00
|
|
|
|
;; - Add vc-file-name-completion-table to read-file-name-internal.
|
|
|
|
|
;; - A feature like completing-help.el.
|
2008-04-09 03:34:19 +00:00
|
|
|
|
|
|
|
|
|
;;; Code:
|
|
|
|
|
|
Reduce use of (require 'cl).
* admin/bzrmerge.el: Use cl-lib.
* leim/quail/hangul.el: Don't require CL.
* leim/quail/ipa.el: Use cl-lib.
* vc/smerge-mode.el, vc/pcvs.el, vc/pcvs-util.el, vc/pcvs-info.el:
* vc/diff-mode.el, vc/cvs-status.el, uniquify.el, scroll-bar.el:
* register.el, progmodes/sh-script.el, net/gnutls.el, net/dbus.el:
* msb.el, mpc.el, minibuffer.el, international/ucs-normalize.el:
* international/quail.el, info-xref.el, imenu.el, image-mode.el:
* font-lock.el, filesets.el, edmacro.el, doc-view.el, bookmark.el:
* battery.el, avoid.el, abbrev.el: Use cl-lib.
* vc/pcvs-parse.el, vc/pcvs-defs.el, vc/log-view.el, vc/log-edit.el:
* vc/diff.el, simple.el, pcomplete.el, lpr.el, comint.el, loadhist.el:
* jit-lock.el, international/iso-ascii.el, info.el, frame.el, bs.el:
* emulation/crisp.el, electric.el, dired.el, cus-dep.el, composite.el:
* calculator.el, autorevert.el, apropos.el: Don't require CL.
* emacs-bytecomp.el (byte-recompile-directory, display-call-tree)
(byte-compile-unfold-bcf, byte-compile-check-variable):
* emacs-byte-opt.el (byte-compile-trueconstp)
(byte-compile-nilconstp):
* emacs-autoload.el (make-autoload): Use pcase.
* face-remap.el (text-scale-adjust): Simplify pcase patterns.
2012-07-10 11:51:54 +00:00
|
|
|
|
(eval-when-compile (require 'cl-lib))
|
2008-04-09 03:34:19 +00:00
|
|
|
|
|
2008-04-11 22:28:02 +00:00
|
|
|
|
;;; Completion table manipulation
|
|
|
|
|
|
2008-05-20 17:03:30 +00:00
|
|
|
|
;; New completion-table operation.
|
2008-05-23 01:58:15 +00:00
|
|
|
|
(defun completion-boundaries (string table pred suffix)
|
|
|
|
|
"Return the boundaries of the completions returned by TABLE for STRING.
|
2008-05-20 17:03:30 +00:00
|
|
|
|
STRING is the string on which completion will be performed.
|
2008-05-23 01:58:15 +00:00
|
|
|
|
SUFFIX is the string after point.
|
|
|
|
|
The result is of the form (START . END) where START is the position
|
|
|
|
|
in STRING of the beginning of the completion field and END is the position
|
|
|
|
|
in SUFFIX of the end of the completion field.
|
|
|
|
|
E.g. for simple completion tables, the result is always (0 . (length SUFFIX))
|
|
|
|
|
and for file names the result is the positions delimited by
|
2008-05-20 17:03:30 +00:00
|
|
|
|
the closest directory separators."
|
|
|
|
|
(let ((boundaries (if (functionp table)
|
2011-05-31 21:40:30 +00:00
|
|
|
|
(funcall table string pred
|
|
|
|
|
(cons 'boundaries suffix)))))
|
2008-05-20 17:03:30 +00:00
|
|
|
|
(if (not (eq (car-safe boundaries) 'boundaries))
|
|
|
|
|
(setq boundaries nil))
|
|
|
|
|
(cons (or (cadr boundaries) 0)
|
2008-05-23 01:58:15 +00:00
|
|
|
|
(or (cddr boundaries) (length suffix)))))
|
2008-05-20 17:03:30 +00:00
|
|
|
|
|
2011-05-31 03:03:38 +00:00
|
|
|
|
(defun completion-metadata (string table pred)
|
|
|
|
|
"Return the metadata of elements to complete at the end of STRING.
|
|
|
|
|
This metadata is an alist. Currently understood keys are:
|
|
|
|
|
- `category': the kind of objects returned by `all-completions'.
|
|
|
|
|
Used by `completion-category-overrides'.
|
|
|
|
|
- `annotation-function': function to add annotations in *Completions*.
|
|
|
|
|
Takes one argument (STRING), which is a possible completion and
|
|
|
|
|
returns a string to append to STRING.
|
|
|
|
|
- `display-sort-function': function to sort entries in *Completions*.
|
|
|
|
|
Takes one argument (COMPLETIONS) and should return a new list
|
|
|
|
|
of completions. Can operate destructively.
|
|
|
|
|
- `cycle-sort-function': function to sort entries when cycling.
|
2011-05-31 21:40:30 +00:00
|
|
|
|
Works like `display-sort-function'.
|
|
|
|
|
The metadata of a completion table should be constant between two boundaries."
|
2011-05-31 03:03:38 +00:00
|
|
|
|
(let ((metadata (if (functionp table)
|
|
|
|
|
(funcall table string pred 'metadata))))
|
|
|
|
|
(if (eq (car-safe metadata) 'metadata)
|
2011-06-20 20:16:20 +00:00
|
|
|
|
metadata
|
|
|
|
|
'(metadata))))
|
2011-05-31 03:03:38 +00:00
|
|
|
|
|
|
|
|
|
(defun completion--field-metadata (field-start)
|
|
|
|
|
(completion-metadata (buffer-substring-no-properties field-start (point))
|
|
|
|
|
minibuffer-completion-table
|
|
|
|
|
minibuffer-completion-predicate))
|
|
|
|
|
|
|
|
|
|
(defun completion-metadata-get (metadata prop)
|
|
|
|
|
(cdr (assq prop metadata)))
|
|
|
|
|
|
2008-04-13 22:12:02 +00:00
|
|
|
|
(defun completion--some (fun xs)
|
|
|
|
|
"Apply FUN to each element of XS in turn.
|
|
|
|
|
Return the first non-nil returned value.
|
|
|
|
|
Like CL's `some'."
|
2011-02-21 20:31:07 +00:00
|
|
|
|
(let ((firsterror nil)
|
|
|
|
|
res)
|
2008-04-13 22:12:02 +00:00
|
|
|
|
(while (and (not res) xs)
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(condition-case-unless-debug err
|
2008-05-20 17:03:30 +00:00
|
|
|
|
(setq res (funcall fun (pop xs)))
|
|
|
|
|
(error (unless firsterror (setq firsterror err)) nil)))
|
|
|
|
|
(or res
|
|
|
|
|
(if firsterror (signal (car firsterror) (cdr firsterror))))))
|
2008-04-13 22:12:02 +00:00
|
|
|
|
|
2008-04-11 22:28:02 +00:00
|
|
|
|
(defun complete-with-action (action table string pred)
|
|
|
|
|
"Perform completion ACTION.
|
|
|
|
|
STRING is the string to complete.
|
2012-03-12 04:10:59 +00:00
|
|
|
|
TABLE is the completion table.
|
2008-04-11 22:28:02 +00:00
|
|
|
|
PRED is a completion predicate.
|
|
|
|
|
ACTION can be one of nil, t or `lambda'."
|
2008-05-20 17:03:30 +00:00
|
|
|
|
(cond
|
|
|
|
|
((functionp table) (funcall table string pred action))
|
2011-05-31 21:40:30 +00:00
|
|
|
|
((eq (car-safe action) 'boundaries) nil)
|
|
|
|
|
((eq action 'metadata) nil)
|
2008-05-20 17:03:30 +00:00
|
|
|
|
(t
|
|
|
|
|
(funcall
|
|
|
|
|
(cond
|
|
|
|
|
((null action) 'try-completion)
|
|
|
|
|
((eq action t) 'all-completions)
|
|
|
|
|
(t 'test-completion))
|
|
|
|
|
string table pred))))
|
2008-04-11 22:28:02 +00:00
|
|
|
|
|
|
|
|
|
(defun completion-table-dynamic (fun)
|
|
|
|
|
"Use function FUN as a dynamic completion table.
|
|
|
|
|
FUN is called with one argument, the string for which completion is required,
|
2008-04-21 00:17:56 +00:00
|
|
|
|
and it should return an alist containing all the intended possible completions.
|
|
|
|
|
This alist may be a full list of possible completions so that FUN can ignore
|
|
|
|
|
the value of its argument. If completion is performed in the minibuffer,
|
|
|
|
|
FUN will be called in the buffer from which the minibuffer was entered.
|
2008-04-11 22:28:02 +00:00
|
|
|
|
|
2008-08-19 04:34:54 +00:00
|
|
|
|
The result of the `completion-table-dynamic' form is a function
|
2008-05-30 19:50:26 +00:00
|
|
|
|
that can be used as the COLLECTION argument to `try-completion' and
|
2008-04-21 00:17:56 +00:00
|
|
|
|
`all-completions'. See Info node `(elisp)Programmed Completion'."
|
2011-02-21 20:31:07 +00:00
|
|
|
|
(lambda (string pred action)
|
2011-05-31 21:40:30 +00:00
|
|
|
|
(if (or (eq (car-safe action) 'boundaries) (eq action 'metadata))
|
Merge from lexical-binding branch.
* doc/lispref/eval.texi (Eval): Discourage the use of `eval'.
Document its new `lexical' argument.
* doc/lispref/variables.texi (Defining Variables): Mention the new meaning of `defvar'.
(Lexical Binding): New sub-section.
* lisp/Makefile.in (BIG_STACK_DEPTH, BIG_STACK_OPTS, BYTE_COMPILE_FLAGS):
New variables.
(compile-onefile, .el.elc, compile-calc, recompile): Use them.
(COMPILE_FIRST): Add macroexp and cconv.
* lisp/makefile.w32-in: Mirror changes in Makefile.in.
* lisp/vc/cvs-status.el:
* lisp/vc/diff-mode.el:
* lisp/vc/log-edit.el:
* lisp/vc/log-view.el:
* lisp/vc/smerge-mode.el:
* lisp/textmodes/bibtex-style.el:
* textmodes/css.el:
* lisp/startup.el:
* lisp/uniquify.el:
* lisp/minibuffer.el:
* lisp/newcomment.el:
* lisp/reveal.el:
* lisp/server.el:
* lisp/mpc.el:
* lisp/emacs-lisp/smie.el:
* lisp/doc-view.el:
* lisp/dired.el:
* lisp/abbrev.el: Use lexical binding.
* lisp/custom.el (custom-initialize-default, custom-declare-variable):
Use `defvar'.
* lisp/files.el (lexical-binding): Declare safe.
* lisp/help-fns.el (help-split-fundoc): Return nil if there's nothing else
than the arglist.
(help-add-fundoc-usage): Don't add `Not documented'.
(help-function-arglist): Handle closures, subroutines, and new
byte-code-functions.
(help-make-usage): Remove leading underscores.
(describe-function-1): Handle closures.
(describe-variable): Use special-variable-p for completion.
* lisp/simple.el (with-wrapper-hook, apply-partially): Move to subr.el.
* lisp/subr.el (apply-partially): Use new closures rather than CL.
(--dolist-tail--, --dotimes-limit--): Don't declare dynamic.
(dolist, dotimes): Use slightly different expansion for lexical code.
(functionp): Move to C.
(letrec): New macro.
(with-wrapper-hook): Use it and apply-partially instead of CL.
(eval-after-load): Preserve lexical-binding.
(save-window-excursion, with-output-to-temp-buffer): Turn them
into macros.
* lisp/emacs-lisp/advice.el (ad-arglist): Use help-function-arglist.
* lisp/emacs-lisp/autoload.el (make-autoload): Don't burp on trivial macros.
* lisp/emacs-lisp/byte-opt.el: Use lexical binding.
(byte-inline-lapcode): Remove (to bytecomp).
(byte-compile-inline-expand): Pay attention to inlining to/from
lexically bound code.
(byte-compile-unfold-lambda): Don't handle byte-code-functions
any more.
(byte-optimize-form-code-walker): Don't handle save-window-excursion
any more and don't call compiler-macros.
(byte-compile-splice-in-already-compiled-code): Remove.
(byte-code): Don't inline any more.
(disassemble-offset): Receive `bytes' as argument rather than via
dynamic scoping.
(byte-compile-tag-number): Declare before first use.
(byte-decompile-bytecode-1): Handle new byte-codes, don't change
`return' even if make-spliceable.
(byte-compile-side-effect-and-error-free-ops): Add stack-ref, remove
obsolete interactive-p.
(byte-optimize-lapcode): Optimize new lap-codes.
Don't trip up on new form of `byte-constant' lap code.
* lisp/emacs-lisp/byte-run.el (make-obsolete): Don't set the `byte-compile'
handler any more.
* lisp/emacs-lisp/bytecomp.el: Use lexical binding instead of
a "bytecomp-" prefix. Macroexpand everything as a separate phase.
(byte-compile-initial-macro-environment):
Handle declare-function here.
(byte-compile--lexical-environment): New var.
(byte-stack-ref, byte-stack-set, byte-discardN)
(byte-discardN-preserve-tos): New lap codes.
(byte-interactive-p): Don't use any more.
(byte-compile-push-bytecodes, byte-compile-push-bytecode-const2):
New macros.
(byte-compile-lapcode): Use them and handle new lap codes.
(byte-compile-obsolete): Remove.
(byte-compile-arglist-signature): Handle new byte-code arg"lists".
(byte-compile-arglist-warn): Check late def of inlinable funs.
(byte-compile-cl-warn): Don't silence warnings for compiler-macros
since they should have been expanded by now.
(byte-compile--outbuffer): Rename from bytecomp-outbuffer.
(byte-compile-from-buffer): Remove unused second arg.
(byte-compile-preprocess): New function.
(byte-compile-toplevel-file-form): New function to distinguish
file-form calls from outside from file-form calls from hunk-handlers.
(byte-compile-file-form): Simplify.
(byte-compile-file-form-defsubst): Remove.
(byte-compile-file-form-defmumble): Simplify now that
byte-compile-lambda always returns a byte-code-function.
(byte-compile): Preprocess.
(byte-compile-byte-code-maker, byte-compile-byte-code-unmake):
Remove, not used any more.
(byte-compile-arglist-vars, byte-compile-make-lambda-lexenv)
(byte-compile-make-args-desc): New funs.
(byte-compile-lambda): Handle lexical functions. Always return
a byte-code-function.
(byte-compile-reserved-constants): New var, to make up room for
closed-over variables.
(byte-compile-constants-vector): Obey it.
(byte-compile-top-level): New args `lexenv' and `reserved-csts'.
(byte-compile-macroexpand-declare-function): New function.
(byte-compile-form): Call byte-compile-unfold-bcf to inline immediate
byte-code-functions.
(byte-compile-form): Check obsolescence here.
(byte-compile-inline-lapcode, byte-compile-unfold-bcf): New functions.
(byte-compile-variable-ref): Remove.
(byte-compile-dynamic-variable-op): New fun.
(byte-compile-dynamic-variable-bind, byte-compile-variable-ref)
(byte-compile-variable-set): New funs.
(byte-compile-discard): Add 2 args.
(byte-compile-stack-ref, byte-compile-stack-set)
(byte-compile-make-closure, byte-compile-get-closed-var): New funs.
(byte-compile-funarg, byte-compile-funarg-2): Remove, handled in
macroexpand-all instead.
(byte-compile-quote-form): Remove.
(byte-compile-push-binding-init, byte-compile-not-lexical-var-p)
(byte-compile-bind, byte-compile-unbind): New funs.
(byte-compile-let): Handle let* and lexical binding.
(byte-compile-let*): Remove.
(byte-compile-catch, byte-compile-unwind-protect)
(byte-compile-track-mouse, byte-compile-condition-case):
Handle a new :fun-body form, used for lexical scoping.
(byte-compile-save-window-excursion)
(byte-compile-with-output-to-temp-buffer): Remove.
(byte-compile-defun): Simplify.
(byte-compile-stack-adjustment): New fun.
(byte-compile-out): Use it.
(byte-compile-refresh-preloaded): Don't reload byte-compiler files.
* lisp/emacs-lisp/cconv.el: New file.
* lisp/emacs-lisp/cl-extra.el (cl-macroexpand-all): Properly quote CL
closures.
* lisp/emacs-lisp/cl-macs.el (cl-byte-compile-block)
(cl-byte-compile-throw): Remove.
(cl-block-wrapper, cl-block-throw): Use compiler-macros instead.
* lisp/emacs-lisp/cl.el (pushnew): Silence warning.
* lisp/emacs-lisp/disass.el (disassemble-internal): Handle new
`closure' objects.
(disassemble-1): Handle new byte codes.
* lisp/emacs-lisp/edebug.el (edebug-eval-defun)
(edebug-eval-top-level-form): Use eval-sexp-add-defvars.
(edebug-toggle): Avoid `eval'.
* lisp/emacs-lisp/eieio-comp.el: Remove.
* lisp/emacs-lisp/eieio.el (byte-compile-file-form-defmethod):
Don't autoload.
(eieio-defgeneric-form-primary-only-one): Use `byte-compile' rather
than the internal `byte-compile-lambda'.
(defmethod): Don't hide code under quotes.
(eieio-defmethod): New `code' argument.
* lisp/emacs-lisp/float-sup.el (pi): Don't declare as dynamically bound.
* lisp/emacs-lisp/lisp-mode.el (eval-last-sexp-1):
Use eval-sexp-add-defvars.
(eval-sexp-add-defvars): New fun.
* lisp/emacs-lisp/macroexp.el: Use lexical binding.
(macroexpand-all-1): Check obsolete macros. Expand compiler-macros.
Don't convert ' to #' without checking that it's indeed quoting
a lambda.
* lisp/emacs-lisp/pcase.el: Don't use destructuring-bind.
(pcase--memoize): Rename from pcase-memoize. Change weakness.
(pcase): Add `let' pattern.
Change memoization so it actually works.
(pcase-mutually-exclusive-predicates): Add byte-code-function-p.
(pcase--u1) <guard, pred>: Fix possible shadowing problem.
<let>: New case.
* src/alloc.c (Fmake_symbol): Init new `declared_special' field.
* src/buffer.c (defvar_per_buffer): Set new `declared_special' field.
* src/bytecode.c (Bstack_ref, Bstack_set, Bstack_set2, BdiscardN):
New byte-codes.
(exec_byte_code): New function extracted from Fbyte_code to handle new
calling convention for byte-code-functions. Add new byte-codes.
* src/callint.c (Fcall_interactively): Preserve lexical-binding mode for
interactive spec.
* src/doc.c (Fdocumentation, store_function_docstring):
* src/data.c (Finteractive_form): Handle closures.
* src/eval.c (Fsetq): Handle lexical vars.
(Fdefun, Fdefmacro, Ffunction): Make closures when needed.
(Fdefconst, Fdefvaralias, Fdefvar): Mark as dynamic.
(FletX, Flet): Obey lexical binding.
(Fcommandp): Handle closures.
(Feval): New `lexical' arg.
(eval_sub): New function extracted from Feval. Use it almost
everywhere where Feval was used. Look up vars in lexical env.
Handle closures.
(Ffunctionp): Move from subr.el.
(Ffuncall): Handle closures.
(apply_lambda): Remove `eval_flags'.
(funcall_lambda): Handle closures and new byte-code-functions.
(Fspecial_variable_p): New function.
(syms_of_eval): Initialize the Vinternal_interpreter_environment var,
but without exporting it to Lisp.
* src/fns.c (concat, mapcar1): Accept byte-code-functions.
* src/image.c (parse_image_spec): Use Ffunctionp.
* src/keyboard.c (eval_dyn): New fun.
(menu_item_eval_property): Use it.
* src/lisp.h (struct Lisp_Symbol): New field `declared_special'.
* src/lread.c (lisp_file_lexically_bound_p): New function.
(Fload): Bind Qlexical_binding.
(readevalloop): Remove `evalfun' arg.
Bind Qinternal_interpreter_environment.
(Feval_buffer): Bind Qlexical_binding.
(defvar_int, defvar_bool, defvar_lisp_nopro, defvar_kboard):
Mark as dynamic.
(syms_of_lread): Declare `lexical-binding'.
* src/window.c (Ftemp_output_buffer_show): New fun.
(Fsave_window_excursion):
* src/print.c (Fwith_output_to_temp_buffer): Move to subr.el.
2011-04-01 17:19:52 +00:00
|
|
|
|
;; `fun' is not supposed to return another function but a plain old
|
|
|
|
|
;; completion table, whose boundaries are always trivial.
|
|
|
|
|
nil
|
|
|
|
|
(with-current-buffer (let ((win (minibuffer-selected-window)))
|
|
|
|
|
(if (window-live-p win) (window-buffer win)
|
|
|
|
|
(current-buffer)))
|
|
|
|
|
(complete-with-action action (funcall fun string) string pred)))))
|
2008-04-11 22:28:02 +00:00
|
|
|
|
|
|
|
|
|
(defmacro lazy-completion-table (var fun)
|
|
|
|
|
"Initialize variable VAR as a lazy completion table.
|
|
|
|
|
If the completion table VAR is used for the first time (e.g., by passing VAR
|
|
|
|
|
as an argument to `try-completion'), the function FUN is called with no
|
|
|
|
|
arguments. FUN must return the completion table that will be stored in VAR.
|
|
|
|
|
If completion is requested in the minibuffer, FUN will be called in the buffer
|
|
|
|
|
from which the minibuffer was entered. The return value of
|
|
|
|
|
`lazy-completion-table' must be used to initialize the value of VAR.
|
|
|
|
|
|
|
|
|
|
You should give VAR a non-nil `risky-local-variable' property."
|
2008-04-11 23:42:25 +00:00
|
|
|
|
(declare (debug (symbolp lambda-expr)))
|
2008-04-11 22:28:02 +00:00
|
|
|
|
(let ((str (make-symbol "string")))
|
|
|
|
|
`(completion-table-dynamic
|
|
|
|
|
(lambda (,str)
|
|
|
|
|
(when (functionp ,var)
|
2012-04-26 03:18:47 +00:00
|
|
|
|
(setq ,var (funcall #',fun)))
|
2008-04-11 22:28:02 +00:00
|
|
|
|
,var))))
|
|
|
|
|
|
2011-10-03 15:03:00 +00:00
|
|
|
|
(defun completion-table-case-fold (table &optional dont-fold)
|
|
|
|
|
"Return new completion TABLE that is case insensitive.
|
|
|
|
|
If DONT-FOLD is non-nil, return a completion table that is
|
|
|
|
|
case sensitive instead."
|
|
|
|
|
(lambda (string pred action)
|
|
|
|
|
(let ((completion-ignore-case (not dont-fold)))
|
|
|
|
|
(complete-with-action action table string pred))))
|
2011-02-12 18:30:13 +00:00
|
|
|
|
|
2012-04-25 18:40:42 +00:00
|
|
|
|
(defun completion-table-subvert (table s1 s2)
|
2012-09-11 14:06:33 +00:00
|
|
|
|
"Return a completion table from TABLE with S1 replaced by S2.
|
2012-04-25 18:40:42 +00:00
|
|
|
|
The result is a completion table which completes strings of the
|
2012-09-11 17:43:21 +00:00
|
|
|
|
form (concat S1 S) in the same way as TABLE completes strings of
|
|
|
|
|
the form (concat S2 S)."
|
2012-04-25 18:40:42 +00:00
|
|
|
|
(lambda (string pred action)
|
|
|
|
|
(let* ((str (if (eq t (compare-strings string 0 (length s1) s1 nil nil
|
|
|
|
|
completion-ignore-case))
|
|
|
|
|
(concat s2 (substring string (length s1)))))
|
|
|
|
|
(res (if str (complete-with-action action table str pred))))
|
|
|
|
|
(when res
|
|
|
|
|
(cond
|
|
|
|
|
((eq (car-safe action) 'boundaries)
|
|
|
|
|
(let ((beg (or (and (eq (car-safe res) 'boundaries) (cadr res)) 0)))
|
Reduce use of (require 'cl).
* admin/bzrmerge.el: Use cl-lib.
* leim/quail/hangul.el: Don't require CL.
* leim/quail/ipa.el: Use cl-lib.
* vc/smerge-mode.el, vc/pcvs.el, vc/pcvs-util.el, vc/pcvs-info.el:
* vc/diff-mode.el, vc/cvs-status.el, uniquify.el, scroll-bar.el:
* register.el, progmodes/sh-script.el, net/gnutls.el, net/dbus.el:
* msb.el, mpc.el, minibuffer.el, international/ucs-normalize.el:
* international/quail.el, info-xref.el, imenu.el, image-mode.el:
* font-lock.el, filesets.el, edmacro.el, doc-view.el, bookmark.el:
* battery.el, avoid.el, abbrev.el: Use cl-lib.
* vc/pcvs-parse.el, vc/pcvs-defs.el, vc/log-view.el, vc/log-edit.el:
* vc/diff.el, simple.el, pcomplete.el, lpr.el, comint.el, loadhist.el:
* jit-lock.el, international/iso-ascii.el, info.el, frame.el, bs.el:
* emulation/crisp.el, electric.el, dired.el, cus-dep.el, composite.el:
* calculator.el, autorevert.el, apropos.el: Don't require CL.
* emacs-bytecomp.el (byte-recompile-directory, display-call-tree)
(byte-compile-unfold-bcf, byte-compile-check-variable):
* emacs-byte-opt.el (byte-compile-trueconstp)
(byte-compile-nilconstp):
* emacs-autoload.el (make-autoload): Use pcase.
* face-remap.el (text-scale-adjust): Simplify pcase patterns.
2012-07-10 11:51:54 +00:00
|
|
|
|
`(boundaries
|
|
|
|
|
,(max (length s1)
|
|
|
|
|
(+ beg (- (length s1) (length s2))))
|
|
|
|
|
. ,(and (eq (car-safe res) 'boundaries) (cddr res)))))
|
2012-04-25 18:40:42 +00:00
|
|
|
|
((stringp res)
|
|
|
|
|
(if (eq t (compare-strings res 0 (length s2) s2 nil nil
|
|
|
|
|
completion-ignore-case))
|
|
|
|
|
(concat s1 (substring res (length s2)))))
|
|
|
|
|
((eq action t)
|
|
|
|
|
(let ((bounds (completion-boundaries str table pred "")))
|
|
|
|
|
(if (>= (car bounds) (length s2))
|
|
|
|
|
res
|
|
|
|
|
(let ((re (concat "\\`"
|
|
|
|
|
(regexp-quote (substring s2 (car bounds))))))
|
|
|
|
|
(delq nil
|
|
|
|
|
(mapcar (lambda (c)
|
|
|
|
|
(if (string-match re c)
|
|
|
|
|
(substring c (match-end 0))))
|
|
|
|
|
res))))))
|
|
|
|
|
;; E.g. action=nil and it's the only completion.
|
|
|
|
|
(res))))))
|
|
|
|
|
|
2008-04-11 22:28:02 +00:00
|
|
|
|
(defun completion-table-with-context (prefix table string pred action)
|
2008-04-19 03:23:15 +00:00
|
|
|
|
;; TODO: add `suffix' maybe?
|
2012-02-23 04:38:29 +00:00
|
|
|
|
(let ((pred
|
|
|
|
|
(if (not (functionp pred))
|
|
|
|
|
;; Notice that `pred' may not be a function in some abusive cases.
|
|
|
|
|
pred
|
|
|
|
|
;; Predicates are called differently depending on the nature of
|
|
|
|
|
;; the completion table :-(
|
|
|
|
|
(cond
|
|
|
|
|
((vectorp table) ;Obarray.
|
|
|
|
|
(lambda (sym) (funcall pred (concat prefix (symbol-name sym)))))
|
|
|
|
|
((hash-table-p table)
|
|
|
|
|
(lambda (s _v) (funcall pred (concat prefix s))))
|
|
|
|
|
((functionp table)
|
|
|
|
|
(lambda (s) (funcall pred (concat prefix s))))
|
|
|
|
|
(t ;Lists and alists.
|
|
|
|
|
(lambda (s)
|
|
|
|
|
(funcall pred (concat prefix (if (consp s) (car s) s)))))))))
|
|
|
|
|
(if (eq (car-safe action) 'boundaries)
|
|
|
|
|
(let* ((len (length prefix))
|
|
|
|
|
(bound (completion-boundaries string table pred (cdr action))))
|
Reduce use of (require 'cl).
* admin/bzrmerge.el: Use cl-lib.
* leim/quail/hangul.el: Don't require CL.
* leim/quail/ipa.el: Use cl-lib.
* vc/smerge-mode.el, vc/pcvs.el, vc/pcvs-util.el, vc/pcvs-info.el:
* vc/diff-mode.el, vc/cvs-status.el, uniquify.el, scroll-bar.el:
* register.el, progmodes/sh-script.el, net/gnutls.el, net/dbus.el:
* msb.el, mpc.el, minibuffer.el, international/ucs-normalize.el:
* international/quail.el, info-xref.el, imenu.el, image-mode.el:
* font-lock.el, filesets.el, edmacro.el, doc-view.el, bookmark.el:
* battery.el, avoid.el, abbrev.el: Use cl-lib.
* vc/pcvs-parse.el, vc/pcvs-defs.el, vc/log-view.el, vc/log-edit.el:
* vc/diff.el, simple.el, pcomplete.el, lpr.el, comint.el, loadhist.el:
* jit-lock.el, international/iso-ascii.el, info.el, frame.el, bs.el:
* emulation/crisp.el, electric.el, dired.el, cus-dep.el, composite.el:
* calculator.el, autorevert.el, apropos.el: Don't require CL.
* emacs-bytecomp.el (byte-recompile-directory, display-call-tree)
(byte-compile-unfold-bcf, byte-compile-check-variable):
* emacs-byte-opt.el (byte-compile-trueconstp)
(byte-compile-nilconstp):
* emacs-autoload.el (make-autoload): Use pcase.
* face-remap.el (text-scale-adjust): Simplify pcase patterns.
2012-07-10 11:51:54 +00:00
|
|
|
|
`(boundaries ,(+ (car bound) len) . ,(cdr bound)))
|
2012-02-23 04:38:29 +00:00
|
|
|
|
(let ((comp (complete-with-action action table string pred)))
|
|
|
|
|
(cond
|
|
|
|
|
;; In case of try-completion, add the prefix.
|
|
|
|
|
((stringp comp) (concat prefix comp))
|
|
|
|
|
(t comp))))))
|
2008-04-11 22:28:02 +00:00
|
|
|
|
|
|
|
|
|
(defun completion-table-with-terminator (terminator table string pred action)
|
2009-10-21 20:03:57 +00:00
|
|
|
|
"Construct a completion table like TABLE but with an extra TERMINATOR.
|
|
|
|
|
This is meant to be called in a curried way by first passing TERMINATOR
|
|
|
|
|
and TABLE only (via `apply-partially').
|
|
|
|
|
TABLE is a completion table, and TERMINATOR is a string appended to TABLE's
|
|
|
|
|
completion if it is complete. TERMINATOR is also used to determine the
|
2009-10-22 16:14:49 +00:00
|
|
|
|
completion suffix's boundary.
|
|
|
|
|
TERMINATOR can also be a cons cell (TERMINATOR . TERMINATOR-REGEXP)
|
|
|
|
|
in which case TERMINATOR-REGEXP is a regular expression whose submatch
|
|
|
|
|
number 1 should match TERMINATOR. This is used when there is a need to
|
|
|
|
|
distinguish occurrences of the TERMINATOR strings which are really terminators
|
2011-04-20 22:31:06 +00:00
|
|
|
|
from others (e.g. escaped). In this form, the car of TERMINATOR can also be,
|
|
|
|
|
instead of a string, a function that takes the completion and returns the
|
|
|
|
|
\"terminated\" string."
|
2011-03-30 22:25:57 +00:00
|
|
|
|
;; FIXME: This implementation is not right since it only adds the terminator
|
|
|
|
|
;; in try-completion, so any completion-style that builds the completion via
|
|
|
|
|
;; all-completions won't get the terminator, and selecting an entry in
|
|
|
|
|
;; *Completions* won't get the terminator added either.
|
2008-04-19 03:23:15 +00:00
|
|
|
|
(cond
|
2009-10-21 20:03:57 +00:00
|
|
|
|
((eq (car-safe action) 'boundaries)
|
|
|
|
|
(let* ((suffix (cdr action))
|
|
|
|
|
(bounds (completion-boundaries string table pred suffix))
|
2009-10-22 16:14:49 +00:00
|
|
|
|
(terminator-regexp (if (consp terminator)
|
|
|
|
|
(cdr terminator) (regexp-quote terminator)))
|
2011-04-20 22:31:06 +00:00
|
|
|
|
(max (and terminator-regexp
|
|
|
|
|
(string-match terminator-regexp suffix))))
|
Reduce use of (require 'cl).
* admin/bzrmerge.el: Use cl-lib.
* leim/quail/hangul.el: Don't require CL.
* leim/quail/ipa.el: Use cl-lib.
* vc/smerge-mode.el, vc/pcvs.el, vc/pcvs-util.el, vc/pcvs-info.el:
* vc/diff-mode.el, vc/cvs-status.el, uniquify.el, scroll-bar.el:
* register.el, progmodes/sh-script.el, net/gnutls.el, net/dbus.el:
* msb.el, mpc.el, minibuffer.el, international/ucs-normalize.el:
* international/quail.el, info-xref.el, imenu.el, image-mode.el:
* font-lock.el, filesets.el, edmacro.el, doc-view.el, bookmark.el:
* battery.el, avoid.el, abbrev.el: Use cl-lib.
* vc/pcvs-parse.el, vc/pcvs-defs.el, vc/log-view.el, vc/log-edit.el:
* vc/diff.el, simple.el, pcomplete.el, lpr.el, comint.el, loadhist.el:
* jit-lock.el, international/iso-ascii.el, info.el, frame.el, bs.el:
* emulation/crisp.el, electric.el, dired.el, cus-dep.el, composite.el:
* calculator.el, autorevert.el, apropos.el: Don't require CL.
* emacs-bytecomp.el (byte-recompile-directory, display-call-tree)
(byte-compile-unfold-bcf, byte-compile-check-variable):
* emacs-byte-opt.el (byte-compile-trueconstp)
(byte-compile-nilconstp):
* emacs-autoload.el (make-autoload): Use pcase.
* face-remap.el (text-scale-adjust): Simplify pcase patterns.
2012-07-10 11:51:54 +00:00
|
|
|
|
`(boundaries ,(car bounds)
|
|
|
|
|
. ,(min (cdr bounds) (or max (length suffix))))))
|
2008-04-19 03:23:15 +00:00
|
|
|
|
((eq action nil)
|
|
|
|
|
(let ((comp (try-completion string table pred)))
|
2009-10-22 16:14:49 +00:00
|
|
|
|
(if (consp terminator) (setq terminator (car terminator)))
|
2008-04-14 15:10:36 +00:00
|
|
|
|
(if (eq comp t)
|
2011-04-20 22:31:06 +00:00
|
|
|
|
(if (functionp terminator)
|
|
|
|
|
(funcall terminator string)
|
|
|
|
|
(concat string terminator))
|
|
|
|
|
(if (and (stringp comp) (not (zerop (length comp)))
|
|
|
|
|
;; Try to avoid the second call to try-completion, since
|
2009-10-21 20:03:57 +00:00
|
|
|
|
;; it may be very inefficient (because `comp' made us
|
|
|
|
|
;; jump to a new boundary, so we complete in that
|
|
|
|
|
;; boundary with an empty start string).
|
2011-04-20 22:31:06 +00:00
|
|
|
|
(let ((newbounds (completion-boundaries comp table pred "")))
|
|
|
|
|
(< (car newbounds) (length comp)))
|
2008-04-19 03:23:15 +00:00
|
|
|
|
(eq (try-completion comp table pred) t))
|
2011-04-20 22:31:06 +00:00
|
|
|
|
(if (functionp terminator)
|
|
|
|
|
(funcall terminator comp)
|
|
|
|
|
(concat comp terminator))
|
2008-04-19 03:23:15 +00:00
|
|
|
|
comp))))
|
2011-05-31 21:40:30 +00:00
|
|
|
|
;; completion-table-with-terminator is always used for
|
|
|
|
|
;; "sub-completions" so it's only called if the terminator is missing,
|
|
|
|
|
;; in which case `test-completion' should return nil.
|
|
|
|
|
((eq action 'lambda) nil)
|
|
|
|
|
(t
|
2008-05-20 17:03:30 +00:00
|
|
|
|
;; FIXME: We generally want the `try' and `all' behaviors to be
|
|
|
|
|
;; consistent so pcm can merge the `all' output to get the `try' output,
|
|
|
|
|
;; but that sometimes clashes with the need for `all' output to look
|
|
|
|
|
;; good in *Completions*.
|
2008-12-21 05:20:06 +00:00
|
|
|
|
;; (mapcar (lambda (s) (concat s terminator))
|
|
|
|
|
;; (all-completions string table pred))))
|
2011-05-31 21:40:30 +00:00
|
|
|
|
(complete-with-action action table string pred))))
|
2008-04-19 03:23:15 +00:00
|
|
|
|
|
|
|
|
|
(defun completion-table-with-predicate (table pred1 strict string pred2 action)
|
|
|
|
|
"Make a completion table equivalent to TABLE but filtered through PRED1.
|
2008-05-08 03:37:39 +00:00
|
|
|
|
PRED1 is a function of one argument which returns non-nil if and only if the
|
2008-04-19 03:23:15 +00:00
|
|
|
|
argument is an element of TABLE which should be considered for completion.
|
|
|
|
|
STRING, PRED2, and ACTION are the usual arguments to completion tables,
|
|
|
|
|
as described in `try-completion', `all-completions', and `test-completion'.
|
2008-04-21 19:02:54 +00:00
|
|
|
|
If STRICT is t, the predicate always applies; if nil it only applies if
|
|
|
|
|
it does not reduce the set of possible completions to nothing.
|
2008-04-19 03:23:15 +00:00
|
|
|
|
Note: TABLE needs to be a proper completion table which obeys predicates."
|
|
|
|
|
(cond
|
|
|
|
|
((and (not strict) (eq action 'lambda))
|
|
|
|
|
;; Ignore pred1 since it doesn't really have to apply anyway.
|
2008-04-19 03:34:02 +00:00
|
|
|
|
(test-completion string table pred2))
|
2008-04-19 03:23:15 +00:00
|
|
|
|
(t
|
|
|
|
|
(or (complete-with-action action table string
|
2011-09-20 01:06:29 +00:00
|
|
|
|
(if (not (and pred1 pred2))
|
|
|
|
|
(or pred1 pred2)
|
2011-02-21 20:31:07 +00:00
|
|
|
|
(lambda (x)
|
|
|
|
|
;; Call `pred1' first, so that `pred2'
|
|
|
|
|
;; really can't tell that `x' is in table.
|
2011-09-20 01:06:29 +00:00
|
|
|
|
(and (funcall pred1 x) (funcall pred2 x)))))
|
2008-04-19 03:23:15 +00:00
|
|
|
|
;; If completion failed and we're not applying pred1 strictly, try
|
|
|
|
|
;; again without pred1.
|
2011-09-20 01:06:29 +00:00
|
|
|
|
(and (not strict) pred1 pred2
|
2008-04-19 03:23:15 +00:00
|
|
|
|
(complete-with-action action table string pred2))))))
|
2008-04-11 22:28:02 +00:00
|
|
|
|
|
2008-04-13 22:12:02 +00:00
|
|
|
|
(defun completion-table-in-turn (&rest tables)
|
|
|
|
|
"Create a completion table that tries each table in TABLES in turn."
|
2009-10-21 20:03:57 +00:00
|
|
|
|
;; FIXME: the boundaries may come from TABLE1 even when the completion list
|
|
|
|
|
;; is returned by TABLE2 (because TABLE1 returned an empty list).
|
2011-02-21 20:31:07 +00:00
|
|
|
|
(lambda (string pred action)
|
|
|
|
|
(completion--some (lambda (table)
|
|
|
|
|
(complete-with-action action table string pred))
|
|
|
|
|
tables)))
|
2008-04-13 22:12:02 +00:00
|
|
|
|
|
2012-04-25 18:40:42 +00:00
|
|
|
|
(defun completion-table-with-quoting (table unquote requote)
|
|
|
|
|
;; A difficult part of completion-with-quoting is to map positions in the
|
|
|
|
|
;; quoted string to equivalent positions in the unquoted string and
|
|
|
|
|
;; vice-versa. There is no efficient and reliable algorithm that works for
|
|
|
|
|
;; arbitrary quote and unquote functions.
|
|
|
|
|
;; So to map from quoted positions to unquoted positions, we simply assume
|
|
|
|
|
;; that `concat' and `unquote' commute (which tends to be the case).
|
|
|
|
|
;; And we ask `requote' to do the work of mapping from unquoted positions
|
|
|
|
|
;; back to quoted positions.
|
2012-10-28 18:48:17 +00:00
|
|
|
|
;; FIXME: For some forms of "quoting" such as the truncation behavior of
|
|
|
|
|
;; substitute-in-file-name, it would be desirable not to requote completely.
|
2012-04-25 18:40:42 +00:00
|
|
|
|
"Return a new completion table operating on quoted text.
|
|
|
|
|
TABLE operates on the unquoted text.
|
|
|
|
|
UNQUOTE is a function that takes a string and returns a new unquoted string.
|
|
|
|
|
REQUOTE is a function of 2 args (UPOS QSTR) where
|
|
|
|
|
QSTR is a string entered by the user (and hence indicating
|
|
|
|
|
the user's preferred form of quoting); and
|
|
|
|
|
UPOS is a position within the unquoted form of QSTR.
|
|
|
|
|
REQUOTE should return a pair (QPOS . QFUN) such that QPOS is the
|
|
|
|
|
position corresponding to UPOS but in QSTR, and QFUN is a function
|
|
|
|
|
of one argument (a string) which returns that argument appropriately quoted
|
|
|
|
|
for use at QPOS."
|
|
|
|
|
;; FIXME: One problem with the current setup is that `qfun' doesn't know if
|
|
|
|
|
;; its argument is "the end of the completion", so if the quoting used double
|
|
|
|
|
;; quotes (for example), we end up completing "fo" to "foobar and throwing
|
|
|
|
|
;; away the closing double quote.
|
|
|
|
|
(lambda (string pred action)
|
|
|
|
|
(cond
|
|
|
|
|
((eq action 'metadata)
|
|
|
|
|
(append (completion-metadata string table pred)
|
|
|
|
|
'((completion--unquote-requote . t))))
|
|
|
|
|
|
|
|
|
|
((eq action 'lambda) ;;test-completion
|
|
|
|
|
(let ((ustring (funcall unquote string)))
|
|
|
|
|
(test-completion ustring table pred)))
|
|
|
|
|
|
|
|
|
|
((eq (car-safe action) 'boundaries)
|
|
|
|
|
(let* ((ustring (funcall unquote string))
|
|
|
|
|
(qsuffix (cdr action))
|
|
|
|
|
(ufull (if (zerop (length qsuffix)) ustring
|
|
|
|
|
(funcall unquote (concat string qsuffix))))
|
Reduce use of (require 'cl).
* admin/bzrmerge.el: Use cl-lib.
* leim/quail/hangul.el: Don't require CL.
* leim/quail/ipa.el: Use cl-lib.
* vc/smerge-mode.el, vc/pcvs.el, vc/pcvs-util.el, vc/pcvs-info.el:
* vc/diff-mode.el, vc/cvs-status.el, uniquify.el, scroll-bar.el:
* register.el, progmodes/sh-script.el, net/gnutls.el, net/dbus.el:
* msb.el, mpc.el, minibuffer.el, international/ucs-normalize.el:
* international/quail.el, info-xref.el, imenu.el, image-mode.el:
* font-lock.el, filesets.el, edmacro.el, doc-view.el, bookmark.el:
* battery.el, avoid.el, abbrev.el: Use cl-lib.
* vc/pcvs-parse.el, vc/pcvs-defs.el, vc/log-view.el, vc/log-edit.el:
* vc/diff.el, simple.el, pcomplete.el, lpr.el, comint.el, loadhist.el:
* jit-lock.el, international/iso-ascii.el, info.el, frame.el, bs.el:
* emulation/crisp.el, electric.el, dired.el, cus-dep.el, composite.el:
* calculator.el, autorevert.el, apropos.el: Don't require CL.
* emacs-bytecomp.el (byte-recompile-directory, display-call-tree)
(byte-compile-unfold-bcf, byte-compile-check-variable):
* emacs-byte-opt.el (byte-compile-trueconstp)
(byte-compile-nilconstp):
* emacs-autoload.el (make-autoload): Use pcase.
* face-remap.el (text-scale-adjust): Simplify pcase patterns.
2012-07-10 11:51:54 +00:00
|
|
|
|
(_ (cl-assert (string-prefix-p ustring ufull)))
|
2012-04-25 18:40:42 +00:00
|
|
|
|
(usuffix (substring ufull (length ustring)))
|
|
|
|
|
(boundaries (completion-boundaries ustring table pred usuffix))
|
|
|
|
|
(qlboundary (car (funcall requote (car boundaries) string)))
|
|
|
|
|
(qrboundary (if (zerop (cdr boundaries)) 0 ;Common case.
|
|
|
|
|
(let* ((urfullboundary
|
|
|
|
|
(+ (cdr boundaries) (length ustring))))
|
|
|
|
|
(- (car (funcall requote urfullboundary
|
|
|
|
|
(concat string qsuffix)))
|
|
|
|
|
(length string))))))
|
Reduce use of (require 'cl).
* admin/bzrmerge.el: Use cl-lib.
* leim/quail/hangul.el: Don't require CL.
* leim/quail/ipa.el: Use cl-lib.
* vc/smerge-mode.el, vc/pcvs.el, vc/pcvs-util.el, vc/pcvs-info.el:
* vc/diff-mode.el, vc/cvs-status.el, uniquify.el, scroll-bar.el:
* register.el, progmodes/sh-script.el, net/gnutls.el, net/dbus.el:
* msb.el, mpc.el, minibuffer.el, international/ucs-normalize.el:
* international/quail.el, info-xref.el, imenu.el, image-mode.el:
* font-lock.el, filesets.el, edmacro.el, doc-view.el, bookmark.el:
* battery.el, avoid.el, abbrev.el: Use cl-lib.
* vc/pcvs-parse.el, vc/pcvs-defs.el, vc/log-view.el, vc/log-edit.el:
* vc/diff.el, simple.el, pcomplete.el, lpr.el, comint.el, loadhist.el:
* jit-lock.el, international/iso-ascii.el, info.el, frame.el, bs.el:
* emulation/crisp.el, electric.el, dired.el, cus-dep.el, composite.el:
* calculator.el, autorevert.el, apropos.el: Don't require CL.
* emacs-bytecomp.el (byte-recompile-directory, display-call-tree)
(byte-compile-unfold-bcf, byte-compile-check-variable):
* emacs-byte-opt.el (byte-compile-trueconstp)
(byte-compile-nilconstp):
* emacs-autoload.el (make-autoload): Use pcase.
* face-remap.el (text-scale-adjust): Simplify pcase patterns.
2012-07-10 11:51:54 +00:00
|
|
|
|
`(boundaries ,qlboundary . ,qrboundary)))
|
2012-04-25 18:40:42 +00:00
|
|
|
|
|
2012-05-01 00:21:23 +00:00
|
|
|
|
;; In "normal" use a c-t-with-quoting completion table should never be
|
|
|
|
|
;; called with action in (t nil) because `completion--unquote' should have
|
|
|
|
|
;; been called before and would have returned a different completion table
|
|
|
|
|
;; to apply to the unquoted text. But there's still a lot of code around
|
|
|
|
|
;; that likes to use all/try-completions directly, so we do our best to
|
|
|
|
|
;; handle those calls as well as we can.
|
|
|
|
|
|
2012-04-25 18:40:42 +00:00
|
|
|
|
((eq action nil) ;;try-completion
|
|
|
|
|
(let* ((ustring (funcall unquote string))
|
|
|
|
|
(completion (try-completion ustring table pred)))
|
|
|
|
|
;; Most forms of quoting allow several ways to quote the same string.
|
|
|
|
|
;; So here we could simply requote `completion' in a kind of
|
|
|
|
|
;; "canonical" quoted form without paying attention to the way
|
|
|
|
|
;; `string' was quoted. But since we have to solve the more complex
|
|
|
|
|
;; problems of "pay attention to the original quoting" for
|
|
|
|
|
;; all-completions, we may as well use it here, since it provides
|
|
|
|
|
;; a nicer behavior.
|
|
|
|
|
(if (not (stringp completion)) completion
|
|
|
|
|
(car (completion--twq-try
|
|
|
|
|
string ustring completion 0 unquote requote)))))
|
|
|
|
|
|
|
|
|
|
((eq action t) ;;all-completions
|
|
|
|
|
;; When all-completions is used for completion-try/all-completions
|
|
|
|
|
;; (e.g. for `pcm' style), we can't do the job properly here because
|
|
|
|
|
;; the caller will match our output against some pattern derived from
|
|
|
|
|
;; the user's (quoted) input, and we don't have access to that
|
|
|
|
|
;; pattern, so we can't know how to requote our output so that it
|
|
|
|
|
;; matches the quoting used in the pattern. It is to fix this
|
|
|
|
|
;; fundamental problem that we have to introduce the new
|
|
|
|
|
;; unquote-requote method so that completion-try/all-completions can
|
|
|
|
|
;; pass the unquoted string to the style functions.
|
|
|
|
|
(pcase-let*
|
|
|
|
|
((ustring (funcall unquote string))
|
|
|
|
|
(completions (all-completions ustring table pred))
|
2012-05-01 00:21:23 +00:00
|
|
|
|
(boundary (car (completion-boundaries ustring table pred "")))
|
|
|
|
|
(completions
|
|
|
|
|
(completion--twq-all
|
|
|
|
|
string ustring completions boundary unquote requote))
|
|
|
|
|
(last (last completions)))
|
|
|
|
|
(when (consp last) (setcdr last nil))
|
|
|
|
|
completions))
|
2012-06-18 20:39:52 +00:00
|
|
|
|
|
2012-04-25 18:40:42 +00:00
|
|
|
|
((eq action 'completion--unquote)
|
|
|
|
|
(let ((ustring (funcall unquote string))
|
|
|
|
|
(uprefix (funcall unquote (substring string 0 pred))))
|
|
|
|
|
;; We presume (more or less) that `concat' and `unquote' commute.
|
Reduce use of (require 'cl).
* admin/bzrmerge.el: Use cl-lib.
* leim/quail/hangul.el: Don't require CL.
* leim/quail/ipa.el: Use cl-lib.
* vc/smerge-mode.el, vc/pcvs.el, vc/pcvs-util.el, vc/pcvs-info.el:
* vc/diff-mode.el, vc/cvs-status.el, uniquify.el, scroll-bar.el:
* register.el, progmodes/sh-script.el, net/gnutls.el, net/dbus.el:
* msb.el, mpc.el, minibuffer.el, international/ucs-normalize.el:
* international/quail.el, info-xref.el, imenu.el, image-mode.el:
* font-lock.el, filesets.el, edmacro.el, doc-view.el, bookmark.el:
* battery.el, avoid.el, abbrev.el: Use cl-lib.
* vc/pcvs-parse.el, vc/pcvs-defs.el, vc/log-view.el, vc/log-edit.el:
* vc/diff.el, simple.el, pcomplete.el, lpr.el, comint.el, loadhist.el:
* jit-lock.el, international/iso-ascii.el, info.el, frame.el, bs.el:
* emulation/crisp.el, electric.el, dired.el, cus-dep.el, composite.el:
* calculator.el, autorevert.el, apropos.el: Don't require CL.
* emacs-bytecomp.el (byte-recompile-directory, display-call-tree)
(byte-compile-unfold-bcf, byte-compile-check-variable):
* emacs-byte-opt.el (byte-compile-trueconstp)
(byte-compile-nilconstp):
* emacs-autoload.el (make-autoload): Use pcase.
* face-remap.el (text-scale-adjust): Simplify pcase patterns.
2012-07-10 11:51:54 +00:00
|
|
|
|
(cl-assert (string-prefix-p uprefix ustring))
|
2012-04-25 18:40:42 +00:00
|
|
|
|
(list ustring table (length uprefix)
|
|
|
|
|
(lambda (unquoted-result op)
|
|
|
|
|
(pcase op
|
Reduce use of (require 'cl).
* admin/bzrmerge.el: Use cl-lib.
* leim/quail/hangul.el: Don't require CL.
* leim/quail/ipa.el: Use cl-lib.
* vc/smerge-mode.el, vc/pcvs.el, vc/pcvs-util.el, vc/pcvs-info.el:
* vc/diff-mode.el, vc/cvs-status.el, uniquify.el, scroll-bar.el:
* register.el, progmodes/sh-script.el, net/gnutls.el, net/dbus.el:
* msb.el, mpc.el, minibuffer.el, international/ucs-normalize.el:
* international/quail.el, info-xref.el, imenu.el, image-mode.el:
* font-lock.el, filesets.el, edmacro.el, doc-view.el, bookmark.el:
* battery.el, avoid.el, abbrev.el: Use cl-lib.
* vc/pcvs-parse.el, vc/pcvs-defs.el, vc/log-view.el, vc/log-edit.el:
* vc/diff.el, simple.el, pcomplete.el, lpr.el, comint.el, loadhist.el:
* jit-lock.el, international/iso-ascii.el, info.el, frame.el, bs.el:
* emulation/crisp.el, electric.el, dired.el, cus-dep.el, composite.el:
* calculator.el, autorevert.el, apropos.el: Don't require CL.
* emacs-bytecomp.el (byte-recompile-directory, display-call-tree)
(byte-compile-unfold-bcf, byte-compile-check-variable):
* emacs-byte-opt.el (byte-compile-trueconstp)
(byte-compile-nilconstp):
* emacs-autoload.el (make-autoload): Use pcase.
* face-remap.el (text-scale-adjust): Simplify pcase patterns.
2012-07-10 11:51:54 +00:00
|
|
|
|
(1 ;;try
|
2012-04-25 18:40:42 +00:00
|
|
|
|
(if (not (stringp (car-safe unquoted-result)))
|
|
|
|
|
unquoted-result
|
|
|
|
|
(completion--twq-try
|
|
|
|
|
string ustring
|
|
|
|
|
(car unquoted-result) (cdr unquoted-result)
|
|
|
|
|
unquote requote)))
|
Reduce use of (require 'cl).
* admin/bzrmerge.el: Use cl-lib.
* leim/quail/hangul.el: Don't require CL.
* leim/quail/ipa.el: Use cl-lib.
* vc/smerge-mode.el, vc/pcvs.el, vc/pcvs-util.el, vc/pcvs-info.el:
* vc/diff-mode.el, vc/cvs-status.el, uniquify.el, scroll-bar.el:
* register.el, progmodes/sh-script.el, net/gnutls.el, net/dbus.el:
* msb.el, mpc.el, minibuffer.el, international/ucs-normalize.el:
* international/quail.el, info-xref.el, imenu.el, image-mode.el:
* font-lock.el, filesets.el, edmacro.el, doc-view.el, bookmark.el:
* battery.el, avoid.el, abbrev.el: Use cl-lib.
* vc/pcvs-parse.el, vc/pcvs-defs.el, vc/log-view.el, vc/log-edit.el:
* vc/diff.el, simple.el, pcomplete.el, lpr.el, comint.el, loadhist.el:
* jit-lock.el, international/iso-ascii.el, info.el, frame.el, bs.el:
* emulation/crisp.el, electric.el, dired.el, cus-dep.el, composite.el:
* calculator.el, autorevert.el, apropos.el: Don't require CL.
* emacs-bytecomp.el (byte-recompile-directory, display-call-tree)
(byte-compile-unfold-bcf, byte-compile-check-variable):
* emacs-byte-opt.el (byte-compile-trueconstp)
(byte-compile-nilconstp):
* emacs-autoload.el (make-autoload): Use pcase.
* face-remap.el (text-scale-adjust): Simplify pcase patterns.
2012-07-10 11:51:54 +00:00
|
|
|
|
(2 ;;all
|
2012-04-25 18:40:42 +00:00
|
|
|
|
(let* ((last (last unquoted-result))
|
|
|
|
|
(base (or (cdr last) 0)))
|
|
|
|
|
(when last
|
|
|
|
|
(setcdr last nil)
|
|
|
|
|
(completion--twq-all string ustring
|
|
|
|
|
unquoted-result base
|
|
|
|
|
unquote requote))))))))))))
|
|
|
|
|
|
|
|
|
|
(defun completion--twq-try (string ustring completion point
|
|
|
|
|
unquote requote)
|
2012-06-23 03:48:18 +00:00
|
|
|
|
;; Basically two cases: either the new result is
|
2012-04-25 18:40:42 +00:00
|
|
|
|
;; - commonprefix1 <point> morecommonprefix <qpos> suffix
|
|
|
|
|
;; - commonprefix <qpos> newprefix <point> suffix
|
|
|
|
|
(pcase-let*
|
|
|
|
|
((prefix (fill-common-string-prefix ustring completion))
|
|
|
|
|
(suffix (substring completion (max point (length prefix))))
|
|
|
|
|
(`(,qpos . ,qfun) (funcall requote (length prefix) string))
|
|
|
|
|
(qstr1 (if (> point (length prefix))
|
|
|
|
|
(funcall qfun (substring completion (length prefix) point))))
|
|
|
|
|
(qsuffix (funcall qfun suffix))
|
|
|
|
|
(qstring (concat (substring string 0 qpos) qstr1 qsuffix))
|
|
|
|
|
(qpoint
|
|
|
|
|
(cond
|
|
|
|
|
((zerop point) 0)
|
|
|
|
|
((> point (length prefix)) (+ qpos (length qstr1)))
|
|
|
|
|
(t (car (funcall requote point string))))))
|
|
|
|
|
;; Make sure `requote' worked.
|
2012-06-23 03:48:18 +00:00
|
|
|
|
(if (equal (funcall unquote qstring) completion)
|
|
|
|
|
(cons qstring qpoint)
|
|
|
|
|
;; If requote failed (e.g. because sifn-requote did not handle
|
|
|
|
|
;; Tramp's "/foo:/bar//baz -> /foo:/baz" truncation), then at least
|
|
|
|
|
;; try requote properly.
|
|
|
|
|
(let ((qstr (funcall qfun completion)))
|
|
|
|
|
(cons qstr (length qstr))))))
|
2012-04-25 18:40:42 +00:00
|
|
|
|
|
2012-05-15 18:07:36 +00:00
|
|
|
|
(defun completion--string-equal-p (s1 s2)
|
|
|
|
|
(eq t (compare-strings s1 nil nil s2 nil nil 'ignore-case)))
|
|
|
|
|
|
2012-04-25 18:40:42 +00:00
|
|
|
|
(defun completion--twq-all (string ustring completions boundary
|
2013-04-16 02:41:37 +00:00
|
|
|
|
_unquote requote)
|
2012-04-25 18:40:42 +00:00
|
|
|
|
(when completions
|
|
|
|
|
(pcase-let*
|
|
|
|
|
((prefix
|
|
|
|
|
(let ((completion-regexp-list nil))
|
|
|
|
|
(try-completion "" (cons (substring ustring boundary)
|
|
|
|
|
completions))))
|
|
|
|
|
(`(,qfullpos . ,qfun)
|
|
|
|
|
(funcall requote (+ boundary (length prefix)) string))
|
|
|
|
|
(qfullprefix (substring string 0 qfullpos))
|
2012-10-28 19:07:52 +00:00
|
|
|
|
;; FIXME: This assertion can be wrong, e.g. in Cygwin, where
|
|
|
|
|
;; (unquote "c:\bin") => "/usr/bin" but (unquote "c:\") => "/".
|
|
|
|
|
;;(cl-assert (completion--string-equal-p
|
|
|
|
|
;; (funcall unquote qfullprefix)
|
|
|
|
|
;; (concat (substring ustring 0 boundary) prefix))
|
|
|
|
|
;; t))
|
2012-04-25 18:40:42 +00:00
|
|
|
|
(qboundary (car (funcall requote boundary string)))
|
Reduce use of (require 'cl).
* admin/bzrmerge.el: Use cl-lib.
* leim/quail/hangul.el: Don't require CL.
* leim/quail/ipa.el: Use cl-lib.
* vc/smerge-mode.el, vc/pcvs.el, vc/pcvs-util.el, vc/pcvs-info.el:
* vc/diff-mode.el, vc/cvs-status.el, uniquify.el, scroll-bar.el:
* register.el, progmodes/sh-script.el, net/gnutls.el, net/dbus.el:
* msb.el, mpc.el, minibuffer.el, international/ucs-normalize.el:
* international/quail.el, info-xref.el, imenu.el, image-mode.el:
* font-lock.el, filesets.el, edmacro.el, doc-view.el, bookmark.el:
* battery.el, avoid.el, abbrev.el: Use cl-lib.
* vc/pcvs-parse.el, vc/pcvs-defs.el, vc/log-view.el, vc/log-edit.el:
* vc/diff.el, simple.el, pcomplete.el, lpr.el, comint.el, loadhist.el:
* jit-lock.el, international/iso-ascii.el, info.el, frame.el, bs.el:
* emulation/crisp.el, electric.el, dired.el, cus-dep.el, composite.el:
* calculator.el, autorevert.el, apropos.el: Don't require CL.
* emacs-bytecomp.el (byte-recompile-directory, display-call-tree)
(byte-compile-unfold-bcf, byte-compile-check-variable):
* emacs-byte-opt.el (byte-compile-trueconstp)
(byte-compile-nilconstp):
* emacs-autoload.el (make-autoload): Use pcase.
* face-remap.el (text-scale-adjust): Simplify pcase patterns.
2012-07-10 11:51:54 +00:00
|
|
|
|
(_ (cl-assert (<= qboundary qfullpos)))
|
2012-04-25 18:40:42 +00:00
|
|
|
|
;; FIXME: this split/quote/concat business messes up the carefully
|
|
|
|
|
;; placed completions-common-part and completions-first-difference
|
|
|
|
|
;; faces. We could try within the mapcar loop to search for the
|
|
|
|
|
;; boundaries of those faces, pass them to `requote' to find their
|
|
|
|
|
;; equivalent positions in the quoted output and re-add the faces:
|
|
|
|
|
;; this might actually lead to correct results but would be
|
|
|
|
|
;; pretty expensive.
|
|
|
|
|
;; The better solution is to not quote the *Completions* display,
|
|
|
|
|
;; which nicely circumvents the problem. The solution I used here
|
|
|
|
|
;; instead is to hope that `qfun' preserves the text-properties and
|
|
|
|
|
;; presume that the `first-difference' is not within the `prefix';
|
|
|
|
|
;; this presumption is not always true, but at least in practice it is
|
|
|
|
|
;; true in most cases.
|
|
|
|
|
(qprefix (propertize (substring qfullprefix qboundary)
|
|
|
|
|
'face 'completions-common-part)))
|
|
|
|
|
|
|
|
|
|
;; Here we choose to quote all elements returned, but a better option
|
|
|
|
|
;; would be to return unquoted elements together with a function to
|
|
|
|
|
;; requote them, so that *Completions* can show nicer unquoted values
|
|
|
|
|
;; which only get quoted when needed by choose-completion.
|
|
|
|
|
(nconc
|
|
|
|
|
(mapcar (lambda (completion)
|
Reduce use of (require 'cl).
* admin/bzrmerge.el: Use cl-lib.
* leim/quail/hangul.el: Don't require CL.
* leim/quail/ipa.el: Use cl-lib.
* vc/smerge-mode.el, vc/pcvs.el, vc/pcvs-util.el, vc/pcvs-info.el:
* vc/diff-mode.el, vc/cvs-status.el, uniquify.el, scroll-bar.el:
* register.el, progmodes/sh-script.el, net/gnutls.el, net/dbus.el:
* msb.el, mpc.el, minibuffer.el, international/ucs-normalize.el:
* international/quail.el, info-xref.el, imenu.el, image-mode.el:
* font-lock.el, filesets.el, edmacro.el, doc-view.el, bookmark.el:
* battery.el, avoid.el, abbrev.el: Use cl-lib.
* vc/pcvs-parse.el, vc/pcvs-defs.el, vc/log-view.el, vc/log-edit.el:
* vc/diff.el, simple.el, pcomplete.el, lpr.el, comint.el, loadhist.el:
* jit-lock.el, international/iso-ascii.el, info.el, frame.el, bs.el:
* emulation/crisp.el, electric.el, dired.el, cus-dep.el, composite.el:
* calculator.el, autorevert.el, apropos.el: Don't require CL.
* emacs-bytecomp.el (byte-recompile-directory, display-call-tree)
(byte-compile-unfold-bcf, byte-compile-check-variable):
* emacs-byte-opt.el (byte-compile-trueconstp)
(byte-compile-nilconstp):
* emacs-autoload.el (make-autoload): Use pcase.
* face-remap.el (text-scale-adjust): Simplify pcase patterns.
2012-07-10 11:51:54 +00:00
|
|
|
|
(cl-assert (string-prefix-p prefix completion 'ignore-case) t)
|
2012-04-25 18:40:42 +00:00
|
|
|
|
(let* ((new (substring completion (length prefix)))
|
|
|
|
|
(qnew (funcall qfun new))
|
2013-07-30 20:42:15 +00:00
|
|
|
|
(qprefix
|
|
|
|
|
(if (not completion-ignore-case)
|
|
|
|
|
qprefix
|
|
|
|
|
;; Make qprefix inherit the case from `completion'.
|
|
|
|
|
(let* ((rest (substring completion
|
|
|
|
|
0 (length prefix)))
|
|
|
|
|
(qrest (funcall qfun rest)))
|
|
|
|
|
(if (completion--string-equal-p qprefix qrest)
|
|
|
|
|
(propertize qrest 'face
|
|
|
|
|
'completions-common-part)
|
|
|
|
|
qprefix))))
|
2012-04-25 18:40:42 +00:00
|
|
|
|
(qcompletion (concat qprefix qnew)))
|
2012-10-28 19:07:52 +00:00
|
|
|
|
;; FIXME: Similarly here, Cygwin's mapping trips this
|
|
|
|
|
;; assertion.
|
|
|
|
|
;;(cl-assert
|
|
|
|
|
;; (completion--string-equal-p
|
|
|
|
|
;; (funcall unquote
|
|
|
|
|
;; (concat (substring string 0 qboundary)
|
|
|
|
|
;; qcompletion))
|
|
|
|
|
;; (concat (substring ustring 0 boundary)
|
|
|
|
|
;; completion))
|
|
|
|
|
;; t)
|
2012-04-25 18:40:42 +00:00
|
|
|
|
qcompletion))
|
|
|
|
|
completions)
|
|
|
|
|
qboundary))))
|
|
|
|
|
|
2008-04-19 03:23:15 +00:00
|
|
|
|
;; (defmacro complete-in-turn (a b) `(completion-table-in-turn ,a ,b))
|
|
|
|
|
;; (defmacro dynamic-completion-table (fun) `(completion-table-dynamic ,fun))
|
2008-04-13 22:12:02 +00:00
|
|
|
|
(define-obsolete-function-alias
|
|
|
|
|
'complete-in-turn 'completion-table-in-turn "23.1")
|
2008-04-19 03:23:15 +00:00
|
|
|
|
(define-obsolete-function-alias
|
|
|
|
|
'dynamic-completion-table 'completion-table-dynamic "23.1")
|
2008-04-11 22:28:02 +00:00
|
|
|
|
|
|
|
|
|
;;; Minibuffer completion
|
|
|
|
|
|
2008-04-09 19:33:56 +00:00
|
|
|
|
(defgroup minibuffer nil
|
|
|
|
|
"Controlling the behavior of the minibuffer."
|
|
|
|
|
:link '(custom-manual "(emacs)Minibuffer")
|
|
|
|
|
:group 'environment)
|
|
|
|
|
|
2008-04-09 03:34:19 +00:00
|
|
|
|
(defun minibuffer-message (message &rest args)
|
|
|
|
|
"Temporarily display MESSAGE at the end of the minibuffer.
|
|
|
|
|
The text is displayed for `minibuffer-message-timeout' seconds,
|
|
|
|
|
or until the next input event arrives, whichever comes first.
|
|
|
|
|
Enclose MESSAGE in [...] if this is not yet the case.
|
|
|
|
|
If ARGS are provided, then pass MESSAGE through `format'."
|
2009-08-30 03:45:30 +00:00
|
|
|
|
(if (not (minibufferp (current-buffer)))
|
|
|
|
|
(progn
|
|
|
|
|
(if args
|
|
|
|
|
(apply 'message message args)
|
|
|
|
|
(message "%s" message))
|
|
|
|
|
(prog1 (sit-for (or minibuffer-message-timeout 1000000))
|
|
|
|
|
(message nil)))
|
|
|
|
|
;; Clear out any old echo-area message to make way for our new thing.
|
|
|
|
|
(message nil)
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(setq message (if (and (null args)
|
|
|
|
|
(string-match-p "\\` *\\[.+\\]\\'" message))
|
2009-08-30 03:45:30 +00:00
|
|
|
|
;; Make sure we can put-text-property.
|
|
|
|
|
(copy-sequence message)
|
|
|
|
|
(concat " [" message "]")))
|
|
|
|
|
(when args (setq message (apply 'format message args)))
|
|
|
|
|
(let ((ol (make-overlay (point-max) (point-max) nil t t))
|
|
|
|
|
;; A quit during sit-for normally only interrupts the sit-for,
|
|
|
|
|
;; but since minibuffer-message is used at the end of a command,
|
|
|
|
|
;; at a time when the command has virtually finished already, a C-g
|
|
|
|
|
;; should really cause an abort-recursive-edit instead (i.e. as if
|
|
|
|
|
;; the C-g had been typed at top-level). Binding inhibit-quit here
|
|
|
|
|
;; is an attempt to get that behavior.
|
|
|
|
|
(inhibit-quit t))
|
|
|
|
|
(unwind-protect
|
|
|
|
|
(progn
|
|
|
|
|
(unless (zerop (length message))
|
|
|
|
|
;; The current C cursor code doesn't know to use the overlay's
|
|
|
|
|
;; marker's stickiness to figure out whether to place the cursor
|
|
|
|
|
;; before or after the string, so let's spoon-feed it the pos.
|
|
|
|
|
(put-text-property 0 1 'cursor t message))
|
|
|
|
|
(overlay-put ol 'after-string message)
|
|
|
|
|
(sit-for (or minibuffer-message-timeout 1000000)))
|
|
|
|
|
(delete-overlay ol)))))
|
2008-04-09 03:34:19 +00:00
|
|
|
|
|
|
|
|
|
(defun minibuffer-completion-contents ()
|
|
|
|
|
"Return the user input in a minibuffer before point as a string.
|
2013-04-23 12:27:06 +00:00
|
|
|
|
In Emacs-22, that was what completion commands operated on."
|
|
|
|
|
(declare (obsolete nil "24.4"))
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(buffer-substring (minibuffer-prompt-end) (point)))
|
2008-04-09 03:34:19 +00:00
|
|
|
|
|
|
|
|
|
(defun delete-minibuffer-contents ()
|
|
|
|
|
"Delete all user input in a minibuffer.
|
|
|
|
|
If the current buffer is not a minibuffer, erase its entire contents."
|
2012-10-06 17:29:15 +00:00
|
|
|
|
(interactive)
|
2008-10-29 21:30:44 +00:00
|
|
|
|
;; We used to do `delete-field' here, but when file name shadowing
|
|
|
|
|
;; is on, the field doesn't cover the entire minibuffer contents.
|
|
|
|
|
(delete-region (minibuffer-prompt-end) (point-max)))
|
2008-04-09 03:34:19 +00:00
|
|
|
|
|
2011-04-10 21:31:14 +00:00
|
|
|
|
(defvar completion-show-inline-help t
|
|
|
|
|
"If non-nil, print helpful inline messages during completion.")
|
|
|
|
|
|
2008-04-09 19:33:56 +00:00
|
|
|
|
(defcustom completion-auto-help t
|
|
|
|
|
"Non-nil means automatically provide help for invalid completion input.
|
|
|
|
|
If the value is t the *Completion* buffer is displayed whenever completion
|
|
|
|
|
is requested but cannot be done.
|
|
|
|
|
If the value is `lazy', the *Completions* buffer is only displayed after
|
|
|
|
|
the second failed attempt to complete."
|
2013-09-06 22:46:44 +00:00
|
|
|
|
:type '(choice (const nil) (const t) (const lazy)))
|
2008-04-09 19:33:56 +00:00
|
|
|
|
|
2009-11-11 06:36:41 +00:00
|
|
|
|
(defconst completion-styles-alist
|
2009-09-01 19:49:34 +00:00
|
|
|
|
'((emacs21
|
|
|
|
|
completion-emacs21-try-completion completion-emacs21-all-completions
|
2010-04-19 13:17:40 +00:00
|
|
|
|
"Simple prefix-based completion.
|
|
|
|
|
I.e. when completing \"foo_bar\" (where _ is the position of point),
|
|
|
|
|
it will consider all completions candidates matching the glob
|
|
|
|
|
pattern \"foobar*\".")
|
2009-09-01 19:49:34 +00:00
|
|
|
|
(emacs22
|
|
|
|
|
completion-emacs22-try-completion completion-emacs22-all-completions
|
2010-04-19 13:17:40 +00:00
|
|
|
|
"Prefix completion that only operates on the text before point.
|
|
|
|
|
I.e. when completing \"foo_bar\" (where _ is the position of point),
|
|
|
|
|
it will consider all completions candidates matching the glob
|
|
|
|
|
pattern \"foo*\" and will add back \"bar\" to the end of it.")
|
2009-09-01 19:49:34 +00:00
|
|
|
|
(basic
|
|
|
|
|
completion-basic-try-completion completion-basic-all-completions
|
2010-04-19 13:17:40 +00:00
|
|
|
|
"Completion of the prefix before point and the suffix after point.
|
|
|
|
|
I.e. when completing \"foo_bar\" (where _ is the position of point),
|
|
|
|
|
it will consider all completions candidates matching the glob
|
|
|
|
|
pattern \"foo*bar*\".")
|
2008-04-26 01:47:11 +00:00
|
|
|
|
(partial-completion
|
2009-09-01 19:49:34 +00:00
|
|
|
|
completion-pcm-try-completion completion-pcm-all-completions
|
|
|
|
|
"Completion of multiple words, each one taken as a prefix.
|
2010-04-19 13:17:40 +00:00
|
|
|
|
I.e. when completing \"l-co_h\" (where _ is the position of point),
|
|
|
|
|
it will consider all completions candidates matching the glob
|
|
|
|
|
pattern \"l*-co*h*\".
|
|
|
|
|
Furthermore, for completions that are done step by step in subfields,
|
|
|
|
|
the method is applied to all the preceding fields that do not yet match.
|
|
|
|
|
E.g. C-x C-f /u/mo/s TAB could complete to /usr/monnier/src.
|
|
|
|
|
Additionally the user can use the char \"*\" as a glob pattern.")
|
2010-04-19 18:33:11 +00:00
|
|
|
|
(substring
|
|
|
|
|
completion-substring-try-completion completion-substring-all-completions
|
|
|
|
|
"Completion of the string taken as a substring.
|
|
|
|
|
I.e. when completing \"foo_bar\" (where _ is the position of point),
|
|
|
|
|
it will consider all completions candidates matching the glob
|
|
|
|
|
pattern \"*foo*bar*\".")
|
2009-09-01 19:49:34 +00:00
|
|
|
|
(initials
|
|
|
|
|
completion-initials-try-completion completion-initials-all-completions
|
|
|
|
|
"Completion of acronyms and initialisms.
|
|
|
|
|
E.g. can complete M-x lch to list-command-history
|
|
|
|
|
and C-x C-f ~/sew to ~/src/emacs/work."))
|
2008-04-13 22:12:02 +00:00
|
|
|
|
"List of available completion styles.
|
2009-09-01 19:49:34 +00:00
|
|
|
|
Each element has the form (NAME TRY-COMPLETION ALL-COMPLETIONS DOC):
|
2008-04-26 12:58:13 +00:00
|
|
|
|
where NAME is the name that should be used in `completion-styles',
|
2009-09-01 19:49:34 +00:00
|
|
|
|
TRY-COMPLETION is the function that does the completion (it should
|
|
|
|
|
follow the same calling convention as `completion-try-completion'),
|
|
|
|
|
ALL-COMPLETIONS is the function that lists the completions (it should
|
|
|
|
|
follow the calling convention of `completion-all-completions'),
|
|
|
|
|
and DOC describes the way this style of completion works.")
|
2008-04-13 22:12:02 +00:00
|
|
|
|
|
2011-10-03 15:03:00 +00:00
|
|
|
|
(defconst completion--styles-type
|
|
|
|
|
`(repeat :tag "insert a new menu to add more styles"
|
|
|
|
|
(choice ,@(mapcar (lambda (x) (list 'const (car x)))
|
|
|
|
|
completion-styles-alist))))
|
|
|
|
|
(defconst completion--cycling-threshold-type
|
|
|
|
|
'(choice (const :tag "No cycling" nil)
|
|
|
|
|
(const :tag "Always cycle" t)
|
|
|
|
|
(integer :tag "Threshold")))
|
|
|
|
|
|
2010-04-19 13:17:40 +00:00
|
|
|
|
(defcustom completion-styles
|
|
|
|
|
;; First, use `basic' because prefix completion has been the standard
|
|
|
|
|
;; for "ever" and works well in most cases, so using it first
|
|
|
|
|
;; ensures that we obey previous behavior in most cases.
|
|
|
|
|
'(basic
|
|
|
|
|
;; Then use `partial-completion' because it has proven to
|
|
|
|
|
;; be a very convenient extension.
|
|
|
|
|
partial-completion
|
|
|
|
|
;; Finally use `emacs22' so as to maintain (in many/most cases)
|
|
|
|
|
;; the previous behavior that when completing "foobar" with point
|
|
|
|
|
;; between "foo" and "bar" the completion try to complete "foo"
|
|
|
|
|
;; and simply add "bar" to the end of the result.
|
|
|
|
|
emacs22)
|
2009-08-18 19:11:41 +00:00
|
|
|
|
"List of completion styles to use.
|
2011-09-27 18:51:05 +00:00
|
|
|
|
The available styles are listed in `completion-styles-alist'.
|
|
|
|
|
|
|
|
|
|
Note that `completion-category-overrides' may override these
|
|
|
|
|
styles for specific categories, such as files, buffers, etc."
|
2011-10-03 15:03:00 +00:00
|
|
|
|
:type completion--styles-type
|
2008-04-13 22:12:02 +00:00
|
|
|
|
:version "23.1")
|
|
|
|
|
|
2011-05-31 03:03:38 +00:00
|
|
|
|
(defcustom completion-category-overrides
|
|
|
|
|
'((buffer (styles . (basic substring))))
|
2011-09-27 18:51:05 +00:00
|
|
|
|
"List of `completion-styles' overrides for specific categories.
|
2011-05-31 03:03:38 +00:00
|
|
|
|
Each override has the shape (CATEGORY . ALIST) where ALIST is
|
|
|
|
|
an association list that can specify properties such as:
|
|
|
|
|
- `styles': the list of `completion-styles' to use for that category.
|
2012-02-23 08:32:18 +00:00
|
|
|
|
- `cycle': the `completion-cycle-threshold' to use for that category.
|
|
|
|
|
Categories are symbols such as `buffer' and `file', used when
|
|
|
|
|
completing buffer and file names, respectively."
|
Add missing :version tags to new defgroups and defcustoms
* window.el (window-sides-slots):
* tool-bar.el (tool-bar-position):
* term/xterm.el (xterm-extra-capabilities):
* ses.el (ses-self-reference-early-detection):
* progmodes/verilog-mode.el (verilog-auto-declare-nettype)
(verilog-auto-wire-type)
(verilog-auto-delete-trailing-whitespace)
(verilog-auto-reset-blocking-in-non, verilog-auto-inst-sort)
(verilog-auto-tieoff-declaration):
* progmodes/sql.el (sql-login-hook, sql-ansi-statement-starters)
(sql-oracle-statement-starters, sql-oracle-scan-on):
* progmodes/prolog.el (prolog-align-comments-flag)
(prolog-indent-mline-comments-flag, prolog-object-end-to-0-flag)
(prolog-left-indent-regexp, prolog-paren-indent-p)
(prolog-paren-indent, prolog-parse-mode, prolog-keywords)
(prolog-types, prolog-mode-specificators)
(prolog-determinism-specificators, prolog-directives)
(prolog-electric-newline-flag, prolog-hungry-delete-key-flag)
(prolog-electric-dot-flag)
(prolog-electric-dot-full-predicate-template)
(prolog-electric-underscore-flag, prolog-electric-tab-flag)
(prolog-electric-if-then-else-flag, prolog-electric-colon-flag)
(prolog-electric-dash-flag, prolog-old-sicstus-keys-flag)
(prolog-program-switches, prolog-prompt-regexp)
(prolog-debug-on-string, prolog-debug-off-string)
(prolog-trace-on-string, prolog-trace-off-string)
(prolog-zip-on-string, prolog-zip-off-string)
(prolog-use-standard-consult-compile-method-flag)
(prolog-use-prolog-tokenizer-flag, prolog-imenu-flag)
(prolog-imenu-max-lines, prolog-info-predicate-index)
(prolog-underscore-wordchar-flag, prolog-use-sicstus-sd)
(prolog-char-quote-workaround):
* progmodes/cc-vars.el (c-defun-tactic):
* net/tramp.el (tramp-encoding-command-interactive)
(tramp-local-end-of-line):
* net/soap-client.el (soap-client):
* net/netrc.el (netrc-file):
* net/gnutls.el (gnutls):
* minibuffer.el (completion-category-overrides)
(completion-cycle-threshold)
(completion-pcm-complete-word-inserts-delimiters):
* man.el (Man-name-local-regexp):
* mail/feedmail.el (feedmail-display-full-frame):
* international/characters.el (glyphless-char-display-control):
* eshell/em-ls.el (eshell-ls-date-format):
* emacs-lisp/cl-indent.el (lisp-lambda-list-keyword-alignment)
(lisp-lambda-list-keyword-parameter-indentation)
(lisp-lambda-list-keyword-parameter-alignment):
* doc-view.el (doc-view-image-width, doc-view-unoconv-program):
* dired-x.el (dired-omit-verbose):
* cus-theme.el (custom-theme-allow-multiple-selections):
* calc/calc.el (calc-highlight-selections-with-faces)
(calc-lu-field-reference, calc-lu-power-reference)
(calc-note-threshold):
* battery.el (battery-mode-line-limit):
* arc-mode.el (archive-7z-extract, archive-7z-expunge)
(archive-7z-update):
* allout.el (allout-prefixed-keybindings)
(allout-unprefixed-keybindings)
(allout-inhibit-auto-fill-on-headline)
(allout-flattened-numbering-abbreviation):
* allout-widgets.el (allout-widgets-auto-activation)
(allout-widgets-icons-dark-subdir)
(allout-widgets-icons-light-subdir, allout-widgets-icon-types)
(allout-widgets-theme-dark-background)
(allout-widgets-theme-light-background)
(allout-widgets-item-image-properties-emacs)
(allout-widgets-item-image-properties-xemacs)
(allout-widgets-run-unit-tests-on-load)
(allout-widgets-time-decoration-activity)
(allout-widgets-hook-error-post-time)
(allout-widgets-track-decoration):
* gnus/sieve-manage.el (sieve-manage-default-stream):
* gnus/shr.el (shr):
* gnus/nnir.el (nnir-ignored-newsgroups, nnir-summary-line-format)
(nnir-retrieve-headers-override-function)
(nnir-imap-default-search-key, nnir-notmuch-program)
(nnir-notmuch-additional-switches, nnir-notmuch-remove-prefix)
(nnir-method-default-engines):
* gnus/message.el (message-cite-reply-position):
* gnus/gssapi.el (gssapi-program):
* gnus/gravatar.el (gravatar):
* gnus/gnus-sum.el (gnus-refer-thread-use-nnir):
* gnus/gnus-registry.el (gnus-registry-unfollowed-addresses)
(gnus-registry-max-pruned-entries):
* gnus/gnus-picon.el (gnus-picon-inhibit-top-level-domains):
* gnus/gnus-int.el (gnus-after-set-mark-hook)
(gnus-before-update-mark-hook):
* gnus/gnus-async.el (gnus-async-post-fetch-function):
* gnus/auth-source.el (auth-source-cache-expiry):
Add missing :version tags to new defcustoms and defgroups.
2012-02-11 22:13:29 +00:00
|
|
|
|
:version "24.1"
|
2011-10-03 14:47:40 +00:00
|
|
|
|
:type `(alist :key-type (choice :tag "Category"
|
|
|
|
|
(const buffer)
|
2011-05-31 03:03:38 +00:00
|
|
|
|
(const file)
|
2011-10-03 15:03:00 +00:00
|
|
|
|
(const unicode-name)
|
2012-10-26 20:44:38 +00:00
|
|
|
|
(const bookmark)
|
2011-05-31 03:03:38 +00:00
|
|
|
|
symbol)
|
|
|
|
|
:value-type
|
2011-10-03 14:47:40 +00:00
|
|
|
|
(set :tag "Properties to override"
|
|
|
|
|
(cons :tag "Completion Styles"
|
|
|
|
|
(const :tag "Select a style from the menu;" styles)
|
2011-10-03 15:03:00 +00:00
|
|
|
|
,completion--styles-type)
|
2011-10-03 14:47:40 +00:00
|
|
|
|
(cons :tag "Completion Cycling"
|
|
|
|
|
(const :tag "Select one value from the menu." cycle)
|
2011-10-03 15:03:00 +00:00
|
|
|
|
,completion--cycling-threshold-type))))
|
2011-05-31 03:03:38 +00:00
|
|
|
|
|
|
|
|
|
(defun completion--styles (metadata)
|
|
|
|
|
(let* ((cat (completion-metadata-get metadata 'category))
|
|
|
|
|
(over (assq 'styles (cdr (assq cat completion-category-overrides)))))
|
|
|
|
|
(if over
|
|
|
|
|
(delete-dups (append (cdr over) (copy-sequence completion-styles)))
|
|
|
|
|
completion-styles)))
|
|
|
|
|
|
2012-04-25 18:40:42 +00:00
|
|
|
|
(defun completion--nth-completion (n string table pred point metadata)
|
|
|
|
|
"Call the Nth method of completion styles."
|
|
|
|
|
(unless metadata
|
|
|
|
|
(setq metadata
|
|
|
|
|
(completion-metadata (substring string 0 point) table pred)))
|
|
|
|
|
;; We provide special support for quoting/unquoting here because it cannot
|
|
|
|
|
;; reliably be done within the normal completion-table routines: Completion
|
|
|
|
|
;; styles such as `substring' or `partial-completion' need to match the
|
|
|
|
|
;; output of all-completions with the user's input, and since most/all
|
|
|
|
|
;; quoting mechanisms allow several equivalent quoted forms, the
|
|
|
|
|
;; completion-style can't do this matching (e.g. `substring' doesn't know
|
|
|
|
|
;; that "\a\b\e" is a valid (quoted) substring of "label").
|
|
|
|
|
;; The quote/unquote function needs to come from the completion table (rather
|
|
|
|
|
;; than from completion-extra-properties) because it may apply only to some
|
|
|
|
|
;; part of the string (e.g. substitute-in-file-name).
|
|
|
|
|
(let ((requote
|
|
|
|
|
(when (completion-metadata-get metadata 'completion--unquote-requote)
|
|
|
|
|
(let ((new (funcall table string point 'completion--unquote)))
|
|
|
|
|
(setq string (pop new))
|
|
|
|
|
(setq table (pop new))
|
|
|
|
|
(setq point (pop new))
|
|
|
|
|
(pop new))))
|
|
|
|
|
(result
|
|
|
|
|
(completion--some (lambda (style)
|
|
|
|
|
(funcall (nth n (assq style
|
|
|
|
|
completion-styles-alist))
|
|
|
|
|
string table pred point))
|
|
|
|
|
(completion--styles metadata))))
|
|
|
|
|
(if requote
|
|
|
|
|
(funcall requote result n)
|
|
|
|
|
result)))
|
|
|
|
|
|
2011-06-20 20:16:20 +00:00
|
|
|
|
(defun completion-try-completion (string table pred point &optional metadata)
|
2008-04-23 21:01:31 +00:00
|
|
|
|
"Try to complete STRING using completion table TABLE.
|
|
|
|
|
Only the elements of table that satisfy predicate PRED are considered.
|
|
|
|
|
POINT is the position of point within STRING.
|
|
|
|
|
The return value can be either nil to indicate that there is no completion,
|
|
|
|
|
t to indicate that STRING is the only possible completion,
|
2012-04-25 18:40:42 +00:00
|
|
|
|
or a pair (NEWSTRING . NEWPOINT) of the completed result string together with
|
2008-04-23 21:01:31 +00:00
|
|
|
|
a new position for point."
|
2012-04-25 18:40:42 +00:00
|
|
|
|
(completion--nth-completion 1 string table pred point metadata))
|
2008-04-13 22:12:02 +00:00
|
|
|
|
|
2011-06-20 20:16:20 +00:00
|
|
|
|
(defun completion-all-completions (string table pred point &optional metadata)
|
2008-04-23 21:01:31 +00:00
|
|
|
|
"List the possible completions of STRING in completion table TABLE.
|
|
|
|
|
Only the elements of table that satisfy predicate PRED are considered.
|
|
|
|
|
POINT is the position of point within STRING.
|
2008-04-26 12:58:13 +00:00
|
|
|
|
The return value is a list of completions and may contain the base-size
|
2008-04-23 21:01:31 +00:00
|
|
|
|
in the last `cdr'."
|
2009-12-06 01:25:41 +00:00
|
|
|
|
;; FIXME: We need to additionally return the info needed for the
|
|
|
|
|
;; second part of completion-base-position.
|
2012-04-25 18:40:42 +00:00
|
|
|
|
(completion--nth-completion 2 string table pred point metadata))
|
2008-04-13 22:12:02 +00:00
|
|
|
|
|
2008-04-09 19:33:56 +00:00
|
|
|
|
(defun minibuffer--bitset (modified completions exact)
|
|
|
|
|
(logior (if modified 4 0)
|
|
|
|
|
(if completions 2 0)
|
|
|
|
|
(if exact 1 0)))
|
|
|
|
|
|
2010-02-27 21:21:43 +00:00
|
|
|
|
(defun completion--replace (beg end newtext)
|
|
|
|
|
"Replace the buffer text between BEG and END with NEWTEXT.
|
|
|
|
|
Moves point to the end of the new text."
|
2012-01-16 15:50:28 +00:00
|
|
|
|
;; The properties on `newtext' include things like
|
|
|
|
|
;; completions-first-difference, which we don't want to include
|
|
|
|
|
;; upon insertion.
|
|
|
|
|
(set-text-properties 0 (length newtext) nil newtext)
|
2010-09-30 23:05:26 +00:00
|
|
|
|
;; Maybe this should be in subr.el.
|
2010-02-27 21:21:43 +00:00
|
|
|
|
;; You'd think this is trivial to do, but details matter if you want
|
|
|
|
|
;; to keep markers "at the right place" and be robust in the face of
|
|
|
|
|
;; after-change-functions that may themselves modify the buffer.
|
2010-09-30 23:05:26 +00:00
|
|
|
|
(let ((prefix-len 0))
|
|
|
|
|
;; Don't touch markers in the shared prefix (if any).
|
|
|
|
|
(while (and (< prefix-len (length newtext))
|
|
|
|
|
(< (+ beg prefix-len) end)
|
|
|
|
|
(eq (char-after (+ beg prefix-len))
|
|
|
|
|
(aref newtext prefix-len)))
|
|
|
|
|
(setq prefix-len (1+ prefix-len)))
|
|
|
|
|
(unless (zerop prefix-len)
|
|
|
|
|
(setq beg (+ beg prefix-len))
|
|
|
|
|
(setq newtext (substring newtext prefix-len))))
|
|
|
|
|
(let ((suffix-len 0))
|
|
|
|
|
;; Don't touch markers in the shared suffix (if any).
|
|
|
|
|
(while (and (< suffix-len (length newtext))
|
|
|
|
|
(< beg (- end suffix-len))
|
|
|
|
|
(eq (char-before (- end suffix-len))
|
|
|
|
|
(aref newtext (- (length newtext) suffix-len 1))))
|
|
|
|
|
(setq suffix-len (1+ suffix-len)))
|
|
|
|
|
(unless (zerop suffix-len)
|
|
|
|
|
(setq end (- end suffix-len))
|
2010-10-17 17:30:22 +00:00
|
|
|
|
(setq newtext (substring newtext 0 (- suffix-len))))
|
|
|
|
|
(goto-char beg)
|
2011-10-17 16:30:02 +00:00
|
|
|
|
(insert-and-inherit newtext)
|
2010-10-17 17:30:22 +00:00
|
|
|
|
(delete-region (point) (+ (point) (- end beg)))
|
|
|
|
|
(forward-char suffix-len)))
|
2010-02-27 21:21:43 +00:00
|
|
|
|
|
2010-05-12 00:39:46 +00:00
|
|
|
|
(defcustom completion-cycle-threshold nil
|
|
|
|
|
"Number of completion candidates below which cycling is used.
|
2013-09-06 22:46:44 +00:00
|
|
|
|
Depending on this setting `completion-in-region' may use cycling,
|
2010-05-12 00:39:46 +00:00
|
|
|
|
like `minibuffer-force-complete'.
|
|
|
|
|
If nil, cycling is never used.
|
|
|
|
|
If t, cycling is always used.
|
2012-10-18 03:30:04 +00:00
|
|
|
|
If an integer, cycling is used so long as there are not more
|
|
|
|
|
completion candidates than this number."
|
Add missing :version tags to new defgroups and defcustoms
* window.el (window-sides-slots):
* tool-bar.el (tool-bar-position):
* term/xterm.el (xterm-extra-capabilities):
* ses.el (ses-self-reference-early-detection):
* progmodes/verilog-mode.el (verilog-auto-declare-nettype)
(verilog-auto-wire-type)
(verilog-auto-delete-trailing-whitespace)
(verilog-auto-reset-blocking-in-non, verilog-auto-inst-sort)
(verilog-auto-tieoff-declaration):
* progmodes/sql.el (sql-login-hook, sql-ansi-statement-starters)
(sql-oracle-statement-starters, sql-oracle-scan-on):
* progmodes/prolog.el (prolog-align-comments-flag)
(prolog-indent-mline-comments-flag, prolog-object-end-to-0-flag)
(prolog-left-indent-regexp, prolog-paren-indent-p)
(prolog-paren-indent, prolog-parse-mode, prolog-keywords)
(prolog-types, prolog-mode-specificators)
(prolog-determinism-specificators, prolog-directives)
(prolog-electric-newline-flag, prolog-hungry-delete-key-flag)
(prolog-electric-dot-flag)
(prolog-electric-dot-full-predicate-template)
(prolog-electric-underscore-flag, prolog-electric-tab-flag)
(prolog-electric-if-then-else-flag, prolog-electric-colon-flag)
(prolog-electric-dash-flag, prolog-old-sicstus-keys-flag)
(prolog-program-switches, prolog-prompt-regexp)
(prolog-debug-on-string, prolog-debug-off-string)
(prolog-trace-on-string, prolog-trace-off-string)
(prolog-zip-on-string, prolog-zip-off-string)
(prolog-use-standard-consult-compile-method-flag)
(prolog-use-prolog-tokenizer-flag, prolog-imenu-flag)
(prolog-imenu-max-lines, prolog-info-predicate-index)
(prolog-underscore-wordchar-flag, prolog-use-sicstus-sd)
(prolog-char-quote-workaround):
* progmodes/cc-vars.el (c-defun-tactic):
* net/tramp.el (tramp-encoding-command-interactive)
(tramp-local-end-of-line):
* net/soap-client.el (soap-client):
* net/netrc.el (netrc-file):
* net/gnutls.el (gnutls):
* minibuffer.el (completion-category-overrides)
(completion-cycle-threshold)
(completion-pcm-complete-word-inserts-delimiters):
* man.el (Man-name-local-regexp):
* mail/feedmail.el (feedmail-display-full-frame):
* international/characters.el (glyphless-char-display-control):
* eshell/em-ls.el (eshell-ls-date-format):
* emacs-lisp/cl-indent.el (lisp-lambda-list-keyword-alignment)
(lisp-lambda-list-keyword-parameter-indentation)
(lisp-lambda-list-keyword-parameter-alignment):
* doc-view.el (doc-view-image-width, doc-view-unoconv-program):
* dired-x.el (dired-omit-verbose):
* cus-theme.el (custom-theme-allow-multiple-selections):
* calc/calc.el (calc-highlight-selections-with-faces)
(calc-lu-field-reference, calc-lu-power-reference)
(calc-note-threshold):
* battery.el (battery-mode-line-limit):
* arc-mode.el (archive-7z-extract, archive-7z-expunge)
(archive-7z-update):
* allout.el (allout-prefixed-keybindings)
(allout-unprefixed-keybindings)
(allout-inhibit-auto-fill-on-headline)
(allout-flattened-numbering-abbreviation):
* allout-widgets.el (allout-widgets-auto-activation)
(allout-widgets-icons-dark-subdir)
(allout-widgets-icons-light-subdir, allout-widgets-icon-types)
(allout-widgets-theme-dark-background)
(allout-widgets-theme-light-background)
(allout-widgets-item-image-properties-emacs)
(allout-widgets-item-image-properties-xemacs)
(allout-widgets-run-unit-tests-on-load)
(allout-widgets-time-decoration-activity)
(allout-widgets-hook-error-post-time)
(allout-widgets-track-decoration):
* gnus/sieve-manage.el (sieve-manage-default-stream):
* gnus/shr.el (shr):
* gnus/nnir.el (nnir-ignored-newsgroups, nnir-summary-line-format)
(nnir-retrieve-headers-override-function)
(nnir-imap-default-search-key, nnir-notmuch-program)
(nnir-notmuch-additional-switches, nnir-notmuch-remove-prefix)
(nnir-method-default-engines):
* gnus/message.el (message-cite-reply-position):
* gnus/gssapi.el (gssapi-program):
* gnus/gravatar.el (gravatar):
* gnus/gnus-sum.el (gnus-refer-thread-use-nnir):
* gnus/gnus-registry.el (gnus-registry-unfollowed-addresses)
(gnus-registry-max-pruned-entries):
* gnus/gnus-picon.el (gnus-picon-inhibit-top-level-domains):
* gnus/gnus-int.el (gnus-after-set-mark-hook)
(gnus-before-update-mark-hook):
* gnus/gnus-async.el (gnus-async-post-fetch-function):
* gnus/auth-source.el (auth-source-cache-expiry):
Add missing :version tags to new defcustoms and defgroups.
2012-02-11 22:13:29 +00:00
|
|
|
|
:version "24.1"
|
2011-10-03 15:03:00 +00:00
|
|
|
|
:type completion--cycling-threshold-type)
|
2010-05-12 00:39:46 +00:00
|
|
|
|
|
2011-05-31 03:03:38 +00:00
|
|
|
|
(defun completion--cycle-threshold (metadata)
|
|
|
|
|
(let* ((cat (completion-metadata-get metadata 'category))
|
|
|
|
|
(over (assq 'cycle (cdr (assq cat completion-category-overrides)))))
|
|
|
|
|
(if over (cdr over) completion-cycle-threshold)))
|
|
|
|
|
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(defvar-local completion-all-sorted-completions nil)
|
2012-10-24 03:18:32 +00:00
|
|
|
|
(defvar-local completion--all-sorted-completions-location nil)
|
2010-10-28 02:22:29 +00:00
|
|
|
|
(defvar completion-cycling nil)
|
|
|
|
|
|
2010-11-18 02:44:44 +00:00
|
|
|
|
(defvar completion-fail-discreetly nil
|
|
|
|
|
"If non-nil, stay quiet when there is no match.")
|
|
|
|
|
|
2011-05-04 01:19:32 +00:00
|
|
|
|
(defun completion--message (msg)
|
|
|
|
|
(if completion-show-inline-help
|
|
|
|
|
(minibuffer-message msg)))
|
|
|
|
|
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(defun completion--do-completion (beg end &optional
|
|
|
|
|
try-completion-function expect-exact)
|
2008-04-09 03:34:19 +00:00
|
|
|
|
"Do the completion and return a summary of what happened.
|
2008-04-09 19:33:56 +00:00
|
|
|
|
M = completion was performed, the text was Modified.
|
|
|
|
|
C = there were available Completions.
|
|
|
|
|
E = after completion we now have an Exact match.
|
|
|
|
|
|
|
|
|
|
MCE
|
|
|
|
|
000 0 no possible completion
|
|
|
|
|
001 1 was already an exact and unique completion
|
|
|
|
|
010 2 no completion happened
|
|
|
|
|
011 3 was already an exact completion
|
|
|
|
|
100 4 ??? impossible
|
|
|
|
|
101 5 ??? impossible
|
|
|
|
|
110 6 some completion happened
|
2011-05-24 02:45:50 +00:00
|
|
|
|
111 7 completed to an exact completion
|
|
|
|
|
|
|
|
|
|
TRY-COMPLETION-FUNCTION is a function to use in place of `try-completion'.
|
|
|
|
|
EXPECT-EXACT, if non-nil, means that there is no need to tell the user
|
|
|
|
|
when the buffer's text is already an exact match."
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(let* ((string (buffer-substring beg end))
|
2011-05-31 03:03:38 +00:00
|
|
|
|
(md (completion--field-metadata beg))
|
2011-02-21 20:31:07 +00:00
|
|
|
|
(comp (funcall (or try-completion-function
|
|
|
|
|
'completion-try-completion)
|
|
|
|
|
string
|
|
|
|
|
minibuffer-completion-table
|
|
|
|
|
minibuffer-completion-predicate
|
2011-05-31 03:03:38 +00:00
|
|
|
|
(- (point) beg)
|
|
|
|
|
md)))
|
2008-04-09 03:34:19 +00:00
|
|
|
|
(cond
|
2008-04-23 21:01:31 +00:00
|
|
|
|
((null comp)
|
2009-08-19 02:15:19 +00:00
|
|
|
|
(minibuffer-hide-completions)
|
2011-05-04 01:19:32 +00:00
|
|
|
|
(unless completion-fail-discreetly
|
2011-04-10 21:31:14 +00:00
|
|
|
|
(ding)
|
2011-05-04 01:19:32 +00:00
|
|
|
|
(completion--message "No match"))
|
2010-11-18 02:44:44 +00:00
|
|
|
|
(minibuffer--bitset nil nil nil))
|
2009-08-18 19:11:41 +00:00
|
|
|
|
((eq t comp)
|
2009-08-19 02:15:19 +00:00
|
|
|
|
(minibuffer-hide-completions)
|
2011-05-24 02:45:50 +00:00
|
|
|
|
(goto-char end)
|
|
|
|
|
(completion--done string 'finished
|
|
|
|
|
(unless expect-exact "Sole completion"))
|
2010-10-28 02:22:29 +00:00
|
|
|
|
(minibuffer--bitset nil nil t)) ;Exact and unique match.
|
2008-04-09 03:34:19 +00:00
|
|
|
|
(t
|
|
|
|
|
;; `completed' should be t if some completion was done, which doesn't
|
|
|
|
|
;; include simply changing the case of the entered string. However,
|
|
|
|
|
;; for appearance, the string is rewritten if the case changes.
|
2011-02-21 20:31:07 +00:00
|
|
|
|
(let* ((comp-pos (cdr comp))
|
|
|
|
|
(completion (car comp))
|
|
|
|
|
(completed (not (eq t (compare-strings completion nil nil
|
|
|
|
|
string nil nil t))))
|
|
|
|
|
(unchanged (eq t (compare-strings completion nil nil
|
|
|
|
|
string nil nil nil))))
|
2010-02-27 21:21:43 +00:00
|
|
|
|
(if unchanged
|
2010-10-03 19:50:14 +00:00
|
|
|
|
(goto-char end)
|
2010-02-27 21:21:43 +00:00
|
|
|
|
;; Insert in minibuffer the chars we got.
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(completion--replace beg end completion)
|
|
|
|
|
(setq end (+ beg (length completion))))
|
2010-02-27 21:21:43 +00:00
|
|
|
|
;; Move point to its completion-mandated destination.
|
|
|
|
|
(forward-char (- comp-pos (length completion)))
|
2008-04-09 19:33:56 +00:00
|
|
|
|
|
2008-04-09 03:34:19 +00:00
|
|
|
|
(if (not (or unchanged completed))
|
2010-10-28 02:22:29 +00:00
|
|
|
|
;; The case of the string changed, but that's all. We're not sure
|
|
|
|
|
;; whether this is a unique completion or not, so try again using
|
|
|
|
|
;; the real case (this shouldn't recurse again, because the next
|
|
|
|
|
;; time try-completion will return either t or the exact string).
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(completion--do-completion beg end
|
|
|
|
|
try-completion-function expect-exact)
|
2008-04-09 03:34:19 +00:00
|
|
|
|
|
|
|
|
|
;; It did find a match. Do we match some possibility exactly now?
|
2011-05-31 03:03:38 +00:00
|
|
|
|
(let* ((exact (test-completion completion
|
2012-02-23 15:41:12 +00:00
|
|
|
|
minibuffer-completion-table
|
|
|
|
|
minibuffer-completion-predicate))
|
2011-05-31 03:03:38 +00:00
|
|
|
|
(threshold (completion--cycle-threshold md))
|
2012-02-23 15:41:12 +00:00
|
|
|
|
(comps
|
|
|
|
|
;; Check to see if we want to do cycling. We do it
|
|
|
|
|
;; here, after having performed the normal completion,
|
|
|
|
|
;; so as to take advantage of the difference between
|
|
|
|
|
;; try-completion and all-completions, for things
|
|
|
|
|
;; like completion-ignored-extensions.
|
2011-05-31 03:03:38 +00:00
|
|
|
|
(when (and threshold
|
2012-02-23 15:41:12 +00:00
|
|
|
|
;; Check that the completion didn't make
|
|
|
|
|
;; us jump to a different boundary.
|
|
|
|
|
(or (not completed)
|
|
|
|
|
(< (car (completion-boundaries
|
|
|
|
|
(substring completion 0 comp-pos)
|
|
|
|
|
minibuffer-completion-table
|
|
|
|
|
minibuffer-completion-predicate
|
2010-05-12 00:39:46 +00:00
|
|
|
|
""))
|
|
|
|
|
comp-pos)))
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(completion-all-sorted-completions beg end))))
|
2010-10-28 02:22:29 +00:00
|
|
|
|
(completion--flush-all-sorted-completions)
|
2010-05-12 00:39:46 +00:00
|
|
|
|
(cond
|
2010-10-28 02:22:29 +00:00
|
|
|
|
((and (consp (cdr comps)) ;; There's something to cycle.
|
|
|
|
|
(not (ignore-errors
|
2010-05-12 00:39:46 +00:00
|
|
|
|
;; This signal an (intended) error if comps is too
|
|
|
|
|
;; short or if completion-cycle-threshold is t.
|
2011-05-31 03:03:38 +00:00
|
|
|
|
(consp (nthcdr threshold comps)))))
|
2012-10-18 03:30:04 +00:00
|
|
|
|
;; Not more than completion-cycle-threshold remaining
|
2010-05-12 00:39:46 +00:00
|
|
|
|
;; completions: let's cycle.
|
|
|
|
|
(setq completed t exact t)
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(completion--cache-all-sorted-completions beg end comps)
|
|
|
|
|
(minibuffer-force-complete beg end))
|
2010-05-12 00:39:46 +00:00
|
|
|
|
(completed
|
2010-10-28 02:22:29 +00:00
|
|
|
|
;; We could also decide to refresh the completions,
|
|
|
|
|
;; if they're displayed (and assuming there are
|
|
|
|
|
;; completions left).
|
2011-05-24 02:45:50 +00:00
|
|
|
|
(minibuffer-hide-completions)
|
|
|
|
|
(if exact
|
|
|
|
|
;; If completion did not put point at end of field,
|
|
|
|
|
;; it's a sign that completion is not finished.
|
|
|
|
|
(completion--done completion
|
|
|
|
|
(if (< comp-pos (length completion))
|
|
|
|
|
'exact 'unknown))))
|
2010-10-28 02:22:29 +00:00
|
|
|
|
;; Show the completion table, if requested.
|
|
|
|
|
((not exact)
|
Reduce use of (require 'cl).
* admin/bzrmerge.el: Use cl-lib.
* leim/quail/hangul.el: Don't require CL.
* leim/quail/ipa.el: Use cl-lib.
* vc/smerge-mode.el, vc/pcvs.el, vc/pcvs-util.el, vc/pcvs-info.el:
* vc/diff-mode.el, vc/cvs-status.el, uniquify.el, scroll-bar.el:
* register.el, progmodes/sh-script.el, net/gnutls.el, net/dbus.el:
* msb.el, mpc.el, minibuffer.el, international/ucs-normalize.el:
* international/quail.el, info-xref.el, imenu.el, image-mode.el:
* font-lock.el, filesets.el, edmacro.el, doc-view.el, bookmark.el:
* battery.el, avoid.el, abbrev.el: Use cl-lib.
* vc/pcvs-parse.el, vc/pcvs-defs.el, vc/log-view.el, vc/log-edit.el:
* vc/diff.el, simple.el, pcomplete.el, lpr.el, comint.el, loadhist.el:
* jit-lock.el, international/iso-ascii.el, info.el, frame.el, bs.el:
* emulation/crisp.el, electric.el, dired.el, cus-dep.el, composite.el:
* calculator.el, autorevert.el, apropos.el: Don't require CL.
* emacs-bytecomp.el (byte-recompile-directory, display-call-tree)
(byte-compile-unfold-bcf, byte-compile-check-variable):
* emacs-byte-opt.el (byte-compile-trueconstp)
(byte-compile-nilconstp):
* emacs-autoload.el (make-autoload): Use pcase.
* face-remap.el (text-scale-adjust): Simplify pcase patterns.
2012-07-10 11:51:54 +00:00
|
|
|
|
(if (pcase completion-auto-help
|
|
|
|
|
(`lazy (eq this-command last-command))
|
|
|
|
|
(_ completion-auto-help))
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(minibuffer-completion-help beg end)
|
2011-05-04 01:19:32 +00:00
|
|
|
|
(completion--message "Next char not unique")))
|
2010-10-28 02:22:29 +00:00
|
|
|
|
;; If the last exact completion and this one were the same, it
|
2011-05-04 01:19:32 +00:00
|
|
|
|
;; means we've already given a "Complete, but not unique" message
|
2010-10-28 02:22:29 +00:00
|
|
|
|
;; and the user's hit TAB again, so now we give him help.
|
2011-05-24 02:45:50 +00:00
|
|
|
|
(t
|
|
|
|
|
(if (and (eq this-command last-command) completion-auto-help)
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(minibuffer-completion-help beg end))
|
2011-05-24 02:45:50 +00:00
|
|
|
|
(completion--done completion 'exact
|
|
|
|
|
(unless expect-exact
|
|
|
|
|
"Complete, but not unique"))))
|
2008-04-09 19:33:56 +00:00
|
|
|
|
|
|
|
|
|
(minibuffer--bitset completed t exact))))))))
|
2008-04-09 03:34:19 +00:00
|
|
|
|
|
|
|
|
|
(defun minibuffer-complete ()
|
|
|
|
|
"Complete the minibuffer contents as far as possible.
|
|
|
|
|
Return nil if there is no valid completion, else t.
|
|
|
|
|
If no characters can be completed, display a list of possible completions.
|
|
|
|
|
If you repeat this command after it displayed such a list,
|
|
|
|
|
scroll the window of possible completions."
|
|
|
|
|
(interactive)
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(completion-in-region (minibuffer-prompt-end) (point-max)
|
|
|
|
|
minibuffer-completion-table
|
|
|
|
|
minibuffer-completion-predicate))
|
|
|
|
|
|
|
|
|
|
(defun completion--in-region-1 (beg end)
|
2008-04-09 03:34:19 +00:00
|
|
|
|
;; If the previous command was not this,
|
|
|
|
|
;; mark the completion buffer obsolete.
|
2012-03-12 04:10:59 +00:00
|
|
|
|
(setq this-command 'completion-at-point)
|
|
|
|
|
(unless (eq 'completion-at-point last-command)
|
2010-10-28 02:22:29 +00:00
|
|
|
|
(completion--flush-all-sorted-completions)
|
2008-04-09 03:34:19 +00:00
|
|
|
|
(setq minibuffer-scroll-window nil))
|
|
|
|
|
|
2010-05-12 00:39:46 +00:00
|
|
|
|
(cond
|
Merge from lexical-binding branch.
* doc/lispref/eval.texi (Eval): Discourage the use of `eval'.
Document its new `lexical' argument.
* doc/lispref/variables.texi (Defining Variables): Mention the new meaning of `defvar'.
(Lexical Binding): New sub-section.
* lisp/Makefile.in (BIG_STACK_DEPTH, BIG_STACK_OPTS, BYTE_COMPILE_FLAGS):
New variables.
(compile-onefile, .el.elc, compile-calc, recompile): Use them.
(COMPILE_FIRST): Add macroexp and cconv.
* lisp/makefile.w32-in: Mirror changes in Makefile.in.
* lisp/vc/cvs-status.el:
* lisp/vc/diff-mode.el:
* lisp/vc/log-edit.el:
* lisp/vc/log-view.el:
* lisp/vc/smerge-mode.el:
* lisp/textmodes/bibtex-style.el:
* textmodes/css.el:
* lisp/startup.el:
* lisp/uniquify.el:
* lisp/minibuffer.el:
* lisp/newcomment.el:
* lisp/reveal.el:
* lisp/server.el:
* lisp/mpc.el:
* lisp/emacs-lisp/smie.el:
* lisp/doc-view.el:
* lisp/dired.el:
* lisp/abbrev.el: Use lexical binding.
* lisp/custom.el (custom-initialize-default, custom-declare-variable):
Use `defvar'.
* lisp/files.el (lexical-binding): Declare safe.
* lisp/help-fns.el (help-split-fundoc): Return nil if there's nothing else
than the arglist.
(help-add-fundoc-usage): Don't add `Not documented'.
(help-function-arglist): Handle closures, subroutines, and new
byte-code-functions.
(help-make-usage): Remove leading underscores.
(describe-function-1): Handle closures.
(describe-variable): Use special-variable-p for completion.
* lisp/simple.el (with-wrapper-hook, apply-partially): Move to subr.el.
* lisp/subr.el (apply-partially): Use new closures rather than CL.
(--dolist-tail--, --dotimes-limit--): Don't declare dynamic.
(dolist, dotimes): Use slightly different expansion for lexical code.
(functionp): Move to C.
(letrec): New macro.
(with-wrapper-hook): Use it and apply-partially instead of CL.
(eval-after-load): Preserve lexical-binding.
(save-window-excursion, with-output-to-temp-buffer): Turn them
into macros.
* lisp/emacs-lisp/advice.el (ad-arglist): Use help-function-arglist.
* lisp/emacs-lisp/autoload.el (make-autoload): Don't burp on trivial macros.
* lisp/emacs-lisp/byte-opt.el: Use lexical binding.
(byte-inline-lapcode): Remove (to bytecomp).
(byte-compile-inline-expand): Pay attention to inlining to/from
lexically bound code.
(byte-compile-unfold-lambda): Don't handle byte-code-functions
any more.
(byte-optimize-form-code-walker): Don't handle save-window-excursion
any more and don't call compiler-macros.
(byte-compile-splice-in-already-compiled-code): Remove.
(byte-code): Don't inline any more.
(disassemble-offset): Receive `bytes' as argument rather than via
dynamic scoping.
(byte-compile-tag-number): Declare before first use.
(byte-decompile-bytecode-1): Handle new byte-codes, don't change
`return' even if make-spliceable.
(byte-compile-side-effect-and-error-free-ops): Add stack-ref, remove
obsolete interactive-p.
(byte-optimize-lapcode): Optimize new lap-codes.
Don't trip up on new form of `byte-constant' lap code.
* lisp/emacs-lisp/byte-run.el (make-obsolete): Don't set the `byte-compile'
handler any more.
* lisp/emacs-lisp/bytecomp.el: Use lexical binding instead of
a "bytecomp-" prefix. Macroexpand everything as a separate phase.
(byte-compile-initial-macro-environment):
Handle declare-function here.
(byte-compile--lexical-environment): New var.
(byte-stack-ref, byte-stack-set, byte-discardN)
(byte-discardN-preserve-tos): New lap codes.
(byte-interactive-p): Don't use any more.
(byte-compile-push-bytecodes, byte-compile-push-bytecode-const2):
New macros.
(byte-compile-lapcode): Use them and handle new lap codes.
(byte-compile-obsolete): Remove.
(byte-compile-arglist-signature): Handle new byte-code arg"lists".
(byte-compile-arglist-warn): Check late def of inlinable funs.
(byte-compile-cl-warn): Don't silence warnings for compiler-macros
since they should have been expanded by now.
(byte-compile--outbuffer): Rename from bytecomp-outbuffer.
(byte-compile-from-buffer): Remove unused second arg.
(byte-compile-preprocess): New function.
(byte-compile-toplevel-file-form): New function to distinguish
file-form calls from outside from file-form calls from hunk-handlers.
(byte-compile-file-form): Simplify.
(byte-compile-file-form-defsubst): Remove.
(byte-compile-file-form-defmumble): Simplify now that
byte-compile-lambda always returns a byte-code-function.
(byte-compile): Preprocess.
(byte-compile-byte-code-maker, byte-compile-byte-code-unmake):
Remove, not used any more.
(byte-compile-arglist-vars, byte-compile-make-lambda-lexenv)
(byte-compile-make-args-desc): New funs.
(byte-compile-lambda): Handle lexical functions. Always return
a byte-code-function.
(byte-compile-reserved-constants): New var, to make up room for
closed-over variables.
(byte-compile-constants-vector): Obey it.
(byte-compile-top-level): New args `lexenv' and `reserved-csts'.
(byte-compile-macroexpand-declare-function): New function.
(byte-compile-form): Call byte-compile-unfold-bcf to inline immediate
byte-code-functions.
(byte-compile-form): Check obsolescence here.
(byte-compile-inline-lapcode, byte-compile-unfold-bcf): New functions.
(byte-compile-variable-ref): Remove.
(byte-compile-dynamic-variable-op): New fun.
(byte-compile-dynamic-variable-bind, byte-compile-variable-ref)
(byte-compile-variable-set): New funs.
(byte-compile-discard): Add 2 args.
(byte-compile-stack-ref, byte-compile-stack-set)
(byte-compile-make-closure, byte-compile-get-closed-var): New funs.
(byte-compile-funarg, byte-compile-funarg-2): Remove, handled in
macroexpand-all instead.
(byte-compile-quote-form): Remove.
(byte-compile-push-binding-init, byte-compile-not-lexical-var-p)
(byte-compile-bind, byte-compile-unbind): New funs.
(byte-compile-let): Handle let* and lexical binding.
(byte-compile-let*): Remove.
(byte-compile-catch, byte-compile-unwind-protect)
(byte-compile-track-mouse, byte-compile-condition-case):
Handle a new :fun-body form, used for lexical scoping.
(byte-compile-save-window-excursion)
(byte-compile-with-output-to-temp-buffer): Remove.
(byte-compile-defun): Simplify.
(byte-compile-stack-adjustment): New fun.
(byte-compile-out): Use it.
(byte-compile-refresh-preloaded): Don't reload byte-compiler files.
* lisp/emacs-lisp/cconv.el: New file.
* lisp/emacs-lisp/cl-extra.el (cl-macroexpand-all): Properly quote CL
closures.
* lisp/emacs-lisp/cl-macs.el (cl-byte-compile-block)
(cl-byte-compile-throw): Remove.
(cl-block-wrapper, cl-block-throw): Use compiler-macros instead.
* lisp/emacs-lisp/cl.el (pushnew): Silence warning.
* lisp/emacs-lisp/disass.el (disassemble-internal): Handle new
`closure' objects.
(disassemble-1): Handle new byte codes.
* lisp/emacs-lisp/edebug.el (edebug-eval-defun)
(edebug-eval-top-level-form): Use eval-sexp-add-defvars.
(edebug-toggle): Avoid `eval'.
* lisp/emacs-lisp/eieio-comp.el: Remove.
* lisp/emacs-lisp/eieio.el (byte-compile-file-form-defmethod):
Don't autoload.
(eieio-defgeneric-form-primary-only-one): Use `byte-compile' rather
than the internal `byte-compile-lambda'.
(defmethod): Don't hide code under quotes.
(eieio-defmethod): New `code' argument.
* lisp/emacs-lisp/float-sup.el (pi): Don't declare as dynamically bound.
* lisp/emacs-lisp/lisp-mode.el (eval-last-sexp-1):
Use eval-sexp-add-defvars.
(eval-sexp-add-defvars): New fun.
* lisp/emacs-lisp/macroexp.el: Use lexical binding.
(macroexpand-all-1): Check obsolete macros. Expand compiler-macros.
Don't convert ' to #' without checking that it's indeed quoting
a lambda.
* lisp/emacs-lisp/pcase.el: Don't use destructuring-bind.
(pcase--memoize): Rename from pcase-memoize. Change weakness.
(pcase): Add `let' pattern.
Change memoization so it actually works.
(pcase-mutually-exclusive-predicates): Add byte-code-function-p.
(pcase--u1) <guard, pred>: Fix possible shadowing problem.
<let>: New case.
* src/alloc.c (Fmake_symbol): Init new `declared_special' field.
* src/buffer.c (defvar_per_buffer): Set new `declared_special' field.
* src/bytecode.c (Bstack_ref, Bstack_set, Bstack_set2, BdiscardN):
New byte-codes.
(exec_byte_code): New function extracted from Fbyte_code to handle new
calling convention for byte-code-functions. Add new byte-codes.
* src/callint.c (Fcall_interactively): Preserve lexical-binding mode for
interactive spec.
* src/doc.c (Fdocumentation, store_function_docstring):
* src/data.c (Finteractive_form): Handle closures.
* src/eval.c (Fsetq): Handle lexical vars.
(Fdefun, Fdefmacro, Ffunction): Make closures when needed.
(Fdefconst, Fdefvaralias, Fdefvar): Mark as dynamic.
(FletX, Flet): Obey lexical binding.
(Fcommandp): Handle closures.
(Feval): New `lexical' arg.
(eval_sub): New function extracted from Feval. Use it almost
everywhere where Feval was used. Look up vars in lexical env.
Handle closures.
(Ffunctionp): Move from subr.el.
(Ffuncall): Handle closures.
(apply_lambda): Remove `eval_flags'.
(funcall_lambda): Handle closures and new byte-code-functions.
(Fspecial_variable_p): New function.
(syms_of_eval): Initialize the Vinternal_interpreter_environment var,
but without exporting it to Lisp.
* src/fns.c (concat, mapcar1): Accept byte-code-functions.
* src/image.c (parse_image_spec): Use Ffunctionp.
* src/keyboard.c (eval_dyn): New fun.
(menu_item_eval_property): Use it.
* src/lisp.h (struct Lisp_Symbol): New field `declared_special'.
* src/lread.c (lisp_file_lexically_bound_p): New function.
(Fload): Bind Qlexical_binding.
(readevalloop): Remove `evalfun' arg.
Bind Qinternal_interpreter_environment.
(Feval_buffer): Bind Qlexical_binding.
(defvar_int, defvar_bool, defvar_lisp_nopro, defvar_kboard):
Mark as dynamic.
(syms_of_lread): Declare `lexical-binding'.
* src/window.c (Ftemp_output_buffer_show): New fun.
(Fsave_window_excursion):
* src/print.c (Fwith_output_to_temp_buffer): Move to subr.el.
2011-04-01 17:19:52 +00:00
|
|
|
|
;; If there's a fresh completion window with a live buffer,
|
|
|
|
|
;; and this command is repeated, scroll that window.
|
2013-04-15 19:55:41 +00:00
|
|
|
|
((and (window-live-p minibuffer-scroll-window)
|
|
|
|
|
(eq t (frame-visible-p (window-frame minibuffer-scroll-window))))
|
2010-05-12 00:39:46 +00:00
|
|
|
|
(let ((window minibuffer-scroll-window))
|
Merge from lexical-binding branch.
* doc/lispref/eval.texi (Eval): Discourage the use of `eval'.
Document its new `lexical' argument.
* doc/lispref/variables.texi (Defining Variables): Mention the new meaning of `defvar'.
(Lexical Binding): New sub-section.
* lisp/Makefile.in (BIG_STACK_DEPTH, BIG_STACK_OPTS, BYTE_COMPILE_FLAGS):
New variables.
(compile-onefile, .el.elc, compile-calc, recompile): Use them.
(COMPILE_FIRST): Add macroexp and cconv.
* lisp/makefile.w32-in: Mirror changes in Makefile.in.
* lisp/vc/cvs-status.el:
* lisp/vc/diff-mode.el:
* lisp/vc/log-edit.el:
* lisp/vc/log-view.el:
* lisp/vc/smerge-mode.el:
* lisp/textmodes/bibtex-style.el:
* textmodes/css.el:
* lisp/startup.el:
* lisp/uniquify.el:
* lisp/minibuffer.el:
* lisp/newcomment.el:
* lisp/reveal.el:
* lisp/server.el:
* lisp/mpc.el:
* lisp/emacs-lisp/smie.el:
* lisp/doc-view.el:
* lisp/dired.el:
* lisp/abbrev.el: Use lexical binding.
* lisp/custom.el (custom-initialize-default, custom-declare-variable):
Use `defvar'.
* lisp/files.el (lexical-binding): Declare safe.
* lisp/help-fns.el (help-split-fundoc): Return nil if there's nothing else
than the arglist.
(help-add-fundoc-usage): Don't add `Not documented'.
(help-function-arglist): Handle closures, subroutines, and new
byte-code-functions.
(help-make-usage): Remove leading underscores.
(describe-function-1): Handle closures.
(describe-variable): Use special-variable-p for completion.
* lisp/simple.el (with-wrapper-hook, apply-partially): Move to subr.el.
* lisp/subr.el (apply-partially): Use new closures rather than CL.
(--dolist-tail--, --dotimes-limit--): Don't declare dynamic.
(dolist, dotimes): Use slightly different expansion for lexical code.
(functionp): Move to C.
(letrec): New macro.
(with-wrapper-hook): Use it and apply-partially instead of CL.
(eval-after-load): Preserve lexical-binding.
(save-window-excursion, with-output-to-temp-buffer): Turn them
into macros.
* lisp/emacs-lisp/advice.el (ad-arglist): Use help-function-arglist.
* lisp/emacs-lisp/autoload.el (make-autoload): Don't burp on trivial macros.
* lisp/emacs-lisp/byte-opt.el: Use lexical binding.
(byte-inline-lapcode): Remove (to bytecomp).
(byte-compile-inline-expand): Pay attention to inlining to/from
lexically bound code.
(byte-compile-unfold-lambda): Don't handle byte-code-functions
any more.
(byte-optimize-form-code-walker): Don't handle save-window-excursion
any more and don't call compiler-macros.
(byte-compile-splice-in-already-compiled-code): Remove.
(byte-code): Don't inline any more.
(disassemble-offset): Receive `bytes' as argument rather than via
dynamic scoping.
(byte-compile-tag-number): Declare before first use.
(byte-decompile-bytecode-1): Handle new byte-codes, don't change
`return' even if make-spliceable.
(byte-compile-side-effect-and-error-free-ops): Add stack-ref, remove
obsolete interactive-p.
(byte-optimize-lapcode): Optimize new lap-codes.
Don't trip up on new form of `byte-constant' lap code.
* lisp/emacs-lisp/byte-run.el (make-obsolete): Don't set the `byte-compile'
handler any more.
* lisp/emacs-lisp/bytecomp.el: Use lexical binding instead of
a "bytecomp-" prefix. Macroexpand everything as a separate phase.
(byte-compile-initial-macro-environment):
Handle declare-function here.
(byte-compile--lexical-environment): New var.
(byte-stack-ref, byte-stack-set, byte-discardN)
(byte-discardN-preserve-tos): New lap codes.
(byte-interactive-p): Don't use any more.
(byte-compile-push-bytecodes, byte-compile-push-bytecode-const2):
New macros.
(byte-compile-lapcode): Use them and handle new lap codes.
(byte-compile-obsolete): Remove.
(byte-compile-arglist-signature): Handle new byte-code arg"lists".
(byte-compile-arglist-warn): Check late def of inlinable funs.
(byte-compile-cl-warn): Don't silence warnings for compiler-macros
since they should have been expanded by now.
(byte-compile--outbuffer): Rename from bytecomp-outbuffer.
(byte-compile-from-buffer): Remove unused second arg.
(byte-compile-preprocess): New function.
(byte-compile-toplevel-file-form): New function to distinguish
file-form calls from outside from file-form calls from hunk-handlers.
(byte-compile-file-form): Simplify.
(byte-compile-file-form-defsubst): Remove.
(byte-compile-file-form-defmumble): Simplify now that
byte-compile-lambda always returns a byte-code-function.
(byte-compile): Preprocess.
(byte-compile-byte-code-maker, byte-compile-byte-code-unmake):
Remove, not used any more.
(byte-compile-arglist-vars, byte-compile-make-lambda-lexenv)
(byte-compile-make-args-desc): New funs.
(byte-compile-lambda): Handle lexical functions. Always return
a byte-code-function.
(byte-compile-reserved-constants): New var, to make up room for
closed-over variables.
(byte-compile-constants-vector): Obey it.
(byte-compile-top-level): New args `lexenv' and `reserved-csts'.
(byte-compile-macroexpand-declare-function): New function.
(byte-compile-form): Call byte-compile-unfold-bcf to inline immediate
byte-code-functions.
(byte-compile-form): Check obsolescence here.
(byte-compile-inline-lapcode, byte-compile-unfold-bcf): New functions.
(byte-compile-variable-ref): Remove.
(byte-compile-dynamic-variable-op): New fun.
(byte-compile-dynamic-variable-bind, byte-compile-variable-ref)
(byte-compile-variable-set): New funs.
(byte-compile-discard): Add 2 args.
(byte-compile-stack-ref, byte-compile-stack-set)
(byte-compile-make-closure, byte-compile-get-closed-var): New funs.
(byte-compile-funarg, byte-compile-funarg-2): Remove, handled in
macroexpand-all instead.
(byte-compile-quote-form): Remove.
(byte-compile-push-binding-init, byte-compile-not-lexical-var-p)
(byte-compile-bind, byte-compile-unbind): New funs.
(byte-compile-let): Handle let* and lexical binding.
(byte-compile-let*): Remove.
(byte-compile-catch, byte-compile-unwind-protect)
(byte-compile-track-mouse, byte-compile-condition-case):
Handle a new :fun-body form, used for lexical scoping.
(byte-compile-save-window-excursion)
(byte-compile-with-output-to-temp-buffer): Remove.
(byte-compile-defun): Simplify.
(byte-compile-stack-adjustment): New fun.
(byte-compile-out): Use it.
(byte-compile-refresh-preloaded): Don't reload byte-compiler files.
* lisp/emacs-lisp/cconv.el: New file.
* lisp/emacs-lisp/cl-extra.el (cl-macroexpand-all): Properly quote CL
closures.
* lisp/emacs-lisp/cl-macs.el (cl-byte-compile-block)
(cl-byte-compile-throw): Remove.
(cl-block-wrapper, cl-block-throw): Use compiler-macros instead.
* lisp/emacs-lisp/cl.el (pushnew): Silence warning.
* lisp/emacs-lisp/disass.el (disassemble-internal): Handle new
`closure' objects.
(disassemble-1): Handle new byte codes.
* lisp/emacs-lisp/edebug.el (edebug-eval-defun)
(edebug-eval-top-level-form): Use eval-sexp-add-defvars.
(edebug-toggle): Avoid `eval'.
* lisp/emacs-lisp/eieio-comp.el: Remove.
* lisp/emacs-lisp/eieio.el (byte-compile-file-form-defmethod):
Don't autoload.
(eieio-defgeneric-form-primary-only-one): Use `byte-compile' rather
than the internal `byte-compile-lambda'.
(defmethod): Don't hide code under quotes.
(eieio-defmethod): New `code' argument.
* lisp/emacs-lisp/float-sup.el (pi): Don't declare as dynamically bound.
* lisp/emacs-lisp/lisp-mode.el (eval-last-sexp-1):
Use eval-sexp-add-defvars.
(eval-sexp-add-defvars): New fun.
* lisp/emacs-lisp/macroexp.el: Use lexical binding.
(macroexpand-all-1): Check obsolete macros. Expand compiler-macros.
Don't convert ' to #' without checking that it's indeed quoting
a lambda.
* lisp/emacs-lisp/pcase.el: Don't use destructuring-bind.
(pcase--memoize): Rename from pcase-memoize. Change weakness.
(pcase): Add `let' pattern.
Change memoization so it actually works.
(pcase-mutually-exclusive-predicates): Add byte-code-function-p.
(pcase--u1) <guard, pred>: Fix possible shadowing problem.
<let>: New case.
* src/alloc.c (Fmake_symbol): Init new `declared_special' field.
* src/buffer.c (defvar_per_buffer): Set new `declared_special' field.
* src/bytecode.c (Bstack_ref, Bstack_set, Bstack_set2, BdiscardN):
New byte-codes.
(exec_byte_code): New function extracted from Fbyte_code to handle new
calling convention for byte-code-functions. Add new byte-codes.
* src/callint.c (Fcall_interactively): Preserve lexical-binding mode for
interactive spec.
* src/doc.c (Fdocumentation, store_function_docstring):
* src/data.c (Finteractive_form): Handle closures.
* src/eval.c (Fsetq): Handle lexical vars.
(Fdefun, Fdefmacro, Ffunction): Make closures when needed.
(Fdefconst, Fdefvaralias, Fdefvar): Mark as dynamic.
(FletX, Flet): Obey lexical binding.
(Fcommandp): Handle closures.
(Feval): New `lexical' arg.
(eval_sub): New function extracted from Feval. Use it almost
everywhere where Feval was used. Look up vars in lexical env.
Handle closures.
(Ffunctionp): Move from subr.el.
(Ffuncall): Handle closures.
(apply_lambda): Remove `eval_flags'.
(funcall_lambda): Handle closures and new byte-code-functions.
(Fspecial_variable_p): New function.
(syms_of_eval): Initialize the Vinternal_interpreter_environment var,
but without exporting it to Lisp.
* src/fns.c (concat, mapcar1): Accept byte-code-functions.
* src/image.c (parse_image_spec): Use Ffunctionp.
* src/keyboard.c (eval_dyn): New fun.
(menu_item_eval_property): Use it.
* src/lisp.h (struct Lisp_Symbol): New field `declared_special'.
* src/lread.c (lisp_file_lexically_bound_p): New function.
(Fload): Bind Qlexical_binding.
(readevalloop): Remove `evalfun' arg.
Bind Qinternal_interpreter_environment.
(Feval_buffer): Bind Qlexical_binding.
(defvar_int, defvar_bool, defvar_lisp_nopro, defvar_kboard):
Mark as dynamic.
(syms_of_lread): Declare `lexical-binding'.
* src/window.c (Ftemp_output_buffer_show): New fun.
(Fsave_window_excursion):
* src/print.c (Fwith_output_to_temp_buffer): Move to subr.el.
2011-04-01 17:19:52 +00:00
|
|
|
|
(with-current-buffer (window-buffer window)
|
|
|
|
|
(if (pos-visible-in-window-p (point-max) window)
|
|
|
|
|
;; If end is in view, scroll up to the beginning.
|
|
|
|
|
(set-window-start window (point-min) nil)
|
|
|
|
|
;; Else scroll down one screen.
|
|
|
|
|
(scroll-other-window))
|
2010-05-12 00:39:46 +00:00
|
|
|
|
nil)))
|
|
|
|
|
;; If we're cycling, keep on cycling.
|
2010-10-28 02:22:29 +00:00
|
|
|
|
((and completion-cycling completion-all-sorted-completions)
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(minibuffer-force-complete beg end)
|
2010-05-12 00:39:46 +00:00
|
|
|
|
t)
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(t (pcase (completion--do-completion beg end)
|
2008-05-20 17:03:30 +00:00
|
|
|
|
(#b000 nil)
|
Reduce use of (require 'cl).
* admin/bzrmerge.el: Use cl-lib.
* leim/quail/hangul.el: Don't require CL.
* leim/quail/ipa.el: Use cl-lib.
* vc/smerge-mode.el, vc/pcvs.el, vc/pcvs-util.el, vc/pcvs-info.el:
* vc/diff-mode.el, vc/cvs-status.el, uniquify.el, scroll-bar.el:
* register.el, progmodes/sh-script.el, net/gnutls.el, net/dbus.el:
* msb.el, mpc.el, minibuffer.el, international/ucs-normalize.el:
* international/quail.el, info-xref.el, imenu.el, image-mode.el:
* font-lock.el, filesets.el, edmacro.el, doc-view.el, bookmark.el:
* battery.el, avoid.el, abbrev.el: Use cl-lib.
* vc/pcvs-parse.el, vc/pcvs-defs.el, vc/log-view.el, vc/log-edit.el:
* vc/diff.el, simple.el, pcomplete.el, lpr.el, comint.el, loadhist.el:
* jit-lock.el, international/iso-ascii.el, info.el, frame.el, bs.el:
* emulation/crisp.el, electric.el, dired.el, cus-dep.el, composite.el:
* calculator.el, autorevert.el, apropos.el: Don't require CL.
* emacs-bytecomp.el (byte-recompile-directory, display-call-tree)
(byte-compile-unfold-bcf, byte-compile-check-variable):
* emacs-byte-opt.el (byte-compile-trueconstp)
(byte-compile-nilconstp):
* emacs-autoload.el (make-autoload): Use pcase.
* face-remap.el (text-scale-adjust): Simplify pcase patterns.
2012-07-10 11:51:54 +00:00
|
|
|
|
(_ t)))))
|
2008-04-09 03:34:19 +00:00
|
|
|
|
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(defun completion--cache-all-sorted-completions (beg end comps)
|
2012-02-23 15:41:12 +00:00
|
|
|
|
(add-hook 'after-change-functions
|
2012-10-24 03:18:32 +00:00
|
|
|
|
'completion--flush-all-sorted-completions nil t)
|
|
|
|
|
(setq completion--all-sorted-completions-location
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(cons (copy-marker beg) (copy-marker end)))
|
2012-02-23 15:41:12 +00:00
|
|
|
|
(setq completion-all-sorted-completions comps))
|
|
|
|
|
|
2012-10-24 03:22:21 +00:00
|
|
|
|
(defun completion--flush-all-sorted-completions (&optional start end _len)
|
2012-10-24 03:18:32 +00:00
|
|
|
|
(unless (and start end
|
|
|
|
|
(or (> start (cdr completion--all-sorted-completions-location))
|
|
|
|
|
(< end (car completion--all-sorted-completions-location))))
|
|
|
|
|
(remove-hook 'after-change-functions
|
|
|
|
|
'completion--flush-all-sorted-completions t)
|
|
|
|
|
(setq completion-cycling nil)
|
|
|
|
|
(setq completion-all-sorted-completions nil)))
|
2008-05-21 20:52:44 +00:00
|
|
|
|
|
2011-05-31 21:40:30 +00:00
|
|
|
|
(defun completion--metadata (string base md-at-point table pred)
|
|
|
|
|
;; Like completion-metadata, but for the specific case of getting the
|
|
|
|
|
;; metadata at `base', which tends to trigger pathological behavior for old
|
|
|
|
|
;; completion tables which don't understand `metadata'.
|
|
|
|
|
(let ((bounds (completion-boundaries string table pred "")))
|
|
|
|
|
(if (eq (car bounds) base) md-at-point
|
|
|
|
|
(completion-metadata (substring string 0 base) table pred))))
|
|
|
|
|
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(defun completion-all-sorted-completions (start end)
|
2008-05-21 20:52:44 +00:00
|
|
|
|
(or completion-all-sorted-completions
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(let* ((start (or start (minibuffer-prompt-end)))
|
|
|
|
|
(end (or end (point-max)))
|
2011-05-31 03:03:38 +00:00
|
|
|
|
(string (buffer-substring start end))
|
2011-05-31 21:40:30 +00:00
|
|
|
|
(md (completion--field-metadata start))
|
2011-05-31 03:03:38 +00:00
|
|
|
|
(all (completion-all-completions
|
|
|
|
|
string
|
|
|
|
|
minibuffer-completion-table
|
|
|
|
|
minibuffer-completion-predicate
|
|
|
|
|
(- (point) start)
|
2011-05-31 21:40:30 +00:00
|
|
|
|
md))
|
2008-05-21 20:52:44 +00:00
|
|
|
|
(last (last all))
|
2011-05-31 03:03:38 +00:00
|
|
|
|
(base-size (or (cdr last) 0))
|
2011-05-31 21:40:30 +00:00
|
|
|
|
(all-md (completion--metadata (buffer-substring-no-properties
|
|
|
|
|
start (point))
|
|
|
|
|
base-size md
|
|
|
|
|
minibuffer-completion-table
|
|
|
|
|
minibuffer-completion-predicate))
|
2011-05-31 03:03:38 +00:00
|
|
|
|
(sort-fun (completion-metadata-get all-md 'cycle-sort-function)))
|
2008-05-21 20:52:44 +00:00
|
|
|
|
(when last
|
|
|
|
|
(setcdr last nil)
|
2012-11-29 21:32:24 +00:00
|
|
|
|
|
|
|
|
|
;; Delete duplicates: do it after setting last's cdr to nil (so
|
|
|
|
|
;; it's a proper list), and be careful to reset `last' since it
|
|
|
|
|
;; may be a different cons-cell.
|
|
|
|
|
(setq all (delete-dups all))
|
|
|
|
|
(setq last (last all))
|
|
|
|
|
|
2011-05-31 03:03:38 +00:00
|
|
|
|
(setq all (if sort-fun (funcall sort-fun all)
|
|
|
|
|
;; Prefer shorter completions, by default.
|
|
|
|
|
(sort all (lambda (c1 c2) (< (length c1) (length c2))))))
|
2008-05-21 20:52:44 +00:00
|
|
|
|
;; Prefer recently used completions.
|
2011-05-24 02:45:50 +00:00
|
|
|
|
(when (minibufferp)
|
|
|
|
|
(let ((hist (symbol-value minibuffer-history-variable)))
|
|
|
|
|
(setq all (sort all (lambda (c1 c2)
|
|
|
|
|
(> (length (member c1 hist))
|
|
|
|
|
(length (member c2 hist))))))))
|
2008-05-21 20:52:44 +00:00
|
|
|
|
;; Cache the result. This is not just for speed, but also so that
|
|
|
|
|
;; repeated calls to minibuffer-force-complete can cycle through
|
|
|
|
|
;; all possibilities.
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(completion--cache-all-sorted-completions
|
|
|
|
|
start end (nconc all base-size))))))
|
2008-05-21 20:52:44 +00:00
|
|
|
|
|
2012-11-29 21:32:24 +00:00
|
|
|
|
(defun minibuffer-force-complete-and-exit ()
|
|
|
|
|
"Complete the minibuffer with first of the matches and exit."
|
|
|
|
|
(interactive)
|
|
|
|
|
(minibuffer-force-complete)
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(completion--complete-and-exit
|
|
|
|
|
(minibuffer-prompt-end) (point-max) #'exit-minibuffer
|
2012-11-29 21:32:24 +00:00
|
|
|
|
;; If the previous completion completed to an element which fails
|
|
|
|
|
;; test-completion, then we shouldn't exit, but that should be rare.
|
|
|
|
|
(lambda () (minibuffer-message "Incomplete"))))
|
|
|
|
|
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(defun minibuffer-force-complete (&optional start end)
|
2008-05-21 20:52:44 +00:00
|
|
|
|
"Complete the minibuffer to an exact match.
|
|
|
|
|
Repeated uses step through the possible completions."
|
|
|
|
|
(interactive)
|
2013-04-15 19:55:41 +00:00
|
|
|
|
(setq minibuffer-scroll-window nil)
|
2008-05-21 20:52:44 +00:00
|
|
|
|
;; FIXME: Need to deal with the extra-size issue here as well.
|
2009-10-21 20:03:57 +00:00
|
|
|
|
;; FIXME: ~/src/emacs/t<M-TAB>/lisp/minibuffer.el completes to
|
|
|
|
|
;; ~/src/emacs/trunk/ and throws away lisp/minibuffer.el.
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(let* ((start (copy-marker (or start (minibuffer-prompt-end))))
|
|
|
|
|
(end (or end (point-max)))
|
2011-05-31 03:03:38 +00:00
|
|
|
|
;; (md (completion--field-metadata start))
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(all (completion-all-sorted-completions start end))
|
2011-05-24 02:45:50 +00:00
|
|
|
|
(base (+ start (or (cdr (last all)) 0))))
|
|
|
|
|
(cond
|
|
|
|
|
((not (consp all))
|
2011-05-04 01:19:32 +00:00
|
|
|
|
(completion--message
|
2011-05-24 02:45:50 +00:00
|
|
|
|
(if all "No more completions" "No completions")))
|
|
|
|
|
((not (consp (cdr all)))
|
2012-10-25 12:56:13 +00:00
|
|
|
|
(let ((done (equal (car all) (buffer-substring-no-properties base end))))
|
|
|
|
|
(unless done (completion--replace base end (car all)))
|
2011-05-24 02:45:50 +00:00
|
|
|
|
(completion--done (buffer-substring-no-properties start (point))
|
2012-10-25 12:56:13 +00:00
|
|
|
|
'finished (when done "Sole completion"))))
|
2011-05-24 02:45:50 +00:00
|
|
|
|
(t
|
|
|
|
|
(completion--replace base end (car all))
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(setq end (+ base (length (car all))))
|
2011-05-24 02:45:50 +00:00
|
|
|
|
(completion--done (buffer-substring-no-properties start (point)) 'sole)
|
2012-02-23 15:41:12 +00:00
|
|
|
|
;; Set cycling after modifying the buffer since the flush hook resets it.
|
|
|
|
|
(setq completion-cycling t)
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(setq this-command 'completion-at-point) ;For completion-in-region.
|
2008-05-21 20:52:44 +00:00
|
|
|
|
;; If completing file names, (car all) may be a directory, so we'd now
|
|
|
|
|
;; have a new set of possible completions and might want to reset
|
|
|
|
|
;; completion-all-sorted-completions to nil, but we prefer not to,
|
|
|
|
|
;; so that repeated calls minibuffer-force-complete still cycle
|
|
|
|
|
;; through the previous possible completions.
|
2009-09-24 02:37:37 +00:00
|
|
|
|
(let ((last (last all)))
|
|
|
|
|
(setcdr last (cons (car all) (cdr last)))
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(completion--cache-all-sorted-completions start end (cdr all)))
|
2012-10-19 18:59:36 +00:00
|
|
|
|
;; Make sure repeated uses cycle, even though completion--done might
|
|
|
|
|
;; have added a space or something that moved us outside of the field.
|
|
|
|
|
;; (bug#12221).
|
|
|
|
|
(let* ((table minibuffer-completion-table)
|
|
|
|
|
(pred minibuffer-completion-predicate)
|
|
|
|
|
(extra-prop completion-extra-properties)
|
|
|
|
|
(cmd
|
|
|
|
|
(lambda () "Cycle through the possible completions."
|
|
|
|
|
(interactive)
|
|
|
|
|
(let ((completion-extra-properties extra-prop))
|
|
|
|
|
(completion-in-region start (point) table pred)))))
|
|
|
|
|
(set-temporary-overlay-map
|
|
|
|
|
(let ((map (make-sparse-keymap)))
|
|
|
|
|
(define-key map [remap completion-at-point] cmd)
|
|
|
|
|
(define-key map (vector last-command-event) cmd)
|
|
|
|
|
map)))))))
|
2008-05-21 20:52:44 +00:00
|
|
|
|
|
2008-11-29 18:07:15 +00:00
|
|
|
|
(defvar minibuffer-confirm-exit-commands
|
2012-06-23 04:48:55 +00:00
|
|
|
|
'(completion-at-point minibuffer-complete
|
|
|
|
|
minibuffer-complete-word PC-complete PC-complete-word)
|
2008-11-29 18:07:15 +00:00
|
|
|
|
"A list of commands which cause an immediately following
|
|
|
|
|
`minibuffer-complete-and-exit' to ask for extra confirmation.")
|
|
|
|
|
|
2008-04-09 03:34:19 +00:00
|
|
|
|
(defun minibuffer-complete-and-exit ()
|
2008-11-24 19:14:05 +00:00
|
|
|
|
"Exit if the minibuffer contains a valid completion.
|
|
|
|
|
Otherwise, try to complete the minibuffer contents. If
|
|
|
|
|
completion leads to a valid completion, a repetition of this
|
|
|
|
|
command will exit.
|
|
|
|
|
|
|
|
|
|
If `minibuffer-completion-confirm' is `confirm', do not try to
|
|
|
|
|
complete; instead, ask for confirmation and accept any input if
|
|
|
|
|
confirmed.
|
|
|
|
|
If `minibuffer-completion-confirm' is `confirm-after-completion',
|
|
|
|
|
do not try to complete; instead, ask for confirmation if the
|
2009-03-17 04:39:09 +00:00
|
|
|
|
preceding minibuffer command was a member of
|
|
|
|
|
`minibuffer-confirm-exit-commands', and accept the input
|
|
|
|
|
otherwise."
|
2008-04-09 03:34:19 +00:00
|
|
|
|
(interactive)
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(completion-complete-and-exit (minibuffer-prompt-end) (point-max)
|
|
|
|
|
#'exit-minibuffer))
|
|
|
|
|
|
|
|
|
|
(defun completion-complete-and-exit (beg end exit-function)
|
|
|
|
|
(completion--complete-and-exit
|
|
|
|
|
beg end exit-function
|
2012-11-29 21:32:24 +00:00
|
|
|
|
(lambda ()
|
|
|
|
|
(pcase (condition-case nil
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(completion--do-completion beg end
|
|
|
|
|
nil 'expect-exact)
|
2012-11-29 21:32:24 +00:00
|
|
|
|
(error 1))
|
2013-09-06 22:46:44 +00:00
|
|
|
|
((or #b001 #b011) (funcall exit-function))
|
2012-11-29 21:32:24 +00:00
|
|
|
|
(#b111 (if (not minibuffer-completion-confirm)
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(funcall exit-function)
|
2012-11-29 21:32:24 +00:00
|
|
|
|
(minibuffer-message "Confirm")
|
|
|
|
|
nil))
|
|
|
|
|
(_ nil)))))
|
|
|
|
|
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(defun completion--complete-and-exit (beg end
|
|
|
|
|
exit-function completion-function)
|
2012-11-29 21:32:24 +00:00
|
|
|
|
"Exit from `require-match' minibuffer.
|
|
|
|
|
COMPLETION-FUNCTION is called if the current buffer's content does not
|
|
|
|
|
appear to be a match."
|
2008-04-21 19:02:54 +00:00
|
|
|
|
(cond
|
|
|
|
|
;; Allow user to specify null string
|
2013-09-06 22:46:44 +00:00
|
|
|
|
((= beg end) (funcall exit-function))
|
2008-04-21 19:02:54 +00:00
|
|
|
|
((test-completion (buffer-substring beg end)
|
|
|
|
|
minibuffer-completion-table
|
|
|
|
|
minibuffer-completion-predicate)
|
2009-12-06 01:25:41 +00:00
|
|
|
|
;; FIXME: completion-ignore-case has various slightly
|
|
|
|
|
;; incompatible meanings. E.g. it can reflect whether the user
|
|
|
|
|
;; wants completion to pay attention to case, or whether the
|
|
|
|
|
;; string will be used in a context where case is significant.
|
|
|
|
|
;; E.g. usually try-completion should obey the first, whereas
|
|
|
|
|
;; test-completion should obey the second.
|
2008-04-21 19:02:54 +00:00
|
|
|
|
(when completion-ignore-case
|
|
|
|
|
;; Fixup case of the field, if necessary.
|
2008-04-22 10:20:05 +00:00
|
|
|
|
(let* ((string (buffer-substring beg end))
|
2008-04-21 19:02:54 +00:00
|
|
|
|
(compl (try-completion
|
|
|
|
|
string
|
|
|
|
|
minibuffer-completion-table
|
|
|
|
|
minibuffer-completion-predicate)))
|
2009-12-06 01:25:41 +00:00
|
|
|
|
(when (and (stringp compl) (not (equal string compl))
|
2008-04-21 19:02:54 +00:00
|
|
|
|
;; If it weren't for this piece of paranoia, I'd replace
|
|
|
|
|
;; the whole thing with a call to do-completion.
|
2008-06-10 22:01:59 +00:00
|
|
|
|
;; This is important, e.g. when the current minibuffer's
|
|
|
|
|
;; content is a directory which only contains a single
|
|
|
|
|
;; file, so `try-completion' actually completes to
|
|
|
|
|
;; that file.
|
2008-04-21 19:02:54 +00:00
|
|
|
|
(= (length string) (length compl)))
|
2011-10-17 16:30:02 +00:00
|
|
|
|
(completion--replace beg end compl))))
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(funcall exit-function))
|
2008-04-09 03:34:19 +00:00
|
|
|
|
|
2009-12-06 01:25:41 +00:00
|
|
|
|
((memq minibuffer-completion-confirm '(confirm confirm-after-completion))
|
2008-04-21 19:02:54 +00:00
|
|
|
|
;; The user is permitted to exit with an input that's rejected
|
2008-11-24 19:14:05 +00:00
|
|
|
|
;; by test-completion, after confirming her choice.
|
2009-12-06 01:25:41 +00:00
|
|
|
|
(if (or (eq last-command this-command)
|
|
|
|
|
;; For `confirm-after-completion' we only ask for confirmation
|
|
|
|
|
;; if trying to exit immediately after typing TAB (this
|
|
|
|
|
;; catches most minibuffer typos).
|
|
|
|
|
(and (eq minibuffer-completion-confirm 'confirm-after-completion)
|
|
|
|
|
(not (memq last-command minibuffer-confirm-exit-commands))))
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(funcall exit-function)
|
2008-04-21 19:02:54 +00:00
|
|
|
|
(minibuffer-message "Confirm")
|
|
|
|
|
nil))
|
2008-04-09 03:34:19 +00:00
|
|
|
|
|
2008-04-21 19:02:54 +00:00
|
|
|
|
(t
|
|
|
|
|
;; Call do-completion, but ignore errors.
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(funcall completion-function))))
|
2008-04-21 19:02:54 +00:00
|
|
|
|
|
2011-05-31 03:03:38 +00:00
|
|
|
|
(defun completion--try-word-completion (string table predicate point md)
|
|
|
|
|
(let ((comp (completion-try-completion string table predicate point md)))
|
2008-04-23 21:01:31 +00:00
|
|
|
|
(if (not (consp comp))
|
|
|
|
|
comp
|
2008-04-09 03:34:19 +00:00
|
|
|
|
|
2008-04-21 19:02:54 +00:00
|
|
|
|
;; If completion finds next char not unique,
|
|
|
|
|
;; consider adding a space or a hyphen.
|
2008-04-23 21:01:31 +00:00
|
|
|
|
(when (= (length string) (length (car comp)))
|
2009-04-14 02:02:30 +00:00
|
|
|
|
;; Mark the added char with the `completion-word' property, so it
|
|
|
|
|
;; can be handled specially by completion styles such as
|
|
|
|
|
;; partial-completion.
|
|
|
|
|
;; We used to remove `partial-completion' from completion-styles
|
|
|
|
|
;; instead, but it was too blunt, leading to situations where SPC
|
|
|
|
|
;; was the only insertable char at point but minibuffer-complete-word
|
|
|
|
|
;; refused inserting it.
|
|
|
|
|
(let ((exts (mapcar (lambda (str) (propertize str 'completion-try-word t))
|
|
|
|
|
'(" " "-")))
|
2008-04-23 21:01:31 +00:00
|
|
|
|
(before (substring string 0 point))
|
|
|
|
|
(after (substring string point))
|
|
|
|
|
tem)
|
|
|
|
|
(while (and exts (not (consp tem)))
|
2008-04-21 19:02:54 +00:00
|
|
|
|
(setq tem (completion-try-completion
|
2008-04-23 21:01:31 +00:00
|
|
|
|
(concat before (pop exts) after)
|
2011-05-31 03:03:38 +00:00
|
|
|
|
table predicate (1+ point) md)))
|
2008-04-23 21:01:31 +00:00
|
|
|
|
(if (consp tem) (setq comp tem))))
|
2008-04-21 19:02:54 +00:00
|
|
|
|
|
2008-04-09 03:34:19 +00:00
|
|
|
|
;; Completing a single word is actually more difficult than completing
|
|
|
|
|
;; as much as possible, because we first have to find the "current
|
|
|
|
|
;; position" in `completion' in order to find the end of the word
|
|
|
|
|
;; we're completing. Normally, `string' is a prefix of `completion',
|
|
|
|
|
;; which makes it trivial to find the position, but with fancier
|
|
|
|
|
;; completion (plus env-var expansion, ...) `completion' might not
|
|
|
|
|
;; look anything like `string' at all.
|
2008-04-23 21:01:31 +00:00
|
|
|
|
(let* ((comppoint (cdr comp))
|
|
|
|
|
(completion (car comp))
|
|
|
|
|
(before (substring string 0 point))
|
|
|
|
|
(combined (concat before "\n" completion)))
|
|
|
|
|
;; Find in completion the longest text that was right before point.
|
|
|
|
|
(when (string-match "\\(.+\\)\n.*?\\1" combined)
|
|
|
|
|
(let* ((prefix (match-string 1 before))
|
|
|
|
|
;; We used non-greedy match to make `rem' as long as possible.
|
|
|
|
|
(rem (substring combined (match-end 0)))
|
|
|
|
|
;; Find in the remainder of completion the longest text
|
|
|
|
|
;; that was right after point.
|
|
|
|
|
(after (substring string point))
|
|
|
|
|
(suffix (if (string-match "\\`\\(.+\\).*\n.*\\1"
|
|
|
|
|
(concat after "\n" rem))
|
|
|
|
|
(match-string 1 after))))
|
|
|
|
|
;; The general idea is to try and guess what text was inserted
|
|
|
|
|
;; at point by the completion. Problem is: if we guess wrong,
|
|
|
|
|
;; we may end up treating as "added by completion" text that was
|
|
|
|
|
;; actually painfully typed by the user. So if we then cut
|
|
|
|
|
;; after the first word, we may throw away things the
|
|
|
|
|
;; user wrote. So let's try to be as conservative as possible:
|
|
|
|
|
;; only cut after the first word, if we're reasonably sure that
|
|
|
|
|
;; our guess is correct.
|
|
|
|
|
;; Note: a quick survey on emacs-devel seemed to indicate that
|
|
|
|
|
;; nobody actually cares about the "word-at-a-time" feature of
|
|
|
|
|
;; minibuffer-complete-word, whose real raison-d'être is that it
|
|
|
|
|
;; tries to add "-" or " ". One more reason to only cut after
|
|
|
|
|
;; the first word, if we're really sure we're right.
|
|
|
|
|
(when (and (or suffix (zerop (length after)))
|
|
|
|
|
(string-match (concat
|
|
|
|
|
;; Make submatch 1 as small as possible
|
|
|
|
|
;; to reduce the risk of cutting
|
|
|
|
|
;; valuable text.
|
|
|
|
|
".*" (regexp-quote prefix) "\\(.*?\\)"
|
|
|
|
|
(if suffix (regexp-quote suffix) "\\'"))
|
|
|
|
|
completion)
|
|
|
|
|
;; The new point in `completion' should also be just
|
|
|
|
|
;; before the suffix, otherwise something more complex
|
|
|
|
|
;; is going on, and we're not sure where we are.
|
|
|
|
|
(eq (match-end 1) comppoint)
|
|
|
|
|
;; (match-beginning 1)..comppoint is now the stretch
|
|
|
|
|
;; of text in `completion' that was completed at point.
|
|
|
|
|
(string-match "\\W" completion (match-beginning 1))
|
|
|
|
|
;; Is there really something to cut?
|
|
|
|
|
(> comppoint (match-end 0)))
|
|
|
|
|
;; Cut after the first word.
|
|
|
|
|
(let ((cutpos (match-end 0)))
|
|
|
|
|
(setq completion (concat (substring completion 0 cutpos)
|
|
|
|
|
(substring completion comppoint)))
|
|
|
|
|
(setq comppoint cutpos)))))
|
|
|
|
|
|
|
|
|
|
(cons completion comppoint)))))
|
2008-04-09 19:33:56 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
(defun minibuffer-complete-word ()
|
|
|
|
|
"Complete the minibuffer contents at most a single word.
|
|
|
|
|
After one word is completed as much as possible, a space or hyphen
|
|
|
|
|
is added, provided that matches some possible completion.
|
|
|
|
|
Return nil if there is no valid completion, else t."
|
|
|
|
|
(interactive)
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(completion-in-region--single-word
|
|
|
|
|
(minibuffer-prompt-end) (point-max)
|
|
|
|
|
minibuffer-completion-table minibuffer-completion-predicate))
|
|
|
|
|
|
|
|
|
|
(defun completion-in-region--single-word (beg end collection
|
|
|
|
|
&optional predicate)
|
|
|
|
|
(let ((minibuffer-completion-table collection)
|
|
|
|
|
(minibuffer-completion-predicate predicate))
|
|
|
|
|
(pcase (completion--do-completion beg end
|
|
|
|
|
#'completion--try-word-completion)
|
2008-05-20 17:03:30 +00:00
|
|
|
|
(#b000 nil)
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(_ t))))
|
2008-04-09 19:33:56 +00:00
|
|
|
|
|
2009-08-19 02:15:19 +00:00
|
|
|
|
(defface completions-annotations '((t :inherit italic))
|
|
|
|
|
"Face to use for annotations in the *Completions* buffer.")
|
|
|
|
|
|
2010-06-24 21:51:14 +00:00
|
|
|
|
(defcustom completions-format 'horizontal
|
2009-11-19 17:38:37 +00:00
|
|
|
|
"Define the appearance and sorting of completions.
|
|
|
|
|
If the value is `vertical', display completions sorted vertically
|
|
|
|
|
in columns in the *Completions* buffer.
|
2010-06-24 21:51:14 +00:00
|
|
|
|
If the value is `horizontal', display completions sorted
|
2009-11-19 17:38:37 +00:00
|
|
|
|
horizontally in alphabetical order, rather than down the screen."
|
2010-06-24 21:51:14 +00:00
|
|
|
|
:type '(choice (const horizontal) (const vertical))
|
2009-11-19 17:38:37 +00:00
|
|
|
|
:version "23.2")
|
|
|
|
|
|
2008-04-21 19:02:54 +00:00
|
|
|
|
(defun completion--insert-strings (strings)
|
2008-04-09 03:34:19 +00:00
|
|
|
|
"Insert a list of STRINGS into the current buffer.
|
|
|
|
|
Uses columns to keep the listing readable but compact.
|
|
|
|
|
It also eliminates runs of equal strings."
|
|
|
|
|
(when (consp strings)
|
|
|
|
|
(let* ((length (apply 'max
|
|
|
|
|
(mapcar (lambda (s)
|
|
|
|
|
(if (consp s)
|
2008-05-02 17:32:51 +00:00
|
|
|
|
(+ (string-width (car s))
|
|
|
|
|
(string-width (cadr s)))
|
|
|
|
|
(string-width s)))
|
2008-04-09 03:34:19 +00:00
|
|
|
|
strings)))
|
|
|
|
|
(window (get-buffer-window (current-buffer) 0))
|
|
|
|
|
(wwidth (if window (1- (window-width window)) 79))
|
|
|
|
|
(columns (min
|
|
|
|
|
;; At least 2 columns; at least 2 spaces between columns.
|
|
|
|
|
(max 2 (/ wwidth (+ 2 length)))
|
|
|
|
|
;; Don't allocate more columns than we can fill.
|
|
|
|
|
;; Windows can't show less than 3 lines anyway.
|
|
|
|
|
(max 1 (/ (length strings) 2))))
|
|
|
|
|
(colwidth (/ wwidth columns))
|
|
|
|
|
(column 0)
|
2009-11-19 17:38:37 +00:00
|
|
|
|
(rows (/ (length strings) columns))
|
|
|
|
|
(row 0)
|
2011-09-02 00:36:58 +00:00
|
|
|
|
(first t)
|
2008-04-09 03:34:19 +00:00
|
|
|
|
(laststring nil))
|
|
|
|
|
;; The insertion should be "sensible" no matter what choices were made
|
|
|
|
|
;; for the parameters above.
|
|
|
|
|
(dolist (str strings)
|
2009-01-21 21:20:55 +00:00
|
|
|
|
(unless (equal laststring str) ; Remove (consecutive) duplicates.
|
2008-04-09 03:34:19 +00:00
|
|
|
|
(setq laststring str)
|
2011-09-02 00:36:58 +00:00
|
|
|
|
;; FIXME: `string-width' doesn't pay attention to
|
|
|
|
|
;; `display' properties.
|
2009-01-21 21:20:55 +00:00
|
|
|
|
(let ((length (if (consp str)
|
|
|
|
|
(+ (string-width (car str))
|
|
|
|
|
(string-width (cadr str)))
|
|
|
|
|
(string-width str))))
|
2009-11-19 17:38:37 +00:00
|
|
|
|
(cond
|
|
|
|
|
((eq completions-format 'vertical)
|
|
|
|
|
;; Vertical format
|
|
|
|
|
(when (> row rows)
|
|
|
|
|
(forward-line (- -1 rows))
|
|
|
|
|
(setq row 0 column (+ column colwidth)))
|
|
|
|
|
(when (> column 0)
|
|
|
|
|
(end-of-line)
|
|
|
|
|
(while (> (current-column) column)
|
|
|
|
|
(if (eobp)
|
|
|
|
|
(insert "\n")
|
|
|
|
|
(forward-line 1)
|
|
|
|
|
(end-of-line)))
|
|
|
|
|
(insert " \t")
|
2011-09-02 00:36:58 +00:00
|
|
|
|
(set-text-properties (1- (point)) (point)
|
2009-11-19 17:38:37 +00:00
|
|
|
|
`(display (space :align-to ,column)))))
|
|
|
|
|
(t
|
|
|
|
|
;; Horizontal format
|
2011-09-02 00:36:58 +00:00
|
|
|
|
(unless first
|
2009-11-19 17:38:37 +00:00
|
|
|
|
(if (< wwidth (+ (max colwidth length) column))
|
|
|
|
|
;; No space for `str' at point, move to next line.
|
|
|
|
|
(progn (insert "\n") (setq column 0))
|
|
|
|
|
(insert " \t")
|
|
|
|
|
;; Leave the space unpropertized so that in the case we're
|
|
|
|
|
;; already past the goal column, there is still
|
|
|
|
|
;; a space displayed.
|
2011-09-02 00:36:58 +00:00
|
|
|
|
(set-text-properties (1- (point)) (point)
|
2009-11-19 17:38:37 +00:00
|
|
|
|
;; We can't just set tab-width, because
|
2011-03-30 22:25:57 +00:00
|
|
|
|
;; completion-setup-function will kill
|
|
|
|
|
;; all local variables :-(
|
2009-11-19 17:38:37 +00:00
|
|
|
|
`(display (space :align-to ,column)))
|
|
|
|
|
nil))))
|
2011-09-02 00:36:58 +00:00
|
|
|
|
(setq first nil)
|
2009-01-21 21:20:55 +00:00
|
|
|
|
(if (not (consp str))
|
2011-08-22 12:58:37 +00:00
|
|
|
|
(put-text-property (point) (progn (insert str) (point))
|
2009-01-21 21:20:55 +00:00
|
|
|
|
'mouse-face 'highlight)
|
2011-08-22 12:58:37 +00:00
|
|
|
|
(put-text-property (point) (progn (insert (car str)) (point))
|
2009-01-21 21:20:55 +00:00
|
|
|
|
'mouse-face 'highlight)
|
2013-03-05 07:38:16 +00:00
|
|
|
|
(let ((beg (point))
|
|
|
|
|
(end (progn (insert (cadr str)) (point))))
|
|
|
|
|
(put-text-property beg end 'mouse-face nil)
|
|
|
|
|
(font-lock-prepend-text-property beg end 'face
|
|
|
|
|
'completions-annotations)))
|
2009-11-19 17:38:37 +00:00
|
|
|
|
(cond
|
|
|
|
|
((eq completions-format 'vertical)
|
|
|
|
|
;; Vertical format
|
|
|
|
|
(if (> column 0)
|
|
|
|
|
(forward-line)
|
|
|
|
|
(insert "\n"))
|
|
|
|
|
(setq row (1+ row)))
|
|
|
|
|
(t
|
|
|
|
|
;; Horizontal format
|
|
|
|
|
;; Next column to align to.
|
|
|
|
|
(setq column (+ column
|
|
|
|
|
;; Round up to a whole number of columns.
|
|
|
|
|
(* colwidth (ceiling length colwidth))))))))))))
|
2008-04-09 03:34:19 +00:00
|
|
|
|
|
2008-04-29 05:36:55 +00:00
|
|
|
|
(defvar completion-common-substring nil)
|
|
|
|
|
(make-obsolete-variable 'completion-common-substring nil "23.1")
|
2008-04-09 03:34:19 +00:00
|
|
|
|
|
2008-04-11 22:28:02 +00:00
|
|
|
|
(defvar completion-setup-hook nil
|
|
|
|
|
"Normal hook run at the end of setting up a completion list buffer.
|
|
|
|
|
When this hook is run, the current buffer is the one in which the
|
|
|
|
|
command to display the completion list buffer was run.
|
|
|
|
|
The completion list buffer is available as the value of `standard-output'.
|
2008-04-29 05:36:55 +00:00
|
|
|
|
See also `display-completion-list'.")
|
|
|
|
|
|
|
|
|
|
(defface completions-first-difference
|
|
|
|
|
'((t (:inherit bold)))
|
2013-09-06 22:46:44 +00:00
|
|
|
|
"Face added on the first uncommon character in completions in *Completions* buffer.")
|
2008-04-29 05:36:55 +00:00
|
|
|
|
|
2013-03-05 07:38:16 +00:00
|
|
|
|
(defface completions-common-part '((t nil))
|
|
|
|
|
"Face added on the common prefix substring in completions in *Completions* buffer.
|
2008-04-29 05:36:55 +00:00
|
|
|
|
The idea of `completions-common-part' is that you can use it to
|
|
|
|
|
make the common parts less visible than normal, so that the rest
|
2013-09-06 22:46:44 +00:00
|
|
|
|
of the differing parts is, by contrast, slightly highlighted.")
|
2008-04-29 05:36:55 +00:00
|
|
|
|
|
2008-12-21 05:20:06 +00:00
|
|
|
|
(defun completion-hilit-commonality (completions prefix-len base-size)
|
2008-04-29 05:36:55 +00:00
|
|
|
|
(when completions
|
2008-12-21 05:20:06 +00:00
|
|
|
|
(let ((com-str-len (- prefix-len (or base-size 0))))
|
2008-04-29 05:36:55 +00:00
|
|
|
|
(nconc
|
|
|
|
|
(mapcar
|
2008-05-02 17:02:52 +00:00
|
|
|
|
(lambda (elem)
|
|
|
|
|
(let ((str
|
|
|
|
|
;; Don't modify the string itself, but a copy, since the
|
|
|
|
|
;; the string may be read-only or used for other purposes.
|
|
|
|
|
;; Furthermore, since `completions' may come from
|
|
|
|
|
;; display-completion-list, `elem' may be a list.
|
|
|
|
|
(if (consp elem)
|
|
|
|
|
(car (setq elem (cons (copy-sequence (car elem))
|
|
|
|
|
(cdr elem))))
|
|
|
|
|
(setq elem (copy-sequence elem)))))
|
2013-03-05 07:38:16 +00:00
|
|
|
|
(font-lock-prepend-text-property
|
|
|
|
|
0
|
|
|
|
|
;; If completion-boundaries returns incorrect
|
|
|
|
|
;; values, all-completions may return strings
|
|
|
|
|
;; that don't contain the prefix.
|
|
|
|
|
(min com-str-len (length str))
|
|
|
|
|
'face 'completions-common-part str)
|
2008-05-02 17:02:52 +00:00
|
|
|
|
(if (> (length str) com-str-len)
|
2013-03-05 07:38:16 +00:00
|
|
|
|
(font-lock-prepend-text-property com-str-len (1+ com-str-len)
|
|
|
|
|
'face
|
|
|
|
|
'completions-first-difference
|
|
|
|
|
str)))
|
2008-05-02 17:02:52 +00:00
|
|
|
|
elem)
|
2008-04-29 05:36:55 +00:00
|
|
|
|
completions)
|
|
|
|
|
base-size))))
|
2008-04-11 22:28:02 +00:00
|
|
|
|
|
2008-08-15 00:10:03 +00:00
|
|
|
|
(defun display-completion-list (completions &optional common-substring)
|
2008-04-09 03:34:19 +00:00
|
|
|
|
"Display the list of completions, COMPLETIONS, using `standard-output'.
|
|
|
|
|
Each element may be just a symbol or string
|
|
|
|
|
or may be a list of two strings to be printed as if concatenated.
|
|
|
|
|
If it is a list of two strings, the first is the actual completion
|
|
|
|
|
alternative, the second serves as annotation.
|
|
|
|
|
`standard-output' must be a buffer.
|
|
|
|
|
The actual completion alternatives, as inserted, are given `mouse-face'
|
|
|
|
|
properties of `highlight'.
|
|
|
|
|
At the end, this runs the normal hook `completion-setup-hook'.
|
2013-09-06 22:46:44 +00:00
|
|
|
|
It can find the completion buffer in `standard-output'."
|
|
|
|
|
(declare (advertised-calling-convention (completions) "24.4"))
|
2008-04-29 05:36:55 +00:00
|
|
|
|
(if common-substring
|
|
|
|
|
(setq completions (completion-hilit-commonality
|
2008-12-21 05:20:06 +00:00
|
|
|
|
completions (length common-substring)
|
|
|
|
|
;; We don't know the base-size.
|
|
|
|
|
nil)))
|
2008-04-09 03:34:19 +00:00
|
|
|
|
(if (not (bufferp standard-output))
|
|
|
|
|
;; This *never* (ever) happens, so there's no point trying to be clever.
|
|
|
|
|
(with-temp-buffer
|
|
|
|
|
(let ((standard-output (current-buffer))
|
|
|
|
|
(completion-setup-hook nil))
|
2008-08-15 00:10:03 +00:00
|
|
|
|
(display-completion-list completions common-substring))
|
2008-04-09 03:34:19 +00:00
|
|
|
|
(princ (buffer-string)))
|
|
|
|
|
|
2009-10-15 01:50:17 +00:00
|
|
|
|
(with-current-buffer standard-output
|
|
|
|
|
(goto-char (point-max))
|
|
|
|
|
(if (null completions)
|
|
|
|
|
(insert "There are no possible completions of what you have typed.")
|
|
|
|
|
(insert "Possible completions are:\n")
|
|
|
|
|
(completion--insert-strings completions))))
|
2008-04-13 22:12:02 +00:00
|
|
|
|
|
2008-04-29 05:36:55 +00:00
|
|
|
|
;; The hilit used to be applied via completion-setup-hook, so there
|
|
|
|
|
;; may still be some code that uses completion-common-substring.
|
2008-08-14 23:44:41 +00:00
|
|
|
|
(with-no-warnings
|
|
|
|
|
(let ((completion-common-substring common-substring))
|
|
|
|
|
(run-hooks 'completion-setup-hook)))
|
2008-04-09 03:34:19 +00:00
|
|
|
|
nil)
|
|
|
|
|
|
2011-05-24 02:45:50 +00:00
|
|
|
|
(defvar completion-extra-properties nil
|
|
|
|
|
"Property list of extra properties of the current completion job.
|
|
|
|
|
These include:
|
2012-04-04 09:19:32 +00:00
|
|
|
|
|
|
|
|
|
`:annotation-function': Function to annotate the completions buffer.
|
|
|
|
|
The function must accept one argument, a completion string,
|
|
|
|
|
and return either nil or a string which is to be displayed
|
|
|
|
|
next to the completion (but which is not part of the
|
|
|
|
|
completion). The function can access the completion data via
|
|
|
|
|
`minibuffer-completion-table' and related variables.
|
|
|
|
|
|
2011-05-24 02:45:50 +00:00
|
|
|
|
`:exit-function': Function to run after completion is performed.
|
2012-04-04 09:19:32 +00:00
|
|
|
|
|
|
|
|
|
The function must accept two arguments, STRING and STATUS.
|
|
|
|
|
STRING is the text to which the field was completed, and
|
|
|
|
|
STATUS indicates what kind of operation happened:
|
|
|
|
|
`finished' - text is now complete
|
|
|
|
|
`sole' - text cannot be further completed but
|
|
|
|
|
completion is not finished
|
|
|
|
|
`exact' - text is a valid completion but may be further
|
|
|
|
|
completed.")
|
2011-05-24 02:45:50 +00:00
|
|
|
|
|
2009-08-30 03:45:30 +00:00
|
|
|
|
(defvar completion-annotate-function
|
|
|
|
|
nil
|
|
|
|
|
;; Note: there's a lot of scope as for when to add annotations and
|
|
|
|
|
;; what annotations to add. E.g. completing-help.el allowed adding
|
|
|
|
|
;; the first line of docstrings to M-x completion. But there's
|
|
|
|
|
;; a tension, since such annotations, while useful at times, can
|
|
|
|
|
;; actually drown the useful information.
|
|
|
|
|
;; So completion-annotate-function should be used parsimoniously, or
|
|
|
|
|
;; else only used upon a user's request (e.g. we could add a command
|
|
|
|
|
;; to completion-list-mode to add annotations to the current
|
|
|
|
|
;; completions).
|
|
|
|
|
"Function to add annotations in the *Completions* buffer.
|
|
|
|
|
The function takes a completion and should either return nil, or a string that
|
|
|
|
|
will be displayed next to the completion. The function can access the
|
|
|
|
|
completion table and predicates via `minibuffer-completion-table' and related
|
|
|
|
|
variables.")
|
2011-05-24 02:45:50 +00:00
|
|
|
|
(make-obsolete-variable 'completion-annotate-function
|
|
|
|
|
'completion-extra-properties "24.1")
|
|
|
|
|
|
|
|
|
|
(defun completion--done (string &optional finished message)
|
|
|
|
|
(let* ((exit-fun (plist-get completion-extra-properties :exit-function))
|
|
|
|
|
(pre-msg (and exit-fun (current-message))))
|
Reduce use of (require 'cl).
* admin/bzrmerge.el: Use cl-lib.
* leim/quail/hangul.el: Don't require CL.
* leim/quail/ipa.el: Use cl-lib.
* vc/smerge-mode.el, vc/pcvs.el, vc/pcvs-util.el, vc/pcvs-info.el:
* vc/diff-mode.el, vc/cvs-status.el, uniquify.el, scroll-bar.el:
* register.el, progmodes/sh-script.el, net/gnutls.el, net/dbus.el:
* msb.el, mpc.el, minibuffer.el, international/ucs-normalize.el:
* international/quail.el, info-xref.el, imenu.el, image-mode.el:
* font-lock.el, filesets.el, edmacro.el, doc-view.el, bookmark.el:
* battery.el, avoid.el, abbrev.el: Use cl-lib.
* vc/pcvs-parse.el, vc/pcvs-defs.el, vc/log-view.el, vc/log-edit.el:
* vc/diff.el, simple.el, pcomplete.el, lpr.el, comint.el, loadhist.el:
* jit-lock.el, international/iso-ascii.el, info.el, frame.el, bs.el:
* emulation/crisp.el, electric.el, dired.el, cus-dep.el, composite.el:
* calculator.el, autorevert.el, apropos.el: Don't require CL.
* emacs-bytecomp.el (byte-recompile-directory, display-call-tree)
(byte-compile-unfold-bcf, byte-compile-check-variable):
* emacs-byte-opt.el (byte-compile-trueconstp)
(byte-compile-nilconstp):
* emacs-autoload.el (make-autoload): Use pcase.
* face-remap.el (text-scale-adjust): Simplify pcase patterns.
2012-07-10 11:51:54 +00:00
|
|
|
|
(cl-assert (memq finished '(exact sole finished unknown)))
|
2011-05-24 02:45:50 +00:00
|
|
|
|
(when exit-fun
|
|
|
|
|
(when (eq finished 'unknown)
|
|
|
|
|
(setq finished
|
|
|
|
|
(if (eq (try-completion string
|
|
|
|
|
minibuffer-completion-table
|
|
|
|
|
minibuffer-completion-predicate)
|
|
|
|
|
t)
|
|
|
|
|
'finished 'exact)))
|
|
|
|
|
(funcall exit-fun string finished))
|
|
|
|
|
(when (and message
|
|
|
|
|
;; Don't output any message if the exit-fun already did so.
|
|
|
|
|
(equal pre-msg (and exit-fun (current-message))))
|
|
|
|
|
(completion--message message))))
|
2009-08-30 03:45:30 +00:00
|
|
|
|
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(defun minibuffer-completion-help (&optional start end)
|
2008-04-09 03:34:19 +00:00
|
|
|
|
"Display a list of possible completions of the current minibuffer contents."
|
|
|
|
|
(interactive)
|
|
|
|
|
(message "Making completion list...")
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(let* ((start (or start (minibuffer-prompt-end)))
|
|
|
|
|
(end (or end (point-max)))
|
|
|
|
|
(string (buffer-substring start end))
|
2011-05-31 21:40:30 +00:00
|
|
|
|
(md (completion--field-metadata start))
|
2011-02-21 20:31:07 +00:00
|
|
|
|
(completions (completion-all-completions
|
|
|
|
|
string
|
|
|
|
|
minibuffer-completion-table
|
|
|
|
|
minibuffer-completion-predicate
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(- (point) start)
|
2011-05-31 21:40:30 +00:00
|
|
|
|
md)))
|
2008-04-09 03:34:19 +00:00
|
|
|
|
(message nil)
|
2011-05-24 02:45:50 +00:00
|
|
|
|
(if (or (null completions)
|
|
|
|
|
(and (not (consp (cdr completions)))
|
|
|
|
|
(equal (car completions) string)))
|
|
|
|
|
(progn
|
|
|
|
|
;; If there are no completions, or if the current input is already
|
|
|
|
|
;; the sole completion, then hide (previous&stale) completions.
|
|
|
|
|
(minibuffer-hide-completions)
|
|
|
|
|
(ding)
|
|
|
|
|
(minibuffer-message
|
|
|
|
|
(if completions "Sole completion" "No completions")))
|
|
|
|
|
|
|
|
|
|
(let* ((last (last completions))
|
|
|
|
|
(base-size (cdr last))
|
|
|
|
|
(prefix (unless (zerop base-size) (substring string 0 base-size)))
|
2011-05-31 21:40:30 +00:00
|
|
|
|
(all-md (completion--metadata (buffer-substring-no-properties
|
|
|
|
|
start (point))
|
|
|
|
|
base-size md
|
|
|
|
|
minibuffer-completion-table
|
|
|
|
|
minibuffer-completion-predicate))
|
2011-05-31 03:03:38 +00:00
|
|
|
|
(afun (or (completion-metadata-get all-md 'annotation-function)
|
|
|
|
|
(plist-get completion-extra-properties
|
|
|
|
|
:annotation-function)
|
|
|
|
|
completion-annotate-function))
|
2011-05-24 02:45:50 +00:00
|
|
|
|
;; If the *Completions* buffer is shown in a new
|
|
|
|
|
;; window, mark it as softly-dedicated, so bury-buffer in
|
|
|
|
|
;; minibuffer-hide-completions will know whether to
|
|
|
|
|
;; delete the window or not.
|
|
|
|
|
(display-buffer-mark-dedicated 'soft))
|
|
|
|
|
(with-output-to-temp-buffer "*Completions*"
|
|
|
|
|
;; Remove the base-size tail because `sort' requires a properly
|
|
|
|
|
;; nil-terminated list.
|
|
|
|
|
(when last (setcdr last nil))
|
|
|
|
|
(setq completions
|
2011-05-31 03:03:38 +00:00
|
|
|
|
;; FIXME: This function is for the output of all-completions,
|
|
|
|
|
;; not completion-all-completions. Often it's the same, but
|
|
|
|
|
;; not always.
|
|
|
|
|
(let ((sort-fun (completion-metadata-get
|
|
|
|
|
all-md 'display-sort-function)))
|
|
|
|
|
(if sort-fun
|
|
|
|
|
(funcall sort-fun completions)
|
|
|
|
|
(sort completions 'string-lessp))))
|
|
|
|
|
(when afun
|
|
|
|
|
(setq completions
|
2011-05-24 02:45:50 +00:00
|
|
|
|
(mapcar (lambda (s)
|
2011-05-31 03:03:38 +00:00
|
|
|
|
(let ((ann (funcall afun s)))
|
2011-05-24 02:45:50 +00:00
|
|
|
|
(if ann (list s ann) s)))
|
2011-05-31 03:03:38 +00:00
|
|
|
|
completions)))
|
2011-05-24 02:45:50 +00:00
|
|
|
|
|
|
|
|
|
(with-current-buffer standard-output
|
|
|
|
|
(set (make-local-variable 'completion-base-position)
|
|
|
|
|
(list (+ start base-size)
|
|
|
|
|
;; FIXME: We should pay attention to completion
|
|
|
|
|
;; boundaries here, but currently
|
|
|
|
|
;; completion-all-completions does not give us the
|
|
|
|
|
;; necessary information.
|
|
|
|
|
end))
|
|
|
|
|
(set (make-local-variable 'completion-list-insert-choice-function)
|
|
|
|
|
(let ((ctable minibuffer-completion-table)
|
|
|
|
|
(cpred minibuffer-completion-predicate)
|
|
|
|
|
(cprops completion-extra-properties))
|
|
|
|
|
(lambda (start end choice)
|
2011-05-31 03:03:38 +00:00
|
|
|
|
(unless (or (zerop (length prefix))
|
|
|
|
|
(equal prefix
|
|
|
|
|
(buffer-substring-no-properties
|
|
|
|
|
(max (point-min)
|
|
|
|
|
(- start (length prefix)))
|
|
|
|
|
start)))
|
2011-05-24 02:45:50 +00:00
|
|
|
|
(message "*Completions* out of date"))
|
|
|
|
|
;; FIXME: Use `md' to do quoting&terminator here.
|
|
|
|
|
(completion--replace start end choice)
|
|
|
|
|
(let* ((minibuffer-completion-table ctable)
|
|
|
|
|
(minibuffer-completion-predicate cpred)
|
|
|
|
|
(completion-extra-properties cprops)
|
|
|
|
|
(result (concat prefix choice))
|
|
|
|
|
(bounds (completion-boundaries
|
|
|
|
|
result ctable cpred "")))
|
|
|
|
|
;; If the completion introduces a new field, then
|
|
|
|
|
;; completion is not finished.
|
|
|
|
|
(completion--done result
|
|
|
|
|
(if (eq (car bounds) (length result))
|
|
|
|
|
'exact 'finished)))))))
|
|
|
|
|
|
|
|
|
|
(display-completion-list completions))))
|
2008-04-09 03:34:19 +00:00
|
|
|
|
nil))
|
|
|
|
|
|
2009-08-19 02:15:19 +00:00
|
|
|
|
(defun minibuffer-hide-completions ()
|
|
|
|
|
"Get rid of an out-of-date *Completions* buffer."
|
|
|
|
|
;; FIXME: We could/should use minibuffer-scroll-window here, but it
|
|
|
|
|
;; can also point to the minibuffer-parent-window, so it's a bit tricky.
|
|
|
|
|
(let ((win (get-buffer-window "*Completions*" 0)))
|
|
|
|
|
(if win (with-selected-window win (bury-buffer)))))
|
|
|
|
|
|
2008-04-09 03:34:19 +00:00
|
|
|
|
(defun exit-minibuffer ()
|
|
|
|
|
"Terminate this minibuffer argument."
|
|
|
|
|
(interactive)
|
|
|
|
|
;; If the command that uses this has made modifications in the minibuffer,
|
|
|
|
|
;; we don't want them to cause deactivation of the mark in the original
|
|
|
|
|
;; buffer.
|
|
|
|
|
;; A better solution would be to make deactivate-mark buffer-local
|
|
|
|
|
;; (or to turn it into a list of buffers, ...), but in the mean time,
|
|
|
|
|
;; this should do the trick in most cases.
|
2008-04-09 19:33:56 +00:00
|
|
|
|
(setq deactivate-mark nil)
|
2008-04-09 03:34:19 +00:00
|
|
|
|
(throw 'exit nil))
|
|
|
|
|
|
|
|
|
|
(defun self-insert-and-exit ()
|
|
|
|
|
"Terminate minibuffer input."
|
|
|
|
|
(interactive)
|
2009-01-09 04:44:15 +00:00
|
|
|
|
(if (characterp last-command-event)
|
2008-04-09 03:34:19 +00:00
|
|
|
|
(call-interactively 'self-insert-command)
|
|
|
|
|
(ding))
|
|
|
|
|
(exit-minibuffer))
|
|
|
|
|
|
2009-11-19 03:12:51 +00:00
|
|
|
|
(defvar completion-in-region-functions nil
|
2013-04-18 00:12:33 +00:00
|
|
|
|
"Wrapper hook around `completion-in-region'.")
|
|
|
|
|
(make-obsolete-variable 'completion-in-region-functions
|
|
|
|
|
'completion-in-region-function "24.4")
|
|
|
|
|
|
|
|
|
|
(defvar completion-in-region-function #'completion--in-region
|
|
|
|
|
"Function to perform the job of `completion-in-region'.
|
|
|
|
|
The function is called with 4 arguments: START END COLLECTION PREDICATE.
|
|
|
|
|
The arguments and expected return value are like the ones of
|
|
|
|
|
`completion-in-region'.")
|
2009-11-19 03:12:51 +00:00
|
|
|
|
|
2011-03-30 22:25:57 +00:00
|
|
|
|
(defvar completion-in-region--data nil)
|
|
|
|
|
|
2011-04-14 00:16:11 +00:00
|
|
|
|
(defvar completion-in-region-mode-predicate nil
|
|
|
|
|
"Predicate to tell `completion-in-region-mode' when to exit.
|
|
|
|
|
It is called with no argument and should return nil when
|
|
|
|
|
`completion-in-region-mode' should exit (and hence pop down
|
|
|
|
|
the *Completions* buffer).")
|
|
|
|
|
|
|
|
|
|
(defvar completion-in-region-mode--predicate nil
|
|
|
|
|
"Copy of the value of `completion-in-region-mode-predicate'.
|
|
|
|
|
This holds the value `completion-in-region-mode-predicate' had when
|
|
|
|
|
we entered `completion-in-region-mode'.")
|
|
|
|
|
|
2009-11-19 03:12:51 +00:00
|
|
|
|
(defun completion-in-region (start end collection &optional predicate)
|
|
|
|
|
"Complete the text between START and END using COLLECTION.
|
2009-12-06 00:58:40 +00:00
|
|
|
|
Return nil if there is no valid completion, else t.
|
2011-07-02 16:07:30 +00:00
|
|
|
|
Point needs to be somewhere between START and END.
|
|
|
|
|
PREDICATE (a function called with no arguments) says when to
|
|
|
|
|
exit."
|
Reduce use of (require 'cl).
* admin/bzrmerge.el: Use cl-lib.
* leim/quail/hangul.el: Don't require CL.
* leim/quail/ipa.el: Use cl-lib.
* vc/smerge-mode.el, vc/pcvs.el, vc/pcvs-util.el, vc/pcvs-info.el:
* vc/diff-mode.el, vc/cvs-status.el, uniquify.el, scroll-bar.el:
* register.el, progmodes/sh-script.el, net/gnutls.el, net/dbus.el:
* msb.el, mpc.el, minibuffer.el, international/ucs-normalize.el:
* international/quail.el, info-xref.el, imenu.el, image-mode.el:
* font-lock.el, filesets.el, edmacro.el, doc-view.el, bookmark.el:
* battery.el, avoid.el, abbrev.el: Use cl-lib.
* vc/pcvs-parse.el, vc/pcvs-defs.el, vc/log-view.el, vc/log-edit.el:
* vc/diff.el, simple.el, pcomplete.el, lpr.el, comint.el, loadhist.el:
* jit-lock.el, international/iso-ascii.el, info.el, frame.el, bs.el:
* emulation/crisp.el, electric.el, dired.el, cus-dep.el, composite.el:
* calculator.el, autorevert.el, apropos.el: Don't require CL.
* emacs-bytecomp.el (byte-recompile-directory, display-call-tree)
(byte-compile-unfold-bcf, byte-compile-check-variable):
* emacs-byte-opt.el (byte-compile-trueconstp)
(byte-compile-nilconstp):
* emacs-autoload.el (make-autoload): Use pcase.
* face-remap.el (text-scale-adjust): Simplify pcase patterns.
2012-07-10 11:51:54 +00:00
|
|
|
|
(cl-assert (<= start (point)) (<= (point) end))
|
2013-04-18 00:12:33 +00:00
|
|
|
|
(funcall completion-in-region-function start end collection predicate))
|
|
|
|
|
|
2013-05-30 03:18:06 +00:00
|
|
|
|
(defcustom read-file-name-completion-ignore-case
|
|
|
|
|
(if (memq system-type '(ms-dos windows-nt darwin cygwin))
|
|
|
|
|
t nil)
|
|
|
|
|
"Non-nil means when reading a file name completion ignores case."
|
|
|
|
|
:type 'boolean
|
|
|
|
|
:version "22.1")
|
|
|
|
|
|
2013-04-18 00:12:33 +00:00
|
|
|
|
(defun completion--in-region (start end collection &optional predicate)
|
2009-11-19 03:12:51 +00:00
|
|
|
|
(with-wrapper-hook
|
2011-03-24 22:05:01 +00:00
|
|
|
|
;; FIXME: Maybe we should use this hook to provide a "display
|
|
|
|
|
;; completions" operation as well.
|
2009-11-19 03:12:51 +00:00
|
|
|
|
completion-in-region-functions (start end collection predicate)
|
|
|
|
|
(let ((minibuffer-completion-table collection)
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(minibuffer-completion-predicate predicate))
|
2012-03-10 07:08:51 +00:00
|
|
|
|
;; HACK: if the text we are completing is already in a field, we
|
|
|
|
|
;; want the completion field to take priority (e.g. Bug#6830).
|
2011-04-14 00:16:11 +00:00
|
|
|
|
(when completion-in-region-mode-predicate
|
|
|
|
|
(completion-in-region-mode 1)
|
|
|
|
|
(setq completion-in-region--data
|
2012-10-24 03:18:32 +00:00
|
|
|
|
(list (if (markerp start) start (copy-marker start))
|
|
|
|
|
(copy-marker end) collection)))
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(completion--in-region-1 start end))))
|
2008-06-05 05:44:12 +00:00
|
|
|
|
|
2011-03-30 22:25:57 +00:00
|
|
|
|
(defvar completion-in-region-mode-map
|
|
|
|
|
(let ((map (make-sparse-keymap)))
|
2011-04-20 22:31:06 +00:00
|
|
|
|
;; FIXME: Only works if completion-in-region-mode was activated via
|
|
|
|
|
;; completion-at-point called directly.
|
2012-04-07 08:12:04 +00:00
|
|
|
|
(define-key map "\M-?" 'completion-help-at-point)
|
2011-03-30 22:25:57 +00:00
|
|
|
|
(define-key map "\t" 'completion-at-point)
|
|
|
|
|
map)
|
|
|
|
|
"Keymap activated during `completion-in-region'.")
|
|
|
|
|
|
|
|
|
|
;; It is difficult to know when to exit completion-in-region-mode (i.e. hide
|
|
|
|
|
;; the *Completions*).
|
|
|
|
|
;; - lisp-mode: never.
|
|
|
|
|
;; - comint: only do it if you hit SPC at the right time.
|
|
|
|
|
;; - pcomplete: pop it down on SPC or after some time-delay.
|
|
|
|
|
;; - semantic: use a post-command-hook check similar to this one.
|
|
|
|
|
(defun completion-in-region--postch ()
|
|
|
|
|
(or unread-command-events ;Don't pop down the completions in the middle of
|
|
|
|
|
;mouse-drag-region/mouse-set-point.
|
|
|
|
|
(and completion-in-region--data
|
2012-10-24 03:18:32 +00:00
|
|
|
|
(and (eq (marker-buffer (nth 0 completion-in-region--data))
|
2011-03-30 22:25:57 +00:00
|
|
|
|
(current-buffer))
|
2012-10-24 03:18:32 +00:00
|
|
|
|
(>= (point) (nth 0 completion-in-region--data))
|
2011-03-30 22:25:57 +00:00
|
|
|
|
(<= (point)
|
|
|
|
|
(save-excursion
|
2012-10-24 03:18:32 +00:00
|
|
|
|
(goto-char (nth 1 completion-in-region--data))
|
2011-03-30 22:25:57 +00:00
|
|
|
|
(line-end-position)))
|
2011-04-20 19:05:50 +00:00
|
|
|
|
(funcall completion-in-region-mode--predicate)))
|
2011-03-30 22:25:57 +00:00
|
|
|
|
(completion-in-region-mode -1)))
|
|
|
|
|
|
|
|
|
|
;; (defalias 'completion-in-region--prech 'completion-in-region--postch)
|
|
|
|
|
|
|
|
|
|
(define-minor-mode completion-in-region-mode
|
2012-02-08 02:12:24 +00:00
|
|
|
|
"Transient minor mode used during `completion-in-region'.
|
|
|
|
|
With a prefix argument ARG, enable the modemode if ARG is
|
|
|
|
|
positive, and disable it otherwise. If called from Lisp, enable
|
|
|
|
|
the mode if ARG is omitted or nil."
|
2011-03-30 22:25:57 +00:00
|
|
|
|
:global t
|
2013-05-15 23:55:41 +00:00
|
|
|
|
:group 'minibuffer
|
2011-03-30 22:25:57 +00:00
|
|
|
|
(setq completion-in-region--data nil)
|
|
|
|
|
;; (remove-hook 'pre-command-hook #'completion-in-region--prech)
|
|
|
|
|
(remove-hook 'post-command-hook #'completion-in-region--postch)
|
|
|
|
|
(setq minor-mode-overriding-map-alist
|
|
|
|
|
(delq (assq 'completion-in-region-mode minor-mode-overriding-map-alist)
|
|
|
|
|
minor-mode-overriding-map-alist))
|
|
|
|
|
(if (null completion-in-region-mode)
|
2011-04-20 19:05:50 +00:00
|
|
|
|
(unless (equal "*Completions*" (buffer-name (window-buffer)))
|
2011-04-05 21:19:42 +00:00
|
|
|
|
(minibuffer-hide-completions))
|
2011-03-30 22:25:57 +00:00
|
|
|
|
;; (add-hook 'pre-command-hook #'completion-in-region--prech)
|
Reduce use of (require 'cl).
* admin/bzrmerge.el: Use cl-lib.
* leim/quail/hangul.el: Don't require CL.
* leim/quail/ipa.el: Use cl-lib.
* vc/smerge-mode.el, vc/pcvs.el, vc/pcvs-util.el, vc/pcvs-info.el:
* vc/diff-mode.el, vc/cvs-status.el, uniquify.el, scroll-bar.el:
* register.el, progmodes/sh-script.el, net/gnutls.el, net/dbus.el:
* msb.el, mpc.el, minibuffer.el, international/ucs-normalize.el:
* international/quail.el, info-xref.el, imenu.el, image-mode.el:
* font-lock.el, filesets.el, edmacro.el, doc-view.el, bookmark.el:
* battery.el, avoid.el, abbrev.el: Use cl-lib.
* vc/pcvs-parse.el, vc/pcvs-defs.el, vc/log-view.el, vc/log-edit.el:
* vc/diff.el, simple.el, pcomplete.el, lpr.el, comint.el, loadhist.el:
* jit-lock.el, international/iso-ascii.el, info.el, frame.el, bs.el:
* emulation/crisp.el, electric.el, dired.el, cus-dep.el, composite.el:
* calculator.el, autorevert.el, apropos.el: Don't require CL.
* emacs-bytecomp.el (byte-recompile-directory, display-call-tree)
(byte-compile-unfold-bcf, byte-compile-check-variable):
* emacs-byte-opt.el (byte-compile-trueconstp)
(byte-compile-nilconstp):
* emacs-autoload.el (make-autoload): Use pcase.
* face-remap.el (text-scale-adjust): Simplify pcase patterns.
2012-07-10 11:51:54 +00:00
|
|
|
|
(cl-assert completion-in-region-mode-predicate)
|
2011-04-20 19:05:50 +00:00
|
|
|
|
(setq completion-in-region-mode--predicate
|
|
|
|
|
completion-in-region-mode-predicate)
|
2011-03-30 22:25:57 +00:00
|
|
|
|
(add-hook 'post-command-hook #'completion-in-region--postch)
|
|
|
|
|
(push `(completion-in-region-mode . ,completion-in-region-mode-map)
|
|
|
|
|
minor-mode-overriding-map-alist)))
|
|
|
|
|
|
|
|
|
|
;; Define-minor-mode added our keymap to minor-mode-map-alist, but we want it
|
|
|
|
|
;; on minor-mode-overriding-map-alist instead.
|
|
|
|
|
(setq minor-mode-map-alist
|
|
|
|
|
(delq (assq 'completion-in-region-mode minor-mode-map-alist)
|
|
|
|
|
minor-mode-map-alist))
|
|
|
|
|
|
2010-04-29 15:32:11 +00:00
|
|
|
|
(defvar completion-at-point-functions '(tags-completion-at-point-function)
|
2009-12-07 20:06:26 +00:00
|
|
|
|
"Special hook to find the completion table for the thing at point.
|
2011-03-24 22:05:01 +00:00
|
|
|
|
Each function on this hook is called in turns without any argument and should
|
|
|
|
|
return either nil to mean that it is not applicable at point,
|
2009-12-07 20:06:26 +00:00
|
|
|
|
or a function of no argument to perform completion (discouraged),
|
2012-02-15 13:45:02 +00:00
|
|
|
|
or a list of the form (START END COLLECTION . PROPS) where
|
2009-12-07 20:06:26 +00:00
|
|
|
|
START and END delimit the entity to complete and should include point,
|
|
|
|
|
COLLECTION is the completion table to use to complete it, and
|
|
|
|
|
PROPS is a property list for additional information.
|
2011-05-24 02:45:50 +00:00
|
|
|
|
Currently supported properties are all the properties that can appear in
|
|
|
|
|
`completion-extra-properties' plus:
|
2011-05-28 02:10:32 +00:00
|
|
|
|
`:predicate' a predicate that completion candidates need to satisfy.
|
2012-02-15 13:45:02 +00:00
|
|
|
|
`:exclusive' If `no', means that if the completion table fails to
|
|
|
|
|
match the text at point, then instead of reporting a completion
|
2012-09-01 04:28:24 +00:00
|
|
|
|
failure, the completion should try the next completion function.
|
|
|
|
|
As is the case with most hooks, the functions are responsible to preserve
|
|
|
|
|
things like point and current buffer.")
|
2009-12-07 20:06:26 +00:00
|
|
|
|
|
2011-03-30 22:25:57 +00:00
|
|
|
|
(defvar completion--capf-misbehave-funs nil
|
2011-05-28 02:10:32 +00:00
|
|
|
|
"List of functions found on `completion-at-point-functions' that misbehave.
|
|
|
|
|
These are functions that neither return completion data nor a completion
|
|
|
|
|
function but instead perform completion right away.")
|
2011-03-30 22:25:57 +00:00
|
|
|
|
(defvar completion--capf-safe-funs nil
|
2011-05-28 02:10:32 +00:00
|
|
|
|
"List of well-behaved functions found on `completion-at-point-functions'.
|
|
|
|
|
These are functions which return proper completion data rather than
|
|
|
|
|
a completion function or god knows what else.")
|
2011-03-30 22:25:57 +00:00
|
|
|
|
|
|
|
|
|
(defun completion--capf-wrapper (fun which)
|
2011-04-28 15:32:28 +00:00
|
|
|
|
;; FIXME: The safe/misbehave handling assumes that a given function will
|
|
|
|
|
;; always return the same kind of data, but this breaks down with functions
|
|
|
|
|
;; like comint-completion-at-point or mh-letter-completion-at-point, which
|
|
|
|
|
;; could be sometimes safe and sometimes misbehaving (and sometimes neither).
|
Reduce use of (require 'cl).
* admin/bzrmerge.el: Use cl-lib.
* leim/quail/hangul.el: Don't require CL.
* leim/quail/ipa.el: Use cl-lib.
* vc/smerge-mode.el, vc/pcvs.el, vc/pcvs-util.el, vc/pcvs-info.el:
* vc/diff-mode.el, vc/cvs-status.el, uniquify.el, scroll-bar.el:
* register.el, progmodes/sh-script.el, net/gnutls.el, net/dbus.el:
* msb.el, mpc.el, minibuffer.el, international/ucs-normalize.el:
* international/quail.el, info-xref.el, imenu.el, image-mode.el:
* font-lock.el, filesets.el, edmacro.el, doc-view.el, bookmark.el:
* battery.el, avoid.el, abbrev.el: Use cl-lib.
* vc/pcvs-parse.el, vc/pcvs-defs.el, vc/log-view.el, vc/log-edit.el:
* vc/diff.el, simple.el, pcomplete.el, lpr.el, comint.el, loadhist.el:
* jit-lock.el, international/iso-ascii.el, info.el, frame.el, bs.el:
* emulation/crisp.el, electric.el, dired.el, cus-dep.el, composite.el:
* calculator.el, autorevert.el, apropos.el: Don't require CL.
* emacs-bytecomp.el (byte-recompile-directory, display-call-tree)
(byte-compile-unfold-bcf, byte-compile-check-variable):
* emacs-byte-opt.el (byte-compile-trueconstp)
(byte-compile-nilconstp):
* emacs-autoload.el (make-autoload): Use pcase.
* face-remap.el (text-scale-adjust): Simplify pcase patterns.
2012-07-10 11:51:54 +00:00
|
|
|
|
(if (pcase which
|
|
|
|
|
(`all t)
|
|
|
|
|
(`safe (member fun completion--capf-safe-funs))
|
|
|
|
|
(`optimist (not (member fun completion--capf-misbehave-funs))))
|
2011-03-30 22:25:57 +00:00
|
|
|
|
(let ((res (funcall fun)))
|
|
|
|
|
(cond
|
2011-05-28 02:10:32 +00:00
|
|
|
|
((and (consp res) (not (functionp res)))
|
2011-03-30 22:25:57 +00:00
|
|
|
|
(unless (member fun completion--capf-safe-funs)
|
2011-05-28 02:10:32 +00:00
|
|
|
|
(push fun completion--capf-safe-funs))
|
|
|
|
|
(and (eq 'no (plist-get (nthcdr 3 res) :exclusive))
|
|
|
|
|
;; FIXME: Here we'd need to decide whether there are
|
|
|
|
|
;; valid completions against the current text. But this depends
|
|
|
|
|
;; on the actual completion UI (e.g. with the default completion
|
|
|
|
|
;; it depends on completion-style) ;-(
|
|
|
|
|
;; We approximate this result by checking whether prefix
|
|
|
|
|
;; completion might work, which means that non-prefix completion
|
|
|
|
|
;; will not work (or not right) for completion functions that
|
|
|
|
|
;; are non-exclusive.
|
|
|
|
|
(null (try-completion (buffer-substring-no-properties
|
|
|
|
|
(car res) (point))
|
|
|
|
|
(nth 2 res)
|
|
|
|
|
(plist-get (nthcdr 3 res) :predicate)))
|
|
|
|
|
(setq res nil)))
|
2011-03-30 22:25:57 +00:00
|
|
|
|
((not (or (listp res) (functionp res)))
|
|
|
|
|
(unless (member fun completion--capf-misbehave-funs)
|
|
|
|
|
(message
|
|
|
|
|
"Completion function %S uses a deprecated calling convention" fun)
|
|
|
|
|
(push fun completion--capf-misbehave-funs))))
|
2011-04-14 00:16:11 +00:00
|
|
|
|
(if res (cons fun res)))))
|
2011-03-30 22:25:57 +00:00
|
|
|
|
|
2010-12-06 21:06:02 +00:00
|
|
|
|
(defun completion-at-point ()
|
2010-04-28 19:04:16 +00:00
|
|
|
|
"Perform completion on the text around point.
|
2010-12-06 21:06:02 +00:00
|
|
|
|
The completion method is determined by `completion-at-point-functions'."
|
|
|
|
|
(interactive)
|
2011-03-30 22:25:57 +00:00
|
|
|
|
(let ((res (run-hook-wrapped 'completion-at-point-functions
|
|
|
|
|
#'completion--capf-wrapper 'all)))
|
2011-04-14 00:16:11 +00:00
|
|
|
|
(pcase res
|
2012-10-24 03:18:32 +00:00
|
|
|
|
(`(,_ . ,(and (pred functionp) f)) (funcall f))
|
|
|
|
|
(`(,hookfun . (,start ,end ,collection . ,plist))
|
|
|
|
|
(unless (markerp start) (setq start (copy-marker start)))
|
|
|
|
|
(let* ((completion-extra-properties plist)
|
|
|
|
|
(completion-in-region-mode-predicate
|
|
|
|
|
(lambda ()
|
|
|
|
|
;; We're still in the same completion field.
|
|
|
|
|
(let ((newstart (car-safe (funcall hookfun))))
|
|
|
|
|
(and newstart (= newstart start))))))
|
|
|
|
|
(completion-in-region start end collection
|
|
|
|
|
(plist-get plist :predicate))))
|
|
|
|
|
;; Maybe completion already happened and the function returned t.
|
|
|
|
|
(_ (cdr res)))))
|
2009-12-07 20:06:26 +00:00
|
|
|
|
|
2011-03-30 22:25:57 +00:00
|
|
|
|
(defun completion-help-at-point ()
|
|
|
|
|
"Display the completions on the text around point.
|
|
|
|
|
The completion method is determined by `completion-at-point-functions'."
|
|
|
|
|
(interactive)
|
|
|
|
|
(let ((res (run-hook-wrapped 'completion-at-point-functions
|
|
|
|
|
;; Ignore misbehaving functions.
|
|
|
|
|
#'completion--capf-wrapper 'optimist)))
|
2011-04-14 00:16:11 +00:00
|
|
|
|
(pcase res
|
|
|
|
|
(`(,_ . ,(and (pred functionp) f))
|
|
|
|
|
(message "Don't know how to show completions for %S" f))
|
2012-10-24 03:18:32 +00:00
|
|
|
|
(`(,hookfun . (,start ,end ,collection . ,plist))
|
|
|
|
|
(unless (markerp start) (setq start (copy-marker start)))
|
|
|
|
|
(let* ((minibuffer-completion-table collection)
|
|
|
|
|
(minibuffer-completion-predicate (plist-get plist :predicate))
|
|
|
|
|
(completion-extra-properties plist)
|
|
|
|
|
(completion-in-region-mode-predicate
|
|
|
|
|
(lambda ()
|
|
|
|
|
;; We're still in the same completion field.
|
|
|
|
|
(let ((newstart (car-safe (funcall hookfun))))
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(and newstart (= newstart start))))))
|
2012-10-24 03:18:32 +00:00
|
|
|
|
;; FIXME: We should somehow (ab)use completion-in-region-function or
|
|
|
|
|
;; introduce a corresponding hook (plus another for word-completion,
|
|
|
|
|
;; and another for force-completion, maybe?).
|
|
|
|
|
(completion-in-region-mode 1)
|
|
|
|
|
(setq completion-in-region--data
|
|
|
|
|
(list start (copy-marker end) collection))
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(minibuffer-completion-help start end)))
|
2012-10-24 03:18:32 +00:00
|
|
|
|
(`(,hookfun . ,_)
|
|
|
|
|
;; The hook function already performed completion :-(
|
|
|
|
|
;; Not much we can do at this point.
|
|
|
|
|
(message "%s already performed completion!" hookfun)
|
|
|
|
|
nil)
|
|
|
|
|
(_ (message "Nothing to complete at point")))))
|
2011-03-30 22:25:57 +00:00
|
|
|
|
|
2009-12-12 05:23:54 +00:00
|
|
|
|
;;; Key bindings.
|
|
|
|
|
|
2008-05-20 17:03:30 +00:00
|
|
|
|
(let ((map minibuffer-local-map))
|
|
|
|
|
(define-key map "\C-g" 'abort-recursive-edit)
|
|
|
|
|
(define-key map "\r" 'exit-minibuffer)
|
|
|
|
|
(define-key map "\n" 'exit-minibuffer))
|
|
|
|
|
|
2011-07-02 04:27:41 +00:00
|
|
|
|
(defvar minibuffer-local-completion-map
|
|
|
|
|
(let ((map (make-sparse-keymap)))
|
|
|
|
|
(set-keymap-parent map minibuffer-local-map)
|
|
|
|
|
(define-key map "\t" 'minibuffer-complete)
|
|
|
|
|
;; M-TAB is already abused for many other purposes, so we should find
|
|
|
|
|
;; another binding for it.
|
|
|
|
|
;; (define-key map "\e\t" 'minibuffer-force-complete)
|
|
|
|
|
(define-key map " " 'minibuffer-complete-word)
|
|
|
|
|
(define-key map "?" 'minibuffer-completion-help)
|
|
|
|
|
map)
|
|
|
|
|
"Local keymap for minibuffer input with completion.")
|
|
|
|
|
|
|
|
|
|
(defvar minibuffer-local-must-match-map
|
|
|
|
|
(let ((map (make-sparse-keymap)))
|
|
|
|
|
(set-keymap-parent map minibuffer-local-completion-map)
|
|
|
|
|
(define-key map "\r" 'minibuffer-complete-and-exit)
|
|
|
|
|
(define-key map "\n" 'minibuffer-complete-and-exit)
|
|
|
|
|
map)
|
|
|
|
|
"Local keymap for minibuffer input with completion, for exact match.")
|
2008-05-20 17:03:30 +00:00
|
|
|
|
|
2011-07-02 04:27:41 +00:00
|
|
|
|
(defvar minibuffer-local-filename-completion-map
|
|
|
|
|
(let ((map (make-sparse-keymap)))
|
|
|
|
|
(define-key map " " nil)
|
|
|
|
|
map)
|
|
|
|
|
"Local keymap for minibuffer input with completion for filenames.
|
|
|
|
|
Gets combined either with `minibuffer-local-completion-map' or
|
|
|
|
|
with `minibuffer-local-must-match-map'.")
|
2008-05-20 17:03:30 +00:00
|
|
|
|
|
2011-07-02 04:27:41 +00:00
|
|
|
|
(define-obsolete-variable-alias 'minibuffer-local-must-match-filename-map
|
|
|
|
|
'minibuffer-local-filename-must-match-map "23.1")
|
2012-05-16 01:57:20 +00:00
|
|
|
|
(defvar minibuffer-local-filename-must-match-map (make-sparse-keymap))
|
|
|
|
|
(make-obsolete-variable 'minibuffer-local-filename-must-match-map nil "24.1")
|
2008-05-20 17:03:30 +00:00
|
|
|
|
|
|
|
|
|
(let ((map minibuffer-local-ns-map))
|
|
|
|
|
(define-key map " " 'exit-minibuffer)
|
|
|
|
|
(define-key map "\t" 'exit-minibuffer)
|
|
|
|
|
(define-key map "?" 'self-insert-and-exit))
|
|
|
|
|
|
2011-06-01 15:34:41 +00:00
|
|
|
|
(defvar minibuffer-inactive-mode-map
|
|
|
|
|
(let ((map (make-keymap)))
|
|
|
|
|
(suppress-keymap map)
|
|
|
|
|
(define-key map "e" 'find-file-other-frame)
|
|
|
|
|
(define-key map "f" 'find-file-other-frame)
|
|
|
|
|
(define-key map "b" 'switch-to-buffer-other-frame)
|
|
|
|
|
(define-key map "i" 'info)
|
|
|
|
|
(define-key map "m" 'mail)
|
|
|
|
|
(define-key map "n" 'make-frame)
|
2013-02-09 05:52:20 +00:00
|
|
|
|
(define-key map [mouse-1] 'view-echo-area-messages)
|
2011-06-01 15:34:41 +00:00
|
|
|
|
;; So the global down-mouse-1 binding doesn't clutter the execution of the
|
|
|
|
|
;; above mouse-1 binding.
|
|
|
|
|
(define-key map [down-mouse-1] #'ignore)
|
|
|
|
|
map)
|
|
|
|
|
"Keymap for use in the minibuffer when it is not active.
|
|
|
|
|
The non-mouse bindings in this keymap can only be used in minibuffer-only
|
|
|
|
|
frames, since the minibuffer can normally not be selected when it is
|
|
|
|
|
not active.")
|
|
|
|
|
|
|
|
|
|
(define-derived-mode minibuffer-inactive-mode nil "InactiveMinibuffer"
|
|
|
|
|
:abbrev-table nil ;abbrev.el is not loaded yet during dump.
|
|
|
|
|
;; Note: this major mode is called from minibuf.c.
|
|
|
|
|
"Major mode to use in the minibuffer when it is not active.
|
|
|
|
|
This is only used when the minibuffer area has no active minibuffer.")
|
|
|
|
|
|
2008-05-20 17:03:30 +00:00
|
|
|
|
;;; Completion tables.
|
|
|
|
|
|
2008-04-10 03:12:49 +00:00
|
|
|
|
(defun minibuffer--double-dollars (str)
|
2012-04-25 18:42:15 +00:00
|
|
|
|
;; Reuse the actual "$" from the string to preserve any text-property it
|
|
|
|
|
;; might have, such as `face'.
|
|
|
|
|
(replace-regexp-in-string "\\$" (lambda (dollar) (concat dollar dollar))
|
|
|
|
|
str))
|
2008-04-10 03:12:49 +00:00
|
|
|
|
|
2008-04-11 22:28:02 +00:00
|
|
|
|
(defun completion--make-envvar-table ()
|
|
|
|
|
(mapcar (lambda (enventry)
|
2009-01-14 02:29:52 +00:00
|
|
|
|
(substring enventry 0 (string-match-p "=" enventry)))
|
2008-04-11 22:28:02 +00:00
|
|
|
|
process-environment))
|
|
|
|
|
|
2008-05-20 17:03:30 +00:00
|
|
|
|
(defconst completion--embedded-envvar-re
|
2012-11-08 15:10:08 +00:00
|
|
|
|
;; We can't reuse env--substitute-vars-regexp because we need to match only
|
|
|
|
|
;; potentially-unfinished envvars at end of string.
|
2008-05-20 17:03:30 +00:00
|
|
|
|
(concat "\\(?:^\\|[^$]\\(?:\\$\\$\\)*\\)"
|
|
|
|
|
"$\\([[:alnum:]_]*\\|{\\([^}]*\\)\\)\\'"))
|
|
|
|
|
|
2011-03-01 05:03:24 +00:00
|
|
|
|
(defun completion--embedded-envvar-table (string _pred action)
|
2009-10-24 00:46:17 +00:00
|
|
|
|
"Completion table for envvars embedded in a string.
|
|
|
|
|
The envvar syntax (and escaping) rules followed by this table are the
|
|
|
|
|
same as `substitute-in-file-name'."
|
|
|
|
|
;; We ignore `pred', because the predicates passed to us via
|
|
|
|
|
;; read-file-name-internal are not 100% correct and fail here:
|
|
|
|
|
;; e.g. we get predicates like file-directory-p there, whereas the filename
|
|
|
|
|
;; completed needs to be passed through substitute-in-file-name before it
|
|
|
|
|
;; can be passed to file-directory-p.
|
2009-10-21 20:03:57 +00:00
|
|
|
|
(when (string-match completion--embedded-envvar-re string)
|
|
|
|
|
(let* ((beg (or (match-beginning 2) (match-beginning 1)))
|
|
|
|
|
(table (completion--make-envvar-table))
|
|
|
|
|
(prefix (substring string 0 beg)))
|
2009-10-24 00:46:17 +00:00
|
|
|
|
(cond
|
|
|
|
|
((eq action 'lambda)
|
|
|
|
|
;; This table is expected to be used in conjunction with some
|
|
|
|
|
;; other table that provides the "main" completion. Let the
|
|
|
|
|
;; other table handle the test-completion case.
|
|
|
|
|
nil)
|
2011-05-31 21:40:30 +00:00
|
|
|
|
((or (eq (car-safe action) 'boundaries) (eq action 'metadata))
|
|
|
|
|
;; Only return boundaries/metadata if there's something to complete,
|
Merge from lexical-binding branch.
* doc/lispref/eval.texi (Eval): Discourage the use of `eval'.
Document its new `lexical' argument.
* doc/lispref/variables.texi (Defining Variables): Mention the new meaning of `defvar'.
(Lexical Binding): New sub-section.
* lisp/Makefile.in (BIG_STACK_DEPTH, BIG_STACK_OPTS, BYTE_COMPILE_FLAGS):
New variables.
(compile-onefile, .el.elc, compile-calc, recompile): Use them.
(COMPILE_FIRST): Add macroexp and cconv.
* lisp/makefile.w32-in: Mirror changes in Makefile.in.
* lisp/vc/cvs-status.el:
* lisp/vc/diff-mode.el:
* lisp/vc/log-edit.el:
* lisp/vc/log-view.el:
* lisp/vc/smerge-mode.el:
* lisp/textmodes/bibtex-style.el:
* textmodes/css.el:
* lisp/startup.el:
* lisp/uniquify.el:
* lisp/minibuffer.el:
* lisp/newcomment.el:
* lisp/reveal.el:
* lisp/server.el:
* lisp/mpc.el:
* lisp/emacs-lisp/smie.el:
* lisp/doc-view.el:
* lisp/dired.el:
* lisp/abbrev.el: Use lexical binding.
* lisp/custom.el (custom-initialize-default, custom-declare-variable):
Use `defvar'.
* lisp/files.el (lexical-binding): Declare safe.
* lisp/help-fns.el (help-split-fundoc): Return nil if there's nothing else
than the arglist.
(help-add-fundoc-usage): Don't add `Not documented'.
(help-function-arglist): Handle closures, subroutines, and new
byte-code-functions.
(help-make-usage): Remove leading underscores.
(describe-function-1): Handle closures.
(describe-variable): Use special-variable-p for completion.
* lisp/simple.el (with-wrapper-hook, apply-partially): Move to subr.el.
* lisp/subr.el (apply-partially): Use new closures rather than CL.
(--dolist-tail--, --dotimes-limit--): Don't declare dynamic.
(dolist, dotimes): Use slightly different expansion for lexical code.
(functionp): Move to C.
(letrec): New macro.
(with-wrapper-hook): Use it and apply-partially instead of CL.
(eval-after-load): Preserve lexical-binding.
(save-window-excursion, with-output-to-temp-buffer): Turn them
into macros.
* lisp/emacs-lisp/advice.el (ad-arglist): Use help-function-arglist.
* lisp/emacs-lisp/autoload.el (make-autoload): Don't burp on trivial macros.
* lisp/emacs-lisp/byte-opt.el: Use lexical binding.
(byte-inline-lapcode): Remove (to bytecomp).
(byte-compile-inline-expand): Pay attention to inlining to/from
lexically bound code.
(byte-compile-unfold-lambda): Don't handle byte-code-functions
any more.
(byte-optimize-form-code-walker): Don't handle save-window-excursion
any more and don't call compiler-macros.
(byte-compile-splice-in-already-compiled-code): Remove.
(byte-code): Don't inline any more.
(disassemble-offset): Receive `bytes' as argument rather than via
dynamic scoping.
(byte-compile-tag-number): Declare before first use.
(byte-decompile-bytecode-1): Handle new byte-codes, don't change
`return' even if make-spliceable.
(byte-compile-side-effect-and-error-free-ops): Add stack-ref, remove
obsolete interactive-p.
(byte-optimize-lapcode): Optimize new lap-codes.
Don't trip up on new form of `byte-constant' lap code.
* lisp/emacs-lisp/byte-run.el (make-obsolete): Don't set the `byte-compile'
handler any more.
* lisp/emacs-lisp/bytecomp.el: Use lexical binding instead of
a "bytecomp-" prefix. Macroexpand everything as a separate phase.
(byte-compile-initial-macro-environment):
Handle declare-function here.
(byte-compile--lexical-environment): New var.
(byte-stack-ref, byte-stack-set, byte-discardN)
(byte-discardN-preserve-tos): New lap codes.
(byte-interactive-p): Don't use any more.
(byte-compile-push-bytecodes, byte-compile-push-bytecode-const2):
New macros.
(byte-compile-lapcode): Use them and handle new lap codes.
(byte-compile-obsolete): Remove.
(byte-compile-arglist-signature): Handle new byte-code arg"lists".
(byte-compile-arglist-warn): Check late def of inlinable funs.
(byte-compile-cl-warn): Don't silence warnings for compiler-macros
since they should have been expanded by now.
(byte-compile--outbuffer): Rename from bytecomp-outbuffer.
(byte-compile-from-buffer): Remove unused second arg.
(byte-compile-preprocess): New function.
(byte-compile-toplevel-file-form): New function to distinguish
file-form calls from outside from file-form calls from hunk-handlers.
(byte-compile-file-form): Simplify.
(byte-compile-file-form-defsubst): Remove.
(byte-compile-file-form-defmumble): Simplify now that
byte-compile-lambda always returns a byte-code-function.
(byte-compile): Preprocess.
(byte-compile-byte-code-maker, byte-compile-byte-code-unmake):
Remove, not used any more.
(byte-compile-arglist-vars, byte-compile-make-lambda-lexenv)
(byte-compile-make-args-desc): New funs.
(byte-compile-lambda): Handle lexical functions. Always return
a byte-code-function.
(byte-compile-reserved-constants): New var, to make up room for
closed-over variables.
(byte-compile-constants-vector): Obey it.
(byte-compile-top-level): New args `lexenv' and `reserved-csts'.
(byte-compile-macroexpand-declare-function): New function.
(byte-compile-form): Call byte-compile-unfold-bcf to inline immediate
byte-code-functions.
(byte-compile-form): Check obsolescence here.
(byte-compile-inline-lapcode, byte-compile-unfold-bcf): New functions.
(byte-compile-variable-ref): Remove.
(byte-compile-dynamic-variable-op): New fun.
(byte-compile-dynamic-variable-bind, byte-compile-variable-ref)
(byte-compile-variable-set): New funs.
(byte-compile-discard): Add 2 args.
(byte-compile-stack-ref, byte-compile-stack-set)
(byte-compile-make-closure, byte-compile-get-closed-var): New funs.
(byte-compile-funarg, byte-compile-funarg-2): Remove, handled in
macroexpand-all instead.
(byte-compile-quote-form): Remove.
(byte-compile-push-binding-init, byte-compile-not-lexical-var-p)
(byte-compile-bind, byte-compile-unbind): New funs.
(byte-compile-let): Handle let* and lexical binding.
(byte-compile-let*): Remove.
(byte-compile-catch, byte-compile-unwind-protect)
(byte-compile-track-mouse, byte-compile-condition-case):
Handle a new :fun-body form, used for lexical scoping.
(byte-compile-save-window-excursion)
(byte-compile-with-output-to-temp-buffer): Remove.
(byte-compile-defun): Simplify.
(byte-compile-stack-adjustment): New fun.
(byte-compile-out): Use it.
(byte-compile-refresh-preloaded): Don't reload byte-compiler files.
* lisp/emacs-lisp/cconv.el: New file.
* lisp/emacs-lisp/cl-extra.el (cl-macroexpand-all): Properly quote CL
closures.
* lisp/emacs-lisp/cl-macs.el (cl-byte-compile-block)
(cl-byte-compile-throw): Remove.
(cl-block-wrapper, cl-block-throw): Use compiler-macros instead.
* lisp/emacs-lisp/cl.el (pushnew): Silence warning.
* lisp/emacs-lisp/disass.el (disassemble-internal): Handle new
`closure' objects.
(disassemble-1): Handle new byte codes.
* lisp/emacs-lisp/edebug.el (edebug-eval-defun)
(edebug-eval-top-level-form): Use eval-sexp-add-defvars.
(edebug-toggle): Avoid `eval'.
* lisp/emacs-lisp/eieio-comp.el: Remove.
* lisp/emacs-lisp/eieio.el (byte-compile-file-form-defmethod):
Don't autoload.
(eieio-defgeneric-form-primary-only-one): Use `byte-compile' rather
than the internal `byte-compile-lambda'.
(defmethod): Don't hide code under quotes.
(eieio-defmethod): New `code' argument.
* lisp/emacs-lisp/float-sup.el (pi): Don't declare as dynamically bound.
* lisp/emacs-lisp/lisp-mode.el (eval-last-sexp-1):
Use eval-sexp-add-defvars.
(eval-sexp-add-defvars): New fun.
* lisp/emacs-lisp/macroexp.el: Use lexical binding.
(macroexpand-all-1): Check obsolete macros. Expand compiler-macros.
Don't convert ' to #' without checking that it's indeed quoting
a lambda.
* lisp/emacs-lisp/pcase.el: Don't use destructuring-bind.
(pcase--memoize): Rename from pcase-memoize. Change weakness.
(pcase): Add `let' pattern.
Change memoization so it actually works.
(pcase-mutually-exclusive-predicates): Add byte-code-function-p.
(pcase--u1) <guard, pred>: Fix possible shadowing problem.
<let>: New case.
* src/alloc.c (Fmake_symbol): Init new `declared_special' field.
* src/buffer.c (defvar_per_buffer): Set new `declared_special' field.
* src/bytecode.c (Bstack_ref, Bstack_set, Bstack_set2, BdiscardN):
New byte-codes.
(exec_byte_code): New function extracted from Fbyte_code to handle new
calling convention for byte-code-functions. Add new byte-codes.
* src/callint.c (Fcall_interactively): Preserve lexical-binding mode for
interactive spec.
* src/doc.c (Fdocumentation, store_function_docstring):
* src/data.c (Finteractive_form): Handle closures.
* src/eval.c (Fsetq): Handle lexical vars.
(Fdefun, Fdefmacro, Ffunction): Make closures when needed.
(Fdefconst, Fdefvaralias, Fdefvar): Mark as dynamic.
(FletX, Flet): Obey lexical binding.
(Fcommandp): Handle closures.
(Feval): New `lexical' arg.
(eval_sub): New function extracted from Feval. Use it almost
everywhere where Feval was used. Look up vars in lexical env.
Handle closures.
(Ffunctionp): Move from subr.el.
(Ffuncall): Handle closures.
(apply_lambda): Remove `eval_flags'.
(funcall_lambda): Handle closures and new byte-code-functions.
(Fspecial_variable_p): New function.
(syms_of_eval): Initialize the Vinternal_interpreter_environment var,
but without exporting it to Lisp.
* src/fns.c (concat, mapcar1): Accept byte-code-functions.
* src/image.c (parse_image_spec): Use Ffunctionp.
* src/keyboard.c (eval_dyn): New fun.
(menu_item_eval_property): Use it.
* src/lisp.h (struct Lisp_Symbol): New field `declared_special'.
* src/lread.c (lisp_file_lexically_bound_p): New function.
(Fload): Bind Qlexical_binding.
(readevalloop): Remove `evalfun' arg.
Bind Qinternal_interpreter_environment.
(Feval_buffer): Bind Qlexical_binding.
(defvar_int, defvar_bool, defvar_lisp_nopro, defvar_kboard):
Mark as dynamic.
(syms_of_lread): Declare `lexical-binding'.
* src/window.c (Ftemp_output_buffer_show): New fun.
(Fsave_window_excursion):
* src/print.c (Fwith_output_to_temp_buffer): Move to subr.el.
2011-04-01 17:19:52 +00:00
|
|
|
|
;; since otherwise when we're used in
|
|
|
|
|
;; completion-table-in-turn, we could return boundaries and
|
|
|
|
|
;; let some subsequent table return a list of completions.
|
|
|
|
|
;; FIXME: Maybe it should rather be fixed in
|
|
|
|
|
;; completion-table-in-turn instead, but it's difficult to
|
|
|
|
|
;; do it efficiently there.
|
2009-10-24 00:46:17 +00:00
|
|
|
|
(when (try-completion (substring string beg) table nil)
|
Merge from lexical-binding branch.
* doc/lispref/eval.texi (Eval): Discourage the use of `eval'.
Document its new `lexical' argument.
* doc/lispref/variables.texi (Defining Variables): Mention the new meaning of `defvar'.
(Lexical Binding): New sub-section.
* lisp/Makefile.in (BIG_STACK_DEPTH, BIG_STACK_OPTS, BYTE_COMPILE_FLAGS):
New variables.
(compile-onefile, .el.elc, compile-calc, recompile): Use them.
(COMPILE_FIRST): Add macroexp and cconv.
* lisp/makefile.w32-in: Mirror changes in Makefile.in.
* lisp/vc/cvs-status.el:
* lisp/vc/diff-mode.el:
* lisp/vc/log-edit.el:
* lisp/vc/log-view.el:
* lisp/vc/smerge-mode.el:
* lisp/textmodes/bibtex-style.el:
* textmodes/css.el:
* lisp/startup.el:
* lisp/uniquify.el:
* lisp/minibuffer.el:
* lisp/newcomment.el:
* lisp/reveal.el:
* lisp/server.el:
* lisp/mpc.el:
* lisp/emacs-lisp/smie.el:
* lisp/doc-view.el:
* lisp/dired.el:
* lisp/abbrev.el: Use lexical binding.
* lisp/custom.el (custom-initialize-default, custom-declare-variable):
Use `defvar'.
* lisp/files.el (lexical-binding): Declare safe.
* lisp/help-fns.el (help-split-fundoc): Return nil if there's nothing else
than the arglist.
(help-add-fundoc-usage): Don't add `Not documented'.
(help-function-arglist): Handle closures, subroutines, and new
byte-code-functions.
(help-make-usage): Remove leading underscores.
(describe-function-1): Handle closures.
(describe-variable): Use special-variable-p for completion.
* lisp/simple.el (with-wrapper-hook, apply-partially): Move to subr.el.
* lisp/subr.el (apply-partially): Use new closures rather than CL.
(--dolist-tail--, --dotimes-limit--): Don't declare dynamic.
(dolist, dotimes): Use slightly different expansion for lexical code.
(functionp): Move to C.
(letrec): New macro.
(with-wrapper-hook): Use it and apply-partially instead of CL.
(eval-after-load): Preserve lexical-binding.
(save-window-excursion, with-output-to-temp-buffer): Turn them
into macros.
* lisp/emacs-lisp/advice.el (ad-arglist): Use help-function-arglist.
* lisp/emacs-lisp/autoload.el (make-autoload): Don't burp on trivial macros.
* lisp/emacs-lisp/byte-opt.el: Use lexical binding.
(byte-inline-lapcode): Remove (to bytecomp).
(byte-compile-inline-expand): Pay attention to inlining to/from
lexically bound code.
(byte-compile-unfold-lambda): Don't handle byte-code-functions
any more.
(byte-optimize-form-code-walker): Don't handle save-window-excursion
any more and don't call compiler-macros.
(byte-compile-splice-in-already-compiled-code): Remove.
(byte-code): Don't inline any more.
(disassemble-offset): Receive `bytes' as argument rather than via
dynamic scoping.
(byte-compile-tag-number): Declare before first use.
(byte-decompile-bytecode-1): Handle new byte-codes, don't change
`return' even if make-spliceable.
(byte-compile-side-effect-and-error-free-ops): Add stack-ref, remove
obsolete interactive-p.
(byte-optimize-lapcode): Optimize new lap-codes.
Don't trip up on new form of `byte-constant' lap code.
* lisp/emacs-lisp/byte-run.el (make-obsolete): Don't set the `byte-compile'
handler any more.
* lisp/emacs-lisp/bytecomp.el: Use lexical binding instead of
a "bytecomp-" prefix. Macroexpand everything as a separate phase.
(byte-compile-initial-macro-environment):
Handle declare-function here.
(byte-compile--lexical-environment): New var.
(byte-stack-ref, byte-stack-set, byte-discardN)
(byte-discardN-preserve-tos): New lap codes.
(byte-interactive-p): Don't use any more.
(byte-compile-push-bytecodes, byte-compile-push-bytecode-const2):
New macros.
(byte-compile-lapcode): Use them and handle new lap codes.
(byte-compile-obsolete): Remove.
(byte-compile-arglist-signature): Handle new byte-code arg"lists".
(byte-compile-arglist-warn): Check late def of inlinable funs.
(byte-compile-cl-warn): Don't silence warnings for compiler-macros
since they should have been expanded by now.
(byte-compile--outbuffer): Rename from bytecomp-outbuffer.
(byte-compile-from-buffer): Remove unused second arg.
(byte-compile-preprocess): New function.
(byte-compile-toplevel-file-form): New function to distinguish
file-form calls from outside from file-form calls from hunk-handlers.
(byte-compile-file-form): Simplify.
(byte-compile-file-form-defsubst): Remove.
(byte-compile-file-form-defmumble): Simplify now that
byte-compile-lambda always returns a byte-code-function.
(byte-compile): Preprocess.
(byte-compile-byte-code-maker, byte-compile-byte-code-unmake):
Remove, not used any more.
(byte-compile-arglist-vars, byte-compile-make-lambda-lexenv)
(byte-compile-make-args-desc): New funs.
(byte-compile-lambda): Handle lexical functions. Always return
a byte-code-function.
(byte-compile-reserved-constants): New var, to make up room for
closed-over variables.
(byte-compile-constants-vector): Obey it.
(byte-compile-top-level): New args `lexenv' and `reserved-csts'.
(byte-compile-macroexpand-declare-function): New function.
(byte-compile-form): Call byte-compile-unfold-bcf to inline immediate
byte-code-functions.
(byte-compile-form): Check obsolescence here.
(byte-compile-inline-lapcode, byte-compile-unfold-bcf): New functions.
(byte-compile-variable-ref): Remove.
(byte-compile-dynamic-variable-op): New fun.
(byte-compile-dynamic-variable-bind, byte-compile-variable-ref)
(byte-compile-variable-set): New funs.
(byte-compile-discard): Add 2 args.
(byte-compile-stack-ref, byte-compile-stack-set)
(byte-compile-make-closure, byte-compile-get-closed-var): New funs.
(byte-compile-funarg, byte-compile-funarg-2): Remove, handled in
macroexpand-all instead.
(byte-compile-quote-form): Remove.
(byte-compile-push-binding-init, byte-compile-not-lexical-var-p)
(byte-compile-bind, byte-compile-unbind): New funs.
(byte-compile-let): Handle let* and lexical binding.
(byte-compile-let*): Remove.
(byte-compile-catch, byte-compile-unwind-protect)
(byte-compile-track-mouse, byte-compile-condition-case):
Handle a new :fun-body form, used for lexical scoping.
(byte-compile-save-window-excursion)
(byte-compile-with-output-to-temp-buffer): Remove.
(byte-compile-defun): Simplify.
(byte-compile-stack-adjustment): New fun.
(byte-compile-out): Use it.
(byte-compile-refresh-preloaded): Don't reload byte-compiler files.
* lisp/emacs-lisp/cconv.el: New file.
* lisp/emacs-lisp/cl-extra.el (cl-macroexpand-all): Properly quote CL
closures.
* lisp/emacs-lisp/cl-macs.el (cl-byte-compile-block)
(cl-byte-compile-throw): Remove.
(cl-block-wrapper, cl-block-throw): Use compiler-macros instead.
* lisp/emacs-lisp/cl.el (pushnew): Silence warning.
* lisp/emacs-lisp/disass.el (disassemble-internal): Handle new
`closure' objects.
(disassemble-1): Handle new byte codes.
* lisp/emacs-lisp/edebug.el (edebug-eval-defun)
(edebug-eval-top-level-form): Use eval-sexp-add-defvars.
(edebug-toggle): Avoid `eval'.
* lisp/emacs-lisp/eieio-comp.el: Remove.
* lisp/emacs-lisp/eieio.el (byte-compile-file-form-defmethod):
Don't autoload.
(eieio-defgeneric-form-primary-only-one): Use `byte-compile' rather
than the internal `byte-compile-lambda'.
(defmethod): Don't hide code under quotes.
(eieio-defmethod): New `code' argument.
* lisp/emacs-lisp/float-sup.el (pi): Don't declare as dynamically bound.
* lisp/emacs-lisp/lisp-mode.el (eval-last-sexp-1):
Use eval-sexp-add-defvars.
(eval-sexp-add-defvars): New fun.
* lisp/emacs-lisp/macroexp.el: Use lexical binding.
(macroexpand-all-1): Check obsolete macros. Expand compiler-macros.
Don't convert ' to #' without checking that it's indeed quoting
a lambda.
* lisp/emacs-lisp/pcase.el: Don't use destructuring-bind.
(pcase--memoize): Rename from pcase-memoize. Change weakness.
(pcase): Add `let' pattern.
Change memoization so it actually works.
(pcase-mutually-exclusive-predicates): Add byte-code-function-p.
(pcase--u1) <guard, pred>: Fix possible shadowing problem.
<let>: New case.
* src/alloc.c (Fmake_symbol): Init new `declared_special' field.
* src/buffer.c (defvar_per_buffer): Set new `declared_special' field.
* src/bytecode.c (Bstack_ref, Bstack_set, Bstack_set2, BdiscardN):
New byte-codes.
(exec_byte_code): New function extracted from Fbyte_code to handle new
calling convention for byte-code-functions. Add new byte-codes.
* src/callint.c (Fcall_interactively): Preserve lexical-binding mode for
interactive spec.
* src/doc.c (Fdocumentation, store_function_docstring):
* src/data.c (Finteractive_form): Handle closures.
* src/eval.c (Fsetq): Handle lexical vars.
(Fdefun, Fdefmacro, Ffunction): Make closures when needed.
(Fdefconst, Fdefvaralias, Fdefvar): Mark as dynamic.
(FletX, Flet): Obey lexical binding.
(Fcommandp): Handle closures.
(Feval): New `lexical' arg.
(eval_sub): New function extracted from Feval. Use it almost
everywhere where Feval was used. Look up vars in lexical env.
Handle closures.
(Ffunctionp): Move from subr.el.
(Ffuncall): Handle closures.
(apply_lambda): Remove `eval_flags'.
(funcall_lambda): Handle closures and new byte-code-functions.
(Fspecial_variable_p): New function.
(syms_of_eval): Initialize the Vinternal_interpreter_environment var,
but without exporting it to Lisp.
* src/fns.c (concat, mapcar1): Accept byte-code-functions.
* src/image.c (parse_image_spec): Use Ffunctionp.
* src/keyboard.c (eval_dyn): New fun.
(menu_item_eval_property): Use it.
* src/lisp.h (struct Lisp_Symbol): New field `declared_special'.
* src/lread.c (lisp_file_lexically_bound_p): New function.
(Fload): Bind Qlexical_binding.
(readevalloop): Remove `evalfun' arg.
Bind Qinternal_interpreter_environment.
(Feval_buffer): Bind Qlexical_binding.
(defvar_int, defvar_bool, defvar_lisp_nopro, defvar_kboard):
Mark as dynamic.
(syms_of_lread): Declare `lexical-binding'.
* src/window.c (Ftemp_output_buffer_show): New fun.
(Fsave_window_excursion):
* src/print.c (Fwith_output_to_temp_buffer): Move to subr.el.
2011-04-01 17:19:52 +00:00
|
|
|
|
;; Compute the boundaries of the subfield to which this
|
|
|
|
|
;; completion applies.
|
2011-05-31 21:40:30 +00:00
|
|
|
|
(if (eq action 'metadata)
|
|
|
|
|
'(metadata (category . environment-variable))
|
|
|
|
|
(let ((suffix (cdr action)))
|
Reduce use of (require 'cl).
* admin/bzrmerge.el: Use cl-lib.
* leim/quail/hangul.el: Don't require CL.
* leim/quail/ipa.el: Use cl-lib.
* vc/smerge-mode.el, vc/pcvs.el, vc/pcvs-util.el, vc/pcvs-info.el:
* vc/diff-mode.el, vc/cvs-status.el, uniquify.el, scroll-bar.el:
* register.el, progmodes/sh-script.el, net/gnutls.el, net/dbus.el:
* msb.el, mpc.el, minibuffer.el, international/ucs-normalize.el:
* international/quail.el, info-xref.el, imenu.el, image-mode.el:
* font-lock.el, filesets.el, edmacro.el, doc-view.el, bookmark.el:
* battery.el, avoid.el, abbrev.el: Use cl-lib.
* vc/pcvs-parse.el, vc/pcvs-defs.el, vc/log-view.el, vc/log-edit.el:
* vc/diff.el, simple.el, pcomplete.el, lpr.el, comint.el, loadhist.el:
* jit-lock.el, international/iso-ascii.el, info.el, frame.el, bs.el:
* emulation/crisp.el, electric.el, dired.el, cus-dep.el, composite.el:
* calculator.el, autorevert.el, apropos.el: Don't require CL.
* emacs-bytecomp.el (byte-recompile-directory, display-call-tree)
(byte-compile-unfold-bcf, byte-compile-check-variable):
* emacs-byte-opt.el (byte-compile-trueconstp)
(byte-compile-nilconstp):
* emacs-autoload.el (make-autoload): Use pcase.
* face-remap.el (text-scale-adjust): Simplify pcase patterns.
2012-07-10 11:51:54 +00:00
|
|
|
|
`(boundaries
|
|
|
|
|
,(or (match-beginning 2) (match-beginning 1))
|
|
|
|
|
. ,(when (string-match "[^[:alnum:]_]" suffix)
|
|
|
|
|
(match-beginning 0)))))))
|
2009-10-24 00:46:17 +00:00
|
|
|
|
(t
|
2008-05-20 17:03:30 +00:00
|
|
|
|
(if (eq (aref string (1- beg)) ?{)
|
|
|
|
|
(setq table (apply-partially 'completion-table-with-terminator
|
|
|
|
|
"}" table)))
|
2009-08-30 03:45:30 +00:00
|
|
|
|
;; Even if file-name completion is case-insensitive, we want
|
|
|
|
|
;; envvar completion to be case-sensitive.
|
|
|
|
|
(let ((completion-ignore-case nil))
|
|
|
|
|
(completion-table-with-context
|
2009-10-24 00:46:17 +00:00
|
|
|
|
prefix table (substring string beg) nil action)))))))
|
2008-04-13 01:49:17 +00:00
|
|
|
|
|
2009-10-21 20:03:57 +00:00
|
|
|
|
(defun completion-file-name-table (string pred action)
|
|
|
|
|
"Completion table for file names."
|
2011-10-11 05:17:04 +00:00
|
|
|
|
(condition-case nil
|
|
|
|
|
(cond
|
|
|
|
|
((eq action 'metadata) '(metadata (category . file)))
|
2012-04-20 19:56:59 +00:00
|
|
|
|
((string-match-p "\\`~[^/\\]*\\'" string)
|
|
|
|
|
(completion-table-with-context "~"
|
|
|
|
|
(mapcar (lambda (u) (concat u "/"))
|
|
|
|
|
(system-users))
|
|
|
|
|
(substring string 1)
|
|
|
|
|
pred action))
|
2011-10-11 05:17:04 +00:00
|
|
|
|
((eq (car-safe action) 'boundaries)
|
|
|
|
|
(let ((start (length (file-name-directory string)))
|
|
|
|
|
(end (string-match-p "/" (cdr action))))
|
Reduce use of (require 'cl).
* admin/bzrmerge.el: Use cl-lib.
* leim/quail/hangul.el: Don't require CL.
* leim/quail/ipa.el: Use cl-lib.
* vc/smerge-mode.el, vc/pcvs.el, vc/pcvs-util.el, vc/pcvs-info.el:
* vc/diff-mode.el, vc/cvs-status.el, uniquify.el, scroll-bar.el:
* register.el, progmodes/sh-script.el, net/gnutls.el, net/dbus.el:
* msb.el, mpc.el, minibuffer.el, international/ucs-normalize.el:
* international/quail.el, info-xref.el, imenu.el, image-mode.el:
* font-lock.el, filesets.el, edmacro.el, doc-view.el, bookmark.el:
* battery.el, avoid.el, abbrev.el: Use cl-lib.
* vc/pcvs-parse.el, vc/pcvs-defs.el, vc/log-view.el, vc/log-edit.el:
* vc/diff.el, simple.el, pcomplete.el, lpr.el, comint.el, loadhist.el:
* jit-lock.el, international/iso-ascii.el, info.el, frame.el, bs.el:
* emulation/crisp.el, electric.el, dired.el, cus-dep.el, composite.el:
* calculator.el, autorevert.el, apropos.el: Don't require CL.
* emacs-bytecomp.el (byte-recompile-directory, display-call-tree)
(byte-compile-unfold-bcf, byte-compile-check-variable):
* emacs-byte-opt.el (byte-compile-trueconstp)
(byte-compile-nilconstp):
* emacs-autoload.el (make-autoload): Use pcase.
* face-remap.el (text-scale-adjust): Simplify pcase patterns.
2012-07-10 11:51:54 +00:00
|
|
|
|
`(boundaries
|
|
|
|
|
;; if `string' is "C:" in w32, (file-name-directory string)
|
|
|
|
|
;; returns "C:/", so `start' is 3 rather than 2.
|
|
|
|
|
;; Not quite sure what is The Right Fix, but clipping it
|
|
|
|
|
;; back to 2 will work for this particular case. We'll
|
|
|
|
|
;; see if we can come up with a better fix when we bump
|
|
|
|
|
;; into more such problematic cases.
|
|
|
|
|
,(min start (length string)) . ,end)))
|
2009-10-21 20:03:57 +00:00
|
|
|
|
|
2011-10-11 05:17:04 +00:00
|
|
|
|
((eq action 'lambda)
|
|
|
|
|
(if (zerop (length string))
|
|
|
|
|
nil ;Not sure why it's here, but it probably doesn't harm.
|
|
|
|
|
(funcall (or pred 'file-exists-p) string)))
|
2008-04-13 01:49:17 +00:00
|
|
|
|
|
2011-10-11 05:17:04 +00:00
|
|
|
|
(t
|
|
|
|
|
(let* ((name (file-name-nondirectory string))
|
|
|
|
|
(specdir (file-name-directory string))
|
|
|
|
|
(realdir (or specdir default-directory)))
|
|
|
|
|
|
|
|
|
|
(cond
|
|
|
|
|
((null action)
|
|
|
|
|
(let ((comp (file-name-completion name realdir pred)))
|
|
|
|
|
(if (stringp comp)
|
|
|
|
|
(concat specdir comp)
|
|
|
|
|
comp)))
|
|
|
|
|
|
|
|
|
|
((eq action t)
|
|
|
|
|
(let ((all (file-name-all-completions name realdir)))
|
|
|
|
|
|
|
|
|
|
;; Check the predicate, if necessary.
|
|
|
|
|
(unless (memq pred '(nil file-exists-p))
|
|
|
|
|
(let ((comp ())
|
|
|
|
|
(pred
|
|
|
|
|
(if (eq pred 'file-directory-p)
|
|
|
|
|
;; Brute-force speed up for directory checking:
|
|
|
|
|
;; Discard strings which don't end in a slash.
|
|
|
|
|
(lambda (s)
|
|
|
|
|
(let ((len (length s)))
|
|
|
|
|
(and (> len 0) (eq (aref s (1- len)) ?/))))
|
|
|
|
|
;; Must do it the hard (and slow) way.
|
|
|
|
|
pred)))
|
|
|
|
|
(let ((default-directory (expand-file-name realdir)))
|
|
|
|
|
(dolist (tem all)
|
|
|
|
|
(if (funcall pred tem) (push tem comp))))
|
|
|
|
|
(setq all (nreverse comp))))
|
|
|
|
|
|
|
|
|
|
all))))))
|
|
|
|
|
(file-error nil))) ;PCM often calls with invalid directories.
|
2009-10-21 20:03:57 +00:00
|
|
|
|
|
|
|
|
|
(defvar read-file-name-predicate nil
|
|
|
|
|
"Current predicate used by `read-file-name-internal'.")
|
|
|
|
|
(make-obsolete-variable 'read-file-name-predicate
|
|
|
|
|
"use the regular PRED argument" "23.2")
|
|
|
|
|
|
2012-04-25 18:42:15 +00:00
|
|
|
|
(defun completion--sifn-requote (upos qstr)
|
2012-10-28 18:48:17 +00:00
|
|
|
|
;; We're looking for `qpos' such that:
|
2012-05-15 18:07:36 +00:00
|
|
|
|
;; (equal (substring (substitute-in-file-name qstr) 0 upos)
|
2012-10-28 18:48:17 +00:00
|
|
|
|
;; (substitute-in-file-name (substring qstr 0 qpos)))
|
2012-05-15 18:07:36 +00:00
|
|
|
|
;; Big problem here: we have to reverse engineer substitute-in-file-name to
|
|
|
|
|
;; find the position corresponding to UPOS in QSTR, but
|
|
|
|
|
;; substitute-in-file-name can do anything, depending on file-name-handlers.
|
2012-10-28 18:48:17 +00:00
|
|
|
|
;; substitute-in-file-name does the following kind of things:
|
|
|
|
|
;; - expand env-var references.
|
|
|
|
|
;; - turn backslashes into slashes.
|
|
|
|
|
;; - truncate some prefix of the input.
|
|
|
|
|
;; - rewrite some prefix.
|
|
|
|
|
;; Some of these operations are written in external libraries and we'd rather
|
|
|
|
|
;; not hard code any assumptions here about what they actually do. IOW, we
|
|
|
|
|
;; want to treat substitute-in-file-name as a black box, as much as possible.
|
2012-05-15 18:07:36 +00:00
|
|
|
|
;; Kind of like in rfn-eshadow-update-overlay, only worse.
|
2012-10-28 18:48:17 +00:00
|
|
|
|
;; Example of things we need to handle:
|
|
|
|
|
;; - Tramp (substitute-in-file-name "/foo:~/bar//baz") => "/scpc:foo:/baz".
|
|
|
|
|
;; - Cygwin (substitute-in-file-name "C:\bin") => "/usr/bin"
|
|
|
|
|
;; (substitute-in-file-name "C:\") => "/"
|
|
|
|
|
;; (substitute-in-file-name "C:\bi") => "/bi"
|
|
|
|
|
(let* ((ustr (substitute-in-file-name qstr))
|
|
|
|
|
(uprefix (substring ustr 0 upos))
|
|
|
|
|
qprefix)
|
|
|
|
|
;; Main assumption: nothing after qpos should affect the text before upos,
|
|
|
|
|
;; so we can work our way backward from the end of qstr, one character
|
|
|
|
|
;; at a time.
|
|
|
|
|
;; Second assumptions: If qpos is far from the end this can be a bit slow,
|
|
|
|
|
;; so we speed it up by doing a first loop that skips a word at a time.
|
|
|
|
|
;; This word-sized loop is careful not to cut in the middle of env-vars.
|
|
|
|
|
(while (let ((boundary (string-match "\\(\\$+{?\\)?\\w+\\W*\\'" qstr)))
|
|
|
|
|
(and boundary
|
2012-05-16 01:57:20 +00:00
|
|
|
|
(progn
|
2012-10-28 18:48:17 +00:00
|
|
|
|
(setq qprefix (substring qstr 0 boundary))
|
|
|
|
|
(string-prefix-p uprefix
|
|
|
|
|
(substitute-in-file-name qprefix)))))
|
|
|
|
|
(setq qstr qprefix))
|
|
|
|
|
(let ((qpos (length qstr)))
|
|
|
|
|
(while (and (> qpos 0)
|
|
|
|
|
(string-prefix-p uprefix
|
|
|
|
|
(substitute-in-file-name
|
|
|
|
|
(substring qstr 0 (1- qpos)))))
|
|
|
|
|
(setq qpos (1- qpos)))
|
|
|
|
|
(cons qpos #'minibuffer--double-dollars))))
|
2012-04-25 18:42:15 +00:00
|
|
|
|
|
|
|
|
|
(defalias 'completion--file-name-table
|
|
|
|
|
(completion-table-with-quoting #'completion-file-name-table
|
|
|
|
|
#'substitute-in-file-name
|
|
|
|
|
#'completion--sifn-requote)
|
2009-10-21 20:03:57 +00:00
|
|
|
|
"Internal subroutine for `read-file-name'. Do not call this.
|
|
|
|
|
This is a completion table for file names, like `completion-file-name-table'
|
2012-04-25 18:42:15 +00:00
|
|
|
|
except that it passes the file name through `substitute-in-file-name'.")
|
2008-04-10 03:12:49 +00:00
|
|
|
|
|
2008-04-11 22:28:02 +00:00
|
|
|
|
(defalias 'read-file-name-internal
|
2012-04-25 18:42:15 +00:00
|
|
|
|
(completion-table-in-turn #'completion--embedded-envvar-table
|
|
|
|
|
#'completion--file-name-table)
|
2008-04-11 22:28:02 +00:00
|
|
|
|
"Internal subroutine for `read-file-name'. Do not call this.")
|
2008-04-10 03:12:49 +00:00
|
|
|
|
|
2011-03-21 14:55:00 +00:00
|
|
|
|
(defvar read-file-name-function 'read-file-name-default
|
|
|
|
|
"The function called by `read-file-name' to do its work.
|
|
|
|
|
It should accept the same arguments as `read-file-name'.")
|
2008-04-23 18:19:57 +00:00
|
|
|
|
|
|
|
|
|
(defcustom insert-default-directory t
|
|
|
|
|
"Non-nil means when reading a filename start with default dir in minibuffer.
|
|
|
|
|
|
|
|
|
|
When the initial minibuffer contents show a name of a file or a directory,
|
|
|
|
|
typing RETURN without editing the initial contents is equivalent to typing
|
|
|
|
|
the default file name.
|
|
|
|
|
|
|
|
|
|
If this variable is non-nil, the minibuffer contents are always
|
|
|
|
|
initially non-empty, and typing RETURN without editing will fetch the
|
|
|
|
|
default name, if one is provided. Note however that this default name
|
|
|
|
|
is not necessarily the same as initial contents inserted in the minibuffer,
|
|
|
|
|
if the initial contents is just the default directory.
|
|
|
|
|
|
|
|
|
|
If this variable is nil, the minibuffer often starts out empty. In
|
|
|
|
|
that case you may have to explicitly fetch the next history element to
|
|
|
|
|
request the default name; typing RETURN without editing will leave
|
|
|
|
|
the minibuffer empty.
|
|
|
|
|
|
|
|
|
|
For some commands, exiting with an empty minibuffer has a special meaning,
|
|
|
|
|
such as making the current buffer visit no file in the case of
|
|
|
|
|
`set-visited-file-name'."
|
|
|
|
|
:type 'boolean)
|
|
|
|
|
|
2008-04-24 05:46:17 +00:00
|
|
|
|
;; Not always defined, but only called if next-read-file-uses-dialog-p says so.
|
|
|
|
|
(declare-function x-file-dialog "xfns.c"
|
|
|
|
|
(prompt dir &optional default-filename mustmatch only-dir-p))
|
|
|
|
|
|
2011-03-21 14:55:00 +00:00
|
|
|
|
(defun read-file-name--defaults (&optional dir initial)
|
2009-11-25 17:11:29 +00:00
|
|
|
|
(let ((default
|
|
|
|
|
(cond
|
|
|
|
|
;; With non-nil `initial', use `dir' as the first default.
|
|
|
|
|
;; Essentially, this mean reversing the normal order of the
|
|
|
|
|
;; current directory name and the current file name, i.e.
|
|
|
|
|
;; 1. with normal file reading:
|
|
|
|
|
;; 1.1. initial input is the current directory
|
|
|
|
|
;; 1.2. the first default is the current file name
|
|
|
|
|
;; 2. with non-nil `initial' (e.g. for `find-alternate-file'):
|
|
|
|
|
;; 2.2. initial input is the current file name
|
|
|
|
|
;; 2.1. the first default is the current directory
|
|
|
|
|
(initial (abbreviate-file-name dir))
|
|
|
|
|
;; In file buffers, try to get the current file name
|
|
|
|
|
(buffer-file-name
|
|
|
|
|
(abbreviate-file-name buffer-file-name))))
|
|
|
|
|
(file-name-at-point
|
|
|
|
|
(run-hook-with-args-until-success 'file-name-at-point-functions)))
|
|
|
|
|
(when file-name-at-point
|
|
|
|
|
(setq default (delete-dups
|
|
|
|
|
(delete "" (delq nil (list file-name-at-point default))))))
|
|
|
|
|
;; Append new defaults to the end of existing `minibuffer-default'.
|
|
|
|
|
(append
|
|
|
|
|
(if (listp minibuffer-default) minibuffer-default (list minibuffer-default))
|
|
|
|
|
(if (listp default) default (list default)))))
|
|
|
|
|
|
2008-04-23 18:19:57 +00:00
|
|
|
|
(defun read-file-name (prompt &optional dir default-filename mustmatch initial predicate)
|
|
|
|
|
"Read file name, prompting with PROMPT and completing in directory DIR.
|
|
|
|
|
Value is not expanded---you must call `expand-file-name' yourself.
|
2012-08-14 17:10:38 +00:00
|
|
|
|
|
|
|
|
|
DIR is the directory to use for completing relative file names.
|
|
|
|
|
It should be an absolute directory name, or nil (which means the
|
|
|
|
|
current buffer's value of `default-directory').
|
|
|
|
|
|
|
|
|
|
DEFAULT-FILENAME specifies the default file name to return if the
|
|
|
|
|
user exits the minibuffer with the same non-empty string inserted
|
|
|
|
|
by this function. If DEFAULT-FILENAME is a string, that serves
|
|
|
|
|
as the default. If DEFAULT-FILENAME is a list of strings, the
|
|
|
|
|
first string is the default. If DEFAULT-FILENAME is omitted or
|
|
|
|
|
nil, then if INITIAL is non-nil, the default is DIR combined with
|
|
|
|
|
INITIAL; otherwise, if the current buffer is visiting a file,
|
|
|
|
|
that file serves as the default; otherwise, the default is simply
|
|
|
|
|
the string inserted into the minibuffer.
|
|
|
|
|
|
|
|
|
|
If the user exits with an empty minibuffer, return an empty
|
|
|
|
|
string. (This happens only if the user erases the pre-inserted
|
|
|
|
|
contents, or if `insert-default-directory' is nil.)
|
2009-03-16 03:17:48 +00:00
|
|
|
|
|
|
|
|
|
Fourth arg MUSTMATCH can take the following values:
|
|
|
|
|
- nil means that the user can exit with any input.
|
|
|
|
|
- t means that the user is not allowed to exit unless
|
|
|
|
|
the input is (or completes to) an existing file.
|
|
|
|
|
- `confirm' means that the user can exit with any input, but she needs
|
|
|
|
|
to confirm her choice if the input is not an existing file.
|
|
|
|
|
- `confirm-after-completion' means that the user can exit with any
|
|
|
|
|
input, but she needs to confirm her choice if she called
|
|
|
|
|
`minibuffer-complete' right before `minibuffer-complete-and-exit'
|
|
|
|
|
and the input is not an existing file.
|
|
|
|
|
- anything else behaves like t except that typing RET does not exit if it
|
|
|
|
|
does non-null completion.
|
|
|
|
|
|
2008-04-23 18:19:57 +00:00
|
|
|
|
Fifth arg INITIAL specifies text to start with.
|
2009-03-16 03:17:48 +00:00
|
|
|
|
|
2012-08-14 17:10:38 +00:00
|
|
|
|
Sixth arg PREDICATE, if non-nil, should be a function of one
|
|
|
|
|
argument; then a file name is considered an acceptable completion
|
|
|
|
|
alternative only if PREDICATE returns non-nil with the file name
|
|
|
|
|
as its argument.
|
2008-04-23 18:19:57 +00:00
|
|
|
|
|
2009-03-16 03:17:48 +00:00
|
|
|
|
If this command was invoked with the mouse, use a graphical file
|
|
|
|
|
dialog if `use-dialog-box' is non-nil, and the window system or X
|
2009-11-02 02:06:36 +00:00
|
|
|
|
toolkit in use provides a file dialog box, and DIR is not a
|
2012-02-13 22:46:43 +00:00
|
|
|
|
remote file. For graphical file dialogs, any of the special values
|
|
|
|
|
of MUSTMATCH `confirm' and `confirm-after-completion' are
|
|
|
|
|
treated as equivalent to nil. Some graphical file dialogs respect
|
|
|
|
|
a MUSTMATCH value of t, and some do not (or it only has a cosmetic
|
2012-02-13 22:49:16 +00:00
|
|
|
|
effect, and does not actually prevent the user from entering a
|
2012-02-13 22:46:43 +00:00
|
|
|
|
non-existent file).
|
2008-04-23 18:19:57 +00:00
|
|
|
|
|
|
|
|
|
See also `read-file-name-completion-ignore-case'
|
|
|
|
|
and `read-file-name-function'."
|
2012-02-13 22:46:43 +00:00
|
|
|
|
;; If x-gtk-use-old-file-dialog = t (xg_get_file_with_selection),
|
|
|
|
|
;; then MUSTMATCH is enforced. But with newer Gtk
|
|
|
|
|
;; (xg_get_file_with_chooser), it only has a cosmetic effect.
|
|
|
|
|
;; The user can still type a non-existent file name.
|
2011-03-21 14:55:00 +00:00
|
|
|
|
(funcall (or read-file-name-function #'read-file-name-default)
|
|
|
|
|
prompt dir default-filename mustmatch initial predicate))
|
|
|
|
|
|
2012-04-13 21:43:03 +00:00
|
|
|
|
(defvar minibuffer-local-filename-syntax
|
|
|
|
|
(let ((table (make-syntax-table))
|
|
|
|
|
(punctuation (car (string-to-syntax "."))))
|
|
|
|
|
;; Convert all punctuation entries to symbol.
|
|
|
|
|
(map-char-table (lambda (c syntax)
|
|
|
|
|
(when (eq (car syntax) punctuation)
|
|
|
|
|
(modify-syntax-entry c "_" table)))
|
|
|
|
|
table)
|
|
|
|
|
(mapc
|
|
|
|
|
(lambda (c)
|
|
|
|
|
(modify-syntax-entry c "." table))
|
|
|
|
|
'(?/ ?: ?\\))
|
|
|
|
|
table)
|
2012-09-30 09:18:38 +00:00
|
|
|
|
"Syntax table used when reading a file name in the minibuffer.")
|
2012-04-13 21:43:03 +00:00
|
|
|
|
|
2011-05-31 03:03:38 +00:00
|
|
|
|
;; minibuffer-completing-file-name is a variable used internally in minibuf.c
|
|
|
|
|
;; to determine whether to use minibuffer-local-filename-completion-map or
|
|
|
|
|
;; minibuffer-local-completion-map. It shouldn't be exported to Elisp.
|
2011-06-01 19:32:04 +00:00
|
|
|
|
;; FIXME: Actually, it is also used in rfn-eshadow.el we'd otherwise have to
|
|
|
|
|
;; use (eq minibuffer-completion-table #'read-file-name-internal), which is
|
|
|
|
|
;; probably even worse. Maybe We should add some read-file-name-setup-hook
|
|
|
|
|
;; instead, but for now, let's keep this non-obsolete.
|
2012-04-25 18:57:09 +00:00
|
|
|
|
;;(make-obsolete-variable 'minibuffer-completing-file-name nil "future" 'get)
|
2011-05-31 03:03:38 +00:00
|
|
|
|
|
2011-03-21 14:55:00 +00:00
|
|
|
|
(defun read-file-name-default (prompt &optional dir default-filename mustmatch initial predicate)
|
|
|
|
|
"Default method for reading file names.
|
|
|
|
|
See `read-file-name' for the meaning of the arguments."
|
2008-04-23 18:19:57 +00:00
|
|
|
|
(unless dir (setq dir default-directory))
|
|
|
|
|
(unless (file-name-absolute-p dir) (setq dir (expand-file-name dir)))
|
|
|
|
|
(unless default-filename
|
|
|
|
|
(setq default-filename (if initial (expand-file-name initial dir)
|
|
|
|
|
buffer-file-name)))
|
|
|
|
|
;; If dir starts with user's homedir, change that to ~.
|
|
|
|
|
(setq dir (abbreviate-file-name dir))
|
|
|
|
|
;; Likewise for default-filename.
|
2008-04-23 18:37:50 +00:00
|
|
|
|
(if default-filename
|
2009-11-10 00:54:45 +00:00
|
|
|
|
(setq default-filename
|
|
|
|
|
(if (consp default-filename)
|
|
|
|
|
(mapcar 'abbreviate-file-name default-filename)
|
|
|
|
|
(abbreviate-file-name default-filename))))
|
2012-06-18 20:39:52 +00:00
|
|
|
|
(let ((insdef (cond
|
2008-04-23 18:19:57 +00:00
|
|
|
|
((and insert-default-directory (stringp dir))
|
|
|
|
|
(if initial
|
|
|
|
|
(cons (minibuffer--double-dollars (concat dir initial))
|
|
|
|
|
(length (minibuffer--double-dollars dir)))
|
|
|
|
|
(minibuffer--double-dollars dir)))
|
|
|
|
|
(initial (cons (minibuffer--double-dollars initial) 0)))))
|
|
|
|
|
|
Merge from lexical-binding branch.
* doc/lispref/eval.texi (Eval): Discourage the use of `eval'.
Document its new `lexical' argument.
* doc/lispref/variables.texi (Defining Variables): Mention the new meaning of `defvar'.
(Lexical Binding): New sub-section.
* lisp/Makefile.in (BIG_STACK_DEPTH, BIG_STACK_OPTS, BYTE_COMPILE_FLAGS):
New variables.
(compile-onefile, .el.elc, compile-calc, recompile): Use them.
(COMPILE_FIRST): Add macroexp and cconv.
* lisp/makefile.w32-in: Mirror changes in Makefile.in.
* lisp/vc/cvs-status.el:
* lisp/vc/diff-mode.el:
* lisp/vc/log-edit.el:
* lisp/vc/log-view.el:
* lisp/vc/smerge-mode.el:
* lisp/textmodes/bibtex-style.el:
* textmodes/css.el:
* lisp/startup.el:
* lisp/uniquify.el:
* lisp/minibuffer.el:
* lisp/newcomment.el:
* lisp/reveal.el:
* lisp/server.el:
* lisp/mpc.el:
* lisp/emacs-lisp/smie.el:
* lisp/doc-view.el:
* lisp/dired.el:
* lisp/abbrev.el: Use lexical binding.
* lisp/custom.el (custom-initialize-default, custom-declare-variable):
Use `defvar'.
* lisp/files.el (lexical-binding): Declare safe.
* lisp/help-fns.el (help-split-fundoc): Return nil if there's nothing else
than the arglist.
(help-add-fundoc-usage): Don't add `Not documented'.
(help-function-arglist): Handle closures, subroutines, and new
byte-code-functions.
(help-make-usage): Remove leading underscores.
(describe-function-1): Handle closures.
(describe-variable): Use special-variable-p for completion.
* lisp/simple.el (with-wrapper-hook, apply-partially): Move to subr.el.
* lisp/subr.el (apply-partially): Use new closures rather than CL.
(--dolist-tail--, --dotimes-limit--): Don't declare dynamic.
(dolist, dotimes): Use slightly different expansion for lexical code.
(functionp): Move to C.
(letrec): New macro.
(with-wrapper-hook): Use it and apply-partially instead of CL.
(eval-after-load): Preserve lexical-binding.
(save-window-excursion, with-output-to-temp-buffer): Turn them
into macros.
* lisp/emacs-lisp/advice.el (ad-arglist): Use help-function-arglist.
* lisp/emacs-lisp/autoload.el (make-autoload): Don't burp on trivial macros.
* lisp/emacs-lisp/byte-opt.el: Use lexical binding.
(byte-inline-lapcode): Remove (to bytecomp).
(byte-compile-inline-expand): Pay attention to inlining to/from
lexically bound code.
(byte-compile-unfold-lambda): Don't handle byte-code-functions
any more.
(byte-optimize-form-code-walker): Don't handle save-window-excursion
any more and don't call compiler-macros.
(byte-compile-splice-in-already-compiled-code): Remove.
(byte-code): Don't inline any more.
(disassemble-offset): Receive `bytes' as argument rather than via
dynamic scoping.
(byte-compile-tag-number): Declare before first use.
(byte-decompile-bytecode-1): Handle new byte-codes, don't change
`return' even if make-spliceable.
(byte-compile-side-effect-and-error-free-ops): Add stack-ref, remove
obsolete interactive-p.
(byte-optimize-lapcode): Optimize new lap-codes.
Don't trip up on new form of `byte-constant' lap code.
* lisp/emacs-lisp/byte-run.el (make-obsolete): Don't set the `byte-compile'
handler any more.
* lisp/emacs-lisp/bytecomp.el: Use lexical binding instead of
a "bytecomp-" prefix. Macroexpand everything as a separate phase.
(byte-compile-initial-macro-environment):
Handle declare-function here.
(byte-compile--lexical-environment): New var.
(byte-stack-ref, byte-stack-set, byte-discardN)
(byte-discardN-preserve-tos): New lap codes.
(byte-interactive-p): Don't use any more.
(byte-compile-push-bytecodes, byte-compile-push-bytecode-const2):
New macros.
(byte-compile-lapcode): Use them and handle new lap codes.
(byte-compile-obsolete): Remove.
(byte-compile-arglist-signature): Handle new byte-code arg"lists".
(byte-compile-arglist-warn): Check late def of inlinable funs.
(byte-compile-cl-warn): Don't silence warnings for compiler-macros
since they should have been expanded by now.
(byte-compile--outbuffer): Rename from bytecomp-outbuffer.
(byte-compile-from-buffer): Remove unused second arg.
(byte-compile-preprocess): New function.
(byte-compile-toplevel-file-form): New function to distinguish
file-form calls from outside from file-form calls from hunk-handlers.
(byte-compile-file-form): Simplify.
(byte-compile-file-form-defsubst): Remove.
(byte-compile-file-form-defmumble): Simplify now that
byte-compile-lambda always returns a byte-code-function.
(byte-compile): Preprocess.
(byte-compile-byte-code-maker, byte-compile-byte-code-unmake):
Remove, not used any more.
(byte-compile-arglist-vars, byte-compile-make-lambda-lexenv)
(byte-compile-make-args-desc): New funs.
(byte-compile-lambda): Handle lexical functions. Always return
a byte-code-function.
(byte-compile-reserved-constants): New var, to make up room for
closed-over variables.
(byte-compile-constants-vector): Obey it.
(byte-compile-top-level): New args `lexenv' and `reserved-csts'.
(byte-compile-macroexpand-declare-function): New function.
(byte-compile-form): Call byte-compile-unfold-bcf to inline immediate
byte-code-functions.
(byte-compile-form): Check obsolescence here.
(byte-compile-inline-lapcode, byte-compile-unfold-bcf): New functions.
(byte-compile-variable-ref): Remove.
(byte-compile-dynamic-variable-op): New fun.
(byte-compile-dynamic-variable-bind, byte-compile-variable-ref)
(byte-compile-variable-set): New funs.
(byte-compile-discard): Add 2 args.
(byte-compile-stack-ref, byte-compile-stack-set)
(byte-compile-make-closure, byte-compile-get-closed-var): New funs.
(byte-compile-funarg, byte-compile-funarg-2): Remove, handled in
macroexpand-all instead.
(byte-compile-quote-form): Remove.
(byte-compile-push-binding-init, byte-compile-not-lexical-var-p)
(byte-compile-bind, byte-compile-unbind): New funs.
(byte-compile-let): Handle let* and lexical binding.
(byte-compile-let*): Remove.
(byte-compile-catch, byte-compile-unwind-protect)
(byte-compile-track-mouse, byte-compile-condition-case):
Handle a new :fun-body form, used for lexical scoping.
(byte-compile-save-window-excursion)
(byte-compile-with-output-to-temp-buffer): Remove.
(byte-compile-defun): Simplify.
(byte-compile-stack-adjustment): New fun.
(byte-compile-out): Use it.
(byte-compile-refresh-preloaded): Don't reload byte-compiler files.
* lisp/emacs-lisp/cconv.el: New file.
* lisp/emacs-lisp/cl-extra.el (cl-macroexpand-all): Properly quote CL
closures.
* lisp/emacs-lisp/cl-macs.el (cl-byte-compile-block)
(cl-byte-compile-throw): Remove.
(cl-block-wrapper, cl-block-throw): Use compiler-macros instead.
* lisp/emacs-lisp/cl.el (pushnew): Silence warning.
* lisp/emacs-lisp/disass.el (disassemble-internal): Handle new
`closure' objects.
(disassemble-1): Handle new byte codes.
* lisp/emacs-lisp/edebug.el (edebug-eval-defun)
(edebug-eval-top-level-form): Use eval-sexp-add-defvars.
(edebug-toggle): Avoid `eval'.
* lisp/emacs-lisp/eieio-comp.el: Remove.
* lisp/emacs-lisp/eieio.el (byte-compile-file-form-defmethod):
Don't autoload.
(eieio-defgeneric-form-primary-only-one): Use `byte-compile' rather
than the internal `byte-compile-lambda'.
(defmethod): Don't hide code under quotes.
(eieio-defmethod): New `code' argument.
* lisp/emacs-lisp/float-sup.el (pi): Don't declare as dynamically bound.
* lisp/emacs-lisp/lisp-mode.el (eval-last-sexp-1):
Use eval-sexp-add-defvars.
(eval-sexp-add-defvars): New fun.
* lisp/emacs-lisp/macroexp.el: Use lexical binding.
(macroexpand-all-1): Check obsolete macros. Expand compiler-macros.
Don't convert ' to #' without checking that it's indeed quoting
a lambda.
* lisp/emacs-lisp/pcase.el: Don't use destructuring-bind.
(pcase--memoize): Rename from pcase-memoize. Change weakness.
(pcase): Add `let' pattern.
Change memoization so it actually works.
(pcase-mutually-exclusive-predicates): Add byte-code-function-p.
(pcase--u1) <guard, pred>: Fix possible shadowing problem.
<let>: New case.
* src/alloc.c (Fmake_symbol): Init new `declared_special' field.
* src/buffer.c (defvar_per_buffer): Set new `declared_special' field.
* src/bytecode.c (Bstack_ref, Bstack_set, Bstack_set2, BdiscardN):
New byte-codes.
(exec_byte_code): New function extracted from Fbyte_code to handle new
calling convention for byte-code-functions. Add new byte-codes.
* src/callint.c (Fcall_interactively): Preserve lexical-binding mode for
interactive spec.
* src/doc.c (Fdocumentation, store_function_docstring):
* src/data.c (Finteractive_form): Handle closures.
* src/eval.c (Fsetq): Handle lexical vars.
(Fdefun, Fdefmacro, Ffunction): Make closures when needed.
(Fdefconst, Fdefvaralias, Fdefvar): Mark as dynamic.
(FletX, Flet): Obey lexical binding.
(Fcommandp): Handle closures.
(Feval): New `lexical' arg.
(eval_sub): New function extracted from Feval. Use it almost
everywhere where Feval was used. Look up vars in lexical env.
Handle closures.
(Ffunctionp): Move from subr.el.
(Ffuncall): Handle closures.
(apply_lambda): Remove `eval_flags'.
(funcall_lambda): Handle closures and new byte-code-functions.
(Fspecial_variable_p): New function.
(syms_of_eval): Initialize the Vinternal_interpreter_environment var,
but without exporting it to Lisp.
* src/fns.c (concat, mapcar1): Accept byte-code-functions.
* src/image.c (parse_image_spec): Use Ffunctionp.
* src/keyboard.c (eval_dyn): New fun.
(menu_item_eval_property): Use it.
* src/lisp.h (struct Lisp_Symbol): New field `declared_special'.
* src/lread.c (lisp_file_lexically_bound_p): New function.
(Fload): Bind Qlexical_binding.
(readevalloop): Remove `evalfun' arg.
Bind Qinternal_interpreter_environment.
(Feval_buffer): Bind Qlexical_binding.
(defvar_int, defvar_bool, defvar_lisp_nopro, defvar_kboard):
Mark as dynamic.
(syms_of_lread): Declare `lexical-binding'.
* src/window.c (Ftemp_output_buffer_show): New fun.
(Fsave_window_excursion):
* src/print.c (Fwith_output_to_temp_buffer): Move to subr.el.
2011-04-01 17:19:52 +00:00
|
|
|
|
(let ((completion-ignore-case read-file-name-completion-ignore-case)
|
|
|
|
|
(minibuffer-completing-file-name t)
|
|
|
|
|
(pred (or predicate 'file-exists-p))
|
|
|
|
|
(add-to-history nil))
|
|
|
|
|
|
|
|
|
|
(let* ((val
|
|
|
|
|
(if (or (not (next-read-file-uses-dialog-p))
|
|
|
|
|
;; Graphical file dialogs can't handle remote
|
|
|
|
|
;; files (Bug#99).
|
|
|
|
|
(file-remote-p dir))
|
|
|
|
|
;; We used to pass `dir' to `read-file-name-internal' by
|
|
|
|
|
;; abusing the `predicate' argument. It's better to
|
|
|
|
|
;; just use `default-directory', but in order to avoid
|
|
|
|
|
;; changing `default-directory' in the current buffer,
|
|
|
|
|
;; we don't let-bind it.
|
|
|
|
|
(let ((dir (file-name-as-directory
|
|
|
|
|
(expand-file-name dir))))
|
|
|
|
|
(minibuffer-with-setup-hook
|
|
|
|
|
(lambda ()
|
|
|
|
|
(setq default-directory dir)
|
|
|
|
|
;; When the first default in `minibuffer-default'
|
|
|
|
|
;; duplicates initial input `insdef',
|
|
|
|
|
;; reset `minibuffer-default' to nil.
|
|
|
|
|
(when (equal (or (car-safe insdef) insdef)
|
|
|
|
|
(or (car-safe minibuffer-default)
|
|
|
|
|
minibuffer-default))
|
|
|
|
|
(setq minibuffer-default
|
|
|
|
|
(cdr-safe minibuffer-default)))
|
|
|
|
|
;; On the first request on `M-n' fill
|
|
|
|
|
;; `minibuffer-default' with a list of defaults
|
|
|
|
|
;; relevant for file-name reading.
|
|
|
|
|
(set (make-local-variable 'minibuffer-default-add-function)
|
|
|
|
|
(lambda ()
|
|
|
|
|
(with-current-buffer
|
|
|
|
|
(window-buffer (minibuffer-selected-window))
|
2012-04-13 21:43:03 +00:00
|
|
|
|
(read-file-name--defaults dir initial))))
|
|
|
|
|
(set-syntax-table minibuffer-local-filename-syntax))
|
Merge from lexical-binding branch.
* doc/lispref/eval.texi (Eval): Discourage the use of `eval'.
Document its new `lexical' argument.
* doc/lispref/variables.texi (Defining Variables): Mention the new meaning of `defvar'.
(Lexical Binding): New sub-section.
* lisp/Makefile.in (BIG_STACK_DEPTH, BIG_STACK_OPTS, BYTE_COMPILE_FLAGS):
New variables.
(compile-onefile, .el.elc, compile-calc, recompile): Use them.
(COMPILE_FIRST): Add macroexp and cconv.
* lisp/makefile.w32-in: Mirror changes in Makefile.in.
* lisp/vc/cvs-status.el:
* lisp/vc/diff-mode.el:
* lisp/vc/log-edit.el:
* lisp/vc/log-view.el:
* lisp/vc/smerge-mode.el:
* lisp/textmodes/bibtex-style.el:
* textmodes/css.el:
* lisp/startup.el:
* lisp/uniquify.el:
* lisp/minibuffer.el:
* lisp/newcomment.el:
* lisp/reveal.el:
* lisp/server.el:
* lisp/mpc.el:
* lisp/emacs-lisp/smie.el:
* lisp/doc-view.el:
* lisp/dired.el:
* lisp/abbrev.el: Use lexical binding.
* lisp/custom.el (custom-initialize-default, custom-declare-variable):
Use `defvar'.
* lisp/files.el (lexical-binding): Declare safe.
* lisp/help-fns.el (help-split-fundoc): Return nil if there's nothing else
than the arglist.
(help-add-fundoc-usage): Don't add `Not documented'.
(help-function-arglist): Handle closures, subroutines, and new
byte-code-functions.
(help-make-usage): Remove leading underscores.
(describe-function-1): Handle closures.
(describe-variable): Use special-variable-p for completion.
* lisp/simple.el (with-wrapper-hook, apply-partially): Move to subr.el.
* lisp/subr.el (apply-partially): Use new closures rather than CL.
(--dolist-tail--, --dotimes-limit--): Don't declare dynamic.
(dolist, dotimes): Use slightly different expansion for lexical code.
(functionp): Move to C.
(letrec): New macro.
(with-wrapper-hook): Use it and apply-partially instead of CL.
(eval-after-load): Preserve lexical-binding.
(save-window-excursion, with-output-to-temp-buffer): Turn them
into macros.
* lisp/emacs-lisp/advice.el (ad-arglist): Use help-function-arglist.
* lisp/emacs-lisp/autoload.el (make-autoload): Don't burp on trivial macros.
* lisp/emacs-lisp/byte-opt.el: Use lexical binding.
(byte-inline-lapcode): Remove (to bytecomp).
(byte-compile-inline-expand): Pay attention to inlining to/from
lexically bound code.
(byte-compile-unfold-lambda): Don't handle byte-code-functions
any more.
(byte-optimize-form-code-walker): Don't handle save-window-excursion
any more and don't call compiler-macros.
(byte-compile-splice-in-already-compiled-code): Remove.
(byte-code): Don't inline any more.
(disassemble-offset): Receive `bytes' as argument rather than via
dynamic scoping.
(byte-compile-tag-number): Declare before first use.
(byte-decompile-bytecode-1): Handle new byte-codes, don't change
`return' even if make-spliceable.
(byte-compile-side-effect-and-error-free-ops): Add stack-ref, remove
obsolete interactive-p.
(byte-optimize-lapcode): Optimize new lap-codes.
Don't trip up on new form of `byte-constant' lap code.
* lisp/emacs-lisp/byte-run.el (make-obsolete): Don't set the `byte-compile'
handler any more.
* lisp/emacs-lisp/bytecomp.el: Use lexical binding instead of
a "bytecomp-" prefix. Macroexpand everything as a separate phase.
(byte-compile-initial-macro-environment):
Handle declare-function here.
(byte-compile--lexical-environment): New var.
(byte-stack-ref, byte-stack-set, byte-discardN)
(byte-discardN-preserve-tos): New lap codes.
(byte-interactive-p): Don't use any more.
(byte-compile-push-bytecodes, byte-compile-push-bytecode-const2):
New macros.
(byte-compile-lapcode): Use them and handle new lap codes.
(byte-compile-obsolete): Remove.
(byte-compile-arglist-signature): Handle new byte-code arg"lists".
(byte-compile-arglist-warn): Check late def of inlinable funs.
(byte-compile-cl-warn): Don't silence warnings for compiler-macros
since they should have been expanded by now.
(byte-compile--outbuffer): Rename from bytecomp-outbuffer.
(byte-compile-from-buffer): Remove unused second arg.
(byte-compile-preprocess): New function.
(byte-compile-toplevel-file-form): New function to distinguish
file-form calls from outside from file-form calls from hunk-handlers.
(byte-compile-file-form): Simplify.
(byte-compile-file-form-defsubst): Remove.
(byte-compile-file-form-defmumble): Simplify now that
byte-compile-lambda always returns a byte-code-function.
(byte-compile): Preprocess.
(byte-compile-byte-code-maker, byte-compile-byte-code-unmake):
Remove, not used any more.
(byte-compile-arglist-vars, byte-compile-make-lambda-lexenv)
(byte-compile-make-args-desc): New funs.
(byte-compile-lambda): Handle lexical functions. Always return
a byte-code-function.
(byte-compile-reserved-constants): New var, to make up room for
closed-over variables.
(byte-compile-constants-vector): Obey it.
(byte-compile-top-level): New args `lexenv' and `reserved-csts'.
(byte-compile-macroexpand-declare-function): New function.
(byte-compile-form): Call byte-compile-unfold-bcf to inline immediate
byte-code-functions.
(byte-compile-form): Check obsolescence here.
(byte-compile-inline-lapcode, byte-compile-unfold-bcf): New functions.
(byte-compile-variable-ref): Remove.
(byte-compile-dynamic-variable-op): New fun.
(byte-compile-dynamic-variable-bind, byte-compile-variable-ref)
(byte-compile-variable-set): New funs.
(byte-compile-discard): Add 2 args.
(byte-compile-stack-ref, byte-compile-stack-set)
(byte-compile-make-closure, byte-compile-get-closed-var): New funs.
(byte-compile-funarg, byte-compile-funarg-2): Remove, handled in
macroexpand-all instead.
(byte-compile-quote-form): Remove.
(byte-compile-push-binding-init, byte-compile-not-lexical-var-p)
(byte-compile-bind, byte-compile-unbind): New funs.
(byte-compile-let): Handle let* and lexical binding.
(byte-compile-let*): Remove.
(byte-compile-catch, byte-compile-unwind-protect)
(byte-compile-track-mouse, byte-compile-condition-case):
Handle a new :fun-body form, used for lexical scoping.
(byte-compile-save-window-excursion)
(byte-compile-with-output-to-temp-buffer): Remove.
(byte-compile-defun): Simplify.
(byte-compile-stack-adjustment): New fun.
(byte-compile-out): Use it.
(byte-compile-refresh-preloaded): Don't reload byte-compiler files.
* lisp/emacs-lisp/cconv.el: New file.
* lisp/emacs-lisp/cl-extra.el (cl-macroexpand-all): Properly quote CL
closures.
* lisp/emacs-lisp/cl-macs.el (cl-byte-compile-block)
(cl-byte-compile-throw): Remove.
(cl-block-wrapper, cl-block-throw): Use compiler-macros instead.
* lisp/emacs-lisp/cl.el (pushnew): Silence warning.
* lisp/emacs-lisp/disass.el (disassemble-internal): Handle new
`closure' objects.
(disassemble-1): Handle new byte codes.
* lisp/emacs-lisp/edebug.el (edebug-eval-defun)
(edebug-eval-top-level-form): Use eval-sexp-add-defvars.
(edebug-toggle): Avoid `eval'.
* lisp/emacs-lisp/eieio-comp.el: Remove.
* lisp/emacs-lisp/eieio.el (byte-compile-file-form-defmethod):
Don't autoload.
(eieio-defgeneric-form-primary-only-one): Use `byte-compile' rather
than the internal `byte-compile-lambda'.
(defmethod): Don't hide code under quotes.
(eieio-defmethod): New `code' argument.
* lisp/emacs-lisp/float-sup.el (pi): Don't declare as dynamically bound.
* lisp/emacs-lisp/lisp-mode.el (eval-last-sexp-1):
Use eval-sexp-add-defvars.
(eval-sexp-add-defvars): New fun.
* lisp/emacs-lisp/macroexp.el: Use lexical binding.
(macroexpand-all-1): Check obsolete macros. Expand compiler-macros.
Don't convert ' to #' without checking that it's indeed quoting
a lambda.
* lisp/emacs-lisp/pcase.el: Don't use destructuring-bind.
(pcase--memoize): Rename from pcase-memoize. Change weakness.
(pcase): Add `let' pattern.
Change memoization so it actually works.
(pcase-mutually-exclusive-predicates): Add byte-code-function-p.
(pcase--u1) <guard, pred>: Fix possible shadowing problem.
<let>: New case.
* src/alloc.c (Fmake_symbol): Init new `declared_special' field.
* src/buffer.c (defvar_per_buffer): Set new `declared_special' field.
* src/bytecode.c (Bstack_ref, Bstack_set, Bstack_set2, BdiscardN):
New byte-codes.
(exec_byte_code): New function extracted from Fbyte_code to handle new
calling convention for byte-code-functions. Add new byte-codes.
* src/callint.c (Fcall_interactively): Preserve lexical-binding mode for
interactive spec.
* src/doc.c (Fdocumentation, store_function_docstring):
* src/data.c (Finteractive_form): Handle closures.
* src/eval.c (Fsetq): Handle lexical vars.
(Fdefun, Fdefmacro, Ffunction): Make closures when needed.
(Fdefconst, Fdefvaralias, Fdefvar): Mark as dynamic.
(FletX, Flet): Obey lexical binding.
(Fcommandp): Handle closures.
(Feval): New `lexical' arg.
(eval_sub): New function extracted from Feval. Use it almost
everywhere where Feval was used. Look up vars in lexical env.
Handle closures.
(Ffunctionp): Move from subr.el.
(Ffuncall): Handle closures.
(apply_lambda): Remove `eval_flags'.
(funcall_lambda): Handle closures and new byte-code-functions.
(Fspecial_variable_p): New function.
(syms_of_eval): Initialize the Vinternal_interpreter_environment var,
but without exporting it to Lisp.
* src/fns.c (concat, mapcar1): Accept byte-code-functions.
* src/image.c (parse_image_spec): Use Ffunctionp.
* src/keyboard.c (eval_dyn): New fun.
(menu_item_eval_property): Use it.
* src/lisp.h (struct Lisp_Symbol): New field `declared_special'.
* src/lread.c (lisp_file_lexically_bound_p): New function.
(Fload): Bind Qlexical_binding.
(readevalloop): Remove `evalfun' arg.
Bind Qinternal_interpreter_environment.
(Feval_buffer): Bind Qlexical_binding.
(defvar_int, defvar_bool, defvar_lisp_nopro, defvar_kboard):
Mark as dynamic.
(syms_of_lread): Declare `lexical-binding'.
* src/window.c (Ftemp_output_buffer_show): New fun.
(Fsave_window_excursion):
* src/print.c (Fwith_output_to_temp_buffer): Move to subr.el.
2011-04-01 17:19:52 +00:00
|
|
|
|
(completing-read prompt 'read-file-name-internal
|
|
|
|
|
pred mustmatch insdef
|
|
|
|
|
'file-name-history default-filename)))
|
|
|
|
|
;; If DEFAULT-FILENAME not supplied and DIR contains
|
|
|
|
|
;; a file name, split it.
|
|
|
|
|
(let ((file (file-name-nondirectory dir))
|
|
|
|
|
;; When using a dialog, revert to nil and non-nil
|
|
|
|
|
;; interpretation of mustmatch. confirm options
|
|
|
|
|
;; need to be interpreted as nil, otherwise
|
|
|
|
|
;; it is impossible to create new files using
|
|
|
|
|
;; dialogs with the default settings.
|
|
|
|
|
(dialog-mustmatch
|
|
|
|
|
(not (memq mustmatch
|
|
|
|
|
'(nil confirm confirm-after-completion)))))
|
|
|
|
|
(when (and (not default-filename)
|
|
|
|
|
(not (zerop (length file))))
|
|
|
|
|
(setq default-filename file)
|
|
|
|
|
(setq dir (file-name-directory dir)))
|
|
|
|
|
(when default-filename
|
|
|
|
|
(setq default-filename
|
|
|
|
|
(expand-file-name (if (consp default-filename)
|
|
|
|
|
(car default-filename)
|
|
|
|
|
default-filename)
|
|
|
|
|
dir)))
|
|
|
|
|
(setq add-to-history t)
|
|
|
|
|
(x-file-dialog prompt dir default-filename
|
|
|
|
|
dialog-mustmatch
|
|
|
|
|
(eq predicate 'file-directory-p)))))
|
|
|
|
|
|
|
|
|
|
(replace-in-history (eq (car-safe file-name-history) val)))
|
|
|
|
|
;; If completing-read returned the inserted default string itself
|
|
|
|
|
;; (rather than a new string with the same contents),
|
|
|
|
|
;; it has to mean that the user typed RET with the minibuffer empty.
|
|
|
|
|
;; In that case, we really want to return ""
|
|
|
|
|
;; so that commands such as set-visited-file-name can distinguish.
|
|
|
|
|
(when (consp default-filename)
|
|
|
|
|
(setq default-filename (car default-filename)))
|
|
|
|
|
(when (eq val default-filename)
|
|
|
|
|
;; In this case, completing-read has not added an element
|
|
|
|
|
;; to the history. Maybe we should.
|
|
|
|
|
(if (not replace-in-history)
|
|
|
|
|
(setq add-to-history t))
|
|
|
|
|
(setq val ""))
|
|
|
|
|
(unless val (error "No file name specified"))
|
|
|
|
|
|
|
|
|
|
(if (and default-filename
|
|
|
|
|
(string-equal val (if (consp insdef) (car insdef) insdef)))
|
|
|
|
|
(setq val default-filename))
|
|
|
|
|
(setq val (substitute-in-file-name val))
|
|
|
|
|
|
|
|
|
|
(if replace-in-history
|
|
|
|
|
;; Replace what Fcompleting_read added to the history
|
|
|
|
|
;; with what we will actually return. As an exception,
|
|
|
|
|
;; if that's the same as the second item in
|
|
|
|
|
;; file-name-history, it's really a repeat (Bug#4657).
|
|
|
|
|
(let ((val1 (minibuffer--double-dollars val)))
|
|
|
|
|
(if history-delete-duplicates
|
|
|
|
|
(setcdr file-name-history
|
|
|
|
|
(delete val1 (cdr file-name-history))))
|
|
|
|
|
(if (string= val1 (cadr file-name-history))
|
|
|
|
|
(pop file-name-history)
|
|
|
|
|
(setcar file-name-history val1)))
|
|
|
|
|
(if add-to-history
|
|
|
|
|
;; Add the value to the history--but not if it matches
|
|
|
|
|
;; the last value already there.
|
2008-04-23 18:19:57 +00:00
|
|
|
|
(let ((val1 (minibuffer--double-dollars val)))
|
Merge from lexical-binding branch.
* doc/lispref/eval.texi (Eval): Discourage the use of `eval'.
Document its new `lexical' argument.
* doc/lispref/variables.texi (Defining Variables): Mention the new meaning of `defvar'.
(Lexical Binding): New sub-section.
* lisp/Makefile.in (BIG_STACK_DEPTH, BIG_STACK_OPTS, BYTE_COMPILE_FLAGS):
New variables.
(compile-onefile, .el.elc, compile-calc, recompile): Use them.
(COMPILE_FIRST): Add macroexp and cconv.
* lisp/makefile.w32-in: Mirror changes in Makefile.in.
* lisp/vc/cvs-status.el:
* lisp/vc/diff-mode.el:
* lisp/vc/log-edit.el:
* lisp/vc/log-view.el:
* lisp/vc/smerge-mode.el:
* lisp/textmodes/bibtex-style.el:
* textmodes/css.el:
* lisp/startup.el:
* lisp/uniquify.el:
* lisp/minibuffer.el:
* lisp/newcomment.el:
* lisp/reveal.el:
* lisp/server.el:
* lisp/mpc.el:
* lisp/emacs-lisp/smie.el:
* lisp/doc-view.el:
* lisp/dired.el:
* lisp/abbrev.el: Use lexical binding.
* lisp/custom.el (custom-initialize-default, custom-declare-variable):
Use `defvar'.
* lisp/files.el (lexical-binding): Declare safe.
* lisp/help-fns.el (help-split-fundoc): Return nil if there's nothing else
than the arglist.
(help-add-fundoc-usage): Don't add `Not documented'.
(help-function-arglist): Handle closures, subroutines, and new
byte-code-functions.
(help-make-usage): Remove leading underscores.
(describe-function-1): Handle closures.
(describe-variable): Use special-variable-p for completion.
* lisp/simple.el (with-wrapper-hook, apply-partially): Move to subr.el.
* lisp/subr.el (apply-partially): Use new closures rather than CL.
(--dolist-tail--, --dotimes-limit--): Don't declare dynamic.
(dolist, dotimes): Use slightly different expansion for lexical code.
(functionp): Move to C.
(letrec): New macro.
(with-wrapper-hook): Use it and apply-partially instead of CL.
(eval-after-load): Preserve lexical-binding.
(save-window-excursion, with-output-to-temp-buffer): Turn them
into macros.
* lisp/emacs-lisp/advice.el (ad-arglist): Use help-function-arglist.
* lisp/emacs-lisp/autoload.el (make-autoload): Don't burp on trivial macros.
* lisp/emacs-lisp/byte-opt.el: Use lexical binding.
(byte-inline-lapcode): Remove (to bytecomp).
(byte-compile-inline-expand): Pay attention to inlining to/from
lexically bound code.
(byte-compile-unfold-lambda): Don't handle byte-code-functions
any more.
(byte-optimize-form-code-walker): Don't handle save-window-excursion
any more and don't call compiler-macros.
(byte-compile-splice-in-already-compiled-code): Remove.
(byte-code): Don't inline any more.
(disassemble-offset): Receive `bytes' as argument rather than via
dynamic scoping.
(byte-compile-tag-number): Declare before first use.
(byte-decompile-bytecode-1): Handle new byte-codes, don't change
`return' even if make-spliceable.
(byte-compile-side-effect-and-error-free-ops): Add stack-ref, remove
obsolete interactive-p.
(byte-optimize-lapcode): Optimize new lap-codes.
Don't trip up on new form of `byte-constant' lap code.
* lisp/emacs-lisp/byte-run.el (make-obsolete): Don't set the `byte-compile'
handler any more.
* lisp/emacs-lisp/bytecomp.el: Use lexical binding instead of
a "bytecomp-" prefix. Macroexpand everything as a separate phase.
(byte-compile-initial-macro-environment):
Handle declare-function here.
(byte-compile--lexical-environment): New var.
(byte-stack-ref, byte-stack-set, byte-discardN)
(byte-discardN-preserve-tos): New lap codes.
(byte-interactive-p): Don't use any more.
(byte-compile-push-bytecodes, byte-compile-push-bytecode-const2):
New macros.
(byte-compile-lapcode): Use them and handle new lap codes.
(byte-compile-obsolete): Remove.
(byte-compile-arglist-signature): Handle new byte-code arg"lists".
(byte-compile-arglist-warn): Check late def of inlinable funs.
(byte-compile-cl-warn): Don't silence warnings for compiler-macros
since they should have been expanded by now.
(byte-compile--outbuffer): Rename from bytecomp-outbuffer.
(byte-compile-from-buffer): Remove unused second arg.
(byte-compile-preprocess): New function.
(byte-compile-toplevel-file-form): New function to distinguish
file-form calls from outside from file-form calls from hunk-handlers.
(byte-compile-file-form): Simplify.
(byte-compile-file-form-defsubst): Remove.
(byte-compile-file-form-defmumble): Simplify now that
byte-compile-lambda always returns a byte-code-function.
(byte-compile): Preprocess.
(byte-compile-byte-code-maker, byte-compile-byte-code-unmake):
Remove, not used any more.
(byte-compile-arglist-vars, byte-compile-make-lambda-lexenv)
(byte-compile-make-args-desc): New funs.
(byte-compile-lambda): Handle lexical functions. Always return
a byte-code-function.
(byte-compile-reserved-constants): New var, to make up room for
closed-over variables.
(byte-compile-constants-vector): Obey it.
(byte-compile-top-level): New args `lexenv' and `reserved-csts'.
(byte-compile-macroexpand-declare-function): New function.
(byte-compile-form): Call byte-compile-unfold-bcf to inline immediate
byte-code-functions.
(byte-compile-form): Check obsolescence here.
(byte-compile-inline-lapcode, byte-compile-unfold-bcf): New functions.
(byte-compile-variable-ref): Remove.
(byte-compile-dynamic-variable-op): New fun.
(byte-compile-dynamic-variable-bind, byte-compile-variable-ref)
(byte-compile-variable-set): New funs.
(byte-compile-discard): Add 2 args.
(byte-compile-stack-ref, byte-compile-stack-set)
(byte-compile-make-closure, byte-compile-get-closed-var): New funs.
(byte-compile-funarg, byte-compile-funarg-2): Remove, handled in
macroexpand-all instead.
(byte-compile-quote-form): Remove.
(byte-compile-push-binding-init, byte-compile-not-lexical-var-p)
(byte-compile-bind, byte-compile-unbind): New funs.
(byte-compile-let): Handle let* and lexical binding.
(byte-compile-let*): Remove.
(byte-compile-catch, byte-compile-unwind-protect)
(byte-compile-track-mouse, byte-compile-condition-case):
Handle a new :fun-body form, used for lexical scoping.
(byte-compile-save-window-excursion)
(byte-compile-with-output-to-temp-buffer): Remove.
(byte-compile-defun): Simplify.
(byte-compile-stack-adjustment): New fun.
(byte-compile-out): Use it.
(byte-compile-refresh-preloaded): Don't reload byte-compiler files.
* lisp/emacs-lisp/cconv.el: New file.
* lisp/emacs-lisp/cl-extra.el (cl-macroexpand-all): Properly quote CL
closures.
* lisp/emacs-lisp/cl-macs.el (cl-byte-compile-block)
(cl-byte-compile-throw): Remove.
(cl-block-wrapper, cl-block-throw): Use compiler-macros instead.
* lisp/emacs-lisp/cl.el (pushnew): Silence warning.
* lisp/emacs-lisp/disass.el (disassemble-internal): Handle new
`closure' objects.
(disassemble-1): Handle new byte codes.
* lisp/emacs-lisp/edebug.el (edebug-eval-defun)
(edebug-eval-top-level-form): Use eval-sexp-add-defvars.
(edebug-toggle): Avoid `eval'.
* lisp/emacs-lisp/eieio-comp.el: Remove.
* lisp/emacs-lisp/eieio.el (byte-compile-file-form-defmethod):
Don't autoload.
(eieio-defgeneric-form-primary-only-one): Use `byte-compile' rather
than the internal `byte-compile-lambda'.
(defmethod): Don't hide code under quotes.
(eieio-defmethod): New `code' argument.
* lisp/emacs-lisp/float-sup.el (pi): Don't declare as dynamically bound.
* lisp/emacs-lisp/lisp-mode.el (eval-last-sexp-1):
Use eval-sexp-add-defvars.
(eval-sexp-add-defvars): New fun.
* lisp/emacs-lisp/macroexp.el: Use lexical binding.
(macroexpand-all-1): Check obsolete macros. Expand compiler-macros.
Don't convert ' to #' without checking that it's indeed quoting
a lambda.
* lisp/emacs-lisp/pcase.el: Don't use destructuring-bind.
(pcase--memoize): Rename from pcase-memoize. Change weakness.
(pcase): Add `let' pattern.
Change memoization so it actually works.
(pcase-mutually-exclusive-predicates): Add byte-code-function-p.
(pcase--u1) <guard, pred>: Fix possible shadowing problem.
<let>: New case.
* src/alloc.c (Fmake_symbol): Init new `declared_special' field.
* src/buffer.c (defvar_per_buffer): Set new `declared_special' field.
* src/bytecode.c (Bstack_ref, Bstack_set, Bstack_set2, BdiscardN):
New byte-codes.
(exec_byte_code): New function extracted from Fbyte_code to handle new
calling convention for byte-code-functions. Add new byte-codes.
* src/callint.c (Fcall_interactively): Preserve lexical-binding mode for
interactive spec.
* src/doc.c (Fdocumentation, store_function_docstring):
* src/data.c (Finteractive_form): Handle closures.
* src/eval.c (Fsetq): Handle lexical vars.
(Fdefun, Fdefmacro, Ffunction): Make closures when needed.
(Fdefconst, Fdefvaralias, Fdefvar): Mark as dynamic.
(FletX, Flet): Obey lexical binding.
(Fcommandp): Handle closures.
(Feval): New `lexical' arg.
(eval_sub): New function extracted from Feval. Use it almost
everywhere where Feval was used. Look up vars in lexical env.
Handle closures.
(Ffunctionp): Move from subr.el.
(Ffuncall): Handle closures.
(apply_lambda): Remove `eval_flags'.
(funcall_lambda): Handle closures and new byte-code-functions.
(Fspecial_variable_p): New function.
(syms_of_eval): Initialize the Vinternal_interpreter_environment var,
but without exporting it to Lisp.
* src/fns.c (concat, mapcar1): Accept byte-code-functions.
* src/image.c (parse_image_spec): Use Ffunctionp.
* src/keyboard.c (eval_dyn): New fun.
(menu_item_eval_property): Use it.
* src/lisp.h (struct Lisp_Symbol): New field `declared_special'.
* src/lread.c (lisp_file_lexically_bound_p): New function.
(Fload): Bind Qlexical_binding.
(readevalloop): Remove `evalfun' arg.
Bind Qinternal_interpreter_environment.
(Feval_buffer): Bind Qlexical_binding.
(defvar_int, defvar_bool, defvar_lisp_nopro, defvar_kboard):
Mark as dynamic.
(syms_of_lread): Declare `lexical-binding'.
* src/window.c (Ftemp_output_buffer_show): New fun.
(Fsave_window_excursion):
* src/print.c (Fwith_output_to_temp_buffer): Move to subr.el.
2011-04-01 17:19:52 +00:00
|
|
|
|
(unless (and (consp file-name-history)
|
|
|
|
|
(equal (car file-name-history) val1))
|
|
|
|
|
(setq file-name-history
|
|
|
|
|
(cons val1
|
|
|
|
|
(if history-delete-duplicates
|
|
|
|
|
(delete val1 file-name-history)
|
|
|
|
|
file-name-history)))))))
|
2011-03-21 14:55:00 +00:00
|
|
|
|
val))))
|
2008-04-23 18:19:57 +00:00
|
|
|
|
|
2008-04-22 19:47:13 +00:00
|
|
|
|
(defun internal-complete-buffer-except (&optional buffer)
|
|
|
|
|
"Perform completion on all buffers excluding BUFFER.
|
2009-02-13 10:35:40 +00:00
|
|
|
|
BUFFER nil or omitted means use the current buffer.
|
2008-04-22 19:47:13 +00:00
|
|
|
|
Like `internal-complete-buffer', but removes BUFFER from the completion list."
|
2011-02-21 20:31:07 +00:00
|
|
|
|
(let ((except (if (stringp buffer) buffer (buffer-name buffer))))
|
2008-04-22 19:47:13 +00:00
|
|
|
|
(apply-partially 'completion-table-with-predicate
|
|
|
|
|
'internal-complete-buffer
|
|
|
|
|
(lambda (name)
|
|
|
|
|
(not (equal (if (consp name) (car name) name) except)))
|
|
|
|
|
nil)))
|
|
|
|
|
|
2008-06-10 22:01:59 +00:00
|
|
|
|
;;; Old-style completion, used in Emacs-21 and Emacs-22.
|
2008-04-23 21:01:31 +00:00
|
|
|
|
|
2011-03-01 05:03:24 +00:00
|
|
|
|
(defun completion-emacs21-try-completion (string table pred _point)
|
2008-04-23 21:01:31 +00:00
|
|
|
|
(let ((completion (try-completion string table pred)))
|
|
|
|
|
(if (stringp completion)
|
|
|
|
|
(cons completion (length completion))
|
|
|
|
|
completion)))
|
|
|
|
|
|
2011-03-01 05:03:24 +00:00
|
|
|
|
(defun completion-emacs21-all-completions (string table pred _point)
|
2008-04-29 05:36:55 +00:00
|
|
|
|
(completion-hilit-commonality
|
2008-06-10 22:01:59 +00:00
|
|
|
|
(all-completions string table pred)
|
2008-12-21 05:20:06 +00:00
|
|
|
|
(length string)
|
|
|
|
|
(car (completion-boundaries string table pred ""))))
|
2008-04-23 21:01:31 +00:00
|
|
|
|
|
|
|
|
|
(defun completion-emacs22-try-completion (string table pred point)
|
|
|
|
|
(let ((suffix (substring string point))
|
|
|
|
|
(completion (try-completion (substring string 0 point) table pred)))
|
|
|
|
|
(if (not (stringp completion))
|
|
|
|
|
completion
|
|
|
|
|
;; Merge a trailing / in completion with a / after point.
|
|
|
|
|
;; We used to only do it for word completion, but it seems to make
|
|
|
|
|
;; sense for all completions.
|
2008-04-26 01:47:11 +00:00
|
|
|
|
;; Actually, claiming this feature was part of Emacs-22 completion
|
|
|
|
|
;; is pushing it a bit: it was only done in minibuffer-completion-word,
|
|
|
|
|
;; which was (by default) not bound during file completion, where such
|
|
|
|
|
;; slashes are most likely to occur.
|
|
|
|
|
(if (and (not (zerop (length completion)))
|
|
|
|
|
(eq ?/ (aref completion (1- (length completion))))
|
2008-04-23 21:01:31 +00:00
|
|
|
|
(not (zerop (length suffix)))
|
|
|
|
|
(eq ?/ (aref suffix 0)))
|
2008-04-26 01:47:11 +00:00
|
|
|
|
;; This leaves point after the / .
|
|
|
|
|
(setq suffix (substring suffix 1)))
|
2008-04-23 21:01:31 +00:00
|
|
|
|
(cons (concat completion suffix) (length completion)))))
|
|
|
|
|
|
|
|
|
|
(defun completion-emacs22-all-completions (string table pred point)
|
2008-12-21 05:20:06 +00:00
|
|
|
|
(let ((beforepoint (substring string 0 point)))
|
|
|
|
|
(completion-hilit-commonality
|
|
|
|
|
(all-completions beforepoint table pred)
|
|
|
|
|
point
|
|
|
|
|
(car (completion-boundaries beforepoint table pred "")))))
|
2008-04-23 21:01:31 +00:00
|
|
|
|
|
2008-06-10 22:01:59 +00:00
|
|
|
|
;;; Basic completion.
|
|
|
|
|
|
|
|
|
|
(defun completion--merge-suffix (completion point suffix)
|
|
|
|
|
"Merge end of COMPLETION with beginning of SUFFIX.
|
|
|
|
|
Simple generalization of the \"merge trailing /\" done in Emacs-22.
|
|
|
|
|
Return the new suffix."
|
|
|
|
|
(if (and (not (zerop (length suffix)))
|
|
|
|
|
(string-match "\\(.+\\)\n\\1" (concat completion "\n" suffix)
|
|
|
|
|
;; Make sure we don't compress things to less
|
|
|
|
|
;; than we started with.
|
|
|
|
|
point)
|
|
|
|
|
;; Just make sure we didn't match some other \n.
|
|
|
|
|
(eq (match-end 1) (length completion)))
|
|
|
|
|
(substring suffix (- (match-end 1) (match-beginning 1)))
|
|
|
|
|
;; Nothing to merge.
|
|
|
|
|
suffix))
|
|
|
|
|
|
2010-03-23 00:59:49 +00:00
|
|
|
|
(defun completion-basic--pattern (beforepoint afterpoint bounds)
|
|
|
|
|
(delete
|
|
|
|
|
"" (list (substring beforepoint (car bounds))
|
|
|
|
|
'point
|
|
|
|
|
(substring afterpoint 0 (cdr bounds)))))
|
|
|
|
|
|
2008-04-26 01:47:11 +00:00
|
|
|
|
(defun completion-basic-try-completion (string table pred point)
|
2011-02-21 20:31:07 +00:00
|
|
|
|
(let* ((beforepoint (substring string 0 point))
|
|
|
|
|
(afterpoint (substring string point))
|
|
|
|
|
(bounds (completion-boundaries beforepoint table pred afterpoint)))
|
2008-06-26 02:48:56 +00:00
|
|
|
|
(if (zerop (cdr bounds))
|
|
|
|
|
;; `try-completion' may return a subtly different result
|
|
|
|
|
;; than `all+merge', so try to use it whenever possible.
|
|
|
|
|
(let ((completion (try-completion beforepoint table pred)))
|
|
|
|
|
(if (not (stringp completion))
|
|
|
|
|
completion
|
|
|
|
|
(cons
|
|
|
|
|
(concat completion
|
|
|
|
|
(completion--merge-suffix completion point afterpoint))
|
|
|
|
|
(length completion))))
|
2011-02-21 20:31:07 +00:00
|
|
|
|
(let* ((suffix (substring afterpoint (cdr bounds)))
|
|
|
|
|
(prefix (substring beforepoint 0 (car bounds)))
|
|
|
|
|
(pattern (delete
|
|
|
|
|
"" (list (substring beforepoint (car bounds))
|
|
|
|
|
'point
|
|
|
|
|
(substring afterpoint 0 (cdr bounds)))))
|
|
|
|
|
(all (completion-pcm--all-completions prefix pattern table pred)))
|
2008-06-26 02:48:56 +00:00
|
|
|
|
(if minibuffer-completing-file-name
|
|
|
|
|
(setq all (completion-pcm--filename-try-filter all)))
|
|
|
|
|
(completion-pcm--merge-try pattern all prefix suffix)))))
|
|
|
|
|
|
|
|
|
|
(defun completion-basic-all-completions (string table pred point)
|
2011-02-21 20:31:07 +00:00
|
|
|
|
(let* ((beforepoint (substring string 0 point))
|
|
|
|
|
(afterpoint (substring string point))
|
|
|
|
|
(bounds (completion-boundaries beforepoint table pred afterpoint))
|
2011-03-01 05:03:24 +00:00
|
|
|
|
;; (suffix (substring afterpoint (cdr bounds)))
|
2011-02-21 20:31:07 +00:00
|
|
|
|
(prefix (substring beforepoint 0 (car bounds)))
|
|
|
|
|
(pattern (delete
|
|
|
|
|
"" (list (substring beforepoint (car bounds))
|
|
|
|
|
'point
|
|
|
|
|
(substring afterpoint 0 (cdr bounds)))))
|
|
|
|
|
(all (completion-pcm--all-completions prefix pattern table pred)))
|
2008-12-21 05:20:06 +00:00
|
|
|
|
(completion-hilit-commonality all point (car bounds))))
|
2008-04-23 21:01:31 +00:00
|
|
|
|
|
2008-04-26 01:47:11 +00:00
|
|
|
|
;;; Partial-completion-mode style completion.
|
|
|
|
|
|
2009-08-19 02:15:19 +00:00
|
|
|
|
(defvar completion-pcm--delim-wild-regex nil
|
|
|
|
|
"Regular expression matching delimiters controlling the partial-completion.
|
|
|
|
|
Typically, this regular expression simply matches a delimiter, meaning
|
|
|
|
|
that completion can add something at (match-beginning 0), but if it has
|
|
|
|
|
a submatch 1, then completion can add something at (match-end 1).
|
|
|
|
|
This is used when the delimiter needs to be of size zero (e.g. the transition
|
|
|
|
|
from lowercase to uppercase characters).")
|
2008-04-26 01:47:11 +00:00
|
|
|
|
|
|
|
|
|
(defun completion-pcm--prepare-delim-re (delims)
|
|
|
|
|
(setq completion-pcm--delim-wild-regex (concat "[" delims "*]")))
|
|
|
|
|
|
2011-05-24 02:45:50 +00:00
|
|
|
|
(defcustom completion-pcm-word-delimiters "-_./:| "
|
2008-04-26 01:47:11 +00:00
|
|
|
|
"A string of characters treated as word delimiters for completion.
|
|
|
|
|
Some arcane rules:
|
|
|
|
|
If `]' is in this string, it must come first.
|
|
|
|
|
If `^' is in this string, it must not come first.
|
|
|
|
|
If `-' is in this string, it must come first or right after `]'.
|
|
|
|
|
In other words, if S is this string, then `[S]' must be a valid Emacs regular
|
|
|
|
|
expression (not containing character ranges like `a-z')."
|
|
|
|
|
:set (lambda (symbol value)
|
|
|
|
|
(set-default symbol value)
|
|
|
|
|
;; Refresh other vars.
|
|
|
|
|
(completion-pcm--prepare-delim-re value))
|
|
|
|
|
:initialize 'custom-initialize-reset
|
|
|
|
|
:type 'string)
|
|
|
|
|
|
2010-05-09 22:39:36 +00:00
|
|
|
|
(defcustom completion-pcm-complete-word-inserts-delimiters nil
|
|
|
|
|
"Treat the SPC or - inserted by `minibuffer-complete-word' as delimiters.
|
|
|
|
|
Those chars are treated as delimiters iff this variable is non-nil.
|
|
|
|
|
I.e. if non-nil, M-x SPC will just insert a \"-\" in the minibuffer, whereas
|
|
|
|
|
if nil, it will list all possible commands in *Completions* because none of
|
|
|
|
|
the commands start with a \"-\" or a SPC."
|
Add missing :version tags to new defgroups and defcustoms
* window.el (window-sides-slots):
* tool-bar.el (tool-bar-position):
* term/xterm.el (xterm-extra-capabilities):
* ses.el (ses-self-reference-early-detection):
* progmodes/verilog-mode.el (verilog-auto-declare-nettype)
(verilog-auto-wire-type)
(verilog-auto-delete-trailing-whitespace)
(verilog-auto-reset-blocking-in-non, verilog-auto-inst-sort)
(verilog-auto-tieoff-declaration):
* progmodes/sql.el (sql-login-hook, sql-ansi-statement-starters)
(sql-oracle-statement-starters, sql-oracle-scan-on):
* progmodes/prolog.el (prolog-align-comments-flag)
(prolog-indent-mline-comments-flag, prolog-object-end-to-0-flag)
(prolog-left-indent-regexp, prolog-paren-indent-p)
(prolog-paren-indent, prolog-parse-mode, prolog-keywords)
(prolog-types, prolog-mode-specificators)
(prolog-determinism-specificators, prolog-directives)
(prolog-electric-newline-flag, prolog-hungry-delete-key-flag)
(prolog-electric-dot-flag)
(prolog-electric-dot-full-predicate-template)
(prolog-electric-underscore-flag, prolog-electric-tab-flag)
(prolog-electric-if-then-else-flag, prolog-electric-colon-flag)
(prolog-electric-dash-flag, prolog-old-sicstus-keys-flag)
(prolog-program-switches, prolog-prompt-regexp)
(prolog-debug-on-string, prolog-debug-off-string)
(prolog-trace-on-string, prolog-trace-off-string)
(prolog-zip-on-string, prolog-zip-off-string)
(prolog-use-standard-consult-compile-method-flag)
(prolog-use-prolog-tokenizer-flag, prolog-imenu-flag)
(prolog-imenu-max-lines, prolog-info-predicate-index)
(prolog-underscore-wordchar-flag, prolog-use-sicstus-sd)
(prolog-char-quote-workaround):
* progmodes/cc-vars.el (c-defun-tactic):
* net/tramp.el (tramp-encoding-command-interactive)
(tramp-local-end-of-line):
* net/soap-client.el (soap-client):
* net/netrc.el (netrc-file):
* net/gnutls.el (gnutls):
* minibuffer.el (completion-category-overrides)
(completion-cycle-threshold)
(completion-pcm-complete-word-inserts-delimiters):
* man.el (Man-name-local-regexp):
* mail/feedmail.el (feedmail-display-full-frame):
* international/characters.el (glyphless-char-display-control):
* eshell/em-ls.el (eshell-ls-date-format):
* emacs-lisp/cl-indent.el (lisp-lambda-list-keyword-alignment)
(lisp-lambda-list-keyword-parameter-indentation)
(lisp-lambda-list-keyword-parameter-alignment):
* doc-view.el (doc-view-image-width, doc-view-unoconv-program):
* dired-x.el (dired-omit-verbose):
* cus-theme.el (custom-theme-allow-multiple-selections):
* calc/calc.el (calc-highlight-selections-with-faces)
(calc-lu-field-reference, calc-lu-power-reference)
(calc-note-threshold):
* battery.el (battery-mode-line-limit):
* arc-mode.el (archive-7z-extract, archive-7z-expunge)
(archive-7z-update):
* allout.el (allout-prefixed-keybindings)
(allout-unprefixed-keybindings)
(allout-inhibit-auto-fill-on-headline)
(allout-flattened-numbering-abbreviation):
* allout-widgets.el (allout-widgets-auto-activation)
(allout-widgets-icons-dark-subdir)
(allout-widgets-icons-light-subdir, allout-widgets-icon-types)
(allout-widgets-theme-dark-background)
(allout-widgets-theme-light-background)
(allout-widgets-item-image-properties-emacs)
(allout-widgets-item-image-properties-xemacs)
(allout-widgets-run-unit-tests-on-load)
(allout-widgets-time-decoration-activity)
(allout-widgets-hook-error-post-time)
(allout-widgets-track-decoration):
* gnus/sieve-manage.el (sieve-manage-default-stream):
* gnus/shr.el (shr):
* gnus/nnir.el (nnir-ignored-newsgroups, nnir-summary-line-format)
(nnir-retrieve-headers-override-function)
(nnir-imap-default-search-key, nnir-notmuch-program)
(nnir-notmuch-additional-switches, nnir-notmuch-remove-prefix)
(nnir-method-default-engines):
* gnus/message.el (message-cite-reply-position):
* gnus/gssapi.el (gssapi-program):
* gnus/gravatar.el (gravatar):
* gnus/gnus-sum.el (gnus-refer-thread-use-nnir):
* gnus/gnus-registry.el (gnus-registry-unfollowed-addresses)
(gnus-registry-max-pruned-entries):
* gnus/gnus-picon.el (gnus-picon-inhibit-top-level-domains):
* gnus/gnus-int.el (gnus-after-set-mark-hook)
(gnus-before-update-mark-hook):
* gnus/gnus-async.el (gnus-async-post-fetch-function):
* gnus/auth-source.el (auth-source-cache-expiry):
Add missing :version tags to new defcustoms and defgroups.
2012-02-11 22:13:29 +00:00
|
|
|
|
:version "24.1"
|
2010-05-09 22:39:36 +00:00
|
|
|
|
:type 'boolean)
|
|
|
|
|
|
2008-04-26 01:47:11 +00:00
|
|
|
|
(defun completion-pcm--pattern-trivial-p (pattern)
|
2009-01-06 04:17:04 +00:00
|
|
|
|
(and (stringp (car pattern))
|
|
|
|
|
;; It can be followed by `point' and "" and still be trivial.
|
|
|
|
|
(let ((trivial t))
|
|
|
|
|
(dolist (elem (cdr pattern))
|
|
|
|
|
(unless (member elem '(point ""))
|
|
|
|
|
(setq trivial nil)))
|
|
|
|
|
trivial)))
|
2008-04-26 01:47:11 +00:00
|
|
|
|
|
2008-05-20 17:03:30 +00:00
|
|
|
|
(defun completion-pcm--string->pattern (string &optional point)
|
|
|
|
|
"Split STRING into a pattern.
|
2008-04-26 01:47:11 +00:00
|
|
|
|
A pattern is a list where each element is either a string
|
2011-08-15 16:10:39 +00:00
|
|
|
|
or a symbol, see `completion-pcm--merge-completions'."
|
2008-05-20 17:03:30 +00:00
|
|
|
|
(if (and point (< point (length string)))
|
|
|
|
|
(let ((prefix (substring string 0 point))
|
|
|
|
|
(suffix (substring string point)))
|
2008-04-26 01:47:11 +00:00
|
|
|
|
(append (completion-pcm--string->pattern prefix)
|
|
|
|
|
'(point)
|
|
|
|
|
(completion-pcm--string->pattern suffix)))
|
2011-03-30 22:25:57 +00:00
|
|
|
|
(let* ((pattern nil)
|
|
|
|
|
(p 0)
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(p0 p)
|
|
|
|
|
(pending nil))
|
2008-04-26 12:58:13 +00:00
|
|
|
|
|
2009-08-19 02:15:19 +00:00
|
|
|
|
(while (and (setq p (string-match completion-pcm--delim-wild-regex
|
|
|
|
|
string p))
|
2010-05-09 22:39:36 +00:00
|
|
|
|
(or completion-pcm-complete-word-inserts-delimiters
|
|
|
|
|
;; If the char was added by minibuffer-complete-word,
|
|
|
|
|
;; then don't treat it as a delimiter, otherwise
|
|
|
|
|
;; "M-x SPC" ends up inserting a "-" rather than listing
|
|
|
|
|
;; all completions.
|
|
|
|
|
(not (get-text-property p 'completion-try-word string))))
|
2009-08-19 02:15:19 +00:00
|
|
|
|
;; Usually, completion-pcm--delim-wild-regex matches a delimiter,
|
|
|
|
|
;; meaning that something can be added *before* it, but it can also
|
|
|
|
|
;; match a prefix and postfix, in which case something can be added
|
|
|
|
|
;; in-between (e.g. match [[:lower:]][[:upper:]]).
|
|
|
|
|
;; This is determined by the presence of a submatch-1 which delimits
|
|
|
|
|
;; the prefix.
|
|
|
|
|
(if (match-end 1) (setq p (match-end 1)))
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(unless (= p0 p)
|
|
|
|
|
(if pending (push pending pattern))
|
|
|
|
|
(push (substring string p0 p) pattern))
|
|
|
|
|
(setq pending nil)
|
2008-05-20 17:03:30 +00:00
|
|
|
|
(if (eq (aref string p) ?*)
|
2008-04-26 01:47:11 +00:00
|
|
|
|
(progn
|
|
|
|
|
(push 'star pattern)
|
|
|
|
|
(setq p0 (1+ p)))
|
|
|
|
|
(push 'any pattern)
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(if (match-end 1)
|
|
|
|
|
(setq p0 p)
|
|
|
|
|
(push (substring string p (match-end 0)) pattern)
|
|
|
|
|
;; `any-delim' is used so that "a-b" also finds "array->beginning".
|
|
|
|
|
(setq pending 'any-delim)
|
|
|
|
|
(setq p0 (match-end 0))))
|
|
|
|
|
(setq p p0))
|
|
|
|
|
|
|
|
|
|
(when (> (length string) p0)
|
|
|
|
|
(if pending (push pending pattern))
|
|
|
|
|
(push (substring string p0) pattern))
|
2008-04-26 01:47:11 +00:00
|
|
|
|
;; An empty string might be erroneously added at the beginning.
|
|
|
|
|
;; It should be avoided properly, but it's so easy to remove it here.
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(delete "" (nreverse pattern)))))
|
|
|
|
|
|
|
|
|
|
(defun completion-pcm--optimize-pattern (p)
|
|
|
|
|
;; Remove empty strings in a separate phase since otherwise a ""
|
|
|
|
|
;; might prevent some other optimization, as in '(any "" any).
|
|
|
|
|
(setq p (delete "" p))
|
|
|
|
|
(let ((n '()))
|
|
|
|
|
(while p
|
|
|
|
|
(pcase p
|
|
|
|
|
(`(,(and s1 (pred stringp)) ,(and s2 (pred stringp)) . ,rest)
|
|
|
|
|
(setq p (cons (concat s1 s2) rest)))
|
|
|
|
|
(`(,(and p1 (pred symbolp)) ,(and p2 (guard (eq p1 p2))) . ,_)
|
|
|
|
|
(setq p (cdr p)))
|
|
|
|
|
(`(star ,(pred symbolp) . ,rest) (setq p `(star . ,rest)))
|
|
|
|
|
(`(,(pred symbolp) star . ,rest) (setq p `(star . ,rest)))
|
|
|
|
|
(`(point ,(or `any `any-delim) . ,rest) (setq p `(point . ,rest)))
|
|
|
|
|
(`(,(or `any `any-delim) point . ,rest) (setq p `(point . ,rest)))
|
|
|
|
|
(`(any ,(or `any `any-delim) . ,rest) (setq p `(any . ,rest)))
|
|
|
|
|
(`(,(pred symbolp)) (setq p nil)) ;Implicit terminating `any'.
|
|
|
|
|
(_ (push (pop p) n))))
|
|
|
|
|
(nreverse n)))
|
2008-04-26 01:47:11 +00:00
|
|
|
|
|
|
|
|
|
(defun completion-pcm--pattern->regex (pattern &optional group)
|
2008-05-20 17:03:30 +00:00
|
|
|
|
(let ((re
|
2009-08-30 03:45:30 +00:00
|
|
|
|
(concat "\\`"
|
|
|
|
|
(mapconcat
|
|
|
|
|
(lambda (x)
|
2010-05-09 22:39:36 +00:00
|
|
|
|
(cond
|
|
|
|
|
((stringp x) (regexp-quote x))
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(t
|
|
|
|
|
(let ((re (if (eq x 'any-delim)
|
|
|
|
|
(concat completion-pcm--delim-wild-regex "*?")
|
|
|
|
|
".*?")))
|
|
|
|
|
(if (if (consp group) (memq x group) group)
|
|
|
|
|
(concat "\\(" re "\\)")
|
|
|
|
|
re)))))
|
2009-08-30 03:45:30 +00:00
|
|
|
|
pattern
|
2008-09-03 14:09:49 +00:00
|
|
|
|
""))))
|
2008-05-20 17:03:30 +00:00
|
|
|
|
;; Avoid pathological backtracking.
|
|
|
|
|
(while (string-match "\\.\\*\\?\\(?:\\\\[()]\\)*\\(\\.\\*\\?\\)" re)
|
|
|
|
|
(setq re (replace-match "" t t re 1)))
|
|
|
|
|
re))
|
2008-04-26 01:47:11 +00:00
|
|
|
|
|
2008-05-20 17:03:30 +00:00
|
|
|
|
(defun completion-pcm--all-completions (prefix pattern table pred)
|
2008-04-26 01:47:11 +00:00
|
|
|
|
"Find all completions for PATTERN in TABLE obeying PRED.
|
2008-04-26 12:58:13 +00:00
|
|
|
|
PATTERN is as returned by `completion-pcm--string->pattern'."
|
Reduce use of (require 'cl).
* admin/bzrmerge.el: Use cl-lib.
* leim/quail/hangul.el: Don't require CL.
* leim/quail/ipa.el: Use cl-lib.
* vc/smerge-mode.el, vc/pcvs.el, vc/pcvs-util.el, vc/pcvs-info.el:
* vc/diff-mode.el, vc/cvs-status.el, uniquify.el, scroll-bar.el:
* register.el, progmodes/sh-script.el, net/gnutls.el, net/dbus.el:
* msb.el, mpc.el, minibuffer.el, international/ucs-normalize.el:
* international/quail.el, info-xref.el, imenu.el, image-mode.el:
* font-lock.el, filesets.el, edmacro.el, doc-view.el, bookmark.el:
* battery.el, avoid.el, abbrev.el: Use cl-lib.
* vc/pcvs-parse.el, vc/pcvs-defs.el, vc/log-view.el, vc/log-edit.el:
* vc/diff.el, simple.el, pcomplete.el, lpr.el, comint.el, loadhist.el:
* jit-lock.el, international/iso-ascii.el, info.el, frame.el, bs.el:
* emulation/crisp.el, electric.el, dired.el, cus-dep.el, composite.el:
* calculator.el, autorevert.el, apropos.el: Don't require CL.
* emacs-bytecomp.el (byte-recompile-directory, display-call-tree)
(byte-compile-unfold-bcf, byte-compile-check-variable):
* emacs-byte-opt.el (byte-compile-trueconstp)
(byte-compile-nilconstp):
* emacs-autoload.el (make-autoload): Use pcase.
* face-remap.el (text-scale-adjust): Simplify pcase patterns.
2012-07-10 11:51:54 +00:00
|
|
|
|
;; (cl-assert (= (car (completion-boundaries prefix table pred ""))
|
2008-12-21 05:20:06 +00:00
|
|
|
|
;; (length prefix)))
|
2008-04-26 01:47:11 +00:00
|
|
|
|
;; Find an initial list of possible completions.
|
|
|
|
|
(if (completion-pcm--pattern-trivial-p pattern)
|
|
|
|
|
|
|
|
|
|
;; Minibuffer contains no delimiters -- simple case!
|
2008-12-21 05:20:06 +00:00
|
|
|
|
(all-completions (concat prefix (car pattern)) table pred)
|
2008-04-26 12:58:13 +00:00
|
|
|
|
|
2008-04-26 01:47:11 +00:00
|
|
|
|
;; Use all-completions to do an initial cull. This is a big win,
|
|
|
|
|
;; since all-completions is written in C!
|
|
|
|
|
(let* (;; Convert search pattern to a standard regular expression.
|
|
|
|
|
(regex (completion-pcm--pattern->regex pattern))
|
2008-09-03 14:09:49 +00:00
|
|
|
|
(case-fold-search completion-ignore-case)
|
|
|
|
|
(completion-regexp-list (cons regex completion-regexp-list))
|
2008-04-26 01:47:11 +00:00
|
|
|
|
(compl (all-completions
|
2011-05-31 21:40:30 +00:00
|
|
|
|
(concat prefix
|
|
|
|
|
(if (stringp (car pattern)) (car pattern) ""))
|
2008-12-21 05:20:06 +00:00
|
|
|
|
table pred)))
|
2008-04-26 01:47:11 +00:00
|
|
|
|
(if (not (functionp table))
|
|
|
|
|
;; The internal functions already obeyed completion-regexp-list.
|
|
|
|
|
compl
|
2008-09-03 14:09:49 +00:00
|
|
|
|
(let ((poss ()))
|
2008-04-26 01:47:11 +00:00
|
|
|
|
(dolist (c compl)
|
2009-01-14 02:29:52 +00:00
|
|
|
|
(when (string-match-p regex c) (push c poss)))
|
2008-04-26 01:47:11 +00:00
|
|
|
|
poss)))))
|
|
|
|
|
|
2008-04-29 06:00:21 +00:00
|
|
|
|
(defun completion-pcm--hilit-commonality (pattern completions)
|
|
|
|
|
(when completions
|
|
|
|
|
(let* ((re (completion-pcm--pattern->regex pattern '(point)))
|
2009-01-06 04:17:04 +00:00
|
|
|
|
(case-fold-search completion-ignore-case))
|
|
|
|
|
(mapcar
|
|
|
|
|
(lambda (str)
|
|
|
|
|
;; Don't modify the string itself.
|
|
|
|
|
(setq str (copy-sequence str))
|
|
|
|
|
(unless (string-match re str)
|
|
|
|
|
(error "Internal error: %s does not match %s" re str))
|
|
|
|
|
(let ((pos (or (match-beginning 1) (match-end 0))))
|
|
|
|
|
(put-text-property 0 pos
|
|
|
|
|
'font-lock-face 'completions-common-part
|
|
|
|
|
str)
|
|
|
|
|
(if (> (length str) pos)
|
|
|
|
|
(put-text-property pos (1+ pos)
|
|
|
|
|
'font-lock-face 'completions-first-difference
|
|
|
|
|
str)))
|
|
|
|
|
str)
|
|
|
|
|
completions))))
|
2008-04-29 06:00:21 +00:00
|
|
|
|
|
2008-06-10 22:01:59 +00:00
|
|
|
|
(defun completion-pcm--find-all-completions (string table pred point
|
|
|
|
|
&optional filter)
|
|
|
|
|
"Find all completions for STRING at POINT in TABLE, satisfying PRED.
|
|
|
|
|
POINT is a position inside STRING.
|
|
|
|
|
FILTER is a function applied to the return value, that can be used, e.g. to
|
2011-11-19 09:18:31 +00:00
|
|
|
|
filter out additional entries (because TABLE might not obey PRED)."
|
2008-06-10 22:01:59 +00:00
|
|
|
|
(unless filter (setq filter 'identity))
|
2011-02-21 20:31:07 +00:00
|
|
|
|
(let* ((beforepoint (substring string 0 point))
|
|
|
|
|
(afterpoint (substring string point))
|
|
|
|
|
(bounds (completion-boundaries beforepoint table pred afterpoint))
|
|
|
|
|
(prefix (substring beforepoint 0 (car bounds)))
|
|
|
|
|
(suffix (substring afterpoint (cdr bounds)))
|
|
|
|
|
firsterror)
|
2008-05-23 01:58:15 +00:00
|
|
|
|
(setq string (substring string (car bounds) (+ point (cdr bounds))))
|
|
|
|
|
(let* ((relpoint (- point (car bounds)))
|
|
|
|
|
(pattern (completion-pcm--string->pattern string relpoint))
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(all (condition-case-unless-debug err
|
2008-06-10 22:01:59 +00:00
|
|
|
|
(funcall filter
|
|
|
|
|
(completion-pcm--all-completions
|
|
|
|
|
prefix pattern table pred))
|
2013-09-06 22:46:44 +00:00
|
|
|
|
(error (setq firsterror err) nil))))
|
2008-05-20 17:03:30 +00:00
|
|
|
|
(when (and (null all)
|
|
|
|
|
(> (car bounds) 0)
|
|
|
|
|
(null (ignore-errors (try-completion prefix table pred))))
|
|
|
|
|
;; The prefix has no completions at all, so we should try and fix
|
|
|
|
|
;; that first.
|
|
|
|
|
(let ((substring (substring prefix 0 -1)))
|
Reduce use of (require 'cl).
* admin/bzrmerge.el: Use cl-lib.
* leim/quail/hangul.el: Don't require CL.
* leim/quail/ipa.el: Use cl-lib.
* vc/smerge-mode.el, vc/pcvs.el, vc/pcvs-util.el, vc/pcvs-info.el:
* vc/diff-mode.el, vc/cvs-status.el, uniquify.el, scroll-bar.el:
* register.el, progmodes/sh-script.el, net/gnutls.el, net/dbus.el:
* msb.el, mpc.el, minibuffer.el, international/ucs-normalize.el:
* international/quail.el, info-xref.el, imenu.el, image-mode.el:
* font-lock.el, filesets.el, edmacro.el, doc-view.el, bookmark.el:
* battery.el, avoid.el, abbrev.el: Use cl-lib.
* vc/pcvs-parse.el, vc/pcvs-defs.el, vc/log-view.el, vc/log-edit.el:
* vc/diff.el, simple.el, pcomplete.el, lpr.el, comint.el, loadhist.el:
* jit-lock.el, international/iso-ascii.el, info.el, frame.el, bs.el:
* emulation/crisp.el, electric.el, dired.el, cus-dep.el, composite.el:
* calculator.el, autorevert.el, apropos.el: Don't require CL.
* emacs-bytecomp.el (byte-recompile-directory, display-call-tree)
(byte-compile-unfold-bcf, byte-compile-check-variable):
* emacs-byte-opt.el (byte-compile-trueconstp)
(byte-compile-nilconstp):
* emacs-autoload.el (make-autoload): Use pcase.
* face-remap.el (text-scale-adjust): Simplify pcase patterns.
2012-07-10 11:51:54 +00:00
|
|
|
|
(pcase-let ((`(,subpat ,suball ,subprefix ,_subsuffix)
|
|
|
|
|
(completion-pcm--find-all-completions
|
|
|
|
|
substring table pred (length substring) filter)))
|
2008-05-20 17:03:30 +00:00
|
|
|
|
(let ((sep (aref prefix (1- (length prefix))))
|
|
|
|
|
;; Text that goes between the new submatches and the
|
|
|
|
|
;; completion substring.
|
|
|
|
|
(between nil))
|
|
|
|
|
;; Eliminate submatches that don't end with the separator.
|
|
|
|
|
(dolist (submatch (prog1 suball (setq suball ())))
|
|
|
|
|
(when (eq sep (aref submatch (1- (length submatch))))
|
|
|
|
|
(push submatch suball)))
|
|
|
|
|
(when suball
|
|
|
|
|
;; Update the boundaries and corresponding pattern.
|
|
|
|
|
;; We assume that all submatches result in the same boundaries
|
|
|
|
|
;; since we wouldn't know how to merge them otherwise anyway.
|
2008-05-23 01:58:15 +00:00
|
|
|
|
;; FIXME: COMPLETE REWRITE!!!
|
|
|
|
|
(let* ((newbeforepoint
|
|
|
|
|
(concat subprefix (car suball)
|
|
|
|
|
(substring string 0 relpoint)))
|
|
|
|
|
(leftbound (+ (length subprefix) (length (car suball))))
|
2008-05-20 17:03:30 +00:00
|
|
|
|
(newbounds (completion-boundaries
|
2008-05-23 01:58:15 +00:00
|
|
|
|
newbeforepoint table pred afterpoint)))
|
|
|
|
|
(unless (or (and (eq (cdr bounds) (cdr newbounds))
|
|
|
|
|
(eq (car newbounds) leftbound))
|
2008-05-20 17:03:30 +00:00
|
|
|
|
;; Refuse new boundaries if they step over
|
|
|
|
|
;; the submatch.
|
2008-05-23 01:58:15 +00:00
|
|
|
|
(< (car newbounds) leftbound))
|
2008-05-20 17:03:30 +00:00
|
|
|
|
;; The new completed prefix does change the boundaries
|
|
|
|
|
;; of the completed substring.
|
2008-05-23 01:58:15 +00:00
|
|
|
|
(setq suffix (substring afterpoint (cdr newbounds)))
|
|
|
|
|
(setq string
|
|
|
|
|
(concat (substring newbeforepoint (car newbounds))
|
|
|
|
|
(substring afterpoint 0 (cdr newbounds))))
|
|
|
|
|
(setq between (substring newbeforepoint leftbound
|
2008-05-20 17:03:30 +00:00
|
|
|
|
(car newbounds)))
|
|
|
|
|
(setq pattern (completion-pcm--string->pattern
|
2008-05-23 01:58:15 +00:00
|
|
|
|
string
|
|
|
|
|
(- (length newbeforepoint)
|
|
|
|
|
(car newbounds)))))
|
2008-05-20 17:03:30 +00:00
|
|
|
|
(dolist (submatch suball)
|
2011-05-31 21:40:30 +00:00
|
|
|
|
(setq all (nconc
|
|
|
|
|
(mapcar
|
|
|
|
|
(lambda (s) (concat submatch between s))
|
|
|
|
|
(funcall filter
|
|
|
|
|
(completion-pcm--all-completions
|
|
|
|
|
(concat subprefix submatch between)
|
|
|
|
|
pattern table pred)))
|
|
|
|
|
all)))
|
2008-05-22 04:26:41 +00:00
|
|
|
|
;; FIXME: This can come in handy for try-completion,
|
|
|
|
|
;; but isn't right for all-completions, since it lists
|
|
|
|
|
;; invalid completions.
|
|
|
|
|
;; (unless all
|
|
|
|
|
;; ;; Even though we found expansions in the prefix, none
|
|
|
|
|
;; ;; leads to a valid completion.
|
|
|
|
|
;; ;; Let's keep the expansions, tho.
|
|
|
|
|
;; (dolist (submatch suball)
|
|
|
|
|
;; (push (concat submatch between newsubstring) all)))
|
|
|
|
|
))
|
2008-05-20 17:03:30 +00:00
|
|
|
|
(setq pattern (append subpat (list 'any (string sep))
|
|
|
|
|
(if between (list between)) pattern))
|
|
|
|
|
(setq prefix subprefix)))))
|
|
|
|
|
(if (and (null all) firsterror)
|
|
|
|
|
(signal (car firsterror) (cdr firsterror))
|
|
|
|
|
(list pattern all prefix suffix)))))
|
|
|
|
|
|
2008-04-26 01:47:11 +00:00
|
|
|
|
(defun completion-pcm-all-completions (string table pred point)
|
Reduce use of (require 'cl).
* admin/bzrmerge.el: Use cl-lib.
* leim/quail/hangul.el: Don't require CL.
* leim/quail/ipa.el: Use cl-lib.
* vc/smerge-mode.el, vc/pcvs.el, vc/pcvs-util.el, vc/pcvs-info.el:
* vc/diff-mode.el, vc/cvs-status.el, uniquify.el, scroll-bar.el:
* register.el, progmodes/sh-script.el, net/gnutls.el, net/dbus.el:
* msb.el, mpc.el, minibuffer.el, international/ucs-normalize.el:
* international/quail.el, info-xref.el, imenu.el, image-mode.el:
* font-lock.el, filesets.el, edmacro.el, doc-view.el, bookmark.el:
* battery.el, avoid.el, abbrev.el: Use cl-lib.
* vc/pcvs-parse.el, vc/pcvs-defs.el, vc/log-view.el, vc/log-edit.el:
* vc/diff.el, simple.el, pcomplete.el, lpr.el, comint.el, loadhist.el:
* jit-lock.el, international/iso-ascii.el, info.el, frame.el, bs.el:
* emulation/crisp.el, electric.el, dired.el, cus-dep.el, composite.el:
* calculator.el, autorevert.el, apropos.el: Don't require CL.
* emacs-bytecomp.el (byte-recompile-directory, display-call-tree)
(byte-compile-unfold-bcf, byte-compile-check-variable):
* emacs-byte-opt.el (byte-compile-trueconstp)
(byte-compile-nilconstp):
* emacs-autoload.el (make-autoload): Use pcase.
* face-remap.el (text-scale-adjust): Simplify pcase patterns.
2012-07-10 11:51:54 +00:00
|
|
|
|
(pcase-let ((`(,pattern ,all ,prefix ,_suffix)
|
|
|
|
|
(completion-pcm--find-all-completions string table pred point)))
|
2008-05-29 20:46:35 +00:00
|
|
|
|
(when all
|
|
|
|
|
(nconc (completion-pcm--hilit-commonality pattern all)
|
|
|
|
|
(length prefix)))))
|
2008-04-26 01:47:11 +00:00
|
|
|
|
|
2010-05-06 02:59:07 +00:00
|
|
|
|
(defun completion--sreverse (str)
|
|
|
|
|
"Like `reverse' but for a string STR rather than a list."
|
2012-06-23 03:48:18 +00:00
|
|
|
|
(apply #'string (nreverse (mapcar 'identity str))))
|
2010-05-06 02:59:07 +00:00
|
|
|
|
|
|
|
|
|
(defun completion--common-suffix (strs)
|
|
|
|
|
"Return the common suffix of the strings STRS."
|
|
|
|
|
(completion--sreverse
|
|
|
|
|
(try-completion
|
|
|
|
|
""
|
2012-06-23 03:48:18 +00:00
|
|
|
|
(mapcar #'completion--sreverse strs))))
|
2010-05-06 02:59:07 +00:00
|
|
|
|
|
2008-04-26 01:47:11 +00:00
|
|
|
|
(defun completion-pcm--merge-completions (strs pattern)
|
2011-08-15 16:10:39 +00:00
|
|
|
|
"Extract the commonality in STRS, with the help of PATTERN.
|
|
|
|
|
PATTERN can contain strings and symbols chosen among `star', `any', `point',
|
|
|
|
|
and `prefix'. They all match anything (aka \".*\") but are merged differently:
|
|
|
|
|
`any' only grows from the left (when matching \"a1b\" and \"a2b\" it gets
|
|
|
|
|
completed to just \"a\").
|
|
|
|
|
`prefix' only grows from the right (when matching \"a1b\" and \"a2b\" it gets
|
|
|
|
|
completed to just \"b\").
|
|
|
|
|
`star' grows from both ends and is reified into a \"*\" (when matching \"a1b\"
|
|
|
|
|
and \"a2b\" it gets completed to \"a*b\").
|
|
|
|
|
`point' is like `star' except that it gets reified as the position of point
|
|
|
|
|
instead of being reified as a \"*\" character.
|
|
|
|
|
The underlying idea is that we should return a string which still matches
|
|
|
|
|
the same set of elements."
|
2009-10-14 15:10:09 +00:00
|
|
|
|
;; When completing while ignoring case, we want to try and avoid
|
|
|
|
|
;; completing "fo" to "foO" when completing against "FOO" (bug#4219).
|
|
|
|
|
;; So we try and make sure that the string we return is all made up
|
|
|
|
|
;; of text from the completions rather than part from the
|
|
|
|
|
;; completions and part from the input.
|
|
|
|
|
;; FIXME: This reduces the problems of inconsistent capitalization
|
|
|
|
|
;; but it doesn't fully fix it: we may still end up completing
|
|
|
|
|
;; "fo-ba" to "foo-BAR" or "FOO-bar" when completing against
|
|
|
|
|
;; '("foo-barr" "FOO-BARD").
|
2008-04-26 01:47:11 +00:00
|
|
|
|
(cond
|
|
|
|
|
((null (cdr strs)) (list (car strs)))
|
|
|
|
|
(t
|
|
|
|
|
(let ((re (completion-pcm--pattern->regex pattern 'group))
|
|
|
|
|
(ccs ())) ;Chopped completions.
|
|
|
|
|
|
|
|
|
|
;; First chop each string into the parts corresponding to each
|
|
|
|
|
;; non-constant element of `pattern', using regexp-matching.
|
|
|
|
|
(let ((case-fold-search completion-ignore-case))
|
|
|
|
|
(dolist (str strs)
|
|
|
|
|
(unless (string-match re str)
|
|
|
|
|
(error "Internal error: %s doesn't match %s" str re))
|
|
|
|
|
(let ((chopped ())
|
2009-10-14 15:10:09 +00:00
|
|
|
|
(last 0)
|
|
|
|
|
(i 1)
|
|
|
|
|
next)
|
|
|
|
|
(while (setq next (match-end i))
|
|
|
|
|
(push (substring str last next) chopped)
|
|
|
|
|
(setq last next)
|
2008-04-26 01:47:11 +00:00
|
|
|
|
(setq i (1+ i)))
|
|
|
|
|
;; Add the text corresponding to the implicit trailing `any'.
|
2009-10-14 15:10:09 +00:00
|
|
|
|
(push (substring str last) chopped)
|
2008-04-26 01:47:11 +00:00
|
|
|
|
(push (nreverse chopped) ccs))))
|
|
|
|
|
|
|
|
|
|
;; Then for each of those non-constant elements, extract the
|
|
|
|
|
;; commonality between them.
|
2009-10-14 15:10:09 +00:00
|
|
|
|
(let ((res ())
|
|
|
|
|
(fixed ""))
|
|
|
|
|
;; Make the implicit trailing `any' explicit.
|
2008-04-26 01:47:11 +00:00
|
|
|
|
(dolist (elem (append pattern '(any)))
|
|
|
|
|
(if (stringp elem)
|
2009-10-14 15:10:09 +00:00
|
|
|
|
(setq fixed (concat fixed elem))
|
2008-04-26 01:47:11 +00:00
|
|
|
|
(let ((comps ()))
|
|
|
|
|
(dolist (cc (prog1 ccs (setq ccs nil)))
|
|
|
|
|
(push (car cc) comps)
|
|
|
|
|
(push (cdr cc) ccs))
|
2009-10-14 15:10:09 +00:00
|
|
|
|
;; Might improve the likelihood to avoid choosing
|
|
|
|
|
;; different capitalizations in different parts.
|
|
|
|
|
;; In practice, it doesn't seem to make any difference.
|
|
|
|
|
(setq ccs (nreverse ccs))
|
|
|
|
|
(let* ((prefix (try-completion fixed comps))
|
|
|
|
|
(unique (or (and (eq prefix t) (setq prefix fixed))
|
2008-04-26 01:47:11 +00:00
|
|
|
|
(eq t (try-completion prefix comps)))))
|
2011-08-15 16:10:39 +00:00
|
|
|
|
(unless (or (eq elem 'prefix)
|
|
|
|
|
(equal prefix ""))
|
|
|
|
|
(push prefix res))
|
2008-04-26 01:47:11 +00:00
|
|
|
|
;; If there's only one completion, `elem' is not useful
|
|
|
|
|
;; any more: it can only match the empty string.
|
|
|
|
|
;; FIXME: in some cases, it may be necessary to turn an
|
|
|
|
|
;; `any' into a `star' because the surrounding context has
|
|
|
|
|
;; changed such that string->pattern wouldn't add an `any'
|
|
|
|
|
;; here any more.
|
2010-05-06 02:59:07 +00:00
|
|
|
|
(unless unique
|
|
|
|
|
(push elem res)
|
2013-03-27 14:41:06 +00:00
|
|
|
|
;; Extract common suffix additionally to common prefix.
|
|
|
|
|
;; Don't do it for `any' since it could lead to a merged
|
|
|
|
|
;; completion that doesn't itself match the candidates.
|
|
|
|
|
(when (and (memq elem '(star point prefix))
|
|
|
|
|
;; If prefix is one of the completions, there's no
|
|
|
|
|
;; suffix left to find.
|
|
|
|
|
(not (assoc-string prefix comps t)))
|
|
|
|
|
(let ((suffix
|
|
|
|
|
(completion--common-suffix
|
|
|
|
|
(if (zerop (length prefix)) comps
|
|
|
|
|
;; Ignore the chars in the common prefix, so we
|
|
|
|
|
;; don't merge '("abc" "abbc") as "ab*bc".
|
|
|
|
|
(let ((skip (length prefix)))
|
|
|
|
|
(mapcar (lambda (str) (substring str skip))
|
|
|
|
|
comps))))))
|
Reduce use of (require 'cl).
* admin/bzrmerge.el: Use cl-lib.
* leim/quail/hangul.el: Don't require CL.
* leim/quail/ipa.el: Use cl-lib.
* vc/smerge-mode.el, vc/pcvs.el, vc/pcvs-util.el, vc/pcvs-info.el:
* vc/diff-mode.el, vc/cvs-status.el, uniquify.el, scroll-bar.el:
* register.el, progmodes/sh-script.el, net/gnutls.el, net/dbus.el:
* msb.el, mpc.el, minibuffer.el, international/ucs-normalize.el:
* international/quail.el, info-xref.el, imenu.el, image-mode.el:
* font-lock.el, filesets.el, edmacro.el, doc-view.el, bookmark.el:
* battery.el, avoid.el, abbrev.el: Use cl-lib.
* vc/pcvs-parse.el, vc/pcvs-defs.el, vc/log-view.el, vc/log-edit.el:
* vc/diff.el, simple.el, pcomplete.el, lpr.el, comint.el, loadhist.el:
* jit-lock.el, international/iso-ascii.el, info.el, frame.el, bs.el:
* emulation/crisp.el, electric.el, dired.el, cus-dep.el, composite.el:
* calculator.el, autorevert.el, apropos.el: Don't require CL.
* emacs-bytecomp.el (byte-recompile-directory, display-call-tree)
(byte-compile-unfold-bcf, byte-compile-check-variable):
* emacs-byte-opt.el (byte-compile-trueconstp)
(byte-compile-nilconstp):
* emacs-autoload.el (make-autoload): Use pcase.
* face-remap.el (text-scale-adjust): Simplify pcase patterns.
2012-07-10 11:51:54 +00:00
|
|
|
|
(cl-assert (stringp suffix))
|
2010-05-06 02:59:07 +00:00
|
|
|
|
(unless (equal suffix "")
|
|
|
|
|
(push suffix res)))))
|
2009-10-14 15:10:09 +00:00
|
|
|
|
(setq fixed "")))))
|
2008-04-26 01:47:11 +00:00
|
|
|
|
;; We return it in reverse order.
|
|
|
|
|
res)))))
|
|
|
|
|
|
|
|
|
|
(defun completion-pcm--pattern->string (pattern)
|
|
|
|
|
(mapconcat (lambda (x) (cond
|
Merge from lexical-binding branch.
* doc/lispref/eval.texi (Eval): Discourage the use of `eval'.
Document its new `lexical' argument.
* doc/lispref/variables.texi (Defining Variables): Mention the new meaning of `defvar'.
(Lexical Binding): New sub-section.
* lisp/Makefile.in (BIG_STACK_DEPTH, BIG_STACK_OPTS, BYTE_COMPILE_FLAGS):
New variables.
(compile-onefile, .el.elc, compile-calc, recompile): Use them.
(COMPILE_FIRST): Add macroexp and cconv.
* lisp/makefile.w32-in: Mirror changes in Makefile.in.
* lisp/vc/cvs-status.el:
* lisp/vc/diff-mode.el:
* lisp/vc/log-edit.el:
* lisp/vc/log-view.el:
* lisp/vc/smerge-mode.el:
* lisp/textmodes/bibtex-style.el:
* textmodes/css.el:
* lisp/startup.el:
* lisp/uniquify.el:
* lisp/minibuffer.el:
* lisp/newcomment.el:
* lisp/reveal.el:
* lisp/server.el:
* lisp/mpc.el:
* lisp/emacs-lisp/smie.el:
* lisp/doc-view.el:
* lisp/dired.el:
* lisp/abbrev.el: Use lexical binding.
* lisp/custom.el (custom-initialize-default, custom-declare-variable):
Use `defvar'.
* lisp/files.el (lexical-binding): Declare safe.
* lisp/help-fns.el (help-split-fundoc): Return nil if there's nothing else
than the arglist.
(help-add-fundoc-usage): Don't add `Not documented'.
(help-function-arglist): Handle closures, subroutines, and new
byte-code-functions.
(help-make-usage): Remove leading underscores.
(describe-function-1): Handle closures.
(describe-variable): Use special-variable-p for completion.
* lisp/simple.el (with-wrapper-hook, apply-partially): Move to subr.el.
* lisp/subr.el (apply-partially): Use new closures rather than CL.
(--dolist-tail--, --dotimes-limit--): Don't declare dynamic.
(dolist, dotimes): Use slightly different expansion for lexical code.
(functionp): Move to C.
(letrec): New macro.
(with-wrapper-hook): Use it and apply-partially instead of CL.
(eval-after-load): Preserve lexical-binding.
(save-window-excursion, with-output-to-temp-buffer): Turn them
into macros.
* lisp/emacs-lisp/advice.el (ad-arglist): Use help-function-arglist.
* lisp/emacs-lisp/autoload.el (make-autoload): Don't burp on trivial macros.
* lisp/emacs-lisp/byte-opt.el: Use lexical binding.
(byte-inline-lapcode): Remove (to bytecomp).
(byte-compile-inline-expand): Pay attention to inlining to/from
lexically bound code.
(byte-compile-unfold-lambda): Don't handle byte-code-functions
any more.
(byte-optimize-form-code-walker): Don't handle save-window-excursion
any more and don't call compiler-macros.
(byte-compile-splice-in-already-compiled-code): Remove.
(byte-code): Don't inline any more.
(disassemble-offset): Receive `bytes' as argument rather than via
dynamic scoping.
(byte-compile-tag-number): Declare before first use.
(byte-decompile-bytecode-1): Handle new byte-codes, don't change
`return' even if make-spliceable.
(byte-compile-side-effect-and-error-free-ops): Add stack-ref, remove
obsolete interactive-p.
(byte-optimize-lapcode): Optimize new lap-codes.
Don't trip up on new form of `byte-constant' lap code.
* lisp/emacs-lisp/byte-run.el (make-obsolete): Don't set the `byte-compile'
handler any more.
* lisp/emacs-lisp/bytecomp.el: Use lexical binding instead of
a "bytecomp-" prefix. Macroexpand everything as a separate phase.
(byte-compile-initial-macro-environment):
Handle declare-function here.
(byte-compile--lexical-environment): New var.
(byte-stack-ref, byte-stack-set, byte-discardN)
(byte-discardN-preserve-tos): New lap codes.
(byte-interactive-p): Don't use any more.
(byte-compile-push-bytecodes, byte-compile-push-bytecode-const2):
New macros.
(byte-compile-lapcode): Use them and handle new lap codes.
(byte-compile-obsolete): Remove.
(byte-compile-arglist-signature): Handle new byte-code arg"lists".
(byte-compile-arglist-warn): Check late def of inlinable funs.
(byte-compile-cl-warn): Don't silence warnings for compiler-macros
since they should have been expanded by now.
(byte-compile--outbuffer): Rename from bytecomp-outbuffer.
(byte-compile-from-buffer): Remove unused second arg.
(byte-compile-preprocess): New function.
(byte-compile-toplevel-file-form): New function to distinguish
file-form calls from outside from file-form calls from hunk-handlers.
(byte-compile-file-form): Simplify.
(byte-compile-file-form-defsubst): Remove.
(byte-compile-file-form-defmumble): Simplify now that
byte-compile-lambda always returns a byte-code-function.
(byte-compile): Preprocess.
(byte-compile-byte-code-maker, byte-compile-byte-code-unmake):
Remove, not used any more.
(byte-compile-arglist-vars, byte-compile-make-lambda-lexenv)
(byte-compile-make-args-desc): New funs.
(byte-compile-lambda): Handle lexical functions. Always return
a byte-code-function.
(byte-compile-reserved-constants): New var, to make up room for
closed-over variables.
(byte-compile-constants-vector): Obey it.
(byte-compile-top-level): New args `lexenv' and `reserved-csts'.
(byte-compile-macroexpand-declare-function): New function.
(byte-compile-form): Call byte-compile-unfold-bcf to inline immediate
byte-code-functions.
(byte-compile-form): Check obsolescence here.
(byte-compile-inline-lapcode, byte-compile-unfold-bcf): New functions.
(byte-compile-variable-ref): Remove.
(byte-compile-dynamic-variable-op): New fun.
(byte-compile-dynamic-variable-bind, byte-compile-variable-ref)
(byte-compile-variable-set): New funs.
(byte-compile-discard): Add 2 args.
(byte-compile-stack-ref, byte-compile-stack-set)
(byte-compile-make-closure, byte-compile-get-closed-var): New funs.
(byte-compile-funarg, byte-compile-funarg-2): Remove, handled in
macroexpand-all instead.
(byte-compile-quote-form): Remove.
(byte-compile-push-binding-init, byte-compile-not-lexical-var-p)
(byte-compile-bind, byte-compile-unbind): New funs.
(byte-compile-let): Handle let* and lexical binding.
(byte-compile-let*): Remove.
(byte-compile-catch, byte-compile-unwind-protect)
(byte-compile-track-mouse, byte-compile-condition-case):
Handle a new :fun-body form, used for lexical scoping.
(byte-compile-save-window-excursion)
(byte-compile-with-output-to-temp-buffer): Remove.
(byte-compile-defun): Simplify.
(byte-compile-stack-adjustment): New fun.
(byte-compile-out): Use it.
(byte-compile-refresh-preloaded): Don't reload byte-compiler files.
* lisp/emacs-lisp/cconv.el: New file.
* lisp/emacs-lisp/cl-extra.el (cl-macroexpand-all): Properly quote CL
closures.
* lisp/emacs-lisp/cl-macs.el (cl-byte-compile-block)
(cl-byte-compile-throw): Remove.
(cl-block-wrapper, cl-block-throw): Use compiler-macros instead.
* lisp/emacs-lisp/cl.el (pushnew): Silence warning.
* lisp/emacs-lisp/disass.el (disassemble-internal): Handle new
`closure' objects.
(disassemble-1): Handle new byte codes.
* lisp/emacs-lisp/edebug.el (edebug-eval-defun)
(edebug-eval-top-level-form): Use eval-sexp-add-defvars.
(edebug-toggle): Avoid `eval'.
* lisp/emacs-lisp/eieio-comp.el: Remove.
* lisp/emacs-lisp/eieio.el (byte-compile-file-form-defmethod):
Don't autoload.
(eieio-defgeneric-form-primary-only-one): Use `byte-compile' rather
than the internal `byte-compile-lambda'.
(defmethod): Don't hide code under quotes.
(eieio-defmethod): New `code' argument.
* lisp/emacs-lisp/float-sup.el (pi): Don't declare as dynamically bound.
* lisp/emacs-lisp/lisp-mode.el (eval-last-sexp-1):
Use eval-sexp-add-defvars.
(eval-sexp-add-defvars): New fun.
* lisp/emacs-lisp/macroexp.el: Use lexical binding.
(macroexpand-all-1): Check obsolete macros. Expand compiler-macros.
Don't convert ' to #' without checking that it's indeed quoting
a lambda.
* lisp/emacs-lisp/pcase.el: Don't use destructuring-bind.
(pcase--memoize): Rename from pcase-memoize. Change weakness.
(pcase): Add `let' pattern.
Change memoization so it actually works.
(pcase-mutually-exclusive-predicates): Add byte-code-function-p.
(pcase--u1) <guard, pred>: Fix possible shadowing problem.
<let>: New case.
* src/alloc.c (Fmake_symbol): Init new `declared_special' field.
* src/buffer.c (defvar_per_buffer): Set new `declared_special' field.
* src/bytecode.c (Bstack_ref, Bstack_set, Bstack_set2, BdiscardN):
New byte-codes.
(exec_byte_code): New function extracted from Fbyte_code to handle new
calling convention for byte-code-functions. Add new byte-codes.
* src/callint.c (Fcall_interactively): Preserve lexical-binding mode for
interactive spec.
* src/doc.c (Fdocumentation, store_function_docstring):
* src/data.c (Finteractive_form): Handle closures.
* src/eval.c (Fsetq): Handle lexical vars.
(Fdefun, Fdefmacro, Ffunction): Make closures when needed.
(Fdefconst, Fdefvaralias, Fdefvar): Mark as dynamic.
(FletX, Flet): Obey lexical binding.
(Fcommandp): Handle closures.
(Feval): New `lexical' arg.
(eval_sub): New function extracted from Feval. Use it almost
everywhere where Feval was used. Look up vars in lexical env.
Handle closures.
(Ffunctionp): Move from subr.el.
(Ffuncall): Handle closures.
(apply_lambda): Remove `eval_flags'.
(funcall_lambda): Handle closures and new byte-code-functions.
(Fspecial_variable_p): New function.
(syms_of_eval): Initialize the Vinternal_interpreter_environment var,
but without exporting it to Lisp.
* src/fns.c (concat, mapcar1): Accept byte-code-functions.
* src/image.c (parse_image_spec): Use Ffunctionp.
* src/keyboard.c (eval_dyn): New fun.
(menu_item_eval_property): Use it.
* src/lisp.h (struct Lisp_Symbol): New field `declared_special'.
* src/lread.c (lisp_file_lexically_bound_p): New function.
(Fload): Bind Qlexical_binding.
(readevalloop): Remove `evalfun' arg.
Bind Qinternal_interpreter_environment.
(Feval_buffer): Bind Qlexical_binding.
(defvar_int, defvar_bool, defvar_lisp_nopro, defvar_kboard):
Mark as dynamic.
(syms_of_lread): Declare `lexical-binding'.
* src/window.c (Ftemp_output_buffer_show): New fun.
(Fsave_window_excursion):
* src/print.c (Fwith_output_to_temp_buffer): Move to subr.el.
2011-04-01 17:19:52 +00:00
|
|
|
|
((stringp x) x)
|
|
|
|
|
((eq x 'star) "*")
|
|
|
|
|
(t ""))) ;any, point, prefix.
|
2008-04-26 01:47:11 +00:00
|
|
|
|
pattern
|
|
|
|
|
""))
|
|
|
|
|
|
2008-06-10 22:01:59 +00:00
|
|
|
|
;; We want to provide the functionality of `try', but we use `all'
|
|
|
|
|
;; and then merge it. In most cases, this works perfectly, but
|
|
|
|
|
;; if the completion table doesn't consider the same completions in
|
|
|
|
|
;; `try' as in `all', then we have a problem. The most common such
|
|
|
|
|
;; case is for filename completion where completion-ignored-extensions
|
|
|
|
|
;; is only obeyed by the `try' code. We paper over the difference
|
|
|
|
|
;; here. Note that it is not quite right either: if the completion
|
|
|
|
|
;; table uses completion-table-in-turn, this filtering may take place
|
|
|
|
|
;; too late to correctly fallback from the first to the
|
|
|
|
|
;; second alternative.
|
|
|
|
|
(defun completion-pcm--filename-try-filter (all)
|
|
|
|
|
"Filter to adjust `all' file completion to the behavior of `try'."
|
Merge from lexical-binding branch.
* doc/lispref/eval.texi (Eval): Discourage the use of `eval'.
Document its new `lexical' argument.
* doc/lispref/variables.texi (Defining Variables): Mention the new meaning of `defvar'.
(Lexical Binding): New sub-section.
* lisp/Makefile.in (BIG_STACK_DEPTH, BIG_STACK_OPTS, BYTE_COMPILE_FLAGS):
New variables.
(compile-onefile, .el.elc, compile-calc, recompile): Use them.
(COMPILE_FIRST): Add macroexp and cconv.
* lisp/makefile.w32-in: Mirror changes in Makefile.in.
* lisp/vc/cvs-status.el:
* lisp/vc/diff-mode.el:
* lisp/vc/log-edit.el:
* lisp/vc/log-view.el:
* lisp/vc/smerge-mode.el:
* lisp/textmodes/bibtex-style.el:
* textmodes/css.el:
* lisp/startup.el:
* lisp/uniquify.el:
* lisp/minibuffer.el:
* lisp/newcomment.el:
* lisp/reveal.el:
* lisp/server.el:
* lisp/mpc.el:
* lisp/emacs-lisp/smie.el:
* lisp/doc-view.el:
* lisp/dired.el:
* lisp/abbrev.el: Use lexical binding.
* lisp/custom.el (custom-initialize-default, custom-declare-variable):
Use `defvar'.
* lisp/files.el (lexical-binding): Declare safe.
* lisp/help-fns.el (help-split-fundoc): Return nil if there's nothing else
than the arglist.
(help-add-fundoc-usage): Don't add `Not documented'.
(help-function-arglist): Handle closures, subroutines, and new
byte-code-functions.
(help-make-usage): Remove leading underscores.
(describe-function-1): Handle closures.
(describe-variable): Use special-variable-p for completion.
* lisp/simple.el (with-wrapper-hook, apply-partially): Move to subr.el.
* lisp/subr.el (apply-partially): Use new closures rather than CL.
(--dolist-tail--, --dotimes-limit--): Don't declare dynamic.
(dolist, dotimes): Use slightly different expansion for lexical code.
(functionp): Move to C.
(letrec): New macro.
(with-wrapper-hook): Use it and apply-partially instead of CL.
(eval-after-load): Preserve lexical-binding.
(save-window-excursion, with-output-to-temp-buffer): Turn them
into macros.
* lisp/emacs-lisp/advice.el (ad-arglist): Use help-function-arglist.
* lisp/emacs-lisp/autoload.el (make-autoload): Don't burp on trivial macros.
* lisp/emacs-lisp/byte-opt.el: Use lexical binding.
(byte-inline-lapcode): Remove (to bytecomp).
(byte-compile-inline-expand): Pay attention to inlining to/from
lexically bound code.
(byte-compile-unfold-lambda): Don't handle byte-code-functions
any more.
(byte-optimize-form-code-walker): Don't handle save-window-excursion
any more and don't call compiler-macros.
(byte-compile-splice-in-already-compiled-code): Remove.
(byte-code): Don't inline any more.
(disassemble-offset): Receive `bytes' as argument rather than via
dynamic scoping.
(byte-compile-tag-number): Declare before first use.
(byte-decompile-bytecode-1): Handle new byte-codes, don't change
`return' even if make-spliceable.
(byte-compile-side-effect-and-error-free-ops): Add stack-ref, remove
obsolete interactive-p.
(byte-optimize-lapcode): Optimize new lap-codes.
Don't trip up on new form of `byte-constant' lap code.
* lisp/emacs-lisp/byte-run.el (make-obsolete): Don't set the `byte-compile'
handler any more.
* lisp/emacs-lisp/bytecomp.el: Use lexical binding instead of
a "bytecomp-" prefix. Macroexpand everything as a separate phase.
(byte-compile-initial-macro-environment):
Handle declare-function here.
(byte-compile--lexical-environment): New var.
(byte-stack-ref, byte-stack-set, byte-discardN)
(byte-discardN-preserve-tos): New lap codes.
(byte-interactive-p): Don't use any more.
(byte-compile-push-bytecodes, byte-compile-push-bytecode-const2):
New macros.
(byte-compile-lapcode): Use them and handle new lap codes.
(byte-compile-obsolete): Remove.
(byte-compile-arglist-signature): Handle new byte-code arg"lists".
(byte-compile-arglist-warn): Check late def of inlinable funs.
(byte-compile-cl-warn): Don't silence warnings for compiler-macros
since they should have been expanded by now.
(byte-compile--outbuffer): Rename from bytecomp-outbuffer.
(byte-compile-from-buffer): Remove unused second arg.
(byte-compile-preprocess): New function.
(byte-compile-toplevel-file-form): New function to distinguish
file-form calls from outside from file-form calls from hunk-handlers.
(byte-compile-file-form): Simplify.
(byte-compile-file-form-defsubst): Remove.
(byte-compile-file-form-defmumble): Simplify now that
byte-compile-lambda always returns a byte-code-function.
(byte-compile): Preprocess.
(byte-compile-byte-code-maker, byte-compile-byte-code-unmake):
Remove, not used any more.
(byte-compile-arglist-vars, byte-compile-make-lambda-lexenv)
(byte-compile-make-args-desc): New funs.
(byte-compile-lambda): Handle lexical functions. Always return
a byte-code-function.
(byte-compile-reserved-constants): New var, to make up room for
closed-over variables.
(byte-compile-constants-vector): Obey it.
(byte-compile-top-level): New args `lexenv' and `reserved-csts'.
(byte-compile-macroexpand-declare-function): New function.
(byte-compile-form): Call byte-compile-unfold-bcf to inline immediate
byte-code-functions.
(byte-compile-form): Check obsolescence here.
(byte-compile-inline-lapcode, byte-compile-unfold-bcf): New functions.
(byte-compile-variable-ref): Remove.
(byte-compile-dynamic-variable-op): New fun.
(byte-compile-dynamic-variable-bind, byte-compile-variable-ref)
(byte-compile-variable-set): New funs.
(byte-compile-discard): Add 2 args.
(byte-compile-stack-ref, byte-compile-stack-set)
(byte-compile-make-closure, byte-compile-get-closed-var): New funs.
(byte-compile-funarg, byte-compile-funarg-2): Remove, handled in
macroexpand-all instead.
(byte-compile-quote-form): Remove.
(byte-compile-push-binding-init, byte-compile-not-lexical-var-p)
(byte-compile-bind, byte-compile-unbind): New funs.
(byte-compile-let): Handle let* and lexical binding.
(byte-compile-let*): Remove.
(byte-compile-catch, byte-compile-unwind-protect)
(byte-compile-track-mouse, byte-compile-condition-case):
Handle a new :fun-body form, used for lexical scoping.
(byte-compile-save-window-excursion)
(byte-compile-with-output-to-temp-buffer): Remove.
(byte-compile-defun): Simplify.
(byte-compile-stack-adjustment): New fun.
(byte-compile-out): Use it.
(byte-compile-refresh-preloaded): Don't reload byte-compiler files.
* lisp/emacs-lisp/cconv.el: New file.
* lisp/emacs-lisp/cl-extra.el (cl-macroexpand-all): Properly quote CL
closures.
* lisp/emacs-lisp/cl-macs.el (cl-byte-compile-block)
(cl-byte-compile-throw): Remove.
(cl-block-wrapper, cl-block-throw): Use compiler-macros instead.
* lisp/emacs-lisp/cl.el (pushnew): Silence warning.
* lisp/emacs-lisp/disass.el (disassemble-internal): Handle new
`closure' objects.
(disassemble-1): Handle new byte codes.
* lisp/emacs-lisp/edebug.el (edebug-eval-defun)
(edebug-eval-top-level-form): Use eval-sexp-add-defvars.
(edebug-toggle): Avoid `eval'.
* lisp/emacs-lisp/eieio-comp.el: Remove.
* lisp/emacs-lisp/eieio.el (byte-compile-file-form-defmethod):
Don't autoload.
(eieio-defgeneric-form-primary-only-one): Use `byte-compile' rather
than the internal `byte-compile-lambda'.
(defmethod): Don't hide code under quotes.
(eieio-defmethod): New `code' argument.
* lisp/emacs-lisp/float-sup.el (pi): Don't declare as dynamically bound.
* lisp/emacs-lisp/lisp-mode.el (eval-last-sexp-1):
Use eval-sexp-add-defvars.
(eval-sexp-add-defvars): New fun.
* lisp/emacs-lisp/macroexp.el: Use lexical binding.
(macroexpand-all-1): Check obsolete macros. Expand compiler-macros.
Don't convert ' to #' without checking that it's indeed quoting
a lambda.
* lisp/emacs-lisp/pcase.el: Don't use destructuring-bind.
(pcase--memoize): Rename from pcase-memoize. Change weakness.
(pcase): Add `let' pattern.
Change memoization so it actually works.
(pcase-mutually-exclusive-predicates): Add byte-code-function-p.
(pcase--u1) <guard, pred>: Fix possible shadowing problem.
<let>: New case.
* src/alloc.c (Fmake_symbol): Init new `declared_special' field.
* src/buffer.c (defvar_per_buffer): Set new `declared_special' field.
* src/bytecode.c (Bstack_ref, Bstack_set, Bstack_set2, BdiscardN):
New byte-codes.
(exec_byte_code): New function extracted from Fbyte_code to handle new
calling convention for byte-code-functions. Add new byte-codes.
* src/callint.c (Fcall_interactively): Preserve lexical-binding mode for
interactive spec.
* src/doc.c (Fdocumentation, store_function_docstring):
* src/data.c (Finteractive_form): Handle closures.
* src/eval.c (Fsetq): Handle lexical vars.
(Fdefun, Fdefmacro, Ffunction): Make closures when needed.
(Fdefconst, Fdefvaralias, Fdefvar): Mark as dynamic.
(FletX, Flet): Obey lexical binding.
(Fcommandp): Handle closures.
(Feval): New `lexical' arg.
(eval_sub): New function extracted from Feval. Use it almost
everywhere where Feval was used. Look up vars in lexical env.
Handle closures.
(Ffunctionp): Move from subr.el.
(Ffuncall): Handle closures.
(apply_lambda): Remove `eval_flags'.
(funcall_lambda): Handle closures and new byte-code-functions.
(Fspecial_variable_p): New function.
(syms_of_eval): Initialize the Vinternal_interpreter_environment var,
but without exporting it to Lisp.
* src/fns.c (concat, mapcar1): Accept byte-code-functions.
* src/image.c (parse_image_spec): Use Ffunctionp.
* src/keyboard.c (eval_dyn): New fun.
(menu_item_eval_property): Use it.
* src/lisp.h (struct Lisp_Symbol): New field `declared_special'.
* src/lread.c (lisp_file_lexically_bound_p): New function.
(Fload): Bind Qlexical_binding.
(readevalloop): Remove `evalfun' arg.
Bind Qinternal_interpreter_environment.
(Feval_buffer): Bind Qlexical_binding.
(defvar_int, defvar_bool, defvar_lisp_nopro, defvar_kboard):
Mark as dynamic.
(syms_of_lread): Declare `lexical-binding'.
* src/window.c (Ftemp_output_buffer_show): New fun.
(Fsave_window_excursion):
* src/print.c (Fwith_output_to_temp_buffer): Move to subr.el.
2011-04-01 17:19:52 +00:00
|
|
|
|
(when all
|
2008-06-10 22:01:59 +00:00
|
|
|
|
(let ((try ())
|
|
|
|
|
(re (concat "\\(?:\\`\\.\\.?/\\|"
|
|
|
|
|
(regexp-opt completion-ignored-extensions)
|
|
|
|
|
"\\)\\'")))
|
|
|
|
|
(dolist (f all)
|
2009-01-14 02:29:52 +00:00
|
|
|
|
(unless (string-match-p re f) (push f try)))
|
2008-06-10 22:01:59 +00:00
|
|
|
|
(or try all))))
|
2009-01-14 02:29:52 +00:00
|
|
|
|
|
2008-06-10 22:01:59 +00:00
|
|
|
|
|
|
|
|
|
(defun completion-pcm--merge-try (pattern all prefix suffix)
|
|
|
|
|
(cond
|
|
|
|
|
((not (consp all)) all)
|
|
|
|
|
((and (not (consp (cdr all))) ;Only one completion.
|
|
|
|
|
;; Ignore completion-ignore-case here.
|
|
|
|
|
(equal (completion-pcm--pattern->string pattern) (car all)))
|
|
|
|
|
t)
|
|
|
|
|
(t
|
Merge from lexical-binding branch.
* doc/lispref/eval.texi (Eval): Discourage the use of `eval'.
Document its new `lexical' argument.
* doc/lispref/variables.texi (Defining Variables): Mention the new meaning of `defvar'.
(Lexical Binding): New sub-section.
* lisp/Makefile.in (BIG_STACK_DEPTH, BIG_STACK_OPTS, BYTE_COMPILE_FLAGS):
New variables.
(compile-onefile, .el.elc, compile-calc, recompile): Use them.
(COMPILE_FIRST): Add macroexp and cconv.
* lisp/makefile.w32-in: Mirror changes in Makefile.in.
* lisp/vc/cvs-status.el:
* lisp/vc/diff-mode.el:
* lisp/vc/log-edit.el:
* lisp/vc/log-view.el:
* lisp/vc/smerge-mode.el:
* lisp/textmodes/bibtex-style.el:
* textmodes/css.el:
* lisp/startup.el:
* lisp/uniquify.el:
* lisp/minibuffer.el:
* lisp/newcomment.el:
* lisp/reveal.el:
* lisp/server.el:
* lisp/mpc.el:
* lisp/emacs-lisp/smie.el:
* lisp/doc-view.el:
* lisp/dired.el:
* lisp/abbrev.el: Use lexical binding.
* lisp/custom.el (custom-initialize-default, custom-declare-variable):
Use `defvar'.
* lisp/files.el (lexical-binding): Declare safe.
* lisp/help-fns.el (help-split-fundoc): Return nil if there's nothing else
than the arglist.
(help-add-fundoc-usage): Don't add `Not documented'.
(help-function-arglist): Handle closures, subroutines, and new
byte-code-functions.
(help-make-usage): Remove leading underscores.
(describe-function-1): Handle closures.
(describe-variable): Use special-variable-p for completion.
* lisp/simple.el (with-wrapper-hook, apply-partially): Move to subr.el.
* lisp/subr.el (apply-partially): Use new closures rather than CL.
(--dolist-tail--, --dotimes-limit--): Don't declare dynamic.
(dolist, dotimes): Use slightly different expansion for lexical code.
(functionp): Move to C.
(letrec): New macro.
(with-wrapper-hook): Use it and apply-partially instead of CL.
(eval-after-load): Preserve lexical-binding.
(save-window-excursion, with-output-to-temp-buffer): Turn them
into macros.
* lisp/emacs-lisp/advice.el (ad-arglist): Use help-function-arglist.
* lisp/emacs-lisp/autoload.el (make-autoload): Don't burp on trivial macros.
* lisp/emacs-lisp/byte-opt.el: Use lexical binding.
(byte-inline-lapcode): Remove (to bytecomp).
(byte-compile-inline-expand): Pay attention to inlining to/from
lexically bound code.
(byte-compile-unfold-lambda): Don't handle byte-code-functions
any more.
(byte-optimize-form-code-walker): Don't handle save-window-excursion
any more and don't call compiler-macros.
(byte-compile-splice-in-already-compiled-code): Remove.
(byte-code): Don't inline any more.
(disassemble-offset): Receive `bytes' as argument rather than via
dynamic scoping.
(byte-compile-tag-number): Declare before first use.
(byte-decompile-bytecode-1): Handle new byte-codes, don't change
`return' even if make-spliceable.
(byte-compile-side-effect-and-error-free-ops): Add stack-ref, remove
obsolete interactive-p.
(byte-optimize-lapcode): Optimize new lap-codes.
Don't trip up on new form of `byte-constant' lap code.
* lisp/emacs-lisp/byte-run.el (make-obsolete): Don't set the `byte-compile'
handler any more.
* lisp/emacs-lisp/bytecomp.el: Use lexical binding instead of
a "bytecomp-" prefix. Macroexpand everything as a separate phase.
(byte-compile-initial-macro-environment):
Handle declare-function here.
(byte-compile--lexical-environment): New var.
(byte-stack-ref, byte-stack-set, byte-discardN)
(byte-discardN-preserve-tos): New lap codes.
(byte-interactive-p): Don't use any more.
(byte-compile-push-bytecodes, byte-compile-push-bytecode-const2):
New macros.
(byte-compile-lapcode): Use them and handle new lap codes.
(byte-compile-obsolete): Remove.
(byte-compile-arglist-signature): Handle new byte-code arg"lists".
(byte-compile-arglist-warn): Check late def of inlinable funs.
(byte-compile-cl-warn): Don't silence warnings for compiler-macros
since they should have been expanded by now.
(byte-compile--outbuffer): Rename from bytecomp-outbuffer.
(byte-compile-from-buffer): Remove unused second arg.
(byte-compile-preprocess): New function.
(byte-compile-toplevel-file-form): New function to distinguish
file-form calls from outside from file-form calls from hunk-handlers.
(byte-compile-file-form): Simplify.
(byte-compile-file-form-defsubst): Remove.
(byte-compile-file-form-defmumble): Simplify now that
byte-compile-lambda always returns a byte-code-function.
(byte-compile): Preprocess.
(byte-compile-byte-code-maker, byte-compile-byte-code-unmake):
Remove, not used any more.
(byte-compile-arglist-vars, byte-compile-make-lambda-lexenv)
(byte-compile-make-args-desc): New funs.
(byte-compile-lambda): Handle lexical functions. Always return
a byte-code-function.
(byte-compile-reserved-constants): New var, to make up room for
closed-over variables.
(byte-compile-constants-vector): Obey it.
(byte-compile-top-level): New args `lexenv' and `reserved-csts'.
(byte-compile-macroexpand-declare-function): New function.
(byte-compile-form): Call byte-compile-unfold-bcf to inline immediate
byte-code-functions.
(byte-compile-form): Check obsolescence here.
(byte-compile-inline-lapcode, byte-compile-unfold-bcf): New functions.
(byte-compile-variable-ref): Remove.
(byte-compile-dynamic-variable-op): New fun.
(byte-compile-dynamic-variable-bind, byte-compile-variable-ref)
(byte-compile-variable-set): New funs.
(byte-compile-discard): Add 2 args.
(byte-compile-stack-ref, byte-compile-stack-set)
(byte-compile-make-closure, byte-compile-get-closed-var): New funs.
(byte-compile-funarg, byte-compile-funarg-2): Remove, handled in
macroexpand-all instead.
(byte-compile-quote-form): Remove.
(byte-compile-push-binding-init, byte-compile-not-lexical-var-p)
(byte-compile-bind, byte-compile-unbind): New funs.
(byte-compile-let): Handle let* and lexical binding.
(byte-compile-let*): Remove.
(byte-compile-catch, byte-compile-unwind-protect)
(byte-compile-track-mouse, byte-compile-condition-case):
Handle a new :fun-body form, used for lexical scoping.
(byte-compile-save-window-excursion)
(byte-compile-with-output-to-temp-buffer): Remove.
(byte-compile-defun): Simplify.
(byte-compile-stack-adjustment): New fun.
(byte-compile-out): Use it.
(byte-compile-refresh-preloaded): Don't reload byte-compiler files.
* lisp/emacs-lisp/cconv.el: New file.
* lisp/emacs-lisp/cl-extra.el (cl-macroexpand-all): Properly quote CL
closures.
* lisp/emacs-lisp/cl-macs.el (cl-byte-compile-block)
(cl-byte-compile-throw): Remove.
(cl-block-wrapper, cl-block-throw): Use compiler-macros instead.
* lisp/emacs-lisp/cl.el (pushnew): Silence warning.
* lisp/emacs-lisp/disass.el (disassemble-internal): Handle new
`closure' objects.
(disassemble-1): Handle new byte codes.
* lisp/emacs-lisp/edebug.el (edebug-eval-defun)
(edebug-eval-top-level-form): Use eval-sexp-add-defvars.
(edebug-toggle): Avoid `eval'.
* lisp/emacs-lisp/eieio-comp.el: Remove.
* lisp/emacs-lisp/eieio.el (byte-compile-file-form-defmethod):
Don't autoload.
(eieio-defgeneric-form-primary-only-one): Use `byte-compile' rather
than the internal `byte-compile-lambda'.
(defmethod): Don't hide code under quotes.
(eieio-defmethod): New `code' argument.
* lisp/emacs-lisp/float-sup.el (pi): Don't declare as dynamically bound.
* lisp/emacs-lisp/lisp-mode.el (eval-last-sexp-1):
Use eval-sexp-add-defvars.
(eval-sexp-add-defvars): New fun.
* lisp/emacs-lisp/macroexp.el: Use lexical binding.
(macroexpand-all-1): Check obsolete macros. Expand compiler-macros.
Don't convert ' to #' without checking that it's indeed quoting
a lambda.
* lisp/emacs-lisp/pcase.el: Don't use destructuring-bind.
(pcase--memoize): Rename from pcase-memoize. Change weakness.
(pcase): Add `let' pattern.
Change memoization so it actually works.
(pcase-mutually-exclusive-predicates): Add byte-code-function-p.
(pcase--u1) <guard, pred>: Fix possible shadowing problem.
<let>: New case.
* src/alloc.c (Fmake_symbol): Init new `declared_special' field.
* src/buffer.c (defvar_per_buffer): Set new `declared_special' field.
* src/bytecode.c (Bstack_ref, Bstack_set, Bstack_set2, BdiscardN):
New byte-codes.
(exec_byte_code): New function extracted from Fbyte_code to handle new
calling convention for byte-code-functions. Add new byte-codes.
* src/callint.c (Fcall_interactively): Preserve lexical-binding mode for
interactive spec.
* src/doc.c (Fdocumentation, store_function_docstring):
* src/data.c (Finteractive_form): Handle closures.
* src/eval.c (Fsetq): Handle lexical vars.
(Fdefun, Fdefmacro, Ffunction): Make closures when needed.
(Fdefconst, Fdefvaralias, Fdefvar): Mark as dynamic.
(FletX, Flet): Obey lexical binding.
(Fcommandp): Handle closures.
(Feval): New `lexical' arg.
(eval_sub): New function extracted from Feval. Use it almost
everywhere where Feval was used. Look up vars in lexical env.
Handle closures.
(Ffunctionp): Move from subr.el.
(Ffuncall): Handle closures.
(apply_lambda): Remove `eval_flags'.
(funcall_lambda): Handle closures and new byte-code-functions.
(Fspecial_variable_p): New function.
(syms_of_eval): Initialize the Vinternal_interpreter_environment var,
but without exporting it to Lisp.
* src/fns.c (concat, mapcar1): Accept byte-code-functions.
* src/image.c (parse_image_spec): Use Ffunctionp.
* src/keyboard.c (eval_dyn): New fun.
(menu_item_eval_property): Use it.
* src/lisp.h (struct Lisp_Symbol): New field `declared_special'.
* src/lread.c (lisp_file_lexically_bound_p): New function.
(Fload): Bind Qlexical_binding.
(readevalloop): Remove `evalfun' arg.
Bind Qinternal_interpreter_environment.
(Feval_buffer): Bind Qlexical_binding.
(defvar_int, defvar_bool, defvar_lisp_nopro, defvar_kboard):
Mark as dynamic.
(syms_of_lread): Declare `lexical-binding'.
* src/window.c (Ftemp_output_buffer_show): New fun.
(Fsave_window_excursion):
* src/print.c (Fwith_output_to_temp_buffer): Move to subr.el.
2011-04-01 17:19:52 +00:00
|
|
|
|
(let* ((mergedpat (completion-pcm--merge-completions all pattern))
|
|
|
|
|
;; `mergedpat' is in reverse order. Place new point (by
|
|
|
|
|
;; order of preference) either at the old point, or at
|
|
|
|
|
;; the last place where there's something to choose, or
|
|
|
|
|
;; at the very end.
|
|
|
|
|
(pointpat (or (memq 'point mergedpat)
|
|
|
|
|
(memq 'any mergedpat)
|
|
|
|
|
(memq 'star mergedpat)
|
|
|
|
|
;; Not `prefix'.
|
|
|
|
|
mergedpat))
|
|
|
|
|
;; New pos from the start.
|
|
|
|
|
(newpos (length (completion-pcm--pattern->string pointpat)))
|
2011-12-30 02:52:49 +00:00
|
|
|
|
;; Do it afterwards because it changes `pointpat' by side effect.
|
Merge from lexical-binding branch.
* doc/lispref/eval.texi (Eval): Discourage the use of `eval'.
Document its new `lexical' argument.
* doc/lispref/variables.texi (Defining Variables): Mention the new meaning of `defvar'.
(Lexical Binding): New sub-section.
* lisp/Makefile.in (BIG_STACK_DEPTH, BIG_STACK_OPTS, BYTE_COMPILE_FLAGS):
New variables.
(compile-onefile, .el.elc, compile-calc, recompile): Use them.
(COMPILE_FIRST): Add macroexp and cconv.
* lisp/makefile.w32-in: Mirror changes in Makefile.in.
* lisp/vc/cvs-status.el:
* lisp/vc/diff-mode.el:
* lisp/vc/log-edit.el:
* lisp/vc/log-view.el:
* lisp/vc/smerge-mode.el:
* lisp/textmodes/bibtex-style.el:
* textmodes/css.el:
* lisp/startup.el:
* lisp/uniquify.el:
* lisp/minibuffer.el:
* lisp/newcomment.el:
* lisp/reveal.el:
* lisp/server.el:
* lisp/mpc.el:
* lisp/emacs-lisp/smie.el:
* lisp/doc-view.el:
* lisp/dired.el:
* lisp/abbrev.el: Use lexical binding.
* lisp/custom.el (custom-initialize-default, custom-declare-variable):
Use `defvar'.
* lisp/files.el (lexical-binding): Declare safe.
* lisp/help-fns.el (help-split-fundoc): Return nil if there's nothing else
than the arglist.
(help-add-fundoc-usage): Don't add `Not documented'.
(help-function-arglist): Handle closures, subroutines, and new
byte-code-functions.
(help-make-usage): Remove leading underscores.
(describe-function-1): Handle closures.
(describe-variable): Use special-variable-p for completion.
* lisp/simple.el (with-wrapper-hook, apply-partially): Move to subr.el.
* lisp/subr.el (apply-partially): Use new closures rather than CL.
(--dolist-tail--, --dotimes-limit--): Don't declare dynamic.
(dolist, dotimes): Use slightly different expansion for lexical code.
(functionp): Move to C.
(letrec): New macro.
(with-wrapper-hook): Use it and apply-partially instead of CL.
(eval-after-load): Preserve lexical-binding.
(save-window-excursion, with-output-to-temp-buffer): Turn them
into macros.
* lisp/emacs-lisp/advice.el (ad-arglist): Use help-function-arglist.
* lisp/emacs-lisp/autoload.el (make-autoload): Don't burp on trivial macros.
* lisp/emacs-lisp/byte-opt.el: Use lexical binding.
(byte-inline-lapcode): Remove (to bytecomp).
(byte-compile-inline-expand): Pay attention to inlining to/from
lexically bound code.
(byte-compile-unfold-lambda): Don't handle byte-code-functions
any more.
(byte-optimize-form-code-walker): Don't handle save-window-excursion
any more and don't call compiler-macros.
(byte-compile-splice-in-already-compiled-code): Remove.
(byte-code): Don't inline any more.
(disassemble-offset): Receive `bytes' as argument rather than via
dynamic scoping.
(byte-compile-tag-number): Declare before first use.
(byte-decompile-bytecode-1): Handle new byte-codes, don't change
`return' even if make-spliceable.
(byte-compile-side-effect-and-error-free-ops): Add stack-ref, remove
obsolete interactive-p.
(byte-optimize-lapcode): Optimize new lap-codes.
Don't trip up on new form of `byte-constant' lap code.
* lisp/emacs-lisp/byte-run.el (make-obsolete): Don't set the `byte-compile'
handler any more.
* lisp/emacs-lisp/bytecomp.el: Use lexical binding instead of
a "bytecomp-" prefix. Macroexpand everything as a separate phase.
(byte-compile-initial-macro-environment):
Handle declare-function here.
(byte-compile--lexical-environment): New var.
(byte-stack-ref, byte-stack-set, byte-discardN)
(byte-discardN-preserve-tos): New lap codes.
(byte-interactive-p): Don't use any more.
(byte-compile-push-bytecodes, byte-compile-push-bytecode-const2):
New macros.
(byte-compile-lapcode): Use them and handle new lap codes.
(byte-compile-obsolete): Remove.
(byte-compile-arglist-signature): Handle new byte-code arg"lists".
(byte-compile-arglist-warn): Check late def of inlinable funs.
(byte-compile-cl-warn): Don't silence warnings for compiler-macros
since they should have been expanded by now.
(byte-compile--outbuffer): Rename from bytecomp-outbuffer.
(byte-compile-from-buffer): Remove unused second arg.
(byte-compile-preprocess): New function.
(byte-compile-toplevel-file-form): New function to distinguish
file-form calls from outside from file-form calls from hunk-handlers.
(byte-compile-file-form): Simplify.
(byte-compile-file-form-defsubst): Remove.
(byte-compile-file-form-defmumble): Simplify now that
byte-compile-lambda always returns a byte-code-function.
(byte-compile): Preprocess.
(byte-compile-byte-code-maker, byte-compile-byte-code-unmake):
Remove, not used any more.
(byte-compile-arglist-vars, byte-compile-make-lambda-lexenv)
(byte-compile-make-args-desc): New funs.
(byte-compile-lambda): Handle lexical functions. Always return
a byte-code-function.
(byte-compile-reserved-constants): New var, to make up room for
closed-over variables.
(byte-compile-constants-vector): Obey it.
(byte-compile-top-level): New args `lexenv' and `reserved-csts'.
(byte-compile-macroexpand-declare-function): New function.
(byte-compile-form): Call byte-compile-unfold-bcf to inline immediate
byte-code-functions.
(byte-compile-form): Check obsolescence here.
(byte-compile-inline-lapcode, byte-compile-unfold-bcf): New functions.
(byte-compile-variable-ref): Remove.
(byte-compile-dynamic-variable-op): New fun.
(byte-compile-dynamic-variable-bind, byte-compile-variable-ref)
(byte-compile-variable-set): New funs.
(byte-compile-discard): Add 2 args.
(byte-compile-stack-ref, byte-compile-stack-set)
(byte-compile-make-closure, byte-compile-get-closed-var): New funs.
(byte-compile-funarg, byte-compile-funarg-2): Remove, handled in
macroexpand-all instead.
(byte-compile-quote-form): Remove.
(byte-compile-push-binding-init, byte-compile-not-lexical-var-p)
(byte-compile-bind, byte-compile-unbind): New funs.
(byte-compile-let): Handle let* and lexical binding.
(byte-compile-let*): Remove.
(byte-compile-catch, byte-compile-unwind-protect)
(byte-compile-track-mouse, byte-compile-condition-case):
Handle a new :fun-body form, used for lexical scoping.
(byte-compile-save-window-excursion)
(byte-compile-with-output-to-temp-buffer): Remove.
(byte-compile-defun): Simplify.
(byte-compile-stack-adjustment): New fun.
(byte-compile-out): Use it.
(byte-compile-refresh-preloaded): Don't reload byte-compiler files.
* lisp/emacs-lisp/cconv.el: New file.
* lisp/emacs-lisp/cl-extra.el (cl-macroexpand-all): Properly quote CL
closures.
* lisp/emacs-lisp/cl-macs.el (cl-byte-compile-block)
(cl-byte-compile-throw): Remove.
(cl-block-wrapper, cl-block-throw): Use compiler-macros instead.
* lisp/emacs-lisp/cl.el (pushnew): Silence warning.
* lisp/emacs-lisp/disass.el (disassemble-internal): Handle new
`closure' objects.
(disassemble-1): Handle new byte codes.
* lisp/emacs-lisp/edebug.el (edebug-eval-defun)
(edebug-eval-top-level-form): Use eval-sexp-add-defvars.
(edebug-toggle): Avoid `eval'.
* lisp/emacs-lisp/eieio-comp.el: Remove.
* lisp/emacs-lisp/eieio.el (byte-compile-file-form-defmethod):
Don't autoload.
(eieio-defgeneric-form-primary-only-one): Use `byte-compile' rather
than the internal `byte-compile-lambda'.
(defmethod): Don't hide code under quotes.
(eieio-defmethod): New `code' argument.
* lisp/emacs-lisp/float-sup.el (pi): Don't declare as dynamically bound.
* lisp/emacs-lisp/lisp-mode.el (eval-last-sexp-1):
Use eval-sexp-add-defvars.
(eval-sexp-add-defvars): New fun.
* lisp/emacs-lisp/macroexp.el: Use lexical binding.
(macroexpand-all-1): Check obsolete macros. Expand compiler-macros.
Don't convert ' to #' without checking that it's indeed quoting
a lambda.
* lisp/emacs-lisp/pcase.el: Don't use destructuring-bind.
(pcase--memoize): Rename from pcase-memoize. Change weakness.
(pcase): Add `let' pattern.
Change memoization so it actually works.
(pcase-mutually-exclusive-predicates): Add byte-code-function-p.
(pcase--u1) <guard, pred>: Fix possible shadowing problem.
<let>: New case.
* src/alloc.c (Fmake_symbol): Init new `declared_special' field.
* src/buffer.c (defvar_per_buffer): Set new `declared_special' field.
* src/bytecode.c (Bstack_ref, Bstack_set, Bstack_set2, BdiscardN):
New byte-codes.
(exec_byte_code): New function extracted from Fbyte_code to handle new
calling convention for byte-code-functions. Add new byte-codes.
* src/callint.c (Fcall_interactively): Preserve lexical-binding mode for
interactive spec.
* src/doc.c (Fdocumentation, store_function_docstring):
* src/data.c (Finteractive_form): Handle closures.
* src/eval.c (Fsetq): Handle lexical vars.
(Fdefun, Fdefmacro, Ffunction): Make closures when needed.
(Fdefconst, Fdefvaralias, Fdefvar): Mark as dynamic.
(FletX, Flet): Obey lexical binding.
(Fcommandp): Handle closures.
(Feval): New `lexical' arg.
(eval_sub): New function extracted from Feval. Use it almost
everywhere where Feval was used. Look up vars in lexical env.
Handle closures.
(Ffunctionp): Move from subr.el.
(Ffuncall): Handle closures.
(apply_lambda): Remove `eval_flags'.
(funcall_lambda): Handle closures and new byte-code-functions.
(Fspecial_variable_p): New function.
(syms_of_eval): Initialize the Vinternal_interpreter_environment var,
but without exporting it to Lisp.
* src/fns.c (concat, mapcar1): Accept byte-code-functions.
* src/image.c (parse_image_spec): Use Ffunctionp.
* src/keyboard.c (eval_dyn): New fun.
(menu_item_eval_property): Use it.
* src/lisp.h (struct Lisp_Symbol): New field `declared_special'.
* src/lread.c (lisp_file_lexically_bound_p): New function.
(Fload): Bind Qlexical_binding.
(readevalloop): Remove `evalfun' arg.
Bind Qinternal_interpreter_environment.
(Feval_buffer): Bind Qlexical_binding.
(defvar_int, defvar_bool, defvar_lisp_nopro, defvar_kboard):
Mark as dynamic.
(syms_of_lread): Declare `lexical-binding'.
* src/window.c (Ftemp_output_buffer_show): New fun.
(Fsave_window_excursion):
* src/print.c (Fwith_output_to_temp_buffer): Move to subr.el.
2011-04-01 17:19:52 +00:00
|
|
|
|
(merged (completion-pcm--pattern->string (nreverse mergedpat))))
|
2008-06-10 22:01:59 +00:00
|
|
|
|
|
|
|
|
|
(setq suffix (completion--merge-suffix merged newpos suffix))
|
Merge from lexical-binding branch.
* doc/lispref/eval.texi (Eval): Discourage the use of `eval'.
Document its new `lexical' argument.
* doc/lispref/variables.texi (Defining Variables): Mention the new meaning of `defvar'.
(Lexical Binding): New sub-section.
* lisp/Makefile.in (BIG_STACK_DEPTH, BIG_STACK_OPTS, BYTE_COMPILE_FLAGS):
New variables.
(compile-onefile, .el.elc, compile-calc, recompile): Use them.
(COMPILE_FIRST): Add macroexp and cconv.
* lisp/makefile.w32-in: Mirror changes in Makefile.in.
* lisp/vc/cvs-status.el:
* lisp/vc/diff-mode.el:
* lisp/vc/log-edit.el:
* lisp/vc/log-view.el:
* lisp/vc/smerge-mode.el:
* lisp/textmodes/bibtex-style.el:
* textmodes/css.el:
* lisp/startup.el:
* lisp/uniquify.el:
* lisp/minibuffer.el:
* lisp/newcomment.el:
* lisp/reveal.el:
* lisp/server.el:
* lisp/mpc.el:
* lisp/emacs-lisp/smie.el:
* lisp/doc-view.el:
* lisp/dired.el:
* lisp/abbrev.el: Use lexical binding.
* lisp/custom.el (custom-initialize-default, custom-declare-variable):
Use `defvar'.
* lisp/files.el (lexical-binding): Declare safe.
* lisp/help-fns.el (help-split-fundoc): Return nil if there's nothing else
than the arglist.
(help-add-fundoc-usage): Don't add `Not documented'.
(help-function-arglist): Handle closures, subroutines, and new
byte-code-functions.
(help-make-usage): Remove leading underscores.
(describe-function-1): Handle closures.
(describe-variable): Use special-variable-p for completion.
* lisp/simple.el (with-wrapper-hook, apply-partially): Move to subr.el.
* lisp/subr.el (apply-partially): Use new closures rather than CL.
(--dolist-tail--, --dotimes-limit--): Don't declare dynamic.
(dolist, dotimes): Use slightly different expansion for lexical code.
(functionp): Move to C.
(letrec): New macro.
(with-wrapper-hook): Use it and apply-partially instead of CL.
(eval-after-load): Preserve lexical-binding.
(save-window-excursion, with-output-to-temp-buffer): Turn them
into macros.
* lisp/emacs-lisp/advice.el (ad-arglist): Use help-function-arglist.
* lisp/emacs-lisp/autoload.el (make-autoload): Don't burp on trivial macros.
* lisp/emacs-lisp/byte-opt.el: Use lexical binding.
(byte-inline-lapcode): Remove (to bytecomp).
(byte-compile-inline-expand): Pay attention to inlining to/from
lexically bound code.
(byte-compile-unfold-lambda): Don't handle byte-code-functions
any more.
(byte-optimize-form-code-walker): Don't handle save-window-excursion
any more and don't call compiler-macros.
(byte-compile-splice-in-already-compiled-code): Remove.
(byte-code): Don't inline any more.
(disassemble-offset): Receive `bytes' as argument rather than via
dynamic scoping.
(byte-compile-tag-number): Declare before first use.
(byte-decompile-bytecode-1): Handle new byte-codes, don't change
`return' even if make-spliceable.
(byte-compile-side-effect-and-error-free-ops): Add stack-ref, remove
obsolete interactive-p.
(byte-optimize-lapcode): Optimize new lap-codes.
Don't trip up on new form of `byte-constant' lap code.
* lisp/emacs-lisp/byte-run.el (make-obsolete): Don't set the `byte-compile'
handler any more.
* lisp/emacs-lisp/bytecomp.el: Use lexical binding instead of
a "bytecomp-" prefix. Macroexpand everything as a separate phase.
(byte-compile-initial-macro-environment):
Handle declare-function here.
(byte-compile--lexical-environment): New var.
(byte-stack-ref, byte-stack-set, byte-discardN)
(byte-discardN-preserve-tos): New lap codes.
(byte-interactive-p): Don't use any more.
(byte-compile-push-bytecodes, byte-compile-push-bytecode-const2):
New macros.
(byte-compile-lapcode): Use them and handle new lap codes.
(byte-compile-obsolete): Remove.
(byte-compile-arglist-signature): Handle new byte-code arg"lists".
(byte-compile-arglist-warn): Check late def of inlinable funs.
(byte-compile-cl-warn): Don't silence warnings for compiler-macros
since they should have been expanded by now.
(byte-compile--outbuffer): Rename from bytecomp-outbuffer.
(byte-compile-from-buffer): Remove unused second arg.
(byte-compile-preprocess): New function.
(byte-compile-toplevel-file-form): New function to distinguish
file-form calls from outside from file-form calls from hunk-handlers.
(byte-compile-file-form): Simplify.
(byte-compile-file-form-defsubst): Remove.
(byte-compile-file-form-defmumble): Simplify now that
byte-compile-lambda always returns a byte-code-function.
(byte-compile): Preprocess.
(byte-compile-byte-code-maker, byte-compile-byte-code-unmake):
Remove, not used any more.
(byte-compile-arglist-vars, byte-compile-make-lambda-lexenv)
(byte-compile-make-args-desc): New funs.
(byte-compile-lambda): Handle lexical functions. Always return
a byte-code-function.
(byte-compile-reserved-constants): New var, to make up room for
closed-over variables.
(byte-compile-constants-vector): Obey it.
(byte-compile-top-level): New args `lexenv' and `reserved-csts'.
(byte-compile-macroexpand-declare-function): New function.
(byte-compile-form): Call byte-compile-unfold-bcf to inline immediate
byte-code-functions.
(byte-compile-form): Check obsolescence here.
(byte-compile-inline-lapcode, byte-compile-unfold-bcf): New functions.
(byte-compile-variable-ref): Remove.
(byte-compile-dynamic-variable-op): New fun.
(byte-compile-dynamic-variable-bind, byte-compile-variable-ref)
(byte-compile-variable-set): New funs.
(byte-compile-discard): Add 2 args.
(byte-compile-stack-ref, byte-compile-stack-set)
(byte-compile-make-closure, byte-compile-get-closed-var): New funs.
(byte-compile-funarg, byte-compile-funarg-2): Remove, handled in
macroexpand-all instead.
(byte-compile-quote-form): Remove.
(byte-compile-push-binding-init, byte-compile-not-lexical-var-p)
(byte-compile-bind, byte-compile-unbind): New funs.
(byte-compile-let): Handle let* and lexical binding.
(byte-compile-let*): Remove.
(byte-compile-catch, byte-compile-unwind-protect)
(byte-compile-track-mouse, byte-compile-condition-case):
Handle a new :fun-body form, used for lexical scoping.
(byte-compile-save-window-excursion)
(byte-compile-with-output-to-temp-buffer): Remove.
(byte-compile-defun): Simplify.
(byte-compile-stack-adjustment): New fun.
(byte-compile-out): Use it.
(byte-compile-refresh-preloaded): Don't reload byte-compiler files.
* lisp/emacs-lisp/cconv.el: New file.
* lisp/emacs-lisp/cl-extra.el (cl-macroexpand-all): Properly quote CL
closures.
* lisp/emacs-lisp/cl-macs.el (cl-byte-compile-block)
(cl-byte-compile-throw): Remove.
(cl-block-wrapper, cl-block-throw): Use compiler-macros instead.
* lisp/emacs-lisp/cl.el (pushnew): Silence warning.
* lisp/emacs-lisp/disass.el (disassemble-internal): Handle new
`closure' objects.
(disassemble-1): Handle new byte codes.
* lisp/emacs-lisp/edebug.el (edebug-eval-defun)
(edebug-eval-top-level-form): Use eval-sexp-add-defvars.
(edebug-toggle): Avoid `eval'.
* lisp/emacs-lisp/eieio-comp.el: Remove.
* lisp/emacs-lisp/eieio.el (byte-compile-file-form-defmethod):
Don't autoload.
(eieio-defgeneric-form-primary-only-one): Use `byte-compile' rather
than the internal `byte-compile-lambda'.
(defmethod): Don't hide code under quotes.
(eieio-defmethod): New `code' argument.
* lisp/emacs-lisp/float-sup.el (pi): Don't declare as dynamically bound.
* lisp/emacs-lisp/lisp-mode.el (eval-last-sexp-1):
Use eval-sexp-add-defvars.
(eval-sexp-add-defvars): New fun.
* lisp/emacs-lisp/macroexp.el: Use lexical binding.
(macroexpand-all-1): Check obsolete macros. Expand compiler-macros.
Don't convert ' to #' without checking that it's indeed quoting
a lambda.
* lisp/emacs-lisp/pcase.el: Don't use destructuring-bind.
(pcase--memoize): Rename from pcase-memoize. Change weakness.
(pcase): Add `let' pattern.
Change memoization so it actually works.
(pcase-mutually-exclusive-predicates): Add byte-code-function-p.
(pcase--u1) <guard, pred>: Fix possible shadowing problem.
<let>: New case.
* src/alloc.c (Fmake_symbol): Init new `declared_special' field.
* src/buffer.c (defvar_per_buffer): Set new `declared_special' field.
* src/bytecode.c (Bstack_ref, Bstack_set, Bstack_set2, BdiscardN):
New byte-codes.
(exec_byte_code): New function extracted from Fbyte_code to handle new
calling convention for byte-code-functions. Add new byte-codes.
* src/callint.c (Fcall_interactively): Preserve lexical-binding mode for
interactive spec.
* src/doc.c (Fdocumentation, store_function_docstring):
* src/data.c (Finteractive_form): Handle closures.
* src/eval.c (Fsetq): Handle lexical vars.
(Fdefun, Fdefmacro, Ffunction): Make closures when needed.
(Fdefconst, Fdefvaralias, Fdefvar): Mark as dynamic.
(FletX, Flet): Obey lexical binding.
(Fcommandp): Handle closures.
(Feval): New `lexical' arg.
(eval_sub): New function extracted from Feval. Use it almost
everywhere where Feval was used. Look up vars in lexical env.
Handle closures.
(Ffunctionp): Move from subr.el.
(Ffuncall): Handle closures.
(apply_lambda): Remove `eval_flags'.
(funcall_lambda): Handle closures and new byte-code-functions.
(Fspecial_variable_p): New function.
(syms_of_eval): Initialize the Vinternal_interpreter_environment var,
but without exporting it to Lisp.
* src/fns.c (concat, mapcar1): Accept byte-code-functions.
* src/image.c (parse_image_spec): Use Ffunctionp.
* src/keyboard.c (eval_dyn): New fun.
(menu_item_eval_property): Use it.
* src/lisp.h (struct Lisp_Symbol): New field `declared_special'.
* src/lread.c (lisp_file_lexically_bound_p): New function.
(Fload): Bind Qlexical_binding.
(readevalloop): Remove `evalfun' arg.
Bind Qinternal_interpreter_environment.
(Feval_buffer): Bind Qlexical_binding.
(defvar_int, defvar_bool, defvar_lisp_nopro, defvar_kboard):
Mark as dynamic.
(syms_of_lread): Declare `lexical-binding'.
* src/window.c (Ftemp_output_buffer_show): New fun.
(Fsave_window_excursion):
* src/print.c (Fwith_output_to_temp_buffer): Move to subr.el.
2011-04-01 17:19:52 +00:00
|
|
|
|
(cons (concat prefix merged suffix) (+ newpos (length prefix)))))))
|
2008-04-26 01:47:11 +00:00
|
|
|
|
|
2008-06-10 22:01:59 +00:00
|
|
|
|
(defun completion-pcm-try-completion (string table pred point)
|
Reduce use of (require 'cl).
* admin/bzrmerge.el: Use cl-lib.
* leim/quail/hangul.el: Don't require CL.
* leim/quail/ipa.el: Use cl-lib.
* vc/smerge-mode.el, vc/pcvs.el, vc/pcvs-util.el, vc/pcvs-info.el:
* vc/diff-mode.el, vc/cvs-status.el, uniquify.el, scroll-bar.el:
* register.el, progmodes/sh-script.el, net/gnutls.el, net/dbus.el:
* msb.el, mpc.el, minibuffer.el, international/ucs-normalize.el:
* international/quail.el, info-xref.el, imenu.el, image-mode.el:
* font-lock.el, filesets.el, edmacro.el, doc-view.el, bookmark.el:
* battery.el, avoid.el, abbrev.el: Use cl-lib.
* vc/pcvs-parse.el, vc/pcvs-defs.el, vc/log-view.el, vc/log-edit.el:
* vc/diff.el, simple.el, pcomplete.el, lpr.el, comint.el, loadhist.el:
* jit-lock.el, international/iso-ascii.el, info.el, frame.el, bs.el:
* emulation/crisp.el, electric.el, dired.el, cus-dep.el, composite.el:
* calculator.el, autorevert.el, apropos.el: Don't require CL.
* emacs-bytecomp.el (byte-recompile-directory, display-call-tree)
(byte-compile-unfold-bcf, byte-compile-check-variable):
* emacs-byte-opt.el (byte-compile-trueconstp)
(byte-compile-nilconstp):
* emacs-autoload.el (make-autoload): Use pcase.
* face-remap.el (text-scale-adjust): Simplify pcase patterns.
2012-07-10 11:51:54 +00:00
|
|
|
|
(pcase-let ((`(,pattern ,all ,prefix ,suffix)
|
|
|
|
|
(completion-pcm--find-all-completions
|
|
|
|
|
string table pred point
|
|
|
|
|
(if minibuffer-completing-file-name
|
|
|
|
|
'completion-pcm--filename-try-filter))))
|
2008-06-10 22:01:59 +00:00
|
|
|
|
(completion-pcm--merge-try pattern all prefix suffix)))
|
|
|
|
|
|
2010-03-23 00:59:49 +00:00
|
|
|
|
;;; Substring completion
|
|
|
|
|
;; Mostly derived from the code of `basic' completion.
|
|
|
|
|
|
|
|
|
|
(defun completion-substring--all-completions (string table pred point)
|
|
|
|
|
(let* ((beforepoint (substring string 0 point))
|
|
|
|
|
(afterpoint (substring string point))
|
|
|
|
|
(bounds (completion-boundaries beforepoint table pred afterpoint))
|
|
|
|
|
(suffix (substring afterpoint (cdr bounds)))
|
|
|
|
|
(prefix (substring beforepoint 0 (car bounds)))
|
|
|
|
|
(basic-pattern (completion-basic--pattern
|
|
|
|
|
beforepoint afterpoint bounds))
|
|
|
|
|
(pattern (if (not (stringp (car basic-pattern)))
|
|
|
|
|
basic-pattern
|
2010-05-09 22:39:36 +00:00
|
|
|
|
(cons 'prefix basic-pattern)))
|
2010-03-23 00:59:49 +00:00
|
|
|
|
(all (completion-pcm--all-completions prefix pattern table pred)))
|
|
|
|
|
(list all pattern prefix suffix (car bounds))))
|
|
|
|
|
|
|
|
|
|
(defun completion-substring-try-completion (string table pred point)
|
Reduce use of (require 'cl).
* admin/bzrmerge.el: Use cl-lib.
* leim/quail/hangul.el: Don't require CL.
* leim/quail/ipa.el: Use cl-lib.
* vc/smerge-mode.el, vc/pcvs.el, vc/pcvs-util.el, vc/pcvs-info.el:
* vc/diff-mode.el, vc/cvs-status.el, uniquify.el, scroll-bar.el:
* register.el, progmodes/sh-script.el, net/gnutls.el, net/dbus.el:
* msb.el, mpc.el, minibuffer.el, international/ucs-normalize.el:
* international/quail.el, info-xref.el, imenu.el, image-mode.el:
* font-lock.el, filesets.el, edmacro.el, doc-view.el, bookmark.el:
* battery.el, avoid.el, abbrev.el: Use cl-lib.
* vc/pcvs-parse.el, vc/pcvs-defs.el, vc/log-view.el, vc/log-edit.el:
* vc/diff.el, simple.el, pcomplete.el, lpr.el, comint.el, loadhist.el:
* jit-lock.el, international/iso-ascii.el, info.el, frame.el, bs.el:
* emulation/crisp.el, electric.el, dired.el, cus-dep.el, composite.el:
* calculator.el, autorevert.el, apropos.el: Don't require CL.
* emacs-bytecomp.el (byte-recompile-directory, display-call-tree)
(byte-compile-unfold-bcf, byte-compile-check-variable):
* emacs-byte-opt.el (byte-compile-trueconstp)
(byte-compile-nilconstp):
* emacs-autoload.el (make-autoload): Use pcase.
* face-remap.el (text-scale-adjust): Simplify pcase patterns.
2012-07-10 11:51:54 +00:00
|
|
|
|
(pcase-let ((`(,all ,pattern ,prefix ,suffix ,_carbounds)
|
|
|
|
|
(completion-substring--all-completions
|
|
|
|
|
string table pred point)))
|
2010-03-23 00:59:49 +00:00
|
|
|
|
(if minibuffer-completing-file-name
|
|
|
|
|
(setq all (completion-pcm--filename-try-filter all)))
|
|
|
|
|
(completion-pcm--merge-try pattern all prefix suffix)))
|
|
|
|
|
|
|
|
|
|
(defun completion-substring-all-completions (string table pred point)
|
Reduce use of (require 'cl).
* admin/bzrmerge.el: Use cl-lib.
* leim/quail/hangul.el: Don't require CL.
* leim/quail/ipa.el: Use cl-lib.
* vc/smerge-mode.el, vc/pcvs.el, vc/pcvs-util.el, vc/pcvs-info.el:
* vc/diff-mode.el, vc/cvs-status.el, uniquify.el, scroll-bar.el:
* register.el, progmodes/sh-script.el, net/gnutls.el, net/dbus.el:
* msb.el, mpc.el, minibuffer.el, international/ucs-normalize.el:
* international/quail.el, info-xref.el, imenu.el, image-mode.el:
* font-lock.el, filesets.el, edmacro.el, doc-view.el, bookmark.el:
* battery.el, avoid.el, abbrev.el: Use cl-lib.
* vc/pcvs-parse.el, vc/pcvs-defs.el, vc/log-view.el, vc/log-edit.el:
* vc/diff.el, simple.el, pcomplete.el, lpr.el, comint.el, loadhist.el:
* jit-lock.el, international/iso-ascii.el, info.el, frame.el, bs.el:
* emulation/crisp.el, electric.el, dired.el, cus-dep.el, composite.el:
* calculator.el, autorevert.el, apropos.el: Don't require CL.
* emacs-bytecomp.el (byte-recompile-directory, display-call-tree)
(byte-compile-unfold-bcf, byte-compile-check-variable):
* emacs-byte-opt.el (byte-compile-trueconstp)
(byte-compile-nilconstp):
* emacs-autoload.el (make-autoload): Use pcase.
* face-remap.el (text-scale-adjust): Simplify pcase patterns.
2012-07-10 11:51:54 +00:00
|
|
|
|
(pcase-let ((`(,all ,pattern ,prefix ,_suffix ,_carbounds)
|
|
|
|
|
(completion-substring--all-completions
|
|
|
|
|
string table pred point)))
|
2010-03-23 00:59:49 +00:00
|
|
|
|
(when all
|
|
|
|
|
(nconc (completion-pcm--hilit-commonality pattern all)
|
|
|
|
|
(length prefix)))))
|
|
|
|
|
|
|
|
|
|
;; Initials completion
|
2009-09-01 19:49:34 +00:00
|
|
|
|
;; Complete /ums to /usr/monnier/src or lch to list-command-history.
|
|
|
|
|
|
|
|
|
|
(defun completion-initials-expand (str table pred)
|
2010-02-05 04:21:11 +00:00
|
|
|
|
(let ((bounds (completion-boundaries str table pred "")))
|
|
|
|
|
(unless (or (zerop (length str))
|
|
|
|
|
;; Only check within the boundaries, since the
|
|
|
|
|
;; boundary char (e.g. /) might be in delim-regexp.
|
|
|
|
|
(string-match completion-pcm--delim-wild-regex str
|
|
|
|
|
(car bounds)))
|
2009-09-01 19:49:34 +00:00
|
|
|
|
(if (zerop (car bounds))
|
|
|
|
|
(mapconcat 'string str "-")
|
|
|
|
|
;; If there's a boundary, it's trickier. The main use-case
|
|
|
|
|
;; we consider here is file-name completion. We'd like
|
|
|
|
|
;; to expand ~/eee to ~/e/e/e and /eee to /e/e/e.
|
|
|
|
|
;; But at the same time, we don't want /usr/share/ae to expand
|
|
|
|
|
;; to /usr/share/a/e just because we mistyped "ae" for "ar",
|
|
|
|
|
;; so we probably don't want initials to touch anything that
|
|
|
|
|
;; looks like /usr/share/foo. As a heuristic, we just check that
|
|
|
|
|
;; the text before the boundary char is at most 1 char.
|
|
|
|
|
;; This allows both ~/eee and /eee and not much more.
|
|
|
|
|
;; FIXME: It sadly also disallows the use of ~/eee when that's
|
|
|
|
|
;; embedded within something else (e.g. "(~/eee" in Info node
|
|
|
|
|
;; completion or "ancestor:/eee" in bzr-revision completion).
|
|
|
|
|
(when (< (car bounds) 3)
|
|
|
|
|
(let ((sep (substring str (1- (car bounds)) (car bounds))))
|
|
|
|
|
;; FIXME: the above string-match checks the whole string, whereas
|
|
|
|
|
;; we end up only caring about the after-boundary part.
|
|
|
|
|
(concat (substring str 0 (car bounds))
|
|
|
|
|
(mapconcat 'string (substring str (car bounds)) sep))))))))
|
|
|
|
|
|
2011-03-01 05:03:24 +00:00
|
|
|
|
(defun completion-initials-all-completions (string table pred _point)
|
2009-09-01 19:49:34 +00:00
|
|
|
|
(let ((newstr (completion-initials-expand string table pred)))
|
|
|
|
|
(when newstr
|
|
|
|
|
(completion-pcm-all-completions newstr table pred (length newstr)))))
|
|
|
|
|
|
2011-03-01 05:03:24 +00:00
|
|
|
|
(defun completion-initials-try-completion (string table pred _point)
|
2009-09-01 19:49:34 +00:00
|
|
|
|
(let ((newstr (completion-initials-expand string table pred)))
|
|
|
|
|
(when newstr
|
|
|
|
|
(completion-pcm-try-completion newstr table pred (length newstr)))))
|
2011-06-23 03:35:05 +00:00
|
|
|
|
|
|
|
|
|
(defvar completing-read-function 'completing-read-default
|
|
|
|
|
"The function called by `completing-read' to do its work.
|
|
|
|
|
It should accept the same arguments as `completing-read'.")
|
|
|
|
|
|
|
|
|
|
(defun completing-read-default (prompt collection &optional predicate
|
|
|
|
|
require-match initial-input
|
|
|
|
|
hist def inherit-input-method)
|
|
|
|
|
"Default method for reading from the minibuffer with completion.
|
|
|
|
|
See `completing-read' for the meaning of the arguments."
|
|
|
|
|
|
|
|
|
|
(when (consp initial-input)
|
|
|
|
|
(setq initial-input
|
|
|
|
|
(cons (car initial-input)
|
|
|
|
|
;; `completing-read' uses 0-based index while
|
|
|
|
|
;; `read-from-minibuffer' uses 1-based index.
|
|
|
|
|
(1+ (cdr initial-input)))))
|
|
|
|
|
|
|
|
|
|
(let* ((minibuffer-completion-table collection)
|
|
|
|
|
(minibuffer-completion-predicate predicate)
|
|
|
|
|
(minibuffer-completion-confirm (unless (eq require-match t)
|
|
|
|
|
require-match))
|
2011-07-02 04:27:41 +00:00
|
|
|
|
(base-keymap (if require-match
|
2011-06-23 03:35:05 +00:00
|
|
|
|
minibuffer-local-must-match-map
|
2011-07-02 04:27:41 +00:00
|
|
|
|
minibuffer-local-completion-map))
|
|
|
|
|
(keymap (if (memq minibuffer-completing-file-name '(nil lambda))
|
|
|
|
|
base-keymap
|
|
|
|
|
;; Layer minibuffer-local-filename-completion-map
|
|
|
|
|
;; on top of the base map.
|
2011-08-03 21:40:06 +00:00
|
|
|
|
(make-composed-keymap
|
|
|
|
|
minibuffer-local-filename-completion-map
|
|
|
|
|
;; Set base-keymap as the parent, so that nil bindings
|
|
|
|
|
;; in minibuffer-local-filename-completion-map can
|
|
|
|
|
;; override bindings in base-keymap.
|
|
|
|
|
base-keymap)))
|
2011-06-23 03:35:05 +00:00
|
|
|
|
(result (read-from-minibuffer prompt initial-input keymap
|
|
|
|
|
nil hist def inherit-input-method)))
|
|
|
|
|
(when (and (equal result "") def)
|
|
|
|
|
(setq result (if (consp def) (car def) def)))
|
|
|
|
|
result))
|
2009-11-25 17:11:29 +00:00
|
|
|
|
|
|
|
|
|
;; Miscellaneous
|
|
|
|
|
|
|
|
|
|
(defun minibuffer-insert-file-name-at-point ()
|
|
|
|
|
"Get a file name at point in original buffer and insert it to minibuffer."
|
|
|
|
|
(interactive)
|
|
|
|
|
(let ((file-name-at-point
|
|
|
|
|
(with-current-buffer (window-buffer (minibuffer-selected-window))
|
|
|
|
|
(run-hook-with-args-until-success 'file-name-at-point-functions))))
|
|
|
|
|
(when file-name-at-point
|
|
|
|
|
(insert file-name-at-point))))
|
2008-04-26 01:47:11 +00:00
|
|
|
|
|
2008-04-09 03:34:19 +00:00
|
|
|
|
(provide 'minibuffer)
|
2008-04-18 02:46:47 +00:00
|
|
|
|
|
2008-04-09 03:34:19 +00:00
|
|
|
|
;;; minibuffer.el ends here
|