;;; auto-complete.el --- Auto Completion for GNU Emacs ;; Copyright (C) 2008, 2009, 2010 Tomohiro Matsuyama ;; Author: Tomohiro Matsuyama ;; URL: http://cx4a.org/software/auto-complete ;; Keywords: completion, convenience ;; Version: 1.4 ;; This program is free software; you can redistribute it and/or modify ;; it under the terms of the GNU General Public License as published by ;; the Free Software Foundation, either version 3 of the License, or ;; (at your option) any later version. ;; This program is distributed in the hope that it will be useful, ;; but WITHOUT ANY WARRANTY; without even the implied warranty of ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ;; GNU General Public License for more details. ;; You should have received a copy of the GNU General Public License ;; along with this program. If not, see . ;;; Commentary: ;; ;; This extension provides a way to complete with popup menu like: ;; ;; def-!- ;; +-----------------+ ;; |defun::::::::::::| ;; |defvar | ;; |defmacro | ;; | ... | ;; +-----------------+ ;; ;; You can complete by typing and selecting menu. ;; ;; Entire documents are located in doc/ directory. ;; Take a look for information. ;; ;; Enjoy! ;;; Code: (eval-when-compile (require 'cl)) (require 'popup) ;;;; Global stuff (defun ac-error (&optional var) "Report an error and disable `auto-complete-mode'." (ignore-errors (message "auto-complete error: %s" var) (auto-complete-mode -1) var)) ;;;; Customization (defgroup auto-complete nil "Auto completion." :group 'completion :prefix "ac-") (defcustom ac-delay 0.1 "Delay to completions will be available." :type 'float :group 'auto-complete) (defcustom ac-auto-show-menu 0.8 "Non-nil means completion menu will be automatically shown." :type '(choice (const :tag "Yes" t) (const :tag "Never" nil) (float :tag "Timer")) :group 'auto-complete) (defcustom ac-show-menu-immediately-on-auto-complete t "Non-nil means menu will be showed immediately on `auto-complete'." :type 'boolean :group 'auto-complete) (defcustom ac-expand-on-auto-complete t "Non-nil means expand whole common part on first time `auto-complete'." :type 'boolean :group 'auto-complete) (defcustom ac-disable-faces '(font-lock-comment-face font-lock-string-face font-lock-doc-face) "Non-nil means disable automatic completion on specified faces." :type '(repeat symbol) :group 'auto-complete) (defcustom ac-stop-flymake-on-completing t "Non-nil means disble flymake temporarily on completing." :type 'boolean :group 'auto-complete) (defcustom ac-use-fuzzy t "Non-nil means use fuzzy matching." :type 'boolean :group 'auto-complete) (defcustom ac-fuzzy-cursor-color "red" "Cursor color in fuzzy mode." :type 'string :group 'auto-complete) (defcustom ac-use-comphist t "Non-nil means use intelligent completion history." :type 'boolean :group 'auto-complete) (defcustom ac-comphist-threshold 0.7 "Percentage of ignoring low scored candidates." :type 'float :group 'auto-complete) (defcustom ac-comphist-file (expand-file-name (concat (if (boundp 'user-emacs-directory) user-emacs-directory "~/.emacs.d/") "/ac-comphist.dat")) "Completion history file name." :type 'string :group 'auto-complete) (defcustom ac-user-dictionary nil "User defined dictionary" :type '(repeat string) :group 'auto-complete) (defcustom ac-dictionary-files '("~/.dict") "Dictionary files." :type '(repeat string) :group 'auto-complete) (defvaralias 'ac-user-dictionary-files 'ac-dictionary-files) (defcustom ac-dictionary-directories nil "Dictionary directories." :type '(repeat string) :group 'auto-complete) (defcustom ac-use-quick-help t "Non-nil means use quick help." :type 'boolean :group 'auto-complete) (defcustom ac-quick-help-delay 1.5 "Delay to show quick help." :type 'float :group 'auto-complete) (defcustom ac-menu-height 10 "Max height of candidate menu." :type 'integer :group 'auto-complete) (defvaralias 'ac-candidate-menu-height 'ac-menu-height) (defcustom ac-quick-help-height 20 "Max height of quick help." :type 'integer :group 'auto-complete) (defcustom ac-quick-help-prefer-pos-tip t "Prefer native tooltip with pos-tip than overlay popup for displaying quick help." :type 'boolean :group 'auto-complete) (defvaralias 'ac-quick-help-prefer-x 'ac-quick-help-prefer-pos-tip) (defcustom ac-candidate-limit nil "Limit number of candidates. Non-integer means no limit." :type 'integer :group 'auto-complete) (defvaralias 'ac-candidate-max 'ac-candidate-limit) (defcustom ac-modes '(emacs-lisp-mode lisp-mode lisp-interaction-mode slime-repl-mode c-mode cc-mode c++-mode java-mode malabar-mode clojure-mode scala-mode scheme-mode ocaml-mode tuareg-mode haskell-mode perl-mode cperl-mode python-mode ruby-mode ecmascript-mode javascript-mode js-mode js2-mode php-mode css-mode makefile-mode sh-mode fortran-mode f90-mode ada-mode xml-mode sgml-mode ts-mode) "Major modes `auto-complete-mode' can run on." :type '(repeat symbol) :group 'auto-complete) (defcustom ac-compatible-packages-regexp "^ac-" "Regexp to indicate what packages can work with auto-complete." :type 'string :group 'auto-complete) (defcustom ac-non-trigger-commands '(*table--cell-self-insert-command) "Commands that can't be used as triggers of `auto-complete'." :type '(repeat symbol) :group 'auto-complete) (defcustom ac-trigger-commands '(self-insert-command) "Trigger commands that specify whether `auto-complete' should start or not." :type '(repeat symbol) :group 'auto-complete) (defcustom ac-trigger-commands-on-completing '(delete-backward-char backward-delete-char backward-delete-char-untabify) "Trigger commands that specify whether `auto-complete' should continue or not." :type '(repeat symbol) :group 'auto-complete) (defcustom ac-trigger-key nil "Non-nil means `auto-complete' will start by typing this key. If you specify this TAB, for example, `auto-complete' will start by typing TAB, and if there is no completions, an original command will be fallbacked." :type 'string :group 'auto-complete :set (lambda (symbol value) (set-default symbol value) (when (and value (fboundp 'ac-set-trigger-key)) (ac-set-trigger-key value)))) (defcustom ac-auto-start 2 "Non-nil means completion will be started automatically. Positive integer means if a length of a word you entered is larger than the value, completion will be started automatically. If you specify `nil', never be started automatically." :type '(choice (const :tag "Yes" t) (const :tag "Never" nil) (integer :tag "Require")) :group 'auto-complete) (defcustom ac-stop-words nil "List of string to stop completion." :type '(repeat string) :group 'auto-complete) (defvaralias 'ac-ignores 'ac-stop-words) (defcustom ac-use-dictionary-as-stop-words t "Non-nil means a buffer related dictionary will be thought of as stop words." :type 'boolean :group 'auto-complete) (defcustom ac-ignore-case 'smart "Non-nil means auto-complete ignores case. If this value is `smart', auto-complete ignores case only when a prefix doen't contain any upper case letters." :type '(choice (const :tag "Yes" t) (const :tag "Smart" smart) (const :tag "No" nil)) :group 'auto-complete) (defcustom ac-dwim t "Non-nil means `auto-complete' works based on Do What I Mean." :type 'boolean :group 'auto-complete) (defcustom ac-use-menu-map nil "Non-nil means a special keymap `ac-menu-map' on completing menu will be used." :type 'boolean :group 'auto-complete) (defcustom ac-use-overriding-local-map nil "Non-nil means `overriding-local-map' will be used to hack for overriding key events on auto-copletion." :type 'boolean :group 'auto-complete) (defface ac-completion-face '((t (:foreground "darkgray" :underline t))) "Face for inline completion" :group 'auto-complete) (defface ac-candidate-face '((t (:background "lightgray" :foreground "black"))) "Face for candidate." :group 'auto-complete) (defface ac-selection-face '((t (:background "steelblue" :foreground "white"))) "Face for selected candidate." :group 'auto-complete) (defvar auto-complete-mode-hook nil "Hook for `auto-complete-mode'.") ;;;; Internal variables (defvar auto-complete-mode nil "Dummy variable to suppress compiler warnings.") (defvar ac-cursor-color nil "Old cursor color.") (defvar ac-inline nil "Inline completion instance.") (defvar ac-menu nil "Menu instance.") (defvar ac-show-menu nil "Flag to show menu on timer tick.") (defvar ac-last-completion nil "Cons of prefix marker and selected item of last completion.") (defvar ac-quick-help nil "Quick help instance") (defvar ac-completing nil "Non-nil means `auto-complete-mode' is now working on completion.") (defvar ac-buffer nil "Buffer where auto-complete is started.") (defvar ac-point nil "Start point of prefix.") (defvar ac-last-point nil "Last point of updating pattern.") (defvar ac-prefix nil "Prefix string.") (defvaralias 'ac-target 'ac-prefix) (defvar ac-selected-candidate nil "Last selected candidate.") (defvar ac-common-part nil "Common part string of meaningful candidates. If there is no common part, this will be nil.") (defvar ac-whole-common-part nil "Common part string of whole candidates. If there is no common part, this will be nil.") (defvar ac-prefix-overlay nil "Overlay for prefix string.") (defvar ac-timer nil "Completion idle timer.") (defvar ac-show-menu-timer nil "Show menu idle timer.") (defvar ac-quick-help-timer nil "Quick help idle timer.") (defvar ac-triggered nil "Flag to update.") (defvar ac-limit nil "Limit number of candidates for each sources.") (defvar ac-candidates nil "Current candidates.") (defvar ac-candidates-cache nil "Candidates cache for individual sources.") (defvar ac-fuzzy-enable nil "Non-nil means fuzzy matching is enabled.") (defvar ac-dwim-enable nil "Non-nil means DWIM completion will be allowed.") (defvar ac-mode-map (make-sparse-keymap) "Auto-complete mode map. It is also used for trigger key command. See also `ac-trigger-key'.") (defvar ac-completing-map (let ((map (make-sparse-keymap))) (define-key map "\t" 'ac-expand) (define-key map "\r" 'ac-complete) (define-key map (kbd "M-TAB") 'auto-complete) (define-key map "\C-s" 'ac-isearch) (define-key map "\M-n" 'ac-next) (define-key map "\M-p" 'ac-previous) (define-key map [down] 'ac-next) (define-key map [up] 'ac-previous) (define-key map [f1] 'ac-help) (define-key map [M-f1] 'ac-persist-help) (define-key map (kbd "C-?") 'ac-help) (define-key map (kbd "C-M-?") 'ac-persist-help) (define-key map [C-down] 'ac-quick-help-scroll-down) (define-key map [C-up] 'ac-quick-help-scroll-up) (define-key map "\C-\M-n" 'ac-quick-help-scroll-down) (define-key map "\C-\M-p" 'ac-quick-help-scroll-up) (dotimes (i 9) (let ((symbol (intern (format "ac-complete-%d" (1+ i))))) (fset symbol `(lambda () (interactive) (when (and (ac-menu-live-p) (popup-select ac-menu ,i)) (ac-complete)))) (define-key map (read-kbd-macro (format "M-%s" (1+ i))) symbol))) map) "Keymap for completion.") (defvaralias 'ac-complete-mode-map 'ac-completing-map) (defvar ac-menu-map (let ((map (make-sparse-keymap))) (define-key map "\C-n" 'ac-next) (define-key map "\C-p" 'ac-previous) (set-keymap-parent map ac-completing-map) map) "Keymap for completion on completing menu.") (defvar ac-current-map (let ((map (make-sparse-keymap))) (set-keymap-parent map ac-completing-map) map)) (defvar ac-match-function 'all-completions "Default match function.") (defvar ac-prefix-definitions '((symbol . ac-prefix-symbol) (file . ac-prefix-file) (valid-file . ac-prefix-valid-file) (c-dot . ac-prefix-c-dot) (c-dot-ref . ac-prefix-c-dot-ref)) "Prefix definitions for common use.") (defvar ac-sources '(ac-source-words-in-same-mode-buffers) "Sources for completion.") (make-variable-buffer-local 'ac-sources) (defvar ac-compiled-sources nil "Compiled source of `ac-sources'.") (defvar ac-current-sources nil "Current working sources. This is sublist of `ac-compiled-sources'.") (defvar ac-omni-completion-sources nil "Do not use this anymore.") (defvar ac-current-prefix-def nil) (defvar ac-ignoring-prefix-def nil) ;;;; Intelligent completion history (defvar ac-comphist nil "Database of completion history.") (defsubst ac-comphist-make-tab () (make-hash-table :test 'equal)) (defsubst ac-comphist-tab (db) (nth 0 db)) (defsubst ac-comphist-cache (db) (nth 1 db)) (defun ac-comphist-make (&optional tab) (list (or tab (ac-comphist-make-tab)) (make-hash-table :test 'equal :weakness t))) (defun ac-comphist-get (db string &optional create) (let* ((tab (ac-comphist-tab db)) (index (gethash string tab))) (when (and create (null index)) (setq index (make-vector (length string) 0)) (puthash string index tab)) index)) (defun ac-comphist-add (db string prefix) (setq prefix (min prefix (1- (length string)))) (when (<= 0 prefix) (setq string (substring-no-properties string)) (let ((stat (ac-comphist-get db string t))) (incf (aref stat prefix)) (remhash string (ac-comphist-cache db))))) (defun ac-comphist-score (db string prefix) (setq prefix (min prefix (1- (length string)))) (if (<= 0 prefix) (let ((cache (gethash string (ac-comphist-cache db)))) (or (and cache (aref cache prefix)) (let ((stat (ac-comphist-get db string)) (score 0.0)) (when stat (loop for p from 0 below (length string) ;; sigmoid function with a = 5 with b = (/ 700.0 a) ; bounds for avoiding range error in `exp' with d = (/ 6.0 a) for x = (max (- b) (min b (- d (abs (- prefix p))))) for r = (/ 1.0 (1+ (exp (* (- a) x)))) do (incf score (* (aref stat p) r)))) ;; Weight by distance (incf score (max 0.0 (- 0.3 (/ (- (length string) prefix) 100.0)))) (unless cache (setq cache (make-vector (length string) nil)) (puthash string cache (ac-comphist-cache db))) (aset cache prefix score) score))) 0.0)) (defun ac-comphist-sort (db collection prefix &optional threshold) (let (result (n 0) (total 0) (cur 0)) (setq result (mapcar (lambda (a) (when (and cur threshold) (if (>= cur (* total threshold)) (setq cur nil) (incf n) (incf cur (cdr a)))) (car a)) (sort (mapcar (lambda (string) (let ((score (ac-comphist-score db string prefix))) (incf total score) (cons string score))) collection) (lambda (a b) (< (cdr b) (cdr a)))))) (if threshold (cons n result) result))) (defun ac-comphist-serialize (db) (let (alist) (maphash (lambda (k v) (push (cons k v) alist)) (ac-comphist-tab db)) (list alist))) (defun ac-comphist-deserialize (sexp) (condition-case nil (ac-comphist-make (let ((tab (ac-comphist-make-tab))) (mapc (lambda (cons) (puthash (car cons) (cdr cons) tab)) (nth 0 sexp)) tab)) (error (message "Invalid comphist db.") nil))) (defun ac-comphist-init () (ac-comphist-load) (add-hook 'kill-emacs-hook 'ac-comphist-save)) (defun ac-comphist-load () (interactive) (let ((db (if (file-exists-p ac-comphist-file) (ignore-errors (with-temp-buffer (insert-file-contents ac-comphist-file) (goto-char (point-min)) (ac-comphist-deserialize (read (current-buffer)))))))) (setq ac-comphist (or db (ac-comphist-make))))) (defun ac-comphist-save () (interactive) (require 'pp) (ignore-errors (with-temp-buffer (pp (ac-comphist-serialize ac-comphist) (current-buffer)) (write-region (point-min) (point-max) ac-comphist-file)))) ;;;; Dictionary (defvar ac-buffer-dictionary nil) (defvar ac-file-dictionary (make-hash-table :test 'equal)) (defun ac-clear-dictionary-cache () (interactive) (dolist (buffer (buffer-list)) (with-current-buffer buffer (if (local-variable-p 'ac-buffer-dictionary) (kill-local-variable 'ac-buffer-dictionary)))) (clrhash ac-file-dictionary)) (defun ac-file-dictionary (filename) (let ((cache (gethash filename ac-file-dictionary 'none))) (if (and cache (not (eq cache 'none))) cache (let (result) (ignore-errors (with-temp-buffer (insert-file-contents filename) (setq result (split-string (buffer-string) "\n")))) (puthash filename result ac-file-dictionary) result)))) (defun ac-mode-dictionary (mode) (loop for name in (cons (symbol-name mode) (ignore-errors (list (file-name-extension (buffer-file-name))))) for dir in ac-dictionary-directories for file = (concat dir "/" name) if (file-exists-p file) append (ac-file-dictionary file))) (defun ac-buffer-dictionary (&optional buffer) (with-current-buffer (or buffer (current-buffer)) (if (local-variable-p 'ac-buffer-dictionary) ac-buffer-dictionary (make-local-variable 'ac-buffer-dictionary) (setq ac-buffer-dictionary (apply 'append ac-user-dictionary (ac-mode-dictionary major-mode) (mapcar 'ac-file-dictionary ac-dictionary-files)))))) ;;;; Auto completion internals (defun ac-menu-at-wrapper-line-p () "Return non-nil if current line is long and wrapped to next visual line." (and (not truncate-lines) (eq (line-beginning-position) (save-excursion (vertical-motion 1) (line-beginning-position))))) (defun ac-stop-word-p (word) (or (member word ac-stop-words) (if ac-use-dictionary-as-stop-words (member word (ac-buffer-dictionary))))) (defun ac-prefix-symbol () "Default prefix definition function." (require 'thingatpt) (car-safe (bounds-of-thing-at-point 'symbol))) (defalias 'ac-prefix-default 'ac-prefix-symbol) (defun ac-prefix-file () "File prefix." (let ((point (re-search-backward "[\"<>' \t\r\n]" nil t))) (if point (1+ point)))) (defun ac-prefix-valid-file () "Existed (or to be existed) file prefix." (let* ((line-beg (line-beginning-position)) (end (point)) (start (or (let ((point (re-search-backward "[\"<>'= \t\r\n]" line-beg t))) (if point (1+ point))) line-beg)) (file (buffer-substring start end))) (if (and file (or (string-match "^/" file) (and (setq file (and (string-match "^[^/]*/" file) (match-string 0 file))) (file-directory-p file)))) start))) (defun ac-prefix-c-dot () "C-like languages dot(.) prefix." (if (re-search-backward "\\.\\(\\(?:[a-zA-Z0-9][_a-zA-Z0-9]*\\)?\\)\\=" nil t) (match-beginning 1))) (defun ac-prefix-c-dot-ref () "C-like languages dot(.) and reference(->) prefix." (if (re-search-backward "\\(?:\\.\\|->\\)\\(\\(?:[a-zA-Z0-9][_a-zA-Z0-9]*\\)?\\)\\=" nil t) (match-beginning 1))) (defun ac-define-prefix (name prefix) "Define new prefix definition. You can not use it in source definition like (prefix . `NAME')." (push (cons name prefix) ac-prefix-definitions)) (defun ac-match-substring (prefix candidates) (loop with regexp = (regexp-quote prefix) for candidate in candidates if (string-match regexp candidate) collect candidate)) (defsubst ac-source-entity (source) (if (symbolp source) (symbol-value source) source)) (defun ac-source-available-p (source) (if (and (symbolp source) (get source 'available)) (eq (get source 'available) t) (let* ((src (ac-source-entity source)) (avail-pair (assq 'available src)) (avail-cond (cdr avail-pair)) (available (and (if avail-pair (cond ((symbolp avail-cond) (funcall avail-cond)) ((listp avail-cond) (eval avail-cond))) t) (loop for feature in (assoc-default 'depends src) unless (require feature nil t) return nil finally return t)))) (if (symbolp source) (put source 'available (if available t 'no))) available))) (defun ac-compile-sources (sources) "Compiled `SOURCES' into expanded sources style." (loop for source in sources if (ac-source-available-p source) do (setq source (ac-source-entity source)) (flet ((add-attribute (name value &optional append) (add-to-list 'source (cons name value) append))) ;; prefix (let* ((prefix (assoc 'prefix source)) (real (assoc-default (cdr prefix) ac-prefix-definitions))) (cond (real (add-attribute 'prefix real)) ((null prefix) (add-attribute 'prefix 'ac-prefix-default)))) ;; match (let ((match (assq 'match source))) (cond ((eq (cdr match) 'substring) (setcdr match 'ac-match-substring))))) and collect source)) (defun ac-compiled-sources () (or ac-compiled-sources (setq ac-compiled-sources (ac-compile-sources ac-sources)))) (defsubst ac-menu-live-p () (popup-live-p ac-menu)) (defun ac-menu-create (point width height) (setq ac-menu (popup-create point width height :around t :face 'ac-candidate-face :selection-face 'ac-selection-face :symbol t :scroll-bar t :margin-left 1))) (defun ac-menu-delete () (when ac-menu (popup-delete ac-menu) (setq ac-menu))) (defsubst ac-inline-overlay () (nth 0 ac-inline)) (defsubst ac-inline-live-p () (and ac-inline (ac-inline-overlay) t)) (defun ac-inline-show (point string) (unless ac-inline (setq ac-inline (list nil))) (save-excursion (let ((overlay (ac-inline-overlay)) (width 0) (string-width (string-width string)) (length 0) (original-string string)) ;; Calculate string space to show completion (goto-char point) (let (c) (while (and (not (eolp)) (< width string-width) (setq c (char-after)) (not (eq c ?\t))) ; special case for tab (incf width (char-width c)) (incf length) (forward-char))) ;; Show completion (goto-char point) (cond ((= width 0) ;; End-of-line ;; Do nothing ) ((<= width string-width) ;; No space to show ;; Do nothing ) ((> width string-width) ;; Need to fill space (setq string (concat string (make-string (- width string-width) ? ))))) (setq string (propertize string 'face 'ac-completion-face)) (if overlay (progn (move-overlay overlay point (+ point length)) (overlay-put overlay 'invisible nil)) (setq overlay (make-overlay point (+ point length))) (setf (nth 0 ac-inline) overlay) (overlay-put overlay 'priority 9999) ;; Help prefix-overlay in some cases (overlay-put overlay 'keymap ac-current-map)) ;; TODO no width but char (if (eq length 0) ;; Case: End-of-line (progn (put-text-property 0 1 'cursor t string) (overlay-put overlay 'after-string string)) (let ((display (substring string 0 1)) (after-string (substring string 1))) (overlay-put overlay 'display display) (overlay-put overlay 'after-string after-string))) (overlay-put overlay 'string original-string)))) (defun ac-inline-delete () (when (ac-inline-live-p) (ac-inline-hide) (delete-overlay (ac-inline-overlay)) (setq ac-inline nil))) (defun ac-inline-hide () (when (ac-inline-live-p) (let ((overlay (ac-inline-overlay)) (buffer-undo-list t)) (when overlay (move-overlay overlay (point-min) (point-min)) (overlay-put overlay 'invisible t) (overlay-put overlay 'display nil) (overlay-put overlay 'after-string nil))))) (defun ac-inline-update () (if (and ac-completing ac-prefix (stringp ac-common-part)) (let ((common-part-length (length ac-common-part)) (prefix-length (length ac-prefix))) (if (> common-part-length prefix-length) (progn (ac-inline-hide) (ac-inline-show (point) (substring ac-common-part prefix-length))) (ac-inline-delete))) (ac-inline-delete))) (defun ac-put-prefix-overlay () (unless ac-prefix-overlay (let (newline) ;; Insert newline to make sure that cursor always on the overlay (when (and (eq ac-point (point-max)) (eq ac-point (point))) (popup-save-buffer-state (insert "\n")) (setq newline t)) (setq ac-prefix-overlay (make-overlay ac-point (1+ (point)) nil t t)) (overlay-put ac-prefix-overlay 'priority 9999) (overlay-put ac-prefix-overlay 'keymap (make-sparse-keymap)) (overlay-put ac-prefix-overlay 'newline newline)))) (defun ac-remove-prefix-overlay () (when ac-prefix-overlay (when (overlay-get ac-prefix-overlay 'newline) ;; Remove inserted newline (popup-save-buffer-state (goto-char (point-max)) (if (eq (char-before) ?\n) (delete-char -1)))) (delete-overlay ac-prefix-overlay))) (defun ac-activate-completing-map () (if (and ac-show-menu ac-use-menu-map) (set-keymap-parent ac-current-map ac-menu-map)) (when (and ac-use-overriding-local-map (null overriding-terminal-local-map)) (setq overriding-terminal-local-map ac-current-map)) (when ac-prefix-overlay (set-keymap-parent (overlay-get ac-prefix-overlay 'keymap) ac-current-map))) (defun ac-deactivate-completing-map () (set-keymap-parent ac-current-map ac-completing-map) (when (and ac-use-overriding-local-map (eq overriding-terminal-local-map ac-current-map)) (setq overriding-terminal-local-map nil)) (when ac-prefix-overlay (set-keymap-parent (overlay-get ac-prefix-overlay 'keymap) nil))) (defsubst ac-selected-candidate () (if ac-menu (popup-selected-item ac-menu))) (defun ac-prefix (requires ignore-list) (loop with current = (point) with point with prefix-def with sources for source in (ac-compiled-sources) for prefix = (assoc-default 'prefix source) for req = (or (assoc-default 'requires source) requires 1) if (null prefix-def) do (unless (member prefix ignore-list) (save-excursion (setq point (cond ((symbolp prefix) (funcall prefix)) ((stringp prefix) (and (re-search-backward (concat prefix "\\=") nil t) (or (match-beginning 1) (match-beginning 0)))) ((stringp (car-safe prefix)) (let ((regexp (nth 0 prefix)) (end (nth 1 prefix)) (group (nth 2 prefix))) (and (re-search-backward (concat regexp "\\=") nil t) (funcall (if end 'match-end 'match-beginning) (or group 0))))) (t (eval prefix)))) (if (and point (integerp req) (< (- current point) req)) (setq point nil)) (if point (setq prefix-def prefix)))) if (equal prefix prefix-def) do (push source sources) finally return (and point (list prefix-def point (nreverse sources))))) (defun ac-init () "Initialize current sources to start completion." (setq ac-candidates-cache nil) (loop for source in ac-current-sources for function = (assoc-default 'init source) if function do (save-excursion (cond ((functionp function) (funcall function)) (t (eval function)))))) (defun ac-candidates-1 (source) (let* ((do-cache (assq 'cache source)) (function (assoc-default 'candidates source)) (action (assoc-default 'action source)) (document (assoc-default 'document source)) (symbol (assoc-default 'symbol source)) (ac-limit (or (assoc-default 'limit source) ac-limit)) (face (or (assoc-default 'face source) (assoc-default 'candidate-face source))) (selection-face (assoc-default 'selection-face source)) (cache (and do-cache (assq source ac-candidates-cache))) (candidates (cdr cache))) (unless cache (setq candidates (save-excursion (cond ((functionp function) (funcall function)) (t (eval function))))) ;; Convert (name value) format candidates into name with text properties. (setq candidates (mapcar (lambda (candidate) (if (consp candidate) (propertize (car candidate) 'value (cdr candidate)) candidate)) candidates)) (when do-cache (push (cons source candidates) ac-candidates-cache))) (setq candidates (funcall (or (assoc-default 'match source) ac-match-function) ac-prefix candidates)) ;; Remove extra items regarding to ac-limit (if (and (integerp ac-limit) (> ac-limit 1) (> (length candidates) ac-limit)) (setcdr (nthcdr (1- ac-limit) candidates) nil)) ;; Put candidate properties (setq candidates (mapcar (lambda (candidate) (popup-item-propertize candidate 'action action 'symbol symbol 'document document 'popup-face face 'selection-face selection-face)) candidates)) candidates)) (defun ac-candidates () "Produce candidates for current sources." (loop with completion-ignore-case = (or (eq ac-ignore-case t) (and (eq ac-ignore-case 'smart) (let ((case-fold-search nil)) (not (string-match "[[:upper:]]" ac-prefix))))) with case-fold-search = completion-ignore-case with prefix-len = (length ac-prefix) for source in ac-current-sources append (ac-candidates-1 source) into candidates finally return (progn (delete-dups candidates) (if (and ac-use-comphist ac-comphist) (if ac-show-menu (let* ((pair (ac-comphist-sort ac-comphist candidates prefix-len ac-comphist-threshold)) (n (car pair)) (result (cdr pair)) (cons (if (> n 0) (nthcdr (1- n) result))) (cdr (cdr cons))) (if cons (setcdr cons nil)) (setq ac-common-part (try-completion ac-prefix result)) (setq ac-whole-common-part (try-completion ac-prefix candidates)) (if cons (setcdr cons cdr)) result) (setq candidates (ac-comphist-sort ac-comphist candidates prefix-len)) (setq ac-common-part (if candidates (popup-x-to-string (car candidates)))) (setq ac-whole-common-part (try-completion ac-prefix candidates)) candidates) (setq ac-common-part (try-completion ac-prefix candidates)) (setq ac-whole-common-part ac-common-part) candidates)))) (defun ac-update-candidates (cursor scroll-top) "Update candidates of menu to `ac-candidates' and redraw it." (setf (popup-cursor ac-menu) cursor (popup-scroll-top ac-menu) scroll-top) (setq ac-dwim-enable (= (length ac-candidates) 1)) (if ac-candidates (progn (setq ac-completing t) (ac-activate-completing-map)) (setq ac-completing nil) (ac-deactivate-completing-map)) (ac-inline-update) (popup-set-list ac-menu ac-candidates) (if (and (not ac-fuzzy-enable) (<= (length ac-candidates) 1)) (popup-hide ac-menu) (if ac-show-menu (popup-draw ac-menu)))) (defun ac-reposition () "Force to redraw candidate menu with current `ac-candidates'." (let ((cursor (popup-cursor ac-menu)) (scroll-top (popup-scroll-top ac-menu)) (height (popup-height ac-menu))) (ac-menu-delete) (ac-menu-create ac-point (popup-preferred-width ac-candidates) height) (ac-update-candidates cursor scroll-top))) (defun ac-cleanup () "Cleanup auto completion." (if ac-cursor-color (set-cursor-color ac-cursor-color)) (when (and ac-use-comphist ac-comphist) (when (and (null ac-selected-candidate) (member ac-prefix ac-candidates)) ;; Assume candidate is selected by just typing (setq ac-selected-candidate ac-prefix) (setq ac-last-point ac-point)) (when ac-selected-candidate (ac-comphist-add ac-comphist ac-selected-candidate (if ac-last-point (- ac-last-point ac-point) (length ac-prefix))))) (ac-deactivate-completing-map) (ac-remove-prefix-overlay) (ac-remove-quick-help) (ac-inline-delete) (ac-menu-delete) (ac-cancel-timer) (ac-cancel-show-menu-timer) (ac-cancel-quick-help-timer) (setq ac-cursor-color nil ac-inline nil ac-show-menu nil ac-menu nil ac-completing nil ac-point nil ac-last-point nil ac-prefix nil ac-prefix-overlay nil ac-selected-candidate nil ac-common-part nil ac-whole-common-part nil ac-triggered nil ac-limit nil ac-candidates nil ac-candidates-cache nil ac-fuzzy-enable nil ac-dwim-enable nil ac-compiled-sources nil ac-current-sources nil ac-current-prefix-def nil ac-ignoring-prefix-def nil)) (defsubst ac-abort () "Abort completion." (ac-cleanup)) (defun ac-expand-string (string &optional remove-undo-boundary) "Expand `STRING' into the buffer and update `ac-prefix' to `STRING'. This function records deletion and insertion sequences by `undo-boundary'. If `remove-undo-boundary' is non-nil, this function also removes `undo-boundary' that have been made before in this function." (when (not (equal string (buffer-substring ac-point (point)))) (undo-boundary) ;; We can't use primitive-undo since it undoes by ;; groups, divided by boundaries. ;; We don't want boundary between deletion and insertion. ;; So do it manually. ;; Delete region silently for undo: (if remove-undo-boundary (progn (let (buffer-undo-list) (save-excursion (delete-region ac-point (point)))) (setq buffer-undo-list (nthcdr 2 buffer-undo-list))) (delete-region ac-point (point))) (insert string) ;; Sometimes, possible when omni-completion used, (insert) added ;; to buffer-undo-list strange record about position changes. ;; Delete it here: (when (and remove-undo-boundary (integerp (cadr buffer-undo-list))) (setcdr buffer-undo-list (nthcdr 2 buffer-undo-list))) (undo-boundary) (setq ac-selected-candidate string) (setq ac-prefix string))) (defun ac-set-trigger-key (key) "Set `ac-trigger-key' to `KEY'. It is recommemded to use this function instead of calling `setq'." ;; Remove old mapping (when ac-trigger-key (define-key ac-mode-map (read-kbd-macro ac-trigger-key) nil)) ;; Make new mapping (setq ac-trigger-key key) (when key (define-key ac-mode-map (read-kbd-macro key) 'ac-trigger-key-command))) (defun ac-set-timer () (unless ac-timer (setq ac-timer (run-with-idle-timer ac-delay ac-delay 'ac-update-greedy)))) (defun ac-cancel-timer () (when (timerp ac-timer) (cancel-timer ac-timer) (setq ac-timer nil))) (defun ac-update (&optional force) (when (and auto-complete-mode ac-prefix (or ac-triggered force) (not isearch-mode)) (ac-put-prefix-overlay) (setq ac-candidates (ac-candidates)) (let ((preferred-width (popup-preferred-width ac-candidates))) ;; Reposition if needed (when (or (null ac-menu) (>= (popup-width ac-menu) preferred-width) (<= (popup-width ac-menu) (- preferred-width 10)) (and (> (popup-direction ac-menu) 0) (ac-menu-at-wrapper-line-p))) (ac-inline-hide) ; Hide overlay to calculate correct column (ac-menu-delete) (ac-menu-create ac-point preferred-width ac-menu-height))) (ac-update-candidates 0 0) t)) (defun ac-update-greedy (&optional force) (let (result) (while (when (and (setq result (ac-update force)) (null ac-candidates)) (add-to-list 'ac-ignoring-prefix-def ac-current-prefix-def) (ac-start :force-init t) ac-current-prefix-def)) result)) (defun ac-set-show-menu-timer () (when (and (or (integerp ac-auto-show-menu) (floatp ac-auto-show-menu)) (null ac-show-menu-timer)) (setq ac-show-menu-timer (run-with-idle-timer ac-auto-show-menu ac-auto-show-menu 'ac-show-menu)))) (defun ac-cancel-show-menu-timer () (when (timerp ac-show-menu-timer) (cancel-timer ac-show-menu-timer) (setq ac-show-menu-timer nil))) (defun ac-show-menu () (when (not (eq ac-show-menu t)) (setq ac-show-menu t) (ac-inline-hide) (ac-remove-quick-help) (ac-update t))) (defun ac-help (&optional persist) (interactive "P") (when ac-menu (popup-menu-show-help ac-menu persist))) (defun ac-persist-help () (interactive) (ac-help t)) (defun ac-last-help (&optional persist) (interactive "P") (when ac-last-completion (popup-item-show-help (cdr ac-last-completion) persist))) (defun ac-last-persist-help () (interactive) (ac-last-help t)) (defun ac-set-quick-help-timer () (when (and ac-use-quick-help (null ac-quick-help-timer)) (setq ac-quick-help-timer (run-with-idle-timer ac-quick-help-delay ac-quick-help-delay 'ac-quick-help)))) (defun ac-cancel-quick-help-timer () (when (timerp ac-quick-help-timer) (cancel-timer ac-quick-help-timer) (setq ac-quick-help-timer nil))) (defun ac-pos-tip-show-quick-help (menu &optional item &rest args) (let* ((point (plist-get args :point)) (around nil) (parent-offset (popup-offset menu)) (doc (popup-menu-documentation menu item))) (when (stringp doc) (if (popup-hidden-p menu) (setq around t) (setq point nil)) (with-no-warnings (pos-tip-show doc 'popup-tip-face (or point (and menu (popup-child-point menu parent-offset)) (point)) nil 0 popup-tip-max-width nil nil (and (not around) 0)) (unless (plist-get args :nowait) (clear-this-command-keys) (unwind-protect (push (read-event (plist-get args :prompt)) unread-command-events) (pos-tip-hide)) t))))) (defun ac-quick-help-use-pos-tip-p () (and ac-quick-help-prefer-pos-tip window-system (featurep 'pos-tip))) (defun ac-quick-help (&optional force) (interactive) (when (and (or force (null this-command)) (ac-menu-live-p) (null ac-quick-help)) (setq ac-quick-help (funcall (if (ac-quick-help-use-pos-tip-p) 'ac-pos-tip-show-quick-help 'popup-menu-show-quick-help) ac-menu nil :point ac-point :height ac-quick-help-height :nowait t)))) (defun ac-remove-quick-help () (when (ac-quick-help-use-pos-tip-p) (with-no-warnings (pos-tip-hide))) (when ac-quick-help (popup-delete ac-quick-help) (setq ac-quick-help nil))) (defun ac-last-quick-help () (interactive) (when (and ac-last-completion (eq (marker-buffer (car ac-last-completion)) (current-buffer))) (let ((doc (popup-item-documentation (cdr ac-last-completion))) (point (marker-position (car ac-last-completion)))) (when (stringp doc) (if (ac-quick-help-use-pos-tip-p) (with-no-warnings (pos-tip-show doc nil point nil 0)) (popup-tip doc :point point :around t :scroll-bar t :margin t)))))) (defmacro ac-define-quick-help-command (name arglist &rest body) (declare (indent 2)) `(progn (defun ,name ,arglist ,@body) (put ',name 'ac-quick-help-command t))) (ac-define-quick-help-command ac-quick-help-scroll-down () (interactive) (when ac-quick-help (popup-scroll-down ac-quick-help))) (ac-define-quick-help-command ac-quick-help-scroll-up () (interactive) (when ac-quick-help (popup-scroll-up ac-quick-help))) ;;;; Auto completion isearch (defun ac-isearch-callback (list) (setq ac-dwim-enable (eq (length list) 1))) (defun ac-isearch () (interactive) (when (ac-menu-live-p) (ac-cancel-show-menu-timer) (ac-cancel-quick-help-timer) (ac-show-menu) (popup-isearch ac-menu :callback 'ac-isearch-callback))) ;;;; Auto completion commands (defun auto-complete (&optional sources) "Start auto-completion at current point." (interactive) (let ((menu-live (ac-menu-live-p)) (inline-live (ac-inline-live-p))) (ac-abort) (let ((ac-sources (or sources ac-sources))) (if (or ac-show-menu-immediately-on-auto-complete inline-live) (setq ac-show-menu t)) (ac-start)) (when (ac-update-greedy t) ;; TODO Not to cause inline completion to be disrupted. (if (ac-inline-live-p) (ac-inline-hide)) ;; Not to expand when it is first time to complete (when (and (or (and (not ac-expand-on-auto-complete) (> (length ac-candidates) 1) (not menu-live)) (not (let ((ac-common-part ac-whole-common-part)) (ac-expand-common)))) ac-use-fuzzy (null ac-candidates)) (ac-fuzzy-complete))))) (defun ac-fuzzy-complete () "Start fuzzy completion at current point." (interactive) (when (require 'fuzzy nil) (unless (ac-menu-live-p) (ac-start)) (let ((ac-match-function 'fuzzy-all-completions)) (unless ac-cursor-color (setq ac-cursor-color (frame-parameter (selected-frame) 'cursor-color))) (if ac-fuzzy-cursor-color (set-cursor-color ac-fuzzy-cursor-color)) (setq ac-show-menu t) (setq ac-fuzzy-enable t) (setq ac-triggered nil) (ac-update t))) t) (defun ac-next () "Select next candidate." (interactive) (when (ac-menu-live-p) (popup-next ac-menu) (setq ac-show-menu t) (if (eq this-command 'ac-next) (setq ac-dwim-enable t)))) (defun ac-previous () "Select previous candidate." (interactive) (when (ac-menu-live-p) (popup-previous ac-menu) (setq ac-show-menu t) (if (eq this-command 'ac-previous) (setq ac-dwim-enable t)))) (defun ac-expand () "Try expand, and if expanded twice, select next candidate." (interactive) (unless (ac-expand-common) (let ((string (ac-selected-candidate))) (when string (when (equal ac-prefix string) (ac-next) (setq string (ac-selected-candidate))) (ac-expand-string string (eq last-command this-command)) ;; Do reposition if menu at long line (if (and (> (popup-direction ac-menu) 0) (ac-menu-at-wrapper-line-p)) (ac-reposition)) (setq ac-show-menu t) string)))) (defun ac-expand-common () "Try to expand meaningful common part." (interactive) (if (and ac-dwim ac-dwim-enable) (ac-complete) (when (and (ac-inline-live-p) ac-common-part) (ac-inline-hide) (ac-expand-string ac-common-part (eq last-command this-command)) (setq ac-common-part nil) t))) (defun ac-complete () "Try complete." (interactive) (let* ((candidate (ac-selected-candidate)) (action (popup-item-property candidate 'action)) (fallback nil)) (when candidate (unless (ac-expand-string candidate) (setq fallback t)) ;; Remember to show help later (when (and ac-point candidate) (unless ac-last-completion (setq ac-last-completion (cons (make-marker) nil))) (set-marker (car ac-last-completion) ac-point ac-buffer) (setcdr ac-last-completion candidate))) (ac-abort) (cond (action (funcall action)) (fallback (ac-fallback-command))) candidate)) (defun* ac-start (&key requires force-init) "Start completion." (interactive) (if (not auto-complete-mode) (message "auto-complete-mode is not enabled") (let* ((info (ac-prefix requires ac-ignoring-prefix-def)) (prefix-def (nth 0 info)) (point (nth 1 info)) (sources (nth 2 info)) prefix (init (or force-init (not (eq ac-point point))))) (if (or (null point) (progn (setq prefix (buffer-substring-no-properties point (point))) (ac-stop-word-p prefix))) (prog1 nil (ac-abort)) (unless ac-cursor-color (setq ac-cursor-color (frame-parameter (selected-frame) 'cursor-color))) (setq ac-show-menu (or ac-show-menu (if (eq ac-auto-show-menu t) t)) ac-current-sources sources ac-buffer (current-buffer) ac-point point ac-prefix prefix ac-limit ac-candidate-limit ac-triggered t ac-current-prefix-def prefix-def) (when (or init (null ac-prefix-overlay)) (ac-init)) (ac-set-timer) (ac-set-show-menu-timer) (ac-set-quick-help-timer) (ac-put-prefix-overlay))))) (defun ac-stop () "Stop completiong." (interactive) (setq ac-selected-candidate nil) (ac-abort)) (defun ac-trigger-key-command (&optional force) (interactive "P") (if (or force (ac-trigger-command-p last-command)) (auto-complete) (ac-fallback-command 'ac-trigger-key-command))) ;;;; Basic cache facility (defvar ac-clear-variables-every-minute-timer nil) (defvar ac-clear-variables-after-save nil) (defvar ac-clear-variables-every-minute nil) (defvar ac-minutes-counter 0) (defun ac-clear-variable-after-save (variable &optional pred) (add-to-list 'ac-clear-variables-after-save (cons variable pred))) (defun ac-clear-variables-after-save () (dolist (pair ac-clear-variables-after-save) (if (or (null (cdr pair)) (funcall (cdr pair))) (set (car pair) nil)))) (defun ac-clear-variable-every-minutes (variable minutes) (add-to-list 'ac-clear-variables-every-minute (cons variable minutes))) (defun ac-clear-variable-every-minute (variable) (ac-clear-variable-every-minutes variable 1)) (defun ac-clear-variable-every-10-minutes (variable) (ac-clear-variable-every-minutes variable 10)) (defun ac-clear-variables-every-minute () (incf ac-minutes-counter) (dolist (pair ac-clear-variables-every-minute) (if (eq (% ac-minutes-counter (cdr pair)) 0) (set (car pair) nil)))) ;;;; Auto complete mode (defun ac-cursor-on-diable-face-p (&optional point) (memq (get-text-property (or point (point)) 'face) ac-disable-faces)) (defun ac-trigger-command-p (command) "Return non-nil if `COMMAND' is a trigger command." (and (symbolp command) (not (memq command ac-non-trigger-commands)) (or (memq command ac-trigger-commands) (string-match "self-insert-command" (symbol-name command)) (string-match "electric" (symbol-name command))))) (defun ac-fallback-command (&optional except-command) (let* ((auto-complete-mode nil) (keys (this-command-keys-vector)) (command (if keys (key-binding keys)))) (when (and (commandp command) (not (eq command except-command))) (setq this-command command) (call-interactively command)))) (defun ac-compatible-package-command-p (command) "Return non-nil if `COMMAND' is compatible with auto-complete." (and (symbolp command) (string-match ac-compatible-packages-regexp (symbol-name command)))) (defun ac-handle-pre-command () (condition-case var (if (or (setq ac-triggered (and (not ac-fuzzy-enable) ; ignore key storkes in fuzzy mode (or (eq this-command 'auto-complete) ; special case (ac-trigger-command-p this-command) (and ac-completing (memq this-command ac-trigger-commands-on-completing))) (not (ac-cursor-on-diable-face-p)))) (ac-compatible-package-command-p this-command)) (progn (if (or (not (symbolp this-command)) (not (get this-command 'ac-quick-help-command))) (ac-remove-quick-help)) ;; Not to cause inline completion to be disrupted. (ac-inline-hide)) (ac-abort)) (error (ac-error var)))) (defun ac-handle-post-command () (condition-case var (when (and ac-triggered (or ac-auto-start ac-completing) (not isearch-mode)) (setq ac-last-point (point)) (ac-start :requires (unless ac-completing ac-auto-start)) (ac-inline-update)) (error (ac-error var)))) (defun ac-setup () (if ac-trigger-key (ac-set-trigger-key ac-trigger-key)) (if ac-use-comphist (ac-comphist-init)) (unless ac-clear-variables-every-minute-timer (setq ac-clear-variables-every-minute-timer (run-with-timer 60 60 'ac-clear-variables-every-minute))) (if ac-stop-flymake-on-completing (defadvice flymake-on-timer-event (around ac-flymake-stop-advice activate) (unless ac-completing ad-do-it)) (ad-disable-advice 'flymake-on-timer-event 'around 'ac-flymake-stop-advice))) (define-minor-mode auto-complete-mode "AutoComplete mode" :lighter " AC" :keymap ac-mode-map :group 'auto-complete (if auto-complete-mode (progn (ac-setup) (add-hook 'pre-command-hook 'ac-handle-pre-command nil t) (add-hook 'post-command-hook 'ac-handle-post-command nil t) (add-hook 'after-save-hook 'ac-clear-variables-after-save nil t) (run-hooks 'auto-complete-mode-hook)) (remove-hook 'pre-command-hook 'ac-handle-pre-command t) (remove-hook 'post-command-hook 'ac-handle-post-command t) (remove-hook 'after-save-hook 'ac-clear-variables-after-save t) (ac-abort))) (defun auto-complete-mode-maybe () "What buffer `auto-complete-mode' prefers." (if (and (not (minibufferp (current-buffer))) (memq major-mode ac-modes)) (auto-complete-mode 1))) (define-global-minor-mode global-auto-complete-mode auto-complete-mode auto-complete-mode-maybe :group 'auto-complete) ;;;; Compatibilities with other extensions (defun ac-flyspell-workaround () "Flyspell uses `sit-for' for delaying its process. Unfortunatelly, it stops auto completion which is trigger with `run-with-idle-timer'. This workaround avoid flyspell processes when auto completion is being started." (interactive) (defadvice flyspell-post-command-hook (around ac-flyspell-workaround activate) (unless ac-triggered ad-do-it))) (defun ac-linum-workaround () "linum-mode tries to display the line numbers even for the completion menu. This workaround stops that annoying behavior." (interactive) (defadvice linum-update (around ac-linum-update-workaround activate) (unless ac-completing ad-do-it))) ;;;; Standard sources (defmacro ac-define-source (name source) "Source definition macro. It defines a complete command also." (declare (indent 1)) `(progn (defvar ,(intern (format "ac-source-%s" name)) ,source) (defun ,(intern (format "ac-complete-%s" name)) () (interactive) (auto-complete '(,(intern (format "ac-source-%s" name))))))) ;; Words in buffer source (defvar ac-word-index nil) (defun ac-candidate-words-in-buffer (point prefix limit) (let ((i 0) candidate candidates (regexp (concat "\\_<" (regexp-quote prefix) "\\(\\sw\\|\\s_\\)+\\_>"))) (save-excursion ;; Search backward (goto-char point) (while (and (or (not (integerp limit)) (< i limit)) (re-search-backward regexp nil t)) (setq candidate (match-string-no-properties 0)) (unless (member candidate candidates) (push candidate candidates) (incf i))) ;; Search backward (goto-char (+ point (length prefix))) (while (and (or (not (integerp limit)) (< i limit)) (re-search-forward regexp nil t)) (setq candidate (match-string-no-properties 0)) (unless (member candidate candidates) (push candidate candidates) (incf i))) (nreverse candidates)))) (defun ac-incremental-update-word-index () (unless (local-variable-p 'ac-word-index) (make-local-variable 'ac-word-index)) (if (null ac-word-index) (setq ac-word-index (cons nil nil))) ;; Mark incomplete (if (car ac-word-index) (setcar ac-word-index nil)) (let ((index (cdr ac-word-index)) (words (ac-candidate-words-in-buffer ac-point ac-prefix (or (and (integerp ac-limit) ac-limit) 10)))) (dolist (word words) (unless (member word index) (push word index) (setcdr ac-word-index index))))) (defun ac-update-word-index-1 () (unless (local-variable-p 'ac-word-index) (make-local-variable 'ac-word-index)) (when (and (not (car ac-word-index)) (< (buffer-size) 1048576)) ;; Complete index (setq ac-word-index (cons t (split-string (buffer-substring-no-properties (point-min) (point-max)) "\\(?:^\\|\\_>\\).*?\\(?:\\_<\\|$\\)"))))) (defun ac-update-word-index () (dolist (buffer (buffer-list)) (when (or ac-fuzzy-enable (not (eq buffer (current-buffer)))) (with-current-buffer buffer (ac-update-word-index-1))))) (defun ac-word-candidates (&optional buffer-pred) (loop initially (unless ac-fuzzy-enable (ac-incremental-update-word-index)) for buffer in (buffer-list) if (and (or (not (integerp ac-limit)) (< (length candidates) ac-limit)) (if buffer-pred (funcall buffer-pred buffer) t)) append (funcall ac-match-function ac-prefix (and (local-variable-p 'ac-word-index buffer) (cdr (buffer-local-value 'ac-word-index buffer)))) into candidates finally return candidates)) (ac-define-source words-in-buffer '((candidates . ac-word-candidates))) (ac-define-source words-in-all-buffer '((init . ac-update-word-index) (candidates . ac-word-candidates))) (ac-define-source words-in-same-mode-buffers '((init . ac-update-word-index) (candidates . (ac-word-candidates (lambda (buffer) (derived-mode-p (buffer-local-value 'major-mode buffer))))))) ;; Lisp symbols source (defvar ac-symbols-cache nil) (ac-clear-variable-every-10-minutes 'ac-symbols-cache) (defun ac-symbol-file (symbol type) (if (fboundp 'find-lisp-object-file-name) (find-lisp-object-file-name symbol type) (let ((file-name (with-no-warnings (describe-simplify-lib-file-name (symbol-file symbol type))))) (when (equal file-name "loaddefs.el") ;; Find the real def site of the preloaded object. (let ((location (condition-case nil (if (eq type 'defun) (find-function-search-for-symbol symbol nil "loaddefs.el") (find-variable-noselect symbol file-name)) (error nil)))) (when location (with-current-buffer (car location) (when (cdr location) (goto-char (cdr location))) (when (re-search-backward "^;;; Generated autoloads from \\(.*\\)" nil t) (setq file-name (match-string 1))))))) (if (and (null file-name) (or (eq type 'defun) (integerp (get symbol 'variable-documentation)))) ;; It's a object not defined in Elisp but in C. (if (get-buffer " *DOC*") (if (eq type 'defun) (help-C-file-name (symbol-function symbol) 'subr) (help-C-file-name symbol 'var)) 'C-source) file-name)))) (defun ac-symbol-documentation (symbol) (if (stringp symbol) (setq symbol (intern-soft symbol))) (ignore-errors (with-temp-buffer (let ((standard-output (current-buffer))) (prin1 symbol) (princ " is ") (cond ((fboundp symbol) ;; import help-xref-following (require 'help-mode) (let ((help-xref-following t)) (describe-function-1 symbol)) (buffer-string)) ((boundp symbol) (let ((file-name (ac-symbol-file symbol 'defvar))) (princ "a variable") (when file-name (princ " defined in `") (princ (if (eq file-name 'C-source) "C source code" (file-name-nondirectory file-name)))) (princ "'.\n\n") (princ (or (documentation-property symbol 'variable-documentation t) "Not documented.")) (buffer-string))) ((facep symbol) (let ((file-name (ac-symbol-file symbol 'defface))) (princ "a face") (when file-name (princ " defined in `") (princ (if (eq file-name 'C-source) "C source code" (file-name-nondirectory file-name)))) (princ "'.\n\n") (princ (or (documentation-property symbol 'face-documentation t) "Not documented.")) (buffer-string))) (t (let ((doc (documentation-property symbol 'group-documentation t))) (when doc (princ "a group.\n\n") (princ doc) (buffer-string))))))))) (defun ac-symbol-candidates () (or ac-symbols-cache (setq ac-symbols-cache (loop for x being the symbols if (or (fboundp x) (boundp x) (symbol-plist x)) collect (symbol-name x))))) (ac-define-source symbols '((candidates . ac-symbol-candidates) (document . ac-symbol-documentation) (symbol . "s") (cache))) ;; Lisp functions source (defvar ac-functions-cache nil) (ac-clear-variable-every-10-minutes 'ac-functions-cache) (defun ac-function-candidates () (or ac-functions-cache (setq ac-functions-cache (loop for x being the symbols if (fboundp x) collect (symbol-name x))))) (ac-define-source functions '((candidates . ac-function-candidates) (document . ac-symbol-documentation) (symbol . "f") (prefix . "(\\(\\(?:\\sw\\|\\s_\\)+\\)") (cache))) ;; Lisp variables source (defvar ac-variables-cache nil) (ac-clear-variable-every-10-minutes 'ac-variables-cache) (defun ac-variable-candidates () (or ac-variables-cache (setq ac-variables-cache (loop for x being the symbols if (boundp x) collect (symbol-name x))))) (ac-define-source variables '((candidates . ac-variable-candidates) (document . ac-symbol-documentation) (symbol . "v") (cache))) ;; Lisp features source (defvar ac-emacs-lisp-features nil) (ac-clear-variable-every-10-minutes 'ac-emacs-lisp-features) (defun ac-emacs-lisp-feature-candidates () (or ac-emacs-lisp-features (if (fboundp 'find-library-suffixes) (let ((suffix (concat (regexp-opt (find-library-suffixes) t) "\\'"))) (setq ac-emacs-lisp-features (append (mapcar 'prin1-to-string features) (loop for dir in load-path if (file-directory-p dir) append (loop for file in (directory-files dir) if (string-match suffix file) collect (substring file 0 (match-beginning 0)))))))))) (ac-define-source features '((depends find-func) (candidates . ac-emacs-lisp-feature-candidates) (prefix . "require +'\\(\\(?:\\sw\\|\\s_\\)*\\)") (requires . 0))) (defvaralias 'ac-source-emacs-lisp-features 'ac-source-features) ;; Abbrev source (ac-define-source abbrev '((candidates . (mapcar 'popup-x-to-string (append (vconcat local-abbrev-table global-abbrev-table) nil))) (action . expand-abbrev) (symbol . "a") (cache))) ;; Files in current directory source (ac-define-source files-in-current-dir '((candidates . (directory-files default-directory)) (cache))) ;; Filename source (defvar ac-filename-cache nil) (defun ac-filename-candidate () (unless (file-regular-p ac-prefix) (ignore-errors (loop with dir = (file-name-directory ac-prefix) with files = (or (assoc-default dir ac-filename-cache) (let ((files (directory-files dir nil "^[^.]"))) (push (cons dir files) ac-filename-cache) files)) for file in files for path = (concat dir file) collect (if (file-directory-p path) (concat path "/") path))))) (ac-define-source filename '((init . (setq ac-filename-cache nil)) (candidates . ac-filename-candidate) (prefix . valid-file) (requires . 0) (action . ac-start) (limit . nil))) ;; Dictionary source (ac-define-source dictionary '((candidates . ac-buffer-dictionary) (symbol . "d"))) (provide 'auto-complete) ;;; auto-complete.el ends here